ERC-918: 可挖矿代币标准

interface ERC918  {
   
   function mint(uint256 nonce) public returns (bool success);

   function getAdjustmentInterval() public view returns (uint);

   function getChallengeNumber() public view returns (bytes32);

   function getMiningDifficulty() public view returns (uint);

   function getMiningTarget() public view returns (uint);

   function getMiningReward() public view returns (uint);
   
   function decimals() public view returns (uint8);

   event Mint(address indexed from, uint rewardAmount, uint epochCount, bytes32 newChallengeNumber);
}

bytes32 public adjustmentInterval;

bytes32 public challengeNumber;

uint public difficulty;

uint public tokensMinted;

uint public epochCount;

contract AbstractERC918 is EIP918Interface {

    // the amount of time between difficulty adjustments
    uint public adjustmentInterval;
     
    // generate a new challenge number after a new reward is minted
    bytes32 public challengeNumber;
    
    // the current mining target
    uint public miningTarget;

    // cumulative counter of the total minted tokens
    uint public tokensMinted;

    // number of blocks per difficulty readjustment
    uint public blocksPerReadjustment;

    //number of 'blocks' mined
    uint public epochCount;
   
    /*
     * Externally facing mint function that is called by miners to validate challenge digests, calculate reward,
     * populate statistics, mutate epoch variables and adjust the solution difficulty as required. Once complete,
     * a Mint event is emitted before returning a success indicator.
     **/
    function mint(uint256 nonce) public returns (bool success) {
        require(msg.sender != address(0));

        // perform the hash function validation
        hash(nonce);
        
        // calculate the current reward
        uint rewardAmount = _reward();
        
        // increment the minted tokens amount
        tokensMinted += rewardAmount;
        
        epochCount = _epoch();

        //every so often, readjust difficulty. Don't readjust when deploying
        if(epochCount % blocksPerReadjustment == 0){
            _adjustDifficulty();
        }
       
        // send Mint event indicating a successful implementation
        emit Mint(msg.sender, rewardAmount, epochCount, challengeNumber);
        
        return true;
    }
}

event Mint(address indexed from, uint reward_amount, uint epochCount, bytes32 newChallengeNumber);

function hash(uint256 nonce) public returns (bytes32 digest);

function _reward() internal returns (uint);

function _newEpoch(uint256 nonce) internal returns (uint);

function _adjustDifficulty() internal returns (uint);

function getAdjustmentInterval() public view returns (uint);

function getChallengeNumber() public view returns (bytes32);

function getMiningDifficulty() public view returns (uint)

function getMiningReward() public view returns (uint)

/**
 * @title ERC-918 可挖矿代币标准，可选的合并挖矿功能
 * @dev See https://github.com/ethereum/EIPs/blob/master/EIPS/eip-918.md
 * 
 */
contract ERC918Merged is AbstractERC918 {
    /*
     * @notice 面向外部的合并函数，由矿工调用以验证挑战摘要、计算奖励、
     * 填充统计信息、更改状态变量并根据需要调整解决方案难度。此外，
     * 合并函数接受一个目标代币地址数组，用于合并奖励。完成后，
     * 在返回成功指示器之前，会发出一个 Mint 事件。
     *
     * @param _nonce 解决方案 nonce
     **/
    function merge(uint256 _nonce, address[] _mineTokens) public returns (bool) {
      for (uint i = 0; i < _mineTokens.length; i++) {
        address tokenAddress = _mineTokens[i];
        ERC918Interface(tokenAddress).mint(_nonce);
      }
    }

    /*
     * @notice 面向外部的合并函数，保留用于与先前定义向后兼容
     *
     * @param _nonce 解决方案 nonce
     * @param _challenge_digest keccak256 编码的挑战码 + 消息发送者 + 解决方案 nonce
     **/
     function merge(uint256 _nonce, bytes32 _challenge_digest, address[] _mineTokens) public returns (bool) {
       //挑战摘要必须与预期匹配
       bytes32 digest = keccak256( abi.encodePacked(challengeNumber, msg.sender, _nonce) );
       require(digest == _challenge_digest, "Challenge digest does not match expected digest on token contract [ ERC918Merged.mint() ]");
       return merge(_nonce, _mineTokens);
     }
}

{
    "title": "Mineable Mint Packet Metadata",
    "type": "object",
    "properties": {
        "nonce": {
            "type": "string",
            "description": "Identifies the target solution nonce",  //标识目标解决方案 nonce
        },
        "origin": {
            "type": "string",
            "description": "Identifies the original user that mined the solution nonce", //标识挖掘解决方案 nonce 的原始用户
        },
        "signature": {
            "type": "string",
            "description": "The signed hash of tightly packed variables sha3('delegatedMintHashing(uint256,address)')+nonce+origin_account", //紧密打包变量的签名哈希 sha3('delegatedMintHashing(uint256,address)')+nonce+origin_account
        }
    }
}

function prepareDelegatedMintTxn(nonce, account) {
  var functionSig = web3.utils.sha3("delegatedMintHashing(uint256,address)").substring(0,10)
  var data = web3.utils.soliditySha3( functionSig, nonce, account.address )
  var sig = web3.eth.accounts.sign(web3.utils.toHex(data), account.privateKey )
  // prepare the mint packet
  var packet = {}
  packet.nonce = nonce
  packet.origin = account.address
  packet.signature = sig.signature
  // deliver resulting JSON packet to pool or third party
  var mineableMintPacket = JSON.stringify(packet, null, 4)
  /* todo: send mineableMintPacket to submitter */
  ...
}

//received by minter  //由矿工接收
var mineableMintPacket = ...
var packet = JSON.parse(mineableMintPacket)
erc918MineableToken.delegatedMint(packet.nonce, packet.origin, packet.signature)

/**
 * @title ERC-918 可挖矿代币标准，可选的元数据扩展
 * @dev See https://github.com/ethereum/EIPs/blob/master/EIPS/eip-918.md
 * 
 */
interface ERC918Metadata is AbstractERC918 {
    /**
     * @notice A distinct Uniform Resource Identifier (URI) for a mineable asset.
     */
    function metadataURI() external view returns (string);
}

{
    "title": "Mineable Token Metadata",
    "type": "object",
    "properties": {
        "symbol": {
            "type": "string",
            "description": "Identifies the Mineable Token's symbol", //标识可挖矿代币的符号
        },
        "name": {
            "type": "string",
            "description": "Identifies the Mineable Token's name", //标识可挖矿代币的名称
        },
        "description": {
            "type": "string",
            "description": "Identifies the Mineable Token's long description", //标识可挖矿代币的长描述
        },
        "website": {
            "type": "string",
            "description": "Identifies the Mineable Token's homepage URI", //标识可挖矿代币的主页 URI
        },
        "image": {
            "type": "string",
            "description": "Identifies the Mineable Token's image URI", //标识可挖矿代币的图像 URI
        },
        "type": {
            "type": "string",
            "description": "Identifies the Mineable Token's hash algorithm ( ie.keccak256 ) used to encode the solution", //标识用于编码解决方案的可挖矿代币的哈希算法（即 keccak256）
        }
    }
}

/**
 * @title ERC-918 可挖矿代币标准，可选的向后兼容性函数
 * @dev See https://github.com/ethereum/EIPs/blob/master/EIPS/eip-918.md
 * 
 */
contract ERC918BackwardsCompatible is AbstractERC918 {

    /*
     * @notice 面向外部的 mint 函数，保留用于与之前的 mint() 定义向后兼容
     * @param _nonce 解决方案 nonce
     * @param _challenge_digest keccak256 编码的挑战码 + 消息发送者 + 解决方案 nonce
     **/
    function mint(uint256 _nonce, bytes32 _challenge_digest) public returns (bool success) {
        //挑战摘要必须与预期匹配
        bytes32 digest = keccak256( abi.encodePacked(challengeNumber, msg.sender, _nonce) );
        require(digest == _challenge_digest, "Challenge digest does not match expected digest on token contract [ AbstractERC918.mint() ]");
        success = mint(_nonce);
    }
}