Contract 0x2f7ac9436ba4b548f9582af91ca1ef02cd2f1f03 15
Contract Overview
My Name Tag:
Not Available
[ Download CSV Export ]
Latest 25 internal transaction
[ Download CSV Export ]
Contract Name:
LockProxy
Compiler Version
v0.5.17+commit.d19bba13
Contract Source Code (Solidity)
/** *Submitted for verification at Arbiscan.io on 2021-11-29 */ /** *Submitted for verification at snowtrace.io on 2021-11-17 */ /** *Submitted for verification at Etherscan.io on 2021-09-01 */ pragma solidity ^0.5.0; /* * @dev Provides information about the current execution context, including the * sender of the transaction and its data. While these are generally available * via msg.sender and msg.data, they should not be accessed in such a direct * manner, since when dealing with GSN meta-transactions the account sending and * paying for execution may not be the actual sender (as far as an application * is concerned). * * This contract is only required for intermediate, library-like contracts. * Refer from https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/GSN/Context.sol */ contract Context { // Empty internal constructor, to prevent people from mistakenly deploying // an instance of this contract, which should be used via inheritance. constructor () internal { } // solhint-disable-previous-line no-empty-blocks function _msgSender() internal view returns (address payable) { return msg.sender; } function _msgData() internal view returns (bytes memory) { this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691 return msg.data; } } pragma solidity ^0.5.0; /** * @dev Contract module which provides a basic access control mechanism, where * there is an account (an owner) that can be granted exclusive access to * specific functions. * * This module is used through inheritance. It will make available the modifier * `onlyOwner`, which can be applied to your functions to restrict their use to * the owner. */ contract Ownable is Context { address private _owner; event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); /** * @dev Initializes the contract setting the deployer as the initial owner. */ constructor () internal { address msgSender = _msgSender(); _owner = msgSender; emit OwnershipTransferred(address(0), msgSender); } /** * @dev Returns the address of the current owner. */ function owner() public view returns (address) { return _owner; } /** * @dev Throws if called by any account other than the owner. */ modifier onlyOwner() { require(isOwner(), "Ownable: caller is not the owner"); _; } /** * @dev Returns true if the caller is the current owner. */ function isOwner() public view returns (bool) { return _msgSender() == _owner; } /** * @dev Leaves the contract without owner. It will not be possible to call * `onlyOwner` functions anymore. Can only be called by the current owner. * * NOTE: Renouncing ownership will leave the contract without an owner, * thereby removing any functionality that is only available to the owner. */ function renounceOwnership() public onlyOwner { emit OwnershipTransferred(_owner, address(0)); _owner = address(0); } /** * @dev Transfers ownership of the contract to a new account (`newOwner`). * Can only be called by the current owner. */ function transferOwnership(address newOwner) public onlyOwner { _transferOwnership(newOwner); } /** * @dev Transfers ownership of the contract to a new account (`newOwner`). */ function _transferOwnership(address newOwner) internal { require(newOwner != address(0), "Ownable: new owner is the zero address"); emit OwnershipTransferred(_owner, newOwner); _owner = newOwner; } } pragma solidity ^0.5.0; /** * @dev Wrappers over Solidity's arithmetic operations with added overflow * checks. * * Arithmetic operations in Solidity wrap on overflow. This can easily result * in bugs, because programmers usually assume that an overflow raises an * error, which is the standard behavior in high level programming languages. * `SafeMath` restores this intuition by reverting the transaction when an * operation overflows. * * Using this library instead of the unchecked operations eliminates an entire * class of bugs, so it's recommended to use it always. */ library SafeMath { /** * @dev Returns the addition of two unsigned integers, reverting on * overflow. * * Counterpart to Solidity's `+` operator. * * Requirements: * - Addition cannot overflow. */ function add(uint256 a, uint256 b) internal pure returns (uint256) { uint256 c = a + b; require(c >= a, "SafeMath: addition overflow"); return c; } /** * @dev Returns the subtraction of two unsigned integers, reverting on * overflow (when the result is negative). * * Counterpart to Solidity's `-` operator. * * Requirements: * - Subtraction cannot overflow. */ function sub(uint256 a, uint256 b) internal pure returns (uint256) { return sub(a, b, "SafeMath: subtraction overflow"); } /** * @dev Returns the subtraction of two unsigned integers, reverting with custom message on * overflow (when the result is negative). * * Counterpart to Solidity's `-` operator. * * Requirements: * - Subtraction cannot overflow. * * _Available since v2.4.0._ */ function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) { require(b <= a, errorMessage); uint256 c = a - b; return c; } /** * @dev Returns the multiplication of two unsigned integers, reverting on * overflow. * * Counterpart to Solidity's `*` operator. * * Requirements: * - Multiplication cannot overflow. */ function mul(uint256 a, uint256 b) internal pure returns (uint256) { // Gas optimization: this is cheaper than requiring 'a' not being zero, but the // benefit is lost if 'b' is also tested. // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522 if (a == 0) { return 0; } uint256 c = a * b; require(c / a == b, "SafeMath: multiplication overflow"); return c; } /** * @dev Returns the integer division of two unsigned integers. Reverts on * division by zero. The result is rounded towards zero. * * Counterpart to Solidity's `/` operator. Note: this function uses a * `revert` opcode (which leaves remaining gas untouched) while Solidity * uses an invalid opcode to revert (consuming all remaining gas). * * Requirements: * - The divisor cannot be zero. */ function div(uint256 a, uint256 b) internal pure returns (uint256) { return div(a, b, "SafeMath: division by zero"); } /** * @dev Returns the integer division of two unsigned integers. Reverts with custom message on * division by zero. The result is rounded towards zero. * * Counterpart to Solidity's `/` operator. Note: this function uses a * `revert` opcode (which leaves remaining gas untouched) while Solidity * uses an invalid opcode to revert (consuming all remaining gas). * * Requirements: * - The divisor cannot be zero. * * _Available since v2.4.0._ */ function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) { // Solidity only automatically asserts when dividing by 0 require(b != 0, errorMessage); uint256 c = a / b; // assert(a == b * c + a % b); // There is no case in which this doesn't hold return c; } /** * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo), * Reverts when dividing by zero. * * Counterpart to Solidity's `%` operator. This function uses a `revert` * opcode (which leaves remaining gas untouched) while Solidity uses an * invalid opcode to revert (consuming all remaining gas). * * Requirements: * - The divisor cannot be zero. */ function mod(uint256 a, uint256 b) internal pure returns (uint256) { return mod(a, b, "SafeMath: modulo by zero"); } /** * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo), * Reverts with custom message when dividing by zero. * * Counterpart to Solidity's `%` operator. This function uses a `revert` * opcode (which leaves remaining gas untouched) while Solidity uses an * invalid opcode to revert (consuming all remaining gas). * * Requirements: * - The divisor cannot be zero. * * _Available since v2.4.0._ */ function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) { require(b != 0, errorMessage); return a % b; } } pragma solidity ^0.5.0; library Utils { /* @notice Convert the bytes array to bytes32 type, the bytes array length must be 32 * @param _bs Source bytes array * @return bytes32 */ function bytesToBytes32(bytes memory _bs) internal pure returns (bytes32 value) { require(_bs.length == 32, "bytes length is not 32."); assembly { // load 32 bytes from memory starting from position _bs + 0x20 since the first 0x20 bytes stores _bs length value := mload(add(_bs, 0x20)) } } /* @notice Convert bytes to uint256 * @param _b Source bytes should have length of 32 * @return uint256 */ function bytesToUint256(bytes memory _bs) internal pure returns (uint256 value) { require(_bs.length == 32, "bytes length is not 32."); assembly { // load 32 bytes from memory starting from position _bs + 32 value := mload(add(_bs, 0x20)) } require(value <= 0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff, "Value exceeds the range"); } /* @notice Convert uint256 to bytes * @param _b uint256 that needs to be converted * @return bytes */ function uint256ToBytes(uint256 _value) internal pure returns (bytes memory bs) { require(_value <= 0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff, "Value exceeds the range"); assembly { // Get a location of some free memory and store it in result as // Solidity does for memory variables. bs := mload(0x40) // Put 0x20 at the first word, the length of bytes for uint256 value mstore(bs, 0x20) //In the next word, put value in bytes format to the next 32 bytes mstore(add(bs, 0x20), _value) // Update the free-memory pointer by padding our last write location to 32 bytes mstore(0x40, add(bs, 0x40)) } } /* @notice Convert bytes to address * @param _bs Source bytes: bytes length must be 20 * @return Converted address from source bytes */ function bytesToAddress(bytes memory _bs) internal pure returns (address addr) { require(_bs.length == 20, "bytes length does not match address"); assembly { // for _bs, first word store _bs.length, second word store _bs.value // load 32 bytes from mem[_bs+20], convert it into Uint160, meaning we take last 20 bytes as addr (address). addr := mload(add(_bs, 0x14)) } } /* @notice Convert address to bytes * @param _addr Address need to be converted * @return Converted bytes from address */ function addressToBytes(address _addr) internal pure returns (bytes memory bs){ assembly { // Get a location of some free memory and store it in result as // Solidity does for memory variables. bs := mload(0x40) // Put 20 (address byte length) at the first word, the length of bytes for uint256 value mstore(bs, 0x14) // logical shift left _a by 12 bytes, change _a from right-aligned to left-aligned mstore(add(bs, 0x20), shl(96, _addr)) // Update the free-memory pointer by padding our last write location to 32 bytes mstore(0x40, add(bs, 0x40)) } } /* @notice Do hash leaf as the multi-chain does * @param _data Data in bytes format * @return Hashed value in bytes32 format */ function hashLeaf(bytes memory _data) internal pure returns (bytes32 result) { result = sha256(abi.encodePacked(byte(0x0), _data)); } /* @notice Do hash children as the multi-chain does * @param _l Left node * @param _r Right node * @return Hashed value in bytes32 format */ function hashChildren(bytes32 _l, bytes32 _r) internal pure returns (bytes32 result) { result = sha256(abi.encodePacked(bytes1(0x01), _l, _r)); } /* @notice Compare if two bytes are equal, which are in storage and memory, seperately Refer from https://github.com/summa-tx/bitcoin-spv/blob/master/solidity/contracts/BytesLib.sol#L368 * @param _preBytes The bytes stored in storage * @param _postBytes The bytes stored in memory * @return Bool type indicating if they are equal */ function equalStorage(bytes storage _preBytes, bytes memory _postBytes) internal view returns (bool) { bool success = true; assembly { // we know _preBytes_offset is 0 let fslot := sload(_preBytes_slot) // Arrays of 31 bytes or less have an even value in their slot, // while longer arrays have an odd value. The actual length is // the slot divided by two for odd values, and the lowest order // byte divided by two for even values. // If the slot is even, bitwise and the slot with 255 and divide by // two to get the length. If the slot is odd, bitwise and the slot // with -1 and divide by two. let slength := div(and(fslot, sub(mul(0x100, iszero(and(fslot, 1))), 1)), 2) let mlength := mload(_postBytes) // if lengths don't match the arrays are not equal switch eq(slength, mlength) case 1 { // fslot can contain both the length and contents of the array // if slength < 32 bytes so let's prepare for that // v. http://solidity.readthedocs.io/en/latest/miscellaneous.html#layout-of-state-variables-in-storage // slength != 0 if iszero(iszero(slength)) { switch lt(slength, 32) case 1 { // blank the last byte which is the length fslot := mul(div(fslot, 0x100), 0x100) if iszero(eq(fslot, mload(add(_postBytes, 0x20)))) { // unsuccess: success := 0 } } default { // cb is a circuit breaker in the for loop since there's // no said feature for inline assembly loops // cb = 1 - don't breaker // cb = 0 - break let cb := 1 // get the keccak hash to get the contents of the array mstore(0x0, _preBytes_slot) let sc := keccak256(0x0, 0x20) let mc := add(_postBytes, 0x20) let end := add(mc, mlength) // the next line is the loop condition: // while(uint(mc < end) + cb == 2) for {} eq(add(lt(mc, end), cb), 2) { sc := add(sc, 1) mc := add(mc, 0x20) } { if iszero(eq(sload(sc), mload(mc))) { // unsuccess: success := 0 cb := 0 } } } } } default { // unsuccess: success := 0 } } return success; } /* @notice Slice the _bytes from _start index till the result has length of _length Refer from https://github.com/summa-tx/bitcoin-spv/blob/master/solidity/contracts/BytesLib.sol#L246 * @param _bytes The original bytes needs to be sliced * @param _start The index of _bytes for the start of sliced bytes * @param _length The index of _bytes for the end of sliced bytes * @return The sliced bytes */ function slice( bytes memory _bytes, uint _start, uint _length ) internal pure returns (bytes memory) { require(_bytes.length >= (_start + _length)); bytes memory tempBytes; assembly { switch iszero(_length) case 0 { // Get a location of some free memory and store it in tempBytes as // Solidity does for memory variables. tempBytes := mload(0x40) // The first word of the slice result is potentially a partial // word read from the original array. To read it, we calculate // the length of that partial word and start copying that many // bytes into the array. The first word we copy will start with // data we don't care about, but the last `lengthmod` bytes will // land at the beginning of the contents of the new array. When // we're done copying, we overwrite the full first word with // the actual length of the slice. // lengthmod <= _length % 32 let lengthmod := and(_length, 31) // The multiplication in the next line is necessary // because when slicing multiples of 32 bytes (lengthmod == 0) // the following copy loop was copying the origin's length // and then ending prematurely not copying everything it should. let mc := add(add(tempBytes, lengthmod), mul(0x20, iszero(lengthmod))) let end := add(mc, _length) for { // The multiplication in the next line has the same exact purpose // as the one above. let cc := add(add(add(_bytes, lengthmod), mul(0x20, iszero(lengthmod))), _start) } lt(mc, end) { mc := add(mc, 0x20) cc := add(cc, 0x20) } { mstore(mc, mload(cc)) } mstore(tempBytes, _length) //update free-memory pointer //allocating the array padded to 32 bytes like the compiler does now mstore(0x40, and(add(mc, 31), not(31))) } //if we want a zero-length slice let's just return a zero-length array default { tempBytes := mload(0x40) mstore(0x40, add(tempBytes, 0x20)) } } return tempBytes; } /* @notice Check if the elements number of _signers within _keepers array is no less than _m * @param _keepers The array consists of serveral address * @param _signers Some specific addresses to be looked into * @param _m The number requirement paramter * @return True means containment, false meansdo do not contain. */ function containMAddresses(address[] memory _keepers, address[] memory _signers, uint _m) internal pure returns (bool){ uint m = 0; for(uint i = 0; i < _signers.length; i++){ for (uint j = 0; j < _keepers.length; j++) { if (_signers[i] == _keepers[j]) { m++; delete _keepers[j]; } } } return m >= _m; } /* @notice TODO * @param key * @return */ function compressMCPubKey(bytes memory key) internal pure returns (bytes memory newkey) { require(key.length >= 67, "key lenggh is too short"); newkey = slice(key, 0, 35); if (uint8(key[66]) % 2 == 0){ newkey[2] = byte(0x02); } else { newkey[2] = byte(0x03); } return newkey; } /** * @dev Returns true if `account` is a contract. * Refer from https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/utils/Address.sol#L18 * * This test is non-exhaustive, and there may be false-negatives: during the * execution of a contract's constructor, its address will be reported as * not containing a contract. * * IMPORTANT: It is unsafe to assume that an address for which this * function returns false is an externally-owned account (EOA) and not a * contract. */ function isContract(address account) internal view returns (bool) { // This method relies in extcodesize, which returns 0 for contracts in // construction, since the code is only stored at the end of the // constructor execution. // According to EIP-1052, 0x0 is the value returned for not-yet created accounts // and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned // for accounts without code, i.e. `keccak256('')` bytes32 codehash; bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470; // solhint-disable-next-line no-inline-assembly assembly { codehash := extcodehash(account) } return (codehash != 0x0 && codehash != accountHash); } } pragma solidity ^0.5.0; /** * @dev Interface of the ERC20 standard as defined in the EIP. Does not include * the optional functions; to access them see {ERC20Detailed}. */ interface IERC20 { /** * @dev Returns the amount of tokens in existence. */ function totalSupply() external view returns (uint256); /** * @dev Returns the amount of tokens owned by `account`. */ function balanceOf(address account) external view returns (uint256); /** * @dev Moves `amount` tokens from the caller's account to `recipient`. * * Returns a boolean value indicating whether the operation succeeded. * * Emits a {Transfer} event. */ function transfer(address recipient, uint256 amount) external returns (bool); /** * @dev Returns the remaining number of tokens that `spender` will be * allowed to spend on behalf of `owner` through {transferFrom}. This is * zero by default. * * This value changes when {approve} or {transferFrom} are called. */ function allowance(address owner, address spender) external view returns (uint256); /** * @dev Sets `amount` as the allowance of `spender` over the caller's tokens. * * Returns a boolean value indicating whether the operation succeeded. * * IMPORTANT: Beware that changing an allowance with this method brings the risk * that someone may use both the old and the new allowance by unfortunate * transaction ordering. One possible solution to mitigate this race * condition is to first reduce the spender's allowance to 0 and set the * desired value afterwards: * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729 * * Emits an {Approval} event. */ function approve(address spender, uint256 amount) external returns (bool); /** * @dev Moves `amount` tokens from `sender` to `recipient` using the * allowance mechanism. `amount` is then deducted from the caller's * allowance. * * Returns a boolean value indicating whether the operation succeeded. * * Emits a {Transfer} event. */ function transferFrom(address sender, address recipient, uint256 amount) external returns (bool); /** * @dev Emitted when `value` tokens are moved from one account (`from`) to * another (`to`). * * Note that `value` may be zero. */ event Transfer(address indexed from, address indexed to, uint256 value); /** * @dev Emitted when the allowance of a `spender` for an `owner` is set by * a call to {approve}. `value` is the new allowance. */ event Approval(address indexed owner, address indexed spender, uint256 value); } /** * @title SafeERC20 * @dev Wrappers around ERC20 operations that throw on failure (when the token * contract returns false). Tokens that return no value (and instead revert or * throw on failure) are also supported, non-reverting calls are assumed to be * successful. * To use this library you can add a `using SafeERC20 for ERC20;` statement to your contract, * which allows you to call the safe operations as `token.safeTransfer(...)`, etc. */ library SafeERC20 { using SafeMath for uint256; 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 { // safeApprove should only be called when setting an initial allowance, // or when resetting it to zero. To increase and decrease it, use // 'safeIncreaseAllowance' and 'safeDecreaseAllowance' // solhint-disable-next-line max-line-length 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); callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance)); } /** * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement * on the return value: the return value is optional (but if data is returned, it must not be false). * @param token The token targeted by the call. * @param data The call data (encoded using abi.encode or one of its variants). */ function callOptionalReturn(IERC20 token, bytes memory data) private { // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since // we're implementing it ourselves. // A Solidity high level call has three parts: // 1. The target address is checked to verify it contains contract code // 2. The call itself is made, and success asserted // 3. The return value is decoded, which in turn checks the size of the returned data. // solhint-disable-next-line max-line-length require(Utils.isContract(address(token)), "SafeERC20: call to non-contract"); // solhint-disable-next-line avoid-low-level-calls (bool success, bytes memory returndata) = address(token).call(data); require(success, "SafeERC20: low-level call failed"); if (returndata.length > 0) { // Return data is optional // solhint-disable-next-line max-line-length require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed"); } } } pragma solidity ^0.5.0; /** * @dev Interface of the EthCrossChainManager contract for business contract like LockProxy to request cross chain transaction */ interface IEthCrossChainManager { function crossChain(uint64 _toChainId, bytes calldata _toContract, bytes calldata _method, bytes calldata _txData) external returns (bool); } pragma solidity ^0.5.0; /** * @dev Interface of the EthCrossChainManagerProxy for business contract like LockProxy to obtain the reliable EthCrossChainManager contract hash. */ interface IEthCrossChainManagerProxy { function getEthCrossChainManager() external view returns (address); } pragma solidity ^0.5.0; /** * @dev Wrappers over decoding and deserialization operation from bytes into bassic types in Solidity for PolyNetwork cross chain utility. * * Decode into basic types in Solidity from bytes easily. It's designed to be used * for PolyNetwork cross chain application, and the decoding rules on Ethereum chain * and the encoding rule on other chains should be consistent, and . Here we * follow the underlying deserialization rule with implementation found here: * https://github.com/polynetwork/poly/blob/master/common/zero_copy_source.go * * Using this library instead of the unchecked serialization method can help reduce * the risk of serious bugs and handfule, so it's recommended to use it. * * Please note that risk can be minimized, yet not eliminated. */ library ZeroCopySource { /* @notice Read next byte as boolean type starting at offset from buff * @param buff Source bytes array * @param offset The position from where we read the boolean value * @return The the read boolean value and new offset */ function NextBool(bytes memory buff, uint256 offset) internal pure returns(bool, uint256) { require(offset + 1 <= buff.length && offset < offset + 1, "Offset exceeds limit"); // byte === bytes1 byte v; assembly{ v := mload(add(add(buff, 0x20), offset)) } bool value; if (v == 0x01) { value = true; } else if (v == 0x00) { value = false; } else { revert("NextBool value error"); } return (value, offset + 1); } /* @notice Read next byte starting at offset from buff * @param buff Source bytes array * @param offset The position from where we read the byte value * @return The read byte value and new offset */ function NextByte(bytes memory buff, uint256 offset) internal pure returns (byte, uint256) { require(offset + 1 <= buff.length && offset < offset + 1, "NextByte, Offset exceeds maximum"); byte v; assembly{ v := mload(add(add(buff, 0x20), offset)) } return (v, offset + 1); } /* @notice Read next byte as uint8 starting at offset from buff * @param buff Source bytes array * @param offset The position from where we read the byte value * @return The read uint8 value and new offset */ function NextUint8(bytes memory buff, uint256 offset) internal pure returns (uint8, uint256) { require(offset + 1 <= buff.length && offset < offset + 1, "NextUint8, Offset exceeds maximum"); uint8 v; assembly{ let tmpbytes := mload(0x40) let bvalue := mload(add(add(buff, 0x20), offset)) mstore8(tmpbytes, byte(0, bvalue)) mstore(0x40, add(tmpbytes, 0x01)) v := mload(sub(tmpbytes, 0x1f)) } return (v, offset + 1); } /* @notice Read next two bytes as uint16 type starting from offset * @param buff Source bytes array * @param offset The position from where we read the uint16 value * @return The read uint16 value and updated offset */ function NextUint16(bytes memory buff, uint256 offset) internal pure returns (uint16, uint256) { require(offset + 2 <= buff.length && offset < offset + 2, "NextUint16, offset exceeds maximum"); uint16 v; assembly { let tmpbytes := mload(0x40) let bvalue := mload(add(add(buff, 0x20), offset)) mstore8(tmpbytes, byte(0x01, bvalue)) mstore8(add(tmpbytes, 0x01), byte(0, bvalue)) mstore(0x40, add(tmpbytes, 0x02)) v := mload(sub(tmpbytes, 0x1e)) } return (v, offset + 2); } /* @notice Read next four bytes as uint32 type starting from offset * @param buff Source bytes array * @param offset The position from where we read the uint32 value * @return The read uint32 value and updated offset */ function NextUint32(bytes memory buff, uint256 offset) internal pure returns (uint32, uint256) { require(offset + 4 <= buff.length && offset < offset + 4, "NextUint32, offset exceeds maximum"); uint32 v; assembly { let tmpbytes := mload(0x40) let byteLen := 0x04 for { let tindex := 0x00 let bindex := sub(byteLen, 0x01) let bvalue := mload(add(add(buff, 0x20), offset)) } lt(tindex, byteLen) { tindex := add(tindex, 0x01) bindex := sub(bindex, 0x01) }{ mstore8(add(tmpbytes, tindex), byte(bindex, bvalue)) } mstore(0x40, add(tmpbytes, byteLen)) v := mload(sub(tmpbytes, sub(0x20, byteLen))) } return (v, offset + 4); } /* @notice Read next eight bytes as uint64 type starting from offset * @param buff Source bytes array * @param offset The position from where we read the uint64 value * @return The read uint64 value and updated offset */ function NextUint64(bytes memory buff, uint256 offset) internal pure returns (uint64, uint256) { require(offset + 8 <= buff.length && offset < offset + 8, "NextUint64, offset exceeds maximum"); uint64 v; assembly { let tmpbytes := mload(0x40) let byteLen := 0x08 for { let tindex := 0x00 let bindex := sub(byteLen, 0x01) let bvalue := mload(add(add(buff, 0x20), offset)) } lt(tindex, byteLen) { tindex := add(tindex, 0x01) bindex := sub(bindex, 0x01) }{ mstore8(add(tmpbytes, tindex), byte(bindex, bvalue)) } mstore(0x40, add(tmpbytes, byteLen)) v := mload(sub(tmpbytes, sub(0x20, byteLen))) } return (v, offset + 8); } /* @notice Read next 32 bytes as uint256 type starting from offset, there are limits considering the numerical limits in multi-chain * @param buff Source bytes array * @param offset The position from where we read the uint256 value * @return The read uint256 value and updated offset */ function NextUint255(bytes memory buff, uint256 offset) internal pure returns (uint256, uint256) { require(offset + 32 <= buff.length && offset < offset + 32, "NextUint255, offset exceeds maximum"); uint256 v; assembly { let tmpbytes := mload(0x40) let byteLen := 0x20 for { let tindex := 0x00 let bindex := sub(byteLen, 0x01) let bvalue := mload(add(add(buff, 0x20), offset)) } lt(tindex, byteLen) { tindex := add(tindex, 0x01) bindex := sub(bindex, 0x01) }{ mstore8(add(tmpbytes, tindex), byte(bindex, bvalue)) } mstore(0x40, add(tmpbytes, byteLen)) v := mload(tmpbytes) } require(v <= 0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff, "Value exceeds the range"); return (v, offset + 32); } /* @notice Read next variable bytes starting from offset, the decoding rule coming from multi-chain * @param buff Source bytes array * @param offset The position from where we read the bytes value * @return The read variable bytes array value and updated offset */ function NextVarBytes(bytes memory buff, uint256 offset) internal pure returns(bytes memory, uint256) { uint len; (len, offset) = NextVarUint(buff, offset); require(offset + len <= buff.length && offset < offset + len, "NextVarBytes, offset exceeds maximum"); bytes memory tempBytes; assembly{ switch iszero(len) case 0 { // Get a location of some free memory and store it in tempBytes as // Solidity does for memory variables. tempBytes := mload(0x40) // The first word of the slice result is potentially a partial // word read from the original array. To read it, we calculate // the length of that partial word and start copying that many // bytes into the array. The first word we copy will start with // data we don't care about, but the last `lengthmod` bytes will // land at the beginning of the contents of the new array. When // we're done copying, we overwrite the full first word with // the actual length of the slice. let lengthmod := and(len, 31) // The multiplication in the next line is necessary // because when slicing multiples of 32 bytes (lengthmod == 0) // the following copy loop was copying the origin's length // and then ending prematurely not copying everything it should. let mc := add(add(tempBytes, lengthmod), mul(0x20, iszero(lengthmod))) let end := add(mc, len) for { // The multiplication in the next line has the same exact purpose // as the one above. let cc := add(add(add(buff, lengthmod), mul(0x20, iszero(lengthmod))), offset) } lt(mc, end) { mc := add(mc, 0x20) cc := add(cc, 0x20) } { mstore(mc, mload(cc)) } mstore(tempBytes, len) //update free-memory pointer //allocating the array padded to 32 bytes like the compiler does now mstore(0x40, and(add(mc, 31), not(31))) } //if we want a zero-length slice let's just return a zero-length array default { tempBytes := mload(0x40) mstore(0x40, add(tempBytes, 0x20)) } } return (tempBytes, offset + len); } /* @notice Read next 32 bytes starting from offset, * @param buff Source bytes array * @param offset The position from where we read the bytes value * @return The read bytes32 value and updated offset */ function NextHash(bytes memory buff, uint256 offset) internal pure returns (bytes32 , uint256) { require(offset + 32 <= buff.length && offset < offset + 32, "NextHash, offset exceeds maximum"); bytes32 v; assembly { v := mload(add(buff, add(offset, 0x20))) } return (v, offset + 32); } /* @notice Read next 20 bytes starting from offset, * @param buff Source bytes array * @param offset The position from where we read the bytes value * @return The read bytes20 value and updated offset */ function NextBytes20(bytes memory buff, uint256 offset) internal pure returns (bytes20 , uint256) { require(offset + 20 <= buff.length && offset < offset + 20, "NextBytes20, offset exceeds maximum"); bytes20 v; assembly { v := mload(add(buff, add(offset, 0x20))) } return (v, offset + 20); } function NextVarUint(bytes memory buff, uint256 offset) internal pure returns(uint, uint256) { byte v; (v, offset) = NextByte(buff, offset); uint value; if (v == 0xFD) { // return NextUint16(buff, offset); (value, offset) = NextUint16(buff, offset); require(value >= 0xFD && value <= 0xFFFF, "NextUint16, value outside range"); return (value, offset); } else if (v == 0xFE) { // return NextUint32(buff, offset); (value, offset) = NextUint32(buff, offset); require(value > 0xFFFF && value <= 0xFFFFFFFF, "NextVarUint, value outside range"); return (value, offset); } else if (v == 0xFF) { // return NextUint64(buff, offset); (value, offset) = NextUint64(buff, offset); require(value > 0xFFFFFFFF, "NextVarUint, value outside range"); return (value, offset); } else{ // return (uint8(v), offset); value = uint8(v); require(value < 0xFD, "NextVarUint, value outside range"); return (value, offset); } } } pragma solidity ^0.5.0; /** * @dev Wrappers over encoding and serialization operation into bytes from bassic types in Solidity for PolyNetwork cross chain utility. * * Encode basic types in Solidity into bytes easily. It's designed to be used * for PolyNetwork cross chain application, and the encoding rules on Ethereum chain * and the decoding rules on other chains should be consistent. Here we * follow the underlying serialization rule with implementation found here: * https://github.com/polynetwork/poly/blob/master/common/zero_copy_sink.go * * Using this library instead of the unchecked serialization method can help reduce * the risk of serious bugs and handfule, so it's recommended to use it. * * Please note that risk can be minimized, yet not eliminated. */ library ZeroCopySink { /* @notice Convert boolean value into bytes * @param b The boolean value * @return Converted bytes array */ function WriteBool(bool b) internal pure returns (bytes memory) { bytes memory buff; assembly{ buff := mload(0x40) mstore(buff, 1) switch iszero(b) case 1 { mstore(add(buff, 0x20), shl(248, 0x00)) // mstore8(add(buff, 0x20), 0x00) } default { mstore(add(buff, 0x20), shl(248, 0x01)) // mstore8(add(buff, 0x20), 0x01) } mstore(0x40, add(buff, 0x21)) } return buff; } /* @notice Convert byte value into bytes * @param b The byte value * @return Converted bytes array */ function WriteByte(byte b) internal pure returns (bytes memory) { return WriteUint8(uint8(b)); } /* @notice Convert uint8 value into bytes * @param v The uint8 value * @return Converted bytes array */ function WriteUint8(uint8 v) internal pure returns (bytes memory) { bytes memory buff; assembly{ buff := mload(0x40) mstore(buff, 1) mstore(add(buff, 0x20), shl(248, v)) // mstore(add(buff, 0x20), byte(0x1f, v)) mstore(0x40, add(buff, 0x21)) } return buff; } /* @notice Convert uint16 value into bytes * @param v The uint16 value * @return Converted bytes array */ function WriteUint16(uint16 v) internal pure returns (bytes memory) { bytes memory buff; assembly{ buff := mload(0x40) let byteLen := 0x02 mstore(buff, byteLen) for { let mindex := 0x00 let vindex := 0x1f } lt(mindex, byteLen) { mindex := add(mindex, 0x01) vindex := sub(vindex, 0x01) }{ mstore8(add(add(buff, 0x20), mindex), byte(vindex, v)) } mstore(0x40, add(buff, 0x22)) } return buff; } /* @notice Convert uint32 value into bytes * @param v The uint32 value * @return Converted bytes array */ function WriteUint32(uint32 v) internal pure returns(bytes memory) { bytes memory buff; assembly{ buff := mload(0x40) let byteLen := 0x04 mstore(buff, byteLen) for { let mindex := 0x00 let vindex := 0x1f } lt(mindex, byteLen) { mindex := add(mindex, 0x01) vindex := sub(vindex, 0x01) }{ mstore8(add(add(buff, 0x20), mindex), byte(vindex, v)) } mstore(0x40, add(buff, 0x24)) } return buff; } /* @notice Convert uint64 value into bytes * @param v The uint64 value * @return Converted bytes array */ function WriteUint64(uint64 v) internal pure returns(bytes memory) { bytes memory buff; assembly{ buff := mload(0x40) let byteLen := 0x08 mstore(buff, byteLen) for { let mindex := 0x00 let vindex := 0x1f } lt(mindex, byteLen) { mindex := add(mindex, 0x01) vindex := sub(vindex, 0x01) }{ mstore8(add(add(buff, 0x20), mindex), byte(vindex, v)) } mstore(0x40, add(buff, 0x28)) } return buff; } /* @notice Convert limited uint256 value into bytes * @param v The uint256 value * @return Converted bytes array */ function WriteUint255(uint256 v) internal pure returns (bytes memory) { require(v <= 0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff, "Value exceeds uint255 range"); bytes memory buff; assembly{ buff := mload(0x40) let byteLen := 0x20 mstore(buff, byteLen) for { let mindex := 0x00 let vindex := 0x1f } lt(mindex, byteLen) { mindex := add(mindex, 0x01) vindex := sub(vindex, 0x01) }{ mstore8(add(add(buff, 0x20), mindex), byte(vindex, v)) } mstore(0x40, add(buff, 0x40)) } return buff; } /* @notice Encode bytes format data into bytes * @param data The bytes array data * @return Encoded bytes array */ function WriteVarBytes(bytes memory data) internal pure returns (bytes memory) { uint64 l = uint64(data.length); return abi.encodePacked(WriteVarUint(l), data); } function WriteVarUint(uint64 v) internal pure returns (bytes memory) { if (v < 0xFD){ return WriteUint8(uint8(v)); } else if (v <= 0xFFFF) { return abi.encodePacked(WriteByte(0xFD), WriteUint16(uint16(v))); } else if (v <= 0xFFFFFFFF) { return abi.encodePacked(WriteByte(0xFE), WriteUint32(uint32(v))); } else { return abi.encodePacked(WriteByte(0xFF), WriteUint64(uint64(v))); } } } contract LockProxy is Ownable { using SafeMath for uint; using SafeERC20 for IERC20; struct TxArgs { bytes toAssetHash; bytes toAddress; uint256 amount; } address public managerProxyContract; mapping(uint64 => bytes) public proxyHashMap; mapping(address => mapping(uint64 => bytes)) public assetHashMap; mapping(address => bool) safeTransfer; event SetManagerProxyEvent(address manager); event BindProxyEvent(uint64 toChainId, bytes targetProxyHash); event BindAssetEvent(address fromAssetHash, uint64 toChainId, bytes targetProxyHash, uint initialAmount); event UnlockEvent(address toAssetHash, address toAddress, uint256 amount); event LockEvent(address fromAssetHash, address fromAddress, uint64 toChainId, bytes toAssetHash, bytes toAddress, uint256 amount); modifier onlyManagerContract() { IEthCrossChainManagerProxy ieccmp = IEthCrossChainManagerProxy(managerProxyContract); require(_msgSender() == ieccmp.getEthCrossChainManager(), "msgSender is not EthCrossChainManagerContract"); _; } function setManagerProxy(address ethCCMProxyAddr) onlyOwner public { managerProxyContract = ethCCMProxyAddr; emit SetManagerProxyEvent(managerProxyContract); } function bindProxyHash(uint64 toChainId, bytes memory targetProxyHash) onlyOwner public returns (bool) { proxyHashMap[toChainId] = targetProxyHash; emit BindProxyEvent(toChainId, targetProxyHash); return true; } function bindAssetHash(address fromAssetHash, uint64 toChainId, bytes memory toAssetHash) onlyOwner public returns (bool) { assetHashMap[fromAssetHash][toChainId] = toAssetHash; emit BindAssetEvent(fromAssetHash, toChainId, toAssetHash, getBalanceFor(fromAssetHash)); return true; } /* @notice This function is meant to be invoked by the user, * a certin amount teokens will be locked in the proxy contract the invoker/msg.sender immediately. * Then the same amount of tokens will be unloked from target chain proxy contract at the target chain with chainId later. * @param fromAssetHash The asset address in current chain, uniformly named as `fromAssetHash` * @param toChainId The target chain id * * @param toAddress The address in bytes format to receive same amount of tokens in target chain * @param amount The amount of tokens to be crossed from ethereum to the chain with chainId */ function lock(address fromAssetHash, uint64 toChainId, bytes memory toAddress, uint256 amount) public payable returns (bool) { require(amount != 0, "amount cannot be zero!"); require(_transferToContract(fromAssetHash, amount), "transfer asset from fromAddress to lock_proxy contract failed!"); bytes memory toAssetHash = assetHashMap[fromAssetHash][toChainId]; require(toAssetHash.length != 0, "empty illegal toAssetHash"); TxArgs memory txArgs = TxArgs({ toAssetHash: toAssetHash, toAddress: toAddress, amount: amount }); bytes memory txData = _serializeTxArgs(txArgs); IEthCrossChainManagerProxy eccmp = IEthCrossChainManagerProxy(managerProxyContract); address eccmAddr = eccmp.getEthCrossChainManager(); IEthCrossChainManager eccm = IEthCrossChainManager(eccmAddr); bytes memory toProxyHash = proxyHashMap[toChainId]; require(toProxyHash.length != 0, "empty illegal toProxyHash"); require(eccm.crossChain(toChainId, toProxyHash, "unlock", txData), "EthCrossChainManager crossChain executed error!"); emit LockEvent(fromAssetHash, _msgSender(), toChainId, toAssetHash, toAddress, amount); return true; } // /* @notice This function is meant to be invoked by the ETH crosschain management contract, // * then mint a certin amount of tokens to the designated address since a certain amount // * was burnt from the source chain invoker. // * @param argsBs The argument bytes recevied by the ethereum lock proxy contract, need to be deserialized. // * based on the way of serialization in the source chain proxy contract. // * @param fromContractAddr The source chain contract address // * @param fromChainId The source chain id // */ function unlock(bytes memory argsBs, bytes memory fromContractAddr, uint64 fromChainId) onlyManagerContract public returns (bool) { TxArgs memory args = _deserializeTxArgs(argsBs); require(fromContractAddr.length != 0, "from proxy contract address cannot be empty"); require(Utils.equalStorage(proxyHashMap[fromChainId], fromContractAddr), "From Proxy contract address error!"); require(args.toAssetHash.length != 0, "toAssetHash cannot be empty"); address toAssetHash = Utils.bytesToAddress(args.toAssetHash); require(args.toAddress.length != 0, "toAddress cannot be empty"); address toAddress = Utils.bytesToAddress(args.toAddress); require(_transferFromContract(toAssetHash, toAddress, args.amount), "transfer asset from lock_proxy contract to toAddress failed!"); emit UnlockEvent(toAssetHash, toAddress, args.amount); return true; } function getBalanceFor(address fromAssetHash) public view returns (uint256) { if (fromAssetHash == address(0)) { // return address(this).balance; // this expression would result in error: Failed to decode output: Error: insufficient data for uint256 type address selfAddr = address(this); return selfAddr.balance; } else { IERC20 erc20Token = IERC20(fromAssetHash); return erc20Token.balanceOf(address(this)); } } function _transferToContract(address fromAssetHash, uint256 amount) internal returns (bool) { if (fromAssetHash == address(0)) { // fromAssetHash === address(0) denotes user choose to lock ether // passively check if the received msg.value equals amount require(msg.value != 0, "transferred ether cannot be zero!"); require(msg.value == amount, "transferred ether is not equal to amount!"); } else { // make sure lockproxy contract will decline any received ether require(msg.value == 0, "there should be no ether transfer!"); // actively transfer amount of asset from msg.sender to lock_proxy contract require(_transferERC20ToContract(fromAssetHash, _msgSender(), address(this), amount), "transfer erc20 asset to lock_proxy contract failed!"); } return true; } function _transferFromContract(address toAssetHash, address toAddress, uint256 amount) internal returns (bool) { if (toAssetHash == address(0x0000000000000000000000000000000000000000)) { // toAssetHash === address(0) denotes contract needs to unlock ether to toAddress // convert toAddress from 'address' type to 'address payable' type, then actively transfer ether address(uint160(toAddress)).transfer(amount); } else { // actively transfer amount of asset from msg.sender to lock_proxy contract require(_transferERC20FromContract(toAssetHash, toAddress, amount), "transfer erc20 asset to lock_proxy contract failed!"); } return true; } function _transferERC20ToContract(address fromAssetHash, address fromAddress, address toAddress, uint256 amount) internal returns (bool) { IERC20 erc20Token = IERC20(fromAssetHash); // require(erc20Token.transferFrom(fromAddress, toAddress, amount), "trasnfer ERC20 Token failed!"); erc20Token.safeTransferFrom(fromAddress, toAddress, amount); return true; } function _transferERC20FromContract(address toAssetHash, address toAddress, uint256 amount) internal returns (bool) { IERC20 erc20Token = IERC20(toAssetHash); // require(erc20Token.transfer(toAddress, amount), "trasnfer ERC20 Token failed!"); erc20Token.safeTransfer(toAddress, amount); return true; } function _serializeTxArgs(TxArgs memory args) internal pure returns (bytes memory) { bytes memory buff; buff = abi.encodePacked( ZeroCopySink.WriteVarBytes(args.toAssetHash), ZeroCopySink.WriteVarBytes(args.toAddress), ZeroCopySink.WriteUint255(args.amount) ); return buff; } function _deserializeTxArgs(bytes memory valueBs) internal pure returns (TxArgs memory) { TxArgs memory args; uint256 off = 0; (args.toAssetHash, off) = ZeroCopySource.NextVarBytes(valueBs, off); (args.toAddress, off) = ZeroCopySource.NextVarBytes(valueBs, off); (args.amount, off) = ZeroCopySource.NextUint255(valueBs, off); return args; } }
[{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"fromAssetHash","type":"address"},{"indexed":false,"internalType":"uint64","name":"toChainId","type":"uint64"},{"indexed":false,"internalType":"bytes","name":"targetProxyHash","type":"bytes"},{"indexed":false,"internalType":"uint256","name":"initialAmount","type":"uint256"}],"name":"BindAssetEvent","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint64","name":"toChainId","type":"uint64"},{"indexed":false,"internalType":"bytes","name":"targetProxyHash","type":"bytes"}],"name":"BindProxyEvent","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"fromAssetHash","type":"address"},{"indexed":false,"internalType":"address","name":"fromAddress","type":"address"},{"indexed":false,"internalType":"uint64","name":"toChainId","type":"uint64"},{"indexed":false,"internalType":"bytes","name":"toAssetHash","type":"bytes"},{"indexed":false,"internalType":"bytes","name":"toAddress","type":"bytes"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"LockEvent","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"manager","type":"address"}],"name":"SetManagerProxyEvent","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"toAssetHash","type":"address"},{"indexed":false,"internalType":"address","name":"toAddress","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"UnlockEvent","type":"event"},{"constant":true,"inputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"uint64","name":"","type":"uint64"}],"name":"assetHashMap","outputs":[{"internalType":"bytes","name":"","type":"bytes"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"internalType":"address","name":"fromAssetHash","type":"address"},{"internalType":"uint64","name":"toChainId","type":"uint64"},{"internalType":"bytes","name":"toAssetHash","type":"bytes"}],"name":"bindAssetHash","outputs":[{"internalType":"bool","name":"","type":"bool"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"internalType":"uint64","name":"toChainId","type":"uint64"},{"internalType":"bytes","name":"targetProxyHash","type":"bytes"}],"name":"bindProxyHash","outputs":[{"internalType":"bool","name":"","type":"bool"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[{"internalType":"address","name":"fromAssetHash","type":"address"}],"name":"getBalanceFor","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"isOwner","outputs":[{"internalType":"bool","name":"","type":"bool"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"internalType":"address","name":"fromAssetHash","type":"address"},{"internalType":"uint64","name":"toChainId","type":"uint64"},{"internalType":"bytes","name":"toAddress","type":"bytes"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"lock","outputs":[{"internalType":"bool","name":"","type":"bool"}],"payable":true,"stateMutability":"payable","type":"function"},{"constant":true,"inputs":[],"name":"managerProxyContract","outputs":[{"internalType":"address","name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"internalType":"uint64","name":"","type":"uint64"}],"name":"proxyHashMap","outputs":[{"internalType":"bytes","name":"","type":"bytes"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[],"name":"renounceOwnership","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"internalType":"address","name":"ethCCMProxyAddr","type":"address"}],"name":"setManagerProxy","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"internalType":"bytes","name":"argsBs","type":"bytes"},{"internalType":"bytes","name":"fromContractAddr","type":"bytes"},{"internalType":"uint64","name":"fromChainId","type":"uint64"}],"name":"unlock","outputs":[{"internalType":"bool","name":"","type":"bool"}],"payable":false,"stateMutability":"nonpayable","type":"function"}]
Contract Creation Code
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
Deployed Bytecode
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
Deployed ByteCode Sourcemap
49822:9466:0:-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;54574:976;;8:9:-1;5:2;;;30:1;27;20:12;5:2;54574:976:0;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;54574:976:0;;;;;;;;-1:-1:-1;;;5:28;;2:2;;;46:1;43;36:12;2:2;54574:976:0;;35:9:-1;28:4;12:14;8:25;5:40;2:2;;;58:1;55;48:12;2:2;54574:976:0;;;;;;100:9:-1;95:1;81:12;77:20;67:8;63:35;60:50;-1:-1;;;25:12;22:29;11:107;8:2;;;131:1;128;121:12;8:2;54574:976:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;30:3:-1;22:6;14;1:33;99:1;81:16;;74:27;;;;-1:-1;54574:976:0;;;;;;;;-1:-1:-1;54574:976:0;;-1:-1:-1;;;;;5:28;;2:2;;;46:1;43;36:12;2:2;54574:976:0;;35:9:-1;28:4;12:14;8:25;5:40;2:2;;;58:1;55;48:12;2:2;54574:976:0;;;;;;100:9:-1;95:1;81:12;77:20;67:8;63:35;60:50;-1:-1;;;25:12;22:29;11:107;8:2;;;131:1;128;121:12;8:2;54574:976:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;30:3:-1;22:6;14;1:33;99:1;81:16;;74:27;;;;-1:-1;54574:976:0;;-1:-1:-1;;;54574:976:0;;-1:-1:-1;;;;;54574:976:0;;-1:-1:-1;54574:976:0;;-1:-1:-1;54574:976:0:i;:::-;;;;;;;;;;;;;;;;;;51416:314;;8:9:-1;5:2;;;30:1;27;20:12;5:2;51416:314:0;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;;;;;51416:314:0;;;;-1:-1:-1;;;;;51416:314:0;;;;;;;;;;;;;;;;-1:-1:-1;;;5:28;;2:2;;;46:1;43;36:12;2:2;51416:314:0;;35:9:-1;28:4;12:14;8:25;5:40;2:2;;;58:1;55;48:12;2:2;51416:314:0;;;;;;100:9:-1;95:1;81:12;77:20;67:8;63:35;60:50;-1:-1;;;25:12;22:29;11:107;8:2;;;131:1;128;121:12;8:2;51416:314:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;30:3:-1;22:6;14;1:33;99:1;81:16;;74:27;;;;-1:-1;51416:314:0;;-1:-1:-1;51416:314:0;;-1:-1:-1;;;;;51416:314:0:i;51161:243::-;;8:9:-1;5:2;;;30:1;27;20:12;5:2;51161:243:0;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;;;;;51161:243:0;;;;;;;;;;;;;;;-1:-1:-1;;;5:28;;2:2;;;46:1;43;36:12;2:2;51161:243:0;;35:9:-1;28:4;12:14;8:25;5:40;2:2;;;58:1;55;48:12;2:2;51161:243:0;;;;;;100:9:-1;95:1;81:12;77:20;67:8;63:35;60:50;-1:-1;;;25:12;22:29;11:107;8:2;;;131:1;128;121:12;8:2;51161:243:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;30:3:-1;22:6;14;1:33;99:1;81:16;;74:27;;;;-1:-1;51161:243:0;;-1:-1:-1;51161:243:0;;-1:-1:-1;;;;;51161:243:0:i;50124:64::-;;8:9:-1;5:2;;;30:1;27;20:12;5:2;50124:64:0;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;50124:64:0;;-1:-1:-1;;;;;50124:64:0;;;;;-1:-1:-1;;;;;50124:64:0;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8:100:-1;33:3;30:1;27:10;8:100;;;90:11;;;84:18;71:11;;;64:39;52:2;45:10;8:100;;;12:14;50124:64:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;55562:510;;8:9:-1;5:2;;;30:1;27;20:12;5:2;55562:510:0;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;55562:510:0;-1:-1:-1;;;;;55562:510:0;;:::i;:::-;;;;;;;;;;;;;;;;3103:140;;8:9:-1;5:2;;;30:1;27;20:12;5:2;3103:140:0;;;:::i;:::-;;52526:1352;;;;;;13:3:-1;8;5:12;2:2;;;30:1;27;20:12;2:2;-1:-1;;;;;52526:1352:0;;;;-1:-1:-1;;;;;52526:1352:0;;;;;;;;;;;;;;;;-1:-1:-1;;;5:28;;2:2;;;46:1;43;36:12;2:2;52526:1352:0;;35:9:-1;28:4;12:14;8:25;5:40;2:2;;;58:1;55;48:12;2:2;52526:1352:0;;;;;;100:9:-1;95:1;81:12;77:20;67:8;63:35;60:50;-1:-1;;;25:12;22:29;11:107;8:2;;;131:1;128;121:12;8:2;52526:1352:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;30:3:-1;22:6;14;1:33;99:1;81:16;;74:27;;;;-1:-1;52526:1352:0;;-1:-1:-1;;52526:1352:0;;;-1:-1:-1;52526:1352:0;;-1:-1:-1;;52526:1352:0:i;2292:79::-;;8:9:-1;5:2;;;30:1;27;20:12;5:2;2292:79:0;;;:::i;:::-;;;;-1:-1:-1;;;;;2292:79:0;;;;;;;;;;;;;;2658:94;;8:9:-1;5:2;;;30:1;27;20:12;5:2;2658:94:0;;;:::i;50073:44::-;;8:9:-1;5:2;;;30:1;27;20:12;5:2;50073:44:0;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;50073:44:0;-1:-1:-1;;;;;50073:44:0;;:::i;50967:182::-;;8:9:-1;5:2;;;30:1;27;20:12;5:2;50967:182:0;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;50967:182:0;-1:-1:-1;;;;;50967:182:0;;:::i;50031:35::-;;8:9:-1;5:2;;;30:1;27;20:12;5:2;50031:35:0;;;:::i;3398:110::-;;8:9:-1;5:2;;;30:1;27;20:12;5:2;3398:110:0;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;3398:110:0;-1:-1:-1;;;;;3398:110:0;;:::i;54574:976::-;50797:20;;50853:32;;;-1:-1:-1;;;50853:32:0;;;;54698:4;;-1:-1:-1;;;;;50797:20:0;;;;50853:30;;:32;;;;;;;;;;;;;;;50797:20;50853:32;;;5:2:-1;;;;30:1;27;20:12;5:2;50853:32:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;50853:32:0;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;50853:32:0;-1:-1:-1;;;;;50837:48:0;:12;:10;:12::i;:::-;-1:-1:-1;;;;;50837:48:0;;50829:106;;;;-1:-1:-1;;;50829:106:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;54715:18;;:::i;:::-;54736:26;54755:6;54736:18;:26::i;:::-;54715:47;;54783:16;:23;54810:1;54783:28;;54775:84;;;;-1:-1:-1;;;54775:84:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;54897:25:0;;;;;;:12;:25;;;;;54878:63;;54924:16;54878:18;:63::i;:::-;54870:110;;;;-1:-1:-1;;;54870:110:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;55009:16;;:23;55001:68;;;;;-1:-1:-1;;;55001:68:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;55080:19;55102:38;55123:4;:16;;;55102:20;:38::i;:::-;55080:60;;55161:4;:14;;;:21;55186:1;55161:26;;55153:64;;;;;-1:-1:-1;;;55153:64:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;55228:17;55248:36;55269:4;:14;;;55248:20;:36::i;:::-;55228:56;;55323:58;55345:11;55358:9;55369:4;:11;;;55323:21;:58::i;:::-;55315:131;;;;-1:-1:-1;;;55315:131:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;55508:11;;;;;55472:48;;-1:-1:-1;;;;;55472:48:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;55538:4:0;;54574:976;-1:-1:-1;;;;;;;54574:976:0:o;51416:314::-;51532:4;2504:9;:7;:9::i;:::-;2496:54;;;;;-1:-1:-1;;;2496:54:0;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;2496:54:0;;;;;;;;;;;;;;;-1:-1:-1;;;;;51549:27:0;;;;;;:12;:27;;;;;;;;-1:-1:-1;;;;;51549:38:0;;;;;;;;;:52;;;;;;;;:::i;:::-;;51617:83;51632:13;51647:9;51658:11;51671:28;51685:13;51671;:28::i;:::-;51617:83;;;;-1:-1:-1;;;;;51617:83:0;-1:-1:-1;;;;;51617:83:0;;;;;;-1:-1:-1;;;;;51617:83:0;-1:-1:-1;;;;;51617:83:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;23:1:-1;8:100;33:3;30:1;27:10;8:100;;;90:11;;;84:18;71:11;;;64:39;52:2;45:10;8:100;;;12:14;51617:83:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;51718:4:0;51416:314;;;;;:::o;51161:243::-;51258:4;2504:9;:7;:9::i;:::-;2496:54;;;;;-1:-1:-1;;;2496:54:0;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;2496:54:0;;;;;;;;;;;;;;;-1:-1:-1;;;;;51275:23:0;;;;;;:12;:23;;;;;;;;:41;;;;;;;;:::i;:::-;;51332:42;51347:9;51358:15;51332:42;;;;-1:-1:-1;;;;;51332:42:0;-1:-1:-1;;;;;51332:42:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;23:1:-1;8:100;33:3;30:1;27:10;8:100;;;90:11;;;84:18;71:11;;;64:39;52:2;45:10;8:100;;;12:14;51332:42:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;51392:4:0;51161:243;;;;:::o;50124:64::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;50124:64:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;55562:510::-;55629:7;-1:-1:-1;;;;;55653:27:0;;55649:416;;-1:-1:-1;55879:4:0;55906:16;55899:23;;55649:416;56018:35;;;-1:-1:-1;;;56018:35:0;;56047:4;56018:35;;;;;;55982:13;;-1:-1:-1;;;;;56018:20:0;;;;;:35;;;;;;;;;;;;;;;:20;:35;;;5:2:-1;;;;30:1;27;20:12;5:2;56018:35:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;56018:35:0;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;56018:35:0;;-1:-1:-1;56011:42:0;;-1:-1:-1;56011:42:0;55649:416;55562:510;;;:::o;3103:140::-;2504:9;:7;:9::i;:::-;2496:54;;;;;-1:-1:-1;;;2496:54:0;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;2496:54:0;;;;;;;;;;;;;;;3202:1;3186:6;;3165:40;;-1:-1:-1;;;;;3186:6:0;;;;3165:40;;3202:1;;3165:40;3233:1;3216:19;;-1:-1:-1;;;;;;3216:19:0;;;3103:140::o;52526:1352::-;52645:4;52670:11;52662:46;;;;;-1:-1:-1;;;52662:46:0;;;;;;;;;;;;-1:-1:-1;;;52662:46:0;;;;;;;;;;;;;;;52747:42;52767:13;52782:6;52747:19;:42::i;:::-;52739:118;;;;-1:-1:-1;;;52739:118:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;52905:27:0;;;;;;:12;:27;;;;;;;;-1:-1:-1;;;;;52905:38:0;;;;;;;;;;52878:65;;;;;;-1:-1:-1;;52878:65:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:24;;:65;;;52905:38;52878:65;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;52962:11;:18;52984:1;52962:23;;52954:61;;;;;-1:-1:-1;;;52954:61:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;53028:20;;:::i;:::-;53051:122;;;;;;;;53086:11;53051:122;;;;53123:9;53051:122;;;;53155:6;53051:122;;;53028:145;;53184:19;53206:24;53223:6;53206:16;:24::i;:::-;53184:46;;53251:32;53313:20;;;;;;;;;-1:-1:-1;;;;;53313:20:0;53251:83;;53345:16;53364:5;-1:-1:-1;;;;;53364:29:0;;:31;;;;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;53364:31:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;53364:31:0;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;53364:31:0;-1:-1:-1;;;;;53514:23:0;;53406:26;53514:23;;;:12;53364:31;53514:23;;;;;;;;53487:50;;;;;;;;;;-1:-1:-1;;53487:50:0;;;;;;;;;;;;;;;;;;;;;;;;;;53364:31;;-1:-1:-1;53364:31:0;;53487:24;;53514:23;;53487:50;;53514:23;53487:50;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;53556:11;:18;53578:1;53556:23;;53548:61;;;;;-1:-1:-1;;;53548:61:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;53628:4;-1:-1:-1;;;;;53628:15:0;;53644:9;53655:11;53678:6;53628:57;;;;;;;;;;;;;-1:-1:-1;;;;;53628:57:0;-1:-1:-1;;;;;53628:57:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;23:1:-1;8:100;33:3;30:1;27:10;8:100;;;90:11;;;84:18;71:11;;;64:39;52:2;45:10;8:100;;;12:14;53628:57:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;53628:57:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;23:1:-1;8:100;33:3;30:1;27:10;8:100;;;90:11;;;84:18;71:11;;;64:39;52:2;45:10;8:100;;;12:14;53628:57:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;53628:57:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;53628:57:0;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;53628:57:0;53620:117;;;;-1:-1:-1;;;53620:117:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;53755:81;53765:13;53780:12;:10;:12::i;:::-;53794:9;53805:11;53818:9;53829:6;53755:81;;;;-1:-1:-1;;;;;53755:81:0;-1:-1:-1;;;;;53755:81:0;;;;;;-1:-1:-1;;;;;53755:81:0;-1:-1:-1;;;;;53755:81:0;;;;;;-1:-1:-1;;;;;53755:81:0;-1:-1:-1;;;;;53755:81:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;23:1:-1;8:100;33:3;30:1;27:10;8:100;;;90:11;;;84:18;71:11;;;64:39;52:2;45:10;8:100;;;12:14;53755:81:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;53755:81:0;;;;;;;;;;;;;;;;;;;;;;23:1:-1;8:100;33:3;30:1;27:10;8:100;;;90:11;;;84:18;71:11;;;64:39;52:2;45:10;8:100;;;12:14;53755:81:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;53864:4:0;;52526:1352;-1:-1:-1;;;;;;;;;;;52526:1352:0:o;2292:79::-;2330:7;2357:6;-1:-1:-1;;;;;2357:6:0;2292:79;;:::o;2658:94::-;2698:4;2738:6;;-1:-1:-1;;;;;2738:6:0;2722:12;:10;:12::i;:::-;-1:-1:-1;;;;;2722:22:0;;2715:29;;2658:94;:::o;50073:44::-;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;50073:44:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;50967:182;2504:9;:7;:9::i;:::-;2496:54;;;;;-1:-1:-1;;;2496:54:0;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;2496:54:0;;;;;;;;;;;;;;;51045:20;:38;;-1:-1:-1;;;;;;51045:38:0;-1:-1:-1;;;;;51045:38:0;;;;;;;;;;;51099:42;;;51120:20;;;;51099:42;;;;;;;;;;;;;50967:182;:::o;50031:35::-;;;-1:-1:-1;;;;;50031:35:0;;:::o;3398:110::-;2504:9;:7;:9::i;:::-;2496:54;;;;;-1:-1:-1;;;2496:54:0;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;2496:54:0;;;;;;;;;;;;;;;3472:28;3491:8;3472:18;:28::i;:::-;3398:110;:::o;1056:98::-;1136:10;1056:98;:::o;58886:399::-;58959:13;;:::i;:::-;58985:18;;:::i;:::-;59014:11;59066:41;59094:7;59014:11;59066:27;:41::i;:::-;59040:67;;;;-1:-1:-1;59142:41:0;59170:7;59040:67;59142:27;:41::i;:::-;59119:14;;;59118:65;;;;;-1:-1:-1;59215:40:0;59242:7;59118:65;59215:26;:40::i;:::-;-1:-1:-1;59195:11:0;;;59194:61;-1:-1:-1;59195:11:0;58886:399;-1:-1:-1;;58886:399:0:o;13974:3160::-;14069:4;14086:12;14101:4;14086:19;;14207:14;14201:21;14797:1;14792;14786;14779:5;14775:13;14768:21;14761:5;14757:33;14753:41;14746:5;14742:53;14738:61;14834:10;14828:17;14944:7;14935;14932:20;14971:1;14966:2024;;;;17073:1;17062:12;;14925:2164;;14966:2024;15310:7;15303:15;15293:2;;15362;15353:7;15350:15;15392:1;15387:355;;;;16056:1;16178:14;16173:3;16166:27;16244:4;16239:3;16229:20;16303:4;16291:10;16287:21;16353:7;16349:2;16345:16;16514:419;16546:1;16541:2;16535:3;16531:2;16528:11;16524:20;16521:27;16514:419;;;16734:2;16728:9;16723:2;16717:9;16714:24;16704:2;;16833:1;16822:12;;16874:1;16868:7;;16704:2;16594:1;16590:2;16586:10;16580:16;;16640:4;16636:2;16632:13;16626:19;;16514:419;;;15772:1184;;;;15343:1613;;15387:355;15521:5;15513;15506;15502:17;15498:29;15489:38;;15597:4;15585:10;15581:21;15575:28;15568:5;15565:39;15555:2;;15691:1;15680:12;;15555:2;15343:1613;15293:2;-1:-1:-1;17119:7:0;;13974:3160;-1:-1:-1;;;;;;13974:3160:0:o;11542:447::-;11607:12;11645:3;:10;11659:2;11645:16;11637:64;;;;-1:-1:-1;;;11637:64:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;11963:4:0;11954:14;11948:21;;11721:259::o;56990:744::-;57095:4;-1:-1:-1;;;;;57116:66:0;;57112:593;;57404:44;;-1:-1:-1;;;;;57404:36:0;;;:44;;;;;57441:6;;57404:44;;;;57441:6;57404:36;:44;;;;;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;57404:44:0;57112:593;;;57579:58;57606:11;57619:9;57630:6;57579:26;:58::i;:::-;57571:122;;;;-1:-1:-1;;;57571:122:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;57722:4:0;56990:744;;;;;:::o;56078:906::-;56164:4;-1:-1:-1;;;;;56185:27:0;;56181:774;;56388:9;56380:60;;;;-1:-1:-1;;;56380:60:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;56476:6;56463:9;:19;56455:73;;;;-1:-1:-1;;;56455:73:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;56181:774;;;56646:9;:14;56638:61;;;;-1:-1:-1;;;56638:61:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;56811:76;56836:13;56851:12;:10;:12::i;:::-;56873:4;56880:6;56811:24;:76::i;:::-;56803:140;;;;-1:-1:-1;;;56803:140:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;56972:4:0;56078:906;;;;:::o;58519:359::-;58588:12;58613:17;58679:44;58706:4;:16;;;58679:26;:44::i;:::-;58738:42;58765:4;:14;;;58738:26;:42::i;:::-;58795:38;58821:4;:11;;;58795:25;:38::i;:::-;58648:200;;;;;;;;;;;;;;;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;;;299:10;344;;263:2;259:12;;;254:3;250:22;-1:-1;;246:30;311:9;;295:26;;;340:21;;377:20;365:33;;58648:200:0;;;;;;;;;;-1:-1:-1;58648:200:0;;;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;;;299:10;344;;263:2;259:12;;;254:3;250:22;-1:-1;;246:30;311:9;;295:26;;;340:21;;377:20;365:33;;58648:200:0;;;;;;;;;;-1:-1:-1;58648:200:0;;;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;;;58648:200:0;;;;;;;;;;;;;49:4:-1;39:7;30;26:21;22:32;13:7;6:49;58648:200:0;;;58641:207;;58866:4;58859:11;;;58519:359;;;:::o;3614:229::-;-1:-1:-1;;;;;3688:22:0;;3680:73;;;;-1:-1:-1;;;3680:73:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;3790:6;;;3769:38;;-1:-1:-1;;;;;3769:38:0;;;;3790:6;;;3769:38;;;3818:6;:17;;-1:-1:-1;;;;;;3818:17:0;-1:-1:-1;;;;;3818:17:0;;;;;;;;;;3614:229::o;38245:2656::-;38324:12;38338:7;38358:8;38393:25;38405:4;38411:6;38393:11;:25::i;:::-;38453:11;;38377:41;;-1:-1:-1;38377:41:0;;-1:-1:-1;38437:12:0;;;:27;;;;:52;;;38486:3;38477:6;:12;38468:6;:21;38437:52;38429:101;;;;-1:-1:-1;;;38429:101:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;38541:22;38604:11;;38629:1991;;;;40764:4;40758:11;40745:24;;40817:4;40806:9;40802:20;40796:4;40789:34;38597:2241;;38629:1991;38814:4;38808:11;38795:24;;39479:2;39474:3;39470:12;39867:9;39860:17;39854:4;39850:28;39838:9;39827;39823:25;39819:60;39916:3;39912:2;39908:12;40167:6;40153:9;40146:17;40140:4;40136:28;40124:9;40118:4;40114:20;40110:55;40106:68;39940:432;40201:3;40197:2;40194:11;39940:432;;;40343:9;;40332:21;;40243:4;40235:13;;;;40276;39940:432;;;-1:-1:-1;;40392:22:0;;;40600:2;40583:11;-1:-1:-1;;40579:25:0;40573:4;40566:39;-1:-1:-1;38597:2241:0;-1:-1:-1;40869:9:0;-1:-1:-1;40880:12:0;;;-1:-1:-1;38245:2656:0;;;;;;:::o;36900:975::-;36979:7;36988;37031:4;:11;37016:6;37025:2;37016:11;:26;;:50;;;;;37055:6;37064:2;37055:11;37046:6;:20;37016:50;37008:98;;;;-1:-1:-1;;;37008:98:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;37117:9;37183:4;37177:11;37217:4;37272;37321;37312:7;37308:18;37385:6;37378:4;37372;37368:15;37364:28;37358:35;37235:386;37420:7;37412:6;37409:19;37235:386;;;37598:6;37590;37585:20;37576:6;37566:8;37562:21;37554:52;37470:4;37462:6;37458:17;37448:27;;37515:4;37507:6;37503:17;37493:27;;37235:386;;;-1:-1:-1;;;37648:22:0;;37642:4;37635:36;37690:15;;-1:-1:-1;;;;;;37734:71:0;;;37726:107;;;;;-1:-1:-1;;;37726:107:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;37852:1;37864:2;37855:11;;;;;-1:-1:-1;;;36900:975:0:o;58161:346::-;58271:4;58316:11;58434:42;-1:-1:-1;;;;;58434:23:0;;58458:9;58469:6;58434:42;:23;:42;:::i;:::-;-1:-1:-1;58495:4:0;;58161:346;-1:-1:-1;;;;58161:346:0:o;57752:403::-;57883:4;57928:13;58065:59;-1:-1:-1;;;;;58065:27:0;;58093:11;58106:9;58117:6;58065:59;:27;:59;:::i;:::-;-1:-1:-1;58143:4:0;;57752:403;-1:-1:-1;;;;;57752:403:0:o;49171:185::-;49279:11;;49236:12;;49326:15;49279:11;49326:12;:15::i;:::-;49343:4;49309:39;;;;;;;;;;;;;;;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;;;299:10;344;;263:2;259:12;;;254:3;250:22;-1:-1;;246:30;311:9;;295:26;;;340:21;;377:20;365:33;;49309:39:0;;;;;;;;;;-1:-1:-1;49309:39:0;;;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;;;49309:39:0;;;;;;;;;;;;49:4:-1;39:7;30;26:21;22:32;13:7;6:49;49309:39:0;;;49302:46;;;49171:185;;;:::o;48256:747::-;48312:12;-1:-1:-1;;;;;48345:1:0;:71;;48337:111;;;;;-1:-1:-1;;;48337:111:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;48526:4;48520:11;48560:4;48578:21;;;48650:4;48686;48613:307;48717:7;48709:6;48706:19;48613:307;;;48902:1;48894:6;48889:15;48880:6;48873:4;48867;48863:15;48859:28;48851:54;48767:4;48755:17;;;;;-1:-1:-1;;48800:17:0;48613:307;;;-1:-1:-1;;;48957:4:0;48947:15;;;48934:29;;48947:15;48256:747;-1:-1:-1;;48256:747:0:o;42177:1186::-;42255:4;42261:7;42281:6;42312:22;42321:4;42327:6;42312:8;:22::i;:::-;42298:36;-1:-1:-1;42298:36:0;-1:-1:-1;42347:10:0;-1:-1:-1;;;;;;;;;42372:9:0;;;42368:988;;;42465:24;42476:4;42482:6;42465:10;:24::i;:::-;42447:42;-1:-1:-1;42447:42:0;;;-1:-1:-1;42521:4:0;42512:13;;;;;:32;;;42538:6;42529:5;:15;;42512:32;42504:76;;;;;-1:-1:-1;;;42504:76:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;42603:5;-1:-1:-1;42610:6:0;;-1:-1:-1;42595:22:0;;-1:-1:-1;42595:22:0;42368:988;-1:-1:-1;;;;;;;;;42639:9:0;;;42635:721;;;42732:24;42743:4;42749:6;42732:10;:24::i;:::-;42714:42;-1:-1:-1;42714:42:0;;;-1:-1:-1;42787:6:0;42779:14;;:37;;;;;42806:10;42797:5;:19;;42779:37;42771:82;;;;;-1:-1:-1;;;42771:82:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;42635:721;-1:-1:-1;;;;;;42912:9:0;;;;42908:448;;;43005:24;43016:4;43022:6;43005:10;:24::i;:::-;42987:42;-1:-1:-1;;;;;;42987:42:0;;-1:-1:-1;43060:10:0;43052:18;;43044:63;;;;;-1:-1:-1;;;43044:63:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;42908:448;-1:-1:-1;43227:8:0;;;;43266:4;43258:12;;43250:57;;;;;-1:-1:-1;;;43250:57:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;26351:176;26460:58;;;-1:-1:-1;;;;;26460:58:0;;;;;;;;;;;;;;;26:21:-1;;;22:32;;;6:49;;26460:58:0;;;;;;;;25:18:-1;;61:17;;-1:-1;;;;;182:15;-1:-1;;;179:29;160:49;;26434:85:0;;26453:5;;26434:18;:85::i;:::-;26351:176;;;:::o;26535:204::-;26662:68;;;-1:-1:-1;;;;;26662:68:0;;;;;;;;;;;;;;;;;;;;;;26:21:-1;;;22:32;;;6:49;;26662:68:0;;;;;;;;25:18:-1;;61:17;;-1:-1;;;;;182:15;-1:-1;;;179:29;160:49;;26636:95:0;;26655:5;;26636:18;:95::i;:::-;26535:204;;;;:::o;49364:453::-;49419:12;49452:4;49448:1;-1:-1:-1;;;;;49448:8:0;;49444:366;;;49473:20;49490:1;49473:10;:20::i;:::-;49466:27;;;;49444:366;49517:6;49512:1;-1:-1:-1;;;;;49512:11:0;;49508:302;;49558:15;-1:-1:-1;;;49558:9:0;:15::i;:::-;49575:22;49594:1;49575:11;:22::i;:::-;49541:57;;;;;;;;;;;;;;;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;;;299:10;344;;263:2;259:12;;;254:3;250:22;-1:-1;;246:30;311:9;;295:26;;;340:21;;377:20;365:33;;49541:57:0;;;;;;;;;;-1:-1:-1;49541:57:0;;;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;;;49541:57:0;;;;;;;;;;;;49:4:-1;39:7;30;26:21;22:32;13:7;6:49;49541:57:0;;;49534:64;;;;49508:302;49622:10;49617:1;-1:-1:-1;;;;;49617:15:0;;49613:197;;49673:15;-1:-1:-1;;;49673:9:0;:15::i;:::-;49690:22;49709:1;49690:11;:22::i;49613:197::-;49761:15;-1:-1:-1;;;;;;49761:9:0;:15::i;:::-;49778:22;49797:1;49778:11;:22::i;32097:337::-;32173:4;32179:7;32221:4;:11;32207:6;32216:1;32207:10;:25;;:48;;;;;32245:6;32254:1;32245:10;32236:6;:19;32207:48;32199:93;;;;;-1:-1:-1;;;32199:93:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;32354:28:0;;;32368:4;32354:28;32348:35;32424:1;32415:10;;32097:337;;;;;:::o;33549:608::-;33627:6;33635:7;33677:4;:11;33663:6;33672:1;33663:10;:25;;:48;;;;;33701:6;33710:1;33701:10;33692:6;:19;33663:48;33655:95;;;;-1:-1:-1;;;33655:95:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;33771:8;33836:4;33830:11;33896:6;33889:4;33883;33879:15;33875:28;33869:35;33947:6;33941:4;33936:18;33926:8;33918:37;34006:6;34003:1;33998:15;33991:4;33981:8;33977:19;33969:45;-1:-1:-1;34055:4:0;34041:19;;;34035:4;34028:33;-1:-1:-1;;34086:19:0;;;34080:26;;34138:10;;;-1:-1:-1;;;;33549:608:0:o;34457:875::-;34535:6;34543:7;34585:4;:11;34571:6;34580:1;34571:10;:25;;:48;;;;;34609:6;34618:1;34609:10;34600:6;:19;34571:48;34563:95;;;;-1:-1:-1;;;34563:95:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;34669:8;34734:4;34728:11;34768:4;34823;34872;34863:7;34859:18;34936:6;34929:4;34923;34919:15;34915:28;34909:35;34786:386;34971:7;34963:6;34960:19;34786:386;;;35149:6;35141;35136:20;35127:6;35117:8;35113:21;35105:52;35021:4;35013:6;35009:17;34999:27;;35066:4;35058:6;35054:17;35044:27;;34786:386;;;-1:-1:-1;;;35199:22:0;;;35193:4;35186:36;35265:4;35261:18;35247:33;;35241:40;;35322:1;35313:10;;;;;-1:-1:-1;;;;34457:875:0:o;35631:::-;35709:6;35717:7;35759:4;:11;35745:6;35754:1;35745:10;:25;;:48;;;;;35783:6;35792:1;35783:10;35774:6;:19;35745:48;35737:95;;;;-1:-1:-1;;;35737:95:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;35843:8;35908:4;35902:11;35942:4;35997;36046;36037:7;36033:18;36110:6;36103:4;36097;36093:15;36089:28;36083:35;35960:386;36145:7;36137:6;36134:19;35960:386;;;36323:6;36315;36310:20;36301:6;36291:8;36287:21;36279:52;36195:4;36187:6;36183:17;36173:27;;36240:4;36232:6;36228:17;36218:27;;35960:386;;;-1:-1:-1;;;36373:22:0;;;36367:4;36360:36;36439:4;36435:18;36421:33;;36415:40;;36496:1;36487:10;;;;;-1:-1:-1;;;;35631:875:0:o;28345:1119::-;28949:32;28974:5;28949:16;:32::i;:::-;28941:76;;;;;-1:-1:-1;;;28941:76:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;29091:12;29105:23;29140:5;-1:-1:-1;;;;;29132:19:0;29152:4;29132:25;;;;;;;;;;;;;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;;;29132:25: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;;29090:67:0;;;;29176:7;29168:52;;;;;-1:-1:-1;;;29168:52:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;29237:17;;:21;29233:224;;29379:10;29368:30;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;29368:30:0;29360:85;;;;-1:-1:-1;;;29360:85:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;45365:364;45507:4;45501:11;;45539:1;45526:15;;45583:3;45579:11;;;;45572:4;45562:15;;45555:36;45683:4;45673:15;;45660:29;;45501:11;45365:364::o;45095:110::-;45145:12;45177:20;45194:1;45188:8;;45177:10;:20::i;:::-;45170:27;45095:110;-1:-1:-1;;45095:110:0:o;45891:623::-;46037:4;46031:11;46071:4;46089:21;;;45945:12;;46031:11;46161:4;46197;46124:307;46228:7;46220:6;46217:19;46124:307;;;46413:1;46405:6;46400:15;46391:6;46384:4;46378;46374:15;46370:28;46362:54;46278:4;46266:17;;;;;-1:-1:-1;;46311:17:0;46124:307;;;-1:-1:-1;;;46468:4:0;46458:15;;46452:4;46445:29;46458:15;45891:623;-1:-1:-1;;45891:623:0:o;46680:620::-;46823:4;46817:11;46857:4;46875:21;;;46733:12;;46817:11;46947:4;46983;46910:307;47014:7;47006:6;47003:19;46910:307;;;47199:1;47191:6;47186:15;47177:6;47170:4;47164;47160:15;47156:28;47148:54;47064:4;47052:17;;;;;-1:-1:-1;;47097:17:0;46910:307;;;-1:-1:-1;;;47254:4:0;47244:15;;47238:4;47231:29;47244:15;46680:620;-1:-1:-1;;46680:620:0:o;47462:622::-;47607:4;47601:11;47641:4;47659:21;;;47515:12;;47601:11;47731:4;47767;47694:307;47798:7;47790:6;47787:19;47694:307;;;47983:1;47975:6;47970:15;47961:6;47954:4;47948;47944:15;47940:28;47932:54;47848:4;47836:17;;;;;-1:-1:-1;;47881:17:0;47694:307;;;-1:-1:-1;;;48038:4:0;48028:15;;48022:4;48015:29;48028:15;47462:622;-1:-1:-1;;47462:622:0:o;22191:810::-;22251:4;22910:20;;22753:66;22950:15;;;;;:42;;;22981:11;22969:8;:23;;22950:42;22942:51;22191:810;-1:-1:-1;;;;22191:810:0:o;49822:9466::-;;;;;;;;;;;;;;;;;;;;;;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;49822:9466:0;;;-1:-1:-1;49822:9466:0;:::i;:::-;;;:::o;:::-;;;;;;;;;;;;;;;;;
Metadata Hash
59a6456b8d5de77c49a7242fefd8988d606c162fcaf307f18991257c53c10bde
Age | Block | Fee Address | BC Fee Address | Voting Power | Jailed | Incoming |
---|
Make sure to use the "Vote Down" button for any spammy posts, and the "Vote Up" for interesting conversations.