Contract 0x878c410028e3830f1fe03c428ff95012111ae1f1 2

 
Txn Hash Method
Block
From
To
Value [Txn Fee]
0x853ae3e700cbc0525c40f25ca825c0bf5a81170c6ae72f5642b982008886aedd0x60806040118295062022-05-11 20:11:14210 days 5 hrs ago0x26ed8119c45e3871df446a13f7fdc9e2c527dacd IN  Create: ConnectV2HopArbitrum0 ETH0.010157083174 ETH
[ Download CSV Export 
Latest 20 internal transactions
Parent Txn Hash Block From To Value
0x6fd112952e80f570239a399c227487396899f6741056f4518e6c06ca998b84ce348863572022-11-03 6:14:3134 days 19 hrs ago 0x079b3427dc1f63c303cae8fea3ef12bbf3c031fe 0x878c410028e3830f1fe03c428ff95012111ae1f10 ETH
0x9ecff81bc2656830515f99ac551ae2f06c326f58ad336c71d2f4458e2b48ffac326842382022-10-26 7:58:3542 days 18 hrs ago 0xb1f247bc5d9414dda93261964aff5ecf32f316c4 0x878c410028e3830f1fe03c428ff95012111ae1f10 ETH
0xef2af0aa1d9c7077061d829081eba113f0edf6f77a17c8b5998037d6c69a39ea240588802022-09-11 9:25:0487 days 16 hrs ago 0xb1f247bc5d9414dda93261964aff5ecf32f316c4 0x878c410028e3830f1fe03c428ff95012111ae1f10 ETH
0x0f3388117f834198952aa09130a1c7030e4dd77f830c6537fd3b020fc2dded7f231710562022-09-06 14:07:3792 days 11 hrs ago 0x01d437f9ca1cfdb1b182b7e29e4ff48a864a6a99 0x878c410028e3830f1fe03c428ff95012111ae1f10 ETH
0x6c4a39b3c4755ce511613fb9a460c4b281c4ad67c52c5bcd21452b67c86f9ac5207643902022-08-20 9:00:50109 days 16 hrs ago 0x7dc089ded787b9ecf8c6ddca3f971a5d86275021 0x878c410028e3830f1fe03c428ff95012111ae1f10 ETH
0x08cd2f08a2d2678dcceac5aa1600f0b5220918037e95bbab431fcc2bdae1b779207643262022-08-20 8:59:25109 days 16 hrs ago 0x7dc089ded787b9ecf8c6ddca3f971a5d86275021 0x878c410028e3830f1fe03c428ff95012111ae1f10 ETH
0xa141ae487a56a378b83b20937049a52f894cdee1155209c353b47678ceeab613207640092022-08-20 8:55:38109 days 17 hrs ago 0x7dc089ded787b9ecf8c6ddca3f971a5d86275021 0x878c410028e3830f1fe03c428ff95012111ae1f10 ETH
0x4a6fc6114b50c6af921e4605ae0a0e5585997d2e12f503d285f9e11565da3416193105932022-08-03 19:41:56126 days 6 hrs ago 0x079b3427dc1f63c303cae8fea3ef12bbf3c031fe 0x878c410028e3830f1fe03c428ff95012111ae1f10 ETH
0xe044b3480c036ab10cb048934506f1557025cd69cc71ee7ee3771d471fa93091192565692022-08-03 6:22:14126 days 19 hrs ago 0x079b3427dc1f63c303cae8fea3ef12bbf3c031fe 0x878c410028e3830f1fe03c428ff95012111ae1f10 ETH
0xed1eaa51b296510818c9f1f718e19c084212c72e19cfca23068794e18a41bed4190840172022-08-01 3:16:13128 days 22 hrs ago 0x8b9b3e2b2eb741f7ad4f3f912f6245bb3ffd9876 0x878c410028e3830f1fe03c428ff95012111ae1f10 ETH
0xa2c48c1984fa994d8eeedd3d8a6c0606f06bf984ab96a0a83502051f36a873b8185761192022-07-26 1:03:21135 days 55 mins ago 0x079b3427dc1f63c303cae8fea3ef12bbf3c031fe 0x878c410028e3830f1fe03c428ff95012111ae1f10 ETH
0x108d42fcac8f81637d4f43060931c54673cccb2d06b0edf52f0b69195b705725176471042022-07-14 19:57:44146 days 6 hrs ago 0x4b41e77761e6ef46514f7f2fddeebb22d99db76e 0x878c410028e3830f1fe03c428ff95012111ae1f10 ETH
0xa15254d2a68b5b5795f86eba72a535bf108aca44bc1acead7caf933b952ae0b7172129622022-07-07 20:20:49153 days 5 hrs ago 0x079b3427dc1f63c303cae8fea3ef12bbf3c031fe 0x878c410028e3830f1fe03c428ff95012111ae1f10 ETH
0x79223be898c9184b4d55cc5c6e4472a75b404431753077bc8c03aed6957b7375172128332022-07-07 20:18:11153 days 5 hrs ago 0x079b3427dc1f63c303cae8fea3ef12bbf3c031fe 0x878c410028e3830f1fe03c428ff95012111ae1f10 ETH
0xbfb892d08b6821e95d021b05e0671b3d78947b05db9891acde1a103d3afaa522160034322022-06-27 4:13:39163 days 21 hrs ago 0x7113efa861c9ba2129769bf0103ebb088ff81405 0x878c410028e3830f1fe03c428ff95012111ae1f10 ETH
0xadb3c78ebc853c224bd220397f8287d0627ed128087991208bb356e35e8937de155553802022-06-23 21:28:31167 days 4 hrs ago 0x7e3f32f05ff8c61a2deeb5094d18ef119c040ada 0x878c410028e3830f1fe03c428ff95012111ae1f10 ETH
0xa89eaca7efd3ea190df82cd170cc37118f70d2a4f6aacfd782e3601cf2bb7757150964032022-06-19 16:43:11171 days 9 hrs ago 0x1c440f08691e2219f027182c5d4a062fa794614b 0x878c410028e3830f1fe03c428ff95012111ae1f10 ETH
0x1ee17bbcdf00c52c4fcd5c36fd49119384ed0192e5aa7102526df9f79085d563143086432022-06-11 11:43:23179 days 14 hrs ago 0x0834c67d087d6e83ff411ff8f4267ef5429a6688 0x878c410028e3830f1fe03c428ff95012111ae1f10 ETH
0x206a278086a5464d7bc88472b6fd7bcd0e837e11be1aa0577c621e70b5233aeb130177662022-05-26 21:49:04195 days 4 hrs ago 0x7e3f32f05ff8c61a2deeb5094d18ef119c040ada 0x878c410028e3830f1fe03c428ff95012111ae1f10 ETH
0xa2890622d3cf66719c4dc2c5fd1116e3cbdf52c3ef98b7e97822bc1724ae2584118423432022-05-11 22:59:41210 days 2 hrs ago 0x67fce99dd6d8d659eea2a1ac1b8881c57eb6592b 0x878c410028e3830f1fe03c428ff95012111ae1f10 ETH
[ Download CSV Export 
Loading

Contract Source Code Verified (Exact Match)

Contract Name:
ConnectV2HopArbitrum

Compiler Version
v0.7.6+commit.7338295f

Optimization Enabled:
Yes with 200 runs

Other Settings:
default evmVersion, MIT license

Contract Source Code (Solidity)

/**
 *Submitted for verification at Arbiscan on 2022-05-11
*/

//SPDX-License-Identifier: MIT
pragma solidity ^0.7.0;
pragma experimental ABIEncoderV2;

interface TokenInterface {
	function approve(address, uint256) external;

	function transfer(address, uint256) external;

	function transferFrom(
		address,
		address,
		uint256
	) external;

	function deposit() external payable;

	function withdraw(uint256) external;

	function balanceOf(address) external view returns (uint256);

	function decimals() external view returns (uint256);
}

interface MemoryInterface {
	function getUint(uint256 id) external returns (uint256 num);

	function setUint(uint256 id, uint256 val) external;
}

interface InstaMapping {
	function cTokenMapping(address) external view returns (address);

	function gemJoinMapping(bytes32) external view returns (address);
}

interface AccountInterface {
	function enable(address) external;

	function disable(address) external;

	function isAuth(address) external view returns (bool);
}

abstract contract Stores {
	/**
	 * @dev Return ethereum address
	 */
	address internal constant ethAddr =
		0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE;

	/**
	 * @dev Return Wrapped ETH address
	 */
	address internal constant wethAddr =
		0x82aF49447D8a07e3bd95BD0d56f35241523fBab1;

	/**
	 * @dev Return memory variable address
	 */
	MemoryInterface internal constant instaMemory =
		MemoryInterface(0xc109f7Ef06152c3a63dc7254fD861E612d3Ac571);

	/**
	 * @dev Get Uint value from InstaMemory Contract.
	 */
	function getUint(uint256 getId, uint256 val)
		internal
		returns (uint256 returnVal)
	{
		returnVal = getId == 0 ? val : instaMemory.getUint(getId);
	}

	/**
	 * @dev Set Uint value in InstaMemory Contract.
	 */
	function setUint(uint256 setId, uint256 val) internal virtual {
		if (setId != 0) instaMemory.setUint(setId, val);
	}
}

interface IHopRouter {
	function swapAndSend(
		uint256 chainId,
		address recipient,
		uint256 amount,
		uint256 bonderFee,
		uint256 amountOutMin,
		uint256 deadline,
		uint256 destinationAmountOutMin,
		uint256 destinationDeadline
	) external payable;
}

/**
 * @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, with an overflow flag.
	 *
	 * _Available since v3.4._
	 */
	function tryAdd(uint256 a, uint256 b)
		internal
		pure
		returns (bool, uint256)
	{
		uint256 c = a + b;
		if (c < a) return (false, 0);
		return (true, c);
	}

	/**
	 * @dev Returns the substraction of two unsigned integers, with an overflow flag.
	 *
	 * _Available since v3.4._
	 */
	function trySub(uint256 a, uint256 b)
		internal
		pure
		returns (bool, uint256)
	{
		if (b > a) return (false, 0);
		return (true, a - b);
	}

	/**
	 * @dev Returns the multiplication of two unsigned integers, with an overflow flag.
	 *
	 * _Available since v3.4._
	 */
	function tryMul(uint256 a, uint256 b)
		internal
		pure
		returns (bool, 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 (true, 0);
		uint256 c = a * b;
		if (c / a != b) return (false, 0);
		return (true, c);
	}

	/**
	 * @dev Returns the division of two unsigned integers, with a division by zero flag.
	 *
	 * _Available since v3.4._
	 */
	function tryDiv(uint256 a, uint256 b)
		internal
		pure
		returns (bool, uint256)
	{
		if (b == 0) return (false, 0);
		return (true, a / b);
	}

	/**
	 * @dev Returns the remainder of dividing two unsigned integers, with a division by zero flag.
	 *
	 * _Available since v3.4._
	 */
	function tryMod(uint256 a, uint256 b)
		internal
		pure
		returns (bool, uint256)
	{
		if (b == 0) return (false, 0);
		return (true, a % b);
	}

	/**
	 * @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) {
		require(b <= a, "SafeMath: subtraction overflow");
		return a - b;
	}

	/**
	 * @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) {
		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, reverting 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) {
		require(b > 0, "SafeMath: division by zero");
		return a / b;
	}

	/**
	 * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
	 * reverting 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) {
		require(b > 0, "SafeMath: modulo by zero");
		return a % b;
	}

	/**
	 * @dev Returns the subtraction of two unsigned integers, reverting with custom message on
	 * overflow (when the result is negative).
	 *
	 * CAUTION: This function is deprecated because it requires allocating memory for the error
	 * message unnecessarily. For custom revert reasons use {trySub}.
	 *
	 * 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);
		return a - b;
	}

	/**
	 * @dev Returns the integer division of two unsigned integers, reverting with custom message on
	 * division by zero. The result is rounded towards zero.
	 *
	 * CAUTION: This function is deprecated because it requires allocating memory for the error
	 * message unnecessarily. For custom revert reasons use {tryDiv}.
	 *
	 * 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);
		return a / b;
	}

	/**
	 * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
	 * reverting with custom message when dividing by zero.
	 *
	 * CAUTION: This function is deprecated because it requires allocating memory for the error
	 * message unnecessarily. For custom revert reasons use {tryMod}.
	 *
	 * 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;
	}
}

contract DSMath {
	uint256 constant WAD = 10**18;
	uint256 constant RAY = 10**27;

	function add(uint256 x, uint256 y) internal pure returns (uint256 z) {
		z = SafeMath.add(x, y);
	}

	function sub(uint256 x, uint256 y)
		internal
		pure
		virtual
		returns (uint256 z)
	{
		z = SafeMath.sub(x, y);
	}

	function mul(uint256 x, uint256 y) internal pure returns (uint256 z) {
		z = SafeMath.mul(x, y);
	}

	function div(uint256 x, uint256 y) internal pure returns (uint256 z) {
		z = SafeMath.div(x, y);
	}

	function wmul(uint256 x, uint256 y) internal pure returns (uint256 z) {
		z = SafeMath.add(SafeMath.mul(x, y), WAD / 2) / WAD;
	}

	function wdiv(uint256 x, uint256 y) internal pure returns (uint256 z) {
		z = SafeMath.add(SafeMath.mul(x, WAD), y / 2) / y;
	}

	function rdiv(uint256 x, uint256 y) internal pure returns (uint256 z) {
		z = SafeMath.add(SafeMath.mul(x, RAY), y / 2) / y;
	}

	function rmul(uint256 x, uint256 y) internal pure returns (uint256 z) {
		z = SafeMath.add(SafeMath.mul(x, y), RAY / 2) / RAY;
	}

	function toInt(uint256 x) internal pure returns (int256 y) {
		y = int256(x);
		require(y >= 0, "int-overflow");
	}

	function toRad(uint256 wad) internal pure returns (uint256 rad) {
		rad = mul(wad, 10**27);
	}
}

abstract contract Basic is DSMath, Stores {
	function convert18ToDec(uint256 _dec, uint256 _amt)
		internal
		pure
		returns (uint256 amt)
	{
		amt = (_amt / 10**(18 - _dec));
	}

	function convertTo18(uint256 _dec, uint256 _amt)
		internal
		pure
		returns (uint256 amt)
	{
		amt = mul(_amt, 10**(18 - _dec));
	}

	function getTokenBal(TokenInterface token)
		internal
		view
		returns (uint256 _amt)
	{
		_amt = address(token) == ethAddr
			? address(this).balance
			: token.balanceOf(address(this));
	}

	function getTokensDec(TokenInterface buyAddr, TokenInterface sellAddr)
		internal
		view
		returns (uint256 buyDec, uint256 sellDec)
	{
		buyDec = address(buyAddr) == ethAddr ? 18 : buyAddr.decimals();
		sellDec = address(sellAddr) == ethAddr ? 18 : sellAddr.decimals();
	}

	function encodeEvent(string memory eventName, bytes memory eventParam)
		internal
		pure
		returns (bytes memory)
	{
		return abi.encode(eventName, eventParam);
	}

	function approve(
		TokenInterface token,
		address spender,
		uint256 amount
	) internal {
		try token.approve(spender, amount) {} catch {
			token.approve(spender, 0);
			token.approve(spender, amount);
		}
	}

	function changeEthAddress(address buy, address sell)
		internal
		pure
		returns (TokenInterface _buy, TokenInterface _sell)
	{
		_buy = buy == ethAddr ? TokenInterface(wethAddr) : TokenInterface(buy);
		_sell = sell == ethAddr
			? TokenInterface(wethAddr)
			: TokenInterface(sell);
	}

	function convertEthToWeth(
		bool isEth,
		TokenInterface token,
		uint256 amount
	) internal {
		if (isEth) token.deposit{ value: amount }();
	}

	function convertWethToEth(
		bool isEth,
		TokenInterface token,
		uint256 amount
	) internal {
		if (isEth) {
			approve(token, address(token), amount);
			token.withdraw(amount);
		}
	}
}

contract Helpers is DSMath, Basic {
	/**
	 * @param token The address of token to be bridged.(For USDC: 0x2791Bca1f2de4661ED88A30C99A7a9449Aa84174)
	 * @param targetChainId The Id of the destination chain.(For MAINNET : 1)
	 * @param router The address of hop router.
	 * @param recipient The address to recieve the token on destination chain.
	 * @param amount The total amount sent by user (Includes bonder fee, destination chain Tx cost).
	 * @param bonderFee The fee to be recieved by bonder at destination chain.
	 * @param sourceAmountOutMin minimum amount of token out for swap on source chain.
	 * @param sourceDeadline The deadline for the source chain transaction (Recommended - Date.now() + 604800 (1 week))
	 * @param destinationAmountOutMin minimum amount of token out for bridge on target chain, zero for L1 bridging
	 * @param destinationDeadline The deadline for the target chain transaction (Recommended - Date.now() + 604800 (1 week)), zero for L1 bridging
	 */
	struct BridgeParams {
		address token;
		address router;
		address recipient;
		uint256 targetChainId;
		uint256 amount;
		uint256 bonderFee;
		uint256 sourceAmountOutMin;
		uint256 sourceDeadline;
		uint256 destinationAmountOutMin;
		uint256 destinationDeadline;
	}

	function _swapAndSend(BridgeParams memory params, bool isEth) internal {
		IHopRouter router = IHopRouter(params.router);

		uint256 nativeTokenAmt = isEth ? params.amount : 0;
		if (!isEth) {
			TokenInterface tokenContract = TokenInterface(params.token);
			approve(tokenContract, params.router, params.amount);
		}

		router.swapAndSend{ value: nativeTokenAmt }(
			params.targetChainId,
			params.recipient,
			params.amount,
			params.bonderFee,
			params.sourceAmountOutMin,
			params.sourceDeadline,
			params.destinationAmountOutMin,
			params.destinationDeadline
		);
	}
}

contract Events {
	event LogBridge(
		address token,
		uint256 chainId,
		address recipient,
		uint256 amount,
		uint256 bonderFee,
		uint256 amountOutMin,
		uint256 deadline,
		uint256 destinationAmountOutMin,
		uint256 destinationDeadline,
		uint256 getId
	);
}

/**
 * @title Hop.
 * @dev Cross chain Bridge.
 */

abstract contract Resolver is Helpers {
	/**
	 * @dev Bridge Token.
	 * @notice Bridge Token on HOP.
	 * @param params BridgeParams struct for bridging
	 * @param getId ID to retrieve amount from last spell.
	 */
	function bridge(BridgeParams memory params, uint256 getId)
		external
		payable
		returns (string memory _eventName, bytes memory _eventParam)
	{
		if (params.targetChainId == 1) {
			require(
				params.destinationAmountOutMin == 0,
				"destinationAmountOutMin != 0, sending to L1"
			);
			require(
				params.destinationDeadline == 0,
				"destinationDeadline != 0, sending to L1"
			);
		}

		params.amount = getUint(getId, params.amount);
		TokenInterface tokenContract = TokenInterface(params.token);

		if (params.token == wethAddr) {
			convertWethToEth(true, tokenContract, params.amount);
			params.token = ethAddr;
		}

		bool isEth = params.token == ethAddr;

		if (isEth) {
			params.amount = params.amount == uint256(-1)
				? address(this).balance
				: params.amount;
		} else {
			params.amount = params.amount == uint256(-1)
				? tokenContract.balanceOf(address(this))
				: params.amount;
		}

		_swapAndSend(params, isEth);

		_eventName = "LogBridge(address,uint256,address,uint256,uint256,uint256,uint256,uint256,uint256,uint256)";
		_eventParam = abi.encode(
			params.token,
			params.targetChainId,
			params.recipient,
			params.amount,
			params.bonderFee,
			params.sourceAmountOutMin,
			params.sourceDeadline,
			params.destinationAmountOutMin,
			params.destinationDeadline,
			getId
		);
	}
}

contract ConnectV2HopArbitrum is Resolver {
	string public constant name = "Hop-v1.0";
}

Contract ABI

[{"inputs":[{"components":[{"internalType":"address","name":"token","type":"address"},{"internalType":"address","name":"router","type":"address"},{"internalType":"address","name":"recipient","type":"address"},{"internalType":"uint256","name":"targetChainId","type":"uint256"},{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"uint256","name":"bonderFee","type":"uint256"},{"internalType":"uint256","name":"sourceAmountOutMin","type":"uint256"},{"internalType":"uint256","name":"sourceDeadline","type":"uint256"},{"internalType":"uint256","name":"destinationAmountOutMin","type":"uint256"},{"internalType":"uint256","name":"destinationDeadline","type":"uint256"}],"internalType":"struct Helpers.BridgeParams","name":"params","type":"tuple"},{"internalType":"uint256","name":"getId","type":"uint256"}],"name":"bridge","outputs":[{"internalType":"string","name":"_eventName","type":"string"},{"internalType":"bytes","name":"_eventParam","type":"bytes"}],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"}]

608060405234801561001057600080fd5b5061094e806100206000396000f3fe6080604052600436106100295760003560e01c806306fdde031461002e578063858424b814610059575b600080fd5b34801561003a57600080fd5b5061004361007a565b604051610050919061077f565b60405180910390f35b61006c6100673660046105eb565b61009e565b604051610050929190610792565b604051806040016040528060088152602001670486f702d76312e360c41b81525081565b6060808360600151600114156100fd57610100840151156100da5760405162461bcd60e51b81526004016100d190610807565b60405180910390fd5b610120840151156100fd5760405162461bcd60e51b81526004016100d1906107c0565b61010b8385608001516102ca565b608085015283516001600160a01b0381167382af49447d8a07e3bd95bd0d56f35241523fbab1141561015f576101476001828760800151610369565b73eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee85525b84516001600160a01b031673eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee1480156101a95760001986608001511461019d57856080015161019f565b475b6080870152610242565b6000198660800151146101c057856080015161023c565b6040516370a0823160e01b81526001600160a01b038316906370a08231906101ec9030906004016106fc565b60206040518083038186803b15801561020457600080fd5b505afa158015610218573d6000803e3d6000fd5b505050506040513d601f19601f8201168201806040525081019061023c9190610699565b60808701525b61024c86826103de565b6040518060800160405280605a81526020016108bf605a9139935085600001518660600151876040015188608001518960a001518a60c001518b60e001518c61010001518d61012001518d6040516020016102b09a99989796959493929190610729565b604051602081830303815290604052925050509250929050565b60008215610360576040516354e3875560e11b815273c109f7ef06152c3a63dc7254fd861e612d3ac5719063a9c70eaa90610309908690600401610852565b602060405180830381600087803b15801561032357600080fd5b505af1158015610337573d6000803e3d6000fd5b505050506040513d601f19601f8201168201806040525081019061035b9190610699565b610362565b815b9392505050565b82156103d95761037a8283836104ac565b604051632e1a7d4d60e01b81526001600160a01b03831690632e1a7d4d906103a6908490600401610852565b600060405180830381600087803b1580156103c057600080fd5b505af11580156103d4573d6000803e3d6000fd5b505050505b505050565b60208201516000826103f15760006103f7565b83608001515b905082610417578351602085015160808601516104159183916104ac565b505b816001600160a01b031663eea0d7b2828660600151876040015188608001518960a001518a60c001518b60e001518c61010001518d61012001516040518a63ffffffff1660e01b815260040161047498979695949392919061085b565b6000604051808303818588803b15801561048d57600080fd5b505af11580156104a1573d6000803e3d6000fd5b505050505050505050565b60405163095ea7b360e01b81526001600160a01b0384169063095ea7b3906104da9085908590600401610710565b600060405180830381600087803b1580156104f457600080fd5b505af1925050508015610505575060015b6103d95760405163095ea7b360e01b81526001600160a01b0384169063095ea7b390610538908590600090600401610710565b600060405180830381600087803b15801561055257600080fd5b505af1158015610566573d6000803e3d6000fd5b505060405163095ea7b360e01b81526001600160a01b038616925063095ea7b391506105989085908590600401610710565b600060405180830381600087803b1580156105b257600080fd5b505af11580156105c6573d6000803e3d6000fd5b505050506103d9565b80356001600160a01b03811681146105e657600080fd5b919050565b6000808284036101608112156105ff578283fd5b6101408082121561060e578384fd5b6106178161089a565b9150610622856105cf565b8252610630602086016105cf565b6020830152610641604086016105cf565b6040830152606085810135908301526080808601359083015260a0808601359083015260c0808601359083015260e0808601359083015261010080860135908301526101208086013590830152909593013593505050565b6000602082840312156106aa578081fd5b5051919050565b60008151808452815b818110156106d6576020818501810151868301820152016106ba565b818111156106e75782602083870101525b50601f01601f19169290920160200192915050565b6001600160a01b0391909116815260200190565b6001600160a01b03929092168252602082015260400190565b6001600160a01b039a8b16815260208101999099529690981660408801526060870194909452608086019290925260a085015260c084015260e08301526101008201929092526101208101919091526101400190565b60006020825261036260208301846106b1565b6000604082526107a560408301856106b1565b82810360208401526107b781856106b1565b95945050505050565b60208082526027908201527f64657374696e6174696f6e446561646c696e6520213d20302c2073656e64696e6040820152666720746f204c3160c81b606082015260800190565b6020808252602b908201527f64657374696e6174696f6e416d6f756e744f75744d696e20213d20302c20736560408201526a6e64696e6720746f204c3160a81b606082015260800190565b90815260200190565b9788526001600160a01b0396909616602088015260408701949094526060860192909252608085015260a084015260c083015260e08201526101000190565b60405181810167ffffffffffffffff811182821017156108b657fe5b60405291905056fe4c6f6742726964676528616464726573732c75696e743235362c616464726573732c75696e743235362c75696e743235362c75696e743235362c75696e743235362c75696e743235362c75696e743235362c75696e7432353629a26469706673582212204c943ab5fab1256e26da94ecc17dc60aa806bcd1c412a4830ff827f008acd91064736f6c63430007060033

Deployed ByteCode Sourcemap

15961:90:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;16007:40;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;14579:1375;;;;;;:::i;:::-;;:::i;:::-;;;;;;;;:::i;16007:40::-;;;;;;;;;;;;;;-1:-1:-1;;;16007:40:0;;;;:::o;14579:1375::-;14673:24;14699;14736:6;:20;;;14760:1;14736:25;14732:255;;;14783:30;;;;:35;14769:107;;;;-1:-1:-1;;;14769:107:0;;;;;;;:::i;:::-;;;;;;;;;14896:26;;;;:31;14882:99;;;;-1:-1:-1;;;14882:99:0;;;;;;;:::i;:::-;15009:29;15017:5;15024:6;:13;;;15009:7;:29::i;:::-;14993:13;;;:45;15089:12;;-1:-1:-1;;;;;15113:24:0;;1247:42;15113:24;15109:122;;;15145:52;15162:4;15168:13;15183:6;:13;;;15145:16;:52::i;:::-;1110:42;15203:22;;15109:122;15250:12;;-1:-1:-1;;;;;15250:23:0;1110:42;15250:23;15280:246;;;;-1:-1:-1;;15313:6:0;:13;;;:28;:78;;15378:6;:13;;;15313:78;;;15349:21;15313:78;15297:13;;;:94;15280:246;;;-1:-1:-1;;15425:6:0;:13;;;:28;:95;;15507:6;:13;;;15425:95;;;15461:38;;-1:-1:-1;;;15461:38:0;;-1:-1:-1;;;;;15461:23:0;;;;;:38;;15493:4;;15461:38;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;15409:13;;;:111;15280:246;15532:27;15545:6;15553:5;15532:12;:27::i;:::-;15566:105;;;;;;;;;;;;;;;;;;;15706:6;:12;;;15724:6;:20;;;15750:6;:16;;;15772:6;:13;;;15791:6;:16;;;15813:6;:25;;;15844:6;:21;;;15871:6;:30;;;15907:6;:26;;;15939:5;15690:259;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;15676:273;;14579:1375;;;;;;;:::o;1528:157::-;1597:17;1635:10;;:45;;1654:26;;-1:-1:-1;;;1654:26:0;;1415:42;;1654:19;;:26;;1674:5;;1654:26;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;1635:45;;;1648:3;1635:45;1623:57;1528:157;-1:-1:-1;;;1528:157:0:o;11937:196::-;12044:5;12040:89;;;12057:38;12065:5;12080;12088:6;12057:7;:38::i;:::-;12101:22;;-1:-1:-1;;;12101:22:0;;-1:-1:-1;;;;;12101:14:0;;;;;:22;;12116:6;;12101:22;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;12040:89;11937:196;;;:::o;13416:598::-;13523:13;;;;13492:17;13569:5;:25;;13593:1;13569:25;;;13577:6;:13;;;13569:25;13544:50;;13604:5;13599:141;;13663:12;;13705:13;;;;13720;;;;13682:52;;13663:12;;13682:7;:52::i;:::-;13599:141;;13746:6;-1:-1:-1;;;;;13746:18:0;;13773:14;13795:6;:20;;;13821:6;:16;;;13843:6;:13;;;13862:6;:16;;;13884:6;:25;;;13915:6;:21;;;13942:6;:30;;;13978:6;:26;;;13746:263;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;13416:598;;;;:::o;11255:220::-;11358:30;;-1:-1:-1;;;11358:30:0;;-1:-1:-1;;;;;11358:13:0;;;;;:30;;11372:7;;11381:6;;11358:30;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;11354:117;;11404:25;;-1:-1:-1;;;11404:25:0;;-1:-1:-1;;;;;11404:13:0;;;;;:25;;11418:7;;11427:1;;11404:25;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;11435:30:0;;-1:-1:-1;;;11435:30:0;;-1:-1:-1;;;;;11435:13:0;;;-1:-1:-1;11435:13:0;;-1:-1:-1;11435:30:0;;11449:7;;11458:6;;11435:30;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;11354:117;;14:175:1;84:20;;-1:-1:-1;;;;;133:31:1;;123:42;;113:2;;179:1;176;169:12;113:2;65:124;;;:::o;194:1115::-;;;344:9;335:7;331:23;374:3;370:2;366:12;363:2;;;396:6;388;381:22;363:2;424:6;450:2;446;442:11;439:2;;;471:6;463;456:22;439:2;502:18;517:2;502:18;:::i;:::-;489:31;;543;564:9;543:31;:::i;:::-;536:5;529:46;607:40;643:2;632:9;628:18;607:40;:::i;:::-;602:2;595:5;591:14;584:64;680:40;716:2;705:9;701:18;680:40;:::i;:::-;675:2;664:14;;657:64;781:2;766:18;;;753:32;737:14;;;730:56;847:3;832:19;;;819:33;802:15;;;795:58;914:3;899:19;;;886:33;869:15;;;862:58;981:3;966:19;;;953:33;936:15;;;929:58;1048:3;1033:19;;;1020:33;1003:15;;;996:58;1073:3;1121:18;;;1108:32;1092:14;;;1085:56;1160:3;1208:18;;;1195:32;1179:14;;;1172:56;668:5;;1284:18;;1271:32;;-1:-1:-1;;;311:998:1:o;1314:194::-;;1437:2;1425:9;1416:7;1412:23;1408:32;1405:2;;;1458:6;1450;1443:22;1405:2;-1:-1:-1;1486:16:1;;1395:113;-1:-1:-1;1395:113:1:o;1513:477::-;;1594:5;1588:12;1621:6;1616:3;1609:19;1646:3;1658:162;1672:6;1669:1;1666:13;1658:162;;;1734:4;1790:13;;;1786:22;;1780:29;1762:11;;;1758:20;;1751:59;1687:12;1658:162;;;1838:6;1835:1;1832:13;1829:2;;;1904:3;1897:4;1888:6;1883:3;1879:16;1875:27;1868:40;1829:2;-1:-1:-1;1972:2:1;1951:15;-1:-1:-1;;1947:29:1;1938:39;;;;1979:4;1934:50;;1564:426;-1:-1:-1;;1564:426:1:o;1995:203::-;-1:-1:-1;;;;;2159:32:1;;;;2141:51;;2129:2;2114:18;;2096:102::o;2203:282::-;-1:-1:-1;;;;;2403:32:1;;;;2385:51;;2467:2;2452:18;;2445:34;2373:2;2358:18;;2340:145::o;2769:879::-;-1:-1:-1;;;;;3224:15:1;;;3206:34;;3271:2;3256:18;;3249:34;;;;3319:15;;;;3314:2;3299:18;;3292:43;3366:2;3351:18;;3344:34;;;;3409:3;3394:19;;3387:35;;;;3186:3;3438:19;;3431:35;3497:3;3482:19;;3475:35;3541:3;3526:19;;3519:35;3585:3;3570:19;;3563:35;;;;3629:3;3614:19;;3607:35;;;;3155:3;3140:19;;3122:526::o;3653:221::-;;3802:2;3791:9;3784:21;3822:46;3864:2;3853:9;3849:18;3841:6;3822:46;:::i;3879:383::-;;4074:2;4063:9;4056:21;4100:46;4142:2;4131:9;4127:18;4119:6;4100:46;:::i;:::-;4194:9;4186:6;4182:22;4177:2;4166:9;4162:18;4155:50;4222:34;4249:6;4241;4222:34;:::i;:::-;4214:42;4046:216;-1:-1:-1;;;;;4046:216:1:o;4267:403::-;4469:2;4451:21;;;4508:2;4488:18;;;4481:30;4547:34;4542:2;4527:18;;4520:62;-1:-1:-1;;;4613:2:1;4598:18;;4591:37;4660:3;4645:19;;4441:229::o;4675:407::-;4877:2;4859:21;;;4916:2;4896:18;;;4889:30;4955:34;4950:2;4935:18;;4928:62;-1:-1:-1;;;5021:2:1;5006:18;;4999:41;5072:3;5057:19;;4849:233::o;5087:177::-;5233:25;;;5221:2;5206:18;;5188:76::o;5269:705::-;5612:25;;;-1:-1:-1;;;;;5673:32:1;;;;5668:2;5653:18;;5646:60;5737:2;5722:18;;5715:34;;;;5780:2;5765:18;;5758:34;;;;5823:3;5808:19;;5801:35;5693:3;5852:19;;5845:35;5911:3;5896:19;;5889:35;5955:3;5940:19;;5933:35;5599:3;5584:19;;5566:408::o;5979:242::-;6049:2;6043:9;6079:17;;;6126:18;6111:34;;6147:22;;;6108:62;6105:2;;;6173:9;6105:2;6200;6193:22;6023:198;;-1:-1:-1;6023:198:1:o

Metadata Hash

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