morpho-contracts-helper 0.0.2 → 0.0.4

package/contracts/DComp.sol

@@ -0,0 +1,137 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.27;
+
+import {
+    Ownable,
+    Ownable2Step
+} from "@openzeppelin/contracts/access/Ownable2Step.sol";
+import {ERC20} from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
+import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+import {ERC20Wrapper} from "@openzeppelin/contracts/token/ERC20/extensions/ERC20Wrapper.sol";
+import {IComp} from "./vendor/@compound-finance/compound-governance/contracts/interfaces/IComp.sol";
+
+/// @title dCOMP
+/// @author API3 DAO
+/// @notice 1:1 wrapper token for COMP built on OpenZeppelin ERC20Wrapper
+contract DComp is ERC20Wrapper, Ownable2Step {
+    address internal constant COMP_ADDRESS =
+        0xc00e94Cb662C3520282E6f5717214004A7f26888;
+    IComp internal immutable comp = IComp(COMP_ADDRESS);
+
+    /// @notice Tracks which addresses are allowed to deposit COMP.
+    /// @dev Withdrawals are never restricted by this whitelist, including when dCOMP is transferred,
+    /// when a depositor is later removed from the whitelist, or when COMP is deposited for another address via `depositFor`.
+    mapping(address => bool) public isDepositorWhitelisted;
+
+    /// @notice Emitted when an address whitelist status changes
+    /// @param account Address whose whitelist status changed
+    /// @param isWhitelisted New whitelist status
+    event DepositorWhitelistStatusUpdated(
+        address indexed account,
+        bool isWhitelisted
+    );
+
+    modifier onlyWhitelisted() {
+        require(
+            isDepositorWhitelisted[msg.sender],
+            "Caller is not whitelisted"
+        );
+        _;
+    }
+
+    /// @notice Constructs the dCOMP wrapper
+    /// @param initialOwner Address of the initial owner
+    /// @param initialDelegatee Address of the initial delegatee for COMP voting power
+    /// @param whitelistedDepositors Initial addresses allowed to deposit COMP
+    constructor(
+        address initialOwner,
+        address initialDelegatee,
+        address[] memory whitelistedDepositors
+    )
+        ERC20("dCOMP", "dCOMP")
+        ERC20Wrapper(IERC20(COMP_ADDRESS))
+        Ownable(initialOwner)
+    {
+        _setDelegatee(initialDelegatee);
+
+        for (uint256 i = 0; i < whitelistedDepositors.length; ++i) {
+            _setDepositorWhitelistStatus(whitelistedDepositors[i], true);
+        }
+    }
+
+    /// @notice Returns the current COMP delegatee for voting power held by this wrapper
+    /// @return delegateeAddress Current delegatee address
+    function delegatee() external view returns (address) {
+        return comp.delegates(address(this));
+    }
+
+    /// @notice Wraps COMP tokens into dCOMP for a specific recipient at a 1:1 ratio
+    /// @param account Recipient of newly minted dCOMP
+    /// @param value Amount of COMP to deposit
+    /// @return success Whether wrapping succeeded
+    function depositFor(
+        address account,
+        uint256 value
+    ) public override onlyWhitelisted returns (bool) {
+        return super.depositFor(account, value);
+    }
+
+    /// @notice Wraps COMP tokens for the caller at a 1:1 ratio
+    /// @param value Amount of COMP to deposit
+    /// @return success Whether wrapping succeeded
+    function deposit(uint256 value) external onlyWhitelisted returns (bool) {
+        return depositFor(msg.sender, value);
+    }
+
+    /// @notice Unwraps dCOMP tokens for the caller at a 1:1 ratio
+    /// @param value Amount of dCOMP to burn and withdraw as COMP
+    /// @return success Whether unwrapping succeeded
+    function withdraw(uint256 value) external returns (bool) {
+        return withdrawTo(msg.sender, value);
+    }
+
+    /// @notice Updates depositor whitelist
+    /// @param addresses Addresses whose whitelist status will be updated
+    /// @param isAddressWhitelisted New whitelist status for each corresponding address
+    function updateWhitelistedDepositors(
+        address[] calldata addresses,
+        bool[] calldata isAddressWhitelisted
+    ) external onlyOwner {
+        require(
+            addresses.length == isAddressWhitelisted.length,
+            "Mismatched array lengths"
+        );
+
+        for (uint256 i = 0; i < addresses.length; ++i) {
+            _setDepositorWhitelistStatus(addresses[i], isAddressWhitelisted[i]);
+        }
+    }
+
+    /// @notice Allows the owner to change who receives the aggregated voting power
+    /// @param newDelegatee The new address to receive the COMP voting power
+    function setDelegatee(address newDelegatee) external onlyOwner {
+        _setDelegatee(newDelegatee);
+    }
+
+    /// @notice Updates whitelist status for a depositor
+    /// @param account Address whose whitelist status is being updated
+    /// @param isWhitelisted New whitelist status for the address
+    function _setDepositorWhitelistStatus(
+        address account,
+        bool isWhitelisted
+    ) internal {
+        require(
+            isDepositorWhitelisted[account] != isWhitelisted,
+            "No change in whitelist status"
+        );
+
+        isDepositorWhitelisted[account] = isWhitelisted;
+        emit DepositorWhitelistStatusUpdated(account, isWhitelisted);
+    }
+
+    /// @notice Updates delegated voting power recipient for COMP held by this wrapper
+    /// @param newDelegatee New delegatee address
+    function _setDelegatee(address newDelegatee) internal {
+        comp.delegate(newDelegatee);
+    }
+}

package/contracts/external/Multicall3.sol

@@ -0,0 +1,216 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.12;
+
+/// @title Multicall3
+/// @notice Aggregate results from multiple function calls
+/// @dev Multicall & Multicall2 backwards-compatible
+/// @dev Aggregate methods are marked `payable` to save 24 gas per call
+/// @author Michael Elliot <mike@makerdao.com>
+/// @author Joshua Levine <joshua@makerdao.com>
+/// @author Nick Johnson <arachnid@notdot.net>
+/// @author Andreas Bigger <andreas@nascent.xyz>
+/// @author Matt Solomon <matt@mattsolomon.dev>
+contract Multicall3 {
+    struct Call {
+        address target;
+        bytes callData;
+    }
+
+    struct Call3 {
+        address target;
+        bool allowFailure;
+        bytes callData;
+    }
+
+    struct Call3Value {
+        address target;
+        bool allowFailure;
+        uint256 value;
+        bytes callData;
+    }
+
+    struct Result {
+        bool success;
+        bytes returnData;
+    }
+
+    /// @notice Backwards-compatible call aggregation with Multicall
+    /// @param calls An array of Call structs
+    /// @return blockNumber The block number where the calls were executed
+    /// @return returnData An array of bytes containing the responses
+    function aggregate(Call[] calldata calls) public payable returns (uint256 blockNumber, bytes[] memory returnData) {
+        blockNumber = block.number;
+        uint256 length = calls.length;
+        returnData = new bytes[](length);
+        Call calldata call;
+        for (uint256 i = 0; i < length;) {
+            bool success;
+            call = calls[i];
+            (success, returnData[i]) = call.target.call(call.callData);
+            require(success, "Multicall3: call failed");
+            unchecked { ++i; }
+        }
+    }
+
+    /// @notice Backwards-compatible with Multicall2
+    /// @notice Aggregate calls without requiring success
+    /// @param requireSuccess If true, require all calls to succeed
+    /// @param calls An array of Call structs
+    /// @return returnData An array of Result structs
+    function tryAggregate(bool requireSuccess, Call[] calldata calls) public payable returns (Result[] memory returnData) {
+        uint256 length = calls.length;
+        returnData = new Result[](length);
+        Call calldata call;
+        for (uint256 i = 0; i < length;) {
+            Result memory result = returnData[i];
+            call = calls[i];
+            (result.success, result.returnData) = call.target.call(call.callData);
+            if (requireSuccess) require(result.success, "Multicall3: call failed");
+            unchecked { ++i; }
+        }
+    }
+
+    /// @notice Backwards-compatible with Multicall2
+    /// @notice Aggregate calls and allow failures using tryAggregate
+    /// @param calls An array of Call structs
+    /// @return blockNumber The block number where the calls were executed
+    /// @return blockHash The hash of the block where the calls were executed
+    /// @return returnData An array of Result structs
+    function tryBlockAndAggregate(bool requireSuccess, Call[] calldata calls) public payable returns (uint256 blockNumber, bytes32 blockHash, Result[] memory returnData) {
+        blockNumber = block.number;
+        blockHash = blockhash(block.number);
+        returnData = tryAggregate(requireSuccess, calls);
+    }
+
+    /// @notice Backwards-compatible with Multicall2
+    /// @notice Aggregate calls and allow failures using tryAggregate
+    /// @param calls An array of Call structs
+    /// @return blockNumber The block number where the calls were executed
+    /// @return blockHash The hash of the block where the calls were executed
+    /// @return returnData An array of Result structs
+    function blockAndAggregate(Call[] calldata calls) public payable returns (uint256 blockNumber, bytes32 blockHash, Result[] memory returnData) {
+        (blockNumber, blockHash, returnData) = tryBlockAndAggregate(true, calls);
+    }
+
+    /// @notice Aggregate calls, ensuring each returns success if required
+    /// @param calls An array of Call3 structs
+    /// @return returnData An array of Result structs
+    function aggregate3(Call3[] calldata calls) public payable returns (Result[] memory returnData) {
+        uint256 length = calls.length;
+        returnData = new Result[](length);
+        Call3 calldata calli;
+        for (uint256 i = 0; i < length;) {
+            Result memory result = returnData[i];
+            calli = calls[i];
+            (result.success, result.returnData) = calli.target.call(calli.callData);
+            assembly {
+                // Revert if the call fails and failure is not allowed
+                // `allowFailure := calldataload(add(calli, 0x20))` and `success := mload(result)`
+                if iszero(or(calldataload(add(calli, 0x20)), mload(result))) {
+                    // set "Error(string)" signature: bytes32(bytes4(keccak256("Error(string)")))
+                    mstore(0x00, 0x08c379a000000000000000000000000000000000000000000000000000000000)
+                    // set data offset
+                    mstore(0x04, 0x0000000000000000000000000000000000000000000000000000000000000020)
+                    // set length of revert string
+                    mstore(0x24, 0x0000000000000000000000000000000000000000000000000000000000000017)
+                    // set revert string: bytes32(abi.encodePacked("Multicall3: call failed"))
+                    mstore(0x44, 0x4d756c746963616c6c333a2063616c6c206661696c6564000000000000000000)
+                    revert(0x00, 0x64)
+                }
+            }
+            unchecked { ++i; }
+        }
+    }
+
+    /// @notice Aggregate calls with a msg value
+    /// @notice Reverts if msg.value is less than the sum of the call values
+    /// @param calls An array of Call3Value structs
+    /// @return returnData An array of Result structs
+    function aggregate3Value(Call3Value[] calldata calls) public payable returns (Result[] memory returnData) {
+        uint256 valAccumulator;
+        uint256 length = calls.length;
+        returnData = new Result[](length);
+        Call3Value calldata calli;
+        for (uint256 i = 0; i < length;) {
+            Result memory result = returnData[i];
+            calli = calls[i];
+            uint256 val = calli.value;
+            // Humanity will be a Type V Kardashev Civilization before this overflows - andreas
+            // ~ 10^25 Wei in existence << ~ 10^76 size uint fits in a uint256
+            unchecked { valAccumulator += val; }
+            (result.success, result.returnData) = calli.target.call{value: val}(calli.callData);
+            assembly {
+                // Revert if the call fails and failure is not allowed
+                // `allowFailure := calldataload(add(calli, 0x20))` and `success := mload(result)`
+                if iszero(or(calldataload(add(calli, 0x20)), mload(result))) {
+                    // set "Error(string)" signature: bytes32(bytes4(keccak256("Error(string)")))
+                    mstore(0x00, 0x08c379a000000000000000000000000000000000000000000000000000000000)
+                    // set data offset
+                    mstore(0x04, 0x0000000000000000000000000000000000000000000000000000000000000020)
+                    // set length of revert string
+                    mstore(0x24, 0x0000000000000000000000000000000000000000000000000000000000000017)
+                    // set revert string: bytes32(abi.encodePacked("Multicall3: call failed"))
+                    mstore(0x44, 0x4d756c746963616c6c333a2063616c6c206661696c6564000000000000000000)
+                    revert(0x00, 0x84)
+                }
+            }
+            unchecked { ++i; }
+        }
+        // Finally, make sure the msg.value = SUM(call[0...i].value)
+        require(msg.value == valAccumulator, "Multicall3: value mismatch");
+    }
+
+    /// @notice Returns the block hash for the given block number
+    /// @param blockNumber The block number
+    function getBlockHash(uint256 blockNumber) public view returns (bytes32 blockHash) {
+        blockHash = blockhash(blockNumber);
+    }
+
+    /// @notice Returns the block number
+    function getBlockNumber() public view returns (uint256 blockNumber) {
+        blockNumber = block.number;
+    }
+
+    /// @notice Returns the block coinbase
+    function getCurrentBlockCoinbase() public view returns (address coinbase) {
+        coinbase = block.coinbase;
+    }
+
+    /// @notice Returns the block difficulty
+    function getCurrentBlockDifficulty() public view returns (uint256 difficulty) {
+        difficulty = block.difficulty;
+    }
+
+    /// @notice Returns the block gas limit
+    function getCurrentBlockGasLimit() public view returns (uint256 gaslimit) {
+        gaslimit = block.gaslimit;
+    }
+
+    /// @notice Returns the block timestamp
+    function getCurrentBlockTimestamp() public view returns (uint256 timestamp) {
+        timestamp = block.timestamp;
+    }
+
+    /// @notice Returns the (ETH) balance of a given address
+    function getEthBalance(address addr) public view returns (uint256 balance) {
+        balance = addr.balance;
+    }
+
+    /// @notice Returns the block hash of the last block
+    function getLastBlockHash() public view returns (bytes32 blockHash) {
+        unchecked {
+            blockHash = blockhash(block.number - 1);
+        }
+    }
+
+    /// @notice Gets the base fee of the given block
+    /// @notice Can revert if the BASEFEE opcode is not implemented by the given chain
+    function getBasefee() public view returns (uint256 basefee) {
+        basefee = block.basefee;
+    }
+
+    /// @notice Returns the chain id
+    function getChainId() public view returns (uint256 chainid) {
+        chainid = block.chainid;
+    }
+}

package/contracts/vendor/@compound-finance/compound-governance/contracts/Comp.sol

@@ -0,0 +1,301 @@
+// SPDX-License-Identifier: BSD-3-Clause
+pragma solidity ^0.8.10;
+
+contract Comp {
+    /// @notice EIP-20 token name for this token
+    string public constant name = "Compound";
+
+    /// @notice EIP-20 token symbol for this token
+    string public constant symbol = "COMP";
+
+    /// @notice EIP-20 token decimals for this token
+    uint8 public constant decimals = 18;
+
+    /// @notice Total number of tokens in circulation
+    uint public constant totalSupply = 10000000e18; // 10 million Comp
+
+    /// @notice Allowance amounts on behalf of others
+    mapping (address => mapping (address => uint96)) internal allowances;
+
+    /// @notice Official record of token balances for each account
+    mapping (address => uint96) internal balances;
+
+    /// @notice A record of each accounts delegate
+    mapping (address => address) public delegates;
+
+    /// @notice A checkpoint for marking number of votes from a given block
+    struct Checkpoint {
+        uint32 fromBlock;
+        uint96 votes;
+    }
+
+    /// @notice A record of votes checkpoints for each account, by index
+    mapping (address => mapping (uint32 => Checkpoint)) public checkpoints;
+
+    /// @notice The number of checkpoints for each account
+    mapping (address => uint32) public numCheckpoints;
+
+    /// @notice The EIP-712 typehash for the contract's domain
+    bytes32 public constant DOMAIN_TYPEHASH = keccak256("EIP712Domain(string name,uint256 chainId,address verifyingContract)");
+
+    /// @notice The EIP-712 typehash for the delegation struct used by the contract
+    bytes32 public constant DELEGATION_TYPEHASH = keccak256("Delegation(address delegatee,uint256 nonce,uint256 expiry)");
+
+    /// @notice A record of states for signing / validating signatures
+    mapping (address => uint) public nonces;
+
+    /// @notice An event thats emitted when an account changes its delegate
+    event DelegateChanged(address indexed delegator, address indexed fromDelegate, address indexed toDelegate);
+
+    /// @notice An event thats emitted when a delegate account's vote balance changes
+    event DelegateVotesChanged(address indexed delegate, uint previousBalance, uint newBalance);
+
+    /// @notice The standard EIP-20 transfer event
+    event Transfer(address indexed from, address indexed to, uint256 amount);
+
+    /// @notice The standard EIP-20 approval event
+    event Approval(address indexed owner, address indexed spender, uint256 amount);
+
+    /**
+     * @notice Construct a new Comp token
+     * @param account The initial account to grant all the tokens
+     */
+    constructor(address account) {
+        balances[account] = uint96(totalSupply);
+        emit Transfer(address(0), account, totalSupply);
+    }
+
+    /**
+     * @notice Get the number of tokens `spender` is approved to spend on behalf of `account`
+     * @param account The address of the account holding the funds
+     * @param spender The address of the account spending the funds
+     * @return The number of tokens approved
+     */
+    function allowance(address account, address spender) external view returns (uint) {
+        return allowances[account][spender];
+    }
+
+    /**
+     * @notice Approve `spender` to transfer up to `amount` from `src`
+     * @dev This will overwrite the approval amount for `spender`
+     *  and is subject to issues noted [here](https://eips.ethereum.org/EIPS/eip-20#approve)
+     * @param spender The address of the account which may transfer tokens
+     * @param rawAmount The number of tokens that are approved (2^256-1 means infinite)
+     * @return Whether or not the approval succeeded
+     */
+    function approve(address spender, uint rawAmount) external returns (bool) {
+        uint96 amount;
+        if (rawAmount == type(uint).max) {
+            amount = type(uint96).max;
+        } else {
+            amount = safe96(rawAmount, "Comp::approve: amount exceeds 96 bits");
+        }
+
+        allowances[msg.sender][spender] = amount;
+
+        emit Approval(msg.sender, spender, amount);
+        return true;
+    }
+
+    /**
+     * @notice Get the number of tokens held by the `account`
+     * @param account The address of the account to get the balance of
+     * @return The number of tokens held
+     */
+    function balanceOf(address account) external view returns (uint) {
+        return balances[account];
+    }
+
+    /**
+     * @notice Transfer `amount` tokens from `msg.sender` to `dst`
+     * @param dst The address of the destination account
+     * @param rawAmount The number of tokens to transfer
+     * @return Whether or not the transfer succeeded
+     */
+    function transfer(address dst, uint rawAmount) external returns (bool) {
+        uint96 amount = safe96(rawAmount, "Comp::transfer: amount exceeds 96 bits");
+        _transferTokens(msg.sender, dst, amount);
+        return true;
+    }
+
+    /**
+     * @notice Transfer `amount` tokens from `src` to `dst`
+     * @param src The address of the source account
+     * @param dst The address of the destination account
+     * @param rawAmount The number of tokens to transfer
+     * @return Whether or not the transfer succeeded
+     */
+    function transferFrom(address src, address dst, uint rawAmount) external returns (bool) {
+        address spender = msg.sender;
+        uint96 spenderAllowance = allowances[src][spender];
+        uint96 amount = safe96(rawAmount, "Comp::approve: amount exceeds 96 bits");
+
+        if (spender != src && spenderAllowance != type(uint96).max) {
+            uint96 newAllowance = sub96(spenderAllowance, amount, "Comp::transferFrom: transfer amount exceeds spender allowance");
+            allowances[src][spender] = newAllowance;
+
+            emit Approval(src, spender, newAllowance);
+        }
+
+        _transferTokens(src, dst, amount);
+        return true;
+    }
+
+    /**
+     * @notice Delegate votes from `msg.sender` to `delegatee`
+     * @param delegatee The address to delegate votes to
+     */
+    function delegate(address delegatee) public {
+        return _delegate(msg.sender, delegatee);
+    }
+
+    /**
+     * @notice Delegates votes from signatory to `delegatee`
+     * @param delegatee The address to delegate votes to
+     * @param nonce The contract state required to match the signature
+     * @param expiry The time at which to expire the signature
+     * @param v The recovery byte of the signature
+     * @param r Half of the ECDSA signature pair
+     * @param s Half of the ECDSA signature pair
+     */
+    function delegateBySig(address delegatee, uint nonce, uint expiry, uint8 v, bytes32 r, bytes32 s) public {
+        bytes32 domainSeparator = keccak256(abi.encode(DOMAIN_TYPEHASH, keccak256(bytes(name)), getChainId(), address(this)));
+        bytes32 structHash = keccak256(abi.encode(DELEGATION_TYPEHASH, delegatee, nonce, expiry));
+        bytes32 digest = keccak256(abi.encodePacked("\x19\x01", domainSeparator, structHash));
+        address signatory = ecrecover(digest, v, r, s);
+        require(signatory != address(0), "Comp::delegateBySig: invalid signature");
+        require(nonce == nonces[signatory]++, "Comp::delegateBySig: invalid nonce");
+        require(block.timestamp <= expiry, "Comp::delegateBySig: signature expired");
+        return _delegate(signatory, delegatee);
+    }
+
+    /**
+     * @notice Gets the current votes balance for `account`
+     * @param account The address to get votes balance
+     * @return The number of current votes for `account`
+     */
+    function getCurrentVotes(address account) external view returns (uint96) {
+        uint32 nCheckpoints = numCheckpoints[account];
+        return nCheckpoints > 0 ? checkpoints[account][nCheckpoints - 1].votes : 0;
+    }
+
+    /**
+     * @notice Determine the prior number of votes for an account as of a block number
+     * @dev Block number must be a finalized block or else this function will revert to prevent misinformation.
+     * @param account The address of the account to check
+     * @param blockNumber The block number to get the vote balance at
+     * @return The number of votes the account had as of the given block
+     */
+    function getPriorVotes(address account, uint blockNumber) public view returns (uint96) {
+        require(blockNumber < block.number, "Comp::getPriorVotes: not yet determined");
+
+        uint32 nCheckpoints = numCheckpoints[account];
+        if (nCheckpoints == 0) {
+            return 0;
+        }
+
+        // First check most recent balance
+        if (checkpoints[account][nCheckpoints - 1].fromBlock <= blockNumber) {
+            return checkpoints[account][nCheckpoints - 1].votes;
+        }
+
+        // Next check implicit zero balance
+        if (checkpoints[account][0].fromBlock > blockNumber) {
+            return 0;
+        }
+
+        uint32 lower = 0;
+        uint32 upper = nCheckpoints - 1;
+        while (upper > lower) {
+            uint32 center = upper - (upper - lower) / 2; // ceil, avoiding overflow
+            Checkpoint memory cp = checkpoints[account][center];
+            if (cp.fromBlock == blockNumber) {
+                return cp.votes;
+            } else if (cp.fromBlock < blockNumber) {
+                lower = center;
+            } else {
+                upper = center - 1;
+            }
+        }
+        return checkpoints[account][lower].votes;
+    }
+
+    function _delegate(address delegator, address delegatee) internal {
+        address currentDelegate = delegates[delegator];
+        uint96 delegatorBalance = balances[delegator];
+        delegates[delegator] = delegatee;
+
+        emit DelegateChanged(delegator, currentDelegate, delegatee);
+
+        _moveDelegates(currentDelegate, delegatee, delegatorBalance);
+    }
+
+    function _transferTokens(address src, address dst, uint96 amount) internal {
+        require(src != address(0), "Comp::_transferTokens: cannot transfer from the zero address");
+        require(dst != address(0), "Comp::_transferTokens: cannot transfer to the zero address");
+
+        balances[src] = sub96(balances[src], amount, "Comp::_transferTokens: transfer amount exceeds balance");
+        balances[dst] = add96(balances[dst], amount, "Comp::_transferTokens: transfer amount overflows");
+        emit Transfer(src, dst, amount);
+
+        _moveDelegates(delegates[src], delegates[dst], amount);
+    }
+
+    function _moveDelegates(address srcRep, address dstRep, uint96 amount) internal {
+        if (srcRep != dstRep && amount > 0) {
+            if (srcRep != address(0)) {
+                uint32 srcRepNum = numCheckpoints[srcRep];
+                uint96 srcRepOld = srcRepNum > 0 ? checkpoints[srcRep][srcRepNum - 1].votes : 0;
+                uint96 srcRepNew = sub96(srcRepOld, amount, "Comp::_moveVotes: vote amount underflows");
+                _writeCheckpoint(srcRep, srcRepNum, srcRepOld, srcRepNew);
+            }
+
+            if (dstRep != address(0)) {
+                uint32 dstRepNum = numCheckpoints[dstRep];
+                uint96 dstRepOld = dstRepNum > 0 ? checkpoints[dstRep][dstRepNum - 1].votes : 0;
+                uint96 dstRepNew = add96(dstRepOld, amount, "Comp::_moveVotes: vote amount overflows");
+                _writeCheckpoint(dstRep, dstRepNum, dstRepOld, dstRepNew);
+            }
+        }
+    }
+
+    function _writeCheckpoint(address delegatee, uint32 nCheckpoints, uint96 oldVotes, uint96 newVotes) internal {
+      uint32 blockNumber = safe32(block.number, "Comp::_writeCheckpoint: block number exceeds 32 bits");
+
+      if (nCheckpoints > 0 && checkpoints[delegatee][nCheckpoints - 1].fromBlock == blockNumber) {
+          checkpoints[delegatee][nCheckpoints - 1].votes = newVotes;
+      } else {
+          checkpoints[delegatee][nCheckpoints] = Checkpoint(blockNumber, newVotes);
+          numCheckpoints[delegatee] = nCheckpoints + 1;
+      }
+
+      emit DelegateVotesChanged(delegatee, oldVotes, newVotes);
+    }
+
+    function safe32(uint n, string memory errorMessage) internal pure returns (uint32) {
+        require(n < 2**32, errorMessage);
+        return uint32(n);
+    }
+
+    function safe96(uint n, string memory errorMessage) internal pure returns (uint96) {
+        require(n < 2**96, errorMessage);
+        return uint96(n);
+    }
+
+    function add96(uint96 a, uint96 b, string memory errorMessage) internal pure returns (uint96) {
+        uint96 c = a + b;
+        require(c >= a, errorMessage);
+        return c;
+    }
+
+    function sub96(uint96 a, uint96 b, string memory errorMessage) internal pure returns (uint96) {
+        require(b <= a, errorMessage);
+        return a - b;
+    }
+
+    function getChainId() internal view returns (uint) {
+        uint256 chainId;
+        assembly { chainId := chainid() }
+        return chainId;
+    }
+}

package/contracts/vendor/@compound-finance/compound-governance/contracts/interfaces/IComp.sol

@@ -0,0 +1,34 @@
+// SPDX-License-Identifier: BSD-3-Clause
+pragma solidity ^0.8.26;
+
+interface IComp {
+    struct Checkpoint {
+        uint32 fromBlock;
+        uint96 votes;
+    }
+
+    event Approval(address indexed owner, address indexed spender, uint256 amount);
+    event DelegateChanged(address indexed delegator, address indexed fromDelegate, address indexed toDelegate);
+    event DelegateVotesChanged(address indexed delegate, uint256 previousBalance, uint256 newBalance);
+    event Transfer(address indexed from, address indexed to, uint256 amount);
+
+    function DELEGATION_TYPEHASH() external view returns (bytes32);
+    function DOMAIN_TYPEHASH() external view returns (bytes32);
+    function allowance(address account, address spender) external view returns (uint256);
+    function approve(address spender, uint256 rawAmount) external returns (bool);
+    function balanceOf(address account) external view returns (uint256);
+    function checkpoints(address, uint32) external view returns (uint32 fromBlock, uint96 votes);
+    function decimals() external view returns (uint8);
+    function delegate(address delegatee) external;
+    function delegateBySig(address delegatee, uint256 nonce, uint256 expiry, uint8 v, bytes32 r, bytes32 s) external;
+    function delegates(address) external view returns (address);
+    function getCurrentVotes(address account) external view returns (uint96);
+    function getPriorVotes(address account, uint256 blockNumber) external view returns (uint96);
+    function name() external view returns (string memory);
+    function nonces(address) external view returns (uint256);
+    function numCheckpoints(address) external view returns (uint32);
+    function symbol() external view returns (string memory);
+    function totalSupply() external view returns (uint256);
+    function transfer(address dst, uint256 rawAmount) external returns (bool);
+    function transferFrom(address src, address dst, uint256 rawAmount) external returns (bool);
+}