Contract 0xaaaf06ee2d48761c845813be1a9eeb2d8dafd5ea 1

 
Txn Hash Method
Block
From
To
Value [Txn Fee]
0xdf8d7f54ed7de7ba5957572f605bfa31a780cd1c0cce8f1036c81345825233efClaim112850522021-09-27 17:19:0011 mins ago0x9fb89686c645fccef25bc1fb4028caa8351f1b2b IN  0xaaaf06ee2d48761c845813be1a9eeb2d8dafd5ea0 BNB0.00033268
0xe9ce811ad0836d02c461ccf24ed22e3abba947d5c7ad75349ea3c349c04d8517Claim112850422021-09-27 17:18:3011 mins ago0x23b4c21e96bb213c1563f6f189131a570ba94718 IN  0xaaaf06ee2d48761c845813be1a9eeb2d8dafd5ea0 BNB0.00033284
0xc1e095c648afe8c4e3c266ead9d28bab7b95ef41451a4031276afd8f4d8d980bClaim112849382021-09-27 17:13:1816 mins ago0x391feddfad5b8cb950ac50f0e073853c45e4997c IN  0xaaaf06ee2d48761c845813be1a9eeb2d8dafd5ea0 BNB0.00033283
0xa7fe4f7dcd28ea61a72af9fc9f09374621f2da0070c61a89e44d431f66ce7c72Claim112849342021-09-27 17:13:0616 mins ago0x391feddfad5b8cb950ac50f0e073853c45e4997c IN  0xaaaf06ee2d48761c845813be1a9eeb2d8dafd5ea0 BNB0.000399455
0xbb3212809ebba47c0f492bc8aba85da2e35a3381e0a6e090c71a751504df4250Claim112843072021-09-27 16:41:4048 mins ago0x982f2697931a6203277cb7400b12a7570d8ac810 IN  0xaaaf06ee2d48761c845813be1a9eeb2d8dafd5ea0 BNB0.00033269
0xe974f561fa3987bb7a2722f5ffe3f4d17d93656a6478d52681ff7319e25e4b0eClaim112843062021-09-27 16:41:3748 mins ago0x982f2697931a6203277cb7400b12a7570d8ac810 IN  0xaaaf06ee2d48761c845813be1a9eeb2d8dafd5ea0 BNB0.000399455
0x221a45c619aa0ae7c6673e96ac95db8feb71697f18bdd34d17a7b0883a8fac1aClaim112842932021-09-27 16:40:5849 mins ago0xceed1e6bbd6ee5f3fe1537488549da81a122aeaf IN  0xaaaf06ee2d48761c845813be1a9eeb2d8dafd5ea0 BNB0.00033284
0x91c2f654a48a786de2044bdc64996122714ad724d0b88e7aad635222646890b0Claim112841972021-09-27 16:36:0353 mins ago0xc21a818e977a5a15315263bec8ef06360ec275b8 IN  0xaaaf06ee2d48761c845813be1a9eeb2d8dafd5ea0 BNB0.000324455
0x5cd97103cf72eeafa127a03671ee753afb0cb66560d94e42b85f487f9bf0c15cClaim112838842021-09-27 16:20:231 hr 9 mins ago0x478802d422f85909a9c78a326a883f1c4b0fe4f3 IN  0xaaaf06ee2d48761c845813be1a9eeb2d8dafd5ea0 BNB0.00040769
0x6c5d152e18401d55765bd237564d3b672a6fb9d033a6e5fcf21ae0fd0050155cClaim112837912021-09-27 16:15:441 hr 14 mins ago0x542a7e1741adccfa0dcf97ade698a02b495c11e8 IN  0xaaaf06ee2d48761c845813be1a9eeb2d8dafd5ea0 BNB0.000324455
0x72048b7ed7de5b17afd12dc3f051df8677ce4ea974aad0e32c40c5dd787f70a1Claim112837882021-09-27 16:15:351 hr 14 mins ago0x542a7e1741adccfa0dcf97ade698a02b495c11e8 IN  0xaaaf06ee2d48761c845813be1a9eeb2d8dafd5ea0 BNB0.00040752
0xb6c9b7f2e3606816d0036bc29d9217f22541fc76a0aa4dda9be0c39b5a736dd6Claim112833522021-09-27 15:53:471 hr 36 mins ago0x3a2868bd71191477bf5a2be1fd7d7e2376914872 IN  0xaaaf06ee2d48761c845813be1a9eeb2d8dafd5ea0 BNB0.00040762
0x3259d3723dbd5769681a133c4b583f5ade198904f11f8bbc7b45df52481bd005Claim112830272021-09-27 15:37:321 hr 52 mins ago0x71491b4ea09a1963e03c559edeb3d75292a347d3 IN  0xaaaf06ee2d48761c845813be1a9eeb2d8dafd5ea0 BNB0.000324465
0x2846acfb6489b5765a1473e5d90759c855646e45a29110dd40b6bff3f3bfb7b2Claim112830252021-09-27 15:37:261 hr 52 mins ago0x71491b4ea09a1963e03c559edeb3d75292a347d3 IN  0xaaaf06ee2d48761c845813be1a9eeb2d8dafd5ea0 BNB0.00033279
0x89efb856664cd288472203cdd72a6bc8be26c21326ef2f477b72734bed3bbf12Claim112829532021-09-27 15:33:501 hr 56 mins ago0x0e6da9e9382aa6180680372c7eb10e12f4167b77 IN  0xaaaf06ee2d48761c845813be1a9eeb2d8dafd5ea0 BNB0.00040773
0xac1f8fa036eb5cef2f50a46cec4c4d336c727d55229641227f214f15ed1dcf6eClaim112826382021-09-27 15:18:052 hrs 11 mins ago0xd66225c67811bbdfb9f76eaed64eca755346637b IN  0xaaaf06ee2d48761c845813be1a9eeb2d8dafd5ea0 BNB0.000399495
0x0fe836637c637c25c9343adecd435cbea1a0705ee65992829c0f290ca3d5eab3Claim112824132021-09-27 15:06:502 hrs 23 mins ago0xd9cfab54f1234aeea22b2818ab919866a2809c1c IN  0xaaaf06ee2d48761c845813be1a9eeb2d8dafd5ea0 BNB0.000399455
0xe21f32e5d878e1761d717c5c0e61374f6aae1c92f4622f41f63204e5fb563983Claim112821822021-09-27 14:55:172 hrs 34 mins ago0x7a2331ed2bb665a2fe1bfd68234c47b777d9601c IN  0xaaaf06ee2d48761c845813be1a9eeb2d8dafd5ea0 BNB0.000324465
0x889ed2411b248f78b815c8172ec6b6be53d3e1f8586e590ce148240d9394c393Claim112821812021-09-27 14:55:142 hrs 34 mins ago0x7a2331ed2bb665a2fe1bfd68234c47b777d9601c IN  0xaaaf06ee2d48761c845813be1a9eeb2d8dafd5ea0 BNB0.000399215
0xe9090e1b9dd97d086602106e7f4d5c1dec96db2c2cf4c731311ea117c61b4358Claim112820912021-09-27 14:50:442 hrs 39 mins ago0x4a34f41379d6af0a2e65a0f5dfc1cee9794f96b9 IN  0xaaaf06ee2d48761c845813be1a9eeb2d8dafd5ea0 BNB0.000324355
0xe9d56edd90eadb467ea35bc62193b82afb3b3716b7f29828b6b0b178758c745cClaim112820862021-09-27 14:50:292 hrs 39 mins ago0x4a34f41379d6af0a2e65a0f5dfc1cee9794f96b9 IN  0xaaaf06ee2d48761c845813be1a9eeb2d8dafd5ea0 BNB0.000399515
0x54a4416db6cb49364963ee4114b09a1cb99ff0494989b6f6b1a2fb0cbc077027Claim112819542021-09-27 14:43:532 hrs 46 mins ago0x6a1f5a328fe4a9b37181fe375511fb24a0098719 IN  0xaaaf06ee2d48761c845813be1a9eeb2d8dafd5ea0 BNB0.00040757
0x255c2042a1d60be9f34961f061ff36981755a9709ffd68e38c17581c7deeff26Claim112818922021-09-27 14:40:462 hrs 49 mins ago0x6a5a32a7fcdd448a1d4e9b280911e0b189b33f26 IN  0xaaaf06ee2d48761c845813be1a9eeb2d8dafd5ea0 BNB0.00033265
0x48f990107e9d4c82bf59ba77aff2ff2a264ff4e6466231c44df11be0e3272afbClaim112818852021-09-27 14:40:252 hrs 49 mins ago0x6a5a32a7fcdd448a1d4e9b280911e0b189b33f26 IN  0xaaaf06ee2d48761c845813be1a9eeb2d8dafd5ea0 BNB0.000324455
0x428aa2910dd4fd4aeaafda0aa10f5160ca49c2d691eae050be250ff1335af191Claim112818172021-09-27 14:37:012 hrs 53 mins ago0xc0606685c64237755676004d4d38404479b5a14d IN  0xaaaf06ee2d48761c845813be1a9eeb2d8dafd5ea0 BNB0.00040778
[ Download CSV Export 
Parent Txn Hash Block From To Value
Loading

Contract Source Code Verified (Similar Match)
Note: This contract matches the deployed ByteCode of the Source Code for Contract 0x28D5a657374D535276ab72BDb3cdB365463bcd93

Contract Name:
MerkleDistributorManager

Compiler Version
v0.7.6+commit.7338295f

Optimization Enabled:
Yes with 200 runs

Other Settings:
default evmVersion, MIT license
/**
 *Submitted for verification at BscScan.com on 2021-06-25
*/

// File: @openzeppelin/contracts/token/ERC20/IERC20.sol


pragma solidity >=0.6.0 <0.8.0;

/**
 * @dev Interface of the ERC20 standard as defined in the EIP.
 */
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);
}

// File: @openzeppelin/contracts/cryptography/MerkleProof.sol


pragma solidity >=0.6.0 <0.8.0;

/**
 * @dev These functions deal with verification of Merkle trees (hash trees),
 */
library MerkleProof {
    /**
     * @dev Returns true if a `leaf` can be proved to be a part of a Merkle tree
     * defined by `root`. For this, a `proof` must be provided, containing
     * sibling hashes on the branch from the leaf to the root of the tree. Each
     * pair of leaves and each pair of pre-images are assumed to be sorted.
     */
    function verify(bytes32[] memory proof, bytes32 root, bytes32 leaf) internal pure returns (bool) {
        bytes32 computedHash = leaf;

        for (uint256 i = 0; i < proof.length; i++) {
            bytes32 proofElement = proof[i];

            if (computedHash <= proofElement) {
                // Hash(current computed hash + current element of the proof)
                computedHash = keccak256(abi.encodePacked(computedHash, proofElement));
            } else {
                // Hash(current element of the proof + current computed hash)
                computedHash = keccak256(abi.encodePacked(proofElement, computedHash));
            }
        }

        // Check if the computed hash (root) is equal to the provided root
        return computedHash == root;
    }
}

// File: contracts/SafeMath64.sol

// See https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/math/SafeMath.sol

pragma solidity =0.7.6;

/**
 * @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 SafeMath64 {
    /**
     * @dev Returns the addition of two unsigned integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `+` operator.
     *
     * Requirements:
     *
     * - Addition cannot overflow.
     */
    function add(uint64 a, uint64 b) internal pure returns (uint64) {
        uint64 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(uint64 a, uint64 b) internal pure returns (uint64) {
        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.
     */
    function sub(uint64 a, uint64 b, string memory errorMessage) internal pure returns (uint64) {
        require(b <= a, errorMessage);
        uint64 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(uint64 a, uint64 b) internal pure returns (uint64) {
        // 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;
        }

        uint64 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(uint64 a, uint64 b) internal pure returns (uint64) {
        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.
     */
    function div(uint64 a, uint64 b, string memory errorMessage) internal pure returns (uint64) {
        require(b > 0, errorMessage);
        uint64 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(uint64 a, uint64 b) internal pure returns (uint64) {
        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.
     */
    function mod(uint64 a, uint64 b, string memory errorMessage) internal pure returns (uint64) {
        require(b != 0, errorMessage);
        return a % b;
    }
}

// File: contracts/interfaces/IMerkleDistributorManager.sol

pragma solidity =0.7.6;



contract IMerkleDistributorManager {
    using SafeMath64 for uint64;

    struct Distribution {
        address token;
        bytes32 merkleRoot;
        uint256 remainingAmount;
    }

    uint64 public nextDistributionId = 1;
    mapping(uint64 => Distribution) public distributionMap;

    // This is a packed array of booleans.
    mapping(uint256 => mapping(uint256 => uint256)) private claimedBitMap;

    function token(uint64 distributionId) external view returns (address) {
        return distributionMap[distributionId].token;
    }

    function merkleRoot(uint64 distributionId) external view returns (bytes32) {
        return distributionMap[distributionId].merkleRoot;
    }

    function remainingAmount(uint64 distributionId) external view returns (uint256) {
        return distributionMap[distributionId].remainingAmount;
    }

    function isClaimed(uint64 distributionId, uint256 index) public view returns (bool) {
        uint256 claimedWordIndex = index / 256;
        uint256 claimedBitIndex = index % 256;
        uint256 claimedWord = claimedBitMap[distributionId][claimedWordIndex];
        uint256 mask = (1 << claimedBitIndex);
        return claimedWord & mask == mask;
    }

    function _setClaimed(uint64 distributionId, uint256 index) internal {
        uint256 claimedWordIndex = index / 256;
        uint256 claimedBitIndex = index % 256;
        claimedBitMap[distributionId][claimedWordIndex] =
        claimedBitMap[distributionId][claimedWordIndex] | (1 << claimedBitIndex);
    }

    function addDistribution(
        address payable newToken,
        bytes32 newMerkleRoot,
        uint256 allowance
    ) public {
        Distribution memory dist = Distribution(newToken, newMerkleRoot, allowance);
        distributionMap[nextDistributionId] = dist;
        nextDistributionId = nextDistributionId.add(1);
        IERC20 erc20 = IERC20(newToken);

        erc20.transferFrom(msg.sender, address(this), allowance);
    }

    event Claimed(
        uint64 indexed distributionId,
        address indexed account,
        uint256 amount
    );
}

// File: contracts/MerkleDistributorManager.sol

pragma solidity =0.7.6;




contract MerkleDistributorManager is IMerkleDistributorManager {
    function claim(
        uint64 distributionId,
        uint256 index,
        address account,
        uint256 amount,
        bytes32[] calldata merkleProof
    ) virtual external {
        require(!isClaimed(distributionId, index), 'MerkleDistributor: Drop already claimed.');
        Distribution storage dist = distributionMap[distributionId];
        require(amount <= dist.remainingAmount, "MerkleDistributor: Insufficient token.");

        // Verify the merkle proof.
        bytes32 node = keccak256(abi.encodePacked(index, account, amount));
        require(MerkleProof.verify(merkleProof, dist.merkleRoot, node), 'MerkleDistributor: Invalid proof.');

        // Mark it claimed and send the token.
        _setClaimed(distributionId, index);
        dist.remainingAmount = dist.remainingAmount - amount;

        require(IERC20(dist.token).transfer(account, amount), 'MerkleDistributor: Transfer failed.');

        emit Claimed(distributionId, account, amount);
    }
}

Contract Security Audit

Contract ABI

[{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint64","name":"distributionId","type":"uint64"},{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Claimed","type":"event"},{"inputs":[{"internalType":"address payable","name":"newToken","type":"address"},{"internalType":"bytes32","name":"newMerkleRoot","type":"bytes32"},{"internalType":"uint256","name":"allowance","type":"uint256"}],"name":"addDistribution","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint64","name":"distributionId","type":"uint64"},{"internalType":"uint256","name":"index","type":"uint256"},{"internalType":"address","name":"account","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"bytes32[]","name":"merkleProof","type":"bytes32[]"}],"name":"claim","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint64","name":"","type":"uint64"}],"name":"distributionMap","outputs":[{"internalType":"address","name":"token","type":"address"},{"internalType":"bytes32","name":"merkleRoot","type":"bytes32"},{"internalType":"uint256","name":"remainingAmount","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint64","name":"distributionId","type":"uint64"},{"internalType":"uint256","name":"index","type":"uint256"}],"name":"isClaimed","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint64","name":"distributionId","type":"uint64"}],"name":"merkleRoot","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"nextDistributionId","outputs":[{"internalType":"uint64","name":"","type":"uint64"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint64","name":"distributionId","type":"uint64"}],"name":"remainingAmount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint64","name":"distributionId","type":"uint64"}],"name":"token","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"}]

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

Deployed ByteCode Sourcemap

11942:1075:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;12012:1002;;;;;;;;;;;;;;;;-1:-1:-1;;;;;12012:1002:0;;;;;;;;;-1:-1:-1;;;;;12012:1002:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;12012:1002:0;;-1:-1:-1;12012:1002:0;-1:-1:-1;12012:1002:0;:::i;:::-;;10582:361;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;10582:361:0;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;9901:36;;;:::i;:::-;;;;-1:-1:-1;;;;;9901:36:0;;;;;;;;;;;;;;10421:153;;;;;;;;;;;;;;;;-1:-1:-1;10421:153:0;-1:-1:-1;;;;;10421:153:0;;:::i;:::-;;;;;;;;;;;;;;;;11274:449;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;11274:449:0;;;;;;;;;;;;;:::i;9944:54::-;;;;;;;;;;;;;;;;-1:-1:-1;9944:54:0;-1:-1:-1;;;;;9944:54:0;;:::i;:::-;;;;-1:-1:-1;;;;;9944:54:0;;;;;;;;;;;;;;;;;;;;;;;;;10270:143;;;;;;;;;;;;;;;;-1:-1:-1;10270:143:0;-1:-1:-1;;;;;10270:143:0;;:::i;10129:133::-;;;;;;;;;;;;;;;;-1:-1:-1;10129:133:0;-1:-1:-1;;;;;10129:133:0;;:::i;:::-;;;;-1:-1:-1;;;;;10129:133:0;;;;;;;;;;;;;;12012:1002;12219:32;12229:14;12245:5;12219:9;:32::i;:::-;12218:33;12210:86;;;;-1:-1:-1;;;12210:86:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;12335:31:0;;12307:25;12335:31;;;:15;:31;;;;;12395:20;;;;12385:30;;;12377:81;;;;-1:-1:-1;;;12377:81:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;12508:12;12550:5;12557:7;12566:6;12533:40;;;;;;;;;;;-1:-1:-1;;;;;12533:40:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;12523:51;;;;;;12508:66;;12593:54;12612:11;;12593:54;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;12625:15:0;;;;12642:4;12593:18;:54::i;:::-;12585:100;;;;-1:-1:-1;;;12585:100:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;12746:34;12758:14;12774:5;12746:11;:34::i;:::-;12814:20;;;;;:29;;;12791:52;;12871:10;;12864:44;;;-1:-1:-1;;;12864:44:0;;-1:-1:-1;;;;;12864:44:0;;;;;;;;;;;;;;;12871:10;;;;;12864:27;;:44;;;;;;;;;;;;;;-1:-1:-1;12871:10:0;12864:44;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;12864:44:0;12856:92;;;;-1:-1:-1;;;12856:92:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;12966:40;;;;;;;;-1:-1:-1;;;;;12966:40:0;;;-1:-1:-1;;;;;12966:40:0;;;;;;;;;;;;12012:1002;;;;;;;;:::o;10582:361::-;-1:-1:-1;;;;;10796:29:0;;;;10660:4;10796:29;;;:13;:29;;;;;;;;10712:3;10704:11;;10796:47;;;;;;;;10870:1;10752:11;;;;10870:20;;;;10909:18;;;:26;;10582:361::o;9901:36::-;;;-1:-1:-1;;;;;9901:36:0;;:::o;10421:153::-;-1:-1:-1;;;;;10519:31:0;10492:7;10519:31;;;:15;:31;;;;;:47;;;;10421:153::o;11274:449::-;11446:48;;;;;;;;-1:-1:-1;;;;;11446:48:0;;;;;;;;;;;;;;;;;;-1:-1:-1;11521:18:0;;-1:-1:-1;;;;;11521:18:0;;;11505:35;;:15;:35;;;;;;;:42;;;;-1:-1:-1;;;;;;11505:42:0;;;;;;;;;;;;;;;;;;;;;;;;11579:18;;11446:48;;11579:25;;:18;;:22;:25::i;:::-;11558:18;:46;;-1:-1:-1;;11558:46:0;-1:-1:-1;;;;;11558:46:0;;;;;;;;;;11659:56;;;-1:-1:-1;;;11659:56:0;;11678:10;11659:56;;;;11698:4;11659:56;;;;;;;;;;;;11637:8;;-1:-1:-1;;;;;11659:18:0;;;;;:56;;;;;;;;;;;;;;;;:18;:56;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;;11274:449:0:o;9944:54::-;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;9944:54:0;;;;;:::o;10270:143::-;-1:-1:-1;;;;;10363:31:0;10336:7;10363:31;;;:15;:31;;;;;;;;:42;;;10270:143::o;10129:133::-;-1:-1:-1;;;;;10217:31:0;10190:7;10217:31;;;:15;:31;;;;;:37;-1:-1:-1;;;;;10217:37:0;;10129:133::o;3360:796::-;3451:4;3491;3451;3508:525;3532:5;:12;3528:1;:16;3508:525;;;3566:20;3589:5;3595:1;3589:8;;;;;;;;;;;;;;3566:31;;3634:12;3618;:28;3614:408;;3788:12;3802;3771:44;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;3761:55;;;;;;3746:70;;3614:408;;;3978:12;3992;3961:44;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;3951:55;;;;;;3936:70;;3614:408;-1:-1:-1;3546:3:0;;3508:525;;;-1:-1:-1;4128:20:0;;;;3360:796;-1:-1:-1;;;3360:796:0:o;10951:315::-;-1:-1:-1;;;;;11186:29:0;;;;11030:24;11186:29;;;:13;:29;;;;;;;;11065:3;11057:11;;11186:47;;;;;;;;;11237:1;11105:11;;;;11237:20;;;;11186:72;;;11127:131;;10951:315::o;5174:177::-;5230:6;5260:5;;;-1:-1:-1;;;;;5284:6:0;;;;;;;;5276:46;;;;;-1:-1:-1;;;5276:46:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;5342:1;5174:177;-1:-1:-1;;;5174:177:0:o

Swarm Source

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