Introduction

The Compound protocol is governed and upgraded by COMP token-holders, using three distinct components; the COMP token, governance module (Governor Bravo), and Timelock. Together, these contracts allow the community to propose, vote, and implement changes through the administrative functions of a cToken or the Comptroller. Proposals can modify system parameters, support new markets, or add entirely new functionality to the protocol.

COMP token-holders can delegate their voting rights to themselves, or an address of their choice. Addresses delegated at least 25,000 COMP can create governance proposals; any address can lock 100 COMP to create an Autonomous Proposal, which becomes a governance proposal after being delegated 25,000 COMP.

When a governance proposal is created, it enters a 2 day review period, after which voting weights are recorded and voting begins. Voting lasts for 3 days; if a majority, and at least 400,000 votes are cast for the proposal, it is queued in the Timelock, and can be implemented 2 days later. In total, any change to the protocol takes at least one week.

COMP

COMP is an ERC-20 token that allows the owner to delegate voting rights to any address, including their own address. Changes to the owner’s token balance automatically adjust the voting rights of the delegate.

Delegate

Delegate votes from the sender to the delegatee. Users can delegate to 1 address at a time, and the number of votes added to the delegatee’s vote count is equivalent to the balance of COMP in the user’s account. Votes are delegated from the current block and onward, until the sender delegates again, or transfers their COMP.

COMP

function delegate(address delegatee)

Solidity

Comp comp = Comp(0x123...); // contract address
comp.delegate(delegateeAddress);

Web3 1.2.6

const tx = await comp.methods.delegate(delegateeAddress).send({ from: sender });

Delegate By Signature

Delegate votes from the signatory to the delegatee. This method has the same purpose as Delegate but it instead enables offline signatures to participate in Compound governance vote delegation. For more details on how to create an offline signature, review EIP-712.

COMP

function delegateBySig(address delegatee, uint nonce, uint expiry, uint8 v, bytes32 r, bytes32 s)

Solidity

Comp comp = Comp(0x123...); // contract address
comp.delegateBySig(delegateeAddress, nonce, expiry, v, r, s);

Web3 1.2.6

const tx = await comp.methods.delegateBySig(delegateeAddress, nonce, expiry, v, r, s).send({});

Get Current Votes

Gets the balance of votes for an account as of the current block.

COMP

function getCurrentVotes(address account) returns (uint96)

Solidity

Comp comp = Comp(0x123...); // contract address
uint votes = comp.getCurrentVotes(0xabc...);

Web3 1.2.6

const account = '0x123...'; // contract address
const votes = await comp.methods.getCurrentVotes(account).call();

Get Prior Votes

Gets the prior number of votes for an account at a specific block number. The block number passed must be a finalized block or the function will revert.

COMP

function getPriorVotes(address account, uint blockNumber) returns (uint96)

Solidity

Comp comp = Comp(0x123...); // contract address
uint priorVotes = comp.getPriorVotes(account, blockNumber);

Web3 1.2.6

const priorVotes = await comp.methods.getPriorVotes(account, blockNumber).call();

Key Events

Governor Bravo

Governor Bravo is the governance module of the protocol; it allows addresses with more than 25,000 COMP to propose changes to the protocol. Addresses that held voting weight, at the start of the proposal, invoked through the getpriorvotes function, can submit their votes during a 3 day voting period. If a majority, and at least 400,000 votes are cast for the proposal, it is queued in the Timelock, and can be implemented after 2 days.

Quorum Votes

The required minimum number of votes in support of a proposal for it to succeed.

Governor Bravo

function quorumVotes() public pure returns (uint)

Solidity

GovernorBravo gov = GovernorBravo(0x123...); // contract address
uint quorum = gov.quorumVotes();

Web3 1.2.6

const quorum = await gov.methods.quorumVotes().call();

Proposal Threshold

The minimum number of votes required for an account to create a proposal. This can be changed through governance.

Governor Bravo

function proposalThreshold() returns (uint)

Solidity

GovernorBravo gov = GovernorBravo(0x123...); // contract address
uint threshold = gov.proposalThreshold();

Web3 1.2.6

const threshold = await gov.methods.proposalThreshold().call();

Proposal Max Operations

The maximum number of actions that can be included in a proposal. Actions are functions calls that will be made when a proposal succeeds and executes.

Governor Bravo

function proposalMaxOperations() returns (uint)

Solidity

GovernorBravo gov = GovernorBravo(0x123...); // contract address
uint operations = gov.proposalMaxOperations();

Web3 1.2.6

const operations = await gov.methods.proposalMaxOperations().call();

Voting Delay

The number of Ethereum blocks to wait before voting on a proposal may begin. This value is added to the current block number when a proposal is created. This can be changed through governance.

Governor Bravo

function votingDelay() returns (uint)

Solidity

GovernorBravo gov = GovernorBravo(0x123...); // contract address
uint blocks = gov.votingDelay();

Web3 1.2.6

const blocks = await gov.methods.votingDelay().call();

Voting Period

The duration of voting on a proposal, in Ethereum blocks. This can be changed through governance.

Governor Bravo

function votingPeriod() returns (uint)

Solidity

GovernorBravo gov = GovernorBravo(0x123...); // contract address
uint blocks = gov.votingPeriod();

Web3 1.2.6

const blocks = await gov.methods.votingPeriod().call();

Propose

Create a Proposal to change the protocol. E.g., A proposal can set a cToken's interest rate model or risk parameters on the Comptroller.

Proposals will be voted on by delegated voters. If there is sufficient support before the voting period ends, the proposal shall be automatically enacted. Enacted proposals are queued and executed in the Compound Timelock contract.

The sender must hold more COMP than the current proposal threshold (proposalThreshold()) as of the immediately previous block. If the threshold is 25,000 COMP, the sender must have been delegated more than 1% of all COMP in order to create a proposal. The proposal can have up to 10 actions (based on proposalMaxOperations()).

The proposer cannot create another proposal if they currently have a pending or active proposal. It is not possible to queue two identical actions in the same block (due to a restriction in the Timelock), therefore actions in a single proposal must be unique, and unique proposals that share an identical action must be queued in different blocks.

Governor Bravo

function propose(address[] memory targets, uint[] memory values, string[] memory signatures, bytes[] memory calldatas, string memory description) returns (uint)

Solidity

GovernorBravo gov = GovernorBravo(0x123...); // contract address
uint proposalId = gov.propose(targets, values, signatures, calldatas, description);

Web3 1.2.6

const tx = gov.methods.propose(targets, values, signatures, calldatas, description).send({ from: sender });

Queue

After a proposal has succeeded, it is moved into the Timelock waiting period using this function. The waiting period (e.g. 2 days) begins when this function is called.

The queue function can be called by any Ethereum address.

Governor Bravo

function queue(uint proposalId)

Solidity

GovernorBravo gov = GovernorBravo(0x123...); // contract address
gov.queue(proposalId);

Web3 1.2.6

const tx = gov.methods.queue(proposalId).send({ from: sender });

Execute

After the Timelock waiting period has elapsed, a proposal can be executed using this function, which applies the proposal changes to the target contracts. This will invoke each of the actions described in the proposal.

The execute function can be called by any Ethereum address.

Note: this function is payable, so the Timelock contract can invoke payable functions that were selected in the proposal.

Governor Bravo

function execute(uint proposalId) payable

Solidity

GovernorBravo gov = GovernorBravo(0x123...); // contract address
gov.execute(proposalId).value(999).gas(999)();

Web3 1.2.6

const tx = gov.methods.execute(proposalId).send({ from: sender, value: 1 });

Cancel

A proposal is eligible to be cancelled at any time prior to its execution, including while queued in the Timelock, using this function.

The cancel function can be called by the proposal creator, or any Ethereum address, if the proposal creator fails to maintain more delegated votes than the proposal threshold (e.g. 25,000).

Governor Bravo

function cancel(uint proposalId)

Solidity

GovernorBravo gov = GovernorBravo(0x123...); // contract address
gov.cancel(proposalId);

Web3 1.2.6

const tx = gov.methods.cancel(proposalId).send({ from: sender });

Get Actions

Gets the actions of a selected proposal. Pass a proposal ID and get the targets, values, signatures and calldatas of that proposal.

Governor Bravo

function getActions(uint proposalId) returns (uint proposalId) public view returns (address[] memory targets, uint[] memory values, string[] memory signatures, bytes[] memory calldatas)

1. Array of addresses of contracts the proposal calls.
2. Array of unsigned integers the proposal uses as values.
3. Array of strings of the proposal’s signatures.
4. Array of calldata bytes of the proposal.

Solidity

GovernorBravo gov = GovernorBravo(0x123...); // contract address
uint proposalId = 123;
(address[] memory targets, uint[] memory values, string[] memory signatures, bytes[] memory calldatas) = gov.getActions(proposalId);

Web3 1.2.6

const {0: targets, 1: values, 2: signatures, 3: calldatas} = gov.methods.getActions(proposalId).call();

Get Receipt

Gets a proposal ballot receipt of the indicated voter.

Governor Bravo

function getReceipt(uint proposalId, address voter) returns (Receipt memory)

Solidity

GovernorBravo gov = GovernorBravo(0x123...); // contract address
Receipt ballot = gov.getReceipt(proposalId, voterAddress);

Web3 1.2.6

const proposalId = 11;
const voterAddress = '0x123...';
const result = await gov.methods.getReceipt(proposalId, voterAddress).call();
const { hasVoted, support, votes } = result;

State

Gets the proposal state for the specified proposal. The return value, ProposalState is an enumerated type defined in the Governor Bravo contract.

Governor Bravo

function state(uint proposalId) returns (ProposalState)

Solidity

GovernorBravo gov = GovernorBravo(0x123...); // contract address
GovernorBravo.ProposalState state = gov.state(123);

Web3 1.2.6

const proposalStates = ['Pending', 'Active', 'Canceled', 'Defeated', 'Succeeded', 'Queued', 'Expired', 'Executed'];
const proposalId = 123;
result = await gov.methods.state(proposalId).call();
const proposalState = proposalStates[result];

Cast Vote

Cast a vote on a proposal. The account's voting weight is determined by the number of votes the account had delegated to it at the time the proposal state became active.

Governor Bravo

function castVote(uint proposalId, uint8 support)

Solidity

GovernorBravo gov = GovernorBravo(0x123...); // contract address
gov.castVote(proposalId, 1);

Web3 1.2.6

const tx = gov.methods.castVote(proposalId, 0).send({ from: sender });

Cast Vote

Cast a vote on a proposal with a reason attached to the vote.

Governor Bravo

function castVoteWithReason(uint proposalId, uint8 support, string calldata reason)

Solidity

GovernorBravo gov = GovernorBravo(0x123...); // contract address
gov.castVoteWithReason(proposalId, 2, "I think...");

Web3 1.2.6

const tx = gov.methods.castVoteWithReason(proposalId, 0, "I think...").send({ from: sender });

Cast Vote By Signature

Cast a vote on a proposal. The account's voting weight is determined by the number of votes the account had delegated at the time that proposal state became active. This method has the same purpose as Cast Vote but it instead enables offline signatures to participate in Compound governance voting. For more details on how to create an offline signature, review EIP-712.

Governor Bravo

function castVoteBySig(uint proposalId, uint8 support, uint8 v, bytes32 r, bytes32 s)

Solidity

GovernorBravo gov = GovernorBravo(0x123...); // contract address
gov.castVoteBySig(proposalId, 0, v, r, s);

Web3 1.2.6

const tx = await gov.methods.castVoteBySig(proposalId, 1, v, r, s).send({});

Timelock

Each protocol contract is controlled by the Timelock contract, which can modify system parameters, logic, and contracts in a 'time-delayed, opt-out' upgrade pattern. The Timelock has a hard-coded minimum delay of 2 days, which is the least amount of notice possible for a governance action.

The Timelock contract queues and executes proposals that have passed a Governance vote.

Pause Guardian

The Comptroller contract designates a Pause Guardian address capable of disabling protocol functionality. Used only in the event of an unforeseen vulnerability, the Pause Guardian has one and only one ability: to disable a select set of functions: Mint, Borrow, Transfer, and Liquidate. The Pause Guardian cannot unpause an action, nor can it ever prevent users from calling Redeem, or Repay Borrow to close positions and exit the protocol.

COMP token-holders designate the Pause Guardian address, which is held by the Community Multi-Sig.