Announcement: Binance Smart Chain is expected to undergo a scheduled hard fork upgrade at block height 13,082,000. For more information, read the blog here.

Contract 0x77d23aff927f3d46e51d449372c957b3cbbfb40e

 
 
Txn Hash Method
Block
From
To
Value [Txn Fee]
0xc438dc7f26622afcb0dd2bbbd0bc76a8fb70720b69c02b58bcc805365a3063c00x6080604067882122021-04-22 13:21:48222 days 4 hrs agoAlpaca Finance: Deployer IN  Contract Creation0 BNB0.00504445
[ Download CSV Export 
Parent Txn Hash Block From To Value
Loading

Contract Source Code Verified (Exact Match)

Contract Name:
PancakeswapV2StrategyAddBaseTokenOnly

Compiler Version
v0.6.6+commit.6c089d02

Optimization Enabled:
Yes with 1 runs

Other Settings:
istanbul EvmVersion, MIT license

Contract Source Code (Solidity)

/**
 *Submitted for verification at BscScan.com on 2021-04-22
*/

pragma solidity 0.6.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 SafeMath {
    /**
     * @dev Returns the addition of two unsigned integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `+` operator.
     *
     * Requirements:
     * - Addition cannot overflow.
     */
    function add(uint256 a, uint256 b) internal pure returns (uint256) {
        uint256 c = a + b;
        require(c >= a, "SafeMath: addition overflow");

        return c;
    }

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

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

        return c;
    }

    /**
     * @dev Returns the multiplication of two unsigned integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `*` operator.
     *
     * Requirements:
     * - Multiplication cannot overflow.
     */
    function mul(uint256 a, uint256 b) internal pure returns (uint256) {
        // Gas optimization: this is cheaper than requiring 'a' not being zero, but the
        // benefit is lost if 'b' is also tested.
        // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
        if (a == 0) {
            return 0;
        }

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

        return c;
    }

    /**
     * @dev Returns the integer division of two unsigned integers. Reverts on
     * division by zero. The result is rounded towards zero.
     *
     * Counterpart to Solidity's `/` operator. Note: this function uses a
     * `revert` opcode (which leaves remaining gas untouched) while Solidity
     * uses an invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     * - The divisor cannot be zero.
     */
    function div(uint256 a, uint256 b) internal pure returns (uint256) {
        return div(a, b, "SafeMath: division by zero");
    }

    /**
     * @dev Returns the integer division of two unsigned integers. Reverts with custom message on
     * division by zero. The result is rounded towards zero.
     *
     * Counterpart to Solidity's `/` operator. Note: this function uses a
     * `revert` opcode (which leaves remaining gas untouched) while Solidity
     * uses an invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     * - The divisor cannot be zero.
     */
    function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        // Solidity only automatically asserts when dividing by 0
        require(b > 0, errorMessage);
        uint256 c = a / b;
        // assert(a == b * c + a % b); // There is no case in which this doesn't hold

        return c;
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * Reverts when dividing by zero.
     *
     * Counterpart to Solidity's `%` operator. This function uses a `revert`
     * opcode (which leaves remaining gas untouched) while Solidity uses an
     * invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     * - The divisor cannot be zero.
     */
    function mod(uint256 a, uint256 b) internal pure returns (uint256) {
        return mod(a, b, "SafeMath: modulo by zero");
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * Reverts with custom message when dividing by zero.
     *
     * Counterpart to Solidity's `%` operator. This function uses a `revert`
     * opcode (which leaves remaining gas untouched) while Solidity uses an
     * invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     * - The divisor cannot be zero.
     */
    function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        require(b != 0, errorMessage);
        return a % b;
    }
}

/**
 * @title Initializable
 *
 * @dev Helper contract to support initializer functions. To use it, replace
 * the constructor with a function that has the `initializer` modifier.
 * WARNING: Unlike constructors, initializer functions must be manually
 * invoked. This applies both to deploying an Initializable contract, as well
 * as extending an Initializable contract via inheritance.
 * WARNING: When used with inheritance, manual care must be taken to not invoke
 * a parent initializer twice, or ensure that all initializers are idempotent,
 * because this is not dealt with automatically as with constructors.
 */
contract Initializable {

  /**
   * @dev Indicates that the contract has been initialized.
   */
  bool private initialized;

  /**
   * @dev Indicates that the contract is in the process of being initialized.
   */
  bool private initializing;

  /**
   * @dev Modifier to use in the initializer function of a contract.
   */
  modifier initializer() {
    require(initializing || isConstructor() || !initialized, "Contract instance has already been initialized");

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

    _;

    if (isTopLevelCall) {
      initializing = false;
    }
  }

  /// @dev Returns true if and only if the function is running in the constructor
  function isConstructor() private view returns (bool) {
    // extcodesize checks the size of the code stored in an address, and
    // address returns the current address. Since the code is still not
    // deployed when running a constructor, any checks on its code size will
    // yield zero, making it an effective way to detect if a contract is
    // under construction or not.
    address self = address(this);
    uint256 cs;
    assembly { cs := extcodesize(self) }
    return cs == 0;
  }

  // Reserved storage space to allow for layout changes in the future.
  uint256[50] private ______gap;
}

/**
 * @dev Contract module that helps prevent reentrant calls to a function.
 *
 * Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier
 * available, which can be applied to functions to make sure there are no nested
 * (reentrant) calls to them.
 *
 * Note that because there is a single `nonReentrant` guard, functions marked as
 * `nonReentrant` may not call one another. This can be worked around by making
 * those functions `private`, and then adding `external` `nonReentrant` entry
 * points to them.
 *
 * TIP: If you would like to learn more about reentrancy and alternative ways
 * to protect against it, check out our blog post
 * https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul].
 */
contract ReentrancyGuardUpgradeSafe is Initializable {
    bool private _notEntered;


    function __ReentrancyGuard_init() internal initializer {
        __ReentrancyGuard_init_unchained();
    }

    function __ReentrancyGuard_init_unchained() internal initializer {


        // Storing an initial non-zero value makes deployment a bit more
        // expensive, but in exchange the refund on every call to nonReentrant
        // will be lower in amount. Since refunds are capped to a percetange of
        // the total transaction's gas, it is best to keep them low in cases
        // like this one, to increase the likelihood of the full refund coming
        // into effect.
        _notEntered = true;

    }


    /**
     * @dev Prevents a contract from calling itself, directly or indirectly.
     * Calling a `nonReentrant` function from another `nonReentrant`
     * function is not supported. It is possible to prevent this from happening
     * by making the `nonReentrant` function external, and make it call a
     * `private` function that does the actual work.
     */
    modifier nonReentrant() {
        // On the first call to nonReentrant, _notEntered will be true
        require(_notEntered, "ReentrancyGuard: reentrant call");

        // Any calls to nonReentrant after this point will fail
        _notEntered = false;

        _;

        // By storing the original value once again, a refund is triggered (see
        // https://eips.ethereum.org/EIPS/eip-2200)
        _notEntered = true;
    }

    uint256[49] private __gap;
}

interface IPancakeFactory {
    event PairCreated(address indexed token0, address indexed token1, address pair, uint);

    function feeTo() external view returns (address);
    function feeToSetter() external view returns (address);

    function getPair(address tokenA, address tokenB) external view returns (address pair);
    function allPairs(uint) external view returns (address pair);
    function allPairsLength() external view returns (uint);

    function createPair(address tokenA, address tokenB) external returns (address pair);

    function setFeeTo(address) external;
    function setFeeToSetter(address) external;
}

interface IPancakePair {
    event Approval(address indexed owner, address indexed spender, uint value);
    event Transfer(address indexed from, address indexed to, uint value);

    function name() external pure returns (string memory);
    function symbol() external pure returns (string memory);
    function decimals() external pure returns (uint8);
    function totalSupply() external view returns (uint);
    function balanceOf(address owner) external view returns (uint);
    function allowance(address owner, address spender) external view returns (uint);

    function approve(address spender, uint value) external returns (bool);
    function transfer(address to, uint value) external returns (bool);
    function transferFrom(address from, address to, uint value) external returns (bool);

    function DOMAIN_SEPARATOR() external view returns (bytes32);
    function PERMIT_TYPEHASH() external pure returns (bytes32);
    function nonces(address owner) external view returns (uint);

    function permit(address owner, address spender, uint value, uint deadline, uint8 v, bytes32 r, bytes32 s) external;

    event Mint(address indexed sender, uint amount0, uint amount1);
    event Burn(address indexed sender, uint amount0, uint amount1, address indexed to);
    event Swap(
        address indexed sender,
        uint amount0In,
        uint amount1In,
        uint amount0Out,
        uint amount1Out,
        address indexed to
    );
    event Sync(uint112 reserve0, uint112 reserve1);

    function MINIMUM_LIQUIDITY() external pure returns (uint);
    function factory() external view returns (address);
    function token0() external view returns (address);
    function token1() external view returns (address);
    function getReserves() external view returns (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast);
    function price0CumulativeLast() external view returns (uint);
    function price1CumulativeLast() external view returns (uint);
    function kLast() external view returns (uint);

    function mint(address to) external returns (uint liquidity);
    function burn(address to) external returns (uint amount0, uint amount1);
    function swap(uint amount0Out, uint amount1Out, address to, bytes calldata data) external;
    function skim(address to) external;
    function sync() external;

    function initialize(address, address) external;
}

interface IPancakeRouter02 {
  function factory() external pure returns (address);

  function WETH() external pure returns (address);

  function addLiquidity(
    address tokenA,
    address tokenB,
    uint256 amountADesired,
    uint256 amountBDesired,
    uint256 amountAMin,
    uint256 amountBMin,
    address to,
    uint256 deadline
  )
    external
    returns (
      uint256 amountA,
      uint256 amountB,
      uint256 liquidity
    );

  function addLiquidityETH(
    address token,
    uint256 amountTokenDesired,
    uint256 amountTokenMin,
    uint256 amountETHMin,
    address to,
    uint256 deadline
  )
    external
    payable
    returns (
      uint256 amountToken,
      uint256 amountETH,
      uint256 liquidity
    );

  function removeLiquidity(
    address tokenA,
    address tokenB,
    uint256 liquidity,
    uint256 amountAMin,
    uint256 amountBMin,
    address to,
    uint256 deadline
  ) external returns (uint256 amountA, uint256 amountB);

  function removeLiquidityETH(
    address token,
    uint256 liquidity,
    uint256 amountTokenMin,
    uint256 amountETHMin,
    address to,
    uint256 deadline
  ) external returns (uint256 amountToken, uint256 amountETH);

  function removeLiquidityWithPermit(
    address tokenA,
    address tokenB,
    uint256 liquidity,
    uint256 amountAMin,
    uint256 amountBMin,
    address to,
    uint256 deadline,
    bool approveMax,
    uint8 v,
    bytes32 r,
    bytes32 s
  ) external returns (uint256 amountA, uint256 amountB);

  function removeLiquidityETHWithPermit(
    address token,
    uint256 liquidity,
    uint256 amountTokenMin,
    uint256 amountETHMin,
    address to,
    uint256 deadline,
    bool approveMax,
    uint8 v,
    bytes32 r,
    bytes32 s
  ) external returns (uint256 amountToken, uint256 amountETH);

  function swapExactTokensForTokens(
    uint256 amountIn,
    uint256 amountOutMin,
    address[] calldata path,
    address to,
    uint256 deadline
  ) external returns (uint256[] memory amounts);

  function swapTokensForExactTokens(
    uint256 amountOut,
    uint256 amountInMax,
    address[] calldata path,
    address to,
    uint256 deadline
  ) external returns (uint256[] memory amounts);

  function swapExactETHForTokens(
    uint256 amountOutMin,
    address[] calldata path,
    address to,
    uint256 deadline
  ) external payable returns (uint256[] memory amounts);

  function swapTokensForExactETH(
    uint256 amountOut,
    uint256 amountInMax,
    address[] calldata path,
    address to,
    uint256 deadline
  ) external returns (uint256[] memory amounts);

  function swapExactTokensForETH(
    uint256 amountIn,
    uint256 amountOutMin,
    address[] calldata path,
    address to,
    uint256 deadline
  ) external returns (uint256[] memory amounts);

  function swapETHForExactTokens(
    uint256 amountOut,
    address[] calldata path,
    address to,
    uint256 deadline
  ) external payable returns (uint256[] memory amounts);

  function quote(
    uint256 amountA,
    uint256 reserveA,
    uint256 reserveB
  ) external pure returns (uint256 amountB);

  function getAmountOut(
    uint256 amountIn,
    uint256 reserveIn,
    uint256 reserveOut
  ) external pure returns (uint256 amountOut);

  function getAmountIn(
    uint256 amountOut,
    uint256 reserveIn,
    uint256 reserveOut
  ) external pure returns (uint256 amountIn);

  function getAmountsOut(uint256 amountIn, address[] calldata path)
    external
    view
    returns (uint256[] memory amounts);

  function getAmountsIn(uint256 amountOut, address[] calldata path)
    external
    view
    returns (uint256[] memory amounts);

  function removeLiquidityETHSupportingFeeOnTransferTokens(
    address token,
    uint256 liquidity,
    uint256 amountTokenMin,
    uint256 amountETHMin,
    address to,
    uint256 deadline
  ) external returns (uint256 amountETH);

  function removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(
    address token,
    uint256 liquidity,
    uint256 amountTokenMin,
    uint256 amountETHMin,
    address to,
    uint256 deadline,
    bool approveMax,
    uint8 v,
    bytes32 r,
    bytes32 s
  ) external returns (uint256 amountETH);

  function swapExactTokensForTokensSupportingFeeOnTransferTokens(
    uint256 amountIn,
    uint256 amountOutMin,
    address[] calldata path,
    address to,
    uint256 deadline
  ) external;

  function swapExactETHForTokensSupportingFeeOnTransferTokens(
    uint256 amountOutMin,
    address[] calldata path,
    address to,
    uint256 deadline
  ) external payable;

  function swapExactTokensForETHSupportingFeeOnTransferTokens(
    uint256 amountIn,
    uint256 amountOutMin,
    address[] calldata path,
    address to,
    uint256 deadline
  ) external;
}

interface IStrategy {
  /// @dev Execute worker strategy.
  /// @param user The original user that is interacting with the operator.
  /// @param debt The user's total debt, for better decision making context.
  /// @param data Extra calldata information passed along to this strategy.
  function execute(address user, uint256 debt, bytes calldata data) external;
}

interface ERC20Interface {
  function balanceOf(address user) external view returns (uint256);
}

library SafeToken {
  function myBalance(address token) internal view returns (uint256) {
    return ERC20Interface(token).balanceOf(address(this));
  }

  function balanceOf(address token, address user) internal view returns (uint256) {
    return ERC20Interface(token).balanceOf(user);
  }

  function safeApprove(address token, address to, uint256 value) internal {
    // bytes4(keccak256(bytes('approve(address,uint256)')));
    (bool success, bytes memory data) = token.call(abi.encodeWithSelector(0x095ea7b3, to, value));
    require(success && (data.length == 0 || abi.decode(data, (bool))), "!safeApprove");
  }

  function safeTransfer(address token, address to, uint256 value) internal {
    // bytes4(keccak256(bytes('transfer(address,uint256)')));
    (bool success, bytes memory data) = token.call(abi.encodeWithSelector(0xa9059cbb, to, value));
    require(success && (data.length == 0 || abi.decode(data, (bool))), "!safeTransfer");
  }

  function safeTransferFrom(address token, address from, address to, uint256 value) internal {
    // bytes4(keccak256(bytes('transferFrom(address,address,uint256)')));
    (bool success, bytes memory data) = token.call(abi.encodeWithSelector(0x23b872dd, from, to, value));
    require(success && (data.length == 0 || abi.decode(data, (bool))), "!safeTransferFrom");
  }

  function safeTransferETH(address to, uint256 value) internal {
    // solhint-disable-next-line no-call-value
    (bool success, ) = to.call{value: value}(new bytes(0));
    require(success, "!safeTransferETH");
  }
}

library AlpacaMath {
  // implementation from https://github.com/Uniswap/uniswap-lib/commit/99f3f28770640ba1bb1ff460ac7c5292fb8291a0
  // original implementation: https://github.com/abdk-consulting/abdk-libraries-solidity/blob/master/ABDKMath64x64.sol#L687
  function sqrt(uint x) internal pure returns (uint) {
    if (x == 0) return 0;
    uint xx = x;
    uint r = 1;

    if (xx >= 0x100000000000000000000000000000000) {
      xx >>= 128;
      r <<= 64;
    }

    if (xx >= 0x10000000000000000) {
      xx >>= 64;
      r <<= 32;
    }
    if (xx >= 0x100000000) {
      xx >>= 32;
      r <<= 16;
    }
    if (xx >= 0x10000) {
      xx >>= 16;
      r <<= 8;
    }
    if (xx >= 0x100) {
      xx >>= 8;
      r <<= 4;
    }
    if (xx >= 0x10) {
      xx >>= 4;
      r <<= 2;
    }
    if (xx >= 0x8) {
      r <<= 1;
    }

    r = (r + x / r) >> 1;
    r = (r + x / r) >> 1;
    r = (r + x / r) >> 1;
    r = (r + x / r) >> 1;
    r = (r + x / r) >> 1;
    r = (r + x / r) >> 1;
    r = (r + x / r) >> 1; // Seven iterations should be enough
    uint r1 = x / r;
    return (r < r1 ? r : r1);
  }
}

contract PancakeswapV2StrategyAddBaseTokenOnly is ReentrancyGuardUpgradeSafe, IStrategy {
  using SafeToken for address;
  using SafeMath for uint256;

  IPancakeFactory public factory;
  IPancakeRouter02 public router;

  /// @dev Create a new add Token only strategy instance.
  /// @param _router The Uniswap router smart contract.
  function initialize(IPancakeRouter02 _router) external initializer {
    ReentrancyGuardUpgradeSafe.__ReentrancyGuard_init();

    factory = IPancakeFactory(_router.factory());
    router = _router;
  }

  /// @dev Execute worker strategy. Take BaseToken. Return LP tokens.
  /// @param data Extra calldata information passed along to this strategy.
  function execute(address /* user */, uint256 /* debt */, bytes calldata data)
    external
    override
    nonReentrant
  {
    // 1. Find out what farming token we are dealing with and min additional LP tokens.
    (
      address baseToken,
      address farmingToken,
      uint256 minLPAmount
    ) = abi.decode(data, (address, address, uint256));
    IPancakePair lpToken = IPancakePair(factory.getPair(farmingToken, baseToken));
    // 2. Approve router to do their stuffs
    farmingToken.safeApprove(address(router), uint256(-1));
    baseToken.safeApprove(address(router), uint256(-1));
    // 3. Compute the optimal amount of baseToken to be converted to farmingToken.
    uint256 balance = baseToken.myBalance();
    (uint256 r0, uint256 r1, ) = lpToken.getReserves();
    uint256 rIn = lpToken.token0() == baseToken ? r0 : r1;
    // find how many baseToken need to be converted to farmingToken
    // Constants come from
    // 2-f = 2-0.0025 = 19975
    // 4(1-f) = 4*9975*10000 = 399000000, where f = 0.0025 and 10,000 is a way to avoid floating point
    // 19975^2 = 399000625
    // 9975*2 = 19950
    uint256 aIn = AlpacaMath.sqrt(rIn.mul(balance.mul(399000000).add(rIn.mul(399000625)))).sub(rIn.mul(19975)) / 19950;
    // 4. Convert that portion of baseToken to farmingToken.
    address[] memory path = new address[](2);
    path[0] = baseToken;
    path[1] = farmingToken;
    router.swapExactTokensForTokens(aIn, 0, path, address(this), now);
    // 5. Mint more LP tokens and return all LP tokens to the sender.
    (,, uint256 moreLPAmount) = router.addLiquidity(
      baseToken, farmingToken, baseToken.myBalance(), farmingToken.myBalance(), 0, 0, address(this), now
    );
    require(moreLPAmount >= minLPAmount, "StrategyAddBaseTokenOnly::execute:: insufficient LP tokens received");
    require(lpToken.transfer(msg.sender, lpToken.balanceOf(address(this))), "StrategyAddBaseTokenOnly::execute:: failed to transfer LP token to msg.sender");
    // 6. Reset approval for safety reason
    baseToken.safeApprove(address(router), 0);
    farmingToken.safeApprove(address(router), 0);
  }
}

Contract Security Audit

Contract ABI

[{"inputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"bytes","name":"data","type":"bytes"}],"name":"execute","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"factory","outputs":[{"internalType":"contract IPancakeFactory","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"contract IPancakeRouter02","name":"_router","type":"address"}],"name":"initialize","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"router","outputs":[{"internalType":"contract IPancakeRouter02","name":"","type":"address"}],"stateMutability":"view","type":"function"}]

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

Deployed ByteCode Sourcemap

21035:2867:0:-:0;;;;5:9:-1;2:2;;;27:1;24;17:12;2:2;21035:2867:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;12:1:-1;9;2:12;21742:2157:0;;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28;21:12;4:2;-1:-1;;;;;21742:2157:0;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;11:28;;8:2;;;52:1;49;42:12;8:2;21742:2157:0;;41:9:-1;34:4;18:14;14:25;11:40;8:2;;;64:1;61;54:12;8:2;21742:2157:0;;;;;;100:9:-1;95:1;81:12;77:20;67:8;63:35;60:50;-1:-1;;;25:12;22:29;11:107;8:2;;;131:1;128;121:12;8:2;-1:-1;21742:2157:0;;-1:-1:-1;21742:2157:0;-1:-1:-1;21742:2157:0;:::i;:::-;;21193:30;;;:::i;:::-;;;;-1:-1:-1;;;;;21193:30:0;;;;;;;;;;;;;;21381:207;;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28;21:12;4:2;-1:-1;21381:207:0;-1:-1:-1;;;;;21381:207:0;;:::i;21228:30::-;;;:::i;21742:2157::-;9375:11;;;;9367:55;;;;;-1:-1:-1;;;9367:55:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;9500:11;:19;;-1:-1:-1;;9500:19:0;;;9514:5;;;22069:4;;15:2:-1::1;7:11:::0;::::1;4:2;;;31:1;28::::0;21:12:::1;4:2;-1:-1:::0;22146:7:0::1;::::0;22058:45;22146:40;;-1:-1:-1;;;22146:40:0;;22058:45:::1;::::0;;::::1;;-1:-1:-1::0;;;;;22058:45:0;;::::1;22146:40;::::0;::::1;::::0;;;22058:45;::::1;::::0;::::1;22146:40:::0;;;;;;;;22058:45;;-1:-1:-1;22058:45:0;;-1:-1:-1;22058:45:0;;;;::::1;::::0;-1:-1:-1;22110:20:0::1;::::0;22146:7;;;::::1;::::0;:15:::1;::::0;:40;;;;;;;;;;:7;:40;::::1;;2:2:-1::0;::::1;;;27:1;24::::0;17:12:::1;2:2;22146:40:0;;;;8:9:-1;5:2;;;45:16;42:1;39::::0;24:38:::1;77:16;74:1;67:27;5:2;22146:40:0;;;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28::::0;21:12:::1;4:2;-1:-1:::0;22146:40:0;22272:6:::1;::::0;22146:40;;-1:-1:-1;22239:54:0::1;::::0;-1:-1:-1;;;;;22239:24:0;;::::1;::::0;22272:6:::1;-1:-1:-1::0;;22239:54:0::1;:24;:54;:::i;:::-;22330:6;::::0;22300:51:::1;::::0;-1:-1:-1;;;;;22300:21:0;;::::1;::::0;22330:6:::1;-1:-1:-1::0;;22300:51:0::1;:21;:51;:::i;:::-;22442:15;22460:21;:9;-1:-1:-1::0;;;;;22460:19:0::1;;:21::i;:::-;22442:39;;22489:10;22501::::0;22517:7:::1;-1:-1:-1::0;;;;;22517:19:0::1;;:21;;;;;;;;;;;;;;;;;;;;;;5:9:-1;2:2;;;27:1;24::::0;17:12:::1;2:2;22517:21:0;;;;8:9:-1;5:2;;;45:16;42:1;39::::0;24:38:::1;77:16;74:1;67:27;5:2;22517:21:0;;;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28::::0;21:12:::1;4:2;-1:-1:::0;22517:21:0;;::::1;::::0;;::::1;::::0;;22559:16;;-1:-1:-1;;;22559:16:0;;;;-1:-1:-1;;;;;22488:50:0;;::::1;::::0;-1:-1:-1;22488:50:0;;;::::1;::::0;-1:-1:-1;22545:11:0::1;::::0;-1:-1:-1;;;;;22559:29:0;;::::1;::::0;:14;;::::1;::::0;::::1;::::0;:16:::1;::::0;;::::1;::::0;22517:21;;22559:16;;;;;:14;:16;::::1;;2:2:-1::0;::::1;;;27:1;24::::0;17:12:::1;2:2;22559:16:0;;;;8:9:-1;5:2;;;45:16;42:1;39::::0;24:38:::1;77:16;74:1;67:27;5:2;22559:16:0;;;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28::::0;21:12:::1;4:2;-1:-1:::0;22559:16:0;-1:-1:-1;;;;;22559:29:0::1;;:39;;22596:2;22559:39;;;22591:2;22559:39;22545:53:::0;-1:-1:-1;22888:11:0::1;22997:5;22902:92;22979:14;22545:53:::0;22987:5:::1;22979:14;:7;:14;:::i;:::-;22902:72;22918:55;22926:46;22953:18;:3:::0;22961:9:::1;22953:18;:7;:18;:::i;:::-;22926:22;:7:::0;22938:9:::1;22926:22;:11;:22;:::i;:::-;:26:::0;:46:::1;:26;:46;:::i;:::-;22918:3:::0;;:55:::1;:7;:55;:::i;:::-;22902:15;:72::i;:::-;:76:::0;:92:::1;:76;:92;:::i;:::-;:100;;;;;23095:16;::::0;;23109:1:::1;23095:16:::0;;;23071:21:::1;23095:16:::0;;::::1;::::0;;22902:100;;;::::1;::::0;-1:-1:-1;23095:16:0;23109:1;23095:16:::1;::::0;::::1;::::0;;109:14:-1::1;23095:16:0::0;88:42:-1::1;144:17;::::0;-1:-1;23095:16:0::1;23071:40;;23128:9;23118:4;23123:1;23118:7;;;;;;;;;;;;;:19;-1:-1:-1::0;;;;;23118:19:0::1;;;-1:-1:-1::0;;;;;23118:19:0::1;;;::::0;::::1;23154:12;23144:4;23149:1;23144:7;;;;;;;;-1:-1:-1::0;;;;;23144:22:0;;::::1;:7;::::0;;::::1;::::0;;;;;;:22;;;;23173:6:::1;::::0;:65:::1;::::0;-1:-1:-1;;;23173:65:0;;::::1;::::0;::::1;::::0;;;:6:::1;:65:::0;;;;;;23227:4:::1;23173:65:::0;;;;;;23234:3:::1;23173:65:::0;;;;;;;;;;;;;;;;;;;;;:6;;;::::1;::::0;:31:::1;::::0;23205:3;;23173:6;;23213:4;;23227;;23234:3;;23173:65;;;;;;;;::::1;::::0;::::1;::::0;;;:6;8:100:-1::1;33:3;30:1;27:10;8:100;;;90:11:::0;;::::1;84:18:::0;71:11;;::::1;64:39:::0;52:2:::1;45:10;8:100;;;12:14;23173:65:0;;;;;;;;;;;;;;;;;;;;;;;;;;5:9:-1;2:2;;;27:1;24::::0;17:12:::1;2:2;23173:65:0;;;;8:9:-1;5:2;;;45:16;42:1;39::::0;24:38:::1;77:16;74:1;67:27;5:2;23173:65:0;;;;;;39:16:-1;36:1;17:17;2:54;101:4;23173:65:0;80:15:-1::0;;::::1;-1:-1:::0;;76:31:::1;65:43:::0;::::1;120:4;113:20:::0;15:2:::1;7:11:::0;::::1;4:2;;;31:1;28::::0;21:12:::1;4:2;23173:65:0;;;;;;;;;;;;;-1:-1:-1::0;;;14:3:::1;11:20;8:2;;;44:1;41::::0;34:12:::1;8:2;62:21:::0;;::::1;::::0;123:4:::1;114:14:::0;::::1;138:31:::0;;::::1;135:2;;;182:1;179::::0;172:12:::1;135:2;219:3;213:10;331:9;325:2;311:12;307:21;289:16;285:44;282:59;-1:-1:::0;;;247:12:::1;244:29;233:116;230:2;;;362:1;359::::0;352:12:::1;230:2;373:25:::0;;-1:-1;23173:65:0;;421:4:-1::1;412:14:::0;;::::1;::::0;23173:65:0;::::1;::::0;::::1;::::0;412:14:-1;23173:65:0;23:1:-1::1;8:100;33:3;30:1;27:10;8:100;;;90:11:::0;;::::1;84:18:::0;71:11;;::::1;64:39:::0;52:2:::1;45:10;8:100;;;12:14;23173:65:0;;;;;;;;::::0;::::1;;;23320:20;23344:6;;;;;;;;;-1:-1:-1::0;;;;;23344:6:0::1;-1:-1:-1::0;;;;;23344:19:0::1;;23372:9;23383:12;23397:21;:9;-1:-1:-1::0;;;;;23397:19:0::1;;:21::i;:::-;23420:24;:12;-1:-1:-1::0;;;;;23420:22:0::1;;:24::i;:::-;23344:133;::::0;;-1:-1:-1;;;;;;23344:133:0::1;::::0;;;;;;-1:-1:-1;;;;;23344:133:0;;::::1;;::::0;::::1;::::0;;;;::::1;::::0;;;;;;;;;;;;;;;23446:1:::1;23344:133:::0;;;;;;;;;;;;23460:4:::1;23344:133:::0;;;;23467:3:::1;23344:133:::0;;;;;;;;;;;::::1;::::0;;;;;;;;;;;;::::1;;2:2:-1::0;::::1;;;27:1;24::::0;17:12:::1;2:2;23344:133:0;;;;8:9:-1;5:2;;;45:16;42:1;39::::0;24:38:::1;77:16;74:1;67:27;5:2;23344:133:0;;;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28::::0;21:12:::1;4:2;-1:-1:::0;23344:133:0;;;;-1:-1:-1;23492:27:0;;::::1;;23484:107;;;;-1:-1:-1::0;;;23484:107:0::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;23635:32;::::0;;-1:-1:-1;;;23635:32:0;;23661:4:::1;23635:32;::::0;::::1;::::0;;;-1:-1:-1;;;;;23606:16:0;::::1;::::0;::::1;::::0;23623:10:::1;::::0;23606:16;;23635:17:::1;::::0;:32;;;;;::::1;::::0;;;;;;;;;23606:16;23635:32;::::1;;2:2:-1::0;::::1;;;27:1;24::::0;17:12:::1;2:2;23635:32:0;;;;8:9:-1;5:2;;;45:16;42:1;39::::0;24:38:::1;77:16;74:1;67:27;5:2;23635:32:0;;;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28::::0;21:12:::1;4:2;-1:-1:::0;23635:32:0;23606:62:::1;::::0;;-1:-1:-1;;;;;;23606:62:0::1;::::0;;;;;;-1:-1:-1;;;;;23606:62:0;;::::1;;::::0;::::1;::::0;;;;;;;;;;;;;;23635:32:::1;::::0;23606:62;;;;;;;-1:-1:-1;23606:62:0;;::::1;;2:2:-1::0;::::1;;;27:1;24::::0;17:12:::1;2:2;23606:62:0;;;;8:9:-1;5:2;;;45:16;42:1;39::::0;24:38:::1;77:16;74:1;67:27;5:2;23606:62:0;;;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28::::0;21:12:::1;4:2;-1:-1:::0;23606:62:0;23598:152:::1;;;;-1:-1:-1::0;;;23598:152:0::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;23831:6;::::0;23801:41:::1;::::0;-1:-1:-1;;;;;23801:21:0;;::::1;::::0;23831:6:::1;;23801:41;:21;:41;:::i;:::-;23882:6;::::0;23849:44:::1;::::0;-1:-1:-1;;;;;23849:24:0;;::::1;::::0;23882:6:::1;;23849:44;:24;:44;:::i;:::-;-1:-1:-1::0;;9680:11:0;:18;;-1:-1:-1;;9680:18:0;9694:4;9680:18;;;-1:-1:-1;;;;;;;;;;;;;21742:2157:0:o;21193:30::-;;;-1:-1:-1;;;;;21193:30:0;;:::o;21381:207::-;6346:12;;;;;;;;:31;;;6362:15;:13;:15::i;:::-;6346:47;;;-1:-1:-1;6382:11:0;;;;6381:12;6346:47;6338:106;;;;-1:-1:-1;;;6338:106:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6453:19;6476:12;;;;;;6475:13;6495:83;;;;6524:12;:19;;-1:-1:-1;;;;6524:19:0;;;;;6552:18;6539:4;6552:18;;;6495:83;21455:51:::1;:49;:51::i;:::-;21541:7;-1:-1:-1::0;;;;;21541:15:0::1;;:17;;;;;;;;;;;;;;;;;;;;;;5:9:-1;2:2;;;27:1;24::::0;17:12:::1;2:2;21541:17:0;;;;8:9:-1;5:2;;;45:16;42:1;39::::0;24:38:::1;77:16;74:1;67:27;5:2;21541:17:0;;;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28::::0;21:12:::1;4:2;-1:-1:::0;21541:17:0;21515:7:::1;:44:::0;;-1:-1:-1;;;;;;21515:44:0;;::::1;-1:-1:-1::0;;;;;21515:44:0;;::::1;;::::0;;;21566:6:::1;:16:::0;;;;::::1;::::0;;::::1;::::0;;;::::1;::::0;;6596:57;;;;6640:5;6625:20;;-1:-1:-1;;6625:20:0;;;6596:57;21381:207;;:::o;21228:30::-;;;-1:-1:-1;;;;;21228:30:0;;:::o;18597:329::-;18785:45;;;-1:-1:-1;;;;;18785:45:0;;;;;;;;;;;;;;;;26:21:-1;;;22:32;;;6:49;;18785:45:0;;;;;;;25:18:-1;;61:17;;-1:-1;;;;;182:15;-1:-1;;;179:29;160:49;;18774:57:0;;;;18739:12;;18753:17;;18774:10;;;;18785:45;18774:57;;;25:18:-1;18774:57:0;;25:18:-1;36:153;66:2;61:3;58:11;36:153;;176:10;;164:23;;-1:-1;;139:12;;;;98:2;89:12;;;;114;36:153;;;274:1;267:3;263:2;259:12;254:3;250:22;246:30;315:4;311:9;305:3;299:10;295:26;356:4;350:3;344:10;340:21;389:7;380;377:20;372:3;365:33;3:399;;;18774:57:0;;;;;;;;;;;;;;;;;;;;;;;;12:1:-1;19;14:27;;;;67:4;61:11;56:16;;134:4;130:9;123:4;105:16;101:27;97:43;94:1;90:51;84:4;77:65;157:16;154:1;147:27;211:16;208:1;201:4;198:1;194:12;179:49;5:228;;14:27;32:4;27:9;;5:228;;18738:93:0;;;;18846:7;:57;;;;-1:-1:-1;18858:11:0;;:16;;:44;;;18889:4;18878:24;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28;21:12;4:2;-1:-1;18878:24:0;18858:44;18838:82;;;;;-1:-1:-1;;;18838:82:0;;;;;;;;;;;;-1:-1:-1;;;18838:82:0;;;;;;;;;;;;;;;18597:329;;;;;:::o;18316:132::-;18396:46;;;-1:-1:-1;;;18396:46:0;;18436:4;18396:46;;;;;;18373:7;;-1:-1:-1;;;;;18396:31:0;;;;;:46;;;;;;;;;;;;;;;:31;:46;;;2:2:-1;;;;27:1;24;17:12;2:2;18396:46:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;18396:46:0;;;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28;21:12;4:2;-1:-1;18396:46:0;;-1:-1:-1;18316:132:0;;;;:::o;2188:471::-;2246:7;2491:6;2487:47;;-1:-1:-1;2521:1:0;2514:8;;2487:47;2558:5;;;2562:1;2558;:5;:1;2582:5;;;;;:10;2574:56;;;;-1:-1:-1;;;2574:56:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2650:1;-1:-1:-1;2188:471:0;;;;;:::o;858:181::-;916:7;948:5;;;972:6;;;;964:46;;;;;-1:-1:-1;;;964:46:0;;;;;;;;;;;;-1:-1:-1;;;964:46:0;;;;;;;;;;;;;;20136:892;20181:4;20198:6;20194:20;;-1:-1:-1;20213:1:0;20206:8;;20194:20;20231:1;20248;-1:-1:-1;;;20262:41:0;;20258:91;;20321:3;20314:10;;;;;20339:2;20333:8;20258:91;-1:-1:-1;;;20361:2:0;:25;20357:74;;20404:2;20397:9;;;;;20421:2;20415:8;20357:74;-1:-1:-1;;;20441:2:0;:17;20437:66;;20476:2;20469:9;;;;;20493:2;20487:8;20437:66;20519:7;20513:2;:13;20509:61;;20544:2;20537:9;;;;;20561:1;20555:7;20509:61;20586:5;20580:2;:11;20576:58;;20609:1;20602:8;;;;;20625:1;20619:7;20576:58;20650:4;20644:2;:10;20640:57;;20672:1;20665:8;;;;;20688:1;20682:7;20640:57;20713:3;20707:2;:9;20703:39;;20733:1;20727:7;20703:39;20769:1;20763;20759;:5;;;;;;20755:1;:9;20754:16;;20750:20;;20796:1;20790;20786;:5;;;;;;20782:1;:9;20781:16;;20777:20;;20823:1;20817;20813;:5;;;;;;20809:1;:9;20808:16;;20804:20;;20850:1;20844;20840;:5;;;;;;20836:1;:9;20835:16;;20831:20;;20877:1;20871;20867;:5;;;;;;20863:1;:9;20862:16;;20858:20;;20904:1;20898;20894;:5;;;;;;20890:1;:9;20889:16;;20885:20;;20931:1;20925;20921;:5;;;;;;20917:1;:9;20916:16;;20912:20;;20976:7;20990:1;20986;:5;;;;;;20976:15;;21010:2;21006:1;:6;:15;;21019:2;21006:15;;;21015:1;21006:15;20998:24;20136:892;-1:-1:-1;;;;;20136:892:0:o;1314:136::-;1372:7;1399:43;1403:1;1406;1399:43;;;;;;;;;;;;;;;;;:3;:43::i;6747:508::-;7164:4;7210:17;7242:7;6747:508;:::o;8232:108::-;6346:12;;;;;;;;:31;;;6362:15;:13;:15::i;:::-;6346:47;;;-1:-1:-1;6382:11:0;;;;6381:12;6346:47;6338:106;;;;-1:-1:-1;;;6338:106:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6453:19;6476:12;;;;;;6475:13;6495:83;;;;6524:12;:19;;-1:-1:-1;;;;6524:19:0;;;;;6552:18;6539:4;6552:18;;;6495:83;8298:34:::1;:32;:34::i;:::-;6600:14:::0;6596:57;;;6640:5;6625:20;;-1:-1:-1;;6625:20:0;;;6596:57;8232:108;:::o;1745:192::-;1831:7;1867:12;1859:6;;;;1851:29;;;;-1:-1:-1;;;1851:29:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;23:1:-1;8:100;33:3;30:1;27:10;8:100;;;90:11;;;84:18;71:11;;;64:39;52:2;45:10;8:100;;;12:14;1851:29:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;1903:5:0;;;1745:192::o;8348:526::-;6346:12;;;;;;;;:31;;;6362:15;:13;:15::i;:::-;6346:47;;;-1:-1:-1;6382:11:0;;;;6381:12;6346:47;6338:106;;;;-1:-1:-1;;;6338:106:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6453:19;6476:12;;;;;;6475:13;6495:83;;;;6524:12;:19;;-1:-1:-1;;;;6524:19:0;;;;;6552:18;6539:4;6552:18;;;6495:83;8846:11:::1;:18:::0;;-1:-1:-1;;8846:18:0::1;8860:4;8846:18;::::0;;6596:57;;;;6640:5;6625:20;;-1:-1:-1;;6625:20:0;;;8348:526;:::o

Swarm Source

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