Contract 0x05cadbf3128bcb7f2b89f3dd55e5b0a036a49e20 12

 
Txn Hash Method
Block
From
To
Value [Txn Fee]
0x5416fdca452a0192464309d642e6cff1ce460005beb70dac90ecd0333bb26d95Burn790387592023-04-10 15:20:08353 days 15 hrs ago0x9563eced683588aeaa8c870648fc1623f06b9bb2 IN  0x05cadbf3128bcb7f2b89f3dd55e5b0a036a49e200 ETH0.0001195 0.1
0xa07775695a86cdfe5c39c871ccd2f462032aa2673f1ffcaabca52b364499abd5Burn788456712023-04-10 1:53:35354 days 5 hrs ago0xd8dbfd62956727d2caf18fad58d69975326c8534 IN  0x05cadbf3128bcb7f2b89f3dd55e5b0a036a49e200 ETH0.00008407 0.1
0x5ac9621865019ab5e06e48ae43c4b63a6dc0eca2ebb5375acc5d3c500aa99624Burn785724052023-04-09 6:42:08355 days 23 mins ago0xd8dbfd62956727d2caf18fad58d69975326c8534 IN  0x05cadbf3128bcb7f2b89f3dd55e5b0a036a49e200 ETH0.00007511 0.1
0x3a07b3d8d5e002aeb4f095f8effd9b24849b3add33884dccb087849fee581045Burn774114592023-04-05 20:46:29358 days 10 hrs ago0xf3ad97364bccc3ea0582ede58c363888f8c4ec85 IN  0x05cadbf3128bcb7f2b89f3dd55e5b0a036a49e200 ETH0.00012466 0.1
0x5c2efc6771388a92e49d33b62f8bd67f52fa1969046eddd93b904d783c8bef4aBurn773714002023-04-05 17:57:38358 days 13 hrs ago0xd8dbfd62956727d2caf18fad58d69975326c8534 IN  0x05cadbf3128bcb7f2b89f3dd55e5b0a036a49e200 ETH0.00012449 0.1
0x5eae1d66456d51bcc661805c58c9ccad55e0904139b350bbc271c58a5f95f998Burn773619882023-04-05 17:18:24358 days 13 hrs ago0x8e0afcab03532e9061dc03b6fda97160dc77a337 IN  0x05cadbf3128bcb7f2b89f3dd55e5b0a036a49e200 ETH0.000131430.1
0x61f3c5e3549524afca53fa90473fd207b6c61e7bf92eeac295ff8bee8bf2581dBurn773531342023-04-05 16:41:21358 days 14 hrs ago0x8e0afcab03532e9061dc03b6fda97160dc77a337 IN  0x05cadbf3128bcb7f2b89f3dd55e5b0a036a49e200 ETH0.000147860.1
0x37e53a4cab7f21c171d7c6b9f6115a0ea5717e7312eb0bfc35e9219f962f4edfBurn773026452023-04-05 13:12:02358 days 17 hrs ago0xc5c0504a929adbc50d765364d7c214ab9e669c50 IN  0x05cadbf3128bcb7f2b89f3dd55e5b0a036a49e200 ETH0.00010367 0.1
0x55b7227346a57f143885098fc8533ef5d4fb31da67600c15fccd527df0a69010Burn767204892023-04-03 20:12:34360 days 10 hrs ago0x8e0afcab03532e9061dc03b6fda97160dc77a337 IN  0x05cadbf3128bcb7f2b89f3dd55e5b0a036a49e200 ETH0.000130230.19574
0xa351746a7d3d0424e5b96ba9b28ea0093fabe90035a89ddd032d2ab533a2cbdbBurn763536602023-04-02 18:20:01361 days 12 hrs ago0xec4e8c7c07d49aa58a017bfd683f23affc73d1c0 IN  0x05cadbf3128bcb7f2b89f3dd55e5b0a036a49e200 ETH0.00008822 0.1
0x9b059b94ac586bf4e30dcf3948590920cd1e110fe22a9af42b74a2180177893dBurn760629522023-04-01 21:41:00362 days 9 hrs ago0x8e0afcab03532e9061dc03b6fda97160dc77a337 IN  0x05cadbf3128bcb7f2b89f3dd55e5b0a036a49e200 ETH0.000079050.1
0x8b63dda9021db1105d644d270d52725c6734d8d10c80c0d57790cae94a50311bBurn760028042023-04-01 17:19:22362 days 13 hrs ago0x8e0afcab03532e9061dc03b6fda97160dc77a337 IN  0x05cadbf3128bcb7f2b89f3dd55e5b0a036a49e200 ETH0.000112730.1
0x336b1feb69e6aca25b24247e2e1318d01553fef90f88c0844e19d46b2bc6798fBurn753381232023-03-30 18:37:47364 days 12 hrs ago0x8e0afcab03532e9061dc03b6fda97160dc77a337 IN  0x05cadbf3128bcb7f2b89f3dd55e5b0a036a49e200 ETH0.000112590.1
0x0775db5fdea59ebeaec51bfa9f9d04b14804b2048f72d21af35736f801093a58Burn752682272023-03-30 13:48:32364 days 17 hrs ago0x8e0afcab03532e9061dc03b6fda97160dc77a337 IN  0x05cadbf3128bcb7f2b89f3dd55e5b0a036a49e200 ETH0.000089220.1
0x9daffba006266ca2dc8699880624ff2c91e56d2522e733d0f0a30c3770165331Burn738340512023-03-26 9:58:46368 days 21 hrs ago0x8e0afcab03532e9061dc03b6fda97160dc77a337 IN  0x05cadbf3128bcb7f2b89f3dd55e5b0a036a49e200 ETH0.000066040.1
0xa5cf33a2bddef49fe0fc364b7ebc09800cccb17dae7e3040f275ce61e3f1aec4Burn733745762023-03-25 1:59:08370 days 5 hrs ago0x9563eced683588aeaa8c870648fc1623f06b9bb2 IN  0x05cadbf3128bcb7f2b89f3dd55e5b0a036a49e200 ETH0.00006154 0.1
0x989f13fe6c4edec1c5dbdc754bab65ae917625dea7b04cdb3f92cc6d8e7ad6c1Burn732668652023-03-24 18:34:22370 days 12 hrs ago0x9563eced683588aeaa8c870648fc1623f06b9bb2 IN  0x05cadbf3128bcb7f2b89f3dd55e5b0a036a49e200 ETH0.0001124 0.1
0xb656b4fc9e669666061bcde5de5ccdcbd3ff4873519171da06c8f5d8ff2303d5Burn732320322023-03-24 16:11:04370 days 14 hrs ago0x96d916bcdb15666d9ca669b3f7a67618301131fc IN  0x05cadbf3128bcb7f2b89f3dd55e5b0a036a49e200 ETH0.00012178 0.1
0x72126de3480d9ecb25f73c168d14e76542091ffc23dd5ced57cc697436dcdac4Burn731935732023-03-24 13:33:30370 days 17 hrs ago0x8cc8ac604cd92e588fa27259dc4557fae0e4a2d6 IN  0x05cadbf3128bcb7f2b89f3dd55e5b0a036a49e200 ETH0.00014872 0.1
0x5d65c6f6552e54915e1a9c74ad7589c126e04807dd17f3118bc03322237a1d9cBurn731848842023-03-24 12:57:54370 days 18 hrs ago0x8e0afcab03532e9061dc03b6fda97160dc77a337 IN  0x05cadbf3128bcb7f2b89f3dd55e5b0a036a49e200 ETH0.000100340.1
0xc0d04079bef6eabd53dca147b1b5c22c2cd87c58cb9598a679a897188150426fBurn731591392023-03-24 11:12:13370 days 19 hrs ago0x9f594f0ac95e4a57d7ebdb3ba5840e7a89f688ed IN  0x05cadbf3128bcb7f2b89f3dd55e5b0a036a49e200 ETH0.00006616 0.1
0xb70515a8292267778045cd832e10dc3a7c6c0d333f5c63233174c0f1e3d3f4a2Burn729750042023-03-23 22:39:14371 days 8 hrs ago0x0aadc7745996993b6e865c69e925bb292a930be8 IN  0x05cadbf3128bcb7f2b89f3dd55e5b0a036a49e200 ETH0.00007872 0.1
0xba9af30f6a6d37393ff6f55105ee1148f427f20c330b31ae2bf4770f7253b1abBurn729671282023-03-23 22:07:23371 days 8 hrs ago0x29d54f612660b8052b82115ce9e095a7c9df4372 IN  0x05cadbf3128bcb7f2b89f3dd55e5b0a036a49e200 ETH0.00008314 0.1
0x54c569096e5b43bd40fc4e0bb950956bd5fc3b2e4f1540fe80704a581e9cc73cBurn726919202023-03-23 3:52:39372 days 3 hrs ago0x95636869d2488f6262d57cef2e0f2b89057b195f IN  0x05cadbf3128bcb7f2b89f3dd55e5b0a036a49e200 ETH0.00005901 0.1
0x46b1b33689f8aacc12a6ba41d55cc8c13e5b5c93032c3bfc2992df8ffb1d8615Burn724644572023-03-22 12:18:02372 days 18 hrs ago0x8e0afcab03532e9061dc03b6fda97160dc77a337 IN  0x05cadbf3128bcb7f2b89f3dd55e5b0a036a49e200 ETH0.000055140.1
[ Download CSV Export 
Latest 25 internal transaction
Parent Txn Hash Block From To Value
0x7ff728cadedbe7bfc649b9e183afbc0d3896be58c09b5a1259b7b49a5c6debe0720334302023-03-21 6:40:19374 days 25 mins ago 0x05cadbf3128bcb7f2b89f3dd55e5b0a036a49e20 0xdbf31df14b66535af65aac99c32e9ea844e145010 ETH
0x7ff728cadedbe7bfc649b9e183afbc0d3896be58c09b5a1259b7b49a5c6debe0720334302023-03-21 6:40:19374 days 25 mins ago 0x05cadbf3128bcb7f2b89f3dd55e5b0a036a49e20 0xdbf31df14b66535af65aac99c32e9ea844e145010 ETH
0x7ff728cadedbe7bfc649b9e183afbc0d3896be58c09b5a1259b7b49a5c6debe0720334302023-03-21 6:40:19374 days 25 mins ago 0x05cadbf3128bcb7f2b89f3dd55e5b0a036a49e20 0x6b8bb175c092de7d81860b18db360b734a2598e00 ETH
0xb83179441127fd6ee768ff40caceb5aa6705a296022fc33787b2ab93ecbd420b704637922023-03-16 16:36:26378 days 14 hrs ago 0x05cadbf3128bcb7f2b89f3dd55e5b0a036a49e20 0xdbf31df14b66535af65aac99c32e9ea844e145010 ETH
0xb83179441127fd6ee768ff40caceb5aa6705a296022fc33787b2ab93ecbd420b704637922023-03-16 16:36:26378 days 14 hrs ago 0x05cadbf3128bcb7f2b89f3dd55e5b0a036a49e20 0xdbf31df14b66535af65aac99c32e9ea844e145010 ETH
0xb83179441127fd6ee768ff40caceb5aa6705a296022fc33787b2ab93ecbd420b704637922023-03-16 16:36:26378 days 14 hrs ago 0x05cadbf3128bcb7f2b89f3dd55e5b0a036a49e20 0x6b8bb175c092de7d81860b18db360b734a2598e00 ETH
0x95bbb32c01249c1cd251644d9e45a7ee5e62106f95b19c42553684b185a1a3a5703826882023-03-16 11:02:37378 days 20 hrs ago 0x05cadbf3128bcb7f2b89f3dd55e5b0a036a49e20 0xdbf31df14b66535af65aac99c32e9ea844e145010 ETH
0x95bbb32c01249c1cd251644d9e45a7ee5e62106f95b19c42553684b185a1a3a5703826882023-03-16 11:02:37378 days 20 hrs ago 0x05cadbf3128bcb7f2b89f3dd55e5b0a036a49e20 0xdbf31df14b66535af65aac99c32e9ea844e145010 ETH
0x95bbb32c01249c1cd251644d9e45a7ee5e62106f95b19c42553684b185a1a3a5703826882023-03-16 11:02:37378 days 20 hrs ago 0x05cadbf3128bcb7f2b89f3dd55e5b0a036a49e20 0x6b8bb175c092de7d81860b18db360b734a2598e00 ETH
0x18ca5159e54b8ff20589d4bd415589f4f188214fa2275eca47dc1a3715d42aa4697697152023-03-14 14:29:01380 days 16 hrs ago 0x05cadbf3128bcb7f2b89f3dd55e5b0a036a49e20 0xdbf31df14b66535af65aac99c32e9ea844e145010 ETH
0x18ca5159e54b8ff20589d4bd415589f4f188214fa2275eca47dc1a3715d42aa4697697152023-03-14 14:29:01380 days 16 hrs ago 0x05cadbf3128bcb7f2b89f3dd55e5b0a036a49e20 0xdbf31df14b66535af65aac99c32e9ea844e145010 ETH
0x18ca5159e54b8ff20589d4bd415589f4f188214fa2275eca47dc1a3715d42aa4697697152023-03-14 14:29:01380 days 16 hrs ago 0x05cadbf3128bcb7f2b89f3dd55e5b0a036a49e20 0x6b8bb175c092de7d81860b18db360b734a2598e00 ETH
0x3bdede08cbcee739e4a765d1ace2deff4a1f9adc5da2513a5a7b9b75bd36c049697517532023-03-14 13:11:09380 days 17 hrs ago 0x05cadbf3128bcb7f2b89f3dd55e5b0a036a49e20 0xdbf31df14b66535af65aac99c32e9ea844e145010 ETH
0x3bdede08cbcee739e4a765d1ace2deff4a1f9adc5da2513a5a7b9b75bd36c049697517532023-03-14 13:11:09380 days 17 hrs ago 0x05cadbf3128bcb7f2b89f3dd55e5b0a036a49e20 0xdbf31df14b66535af65aac99c32e9ea844e145010 ETH
0x3bdede08cbcee739e4a765d1ace2deff4a1f9adc5da2513a5a7b9b75bd36c049697517532023-03-14 13:11:09380 days 17 hrs ago 0x05cadbf3128bcb7f2b89f3dd55e5b0a036a49e20 0x6b8bb175c092de7d81860b18db360b734a2598e00 ETH
0xc225353bb670aaa51cc3c2731f4391149167fa1bf51ad619114c29ddd2e4eecf687123212023-03-11 2:22:39384 days 4 hrs ago 0x05cadbf3128bcb7f2b89f3dd55e5b0a036a49e20 0xdbf31df14b66535af65aac99c32e9ea844e145010 ETH
0xc225353bb670aaa51cc3c2731f4391149167fa1bf51ad619114c29ddd2e4eecf687123212023-03-11 2:22:39384 days 4 hrs ago 0x05cadbf3128bcb7f2b89f3dd55e5b0a036a49e20 0xdbf31df14b66535af65aac99c32e9ea844e145010 ETH
0xc225353bb670aaa51cc3c2731f4391149167fa1bf51ad619114c29ddd2e4eecf687123212023-03-11 2:22:39384 days 4 hrs ago 0x05cadbf3128bcb7f2b89f3dd55e5b0a036a49e20 0x6b8bb175c092de7d81860b18db360b734a2598e00 ETH
0x97510a824bfe9170b62f3ef3ea363d522dfc1b4d55caf9a1f708315d9734be59686245582023-03-10 19:37:23384 days 11 hrs ago 0x05cadbf3128bcb7f2b89f3dd55e5b0a036a49e20 0xdbf31df14b66535af65aac99c32e9ea844e145010 ETH
0x97510a824bfe9170b62f3ef3ea363d522dfc1b4d55caf9a1f708315d9734be59686245582023-03-10 19:37:23384 days 11 hrs ago 0x05cadbf3128bcb7f2b89f3dd55e5b0a036a49e20 0xdbf31df14b66535af65aac99c32e9ea844e145010 ETH
0x97510a824bfe9170b62f3ef3ea363d522dfc1b4d55caf9a1f708315d9734be59686245582023-03-10 19:37:23384 days 11 hrs ago 0x05cadbf3128bcb7f2b89f3dd55e5b0a036a49e20 0x6b8bb175c092de7d81860b18db360b734a2598e00 ETH
0x48c82f034b8353f76ad6d0b503410516bedff7b499d1929f3d7ca8fc4d0e0812664846642023-03-03 20:42:47391 days 10 hrs ago 0x05cadbf3128bcb7f2b89f3dd55e5b0a036a49e20 0xdbf31df14b66535af65aac99c32e9ea844e145010 ETH
0x48c82f034b8353f76ad6d0b503410516bedff7b499d1929f3d7ca8fc4d0e0812664846642023-03-03 20:42:47391 days 10 hrs ago 0x05cadbf3128bcb7f2b89f3dd55e5b0a036a49e20 0xdbf31df14b66535af65aac99c32e9ea844e145010 ETH
0x48c82f034b8353f76ad6d0b503410516bedff7b499d1929f3d7ca8fc4d0e0812664846642023-03-03 20:42:47391 days 10 hrs ago 0x05cadbf3128bcb7f2b89f3dd55e5b0a036a49e20 0x6b8bb175c092de7d81860b18db360b734a2598e00 ETH
0xd25515d5b920c6ec4273e1264f4c261e41cdadc321bf718df373d8f2d2b0cca4664822682023-03-03 20:31:54391 days 10 hrs ago 0x05cadbf3128bcb7f2b89f3dd55e5b0a036a49e20 0xdbf31df14b66535af65aac99c32e9ea844e145010 ETH
[ Download CSV Export 
Loading
This contract may be a proxy contract. Click on More Options and select Is this a proxy? to confirm and enable the "Read as Proxy" & "Write as Proxy" tabs.

Contract Source Code Verified (Exact Match)

Contract Name:
BCHGateway

Compiler Version
v0.5.17+commit.d19bba13

Optimization Enabled:
Yes with 200 runs

Other Settings:
default evmVersion, None license

Contract Source Code (Solidity)

/**
 *Submitted for verification at Arbiscan.io on 2022-02-07
*/

/**
 *Submitted for verification at FtmScan.com on 2021-08-28
*/

/**

Deployed by Ren Project, https://renproject.io

Commit hash: 05c0aaf
Repository: https://github.com/renproject/gateway-sol
Issues: https://github.com/renproject/gateway-sol/issues

Licenses
@openzeppelin/contracts: https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/LICENSE
gateway-sol: https://github.com/renproject/gateway-sol/blob/master/LICENSE

*/

pragma solidity ^0.5.17;


contract Initializable {

  
  bool private initialized;

  
  bool private initializing;

  
  modifier initializer() {
    require(initializing || isConstructor() || !initialized, "Contract instance has already been initialized");

    bool isTopLevelCall = !initializing;
    if (isTopLevelCall) {
      initializing = true;
      initialized = true;
    }

    _;

    if (isTopLevelCall) {
      initializing = false;
    }
  }

  
  function isConstructor() private view returns (bool) {
    
    
    
    
    
    address self = address(this);
    uint256 cs;
    assembly { cs := extcodesize(self) }
    return cs == 0;
  }

  
  uint256[50] private ______gap;
}

library SafeMath {
    
    function add(uint256 a, uint256 b) internal pure returns (uint256) {
        uint256 c = a + b;
        require(c >= a, "SafeMath: addition overflow");

        return c;
    }

    
    function sub(uint256 a, uint256 b) internal pure returns (uint256) {
        return sub(a, b, "SafeMath: subtraction overflow");
    }

    
    function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        require(b <= a, errorMessage);
        uint256 c = a - b;

        return c;
    }

    
    function mul(uint256 a, uint256 b) internal pure returns (uint256) {
        
        
        
        if (a == 0) {
            return 0;
        }

        uint256 c = a * b;
        require(c / a == b, "SafeMath: multiplication overflow");

        return c;
    }

    
    function div(uint256 a, uint256 b) internal pure returns (uint256) {
        return div(a, b, "SafeMath: division by zero");
    }

    
    function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        
        require(b > 0, errorMessage);
        uint256 c = a / b;
        

        return c;
    }

    
    function mod(uint256 a, uint256 b) internal pure returns (uint256) {
        return mod(a, b, "SafeMath: modulo by zero");
    }

    
    function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        require(b != 0, errorMessage);
        return a % b;
    }
}

library ECDSA {
    
    function recover(bytes32 hash, bytes memory signature) internal pure returns (address) {
        
        if (signature.length != 65) {
            revert("ECDSA: signature length is invalid");
        }

        
        bytes32 r;
        bytes32 s;
        uint8 v;

        
        
        
        assembly {
            r := mload(add(signature, 0x20))
            s := mload(add(signature, 0x40))
            v := byte(0, mload(add(signature, 0x60)))
        }

        
        
        
        
        
        
        
        
        
        if (uint256(s) > 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20A0) {
            revert("ECDSA: signature.s is in the wrong range");
        }

        if (v != 27 && v != 28) {
            revert("ECDSA: signature.v is in the wrong range");
        }

        
        return ecrecover(hash, v, r, s);
    }

    
    function toEthSignedMessageHash(bytes32 hash) internal pure returns (bytes32) {
        
        
        return keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n32", hash));
    }
}

contract Proxy {
  
  function () payable external {
    _fallback();
  }

  
  function _implementation() internal view returns (address);

  
  function _delegate(address implementation) internal {
    assembly {
      
      
      
      calldatacopy(0, 0, calldatasize)

      
      
      let result := delegatecall(gas, implementation, 0, calldatasize, 0, 0)

      
      returndatacopy(0, 0, returndatasize)

      switch result
      
      case 0 { revert(0, returndatasize) }
      default { return(0, returndatasize) }
    }
  }

  
  function _willFallback() internal {
  }

  
  function _fallback() internal {
    _willFallback();
    _delegate(_implementation());
  }
}

library OpenZeppelinUpgradesAddress {
    
    function isContract(address account) internal view returns (bool) {
        uint256 size;
        
        
        
        
        
        
        
        assembly { size := extcodesize(account) }
        return size > 0;
    }
}

contract BaseUpgradeabilityProxy is Proxy {
  
  event Upgraded(address indexed implementation);

  
  bytes32 internal constant IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;

  
  function _implementation() internal view returns (address impl) {
    bytes32 slot = IMPLEMENTATION_SLOT;
    assembly {
      impl := sload(slot)
    }
  }

  
  function _upgradeTo(address newImplementation) internal {
    _setImplementation(newImplementation);
    emit Upgraded(newImplementation);
  }

  
  function _setImplementation(address newImplementation) internal {
    require(OpenZeppelinUpgradesAddress.isContract(newImplementation), "Cannot set a proxy implementation to a non-contract address");

    bytes32 slot = IMPLEMENTATION_SLOT;

    assembly {
      sstore(slot, newImplementation)
    }
  }
}

contract UpgradeabilityProxy is BaseUpgradeabilityProxy {
  
  constructor(address _logic, bytes memory _data) public payable {
    assert(IMPLEMENTATION_SLOT == bytes32(uint256(keccak256('eip1967.proxy.implementation')) - 1));
    _setImplementation(_logic);
    if(_data.length > 0) {
      (bool success,) = _logic.delegatecall(_data);
      require(success);
    }
  }  
}

contract BaseAdminUpgradeabilityProxy is BaseUpgradeabilityProxy {
  
  event AdminChanged(address previousAdmin, address newAdmin);

  

  bytes32 internal constant ADMIN_SLOT = 0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103;

  
  modifier ifAdmin() {
    if (msg.sender == _admin()) {
      _;
    } else {
      _fallback();
    }
  }

  
  function admin() external ifAdmin returns (address) {
    return _admin();
  }

  
  function implementation() external ifAdmin returns (address) {
    return _implementation();
  }

  
  function changeAdmin(address newAdmin) external ifAdmin {
    require(newAdmin != address(0), "Cannot change the admin of a proxy to the zero address");
    emit AdminChanged(_admin(), newAdmin);
    _setAdmin(newAdmin);
  }

  
  function upgradeTo(address newImplementation) external ifAdmin {
    _upgradeTo(newImplementation);
  }

  
  function upgradeToAndCall(address newImplementation, bytes calldata data) payable external ifAdmin {
    _upgradeTo(newImplementation);
    (bool success,) = newImplementation.delegatecall(data);
    require(success);
  }

  
  function _admin() internal view returns (address adm) {
    bytes32 slot = ADMIN_SLOT;
    assembly {
      adm := sload(slot)
    }
  }

  
  function _setAdmin(address newAdmin) internal {
    bytes32 slot = ADMIN_SLOT;

    assembly {
      sstore(slot, newAdmin)
    }
  }

  
  function _willFallback() internal {
    require(msg.sender != _admin(), "Cannot call fallback function from the proxy admin");
    super._willFallback();
  }
}

contract InitializableUpgradeabilityProxy is BaseUpgradeabilityProxy {
  
  function initialize(address _logic, bytes memory _data) public payable {
    require(_implementation() == address(0));
    assert(IMPLEMENTATION_SLOT == bytes32(uint256(keccak256('eip1967.proxy.implementation')) - 1));
    _setImplementation(_logic);
    if(_data.length > 0) {
      (bool success,) = _logic.delegatecall(_data);
      require(success);
    }
  }  
}

contract InitializableAdminUpgradeabilityProxy is BaseAdminUpgradeabilityProxy, InitializableUpgradeabilityProxy {
  
  function initialize(address _logic, address _admin, bytes memory _data) public payable {
    require(_implementation() == address(0));
    InitializableUpgradeabilityProxy.initialize(_logic, _data);
    assert(ADMIN_SLOT == bytes32(uint256(keccak256('eip1967.proxy.admin')) - 1));
    _setAdmin(_admin);
  }
}

contract Context is Initializable {
    
    
    constructor () internal { }
    

    function _msgSender() internal view returns (address payable) {
        return msg.sender;
    }

    function _msgData() internal view returns (bytes memory) {
        this; 
        return msg.data;
    }
}

contract Ownable is Initializable, Context {
    address private _owner;

    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);

    
    function initialize(address sender) public initializer {
        _owner = sender;
        emit OwnershipTransferred(address(0), _owner);
    }

    
    function owner() public view returns (address) {
        return _owner;
    }

    
    modifier onlyOwner() {
        require(isOwner(), "Ownable: caller is not the owner");
        _;
    }

    
    function isOwner() public view returns (bool) {
        return _msgSender() == _owner;
    }

    
    function renounceOwnership() public onlyOwner {
        emit OwnershipTransferred(_owner, address(0));
        _owner = address(0);
    }

    
    function transferOwnership(address newOwner) public onlyOwner {
        _transferOwnership(newOwner);
    }

    
    function _transferOwnership(address newOwner) internal {
        require(newOwner != address(0), "Ownable: new owner is the zero address");
        emit OwnershipTransferred(_owner, newOwner);
        _owner = newOwner;
    }

    uint256[50] private ______gap;
}

contract Claimable is Initializable, Ownable {
    address public pendingOwner;

    function initialize(address _nextOwner) public initializer {
        Ownable.initialize(_nextOwner);
    }

    modifier onlyPendingOwner() {
        require(
            _msgSender() == pendingOwner,
            "Claimable: caller is not the pending owner"
        );
        _;
    }

    function transferOwnership(address newOwner) public onlyOwner {
        require(
            newOwner != owner() && newOwner != pendingOwner,
            "Claimable: invalid new owner"
        );
        pendingOwner = newOwner;
    }

    
    
    function _directTransferOwnership(address newOwner) public onlyOwner {
        _transferOwnership(newOwner);
    }

    function claimOwnership() public onlyPendingOwner {
        _transferOwnership(pendingOwner);
        delete pendingOwner;
    }
}

library String {
    
    
    function fromUint(uint256 _i) internal pure returns (string memory) {
        if (_i == 0) {
            return "0";
        }
        uint256 j = _i;
        uint256 len;
        while (j != 0) {
            len++;
            j /= 10;
        }
        bytes memory bstr = new bytes(len);
        uint256 k = len - 1;
        while (_i != 0) {
            bstr[k--] = bytes1(uint8(48 + (_i % 10)));
            _i /= 10;
        }
        return string(bstr);
    }

    
    function fromBytes32(bytes32 _value) internal pure returns (string memory) {
        bytes memory alphabet = "0123456789abcdef";

        bytes memory str = new bytes(32 * 2 + 2);
        str[0] = "0";
        str[1] = "x";
        for (uint256 i = 0; i < 32; i++) {
            str[2 + i * 2] = alphabet[uint256(uint8(_value[i] >> 4))];
            str[3 + i * 2] = alphabet[uint256(uint8(_value[i] & 0x0f))];
        }
        return string(str);
    }

    
    function fromAddress(address _addr) internal pure returns (string memory) {
        bytes32 value = bytes32(uint256(_addr));
        bytes memory alphabet = "0123456789abcdef";

        bytes memory str = new bytes(20 * 2 + 2);
        str[0] = "0";
        str[1] = "x";
        for (uint256 i = 0; i < 20; i++) {
            str[2 + i * 2] = alphabet[uint256(uint8(value[i + 12] >> 4))];
            str[3 + i * 2] = alphabet[uint256(uint8(value[i + 12] & 0x0f))];
        }
        return string(str);
    }

    
    function add8(
        string memory a,
        string memory b,
        string memory c,
        string memory d,
        string memory e,
        string memory f,
        string memory g,
        string memory h
    ) internal pure returns (string memory) {
        return string(abi.encodePacked(a, b, c, d, e, f, g, h));
    }
}

interface IERC20 {
    
    function totalSupply() external view returns (uint256);

    
    function balanceOf(address account) external view returns (uint256);

    
    function transfer(address recipient, uint256 amount) external returns (bool);

    
    function allowance(address owner, address spender) external view returns (uint256);

    
    function approve(address spender, uint256 amount) external returns (bool);

    
    function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);

    
    event Transfer(address indexed from, address indexed to, uint256 value);

    
    event Approval(address indexed owner, address indexed spender, uint256 value);
}

contract ERC20 is Initializable, Context, IERC20 {
    using SafeMath for uint256;

    mapping (address => uint256) private _balances;

    mapping (address => mapping (address => uint256)) private _allowances;

    uint256 private _totalSupply;

    
    function totalSupply() public view returns (uint256) {
        return _totalSupply;
    }

    
    function balanceOf(address account) public view returns (uint256) {
        return _balances[account];
    }

    
    function transfer(address recipient, uint256 amount) public returns (bool) {
        _transfer(_msgSender(), recipient, amount);
        return true;
    }

    
    function allowance(address owner, address spender) public view returns (uint256) {
        return _allowances[owner][spender];
    }

    
    function approve(address spender, uint256 amount) public returns (bool) {
        _approve(_msgSender(), spender, amount);
        return true;
    }

    
    function transferFrom(address sender, address recipient, uint256 amount) public returns (bool) {
        _transfer(sender, recipient, amount);
        _approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
        return true;
    }

    
    function increaseAllowance(address spender, uint256 addedValue) public returns (bool) {
        _approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
        return true;
    }

    
    function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) {
        _approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
        return true;
    }

    
    function _transfer(address sender, address recipient, uint256 amount) internal {
        require(sender != address(0), "ERC20: transfer from the zero address");
        require(recipient != address(0), "ERC20: transfer to the zero address");

        _balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
        _balances[recipient] = _balances[recipient].add(amount);
        emit Transfer(sender, recipient, amount);
    }

    
    function _mint(address account, uint256 amount) internal {
        require(account != address(0), "ERC20: mint to the zero address");

        _totalSupply = _totalSupply.add(amount);
        _balances[account] = _balances[account].add(amount);
        emit Transfer(address(0), account, amount);
    }

    
    function _burn(address account, uint256 amount) internal {
        require(account != address(0), "ERC20: burn from the zero address");

        _balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance");
        _totalSupply = _totalSupply.sub(amount);
        emit Transfer(account, address(0), amount);
    }

    
    function _approve(address owner, address spender, uint256 amount) internal {
        require(owner != address(0), "ERC20: approve from the zero address");
        require(spender != address(0), "ERC20: approve to the zero address");

        _allowances[owner][spender] = amount;
        emit Approval(owner, spender, amount);
    }

    
    function _burnFrom(address account, uint256 amount) internal {
        _burn(account, amount);
        _approve(account, _msgSender(), _allowances[account][_msgSender()].sub(amount, "ERC20: burn amount exceeds allowance"));
    }

    uint256[50] private ______gap;
}

contract ERC20Detailed is Initializable, IERC20 {
    string private _name;
    string internal _symbol;
    uint8 private _decimals;

    
    function initialize(string memory name, string memory symbol, uint8 decimals) public initializer {
        _name = name;
        _symbol = symbol;
        _decimals = decimals;
    }

    
    function name() public view returns (string memory) {
        return _name;
    }

    
    function symbol() public view returns (string memory) {
        return _symbol;
    }

    
    function decimals() public view returns (uint8) {
        return _decimals;
    }

    uint256[50] private ______gap;
}

library Address {
    
    function isContract(address account) internal view returns (bool) {
        
        
        
        bytes32 codehash;
        bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
        
        assembly { codehash := extcodehash(account) }
        return (codehash != accountHash && codehash != 0x0);
    }

    
    function toPayable(address account) internal pure returns (address payable) {
        return address(uint160(account));
    }

    
    function sendValue(address payable recipient, uint256 amount) internal {
        require(address(this).balance >= amount, "Address: insufficient balance");

        
        (bool success, ) = recipient.call.value(amount)("");
        require(success, "Address: unable to send value, recipient may have reverted");
    }
}

library SafeERC20 {
    using SafeMath for uint256;
    using Address for address;

    function safeTransfer(IERC20 token, address to, uint256 value) internal {
        callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
    }

    function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
        callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
    }

    function safeApprove(IERC20 token, address spender, uint256 value) internal {
        
        
        
        
        require((value == 0) || (token.allowance(address(this), spender) == 0),
            "SafeERC20: approve from non-zero to non-zero allowance"
        );
        callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
    }

    function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
        uint256 newAllowance = token.allowance(address(this), spender).add(value);
        callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
    }

    function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
        uint256 newAllowance = token.allowance(address(this), spender).sub(value, "SafeERC20: decreased allowance below zero");
        callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
    }

    
    function callOptionalReturn(IERC20 token, bytes memory data) private {
        
        

        
        
        
        
        
        require(address(token).isContract(), "SafeERC20: call to non-contract");

        
        (bool success, bytes memory returndata) = address(token).call(data);
        require(success, "SafeERC20: low-level call failed");

        if (returndata.length > 0) { 
            
            require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
        }
    }
}

contract CanReclaimTokens is Claimable {
    using SafeERC20 for ERC20;

    mapping(address => bool) private recoverableTokensBlacklist;

    function initialize(address _nextOwner) public initializer {
        Claimable.initialize(_nextOwner);
    }

    function blacklistRecoverableToken(address _token) public onlyOwner {
        recoverableTokensBlacklist[_token] = true;
    }

    
    
    function recoverTokens(address _token) external onlyOwner {
        require(
            !recoverableTokensBlacklist[_token],
            "CanReclaimTokens: token is not recoverable"
        );

        if (_token == address(0x0)) {
            msg.sender.transfer(address(this).balance);
        } else {
            ERC20(_token).safeTransfer(
                msg.sender,
                ERC20(_token).balanceOf(address(this))
            );
        }
    }
}

contract ERC20WithRate is Initializable, Ownable, ERC20 {
    using SafeMath for uint256;

    uint256 public constant _rateScale = 1e18;
    uint256 internal _rate;

    event LogRateChanged(uint256 indexed _rate);

    
    function initialize(address _nextOwner, uint256 _initialRate)
        public
        initializer
    {
        Ownable.initialize(_nextOwner);
        _setRate(_initialRate);
    }

    function setExchangeRate(uint256 _nextRate) public onlyOwner {
        _setRate(_nextRate);
    }

    function exchangeRateCurrent() public view returns (uint256) {
        require(_rate != 0, "ERC20WithRate: rate has not been initialized");
        return _rate;
    }

    function _setRate(uint256 _nextRate) internal {
        require(_nextRate > 0, "ERC20WithRate: rate must be greater than zero");
        _rate = _nextRate;
    }

    function balanceOfUnderlying(address _account)
        public
        view
        returns (uint256)
    {
        return toUnderlying(balanceOf(_account));
    }

    function toUnderlying(uint256 _amount) public view returns (uint256) {
        return _amount.mul(_rate).div(_rateScale);
    }

    function fromUnderlying(uint256 _amountUnderlying)
        public
        view
        returns (uint256)
    {
        return _amountUnderlying.mul(_rateScale).div(_rate);
    }
}

contract ERC20WithPermit is Initializable, ERC20, ERC20Detailed {
    using SafeMath for uint256;

    mapping(address => uint256) public nonces;

    
    
    string public version;

    
    bytes32 public DOMAIN_SEPARATOR;
    
    
    bytes32 public constant PERMIT_TYPEHASH =
        0xea2aa0a1be11a07ed86d755c93467f4f82362b452371d1ba94d1715123511acb;

    function initialize(
        uint256 _chainId,
        string memory _version,
        string memory _name,
        string memory _symbol,
        uint8 _decimals
    ) public initializer {
        ERC20Detailed.initialize(_name, _symbol, _decimals);
        version = _version;
        DOMAIN_SEPARATOR = keccak256(
            abi.encode(
                keccak256(
                    "EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)"
                ),
                keccak256(bytes(name())),
                keccak256(bytes(version)),
                _chainId,
                address(this)
            )
        );
    }

    
    function permit(
        address holder,
        address spender,
        uint256 nonce,
        uint256 expiry,
        bool allowed,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) external {
        bytes32 digest =
            keccak256(
                abi.encodePacked(
                    "\x19\x01",
                    DOMAIN_SEPARATOR,
                    keccak256(
                        abi.encode(
                            PERMIT_TYPEHASH,
                            holder,
                            spender,
                            nonce,
                            expiry,
                            allowed
                        )
                    )
                )
            );

        require(holder != address(0), "ERC20WithRate: address must not be 0x0");
        require(
            holder == ecrecover(digest, v, r, s),
            "ERC20WithRate: invalid signature"
        );
        require(
            expiry == 0 || now <= expiry,
            "ERC20WithRate: permit has expired"
        );
        require(nonce == nonces[holder]++, "ERC20WithRate: invalid nonce");
        uint256 amount = allowed ? uint256(-1) : 0;
        _approve(holder, spender, amount);
    }
}

contract RenERC20LogicV1 is
    Initializable,
    ERC20,
    ERC20Detailed,
    ERC20WithRate,
    ERC20WithPermit,
    Claimable,
    CanReclaimTokens
{
    
    function initialize(
        uint256 _chainId,
        address _nextOwner,
        uint256 _initialRate,
        string memory _version,
        string memory _name,
        string memory _symbol,
        uint8 _decimals
    ) public initializer {
        ERC20Detailed.initialize(_name, _symbol, _decimals);
        ERC20WithRate.initialize(_nextOwner, _initialRate);
        ERC20WithPermit.initialize(
            _chainId,
            _version,
            _name,
            _symbol,
            _decimals
        );
        Claimable.initialize(_nextOwner);
        CanReclaimTokens.initialize(_nextOwner);
    }

    function updateSymbol(string memory symbol) public onlyOwner {
        ERC20Detailed._symbol = symbol;
    }

    
    
    function mint(address _to, uint256 _amount) public onlyOwner {
        _mint(_to, _amount);
    }

    
    
    function burn(address _from, uint256 _amount) public onlyOwner {
        _burn(_from, _amount);
    }

    function transfer(address recipient, uint256 amount) public returns (bool) {
        
        
        
        require(
            recipient != address(this),
            "RenERC20: can't transfer to token address"
        );
        return super.transfer(recipient, amount);
    }

    function transferFrom(
        address sender,
        address recipient,
        uint256 amount
    ) public returns (bool) {
        
        
        require(
            recipient != address(this),
            "RenERC20: can't transfer to token address"
        );
        return super.transferFrom(sender, recipient, amount);
    }
}

contract RenERC20Proxy is InitializableAdminUpgradeabilityProxy {

}

interface IMintGateway {
    function mint(
        bytes32 _pHash,
        uint256 _amount,
        bytes32 _nHash,
        bytes calldata _sig
    ) external returns (uint256);

    function mintFee() external view returns (uint256);
}

interface IBurnGateway {
    function burn(bytes calldata _to, uint256 _amountScaled)
        external
        returns (uint256);

    function burnFee() external view returns (uint256);
}

interface IGateway {
    
    function mint(
        bytes32 _pHash,
        uint256 _amount,
        bytes32 _nHash,
        bytes calldata _sig
    ) external returns (uint256);

    function mintFee() external view returns (uint256);

    
    function burn(bytes calldata _to, uint256 _amountScaled)
        external
        returns (uint256);

    function burnFee() external view returns (uint256);
}

contract MintGatewayStateV1 {
    uint256 constant BIPS_DENOMINATOR = 10000;
    uint256 public minimumBurnAmount;

    
    RenERC20LogicV1 public token;

    
    address public mintAuthority;

    
    
    
    
    address public feeRecipient;

    
    uint16 public mintFee;

    
    uint16 public burnFee;

    
    mapping(bytes32 => bool) public status;

    
    
    uint256 public nextN = 0;
}

contract MintGatewayLogicV1 is
    Initializable,
    Claimable,
    CanReclaimTokens,
    IGateway,
    MintGatewayStateV1
{
    using SafeMath for uint256;

    event LogMintAuthorityUpdated(address indexed _newMintAuthority);
    event LogMint(
        address indexed _to,
        uint256 _amount,
        uint256 indexed _n,
        bytes32 indexed _signedMessageHash
    );
    event LogBurn(
        bytes _to,
        uint256 _amount,
        uint256 indexed _n,
        bytes indexed _indexedTo
    );

    
    modifier onlyOwnerOrMintAuthority() {
        require(
            msg.sender == mintAuthority || msg.sender == owner(),
            "Gateway: caller is not the owner or mint authority"
        );
        _;
    }

    
    
    
    
    
    
    
    
    function initialize(
        RenERC20LogicV1 _token,
        address _feeRecipient,
        address _mintAuthority,
        uint16 _mintFee,
        uint16 _burnFee,
        uint256 _minimumBurnAmount
    ) public initializer {
        Claimable.initialize(msg.sender);
        CanReclaimTokens.initialize(msg.sender);
        minimumBurnAmount = _minimumBurnAmount;
        token = _token;
        mintFee = _mintFee;
        burnFee = _burnFee;
        updateMintAuthority(_mintAuthority);
        updateFeeRecipient(_feeRecipient);
    }

    

    
    
    
    function claimTokenOwnership() public {
        token.claimOwnership();
    }

    
    function transferTokenOwnership(MintGatewayLogicV1 _nextTokenOwner)
        public
        onlyOwner
    {
        token.transferOwnership(address(_nextTokenOwner));
        _nextTokenOwner.claimTokenOwnership();
    }

    
    
    
    function updateMintAuthority(address _nextMintAuthority)
        public
        onlyOwnerOrMintAuthority
    {
        
        
        require(
            _nextMintAuthority != address(0),
            "Gateway: mintAuthority cannot be set to address zero"
        );
        mintAuthority = _nextMintAuthority;
        emit LogMintAuthorityUpdated(mintAuthority);
    }

    
    
    
    function updateMinimumBurnAmount(uint256 _minimumBurnAmount)
        public
        onlyOwner
    {
        minimumBurnAmount = _minimumBurnAmount;
    }

    
    
    
    function updateFeeRecipient(address _nextFeeRecipient) public onlyOwner {
        
        require(
            _nextFeeRecipient != address(0x0),
            "Gateway: fee recipient cannot be 0x0"
        );

        feeRecipient = _nextFeeRecipient;
    }

    
    
    
    function updateMintFee(uint16 _nextMintFee) public onlyOwner {
        mintFee = _nextMintFee;
    }

    
    
    
    function updateBurnFee(uint16 _nextBurnFee) public onlyOwner {
        burnFee = _nextBurnFee;
    }

    
    
    
    
    
    
    
    
    
    
    function mint(
        bytes32 _pHash,
        uint256 _amountUnderlying,
        bytes32 _nHash,
        bytes memory _sig
    ) public returns (uint256) {
        
        bytes32 sigHash =
            hashForSignature(_pHash, _amountUnderlying, msg.sender, _nHash);

        

        
        require(status[sigHash] == false, "Gateway: nonce hash already spent");

        
        
        if (!verifySignature(sigHash, _sig)) {
            
            
            
            revert(
                String.add8(
                    "Gateway: invalid signature. pHash: ",
                    String.fromBytes32(_pHash),
                    ", amount: ",
                    String.fromUint(_amountUnderlying),
                    ", msg.sender: ",
                    String.fromAddress(msg.sender),
                    ", _nHash: ",
                    String.fromBytes32(_nHash)
                )
            );
        }

        
        
        status[sigHash] = true;

        uint256 amountScaled = token.fromUnderlying(_amountUnderlying);

        
        uint256 absoluteFeeScaled =
            amountScaled.mul(mintFee).div(BIPS_DENOMINATOR);
        uint256 receivedAmountScaled =
            amountScaled.sub(absoluteFeeScaled, "Gateway: fee exceeds amount");

        
        token.mint(msg.sender, receivedAmountScaled);
        
        token.mint(feeRecipient, absoluteFeeScaled);

        
        uint256 receivedAmountUnderlying =
            token.toUnderlying(receivedAmountScaled);
        emit LogMint(msg.sender, receivedAmountUnderlying, nextN, sigHash);
        nextN += 1;

        return receivedAmountScaled;
    }

    
    
    
    
    
    
    
    
    
    
    function burn(bytes memory _to, uint256 _amount) public returns (uint256) {
        
        
        require(_to.length != 0, "Gateway: to address is empty");

        
        uint256 fee = _amount.mul(burnFee).div(BIPS_DENOMINATOR);
        uint256 amountAfterFee =
            _amount.sub(fee, "Gateway: fee exceeds amount");

        
        
        
        uint256 amountAfterFeeUnderlying = token.toUnderlying(amountAfterFee);

        
        token.burn(msg.sender, _amount);
        token.mint(feeRecipient, fee);

        require(
            
            
            amountAfterFeeUnderlying > minimumBurnAmount,
            "Gateway: amount is less than the minimum burn amount"
        );

        emit LogBurn(_to, amountAfterFeeUnderlying, nextN, _to);
        nextN += 1;

        return amountAfterFeeUnderlying;
    }

    
    
    function verifySignature(bytes32 _sigHash, bytes memory _sig)
        public
        view
        returns (bool)
    {
        return mintAuthority == ECDSA.recover(_sigHash, _sig);
    }

    
    
    function hashForSignature(
        bytes32 _pHash,
        uint256 _amount,
        address _to,
        bytes32 _nHash
    ) public view returns (bytes32) {
        return
            keccak256(abi.encode(_pHash, _amount, address(token), _to, _nHash));
    }
}

contract BTCGateway is InitializableAdminUpgradeabilityProxy {}

contract ZECGateway is InitializableAdminUpgradeabilityProxy {}

contract BCHGateway is InitializableAdminUpgradeabilityProxy {}

contract MintGatewayStateV2 {
    struct Burn {
        uint256 _blocknumber;
        bytes _to;
        uint256 _amount;
        
        string _chain;
        bytes _payload;
    }

    mapping(uint256 => Burn) internal burns;

    bytes32 public selectorHash;

    
    
    address public _legacy_mintAuthority;
}

contract MintGatewayLogicV2 is
    Initializable,
    Claimable,
    CanReclaimTokens,
    IGateway,
    MintGatewayStateV1,
    MintGatewayStateV2
{
    using SafeMath for uint256;

    event LogMintAuthorityUpdated(address indexed _newMintAuthority);
    event LogMint(
        address indexed _to,
        uint256 _amount,
        uint256 indexed _n,
        
        
        bytes32 indexed _nHash
    );
    event LogBurn(
        bytes _to,
        uint256 _amount,
        uint256 indexed _n,
        bytes indexed _indexedTo
    );

    
    modifier onlyOwnerOrMintAuthority() {
        require(
            msg.sender == mintAuthority || msg.sender == owner(),
            "MintGateway: caller is not the owner or mint authority"
        );
        _;
    }

    
    
    
    
    
    
    
    
    function initialize(
        RenERC20LogicV1 _token,
        address _feeRecipient,
        address _mintAuthority,
        uint16 _mintFee,
        uint16 _burnFee,
        uint256 _minimumBurnAmount
    ) public initializer {
        Claimable.initialize(msg.sender);
        CanReclaimTokens.initialize(msg.sender);
        minimumBurnAmount = _minimumBurnAmount;
        token = _token;
        mintFee = _mintFee;
        burnFee = _burnFee;
        updateMintAuthority(_mintAuthority);
        updateFeeRecipient(_feeRecipient);
    }

    
    
    
    function updateSelectorHash(bytes32 _selectorHash) public onlyOwner {
        selectorHash = _selectorHash;
    }

    
    function updateSymbol(string memory symbol) public onlyOwner {
        token.updateSymbol(symbol);
    }

    

    
    
    
    function claimTokenOwnership() public {
        token.claimOwnership();
    }

    
    function transferTokenOwnership(MintGatewayLogicV2 _nextTokenOwner)
        public
        onlyOwner
    {
        token.transferOwnership(address(_nextTokenOwner));
        _nextTokenOwner.claimTokenOwnership();
    }

    
    
    
    function updateMintAuthority(address _nextMintAuthority)
        public
        onlyOwnerOrMintAuthority
    {
        
        
        require(
            _nextMintAuthority != address(0),
            "MintGateway: mintAuthority cannot be set to address zero"
        );
        mintAuthority = _nextMintAuthority;
        emit LogMintAuthorityUpdated(mintAuthority);
    }

    
    
    
    function _legacy_updateMintAuthority(address _nextMintAuthority)
        public
        onlyOwner
    {
        _legacy_mintAuthority = _nextMintAuthority;
    }

    
    
    
    function updateMinimumBurnAmount(uint256 _minimumBurnAmount)
        public
        onlyOwner
    {
        minimumBurnAmount = _minimumBurnAmount;
    }

    
    
    
    function updateFeeRecipient(address _nextFeeRecipient) public onlyOwner {
        
        require(
            _nextFeeRecipient != address(0x0),
            "MintGateway: fee recipient cannot be 0x0"
        );

        feeRecipient = _nextFeeRecipient;
    }

    
    
    
    function updateMintFee(uint16 _nextMintFee) public onlyOwner {
        mintFee = _nextMintFee;
    }

    
    
    
    function updateBurnFee(uint16 _nextBurnFee) public onlyOwner {
        burnFee = _nextBurnFee;
    }

    
    
    
    
    
    
    
    
    
    
    function mint(
        bytes32 _pHash,
        uint256 _amountUnderlying,
        bytes32 _nHash,
        bytes memory _sig
    ) public returns (uint256) {
        
        bytes32 sigHash =
            hashForSignature(_pHash, _amountUnderlying, msg.sender, _nHash);

        
        bytes32 legacySigHash =
            _legacy_hashForSignature(
                _pHash,
                _amountUnderlying,
                msg.sender,
                _nHash
            );

        
        require(
            status[sigHash] == false && status[legacySigHash] == false,
            "MintGateway: nonce hash already spent"
        );

        
        
        if (
            !verifySignature(sigHash, _sig) &&
            !_legacy_verifySignature(legacySigHash, _sig)
        ) {
            
            
            
            revert(
                String.add8(
                    "MintGateway: invalid signature. pHash: ",
                    String.fromBytes32(_pHash),
                    ", amount: ",
                    String.fromUint(_amountUnderlying),
                    ", msg.sender: ",
                    String.fromAddress(msg.sender),
                    ", _nHash: ",
                    String.fromBytes32(_nHash)
                )
            );
        }

        
        
        
        
        status[sigHash] = true;
        status[legacySigHash] = true;

        uint256 amountScaled = token.fromUnderlying(_amountUnderlying);

        
        uint256 absoluteFeeScaled =
            amountScaled.mul(mintFee).div(BIPS_DENOMINATOR);
        uint256 receivedAmountScaled =
            amountScaled.sub(
                absoluteFeeScaled,
                "MintGateway: fee exceeds amount"
            );

        
        token.mint(msg.sender, receivedAmountScaled);
        
        if (absoluteFeeScaled > 0) {
            token.mint(feeRecipient, absoluteFeeScaled);
        }

        
        uint256 receivedAmountUnderlying =
            token.toUnderlying(receivedAmountScaled);
        emit LogMint(msg.sender, receivedAmountUnderlying, nextN, _nHash);
        nextN += 1;

        return receivedAmountScaled;
    }

    
    
    
    
    
    
    
    
    
    
    function burn(bytes memory _to, uint256 _amount) public returns (uint256) {
        
        
        require(_to.length != 0, "MintGateway: to address is empty");

        
        uint256 fee = _amount.mul(burnFee).div(BIPS_DENOMINATOR);
        uint256 amountAfterFee =
            _amount.sub(fee, "MintGateway: fee exceeds amount");

        
        
        
        uint256 amountAfterFeeUnderlying = token.toUnderlying(amountAfterFee);

        
        token.burn(msg.sender, _amount);
        if (fee > 0) {
            token.mint(feeRecipient, fee);
        }

        require(
            
            
            amountAfterFeeUnderlying > minimumBurnAmount,
            "MintGateway: amount is less than the minimum burn amount"
        );

        emit LogBurn(_to, amountAfterFeeUnderlying, nextN, _to);

        
        
        bytes memory payload;
        MintGatewayStateV2.burns[nextN] = Burn({
            _blocknumber: block.number,
            _to: _to,
            _amount: amountAfterFeeUnderlying,
            _chain: "",
            _payload: payload
        });

        nextN += 1;

        return amountAfterFeeUnderlying;
    }

    function getBurn(uint256 _n)
        public
        view
        returns (
            uint256 _blocknumber,
            bytes memory _to,
            uint256 _amount,
            
            string memory _chain,
            bytes memory _payload
        )
    {
        Burn memory burnStruct = MintGatewayStateV2.burns[_n];
        require(burnStruct._to.length > 0, "MintGateway: burn not found");
        return (
            burnStruct._blocknumber,
            burnStruct._to,
            burnStruct._amount,
            burnStruct._chain,
            burnStruct._payload
        );
    }

    
    
    function verifySignature(bytes32 _sigHash, bytes memory _sig)
        public
        view
        returns (bool)
    {
        return mintAuthority == ECDSA.recover(_sigHash, _sig);
    }

    
    
    function _legacy_verifySignature(bytes32 _sigHash, bytes memory _sig)
        public
        view
        returns (bool)
    {
        require(
            _legacy_mintAuthority != address(0x0),
            "MintGateway: legacy mintAuthority not set"
        );
        return _legacy_mintAuthority == ECDSA.recover(_sigHash, _sig);
    }

    
    
    function hashForSignature(
        bytes32 _pHash,
        uint256 _amount,
        address _to,
        bytes32 _nHash
    ) public view returns (bytes32) {
        return
            keccak256(abi.encode(_pHash, _amount, selectorHash, _to, _nHash));
    }

    
    
    function _legacy_hashForSignature(
        bytes32 _pHash,
        uint256 _amount,
        address _to,
        bytes32 _nHash
    ) public view returns (bytes32) {
        return
            keccak256(abi.encode(_pHash, _amount, address(token), _to, _nHash));
    }
}

contract MintGatewayProxy is InitializableAdminUpgradeabilityProxy {

}

Contract ABI

[{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"previousAdmin","type":"address"},{"indexed":false,"internalType":"address","name":"newAdmin","type":"address"}],"name":"AdminChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"implementation","type":"address"}],"name":"Upgraded","type":"event"},{"payable":true,"stateMutability":"payable","type":"fallback"},{"constant":false,"inputs":[],"name":"admin","outputs":[{"internalType":"address","name":"","type":"address"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"internalType":"address","name":"newAdmin","type":"address"}],"name":"changeAdmin","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[],"name":"implementation","outputs":[{"internalType":"address","name":"","type":"address"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"internalType":"address","name":"_logic","type":"address"},{"internalType":"address","name":"_admin","type":"address"},{"internalType":"bytes","name":"_data","type":"bytes"}],"name":"initialize","outputs":[],"payable":true,"stateMutability":"payable","type":"function"},{"constant":false,"inputs":[{"internalType":"address","name":"_logic","type":"address"},{"internalType":"bytes","name":"_data","type":"bytes"}],"name":"initialize","outputs":[],"payable":true,"stateMutability":"payable","type":"function"},{"constant":false,"inputs":[{"internalType":"address","name":"newImplementation","type":"address"}],"name":"upgradeTo","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"internalType":"address","name":"newImplementation","type":"address"},{"internalType":"bytes","name":"data","type":"bytes"}],"name":"upgradeToAndCall","outputs":[],"payable":true,"stateMutability":"payable","type":"function"}]

608060405234801561001057600080fd5b5061097c806100206000396000f3fe6080604052600436106100705760003560e01c80638f2839701161004e5780638f2839701461015e578063cf7a1d7714610191578063d1f5789414610250578063f851a4401461030657610070565b80633659cfe61461007a5780634f1ef286146100ad5780635c60da1b1461012d575b61007861031b565b005b34801561008657600080fd5b506100786004803603602081101561009d57600080fd5b50356001600160a01b0316610335565b610078600480360360408110156100c357600080fd5b6001600160a01b0382351691908101906040810160208201356401000000008111156100ee57600080fd5b82018360208201111561010057600080fd5b8035906020019184600183028401116401000000008311171561012257600080fd5b50909250905061036f565b34801561013957600080fd5b5061014261041c565b604080516001600160a01b039092168252519081900360200190f35b34801561016a57600080fd5b506100786004803603602081101561018157600080fd5b50356001600160a01b0316610459565b610078600480360360608110156101a757600080fd5b6001600160a01b0382358116926020810135909116918101906060810160408201356401000000008111156101db57600080fd5b8201836020820111156101ed57600080fd5b8035906020019184600183028401116401000000008311171561020f57600080fd5b91908080601f016020809104026020016040519081016040528093929190818152602001838380828437600092019190915250929550610513945050505050565b6100786004803603604081101561026657600080fd5b6001600160a01b03823516919081019060408101602082013564010000000081111561029157600080fd5b8201836020820111156102a357600080fd5b803590602001918460018302840111640100000000831117156102c557600080fd5b91908080601f016020809104026020016040519081016040528093929190818152602001838380828437600092019190915250929550610599945050505050565b34801561031257600080fd5b506101426106d9565b610323610704565b61033361032e610764565b610789565b565b61033d6107ad565b6001600160a01b0316336001600160a01b031614156103645761035f816107d2565b61036c565b61036c61031b565b50565b6103776107ad565b6001600160a01b0316336001600160a01b0316141561040f57610399836107d2565b6000836001600160a01b031683836040518083838082843760405192019450600093509091505080830381855af49150503d80600081146103f6576040519150601f19603f3d011682016040523d82523d6000602084013e6103fb565b606091505b505090508061040957600080fd5b50610417565b61041761031b565b505050565b60006104266107ad565b6001600160a01b0316336001600160a01b0316141561044e57610447610764565b9050610456565b61045661031b565b90565b6104616107ad565b6001600160a01b0316336001600160a01b03161415610364576001600160a01b0381166104bf5760405162461bcd60e51b81526004018080602001828103825260368152602001806108d76036913960400191505060405180910390fd5b7f7e644d79422f17c01e4894b5f4f588d331ebfa28653d42ae832dc59e38c9798f6104e86107ad565b604080516001600160a01b03928316815291841660208301528051918290030190a161035f81610812565b600061051d610764565b6001600160a01b03161461053057600080fd5b61053a8382610599565b604080517232b4b8189c9b1b97383937bc3c9730b236b4b760691b815290519081900360130190207fb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d61036000199091011461059057fe5b61041782610812565b60006105a3610764565b6001600160a01b0316146105b657600080fd5b604080517f656970313936372e70726f78792e696d706c656d656e746174696f6e000000008152905190819003601c0190207f360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc6000199091011461061657fe5b61061f82610836565b8051156106d5576000826001600160a01b0316826040518082805190602001908083835b602083106106625780518252601f199092019160209182019101610643565b6001836020036101000a038019825116818451168082178552505050505050905001915050600060405180830381855af49150503d80600081146106c2576040519150601f19603f3d011682016040523d82523d6000602084013e6106c7565b606091505b505090508061041757600080fd5b5050565b60006106e36107ad565b6001600160a01b0316336001600160a01b0316141561044e576104476107ad565b61070c6107ad565b6001600160a01b0316336001600160a01b0316141561075c5760405162461bcd60e51b81526004018080602001828103825260328152602001806108a56032913960400191505060405180910390fd5b610333610333565b7f360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc5490565b3660008037600080366000845af43d6000803e8080156107a8573d6000f35b3d6000fd5b7fb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d61035490565b6107db81610836565b6040516001600160a01b038216907fbc7cd75a20ee27fd9adebab32041f755214dbc6bffa90cc0225b39da2e5c2d3b90600090a250565b7fb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d610355565b61083f8161089e565b61087a5760405162461bcd60e51b815260040180806020018281038252603b81526020018061090d603b913960400191505060405180910390fd5b7f360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc55565b3b15159056fe43616e6e6f742063616c6c2066616c6c6261636b2066756e6374696f6e2066726f6d207468652070726f78792061646d696e43616e6e6f74206368616e6765207468652061646d696e206f6620612070726f787920746f20746865207a65726f206164647265737343616e6e6f742073657420612070726f787920696d706c656d656e746174696f6e20746f2061206e6f6e2d636f6e74726163742061646472657373a265627a7a723158207b2776c174786ccfb25b02628640b840274eefce03ef1af0a0a70d0f87f175f764736f6c63430005110032

Deployed Bytecode

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

Deployed ByteCode Sourcemap

35156:63:0:-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;3994:11;:9;:11::i;:::-;35156:63;7053:105;;8:9:-1;5:2;;;30:1;27;20:12;5:2;7053:105:0;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;7053:105:0;-1:-1:-1;;;;;7053:105:0;;:::i;7168:225::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;;;;;7168:225:0;;;;;;;;;;;;;;;21:11:-1;5:28;;2:2;;;46:1;43;36:12;2:2;7168:225:0;;35:9:-1;28:4;12:14;8:25;5:40;2:2;;;58:1;55;48:12;2:2;7168:225:0;;;;;;100:9:-1;95:1;81:12;77:20;67:8;63:35;60:50;39:11;25:12;22:29;11:107;8:2;;;131:1;128;121:12;8:2;-1:-1;7168:225:0;;-1:-1:-1;7168:225:0;-1:-1:-1;7168:225:0;:::i;6707:98::-;;8:9:-1;5:2;;;30:1;27;20:12;5:2;6707:98:0;;;:::i;:::-;;;;-1:-1:-1;;;;;6707:98:0;;;;;;;;;;;;;;6815:228;;8:9:-1;5:2;;;30:1;27;20:12;5:2;6815:228:0;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;6815:228:0;-1:-1:-1;;;;;6815:228:0;;:::i;8450:312::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;;;;;8450:312:0;;;;;;;;;;;;;;;;;;;;;;;21:11:-1;5:28;;2:2;;;46:1;43;36:12;2:2;8450:312:0;;35:9:-1;28:4;12:14;8:25;5:40;2:2;;;58:1;55;48:12;2:2;8450:312:0;;;;;;100:9:-1;95:1;81:12;77:20;67:8;63:35;60:50;39:11;25:12;22:29;11:107;8:2;;;131:1;128;121:12;8:2;8450:312:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;30:3:-1;22:6;14;1:33;99:1;81:16;;74:27;;;;-1:-1;8450:312:0;;-1:-1:-1;8450:312:0;;-1:-1:-1;;;;;8450:312:0:i;7948:371::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;;;;;7948:371:0;;;;;;;;;;;;;;;21:11:-1;5:28;;2:2;;;46:1;43;36:12;2:2;7948:371:0;;35:9:-1;28:4;12:14;8:25;5:40;2:2;;;58:1;55;48:12;2:2;7948:371:0;;;;;;100:9:-1;95:1;81:12;77:20;67:8;63:35;60:50;39:11;25:12;22:29;11:107;8:2;;;131:1;128;121:12;8:2;7948:371:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;30:3:-1;22:6;14;1:33;99:1;81:16;;74:27;;;;-1:-1;7948:371:0;;-1:-1:-1;7948:371:0;;-1:-1:-1;;;;;7948:371:0:i;6617:80::-;;8:9:-1;5:2;;;30:1;27;20:12;5:2;6617:80:0;;;:::i;4565:93::-;4602:15;:13;:15::i;:::-;4624:28;4634:17;:15;:17::i;:::-;4624:9;:28::i;:::-;4565:93::o;7053:105::-;6540:8;:6;:8::i;:::-;-1:-1:-1;;;;;6526:22:0;:10;-1:-1:-1;;;;;6526:22:0;;6522:80;;;7123:29;7134:17;7123:10;:29::i;:::-;6522:80;;;6583:11;:9;:11::i;:::-;7053:105;:::o;7168:225::-;6540:8;:6;:8::i;:::-;-1:-1:-1;;;;;6526:22:0;:10;-1:-1:-1;;;;;6526:22:0;;6522:80;;;7274:29;7285:17;7274:10;:29::i;:::-;7311:12;7328:17;-1:-1:-1;;;;;7328:30:0;7359:4;;7328:36;;;;;30:3:-1;22:6;14;1:33;7328:36:0;;45:16:-1;;;-1:-1;7328:36:0;;-1:-1:-1;7328:36:0;;-1:-1:-1;;7328:36:0;;;;;;;;;;;14:1:-1;21;16:31;;;;75:4;69:11;64:16;;144:4;140:9;133:4;115:16;111:27;107:43;104:1;100:51;94:4;87:65;169:16;166:1;159:27;225:16;222:1;215:4;212:1;208:12;193:49;7:242;;16:31;36:4;31:9;;7:242;;7310:54:0;;;7379:7;7371:16;;;;;;6559:1;6522:80;;;6583:11;:9;:11::i;:::-;7168:225;;;:::o;6707:98::-;6759:7;6540:8;:6;:8::i;:::-;-1:-1:-1;;;;;6526:22:0;:10;-1:-1:-1;;;;;6526:22:0;;6522:80;;;6782:17;:15;:17::i;:::-;6775:24;;6522:80;;;6583:11;:9;:11::i;:::-;6707:98;:::o;6815:228::-;6540:8;:6;:8::i;:::-;-1:-1:-1;;;;;6526:22:0;:10;-1:-1:-1;;;;;6526:22:0;;6522:80;;;-1:-1:-1;;;;;6886:22:0;;6878:89;;;;-1:-1:-1;;;6878:89:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6979:32;6992:8;:6;:8::i;:::-;6979:32;;;-1:-1:-1;;;;;6979:32:0;;;;;;;;;;;;;;;;;;;;;7018:19;7028:8;7018:9;:19::i;8450:312::-;8581:1;8552:17;:15;:17::i;:::-;-1:-1:-1;;;;;8552:31:0;;8544:40;;;;;;8591:58;8635:6;8643:5;8591:43;:58::i;:::-;8693:32;;;-1:-1:-1;;;8693:32:0;;;;;;;;;;;;6419:66;-1:-1:-1;;8685:45:0;;;8663:68;8656:76;;;;8739:17;8749:6;8739:9;:17::i;7948:371::-;8063:1;8034:17;:15;:17::i;:::-;-1:-1:-1;;;;;8034:31:0;;8026:40;;;;;;8119:41;;;;;;;;;;;;;;;;5121:66;-1:-1:-1;;8111:54:0;;;8080:86;8073:94;;;;8174:26;8193:6;8174:18;:26::i;:::-;8210:12;;:16;8207:107;;8238:12;8255:6;-1:-1:-1;;;;;8255:19:0;8275:5;8255:26;;;;;;;;;;;;;36:153:-1;66:2;61:3;58:11;36:153;;176:10;;164:23;;-1:-1;;139:12;;;;98:2;89:12;;;;114;36:153;;;274:1;267:3;263:2;259:12;254:3;250:22;246:30;315:4;311:9;305:3;299:10;295:26;356:4;350:3;344:10;340:21;389:7;380;377:20;372:3;365:33;3:399;;;8255:26:0;;;;;;;;;;;;;;;;;;;;;;;14:1:-1;21;16:31;;;;75:4;69:11;64:16;;144:4;140:9;133:4;115:16;111:27;107:43;104:1;100:51;94:4;87:65;169:16;166:1;159:27;225:16;222:1;215:4;212:1;208:12;193:49;7:242;;16:31;36:4;31:9;;7:242;;8237:44:0;;;8298:7;8290:16;;;;;8207:107;7948:371;;:::o;6617:80::-;6660:7;6540:8;:6;:8::i;:::-;-1:-1:-1;;;;;6526:22:0;:10;-1:-1:-1;;;;;6526:22:0;;6522:80;;;6683:8;:6;:8::i;7703:160::-;7766:8;:6;:8::i;:::-;-1:-1:-1;;;;;7752:22:0;:10;-1:-1:-1;;;;;7752:22:0;;;7744:85;;;;-1:-1:-1;;;7744:85:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;7836:21;:19;:21::i;5198:161::-;5121:66;5336:11;;5319:35::o;4090:415::-;4210:12;4207:1;4204;4191:32;4317:1;4314;4300:12;4297:1;4281:14;4276:3;4263:56;4358:14;4355:1;4352;4337:36;4390:6;4412:36;;;;4476:14;4473:1;4466:25;4412:36;4431:14;4428:1;4421:25;7403:141;6419:66;7521:11;;7505:34::o;5369:145::-;5432:37;5451:17;5432:18;:37::i;:::-;5481:27;;-1:-1:-1;;;;;5481:27:0;;;;;;;;5369:145;:::o;7554:139::-;6419:66;7659:22;7650:38::o;5524:313::-;5603:57;5642:17;5603:38;:57::i;:::-;5595:129;;;;-1:-1:-1;;;5595:129:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;5121:66;5794:31;5785:47::o;4714:244::-;4903:20;4942:8;;;4714:244::o

Metadata Hash

7b2776c174786ccfb25b02628640b840274eefce03ef1af0a0a70d0f87f175f7
Block Transaction Gas Used Reward
Age Block Fee Address BC Fee Address Voting Power Jailed Incoming
Block Uncle Number Difficulty Gas Used Reward
Loading
Make sure to use the "Vote Down" button for any spammy posts, and the "Vote Up" for interesting conversations.