万向区块链技术研究报告 | Polygon技术调研

 type CheckpointBlockHeader struct {

    
     // Proposer is selected based on stake
    
     Proposer        types.HeimdallAddress `json:"proposer"`
    
  
    
     // StartBlock: The block number on Bor from which this checkpoint starts
    
     StartBlock      uint64                `json:"startBlock"`
    
  
    
     // EndBlock: The block number on Bor from which this checkpoint ends
    
     EndBlock        uint64                `json:"endBlock"`
    
     
    
     // RootHash is the Merkle root of all the leaves containing the block 
    
     // headers starting from start to the end block 
    
     RootHash        types.HeimdallHash    `json:"rootHash"`
    
  
    
     // Account root hash for each validator
    
   // Hash of data that needs to be passed from Heimdall to Ethereum chain like slashing, withdraw topup etc.
    
     AccountRootHash types.HeimdallHash    `json:"accountRootHash"`
    
  
    
   // Timestamp when checkpoint was created on Heimdall
    
     TimeStamp       uint64          `json:"timestamp"`
    
 }
    
    
    
    

    blockHash = keccak256([number, time, tx hash, receipt hash])
    

 B(1) := keccak256([number, time, tx hash, receipt hash])

    
 B(2) := keccak256([number, time, tx hash, receipt hash]) 
    
 . . . 
    
 B(n) := keccak256([number, time, tx hash, receipt hash]) 
    
  
    
 // checkpoint is Merkle root of all block hash 
    
 checkpoint's root hash = Merkel[B(1), B(2), ....., B(n)]
    
    
    
    

 // id

    
 eachAccountHash := keccak256([validator id, withdraw fee, slash amount])
    
    
    
    

 B(1) := keccak256([validator id, withdraw fee, slash amount])

    
 B(2) := keccak256([validator id, withdraw fee, slash amount]) 
    
 . . . 
    
 B(n) := keccak256([validator id, withdraw fee, slash amount]) 
    
  
    
 // account root hash is Merkle root of all block hash 
    
 checkpoint's account root hash = Merkel[B(1), B(2), ....., B(n)]
    
    
    
    

 pragma solidity 0.6.6;

    
  
    
 import {SafeMath} from "@openzeppelin/contracts/math/SafeMath.sol";
    
 import {ICheckpointManager} from "./ICheckpointManager.sol";
    
  
    
 /** * @notice Mock Checkpoint Manager contract to simulate plasma checkpoints while testing
    
 */
    
 contract MockCheckpointManager is ICheckpointManager {
    
     using SafeMath for uint256;
    
  
    
     uint256 public currentCheckpointNumber = 0;
    
  
    
     function setCheckpoint(bytes32 rootHash, uint256 start, uint256 end) public {
    
     HeaderBlock memory headerBlock = HeaderBlock({
    
         root: rootHash,
    
         start: start,
    
         end: end,
    
         createdAt: now,
    
         proposer: msg.sender
    
     });
    
  
    
     currentCheckpointNumber = currentCheckpointNumber.add(1);
    
     headerBlocks[currentCheckpointNumber] = headerBlock;
    
     }
    
 }
    
    
    
    

        1. pragma solidity 0.6.6;

    
        2.  
    
        3. interface IStateSender {
    
        4.     function syncState(address receiver, bytes calldata data) external;
    
        5. }
    

        1. pragma solidity 0.6.6;

    
        2.  
    
        3. interface IStateReceiver {
    
        4.     function onStateReceive(uint256 id, bytes calldata data) external;
    
        5. }
    

 function mapToken(

    
     address rootToken,
    
     address childToken,
    
     bytes32 tokenType
    
     ) external;
    
    
    
    

 await rootTokenContract.methods

    
   .approve(erc20Predicate, amount)
    
   .send({ from: userAddress })
    
    
    
    

 const depositData = mainWeb3.eth.abi.encodeParameter('uint256', amount)

    
 await rootChainManagerContract.methods
    
   .depositFor(userAddress, rootToken, depositData)
    
   .send({ from: userAddress })
    
    
    
    

 const burnTx = await childTokenContract.methods

    
   .withdraw(amount)
    
   .send({ from: userAddress })
    
 const burnTxHash = burnTx.transactionHash
    
    
    
    

    function exit(bytes calldata inputData) external;
    

 const exitCalldata = await maticPOSClient

    
   .exitERC20(burnTxHash, { from, encodeAbi: true })
    
    
    
    

 await mainWeb3.eth.sendTransaction({

    
   from: userAddress,
    
   to: rootChainManagerAddress,
    
   data: exitCalldata.data
    
 })
    
    
    
    

 function exit(bytes calldata inputData) external override {

    
     ExitPayloadReader.ExitPayload memory payload = inputData.toExitPayload();
    
  
    
     bytes memory branchMaskBytes = payload.getBranchMaskAsBytes();
    
     // checking if exit has already been processed
    
     // unique exit is identified using hash of (blockNumber, branchMask, receiptLogIndex)
    
     bytes32 exitHash = keccak256(
    
     abi.encodePacked(
    
         payload.getBlockNumber(),
    
         // first 2 nibbles are dropped while generating nibble array
    
         // this allows branch masks that are valid but bypass exitHash check (changing first 2 nibbles only)
    
         // so converting to nibble array and then hashing it
    
         MerklePatriciaProof._getNibbleArray(branchMaskBytes),
    
         payload.getReceiptLogIndex()
    
     )
    
     );
    
  
    
     require(
    
     processedExits[exitHash] == false,
    
     "RootChainManager: EXIT_ALREADY_PROCESSED"
    
     );
    
     processedExits[exitHash] = true;
    
  
    
     // 解析 receipt 数据
    
     ExitPayloadReader.Receipt memory receipt = payload.getReceipt();
    
     ExitPayloadReader.Log memory log = receipt.getLog();
    
  
    
     // log should be emmited only by the child token
    
     address rootToken = childToRootToken[log.getEmitter()];
    
     require(
    
     rootToken != address(0),
    
     "RootChainManager: TOKEN_NOT_MAPPED"
    
     );
    
  
    
     address predicateAddress = typeToPredicate[
    
     tokenToType[rootToken]
    
     ];
    
  
    
     // branch mask can be maximum 32 bits
    
     require(
    
     payload.getBranchMaskAsUint() &
    
     0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF00000000 ==
    
     0,
    
     "RootChainManager: INVALID_BRANCH_MASK"
    
     );
    
  
    
     // 验证收据内容
    
     require(
    
     MerklePatriciaProof.verify(
    
         receipt.toBytes(),
    
         branchMaskBytes,
    
         payload.getReceiptProof(),
    
         payload.getReceiptRoot()
    
     ),
    
     "RootChainManager: INVALID_PROOF"
    
     );
    
  
    
     // 验证检查点内容
    
     _checkBlockMembershipInCheckpoint(
    
     payload.getBlockNumber(), 
    
     payload.getBlockTime(), 
    
     payload.getTxRoot(), 
    
     payload.getReceiptRoot(), 
    
     payload.getHeaderNumber(), 
    
     payload.getBlockProof()
    
     );
    
  
    
     // 取款
    
     ITokenPredicate(predicateAddress).exitTokens(
    
     _msgSender(),
    
     rootToken,
    
     log.toRlpBytes()
    
     );
    
 }
    
  
    
 function _checkBlockMembershipInCheckpoint(
    
     uint256 blockNumber,
    
     uint256 blockTime,
    
     bytes32 txRoot,
    
     bytes32 receiptRoot,
    
     uint256 headerNumber,
    
     bytes memory blockProof
    
 ) private view returns (uint256) {
    
     (
    
     bytes32 headerRoot,
    
     uint256 startBlock,
    
     ,
    
     uint256 createdAt,
    
  
    
     ) = _checkpointManager.headerBlocks(headerNumber);
    
  
    
     require(
    
     keccak256(
    
         abi.encodePacked(blockNumber, blockTime, txRoot, receiptRoot)
    
     )
    
         .checkMembership(
    
         blockNumber.sub(startBlock),
    
         headerRoot,
    
         blockProof
    
     ),
    
     "RootChainManager: INVALID_HEADER"
    
     );
    
     return createdAt;
    
 }
    
    
    
    

     /** * @notice Validates log signature, from and to address
    
      * then sends the correct amount to withdrawer
    
      * callable only by manager
    
      * @param rootToken Token which gets withdrawn
    
      * @param log Valid ERC20 burn log from child chain
    
      */
    
     function exitTokens(
    
     address,
    
     address rootToken,
    
     bytes memory log
    
     )
    
     public
    
     override
    
     only(MANAGER_ROLE)
    
     {
    
     RLPReader.RLPItem[] memory logRLPList = log.toRlpItem().toList();
    
     RLPReader.RLPItem[] memory logTopicRLPList = logRLPList[1].toList(); // topics
    
  
    
     require(
    
         bytes32(logTopicRLPList[0].toUint()) == TRANSFER_EVENT_SIG, // topic0 is event sig
    
         "ERC20Predicate: INVALID_SIGNATURE"
    
     );
    
  
    
     address withdrawer = address(logTopicRLPList[1].toUint()); // topic1 is from address
    
  
    
     require(
    
         address(logTopicRLPList[2].toUint()) == address(0), // topic2 is to address
    
         "ERC20Predicate: INVALID_RECEIVER"
    
     );
    
     
    
     uint256 amount = logRLPList[2].toUint(); // log data field is the amount
    
  
    
     IERC20(rootToken).safeTransfer(
    
         withdrawer,
    
         amount
    
     );
    
  
    
     emit ExitedERC20(withdrawer, rootToken, amount);
    
     }