Contract

0xe04b08Dfc6CaA0F4Ec523a3Ae283Ece7efE00019

Source Code

Overview

ETH Balance

0 ETH

Eth Value

$0.00

More Info

Private Name Tags

Add

ContractCreator

DePay: Deployer at txn 0x521e4d920a23b7628824e6f046eb77d2d7f5d068ad27f3320122dd141753800d

Multichain Info

$0 (Multichain Portfolio)

Advanced Filter

Latest 1 from a total of 1 transactions

	Transaction Hash	Method	Block		From		To
	0x521e4d920a23b7628824e6f046eb77d2d7f5d068ad27f3320122dd141753800d	0x61010060	11940294	2021-02-27 16:02:14	1279 days ago	1614441734	DePay: Deployer	IN	Create: DePayRouterV1Uniswap01	0 ETH$0.00	0.09160162	122

View more zero value Internal Transactions in Advanced View mode

Advanced mode:

Contract Source Code Verified (Exact Match)

Contract Name:

DePayRouterV1Uniswap01

Compiler Version

v0.7.6+commit.7338295f

Optimization Enabled:

Yes with 200 runs

Other Settings:

default evmVersion, MIT license

Contract Source Code (Solidity)

IDE

/**
 *Submitted for verification at Etherscan.io on 2021-02-27
*/

// Dependency file: @openzeppelin/contracts/token/ERC20/IERC20.sol

// SPDX-License-Identifier: MIT

// 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);
}


// Dependency file: @openzeppelin/contracts/math/SafeMath.sol


// pragma solidity >=0.6.0 <0.8.0;

/**
 * @dev Wrappers over Solidity's arithmetic operations with added overflow
 * checks.
 *
 * Arithmetic operations in Solidity wrap on overflow. This can easily result
 * in bugs, because programmers usually assume that an overflow raises an
 * error, which is the standard behavior in high level programming languages.
 * `SafeMath` restores this intuition by reverting the transaction when an
 * operation overflows.
 *
 * Using this library instead of the unchecked operations eliminates an entire
 * class of bugs, so it's recommended to use it always.
 */
library SafeMath {
    /**
     * @dev Returns the addition of two unsigned integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `+` operator.
     *
     * Requirements:
     *
     * - Addition cannot overflow.
     */
    function add(uint256 a, uint256 b) internal pure returns (uint256) {
        uint256 c = a + b;
        require(c >= a, "SafeMath: addition overflow");

        return c;
    }

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

    /**
     * @dev Returns the subtraction of two unsigned integers, reverting with custom message on
     * overflow (when the result is negative).
     *
     * Counterpart to Solidity's `-` operator.
     *
     * Requirements:
     *
     * - Subtraction cannot overflow.
     */
    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) {
        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;
    }
}


// Dependency file: contracts/interfaces/IUniswapV2Router02.sol

// pragma solidity >=0.6.2;

interface IUniswapV2Router01 {
    function factory() external pure returns (address);
    function WETH() external pure returns (address);

    function addLiquidity(
        address tokenA,
        address tokenB,
        uint amountADesired,
        uint amountBDesired,
        uint amountAMin,
        uint amountBMin,
        address to,
        uint deadline
    ) external returns (uint amountA, uint amountB, uint liquidity);
    function addLiquidityETH(
        address token,
        uint amountTokenDesired,
        uint amountTokenMin,
        uint amountETHMin,
        address to,
        uint deadline
    ) external payable returns (uint amountToken, uint amountETH, uint liquidity);
    function removeLiquidity(
        address tokenA,
        address tokenB,
        uint liquidity,
        uint amountAMin,
        uint amountBMin,
        address to,
        uint deadline
    ) external returns (uint amountA, uint amountB);
    function removeLiquidityETH(
        address token,
        uint liquidity,
        uint amountTokenMin,
        uint amountETHMin,
        address to,
        uint deadline
    ) external returns (uint amountToken, uint amountETH);
    function removeLiquidityWithPermit(
        address tokenA,
        address tokenB,
        uint liquidity,
        uint amountAMin,
        uint amountBMin,
        address to,
        uint deadline,
        bool approveMax, uint8 v, bytes32 r, bytes32 s
    ) external returns (uint amountA, uint amountB);
    function removeLiquidityETHWithPermit(
        address token,
        uint liquidity,
        uint amountTokenMin,
        uint amountETHMin,
        address to,
        uint deadline,
        bool approveMax, uint8 v, bytes32 r, bytes32 s
    ) external returns (uint amountToken, uint amountETH);
    function swapExactTokensForTokens(
        uint amountIn,
        uint amountOutMin,
        address[] calldata path,
        address to,
        uint deadline
    ) external returns (uint[] memory amounts);
    function swapTokensForExactTokens(
        uint amountOut,
        uint amountInMax,
        address[] calldata path,
        address to,
        uint deadline
    ) external returns (uint[] memory amounts);
    function swapExactETHForTokens(uint amountOutMin, address[] calldata path, address to, uint deadline)
        external
        payable
        returns (uint[] memory amounts);
    function swapTokensForExactETH(uint amountOut, uint amountInMax, address[] calldata path, address to, uint deadline)
        external
        returns (uint[] memory amounts);
    function swapExactTokensForETH(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline)
        external
        returns (uint[] memory amounts);
    function swapETHForExactTokens(uint amountOut, address[] calldata path, address to, uint deadline)
        external
        payable
        returns (uint[] memory amounts);

    function quote(uint amountA, uint reserveA, uint reserveB) external pure returns (uint amountB);
    function getAmountOut(uint amountIn, uint reserveIn, uint reserveOut) external pure returns (uint amountOut);
    function getAmountIn(uint amountOut, uint reserveIn, uint reserveOut) external pure returns (uint amountIn);
    function getAmountsOut(uint amountIn, address[] calldata path) external view returns (uint[] memory amounts);
    function getAmountsIn(uint amountOut, address[] calldata path) external view returns (uint[] memory amounts);
}

interface IUniswapV2Router02 is IUniswapV2Router01 {
    function removeLiquidityETHSupportingFeeOnTransferTokens(
        address token,
        uint liquidity,
        uint amountTokenMin,
        uint amountETHMin,
        address to,
        uint deadline
    ) external returns (uint amountETH);
    function removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(
        address token,
        uint liquidity,
        uint amountTokenMin,
        uint amountETHMin,
        address to,
        uint deadline,
        bool approveMax, uint8 v, bytes32 r, bytes32 s
    ) external returns (uint amountETH);

    function swapExactTokensForTokensSupportingFeeOnTransferTokens(
        uint amountIn,
        uint amountOutMin,
        address[] calldata path,
        address to,
        uint deadline
    ) external;
    function swapExactETHForTokensSupportingFeeOnTransferTokens(
        uint amountOutMin,
        address[] calldata path,
        address to,
        uint deadline
    ) external payable;
    function swapExactTokensForETHSupportingFeeOnTransferTokens(
        uint amountIn,
        uint amountOutMin,
        address[] calldata path,
        address to,
        uint deadline
    ) external;
}


// Dependency file: contracts/libraries/Helper.sol

// Helper methods for interacting with ERC20 tokens and sending ETH that do not consistently return true/false
library Helper {
  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))),
      'Helper::safeApprove: approve failed'
    );
  }

  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))),
      'Helper::safeTransfer: transfer failed'
    );
  }

  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))),
      'Helper::transferFrom: transferFrom failed'
    );
  }

  function safeTransferETH(address to, uint256 value) internal {
    (bool success, ) = to.call{value: value}(new bytes(0));
    require(success, 'Helper::safeTransferETH: ETH transfer failed');
  }
}


// Root file: contracts/DePayRouterV1Uniswap01.sol


pragma solidity >=0.7.5 <0.8.0;
pragma abicoder v2;

// import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
// import "@openzeppelin/contracts/math/SafeMath.sol";
// import "contracts/interfaces/IUniswapV2Router02.sol";
// import 'contracts/libraries/Helper.sol';

contract DePayRouterV1Uniswap01 {
  
  using SafeMath for uint;

  // Address representating ETH (e.g. in payment routing paths)
  address public constant ETH = 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE;

  // MAXINT to be used only, to increase allowance from
  // payment protocol contract towards known 
  // decentralized exchanges, not to dyanmically called contracts!!!
  uint public immutable MAXINT = type(uint256).max;
  
  // Address of WETH.
  address public immutable WETH;

  // Address of Uniswap router.
  address public immutable UniswapV2Router02;

  // Indicates that this plugin requires delegate call
  bool public immutable delegate = true;

  // Pass WETH and the UniswapRouter when deploying this contract.
  constructor (
    address _WETH,
    address _UniswapV2Router02
  ) public {
    WETH = _WETH;
    UniswapV2Router02 = _UniswapV2Router02;
  }

  // Swap tokenA<>tokenB, ETH<>tokenA or tokenA<>ETH on Uniswap as part of the payment.
  // Swaps tokens according to provided `path` using the amount at index 0 (`amounts[0]`) as input amount,
  // the amount at index 1 (`amounts[1]`) as output amount and the amount at index 2 (`amount[2]`) as deadline.
  function execute(
    address[] calldata path,
    uint[] calldata amounts,
    address[] calldata addresses,
    string[] calldata data
  ) external payable returns(bool) {
    
    // Make sure swapping the token within the payment protocol contract is approved on the Uniswap router.
    if( 
      path[0] != ETH &&
      IERC20(path[0]).allowance(address(this), UniswapV2Router02) < amounts[0]
    ) {
      Helper.safeApprove(path[0], UniswapV2Router02, MAXINT);
    }

    // Uniswap uses WETH within their path to indicate bridge swapping (instead of ETH).
    // This prepares the path as applicable to the Uniswap router.
    address[] memory uniPath = new address[](path.length);
    for (uint i=0; i<path.length; i++) {
        if(path[i] == ETH) {
            uniPath[i] = WETH;
        } else {
            uniPath[i] = path[i];
        }
    }

    // Executes ETH<>tokenA, tokenA<>ETH, or tokenA<>tokenB swaps depending on the provided path.
    if(path[0] == ETH) {
      IUniswapV2Router01(UniswapV2Router02).swapExactETHForTokens{value: amounts[0]}(
        amounts[1],
        uniPath,
        address(this),
        amounts[2]
      );
    } else if (path[path.length-1] == ETH) {
      IUniswapV2Router01(UniswapV2Router02).swapExactTokensForETH(
        amounts[0],
        amounts[1],
        uniPath,
        address(this),
        amounts[2]
      );
    } else {
      IUniswapV2Router02(UniswapV2Router02).swapExactTokensForTokens(
        amounts[0],
        amounts[1],
        uniPath,
        address(this),
        amounts[2]
      );
    }

    return true;
  }
}

Contract Security Audit

No Contract Security Audit Submitted- Submit Audit Here

Contract ABI

[{"inputs":[{"internalType":"address","name":"_WETH","type":"address"},{"internalType":"address","name":"_UniswapV2Router02","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"name":"ETH","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"MAXINT","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"UniswapV2Router02","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"WETH","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"delegate","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address[]","name":"path","type":"address[]"},{"internalType":"uint256[]","name":"amounts","type":"uint256[]"},{"internalType":"address[]","name":"addresses","type":"address[]"},{"internalType":"string[]","name":"data","type":"string[]"}],"name":"execute","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"payable","type":"function"}]

Contract Creation Code

Decompile Bytecode Switch to Opcodes View

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

Deployed Bytecode

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

Constructor Arguments (ABI-Encoded and is the last bytes of the Contract Creation Code above)

000000000000000000000000c02aaa39b223fe8d0a0e5c4f27ead9083c756cc20000000000000000000000007a250d5630b4cf539739df2c5dacb4c659f2488d

-----Decoded View---------------
Arg [0] : _WETH (address): 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2
Arg [1] : _UniswapV2Router02 (address): 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D

-----Encoded View---------------
2 Constructor Arguments found :
Arg [0] : 000000000000000000000000c02aaa39b223fe8d0a0e5c4f27ead9083c756cc2
Arg [1] : 0000000000000000000000007a250d5630b4cf539739df2c5dacb4c659f2488d

Deployed Bytecode Sourcemap

15207:2870:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;15596:48;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;15745:42;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;15343:72::-;;;;;;;;;;;;;:::i;15676:29::-;;;;;;;;;;;;;:::i;16426:1648::-;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;15850:37::-;;;;;;;;;;;;;:::i;15596:48::-;;;:::o;15745:42::-;;;:::o;15343:72::-;15373:42;15343:72;:::o;15676:29::-;;;:::o;16426:1648::-;16597:4;15373:42;16737:4;;16597;16737:7;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1;;;;;16737:14:0;;;:97;;;;;16824:7;;16832:1;16824:10;;;;;;;;;;;;;16769:4;;16774:1;16769:7;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1;;;;;16762:25:0;;16796:4;16803:17;16762:59;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:72;16737:97;16725:188;;;16851:54;16870:4;;16875:1;16870:7;;;;;;;;;;;;;;;;;;;;:::i;:::-;16879:17;16898:6;16851:18;:54::i;:::-;17079:24;17120:4;17106:26;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;17106:26:0;;17079:53;;17144:6;17139:169;17154:13;;;17139:169;;;15373:42;17188:4;;17193:1;17188:7;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1;;;;;17188:14:0;;17185:116;;;17232:4;17219:7;17227:1;17219:10;;;;;;;;;;;;;:17;-1:-1:-1;;;;;17219:17:0;;;-1:-1:-1;;;;;17219:17:0;;;;;17185:116;;;17282:4;;17287:1;17282:7;;;;;;;;;;;;;;;;;;;;:::i;:::-;17269;17277:1;17269:10;;;;;;;;;;;;;:20;-1:-1:-1;;;;;17269:20:0;;;-1:-1:-1;;;;;17269:20:0;;;;;17185:116;17169:3;;17139:169;;;-1:-1:-1;15373:42:0;17418:4;;17423:1;17418:7;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1;;;;;17418:14:0;;17415:634;;;17462:17;-1:-1:-1;;;;;17443:59:0;;17510:7;;17518:1;17510:10;;;;;;;;;;;;;17532:7;;17540:1;17532:10;;;;;;;;;;;;;17553:7;17579:4;17595:7;;17603:1;17595:10;;;;;;;;;;;;;17443:171;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;17443:171:0;;;;;;;;;;;;:::i;:::-;;17415:634;;;15373:42;17632:4;;-1:-1:-1;;17637:13:0;;17632:19;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1;;;;;17632:26:0;;17628:421;;;17688:17;-1:-1:-1;;;;;17669:59:0;;17739:7;;17747:1;17739:10;;;;;;;;;;;;;17760:7;;17768:1;17760:10;;;;;;;;;;;;;17781:7;17807:4;17823:7;;17831:1;17823:10;;;;;;;;;;;;;17669:173;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;17669:173:0;;;;;;;;;;;;:::i;17628:421::-;17884:17;-1:-1:-1;;;;;17865:62:0;;17938:7;;17946:1;17938:10;;;;;;;;;;;;;17959:7;;17967:1;17959:10;;;;;;;;;;;;;17980:7;18006:4;18022:7;;18030:1;18022:10;;;;;;;;;;;;;17865:176;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;17865:176:0;;;;;;;;;;;;:::i;:::-;;17628:421;-1:-1:-1;18064:4:0;;16426:1648;-1:-1:-1;;;;;;;;;16426:1648:0:o;15850:37::-;;;:::o;13415:393::-;13577:12;13591:17;13612:5;-1:-1:-1;;;;;13612:10:0;13646;13658:2;13662:5;13623:45;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;13623:45:0;;;;;;;;;;;13612:57;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;13576:93;;;;13692:7;:57;;;;-1:-1:-1;13704:11:0;;:16;;:44;;;13735:4;13724:24;;;;;;;;;;;;:::i;:::-;13676:126;;;;-1:-1:-1;;;13676:126:0;;;;;;;:::i;:::-;;;;;;;;;13415:393;;;;;:::o;14:400:1:-;;;147:3;140:4;132:6;128:17;124:27;114:2;;170:6;162;155:22;114:2;-1:-1:-1;198:20:1;;241:18;230:30;;227:2;;;280:8;270;263:26;227:2;324:4;316:6;312:17;300:29;;387:3;380:4;372;364:6;360:17;352:6;348:30;344:41;341:50;338:2;;;404:1;401;394:12;338:2;104:310;;;;;:::o;419:306::-;;531:2;519:9;510:7;506:23;502:32;499:2;;;552:6;544;537:22;499:2;583:23;;-1:-1:-1;;;;;635:31:1;;625:42;;615:2;;686:6;678;671:22;615:2;714:5;489:236;-1:-1:-1;;;489:236:1:o;730:1490::-;;;;;;;;;1045:3;1033:9;1024:7;1020:23;1016:33;1013:2;;;1067:6;1059;1052:22;1013:2;1112:9;1099:23;1141:18;1182:2;1174:6;1171:14;1168:2;;;1203:6;1195;1188:22;1168:2;1247:76;1315:7;1306:6;1295:9;1291:22;1247:76;:::i;:::-;1342:8;;-1:-1:-1;1221:102:1;-1:-1:-1;1430:2:1;1415:18;;1402:32;;-1:-1:-1;1446:16:1;;;1443:2;;;1480:6;1472;1465:22;1443:2;1524:78;1594:7;1583:8;1572:9;1568:24;1524:78;:::i;:::-;1621:8;;-1:-1:-1;1498:104:1;-1:-1:-1;1709:2:1;1694:18;;1681:32;;-1:-1:-1;1725:16:1;;;1722:2;;;1759:6;1751;1744:22;1722:2;1803:78;1873:7;1862:8;1851:9;1847:24;1803:78;:::i;:::-;1900:8;;-1:-1:-1;1777:104:1;-1:-1:-1;1988:2:1;1973:18;;1960:32;;-1:-1:-1;2004:16:1;;;2001:2;;;2038:6;2030;2023:22;2001:2;;2082:78;2152:7;2141:8;2130:9;2126:24;2082:78;:::i;:::-;1003:1217;;;;-1:-1:-1;1003:1217:1;;-1:-1:-1;1003:1217:1;;;;;;2179:8;-1:-1:-1;;;1003:1217:1:o;2225:1130::-;;2351:2;2394;2382:9;2373:7;2369:23;2365:32;2362:2;;;2415:6;2407;2400:22;2362:2;2453:9;2447:16;2482:18;2523:2;2515:6;2512:14;2509:2;;;2544:6;2536;2529:22;2509:2;2587:6;2576:9;2572:22;2562:32;;2632:7;2625:4;2621:2;2617:13;2613:27;2603:2;;2659:6;2651;2644:22;2603:2;2693;2687:9;2715:2;2711;2708:10;2705:2;;;2721:9;2705:2;2759;2755;2751:11;2791:2;2785:9;2842:2;2837;2829:6;2825:15;2821:24;2895:6;2883:10;2880:22;2875:2;2863:10;2860:18;2857:46;2854:2;;;2906:9;2854:2;2933;2926:22;2983:18;;;3017:15;;;;-1:-1:-1;3052:11:1;;;3082;;;3078:20;;3075:33;-1:-1:-1;3072:2:1;;;3126:6;3118;3111:22;3072:2;3153:6;3144:15;;3168:156;3182:2;3179:1;3176:9;3168:156;;;3239:10;;3227:23;;3200:1;3193:9;;;;;3270:12;;;;3302;;3168:156;;;-1:-1:-1;3343:6:1;2331:1024;-1:-1:-1;;;;;;;;2331:1024:1:o;3360:297::-;;3480:2;3468:9;3459:7;3455:23;3451:32;3448:2;;;3501:6;3493;3486:22;3448:2;3538:9;3532:16;3591:5;3584:13;3577:21;3570:5;3567:32;3557:2;;3618:6;3610;3603:22;3662:194;;3785:2;3773:9;3764:7;3760:23;3756:32;3753:2;;;3806:6;3798;3791:22;3753:2;-1:-1:-1;3834:16:1;;3743:113;-1:-1:-1;3743:113:1:o;3861:469::-;;3958:5;3952:12;3985:6;3980:3;3973:19;4011:4;4040:2;4035:3;4031:12;4024:19;;4077:2;4070:5;4066:14;4098:3;4110:195;4124:6;4121:1;4118:13;4110:195;;;4189:13;;-1:-1:-1;;;;;4185:39:1;4173:52;;4245:12;;;;4280:15;;;;4221:1;4139:9;4110:195;;;-1:-1:-1;4321:3:1;;3928:402;-1:-1:-1;;;;;3928:402:1:o;4335:430::-;;4502:6;4496:13;4527:3;4539:129;4553:6;4550:1;4547:13;4539:129;;;4651:4;4635:14;;;4631:25;;4625:32;4612:11;;;4605:53;4568:12;4539:129;;;4686:6;4683:1;4680:13;4677:2;;;4721:3;4712:6;4707:3;4703:16;4696:29;4677:2;-1:-1:-1;4743:16:1;;;;;4472:293;-1:-1:-1;;4472:293:1:o;4770:203::-;-1:-1:-1;;;;;4934:32:1;;;;4916:51;;4904:2;4889:18;;4871:102::o;4978:304::-;-1:-1:-1;;;;;5208:15:1;;;5190:34;;5260:15;;5255:2;5240:18;;5233:43;5140:2;5125:18;;5107:175::o;5287:274::-;-1:-1:-1;;;;;5479:32:1;;;;5461:51;;5543:2;5528:18;;5521:34;5449:2;5434:18;;5416:145::o;5566:187::-;5731:14;;5724:22;5706:41;;5694:2;5679:18;;5661:92::o;5758:399::-;5960:2;5942:21;;;5999:2;5979:18;;;5972:30;6038:34;6033:2;6018:18;;6011:62;-1:-1:-1;;;6104:2:1;6089:18;;6082:33;6147:3;6132:19;;5932:225::o;6162:177::-;6308:25;;;6296:2;6281:18;;6263:76::o;6344:508::-;;6607:6;6596:9;6589:25;6650:3;6645:2;6634:9;6630:18;6623:31;6671:63;6729:3;6718:9;6714:19;6706:6;6671:63;:::i;:::-;-1:-1:-1;;;;;6770:32:1;;;;6765:2;6750:18;;6743:60;-1:-1:-1;6834:2:1;6819:18;6812:34;6663:71;6579:273;-1:-1:-1;;6579:273:1:o;6857:580::-;;7148:6;7137:9;7130:25;7191:6;7186:2;7175:9;7171:18;7164:34;7234:3;7229:2;7218:9;7214:18;7207:31;7255:63;7313:3;7302:9;7298:19;7290:6;7255:63;:::i;:::-;-1:-1:-1;;;;;7354:32:1;;;;7349:2;7334:18;;7327:60;-1:-1:-1;7418:3:1;7403:19;7396:35;7247:71;7120:317;-1:-1:-1;;;7120:317:1:o

Swarm Source

ipfs://8977529fa63f58679f473b9a7ce99d5f90da0450bacca0eae199801122ecf03a

Block		Transaction	Difficulty	Gas Used	Reward

View All Blocks Produced

Block		Uncle Number	Difficulty	Gas Used	Reward

View All Uncles

Validator Index	Block		Amount

View All Withdrawals

Transaction Hash	Block		Value	Eth2 PubKey	Valid

View All Deposits

Multichain Portfolio | 26 Chains

Display all chains •

Last updated: less than 1 sec ago

Chain	Token	Portfolio %	Price	Amount	Value

A contract address hosts a smart contract, which is a set of code stored on the blockchain that runs when predetermined conditions are met. Learn more about addresses in our Knowledge Base.

Tools & Services