Contract 0x766909d0c5dec7eeb5deb00746f609e9bc31b6f4

 
Ad
Ad
Txn Hash
Block
From
To
Value
0xad10b122e2be2ba3d831a87e7d7ef2749c73bb870e4d745c117fa9855948a51b113547342020-11-29 16:34:5989 days 13 hrs agoLock3r: Deployer IN  0x766909d0c5dec7eeb5deb00746f609e9bc31b6f40 Ether0.001029812423.7
0x2b53ab1d29a55187e209aaba87cc2c252fc99089c0fd5700eefbe049ca0d3b54112965122020-11-20 18:11:5698 days 12 hrs agoLock3r: Deployer IN  Contract Creation0 Ether0.04403655271267.243800324
[ Download CSV Export 
View more zero value Internal Transactions in Advanced View mode
Loading

Contract Source Code Verified (Exact Match)

Contract Name:
Lock3rV1Helper

Compiler Version
v0.6.12+commit.27d51765

Optimization Enabled:
Yes with 200 runs

Other Settings:
default evmVersion, MIT license

Contract Source Code (Solidity)

/**
 *Submitted for verification at Etherscan.io on 2020-11-20
*/

// SPDX-License-Identifier: MIT
pragma solidity ^0.6.12;

/**
 * @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(uint a, uint b) internal pure returns (uint) {
        uint c = a + b;
        require(c >= a, "add: +");

        return c;
    }

    /**
     * @dev Returns the addition of two unsigned integers, reverting with custom message on overflow.
     *
     * Counterpart to Solidity's `+` operator.
     *
     * Requirements:
     * - Addition cannot overflow.
     */
    function add(uint a, uint b, string memory errorMessage) internal pure returns (uint) {
        uint c = a + b;
        require(c >= a, errorMessage);

        return c;
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, reverting on underflow (when the result is negative).
     *
     * Counterpart to Solidity's `-` operator.
     *
     * Requirements:
     * - Subtraction cannot underflow.
     */
    function sub(uint a, uint b) internal pure returns (uint) {
        return sub(a, b, "sub: -");
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, reverting with custom message on underflow (when the result is negative).
     *
     * Counterpart to Solidity's `-` operator.
     *
     * Requirements:
     * - Subtraction cannot underflow.
     */
    function sub(uint a, uint b, string memory errorMessage) internal pure returns (uint) {
        require(b <= a, errorMessage);
        uint 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(uint a, uint b) internal pure returns (uint) {
        // 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;
        }

        uint c = a * b;
        require(c / a == b, "mul: *");

        return c;
    }

    /**
     * @dev Returns the multiplication of two unsigned integers, reverting on overflow.
     *
     * Counterpart to Solidity's `*` operator.
     *
     * Requirements:
     * - Multiplication cannot overflow.
     */
    function mul(uint a, uint b, string memory errorMessage) internal pure returns (uint) {
        // 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;
        }

        uint c = a * b;
        require(c / a == b, errorMessage);

        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(uint a, uint b) internal pure returns (uint) {
        return div(a, b, "div: /");
    }

    /**
     * @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(uint a, uint b, string memory errorMessage) internal pure returns (uint) {
        // Solidity only automatically asserts when dividing by 0
        require(b > 0, errorMessage);
        uint 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(uint a, uint b) internal pure returns (uint) {
        return mod(a, b, "mod: %");
    }

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

library Math {
    /**
     * @dev Returns the largest of two numbers.
     */
    function max(uint256 a, uint256 b) internal pure returns (uint256) {
        return a >= b ? a : b;
    }

    /**
     * @dev Returns the smallest of two numbers.
     */
    function min(uint256 a, uint256 b) internal pure returns (uint256) {
        return a < b ? a : b;
    }

    /**
     * @dev Returns the average of two numbers. The result is rounded towards
     * zero.
     */
    function average(uint256 a, uint256 b) internal pure returns (uint256) {
        // (a + b) / 2 can overflow, so we distribute
        return (a / 2) + (b / 2) + ((a % 2 + b % 2) / 2);
    }
}

interface IChainLinkFeed {
    function latestAnswer() external view returns (int256);
}

interface ILock3rV1 {
    function totalBonded() external view returns (uint);
    function bonds(address locker, address credit) external view returns (uint);
    function votes(address locker) external view returns (uint);
}

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

    function _msgData() internal view virtual returns (bytes memory) {
        this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691
        return msg.data;
    }
}

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(_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 {
        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 virtual onlyOwner {
        require(newOwner != address(0), "Ownable: new owner is the zero address");
        emit OwnershipTransferred(_owner, newOwner);
        _owner = newOwner;
    }
}

interface IMiniLock3r {
    function isLocker(address) external returns (bool);
    function worked(address Locker) external;
    function totalBonded() external view returns (uint);
    function bonds(address Locker, address credit) external view returns (uint);
    function votes(address Locker) external view returns (uint);
    function isMinLocker(address Locker, uint minBond, uint earned, uint age) external returns (bool);
    function addCreditETH(address job) external payable;
    function workedETH(address Locker) external;
}

interface IUniswapV2SlidingOracle {
    function current(address tokenIn, uint amountIn, address tokenOut) external view returns (uint);
}

contract Lock3rV1Helper is Ownable{
    using SafeMath for uint;

    IChainLinkFeed public constant FASTGAS = IChainLinkFeed(0x169E633A2D1E6c10dD91238Ba11c4A708dfEF37C);
    IMiniLock3r public LK3R;
    IUniswapV2SlidingOracle public constant UV2SO = IUniswapV2SlidingOracle(0x061a92584Bc5bc2d91C08818993Ce1411DD34913);
    address public constant WETH = address(0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2);

    uint constant public MAX = 15;
    uint constant public BASE = 10;
    uint constant public SWAP = 300000;
    uint constant public TARGETBOND = 250e18; //Incentivises bigger holdings
    
    function quote(uint eth) public view returns (uint) {
        return UV2SO.current(address(WETH), eth, address(LK3R));
    }
    
    function setToken(address lockertoken) public onlyOwner{
        LK3R = IMiniLock3r(lockertoken);
    }

    function getFastGas() external view returns (uint) {
        return uint(FASTGAS.latestAnswer());
    }

    function bonds(address locker) public view returns (uint) {
        return LK3R.bonds(locker, address(LK3R)).add(LK3R.votes(locker));
    }

    function getQuoteLimitFor(address origin, uint gasUsed) public view returns (uint) {
        uint _min = quote((gasUsed.add(SWAP)).mul(uint(FASTGAS.latestAnswer())));
        uint _boost = _min.mul(MAX).div(BASE); // increase by 2.5
        uint _bond = Math.min(bonds(origin), TARGETBOND);
        return Math.max(_min, _boost.mul(_bond).div(TARGETBOND));
    }

    function getQuoteLimit(uint gasUsed) external view returns (uint) {
        return getQuoteLimitFor(tx.origin, gasUsed);
    }
}

Contract Security Audit

Contract ABI

[{"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":"BASE","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"FASTGAS","outputs":[{"internalType":"contract IChainLinkFeed","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"LK3R","outputs":[{"internalType":"contract IMiniLock3r","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"MAX","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"SWAP","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"TARGETBOND","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"UV2SO","outputs":[{"internalType":"contract IUniswapV2SlidingOracle","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"WETH","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"locker","type":"address"}],"name":"bonds","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getFastGas","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"gasUsed","type":"uint256"}],"name":"getQuoteLimit","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"origin","type":"address"},{"internalType":"uint256","name":"gasUsed","type":"uint256"}],"name":"getQuoteLimitFor","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":"uint256","name":"eth","type":"uint256"}],"name":"quote","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"lockertoken","type":"address"}],"name":"setToken","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"}]

608060405234801561001057600080fd5b50600061001b61006a565b600080546001600160a01b0319166001600160a01b0383169081178255604051929350917f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0908290a35061006e565b3390565b610a738061007d6000396000f3fe608060405234801561001057600080fd5b506004361061010b5760003560e01c8063904440bd116100a2578063dbbc4a5711610071578063dbbc4a57146101f7578063ec342ad0146101ff578063ed1bd76c14610207578063f2fde38b14610224578063fe10d7741461024a5761010b565b8063904440bd146101d757806395f9dac2146101df578063ad5c4648146101e7578063d49d5181146101ef5761010b565b8063525ea631116100de578063525ea631146101a2578063715018a6146101bf5780638da5cb5b146101c75780638e686d56146101cf5761010b565b80630421d7f21461011057806304d841081461014e578063144fa6d7146101565780634d8ea0de1461017e575b600080fd5b61013c6004803603604081101561012657600080fd5b506001600160a01b038135169060200135610270565b60408051918252519081900360200190f35b61013c610371565b61017c6004803603602081101561016c57600080fd5b50356001600160a01b0316610378565b005b610186610404565b604080516001600160a01b039092168252519081900360200190f35b61013c600480360360208110156101b857600080fd5b5035610413565b61017c61041f565b6101866104d3565b61013c6104e2565b61013c6104ef565b61018661056f565b610186610587565b61013c61059f565b6101866105a4565b61013c6105bc565b61013c6004803603602081101561021d57600080fd5b50356105c1565b61017c6004803603602081101561023a57600080fd5b50356001600160a01b0316610675565b61013c6004803603602081101561026057600080fd5b50356001600160a01b031661077f565b60008061030a61030573169e633a2d1e6c10dd91238ba11c4a708dfef37c6001600160a01b03166350d25bcd6040518163ffffffff1660e01b815260040160206040518083038186803b1580156102c657600080fd5b505afa1580156102da573d6000803e3d6000fd5b505050506040513d60208110156102f057600080fd5b50516102ff86620493e061087e565b906108c8565b6105c1565b90506000610324600a61031e84600f6108c8565b90610920565b905060006103436103348761077f565b680d8d726b7177a8000061094b565b905061036583610360680d8d726b7177a8000061031e86866108c8565b610961565b93505050505b92915050565b620493e081565b610380610971565b6000546001600160a01b039081169116146103e2576040805162461bcd60e51b815260206004820181905260248201527f4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572604482015290519081900360640190fd5b600180546001600160a01b0319166001600160a01b0392909216919091179055565b6001546001600160a01b031681565b600061036b3283610270565b610427610971565b6000546001600160a01b03908116911614610489576040805162461bcd60e51b815260206004820181905260248201527f4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572604482015290519081900360640190fd5b600080546040516001600160a01b03909116907f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0908390a3600080546001600160a01b0319169055565b6000546001600160a01b031690565b680d8d726b7177a8000081565b600073169e633a2d1e6c10dd91238ba11c4a708dfef37c6001600160a01b03166350d25bcd6040518163ffffffff1660e01b815260040160206040518083038186803b15801561053e57600080fd5b505afa158015610552573d6000803e3d6000fd5b505050506040513d602081101561056857600080fd5b5051905090565b73061a92584bc5bc2d91c08818993ce1411dd3491381565b73c02aaa39b223fe8d0a0e5c4f27ead9083c756cc281565b600f81565b73169e633a2d1e6c10dd91238ba11c4a708dfef37c81565b600a81565b600154604080516353ae9ce160e11b815273c02aaa39b223fe8d0a0e5c4f27ead9083c756cc26004820152602481018490526001600160a01b0390921660448301525160009173061a92584bc5bc2d91c08818993ce1411dd349139163a75d39c291606480820192602092909190829003018186803b15801561064357600080fd5b505afa158015610657573d6000803e3d6000fd5b505050506040513d602081101561066d57600080fd5b505192915050565b61067d610971565b6000546001600160a01b039081169116146106df576040805162461bcd60e51b815260206004820181905260248201527f4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572604482015290519081900360640190fd5b6001600160a01b0381166107245760405162461bcd60e51b8152600401808060200182810382526026815260200180610a186026913960400191505060405180910390fd5b600080546040516001600160a01b03808516939216917f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e091a3600080546001600160a01b0319166001600160a01b0392909216919091179055565b6001546040805163d8bff5a560e01b81526001600160a01b038481166004830152915160009361036b93169163d8bff5a5916024808301926020929190829003018186803b1580156107d057600080fd5b505afa1580156107e4573d6000803e3d6000fd5b505050506040513d60208110156107fa57600080fd5b50516001546040805163a39744b560e01b81526001600160a01b038781166004830152909216602483018190529051909163a39744b5916044808301926020929190829003018186803b15801561085057600080fd5b505afa158015610864573d6000803e3d6000fd5b505050506040513d602081101561087a57600080fd5b5051905b6000828201838110156108c1576040805162461bcd60e51b81526020600482015260066024820152656164643a202b60d01b604482015290519081900360640190fd5b9392505050565b6000826108d75750600061036b565b828202828482816108e457fe5b04146108c1576040805162461bcd60e51b815260206004820152600660248201526536bab61d101560d11b604482015290519081900360640190fd5b60006108c18383604051806040016040528060068152602001656469763a202f60d01b815250610975565b600081831061095a57816108c1565b5090919050565b60008183101561095a57816108c1565b3390565b60008183610a015760405162461bcd60e51b81526004018080602001828103825283818151815260200191508051906020019080838360005b838110156109c65781810151838201526020016109ae565b50505050905090810190601f1680156109f35780820380516001836020036101000a031916815260200191505b509250505060405180910390fd5b506000838581610a0d57fe5b049594505050505056fe4f776e61626c653a206e6577206f776e657220697320746865207a65726f2061646472657373a2646970667358221220e24ad8f5abdab6d08314ffb188df8b399b69d93541c2eae7c44af9fab399b1db64736f6c634300060c0033

Deployed ByteCode Sourcemap

10593:1639:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;11726:367;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;11726:367:0;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;11088:34;;;:::i;11351:105::-;;;;;;;;;;;;;;;;-1:-1:-1;11351:105:0;-1:-1:-1;;;;;11351:105:0;;:::i;:::-;;10772:23;;;:::i;:::-;;;;-1:-1:-1;;;;;10772:23:0;;;;;;;;;;;;;;12101:128;;;;;;;;;;;;;;;;-1:-1:-1;12101:128:0;;:::i;9343:148::-;;;:::i;8701:79::-;;;:::i;11129:40::-;;;:::i;11464:105::-;;;:::i;10802:115::-;;;:::i;10924:82::-;;;:::i;11015:29::-;;;:::i;10666:99::-;;;:::i;11051:30::-;;;:::i;11213:126::-;;;;;;;;;;;;;;;;-1:-1:-1;11213:126:0;;:::i;9646:244::-;;;;;;;;;;;;;;;;-1:-1:-1;9646:244:0;-1:-1:-1;;;;;9646:244:0;;:::i;11577:141::-;;;;;;;;;;;;;;;;-1:-1:-1;11577:141:0;-1:-1:-1;;;;;11577:141:0;;:::i;11726:367::-;11803:4;11820:9;11832:60;11838:53;10722:42;-1:-1:-1;;;;;11867:20:0;;:22;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;11867:22:0;11839:17;:7;11116:6;11839:11;:17::i;:::-;11838:23;;:53::i;:::-;11832:5;:60::i;:::-;11820:72;-1:-1:-1;11903:11:0;11917:23;11079:2;11917:13;11820:72;11042:2;11917:8;:13::i;:::-;:17;;:23::i;:::-;11903:37;;11970:10;11983:35;11992:13;11998:6;11992:5;:13::i;:::-;11163:6;11983:8;:35::i;:::-;11970:48;-1:-1:-1;12036:49:0;12045:4;12051:33;11163:6;12051:17;:6;11970:48;12051:10;:17::i;:33::-;12036:8;:49::i;:::-;12029:56;;;;;11726:367;;;;;:::o;11088:34::-;11116:6;11088:34;:::o;11351:105::-;8923:12;:10;:12::i;:::-;8913:6;;-1:-1:-1;;;;;8913:6:0;;;:22;;;8905:67;;;;;-1:-1:-1;;;8905:67:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;11417:4:::1;:31:::0;;-1:-1:-1;;;;;;11417:31:0::1;-1:-1:-1::0;;;;;11417:31:0;;;::::1;::::0;;;::::1;::::0;;11351:105::o;10772:23::-;;;-1:-1:-1;;;;;10772:23:0;;:::o;12101:128::-;12161:4;12185:36;12202:9;12213:7;12185:16;:36::i;9343:148::-;8923:12;:10;:12::i;:::-;8913:6;;-1:-1:-1;;;;;8913:6:0;;;:22;;;8905:67;;;;;-1:-1:-1;;;8905:67:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;9450:1:::1;9434:6:::0;;9413:40:::1;::::0;-1:-1:-1;;;;;9434:6:0;;::::1;::::0;9413:40:::1;::::0;9450:1;;9413:40:::1;9481:1;9464:19:::0;;-1:-1:-1;;;;;;9464:19:0::1;::::0;;9343:148::o;8701:79::-;8739:7;8766:6;-1:-1:-1;;;;;8766:6:0;8701:79;:::o;11129:40::-;11163:6;11129:40;:::o;11464:105::-;11509:4;10722:42;-1:-1:-1;;;;;11538:20:0;;:22;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;11538:22:0;;-1:-1:-1;11464:105:0;:::o;10802:115::-;10874:42;10802:115;:::o;10924:82::-;10963:42;10924:82;:::o;11015:29::-;11042:2;11015:29;:::o;10666:99::-;10722:42;10666:99;:::o;11051:30::-;11079:2;11051:30;:::o;11213:126::-;11325:4;;11283:48;;;-1:-1:-1;;;11283:48:0;;10963:42;11283:48;;;;;;;;;;-1:-1:-1;;;;;11325:4:0;;;11283:48;;;;;-1:-1:-1;;10874:42:0;;11283:13;;:48;;;;;;;;;;;;;;;10874:42;11283:48;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;11283:48:0;;11213:126;-1:-1:-1;;11213:126:0:o;9646:244::-;8923:12;:10;:12::i;:::-;8913:6;;-1:-1:-1;;;;;8913:6:0;;;:22;;;8905:67;;;;;-1:-1:-1;;;8905:67:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;9735:22:0;::::1;9727:73;;;;-1:-1:-1::0;;;9727:73:0::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;9837:6;::::0;;9816:38:::1;::::0;-1:-1:-1;;;;;9816:38:0;;::::1;::::0;9837:6;::::1;::::0;9816:38:::1;::::0;::::1;9865:6;:17:::0;;-1:-1:-1;;;;;;9865:17:0::1;-1:-1:-1::0;;;;;9865:17:0;;;::::1;::::0;;;::::1;::::0;;9646:244::o;11577:141::-;11691:4;;:18;;;-1:-1:-1;;;11691:18:0;;-1:-1:-1;;;;;11691:18:0;;;;;;;;;11629:4;;11653:57;;11691:4;;:10;;:18;;;;;;;;;;;;;;:4;:18;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;11691:18:0;11653:4;;:33;;;-1:-1:-1;;;11653:33:0;;-1:-1:-1;;;;;11653:33:0;;;;;;;:4;;;:33;;;;;;;;:4;;:10;;:33;;;;;11691:18;;11653:33;;;;;;;:4;:33;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;11653:33:0;;885:148;937:4;963:5;;;987:6;;;;979:25;;;;;-1:-1:-1;;;979:25:0;;;;;;;;;;;;-1:-1:-1;;;979:25:0;;;;;;;;;;;;;;;1024:1;885:148;-1:-1:-1;;;885:148:0:o;2548:432::-;2600:4;2842:6;2838:47;;-1:-1:-1;2872:1:0;2865:8;;2838:47;2906:5;;;2910:1;2906;:5;:1;2930:5;;;;;:10;2922:29;;;;;-1:-1:-1;;;2922:29:0;;;;;;;;;;;;-1:-1:-1;;;2922:29:0;;;;;;;;;;;;;;4155:103;4207:4;4231:19;4235:1;4238;4231:19;;;;;;;;;;;;;-1:-1:-1;;;4231:19:0;;;:3;:19::i;6550:106::-;6608:7;6639:1;6635;:5;:13;;6647:1;6635:13;;;-1:-1:-1;6643:1:0;;6550:106;-1:-1:-1;6550:106:0:o;6367:107::-;6425:7;6457:1;6452;:6;;:14;;6465:1;6452:14;;7846:106;7934:10;7846:106;:::o;4746:333::-;4826:4;4925:12;4918:5;4910:28;;;;-1:-1:-1;;;4910:28:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4949:6;4962:1;4958;:5;;;;;;;4746:333;-1:-1:-1;;;;;4746:333:0:o

Swarm Source

ipfs://e24ad8f5abdab6d08314ffb188df8b399b69d93541c2eae7c44af9fab399b1db
Block Transaction Difficulty Gas Used Reward
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.