eth以太坊sushi合约源码开发

- 日理万妓 2022-12-06 12:40 296阅读 0赞

以太坊或波场sushiy合约源码开发

1：官网：https://sushiswap.org/

2：部分合约源码浏览

  1. pragma solidity 0.6.12;
  4. import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
  5. import "@openzeppelin/contracts/access/Ownable.sol";
  8. // SushiToken with Governance.
  9. contract SushiToken is ERC20("SushiToken", "SUSHI"), Ownable {
  10.     /// @notice Creates `_amount` token to `_to`. Must only be called by the owner (MasterChef).
  11.     function mint(address _to, uint256 _amount) public onlyOwner {
  12.         _mint(_to, _amount);
  13.         _moveDelegates(address(0), _delegates[_to], _amount);
  14.     }
  16.     // Copied and modified from YAM code:
  17.     // https://github.com/yam-finance/yam-protocol/blob/master/contracts/token/YAMGovernanceStorage.sol
  18.     // https://github.com/yam-finance/yam-protocol/blob/master/contracts/token/YAMGovernance.sol
  19.     // Which is copied and modified from COMPOUND:
  20.     // https://github.com/compound-finance/compound-protocol/blob/master/contracts/Governance/Comp.sol
  22.     /// @notice A record of each accounts delegate
  23.     mapping (address => address) internal _delegates;
  25.     /// @notice A checkpoint for marking number of votes from a given block
  26.     struct Checkpoint {
  27.         uint32 fromBlock;
  28.         uint256 votes;
  29.     }
  31.     /// @notice A record of votes checkpoints for each account, by index
  32.     mapping (address => mapping (uint32 => Checkpoint)) public checkpoints;
  34.     /// @notice The number of checkpoints for each account
  35.     mapping (address => uint32) public numCheckpoints;
  37.     /// @notice The EIP-712 typehash for the contract's domain
  38.     bytes32 public constant DOMAIN_TYPEHASH = keccak256("EIP712Domain(string name,uint256 chainId,address verifyingContract)");
  40.     /// @notice The EIP-712 typehash for the delegation struct used by the contract
  41.     bytes32 public constant DELEGATION_TYPEHASH = keccak256("Delegation(address delegatee,uint256 nonce,uint256 expiry)");
  43.     /// @notice A record of states for signing / validating signatures
  44.     mapping (address => uint) public nonces;
  46.       /// @notice An event thats emitted when an account changes its delegate
  47.     event DelegateChanged(address indexed delegator, address indexed fromDelegate, address indexed toDelegate);
  49.     /// @notice An event thats emitted when a delegate account's vote balance changes
  50.     event DelegateVotesChanged(address indexed delegate, uint previousBalance, uint newBalance);
  52.     /**
  53.      * @notice Delegate votes from `msg.sender` to `delegatee`
  54.      * @param delegator The address to get delegatee for
  55.      */
  56.     function delegates(address delegator)
  57.         external
  58.         view
  59.         returns (address)
  60.     {
  61.         return _delegates[delegator];
  62.     }
  64.    /**
  65.     * @notice Delegate votes from `msg.sender` to `delegatee`
  66.     * @param delegatee The address to delegate votes to
  67.     */
  68.     function delegate(address delegatee) external {
  69.         return _delegate(msg.sender, delegatee);
  70.     }
  72.     /**
  73.      * @notice Delegates votes from signatory to `delegatee`
  74.      * @param delegatee The address to delegate votes to
  75.      * @param nonce The contract state required to match the signature
  76.      * @param expiry The time at which to expire the signature
  77.      * @param v The recovery byte of the signature
  78.      * @param r Half of the ECDSA signature pair
  79.      * @param s Half of the ECDSA signature pair
  80.      */
  81.     function delegateBySig(
  82.         address delegatee,
  83.         uint nonce,
  84.         uint expiry,
  85.         uint8 v,
  86.         bytes32 r,
  87.         bytes32 s
  88.     )
  89.         external
  90.     {
  91.         bytes32 domainSeparator = keccak256(
  92.             abi.encode(
  93.                 DOMAIN_TYPEHASH,
  94.                 keccak256(bytes(name())),
  95.                 getChainId(),
  96.                 address(this)
  97.             )
  98.         );
  100.         bytes32 structHash = keccak256(
  101.             abi.encode(
  102.                 DELEGATION_TYPEHASH,
  103.                 delegatee,
  104.                 nonce,
  105.                 expiry
  106.             )
  107.         );
  109.         bytes32 digest = keccak256(
  110.             abi.encodePacked(
  111.                 "\x19\x01",
  112.                 domainSeparator,
  113.                 structHash
  114.             )
  115.         );
  117.         address signatory = ecrecover(digest, v, r, s);
  118.         require(signatory != address(0), "SUSHI::delegateBySig: invalid signature");
  119.         require(nonce == nonces[signatory]++, "SUSHI::delegateBySig: invalid nonce");
  120.         require(now <= expiry, "SUSHI::delegateBySig: signature expired");
  121.         return _delegate(signatory, delegatee);
  122.     }
  124.     /**
  125.      * @notice Gets the current votes balance for `account`
  126.      * @param account The address to get votes balance
  127.      * @return The number of current votes for `account`
  128.      */
  129.     function getCurrentVotes(address account)
  130.         external
  131.         view
  132.         returns (uint256)
  133.     {
  134.         uint32 nCheckpoints = numCheckpoints[account];
  135.         return nCheckpoints > 0 ? checkpoints[account][nCheckpoints - 1].votes : 0;
  136.     }
  138.     /**
  139.      * @notice Determine the prior number of votes for an account as of a block number
  140.      * @dev Block number must be a finalized block or else this function will revert to prevent misinformation.
  141.      * @param account The address of the account to check
  142.      * @param blockNumber The block number to get the vote balance at
  143.      * @return The number of votes the account had as of the given block
  144.      */
  145.     function getPriorVotes(address account, uint blockNumber)
  146.         external
  147.         view
  148.         returns (uint256)
  149.     {
  150.         require(blockNumber < block.number, "SUSHI::getPriorVotes: not yet determined");
  152.         uint32 nCheckpoints = numCheckpoints[account];
  153.         if (nCheckpoints == 0) {
  154.             return 0;
  155.         }
  157.         // First check most recent balance
  158.         if (checkpoints[account][nCheckpoints - 1].fromBlock <= blockNumber) {
  159.             return checkpoints[account][nCheckpoints - 1].votes;
  160.         }
  162.         // Next check implicit zero balance
  163.         if (checkpoints[account][0].fromBlock > blockNumber) {
  164.             return 0;
  165.         }
  167.         uint32 lower = 0;
  168.         uint32 upper = nCheckpoints - 1;
  169.         while (upper > lower) {
  170.             uint32 center = upper - (upper - lower) / 2; // ceil, avoiding overflow
  171.             Checkpoint memory cp = checkpoints[account][center];
  172.             if (cp.fromBlock == blockNumber) {
  173.                 return cp.votes;
  174.             } else if (cp.fromBlock < blockNumber) {
  175.                 lower = center;
  176.             } else {
  177.                 upper = center - 1;
  178.             }
  179.         }
  180.         return checkpoints[account][lower].votes;
  181.     }
  183.     function _delegate(address delegator, address delegatee)
  184.         internal
  185.     {
  186.         address currentDelegate = _delegates[delegator];
  187.         uint256 delegatorBalance = balanceOf(delegator); // balance of underlying SUSHIs (not scaled);
  188.         _delegates[delegator] = delegatee;
  190.         emit DelegateChanged(delegator, currentDelegate, delegatee);
  192.         _moveDelegates(currentDelegate, delegatee, delegatorBalance);
  193.     }
  195.     function _moveDelegates(address srcRep, address dstRep, uint256 amount) internal {
  196.         if (srcRep != dstRep && amount > 0) {
  197.             if (srcRep != address(0)) {
  198.                 // decrease old representative
  199.                 uint32 srcRepNum = numCheckpoints[srcRep];
  200.                 uint256 srcRepOld = srcRepNum > 0 ? checkpoints[srcRep][srcRepNum - 1].votes : 0;
  201.                 uint256 srcRepNew = srcRepOld.sub(amount);
  202.                 _writeCheckpoint(srcRep, srcRepNum, srcRepOld, srcRepNew);
  203.             }
  205.             if (dstRep != address(0)) {
  206.                 // increase new representative
  207.                 uint32 dstRepNum = numCheckpoints[dstRep];
  208.                 uint256 dstRepOld = dstRepNum > 0 ? checkpoints[dstRep][dstRepNum - 1].votes : 0;
  209.                 uint256 dstRepNew = dstRepOld.add(amount);
  210.                 _writeCheckpoint(dstRep, dstRepNum, dstRepOld, dstRepNew);
  211.             }
  212.         }
  213.     }
  215.     function _writeCheckpoint(
  216.         address delegatee,
  217.         uint32 nCheckpoints,
  218.         uint256 oldVotes,
  219.         uint256 newVotes
  220.     )
  221.         internal
  222.     {
  223.         uint32 blockNumber = safe32(block.number, "SUSHI::_writeCheckpoint: block number exceeds 32 bits");
  225.         if (nCheckpoints > 0 && checkpoints[delegatee][nCheckpoints - 1].fromBlock == blockNumber) {
  226.             checkpoints[delegatee][nCheckpoints - 1].votes = newVotes;
  227.         } else {
  228.             checkpoints[delegatee][nCheckpoints] = Checkpoint(blockNumber, newVotes);
  229.             numCheckpoints[delegatee] = nCheckpoints + 1;
  230.         }
  232.         emit DelegateVotesChanged(delegatee, oldVotes, newVotes);
  233.     }
  235.     function safe32(uint n, string memory errorMessage) internal pure returns (uint32) {
  236.         require(n < 2**32, errorMessage);
  237.         return uint32(n);
  238.     }
  240.     function getChainId() internal pure returns (uint) {
  241.         uint256 chainId;
  242.         assembly { chainId := chainid() }
  243.         return chainId;
  244.     }
  245. }

3：完整sushi源码下载地址：https://github.com/sushiswap/sushiswap/tree/master/contracts

发表评论

表情：
评论列表 （有 0 条评论，296人围观）

还没有评论，来说两句吧...

相关阅读

    相关 以太坊 智能合约 简介

    以太坊是一个分布式的计算平台。它会生成一个名为Ether的加密货币。程序员可以在以太坊区块链上写下“智能合约”，这些以太坊智能合约会根据代码自动执行。 以太坊是什么？

    灰太狼灰太狼/ 0 赞/ 698 阅读