텍스트 비교

두 텍스트 파일의 차이점을 찾아보세요

실시간 편집

변경 없는 행 숨기기

줄바꿈 비활성화

레이아웃

비교 단위

구문 강조

Diffchecker Desktop 가장 안전하게 Diffchecker를 사용하는 방법. 데스크톱 앱을 사용하면 비교 데이터가 외부로 전송되지 않습니다!데스크톱 앱 받기

Uniswap Changes

생성일 5년 전비교 결과 만료 없음

12 삭제

행
총
삭제

글자
총
삭제

이 기능을 계속 사용하려면 업그레이드해 주세요 Diffchecker Pro 요금제 보기

315 행

12 추가

행
총
추가

글자
총
추가

이 기능을 계속 사용하려면 업그레이드해 주세요 Diffchecker Pro 요금제 보기

311 행

/**

*Submitted for verification at Etherscan.io on 2020-09-16

/**

*Submitted for verification at Etherscan.io on 2020-09-15

*Submitted for verification at Etherscan.io on 2021-05-31

pragma solidity ^0.5.16;

pragma experimental ABIEncoderV2;

// Even fish can make waves.

contract GovernorAlpha {

/// @notice The name of this contract

string public constant name = "Uniswap Governor Alpha";

/// @notice The number of votes in support of a proposal required in order for a quorum to be reached and for a vote to succeed

function quorumVotes() public pure returns (uint) { return 40_000_000e18; } // 4% of Uni

/// @notice The number of votes required in order for a voter to become a proposer

function proposalThreshold() public pure returns (uint) { return 10_000_000e18; } // 1% of Uni

function proposalThreshold() public pure returns (uint) { return 2_500_000e18; } // 0.25% of Uni

/// @notice The maximum number of actions that can be included in a proposal

function proposalMaxOperations() public pure returns (uint) { return 10; } // 10 actions

/// @notice The delay before voting on a proposal may take place, once proposed

function votingDelay() public pure returns (uint) { return 1; } // 1 block

/// @notice The duration of voting on a proposal, in blocks

function votingPeriod() public pure returns (uint) { return 40_320; } // ~7 days in blocks (assuming 15s blocks)

/// @notice The address of the Uniswap Protocol Timelock

TimelockInterface public timelock;

TimelockInterface public constant timelock = TimelockInterface(0x1a9C8182C09F50C8318d769245beA52c32BE35BC);

/// @notice The address of the Uniswap governance token

UniInterface public uni;

UniInterface public constant uni = UniInterface(0x1f9840a85d5aF5bf1D1762F925BDADdC4201F984);

/// @notice The total number of proposals

uint public proposalCount;

struct Proposal {

/// @notice Unique id for looking up a proposal

uint id;

/// @notice Creator of the proposal

address proposer;

/// @notice The timestamp that the proposal will be available for execution, set once the vote succeeds

uint eta;

/// @notice the ordered list of target addresses for calls to be made

address[] targets;

/// @notice The ordered list of values (i.e. msg.value) to be passed to the calls to be made

uint[] values;

/// @notice The ordered list of function signatures to be called

string[] signatures;

/// @notice The ordered list of calldata to be passed to each call

bytes[] calldatas;

/// @notice The block at which voting begins: holders must delegate their votes prior to this block

uint startBlock;

/// @notice The block at which voting ends: votes must be cast prior to this block

uint endBlock;

/// @notice Current number of votes in favor of this proposal

uint forVotes;

/// @notice Current number of votes in opposition to this proposal

uint againstVotes;

/// @notice Flag marking whether the proposal has been canceled

bool canceled;

/// @notice Flag marking whether the proposal has been executed

bool executed;

/// @notice Receipts of ballots for the entire set of voters

mapping (address => Receipt) receipts;

}

/// @notice Ballot receipt record for a voter

struct Receipt {

/// @notice Whether or not a vote has been cast

bool hasVoted;

/// @notice Whether or not the voter supports the proposal

bool support;

/// @notice The number of votes the voter had, which were cast

uint96 votes;

}

/// @notice Possible states that a proposal may be in

enum ProposalState {

Pending,

Active,

Canceled,

Defeated,

Succeeded,

Queued,

Expired,

Executed

}

/// @notice The official record of all proposals ever proposed

mapping (uint => Proposal) public proposals;

/// @notice The latest proposal for each proposer

mapping (address => uint) public latestProposalIds;

/// @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 ballot struct used by the contract

bytes32 public constant BALLOT_TYPEHASH = keccak256("Ballot(uint256 proposalId,bool support)");

/// @notice An event emitted when a new proposal is created

event ProposalCreated(uint id, address proposer, address[] targets, uint[] values, string[] signatures, bytes[] calldatas, uint startBlock, uint endBlock, string description);

/// @notice An event emitted when a vote has been cast on a proposal

event VoteCast(address voter, uint proposalId, bool support, uint votes);

/// @notice An event emitted when a proposal has been canceled

event ProposalCanceled(uint id);

/// @notice An event emitted when a proposal has been queued in the Timelock

event ProposalQueued(uint id, uint eta);

/// @notice An event emitted when a proposal has been executed in the Timelock

event ProposalExecuted(uint id);

constructor(address timelock_, address uni_) public {

timelock = TimelockInterface(timelock_);

uni = UniInterface(uni_);

}

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

require(uni.getPriorVotes(msg.sender, sub256(block.number, 1)) > proposalThreshold(), "GovernorAlpha::propose: proposer votes below proposal threshold");

require(targets.length == values.length && targets.length == signatures.length && targets.length == calldatas.length, "GovernorAlpha::propose: proposal function information arity mismatch");

require(targets.length != 0, "GovernorAlpha::propose: must provide actions");

require(targets.length <= proposalMaxOperations(), "GovernorAlpha::propose: too many actions");

uint latestProposalId = latestProposalIds[msg.sender];

if (latestProposalId != 0) {

ProposalState proposersLatestProposalState = state(latestProposalId);

require(proposersLatestProposalState != ProposalState.Active, "GovernorAlpha::propose: one live proposal per proposer, found an already active proposal");

require(proposersLatestProposalState != ProposalState.Pending, "GovernorAlpha::propose: one live proposal per proposer, found an already pending proposal");

}

uint startBlock = add256(block.number, votingDelay());

uint endBlock = add256(startBlock, votingPeriod());

proposalCount++;

Proposal memory newProposal = Proposal({

id: proposalCount,

proposer: msg.sender,

eta: 0,

targets: targets,

values: values,

signatures: signatures,

calldatas: calldatas,

startBlock: startBlock,

endBlock: endBlock,

forVotes: 0,

againstVotes: 0,

canceled: false,

executed: false

});

proposals[newProposal.id] = newProposal;

latestProposalIds[newProposal.proposer] = newProposal.id;

emit ProposalCreated(newProposal.id, msg.sender, targets, values, signatures, calldatas, startBlock, endBlock, description);

return newProposal.id;

}

function queue(uint proposalId) public {

require(state(proposalId) == ProposalState.Succeeded, "GovernorAlpha::queue: proposal can only be queued if it is succeeded");

Proposal storage proposal = proposals[proposalId];

uint eta = add256(block.timestamp, timelock.delay());

for (uint i = 0; i < proposal.targets.length; i++) {

_queueOrRevert(proposal.targets[i], proposal.values[i], proposal.signatures[i], proposal.calldatas[i], eta);

}

proposal.eta = eta;

emit ProposalQueued(proposalId, eta);

}

function _queueOrRevert(address target, uint value, string memory signature, bytes memory data, uint eta) internal {

require(!timelock.queuedTransactions(keccak256(abi.encode(target, value, signature, data, eta))), "GovernorAlpha::_queueOrRevert: proposal action already queued at eta");

timelock.queueTransaction(target, value, signature, data, eta);

}

function execute(uint proposalId) public payable {

require(state(proposalId) == ProposalState.Queued, "GovernorAlpha::execute: proposal can only be executed if it is queued");

Proposal storage proposal = proposals[proposalId];

proposal.executed = true;

for (uint i = 0; i < proposal.targets.length; i++) {

timelock.executeTransaction.value(proposal.values[i])(proposal.targets[i], proposal.values[i], proposal.signatures[i], proposal.calldatas[i], proposal.eta);

}

emit ProposalExecuted(proposalId);

}

function cancel(uint proposalId) public {

ProposalState state = state(proposalId);

require(state != ProposalState.Executed, "GovernorAlpha::cancel: cannot cancel executed proposal");

Proposal storage proposal = proposals[proposalId];

require(uni.getPriorVotes(proposal.proposer, sub256(block.number, 1)) < proposalThreshold(), "GovernorAlpha::cancel: proposer above threshold");

proposal.canceled = true;

for (uint i = 0; i < proposal.targets.length; i++) {

timelock.cancelTransaction(proposal.targets[i], proposal.values[i], proposal.signatures[i], proposal.calldatas[i], proposal.eta);

}

emit ProposalCanceled(proposalId);

}

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

Proposal storage p = proposals[proposalId];

return (p.targets, p.values, p.signatures, p.calldatas);

}

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

return proposals[proposalId].receipts[voter];

}

function state(uint proposalId) public view returns (ProposalState) {

require(proposalCount >= proposalId && proposalId > 0, "GovernorAlpha::state: invalid proposal id");

Proposal storage proposal = proposals[proposalId];

if (proposal.canceled) {

return ProposalState.Canceled;

} else if (block.number <= proposal.startBlock) {

return ProposalState.Pending;

} else if (block.number <= proposal.endBlock) {

return ProposalState.Active;

} else if (proposal.forVotes <= proposal.againstVotes || proposal.forVotes < quorumVotes()) {

return ProposalState.Defeated;

} else if (proposal.eta == 0) {

return ProposalState.Succeeded;

} else if (proposal.executed) {

return ProposalState.Executed;

} else if (block.timestamp >= add256(proposal.eta, timelock.GRACE_PERIOD())) {

return ProposalState.Expired;

} else {

return ProposalState.Queued;

}

function castVote(uint proposalId, bool support) public {

return _castVote(msg.sender, proposalId, support);

}

function castVoteBySig(uint proposalId, bool support, 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(BALLOT_TYPEHASH, proposalId, support));

bytes32 digest = keccak256(abi.encodePacked("\x19\x01", domainSeparator, structHash));

address signatory = ecrecover(digest, v, r, s);

require(signatory != address(0), "GovernorAlpha::castVoteBySig: invalid signature");

return _castVote(signatory, proposalId, support);

}

function __acceptAdmin() public {

timelock.acceptAdmin();

}

function _castVote(address voter, uint proposalId, bool support) internal {

require(state(proposalId) == ProposalState.Active, "GovernorAlpha::_castVote: voting is closed");

Proposal storage proposal = proposals[proposalId];

Receipt storage receipt = proposal.receipts[voter];

require(receipt.hasVoted == false, "GovernorAlpha::_castVote: voter already voted");

uint96 votes = uni.getPriorVotes(voter, proposal.startBlock);

if (support) {

proposal.forVotes = add256(proposal.forVotes, votes);

} else {

proposal.againstVotes = add256(proposal.againstVotes, votes);

}

receipt.hasVoted = true;

receipt.support = support;

receipt.votes = votes;

emit VoteCast(voter, proposalId, support, votes);

}

function add256(uint256 a, uint256 b) internal pure returns (uint) {

uint c = a + b;

require(c >= a, "addition overflow");

return c;

}

function sub256(uint256 a, uint256 b) internal pure returns (uint) {

require(b <= a, "subtraction underflow");

return a - b;

}

function getChainId() internal pure returns (uint) {

uint chainId;

assembly { chainId := chainid() }

return chainId;

}

interface TimelockInterface {

function delay() external view returns (uint);

function GRACE_PERIOD() external view returns (uint);

function acceptAdmin() external;

function queuedTransactions(bytes32 hash) external view returns (bool);

function queueTransaction(address target, uint value, string calldata signature, bytes calldata data, uint eta) external returns (bytes32);

function cancelTransaction(address target, uint value, string calldata signature, bytes calldata data, uint eta) external;

function executeTransaction(address target, uint value, string calldata signature, bytes calldata data, uint eta) external payable returns (bytes memory);

}

interface UniInterface {

function getPriorVotes(address account, uint blockNumber) external view returns (uint96);

}

저장된 비교 결과

원본

파일 열기

/**
 *Submitted for verification at Etherscan.io on 2020-09-16
*/

/**
 *Submitted for verification at Etherscan.io on 2020-09-15
*/

pragma solidity ^0.5.16;
pragma experimental ABIEncoderV2;

contract GovernorAlpha {
    /// @notice The name of this contract
    string public constant name = "Uniswap Governor Alpha";

/// @notice The number of votes in support of a proposal required in order for a quorum to be reached and for a vote to succeed
    function quorumVotes() public pure returns (uint) { return 40_000_000e18; } // 4% of Uni

/// @notice The number of votes required in order for a voter to become a proposer
    function proposalThreshold() public pure returns (uint) { return 10_000_000e18; } // 1% of Uni

/// @notice The maximum number of actions that can be included in a proposal
    function proposalMaxOperations() public pure returns (uint) { return 10; } // 10 actions

/// @notice The delay before voting on a proposal may take place, once proposed
    function votingDelay() public pure returns (uint) { return 1; } // 1 block

/// @notice The duration of voting on a proposal, in blocks
    function votingPeriod() public pure returns (uint) { return 40_320; } // ~7 days in blocks (assuming 15s blocks)

/// @notice The address of the Uniswap Protocol Timelock
    TimelockInterface public timelock;

/// @notice The address of the Uniswap governance token
    UniInterface public uni;

/// @notice The total number of proposals
    uint public proposalCount;

struct Proposal {
        /// @notice Unique id for looking up a proposal
        uint id;

/// @notice Creator of the proposal
        address proposer;

/// @notice The timestamp that the proposal will be available for execution, set once the vote succeeds
        uint eta;

/// @notice the ordered list of target addresses for calls to be made
        address[] targets;

/// @notice The ordered list of values (i.e. msg.value) to be passed to the calls to be made
        uint[] values;

/// @notice The ordered list of function signatures to be called
        string[] signatures;

/// @notice The ordered list of calldata to be passed to each call
        bytes[] calldatas;

/// @notice The block at which voting begins: holders must delegate their votes prior to this block
        uint startBlock;

/// @notice The block at which voting ends: votes must be cast prior to this block
        uint endBlock;

/// @notice Current number of votes in favor of this proposal
        uint forVotes;

/// @notice Current number of votes in opposition to this proposal
        uint againstVotes;

/// @notice Flag marking whether the proposal has been canceled
        bool canceled;

/// @notice Flag marking whether the proposal has been executed
        bool executed;

/// @notice Receipts of ballots for the entire set of voters
        mapping (address => Receipt) receipts;
    }

/// @notice Ballot receipt record for a voter
    struct Receipt {
        /// @notice Whether or not a vote has been cast
        bool hasVoted;

/// @notice Whether or not the voter supports the proposal
        bool support;

/// @notice The number of votes the voter had, which were cast
        uint96 votes;
    }

/// @notice Possible states that a proposal may be in
    enum ProposalState {
        Pending,
        Active,
        Canceled,
        Defeated,
        Succeeded,
        Queued,
        Expired,
        Executed
    }

/// @notice The official record of all proposals ever proposed
    mapping (uint => Proposal) public proposals;

/// @notice The latest proposal for each proposer
    mapping (address => uint) public latestProposalIds;

/// @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 ballot struct used by the contract
    bytes32 public constant BALLOT_TYPEHASH = keccak256("Ballot(uint256 proposalId,bool support)");

/// @notice An event emitted when a new proposal is created
    event ProposalCreated(uint id, address proposer, address[] targets, uint[] values, string[] signatures, bytes[] calldatas, uint startBlock, uint endBlock, string description);

/// @notice An event emitted when a vote has been cast on a proposal
    event VoteCast(address voter, uint proposalId, bool support, uint votes);

/// @notice An event emitted when a proposal has been canceled
    event ProposalCanceled(uint id);

/// @notice An event emitted when a proposal has been queued in the Timelock
    event ProposalQueued(uint id, uint eta);

/// @notice An event emitted when a proposal has been executed in the Timelock
    event ProposalExecuted(uint id);

constructor(address timelock_, address uni_) public {
        timelock = TimelockInterface(timelock_);
        uni = UniInterface(uni_);
    }

function propose(address[] memory targets, uint[] memory values, string[] memory signatures, bytes[] memory calldatas, string memory description) public returns (uint) {
        require(uni.getPriorVotes(msg.sender, sub256(block.number, 1)) > proposalThreshold(), "GovernorAlpha::propose: proposer votes below proposal threshold");
        require(targets.length == values.length && targets.length == signatures.length && targets.length == calldatas.length, "GovernorAlpha::propose: proposal function information arity mismatch");
        require(targets.length != 0, "GovernorAlpha::propose: must provide actions");
        require(targets.length <= proposalMaxOperations(), "GovernorAlpha::propose: too many actions");

uint latestProposalId = latestProposalIds[msg.sender];
        if (latestProposalId != 0) {
          ProposalState proposersLatestProposalState = state(latestProposalId);
          require(proposersLatestProposalState != ProposalState.Active, "GovernorAlpha::propose: one live proposal per proposer, found an already active proposal");
          require(proposersLatestProposalState != ProposalState.Pending, "GovernorAlpha::propose: one live proposal per proposer, found an already pending proposal");
        }

uint startBlock = add256(block.number, votingDelay());
        uint endBlock = add256(startBlock, votingPeriod());

proposalCount++;
        Proposal memory newProposal = Proposal({
            id: proposalCount,
            proposer: msg.sender,
            eta: 0,
            targets: targets,
            values: values,
            signatures: signatures,
            calldatas: calldatas,
            startBlock: startBlock,
            endBlock: endBlock,
            forVotes: 0,
            againstVotes: 0,
            canceled: false,
            executed: false
        });

proposals[newProposal.id] = newProposal;
        latestProposalIds[newProposal.proposer] = newProposal.id;

emit ProposalCreated(newProposal.id, msg.sender, targets, values, signatures, calldatas, startBlock, endBlock, description);
        return newProposal.id;
    }

function queue(uint proposalId) public {
        require(state(proposalId) == ProposalState.Succeeded, "GovernorAlpha::queue: proposal can only be queued if it is succeeded");
        Proposal storage proposal = proposals[proposalId];
        uint eta = add256(block.timestamp, timelock.delay());
        for (uint i = 0; i < proposal.targets.length; i++) {
            _queueOrRevert(proposal.targets[i], proposal.values[i], proposal.signatures[i], proposal.calldatas[i], eta);
        }
        proposal.eta = eta;
        emit ProposalQueued(proposalId, eta);
    }

function _queueOrRevert(address target, uint value, string memory signature, bytes memory data, uint eta) internal {
        require(!timelock.queuedTransactions(keccak256(abi.encode(target, value, signature, data, eta))), "GovernorAlpha::_queueOrRevert: proposal action already queued at eta");
        timelock.queueTransaction(target, value, signature, data, eta);
    }

function execute(uint proposalId) public payable {
        require(state(proposalId) == ProposalState.Queued, "GovernorAlpha::execute: proposal can only be executed if it is queued");
        Proposal storage proposal = proposals[proposalId];
        proposal.executed = true;
        for (uint i = 0; i < proposal.targets.length; i++) {
            timelock.executeTransaction.value(proposal.values[i])(proposal.targets[i], proposal.values[i], proposal.signatures[i], proposal.calldatas[i], proposal.eta);
        }
        emit ProposalExecuted(proposalId);
    }

function cancel(uint proposalId) public {
        ProposalState state = state(proposalId);
        require(state != ProposalState.Executed, "GovernorAlpha::cancel: cannot cancel executed proposal");

Proposal storage proposal = proposals[proposalId];
        require(uni.getPriorVotes(proposal.proposer, sub256(block.number, 1)) < proposalThreshold(), "GovernorAlpha::cancel: proposer above threshold");

proposal.canceled = true;
        for (uint i = 0; i < proposal.targets.length; i++) {
            timelock.cancelTransaction(proposal.targets[i], proposal.values[i], proposal.signatures[i], proposal.calldatas[i], proposal.eta);
        }

emit ProposalCanceled(proposalId);
    }

function getActions(uint proposalId) public view returns (address[] memory targets, uint[] memory values, string[] memory signatures, bytes[] memory calldatas) {
        Proposal storage p = proposals[proposalId];
        return (p.targets, p.values, p.signatures, p.calldatas);
    }

function getReceipt(uint proposalId, address voter) public view returns (Receipt memory) {
        return proposals[proposalId].receipts[voter];
    }

function castVote(uint proposalId, bool support) public {
        return _castVote(msg.sender, proposalId, support);
    }

function castVoteBySig(uint proposalId, bool support, 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(BALLOT_TYPEHASH, proposalId, support));
        bytes32 digest = keccak256(abi.encodePacked("\x19\x01", domainSeparator, structHash));
        address signatory = ecrecover(digest, v, r, s);
        require(signatory != address(0), "GovernorAlpha::castVoteBySig: invalid signature");
        return _castVote(signatory, proposalId, support);
    }

function _castVote(address voter, uint proposalId, bool support) internal {
        require(state(proposalId) == ProposalState.Active, "GovernorAlpha::_castVote: voting is closed");
        Proposal storage proposal = proposals[proposalId];
        Receipt storage receipt = proposal.receipts[voter];
        require(receipt.hasVoted == false, "GovernorAlpha::_castVote: voter already voted");
        uint96 votes = uni.getPriorVotes(voter, proposal.startBlock);

if (support) {
            proposal.forVotes = add256(proposal.forVotes, votes);
        } else {
            proposal.againstVotes = add256(proposal.againstVotes, votes);
        }

receipt.hasVoted = true;
        receipt.support = support;
        receipt.votes = votes;

emit VoteCast(voter, proposalId, support, votes);
    }

function add256(uint256 a, uint256 b) internal pure returns (uint) {
        uint c = a + b;
        require(c >= a, "addition overflow");
        return c;
    }

function sub256(uint256 a, uint256 b) internal pure returns (uint) {
        require(b <= a, "subtraction underflow");
        return a - b;
    }

function getChainId() internal pure returns (uint) {
        uint chainId;
        assembly { chainId := chainid() }
        return chainId;
    }
}

interface TimelockInterface {
    function delay() external view returns (uint);
    function GRACE_PERIOD() external view returns (uint);
    function acceptAdmin() external;
    function queuedTransactions(bytes32 hash) external view returns (bool);
    function queueTransaction(address target, uint value, string calldata signature, bytes calldata data, uint eta) external returns (bytes32);
    function cancelTransaction(address target, uint value, string calldata signature, bytes calldata data, uint eta) external;
    function executeTransaction(address target, uint value, string calldata signature, bytes calldata data, uint eta) external payable returns (bytes memory);
}

interface UniInterface {
    function getPriorVotes(address account, uint blockNumber) external view returns (uint96);
}

수정본

파일 열기

/**
 *Submitted for verification at Etherscan.io on 2021-05-31
*/

pragma solidity ^0.5.16;
pragma experimental ABIEncoderV2;

// Even fish can make waves.
contract GovernorAlpha {
    /// @notice The name of this contract
    string public constant name = "Uniswap Governor Alpha";

/// @notice The number of votes required in order for a voter to become a proposer
    function proposalThreshold() public pure returns (uint) { return 2_500_000e18; } // 0.25% of Uni

/// @notice The maximum number of actions that can be included in a proposal
    function proposalMaxOperations() public pure returns (uint) { return 10; } // 10 actions

/// @notice The delay before voting on a proposal may take place, once proposed
    function votingDelay() public pure returns (uint) { return 1; } // 1 block

/// @notice The duration of voting on a proposal, in blocks
    function votingPeriod() public pure returns (uint) { return 40_320; } // ~7 days in blocks (assuming 15s blocks)

/// @notice The address of the Uniswap Protocol Timelock
    TimelockInterface public constant timelock = TimelockInterface(0x1a9C8182C09F50C8318d769245beA52c32BE35BC);

/// @notice The address of the Uniswap governance token
    UniInterface public constant uni = UniInterface(0x1f9840a85d5aF5bf1D1762F925BDADdC4201F984);