Contract 0x3D08ce1f9609bB02F47192ff620634d9Eb0E7B56 4

Txn Hash Method
Block
From
To
Value [Txn Fee]
0x56d69448e798c5d96c4ab74ce0bb6ea09b7e4d0a891911f407416f752457c577Register Domain ...6727162022-03-24 16:56:0663 days 4 hrs ago0x2b241cbe6b455e08ade78a7ccc42de2403d7b566 IN  0x3d08ce1f9609bb02f47192ff620634d9eb0e7b560 GLMR0.0102958
0xd4cd5e6c2cef6cb57288d74c1e278e8b7af788ebb95790bff1095eb1b3a63ab2Register Domain ...2923022022-01-28 18:54:12118 days 2 hrs ago0x2b241cbe6b455e08ade78a7ccc42de2403d7b566 IN  0x3d08ce1f9609bb02f47192ff620634d9eb0e7b560 GLMR0.0048795
0xc32bb3f79f9b9add54643b161028ffbadb3b088e9a67ae657b2ddd227a4cd67b0x608060402922992022-01-28 18:53:36118 days 2 hrs ago0x2b241cbe6b455e08ade78a7ccc42de2403d7b566 IN  Create: BiconomyForwarder0 GLMR0.1369949
[ Download CSV Export 
Parent Txn Hash Block From To Value
Loading

Contract Source Code Verified (Exact Match)

Contract Name:
BiconomyForwarder

Compiler Version
v0.8.4+commit.c7e474f2

Optimization Enabled:
Yes with 200 runs

Other Settings:
default evmVersion, MIT license
/**
 *Submitted for verification at moonbeam.moonscan.io on 2022-01-28
*/

// SPDX-License-Identifier: MIT

pragma solidity 0.8.4;

/**
 * @dev Elliptic Curve Digital Signature Algorithm (ECDSA) operations.
 *
 * These functions can be used to verify that a message was signed by the holder
 * of the private keys of a given address.
 */
library ECDSA {
    enum RecoverError {
        NoError,
        InvalidSignature,
        InvalidSignatureLength,
        InvalidSignatureS,
        InvalidSignatureV
    }

    function _throwError(RecoverError error) private pure {
        if (error == RecoverError.NoError) {
            return; // no error: do nothing
        } else if (error == RecoverError.InvalidSignature) {
            revert("ECDSA: invalid signature");
        } else if (error == RecoverError.InvalidSignatureLength) {
            revert("ECDSA: invalid signature length");
        } else if (error == RecoverError.InvalidSignatureS) {
            revert("ECDSA: invalid signature 's' value");
        } else if (error == RecoverError.InvalidSignatureV) {
            revert("ECDSA: invalid signature 'v' value");
        }
    }

    /**
     * @dev Returns the address that signed a hashed message (`hash`) with
     * `signature` or error string. This address can then be used for verification purposes.
     *
     * The `ecrecover` EVM opcode allows for malleable (non-unique) signatures:
     * this function rejects them by requiring the `s` value to be in the lower
     * half order, and the `v` value to be either 27 or 28.
     *
     * IMPORTANT: `hash` _must_ be the result of a hash operation for the
     * verification to be secure: it is possible to craft signatures that
     * recover to arbitrary addresses for non-hashed data. A safe way to ensure
     * this is by receiving a hash of the original message (which may otherwise
     * be too long), and then calling {toEthSignedMessageHash} on it.
     *
     * Documentation for signature generation:
     * - with https://web3js.readthedocs.io/en/v1.3.4/web3-eth-accounts.html#sign[Web3.js]
     * - with https://docs.ethers.io/v5/api/signer/#Signer-signMessage[ethers]
     *
     * _Available since v4.3._
     */
    function tryRecover(bytes32 hash, bytes memory signature) internal pure returns (address, RecoverError) {
        // Check the signature length
        // - case 65: r,s,v signature (standard)
        // - case 64: r,vs signature (cf https://eips.ethereum.org/EIPS/eip-2098) _Available since v4.1._
        if (signature.length == 65) {
            bytes32 r;
            bytes32 s;
            uint8 v;
            // ecrecover takes the signature parameters, and the only way to get them
            // currently is to use assembly.
            assembly {
                r := mload(add(signature, 0x20))
                s := mload(add(signature, 0x40))
                v := byte(0, mload(add(signature, 0x60)))
            }
            return tryRecover(hash, v, r, s);
        } else if (signature.length == 64) {
            bytes32 r;
            bytes32 vs;
            // ecrecover takes the signature parameters, and the only way to get them
            // currently is to use assembly.
            assembly {
                r := mload(add(signature, 0x20))
                vs := mload(add(signature, 0x40))
            }
            return tryRecover(hash, r, vs);
        } else {
            return (address(0), RecoverError.InvalidSignatureLength);
        }
    }

    /**
     * @dev Returns the address that signed a hashed message (`hash`) with
     * `signature`. This address can then be used for verification purposes.
     *
     * The `ecrecover` EVM opcode allows for malleable (non-unique) signatures:
     * this function rejects them by requiring the `s` value to be in the lower
     * half order, and the `v` value to be either 27 or 28.
     *
     * IMPORTANT: `hash` _must_ be the result of a hash operation for the
     * verification to be secure: it is possible to craft signatures that
     * recover to arbitrary addresses for non-hashed data. A safe way to ensure
     * this is by receiving a hash of the original message (which may otherwise
     * be too long), and then calling {toEthSignedMessageHash} on it.
     */
    function recover(bytes32 hash, bytes memory signature) internal pure returns (address) {
        (address recovered, RecoverError error) = tryRecover(hash, signature);
        _throwError(error);
        return recovered;
    }

    /**
     * @dev Overload of {ECDSA-tryRecover} that receives the `r` and `vs` short-signature fields separately.
     *
     * See https://eips.ethereum.org/EIPS/eip-2098[EIP-2098 short signatures]
     *
     * _Available since v4.3._
     */
    function tryRecover(
        bytes32 hash,
        bytes32 r,
        bytes32 vs
    ) internal pure returns (address, RecoverError) {
        bytes32 s;
        uint8 v;
        assembly {
            s := and(vs, 0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff)
            v := add(shr(255, vs), 27)
        }
        return tryRecover(hash, v, r, s);
    }

    /**
     * @dev Overload of {ECDSA-recover} that receives the `r and `vs` short-signature fields separately.
     *
     * _Available since v4.2._
     */
    function recover(
        bytes32 hash,
        bytes32 r,
        bytes32 vs
    ) internal pure returns (address) {
        (address recovered, RecoverError error) = tryRecover(hash, r, vs);
        _throwError(error);
        return recovered;
    }

    /**
     * @dev Overload of {ECDSA-tryRecover} that receives the `v`,
     * `r` and `s` signature fields separately.
     *
     * _Available since v4.3._
     */
    function tryRecover(
        bytes32 hash,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) internal pure returns (address, RecoverError) {
        // EIP-2 still allows signature malleability for ecrecover(). Remove this possibility and make the signature
        // unique. Appendix F in the Ethereum Yellow paper (https://ethereum.github.io/yellowpaper/paper.pdf), defines
        // the valid range for s in (301): 0 < s < secp256k1n ÷ 2 + 1, and for v in (302): v ∈ {27, 28}. Most
        // signatures from current libraries generate a unique signature with an s-value in the lower half order.
        //
        // If your library generates malleable signatures, such as s-values in the upper range, calculate a new s-value
        // with 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141 - s1 and flip v from 27 to 28 or
        // vice versa. If your library also generates signatures with 0/1 for v instead 27/28, add 27 to v to accept
        // these malleable signatures as well.
        if (uint256(s) > 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20A0) {
            return (address(0), RecoverError.InvalidSignatureS);
        }
        if (v != 27 && v != 28) {
            return (address(0), RecoverError.InvalidSignatureV);
        }

        // If the signature is valid (and not malleable), return the signer address
        address signer = ecrecover(hash, v, r, s);
        if (signer == address(0)) {
            return (address(0), RecoverError.InvalidSignature);
        }

        return (signer, RecoverError.NoError);
    }

    /**
     * @dev Overload of {ECDSA-recover} that receives the `v`,
     * `r` and `s` signature fields separately.
     */
    function recover(
        bytes32 hash,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) internal pure returns (address) {
        (address recovered, RecoverError error) = tryRecover(hash, v, r, s);
        _throwError(error);
        return recovered;
    }

    /**
     * @dev Returns an Ethereum Signed Message, created from a `hash`. This
     * produces hash corresponding to the one signed with the
     * https://eth.wiki/json-rpc/API#eth_sign[`eth_sign`]
     * JSON-RPC method as part of EIP-191.
     *
     * See {recover}.
     */
    function toEthSignedMessageHash(bytes32 hash) internal pure returns (bytes32) {
        // 32 is the length in bytes of hash,
        // enforced by the type signature above
        return keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n32", hash));
    }

    /**
     * @dev Returns an Ethereum Signed Typed Data, created from a
     * `domainSeparator` and a `structHash`. This produces hash corresponding
     * to the one signed with the
     * https://eips.ethereum.org/EIPS/eip-712[`eth_signTypedData`]
     * JSON-RPC method as part of EIP-712.
     *
     * See {recover}.
     */
    function toTypedDataHash(bytes32 domainSeparator, bytes32 structHash) internal pure returns (bytes32) {
        return keccak256(abi.encodePacked("\x19\x01", domainSeparator, structHash));
    }
}


// File contracts/forward-v2/forwarder/ForwardRequestTypes.sol


pragma solidity 0.8.4;


/* deadline can be removed : GSN reference https://github.com/opengsn/gsn/blob/master/contracts/forwarder/IForwarder.sol (Saves 250 more gas)*/
/**
* @title ForwardRequestTypes 
* @notice specifies structures required by Forwarders to verify structured signatures.
* @notice This contract defines a struct which both ERC20Forwarder and BiconomyForwarder inherit. ERC20ForwardRequest includes all the fields present in the GSN V2 ForwardRequest struct, 
* but adds the following :
* address token : address of the token to pay for gas fees. For gasless transactions token address will be 0 address
* uint256 tokenGasPrice : gas price in the context of fee token
* uint256 txGas : gas to be supplied for recipient method call
* uint256 batchNonce : used for 2D nonces
* uint256 deadline 
* @dev Fields are placed in type order, to minimise storage used when executing transactions.
*/
contract ForwardRequestTypes {

/*allow the EVM to optimize for this, 
ensure that you try to order your storage variables and struct members such that they can be packed tightly*/

    struct ERC20ForwardRequest {
        address from; 
        address to; 
        address token; 
        uint256 txGas;
        uint256 tokenGasPrice;
        uint256 batchId; 
        uint256 batchNonce; 
        uint256 deadline; 
        bytes data;
    }

    //@review
    //should be SandBox Forward Request?
    struct ForwardRequest {
        string info;
        string warning; //optional
        string action;
        ERC20ForwardRequest request;
    }

     //For DAI and EIP2612 type Permits
     struct PermitRequest {
        address holder; 
        address spender;  
        uint256 value;
        uint256 nonce;
        uint256 expiry;
        bool allowed; 
        uint8 v;
        bytes32 r; 
        bytes32 s; 
    }

}


// File @openzeppelin/contracts/utils/[email protected]





/**
 * @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 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.
 */
abstract contract Context {
    function _msgSender() internal view virtual returns (address) {
        return msg.sender;
    }

    function _msgData() internal view virtual returns (bytes calldata) {
        return msg.data;
    }
}


// File @openzeppelin/contracts/access/[email protected]





/**
 * @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.
 *
 * By default, the owner account will be the one that deploys the contract. This
 * can later be changed with {transferOwnership}.
 *
 * 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.
 */
abstract 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() {
        _setOwner(_msgSender());
    }

    /**
     * @dev Returns the address of the current owner.
     */
    function owner() public view virtual returns (address) {
        return _owner;
    }

    /**
     * @dev Throws if called by any account other than the owner.
     */
    modifier onlyOwner() {
        require(owner() == _msgSender(), "Ownable: caller is not the 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 virtual onlyOwner {
        _setOwner(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 virtual onlyOwner {
        require(newOwner != address(0), "Ownable: new owner is the zero address");
        _setOwner(newOwner);
    }

    function _setOwner(address newOwner) private {
        address oldOwner = _owner;
        _owner = newOwner;
        emit OwnershipTransferred(oldOwner, newOwner);
    }
}


// File contracts/forward-v2/forwarder/BiconomyForwarder.sol


pragma solidity 0.8.4;



/**
 *
 * @title BiconomyForwarder
 *
 * @notice A trusted forwarder for Biconomy relayed meta transactions
 *
 * @dev - Inherits Forward Request structs from Forward Request Types
 * @dev - Verifies EIP712 signatures
 * @dev - Verifies traditional personalSign signatures
 * @dev - Implements 2D nonces... each Tx has a BatchId and a BatchNonce
 * @dev - Keeps track of highest BatchId used by a given address, to assist in encoding of transactions client-side
 * @dev - maintains a list of verified domain seperators
 *
 */

 //@review if experimental abiCoder is necessary for structs we need in calldata
 contract BiconomyForwarder is ForwardRequestTypes, Ownable {
    using ECDSA for bytes32;

    mapping(bytes32 => bool) public domains;

    uint256 chainId;

    string public constant EIP712_DOMAIN_TYPE = "EIP712Domain(string name,string version,address verifyingContract,bytes32 salt)";

    //@review and rename
    bytes32 public constant REQUEST_TYPEHASH = keccak256(bytes("ERC20ForwardRequest(address from,address to,address token,uint256 txGas,uint256 tokenGasPrice,uint256 batchId,uint256 batchNonce,uint256 deadline,bytes data)"));

    //@review
    //Could add more type hash and rename above one if multiple executeEIP712 is planned to be supported

    mapping(address => mapping(uint256 => uint256)) nonces;

    constructor(
    ) public {
        uint256 id;
        assembly {
            id := chainid()
        }
        chainId = id;
    }

    /**
     * @dev registers domain seperators, maintaining that all domain seperators used for EIP712 forward requests use...
     * ... the address of this contract and the chainId of the chain this contract is deployed to
     * @param name : name of dApp/dApp fee proxy
     * @param version : version of dApp/dApp fee proxy
     */
    function registerDomainSeparator(string calldata name, string calldata version) external onlyOwner{
        uint256 id;
        /* solhint-disable-next-line no-inline-assembly */
        assembly {
            id := chainid()
        }

        bytes memory domainValue = abi.encode(
            keccak256(bytes(EIP712_DOMAIN_TYPE)),
            keccak256(bytes(name)),
            keccak256(bytes(version)),
            address(this),
            bytes32(id));

        bytes32 domainHash = keccak256(domainValue);

        domains[domainHash] = true;
        emit DomainRegistered(domainHash, domainValue);
    }

    event DomainRegistered(bytes32 indexed domainSeparator, bytes domainValue);

    event MetaTransactionExecuted(address indexed userAddress, address indexed relayerAddress, bytes indexed functionSignature);

    /**
     * @dev returns a value from the nonces 2d mapping
     * @param from : the user address
     * @param batchId : the key of the user's batch being queried
     * @return nonce : the number of transaction made within said batch
     */
    function getNonce(address from, uint256 batchId)
    public view
    returns (uint256) {
        return nonces[from][batchId];
    }

    /**
     * @dev an external function which exposes the internal _verifySigEIP712 method
     * @param req : request being verified
     * @param domainSeparator : the domain separator presented to the user when signing
     * @param sig : the signature generated by the user's wallet
     */
    function verifyEIP712(
        ERC20ForwardRequest calldata req,
        bytes32 domainSeparator,
        bytes calldata sig)
    external view {
        _verifySigEIP712(req, domainSeparator, sig);
    }

    /**
     * @dev verifies the call is valid by calling _verifySigEIP712
     * @dev executes the forwarded call if valid
     * @dev updates the nonce after
     * @param req : request being executed
     * @param domainSeparator : the domain separator presented to the user when signing
     * @param sig : the signature generated by the user's wallet
     * @return success : false if call fails. true otherwise
     * @return ret : any return data from the call
     */
    function executeEIP712(
        ERC20ForwardRequest calldata req,
        bytes32 domainSeparator,
        bytes calldata sig
    )
    external 
    returns (bool success, bytes memory ret) {
        _verifySigEIP712(req,domainSeparator,sig);
        _updateNonce(req);
        /* solhint-disable-next-line avoid-low-level-calls */
         (success,ret) = req.to.call{gas : req.txGas}(abi.encodePacked(req.data, req.from));
         // Validate that the relayer has sent enough gas for the call.
        // See https://ronan.eth.link/blog/ethereum-gas-dangers/
        assert(gasleft() > req.txGas / 63);
        _verifyCallResult(success,ret,"Forwarded call to destination did not succeed");
        emit MetaTransactionExecuted(req.from, msg.sender, req.data);
    }

    /**
     * @dev an external function which exposes the internal _verifySigPersonSign method
     * @param req : request being verified
     * @param sig : the signature generated by the user's wallet
     */
    function verifyPersonalSign(
        ERC20ForwardRequest calldata req,
        bytes calldata sig)
    external view {
        _verifySigPersonalSign(req, sig);
    }

    /**
     * @dev verifies the call is valid by calling _verifySigPersonalSign
     * @dev executes the forwarded call if valid
     * @dev updates the nonce after
     * @param req : request being executed
     * @param sig : the signature generated by the user's wallet
     * @return success : false if call fails. true otherwise
     * @return ret : any return data from the call
     */
    function executePersonalSign(ERC20ForwardRequest calldata req,bytes calldata sig)
    external 
    returns(bool success, bytes memory ret){
        _verifySigPersonalSign(req, sig);
        _updateNonce(req);
        (success,ret) = req.to.call{gas : req.txGas}(abi.encodePacked(req.data, req.from));
        // Validate that the relayer has sent enough gas for the call.
        // See https://ronan.eth.link/blog/ethereum-gas-dangers/
        assert(gasleft() > req.txGas / 63);
        _verifyCallResult(success,ret,"Forwarded call to destination did not succeed");
        emit MetaTransactionExecuted(req.from, msg.sender, req.data);
    }

    /**
     * @dev Increments the nonce of given user/batch pair
     * @dev Updates the highestBatchId of the given user if the request's batchId > current highest
     * @dev only intended to be called post call execution
     * @param req : request that was executed
     */
    function _updateNonce(ERC20ForwardRequest calldata req) internal {
        nonces[req.from][req.batchId]++;
    }

    /**
     * @dev verifies the domain separator used has been registered via registerDomainSeparator()
     * @dev recreates the 32 byte hash signed by the user's wallet (as per EIP712 specifications)
     * @dev verifies the signature using Open Zeppelin's ECDSA library
     * @dev signature valid if call doesn't throw
     *
     * @param req : request being executed
     * @param domainSeparator : the domain separator presented to the user when signing
     * @param sig : the signature generated by the user's wallet
     *
     */
    function _verifySigEIP712(
        ERC20ForwardRequest calldata req,
        bytes32 domainSeparator,
        bytes memory sig)
    internal
    view
    {   
        uint256 id;
        /* solhint-disable-next-line no-inline-assembly */
        assembly {
            id := chainid()
        }
        require(req.deadline == 0 || block.timestamp + 20 <= req.deadline, "request expired");
        require(domains[domainSeparator], "unregistered domain separator");
        require(chainId == id, "potential replay attack on the fork");
        bytes32 digest =
            keccak256(abi.encodePacked(
                "\x19\x01",
                domainSeparator,
                keccak256(abi.encode(REQUEST_TYPEHASH,
                            req.from,
                            req.to,
                            req.token,
                            req.txGas,
                            req.tokenGasPrice,
                            req.batchId,
                            nonces[req.from][req.batchId],
                            req.deadline,
                            keccak256(req.data)
                        ))));
        require(digest.recover(sig) == req.from, "signature mismatch");
    }

    /**
     * @dev encodes a 32 byte data string (presumably a hash of encoded data) as per eth_sign
     *
     * @param hash : hash of encoded data that signed by user's wallet using eth_sign
     * @return input hash encoded to matched what is signed by the user's key when using eth_sign*/
    function prefixed(bytes32 hash) internal pure returns (bytes32) {
        return keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n32", hash));
    }

    /**
     * @dev recreates the 32 byte hash signed by the user's wallet
     * @dev verifies the signature using Open Zeppelin's ECDSA library
     * @dev signature valid if call doesn't throw
     *
     * @param req : request being executed
     * @param sig : the signature generated by the user's wallet
     *
     */
    function _verifySigPersonalSign(
        ERC20ForwardRequest calldata req,
        bytes memory sig)
    internal
    view
    {
        require(req.deadline == 0 || block.timestamp + 20 <= req.deadline, "request expired");
        bytes32 digest = prefixed(keccak256(abi.encodePacked(
            req.from,
            req.to,
            req.token,
            req.txGas,
            req.tokenGasPrice,
            req.batchId,
            nonces[req.from][req.batchId],
            req.deadline,
            keccak256(req.data)
        )));
        require(digest.recover(sig) == req.from, "signature mismatch");
    }

    /**
     * @dev verifies the call result and bubbles up revert reason for failed calls
     *
     * @param success : outcome of forwarded call
     * @param returndata : returned data from the frowarded call
     * @param errorMessage : fallback error message to show 
     */
     function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure {
        if (!success) {
            // Look for revert reason and bubble it up if present
            if (returndata.length > 0) {
                // The easiest way to bubble the revert reason is using memory via assembly

                // solhint-disable-next-line no-inline-assembly
                assembly {
                    let returndata_size := mload(returndata)
                    revert(add(32, returndata), returndata_size)
                }
            } else {
                revert(errorMessage);
            }
        }
    }

}

Contract ABI

[{"inputs":[],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"domainSeparator","type":"bytes32"},{"indexed":false,"internalType":"bytes","name":"domainValue","type":"bytes"}],"name":"DomainRegistered","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"userAddress","type":"address"},{"indexed":true,"internalType":"address","name":"relayerAddress","type":"address"},{"indexed":true,"internalType":"bytes","name":"functionSignature","type":"bytes"}],"name":"MetaTransactionExecuted","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"},{"inputs":[],"name":"EIP712_DOMAIN_TYPE","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"REQUEST_TYPEHASH","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"name":"domains","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"components":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"address","name":"token","type":"address"},{"internalType":"uint256","name":"txGas","type":"uint256"},{"internalType":"uint256","name":"tokenGasPrice","type":"uint256"},{"internalType":"uint256","name":"batchId","type":"uint256"},{"internalType":"uint256","name":"batchNonce","type":"uint256"},{"internalType":"uint256","name":"deadline","type":"uint256"},{"internalType":"bytes","name":"data","type":"bytes"}],"internalType":"struct ForwardRequestTypes.ERC20ForwardRequest","name":"req","type":"tuple"},{"internalType":"bytes32","name":"domainSeparator","type":"bytes32"},{"internalType":"bytes","name":"sig","type":"bytes"}],"name":"executeEIP712","outputs":[{"internalType":"bool","name":"success","type":"bool"},{"internalType":"bytes","name":"ret","type":"bytes"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"components":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"address","name":"token","type":"address"},{"internalType":"uint256","name":"txGas","type":"uint256"},{"internalType":"uint256","name":"tokenGasPrice","type":"uint256"},{"internalType":"uint256","name":"batchId","type":"uint256"},{"internalType":"uint256","name":"batchNonce","type":"uint256"},{"internalType":"uint256","name":"deadline","type":"uint256"},{"internalType":"bytes","name":"data","type":"bytes"}],"internalType":"struct ForwardRequestTypes.ERC20ForwardRequest","name":"req","type":"tuple"},{"internalType":"bytes","name":"sig","type":"bytes"}],"name":"executePersonalSign","outputs":[{"internalType":"bool","name":"success","type":"bool"},{"internalType":"bytes","name":"ret","type":"bytes"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"uint256","name":"batchId","type":"uint256"}],"name":"getNonce","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"string","name":"name","type":"string"},{"internalType":"string","name":"version","type":"string"}],"name":"registerDomainSeparator","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"components":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"address","name":"token","type":"address"},{"internalType":"uint256","name":"txGas","type":"uint256"},{"internalType":"uint256","name":"tokenGasPrice","type":"uint256"},{"internalType":"uint256","name":"batchId","type":"uint256"},{"internalType":"uint256","name":"batchNonce","type":"uint256"},{"internalType":"uint256","name":"deadline","type":"uint256"},{"internalType":"bytes","name":"data","type":"bytes"}],"internalType":"struct ForwardRequestTypes.ERC20ForwardRequest","name":"req","type":"tuple"},{"internalType":"bytes32","name":"domainSeparator","type":"bytes32"},{"internalType":"bytes","name":"sig","type":"bytes"}],"name":"verifyEIP712","outputs":[],"stateMutability":"view","type":"function"},{"inputs":[{"components":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"address","name":"token","type":"address"},{"internalType":"uint256","name":"txGas","type":"uint256"},{"internalType":"uint256","name":"tokenGasPrice","type":"uint256"},{"internalType":"uint256","name":"batchId","type":"uint256"},{"internalType":"uint256","name":"batchNonce","type":"uint256"},{"internalType":"uint256","name":"deadline","type":"uint256"},{"internalType":"bytes","name":"data","type":"bytes"}],"internalType":"struct ForwardRequestTypes.ERC20ForwardRequest","name":"req","type":"tuple"},{"internalType":"bytes","name":"sig","type":"bytes"}],"name":"verifyPersonalSign","outputs":[],"stateMutability":"view","type":"function"}]

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

Deployed ByteCode Sourcemap

14746:10381:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;18240:786;;;;;;:::i;:::-;;:::i;:::-;;;;;;;;:::i;:::-;;;;;;;;19251:171;;;;;;:::i;:::-;;:::i;:::-;;13394:94;;;:::i;19833:656::-;;;;;;:::i;:::-;;:::i;17090:136::-;;;;;;:::i;:::-;-1:-1:-1;;;;;17197:12:0;;;;17170:7;17197:12;;;:6;:12;;;;;;;;:21;;;;;;;;;17090:136;;;;7339:25:1;;;7327:2;7312:18;17090:136:0;7294:76:1;12743:87:0;12789:7;12816:6;12743:87;;-1:-1:-1;;;;;12816:6:0;;;6636:51:1;;6624:2;6609:18;12743:87:0;6591:102:1;15982:632:0;;;;;;:::i;:::-;;:::i;15076:220::-;;;:::i;17536:210::-;;;;;;:::i;:::-;;:::i;14916:125::-;;;:::i;:::-;;;;;;;:::i;14844:39::-;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;6863:14:1;;6856:22;6838:41;;6826:2;6811:18;14844:39:0;6793:92:1;13643:192:0;;;;;;:::i;:::-;;:::i;18240:786::-;18405:12;18419:16;18448:41;18465:3;18469:15;18485:3;;18448:41;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;18448:16:0;;-1:-1:-1;;;18448:41:0:i;:::-;18500:17;18513:3;18500:12;:17::i;:::-;18608:6;;;;;;;;:::i;:::-;-1:-1:-1;;;;;18608:11:0;18626:9;;;;18654:8;;;;18626:3;18654:8;:::i;:::-;18664;;;;:3;:8;:::i;:::-;18637:36;;;;;;;;;;:::i;:::-;;;;-1:-1:-1;;18637:36:0;;;;;;;;;;18608:66;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;18592:82:0;;-1:-1:-1;18592:82:0;-1:-1:-1;18843:14:0;18855:2;18843:9;;;;:14;:::i;:::-;18831:9;:26;18824:34;;-1:-1:-1;;;18824:34:0;;;;;;;;;18869:78;18887:7;18895:3;18869:78;;;;;;;;;;;;;;;;;:17;:78::i;:::-;19009:8;;;;:3;:8;:::i;:::-;18963:55;;;;;;;:::i;:::-;;;;;;;;;18997:10;18987:8;;;;:3;:8;:::i;:::-;-1:-1:-1;;;;;18963:55:0;;;;;;;;;;;18240:786;;;;;;;:::o;19251:171::-;19382:32;19405:3;19410;;19382:32;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;19382:22:0;;-1:-1:-1;;;19382:32:0:i;:::-;19251:171;;;:::o;13394:94::-;12789:7;12816:6;-1:-1:-1;;;;;12816:6:0;11628:10;12963:23;12955:68;;;;-1:-1:-1;;;12955:68:0;;;;;;;:::i;:::-;;;;;;;;;13459:21:::1;13477:1;13459:9;:21::i;:::-;13394:94::o:0;19833:656::-;19943:12;19957:16;19985:32;20008:3;20013;;19985:32;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;19985:22:0;;-1:-1:-1;;;19985:32:0:i;:::-;20028:17;20041:3;20028:12;:17::i;:::-;20072:6;;;;;;;;:::i;:::-;-1:-1:-1;;;;;20072:11:0;20090:9;;;;20118:8;;;;20090:3;20118:8;:::i;:::-;20128;;;;:3;:8;:::i;:::-;20101:36;;;;;;;;;;:::i;:::-;;;;-1:-1:-1;;20101:36:0;;;;;;;;;;20072:66;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;20056:82:0;;-1:-1:-1;20056:82:0;-1:-1:-1;20306:14:0;20318:2;20306:9;;;;:14;:::i;:::-;20294:9;:26;20287:34;;-1:-1:-1;;;20287:34:0;;;;;;;;;20332:78;20350:7;20358:3;20332:78;;;;;;;;;;;;;;;;;:17;:78::i;:::-;20472:8;;;;:3;:8;:::i;:::-;20426:55;;;;;;;:::i;:::-;;;;;;;;;20460:10;20450:8;;;;:3;:8;:::i;:::-;-1:-1:-1;;;;;20426:55:0;;;;;;;;;;;19833:656;;;;;;:::o;15982:632::-;12789:7;12816:6;-1:-1:-1;;;;;12816:6:0;11628:10;12963:23;12955:68;;;;-1:-1:-1;;;12955:68:0;;;;;;;:::i;:::-;16091:10:::1;16202:9;16196:15;;16234:24;16302:18;;;;;;;;;;;;;;;;;16286:36;;;;;;16353:4;;16337:22;;;;;;;:::i;:::-;;;;;;;;16390:7;;16374:25;;;;;;;:::i;:::-;;::::0;;;;;::::1;::::0;;16261:193:::1;::::0;::::1;8527:25:1::0;;;;8568:18;;8561:34;;;;8611:18;;;8604:34;;;;16422:4:0::1;8654:18:1::0;;;8647:60;8723:19;;;8716:35;;;8499:19;;16261:193:0::1;::::0;;-1:-1:-1;;16261:193:0;;::::1;::::0;;;;;;16488:22;;16261:193:::1;16488:22:::0;;::::1;::::0;;;;16467:18:::1;16523:19:::0;;;16545:4:::1;16523:19:::0;;;;;;;;:26;;-1:-1:-1;;16523:26:0::1;::::0;;::::1;::::0;;16261:193;-1:-1:-1;16488:22:0;;;16565:41:::1;::::0;::::1;::::0;16261:193;;16565:41:::1;:::i;:::-;;;;;;;;13034:1;;;15982:632:::0;;;;:::o;15076:220::-;15129:166;;;;;;;;;;;;;;;;;15119:177;;;;;;15076:220;:::o;17536:210::-;17695:43;17712:3;17717:15;17734:3;;17695:43;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;17695:16:0;;-1:-1:-1;;;17695:43:0:i;:::-;17536:210;;;;:::o;14916:125::-;;;;;;;;;;;;;;;;;;;:::o;13643:192::-;12789:7;12816:6;-1:-1:-1;;;;;12816:6:0;11628:10;12963:23;12955:68;;;;-1:-1:-1;;;12955:68:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;13732:22:0;::::1;13724:73;;;::::0;-1:-1:-1;;;13724:73:0;;10870:2:1;13724:73:0::1;::::0;::::1;10852:21:1::0;10909:2;10889:18;;;10882:30;10948:34;10928:18;;;10921:62;-1:-1:-1;;;10999:18:1;;;10992:36;11045:19;;13724:73:0::1;10842:228:1::0;13724:73:0::1;13808:19;13818:8;13808:9;:19::i;:::-;13643:192:::0;:::o;21458:1245::-;21743:9;21781:12;;;;:17;;:57;;-1:-1:-1;21826:12:0;;;;21802:20;:15;21820:2;21802:20;:::i;:::-;:36;;21781:57;21773:85;;;;-1:-1:-1;;;21773:85:0;;10166:2:1;21773:85:0;;;10148:21:1;10205:2;10185:18;;;10178:30;-1:-1:-1;;;10224:18:1;;;10217:45;10279:18;;21773:85:0;10138:165:1;21773:85:0;21877:24;;;;:7;:24;;;;;;;;21869:66;;;;-1:-1:-1;;;21869:66:0;;11680:2:1;21869:66:0;;;11662:21:1;11719:2;11699:18;;;11692:30;11758:31;11738:18;;;11731:59;11807:18;;21869:66:0;11652:179:1;21869:66:0;21965:2;21954:7;;:13;21946:61;;;;-1:-1:-1;;;21946:61:0;;12802:2:1;21946:61:0;;;12784:21:1;12841:2;12821:18;;;12814:30;12880:34;12860:18;;;12853:62;-1:-1:-1;;;12931:18:1;;;12924:33;12974:19;;21946:61:0;12774:225:1;21946:61:0;22018:14;22122:15;15129:166;;;;;;;;;;;;;;;;;15119:177;;;;;;;;22224:8;;;;:3;:8;:::i;:::-;22263:6;;;;;;;;:::i;:::-;22300:9;;;;;;;;:::i;:::-;22340:3;:9;;;22380:3;:17;;;22428:3;:11;;;22470:6;:16;22477:3;:8;;;;;;;;;;:::i;:::-;-1:-1:-1;;;;;22470:16:0;-1:-1:-1;;;;;22470:16:0;;;;;;;;;;;;:29;22487:3;:11;;;22470:29;;;;;;;;;;;;22530:3;:12;;;22583:3;:8;;;;;;;;:::i;:::-;22573:19;;;;;;;:::i;:::-;;;;;;;;;;22166:453;;;7774:25:1;;;;-1:-1:-1;;;;;7873:15:1;;;7853:18;;;7846:43;7925:15;;;7905:18;;;7898:43;7977:15;;;;7957:18;;;7950:43;8009:19;;;8002:35;;;;8053:19;;;8046:35;8097:19;;;8090:35;8141:19;;;8134:35;8185:19;;;8178:35;;;;8229:19;;;8222:35;;;;7746:19;;22166:453:0;;;;;;;;;;;;22156:464;;;;;;22058:563;;;;;;;;-1:-1:-1;;;6351:27:1;;6403:1;6394:11;;6387:27;;;;6439:2;6430:12;;6423:28;6476:2;6467:12;;6341:144;22058:563:0;;;;-1:-1:-1;;22058:563:0;;;;;;;;;22048:574;;22058:563;22048:574;;;;;-1:-1:-1;22664:8:0;;;;:3;:8;:::i;:::-;-1:-1:-1;;;;;22641:31:0;:19;:6;22656:3;22641:14;:19::i;:::-;-1:-1:-1;;;;;22641:31:0;;22633:62;;;;-1:-1:-1;;;22633:62:0;;13206:2:1;22633:62:0;;;13188:21:1;13245:2;13225:18;;;13218:30;-1:-1:-1;;;13264:18:1;;;13257:48;13322:18;;22633:62:0;13178:168:1;22633:62:0;21458:1245;;;;;:::o;20782:115::-;20858:6;:16;20865:8;;;;:3;:8;:::i;:::-;-1:-1:-1;;;;;20858:16:0;;;;;;;;;;;;;;;-1:-1:-1;20858:16:0;;;20875:11;;;;20858:29;;;;;;;:31;;;;;;:::i;:::-;;;;;;20782:115;:::o;24451:671::-;24574:7;24569:546;;24669:17;;:21;24665:439;;24932:10;24926:17;24993:15;24980:10;24976:2;24972:19;24965:44;24880:148;25075:12;25068:20;;-1:-1:-1;;;25068:20:0;;;;;;;;:::i;23513:640::-;23664:12;;;;:17;;:57;;-1:-1:-1;23709:12:0;;;;23685:20;:15;23703:2;23685:20;:::i;:::-;:36;;23664:57;23656:85;;;;-1:-1:-1;;;23656:85:0;;10166:2:1;23656:85:0;;;10148:21:1;10205:2;10185:18;;;10178:30;-1:-1:-1;;;10224:18:1;;;10217:45;10279:18;;23656:85:0;10138:165:1;23656:85:0;23752:14;23769:303;23819:8;;;;:3;:8;:::i;:::-;23842:6;;;;;;;;:::i;:::-;23863:9;;;;;;;;:::i;:::-;23887;;;;23911:17;;;;23943:11;;;;23969:6;:16;23976:8;;;;23887:3;23976:8;:::i;:::-;-1:-1:-1;;;;;23969:16:0;;;;;;;;;;;;;;;-1:-1:-1;23969:16:0;;;23986:11;;;;23969:29;;;;;;;;24013:12;;;;24050:8;;;;23986:3;24050:8;:::i;:::-;24040:19;;;;;;;:::i;:::-;;;;;;;;;-1:-1:-1;;4369:2:1;4365:15;;;4361:24;;23788:282:0;;;4349:37:1;4420:15;;;4416:24;;4402:12;;;4395:46;4475:15;;;;4471:24;;;4457:12;;;4450:46;4512:12;;;4505:28;;;;4549:12;;;4542:28;;;;4586:13;;;4579:29;4624:13;;;4617:29;4662:13;;;4655:29;;;;4700:13;;;4693:29;4738:13;;23788:282:0;;;;;;;;;;;;23778:293;;;;;;23103:58;;5950:66:1;23103:58:0;;;5938:79:1;6033:12;;;6026:28;;;23066:7:0;;6070:12:1;;23103:58:0;;;;;;;;;;;;23093:69;;;;;;23086:76;;23011:159;;;;23769:303;23752:320;-1:-1:-1;24114:8:0;;;;:3;:8;:::i;:::-;-1:-1:-1;;;;;24091:31:0;:19;:6;24106:3;24091:14;:19::i;:::-;-1:-1:-1;;;;;24091:31:0;;24083:62;;;;-1:-1:-1;;;24083:62:0;;13206:2:1;24083:62:0;;;13188:21:1;13245:2;13225:18;;;13218:30;-1:-1:-1;;;13264:18:1;;;13257:48;13322:18;;24083:62:0;13178:168:1;13843:173:0;13899:16;13918:6;;-1:-1:-1;;;;;13935:17:0;;;-1:-1:-1;;;;;;13935:17:0;;;;;;13968:40;;13918:6;;;;;;;13968:40;;13899:16;13968:40;13843:173;;:::o;4300:231::-;4378:7;4399:17;4418:18;4440:27;4451:4;4457:9;4440:10;:27::i;:::-;4398:69;;;;4478:18;4490:5;4478:11;:18::i;:::-;-1:-1:-1;4514:9:0;4300:231;-1:-1:-1;;;4300:231:0:o;2190:1308::-;2271:7;2280:12;2505:9;:16;2525:2;2505:22;2501:990;;;2801:4;2786:20;;2780:27;2851:4;2836:20;;2830:27;2909:4;2894:20;;2888:27;2544:9;2880:36;2952:25;2963:4;2880:36;2780:27;2830;2952:10;:25::i;:::-;2945:32;;;;;;;;;2501:990;2999:9;:16;3019:2;2999:22;2995:496;;;3274:4;3259:20;;3253:27;3325:4;3310:20;;3304:27;3367:23;3378:4;3253:27;3304;3367:10;:23::i;:::-;3360:30;;;;;;;;2995:496;-1:-1:-1;3439:1:0;;-1:-1:-1;3443:35:0;2995:496;2190:1308;;;;;:::o;461:643::-;539:20;530:5;:29;;;;;;-1:-1:-1;;;530:29:0;;;;;;;;;;526:571;;;461:643;:::o;526:571::-;637:29;628:5;:38;;;;;;-1:-1:-1;;;628:38:0;;;;;;;;;;624:473;;;683:34;;-1:-1:-1;;;683:34:0;;9813:2:1;683:34:0;;;9795:21:1;9852:2;9832:18;;;9825:30;9891:26;9871:18;;;9864:54;9935:18;;683:34:0;9785:174:1;624:473:0;748:35;739:5;:44;;;;;;-1:-1:-1;;;739:44:0;;;;;;;;;;735:362;;;800:41;;-1:-1:-1;;;800:41:0;;10510:2:1;800:41:0;;;10492:21:1;10549:2;10529:18;;;10522:30;10588:33;10568:18;;;10561:61;10639:18;;800:41:0;10482:181:1;735:362:0;872:30;863:5;:39;;;;;;-1:-1:-1;;;863:39:0;;;;;;;;;;859:238;;;919:44;;-1:-1:-1;;;919:44:0;;11277:2:1;919:44:0;;;11259:21:1;11316:2;11296:18;;;11289:30;11355:34;11335:18;;;11328:62;-1:-1:-1;;;11406:18:1;;;11399:32;11448:19;;919:44:0;11249:224:1;859:238:0;994:30;985:5;:39;;;;;;-1:-1:-1;;;985:39:0;;;;;;;;;;981:116;;;1041:44;;-1:-1:-1;;;1041:44:0;;12038:2:1;1041:44:0;;;12020:21:1;12077:2;12057:18;;;12050:30;12116:34;12096:18;;;12089:62;-1:-1:-1;;;12167:18:1;;;12160:32;12209:19;;1041:44:0;12010:224:1;5799:1632:0;5930:7;;6864:66;6851:79;;6847:163;;;-1:-1:-1;6963:1:0;;-1:-1:-1;6967:30:0;6947:51;;6847:163;7024:1;:7;;7029:2;7024:7;;:18;;;;;7035:1;:7;;7040:2;7035:7;;7024:18;7020:102;;;-1:-1:-1;7075:1:0;;-1:-1:-1;7079:30:0;7059:51;;7020:102;7236:24;;;7219:14;7236:24;;;;;;;;;8989:25:1;;;9062:4;9050:17;;9030:18;;;9023:45;;;;9084:18;;;9077:34;;;9127:18;;;9120:34;;;7236:24:0;;8961:19:1;;7236:24:0;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;7236:24:0;;-1:-1:-1;;7236:24:0;;;-1:-1:-1;;;;;;;7275:20:0;;7271:103;;7328:1;7332:29;7312:50;;;;;;;7271:103;7394:6;-1:-1:-1;7402:20:0;;-1:-1:-1;5799:1632:0;;;;;;;;:::o;4794:391::-;4908:7;;-1:-1:-1;;;;;5009:75:0;;5111:3;5107:12;;;5121:2;5103:21;5152:25;5163:4;5103:21;5172:1;5009:75;5152:10;:25::i;:::-;5145:32;;;;;;4794:391;;;;;;:::o;14:173:1:-;82:20;;-1:-1:-1;;;;;131:31:1;;121:42;;111:2;;177:1;174;167:12;111:2;63:124;;;:::o;192:375::-;243:8;253:6;307:3;300:4;292:6;288:17;284:27;274:2;;332:8;322;315:26;274:2;-1:-1:-1;362:20:1;;405:18;394:30;;391:2;;;444:8;434;427:26;391:2;488:4;480:6;476:17;464:29;;540:3;533:4;524:6;516;512:19;508:30;505:39;502:2;;;557:1;554;547:12;572:176;644:5;689:3;680:6;675:3;671:16;667:26;664:2;;;710:5;703;696:20;664:2;-1:-1:-1;736:6:1;654:94;-1:-1:-1;654:94:1:o;753:196::-;812:6;865:2;853:9;844:7;840:23;836:32;833:2;;;886:6;878;871:22;833:2;914:29;933:9;914:29;:::i;:::-;904:39;823:126;-1:-1:-1;;;823:126:1:o;954:264::-;1022:6;1030;1083:2;1071:9;1062:7;1058:23;1054:32;1051:2;;;1104:6;1096;1089:22;1051:2;1132:29;1151:9;1132:29;:::i;:::-;1122:39;1208:2;1193:18;;;;1180:32;;-1:-1:-1;;;1041:177:1:o;1223:190::-;1282:6;1335:2;1323:9;1314:7;1310:23;1306:32;1303:2;;;1356:6;1348;1341:22;1303:2;-1:-1:-1;1384:23:1;;1293:120;-1:-1:-1;1293:120:1:o;1418:749::-;1510:6;1518;1526;1534;1587:2;1575:9;1566:7;1562:23;1558:32;1555:2;;;1608:6;1600;1593:22;1555:2;1653:9;1640:23;1682:18;1723:2;1715:6;1712:14;1709:2;;;1744:6;1736;1729:22;1709:2;1788:58;1838:7;1829:6;1818:9;1814:22;1788:58;:::i;:::-;1865:8;;-1:-1:-1;1762:84:1;-1:-1:-1;1953:2:1;1938:18;;1925:32;;-1:-1:-1;1969:16:1;;;1966:2;;;2003:6;1995;1988:22;1966:2;;2047:60;2099:7;2088:8;2077:9;2073:24;2047:60;:::i;:::-;1545:622;;;;-1:-1:-1;2126:8:1;-1:-1:-1;;;;1545:622:1:o;2172:785::-;2298:6;2306;2314;2322;2375:2;2363:9;2354:7;2350:23;2346:32;2343:2;;;2396:6;2388;2381:22;2343:2;2441:9;2428:23;2470:18;2511:2;2503:6;2500:14;2497:2;;;2532:6;2524;2517:22;2497:2;2560:79;2631:7;2622:6;2611:9;2607:22;2560:79;:::i;:::-;2550:89;;2686:2;2675:9;2671:18;2658:32;2648:42;;2743:2;2732:9;2728:18;2715:32;2699:48;;2772:2;2762:8;2759:16;2756:2;;;2793:6;2785;2778:22;2962:717;3079:6;3087;3095;3148:2;3136:9;3127:7;3123:23;3119:32;3116:2;;;3169:6;3161;3154:22;3116:2;3214:9;3201:23;3243:18;3284:2;3276:6;3273:14;3270:2;;;3305:6;3297;3290:22;3270:2;3333:79;3404:7;3395:6;3384:9;3380:22;3333:79;:::i;:::-;3323:89;;3465:2;3454:9;3450:18;3437:32;3421:48;;3494:2;3484:8;3481:16;3478:2;;;3515:6;3507;3500:22;3478:2;;3559:60;3611:7;3600:8;3589:9;3585:24;3559:60;:::i;:::-;3106:573;;3638:8;;-1:-1:-1;3533:86:1;;-1:-1:-1;;;;3106:573:1:o;3684:257::-;3725:3;3763:5;3757:12;3790:6;3785:3;3778:19;3806:63;3862:6;3855:4;3850:3;3846:14;3839:4;3832:5;3828:16;3806:63;:::i;:::-;3923:2;3902:15;-1:-1:-1;;3898:29:1;3889:39;;;;3930:4;3885:50;;3733:208;-1:-1:-1;;3733:208:1:o;4762:273::-;4945:6;4937;4932:3;4919:33;4901:3;4971:16;;4996:15;;;4971:16;4909:126;-1:-1:-1;4909:126:1:o;5040:384::-;5251:6;5243;5238:3;5225:33;5345:2;5341:15;;;;-1:-1:-1;;5337:53:1;5277:16;;5326:65;;;5415:2;5407:11;;5215:209;-1:-1:-1;5215:209:1:o;5429:274::-;5558:3;5596:6;5590:13;5612:53;5658:6;5653:3;5646:4;5638:6;5634:17;5612:53;:::i;:::-;5681:16;;;;;5566:137;-1:-1:-1;;5566:137:1:o;6890:298::-;7073:6;7066:14;7059:22;7048:9;7041:41;7118:2;7113;7102:9;7098:18;7091:30;7022:4;7138:44;7178:2;7167:9;7163:18;7155:6;7138:44;:::i;:::-;7130:52;7031:157;-1:-1:-1;;;;7031:157:1:o;9165:217::-;9312:2;9301:9;9294:21;9275:4;9332:44;9372:2;9361:9;9357:18;9349:6;9332:44;:::i;12239:356::-;12441:2;12423:21;;;12460:18;;;12453:30;12519:34;12514:2;12499:18;;12492:62;12586:2;12571:18;;12413:182::o;13533:533::-;13610:4;13616:6;13676:11;13663:25;13770:2;13766:7;13755:8;13739:14;13735:29;13731:43;13711:18;13707:68;13697:2;;13792:4;13786;13779:18;13697:2;13822:33;;13874:20;;;-1:-1:-1;13917:18:1;13906:30;;13903:2;;;13952:4;13946;13939:18;13903:2;13988:4;13976:17;;-1:-1:-1;14019:14:1;14015:27;;;14005:38;;14002:2;;;14056:1;14053;14046:12;14071:128;14111:3;14142:1;14138:6;14135:1;14132:13;14129:2;;;14148:18;;:::i;:::-;-1:-1:-1;14184:9:1;;14119:80::o;14204:217::-;14244:1;14270;14260:2;;-1:-1:-1;;;14295:31:1;;14349:4;14346:1;14339:15;14377:4;14302:1;14367:15;14260:2;-1:-1:-1;14406:9:1;;14250:171::o;14426:258::-;14498:1;14508:113;14522:6;14519:1;14516:13;14508:113;;;14598:11;;;14592:18;14579:11;;;14572:39;14544:2;14537:10;14508:113;;;14639:6;14636:1;14633:13;14630:2;;;-1:-1:-1;;14674:1:1;14656:16;;14649:27;14479:205::o;14689:135::-;14728:3;-1:-1:-1;;14749:17:1;;14746:2;;;14769:18;;:::i;:::-;-1:-1:-1;14816:1:1;14805:13;;14736:88::o;14829:127::-;14890:10;14885:3;14881:20;14878:1;14871:31;14921:4;14918:1;14911:15;14945:4;14942:1;14935:15

Swarm Source

ipfs://2097c91bd976061fd913789ee0f58acc962494c391c5d4a2eda20081b94ff022
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.