ETH Price: $3,300.54 (-1.62%)

Contract

0xF3f04555f8FdA510bfC77820FD6eB8446f59E72d
 

Overview

ETH Balance

0.04000444231213462 ETH

Eth Value

$132.04 (@ $3,300.54/ETH)

Token Holdings

Multichain Info

1 address found via
Transaction Hash
Method
Block
From
To
Wrap And Swap ET...214638232024-12-23 7:54:3530 mins ago1734940475IN
Mayan Swap: Bridge
0.04911091 ETH0.000598954.63229746
Wrap And Swap ET...214632662024-12-23 6:01:352 hrs ago1734933695IN
Mayan Swap: Bridge
0.09804181 ETH0.000471763.64864239
Wrap And Swap ET...214616832024-12-23 0:42:597 hrs ago1734914579IN
Mayan Swap: Bridge
0.49688343 ETH0.000559364.32615894
Wrap And Swap ET...214610152024-12-22 22:27:599 hrs ago1734906479IN
Mayan Swap: Bridge
0.0865014 ETH0.000711055.49980807
Wrap And Swap ET...214608692024-12-22 21:58:2310 hrs ago1734904703IN
Mayan Swap: Bridge
2.10250565 ETH0.000786546.08315698
Wrap And Swap ET...214594872024-12-22 17:20:1115 hrs ago1734888011IN
Mayan Swap: Bridge
0.007 ETH0.000813026.2698797
Wrap And Swap ET...214570332024-12-22 9:06:1123 hrs ago1734858371IN
Mayan Swap: Bridge
0.99665423 ETH0.000685775.30431589
Wrap And Swap ET...214565212024-12-22 7:23:3525 hrs ago1734852215IN
Mayan Swap: Bridge
1.50139043 ETH0.000586344.53520952
Wrap And Swap ET...214561792024-12-22 6:15:1126 hrs ago1734848111IN
Mayan Swap: Bridge
0.06182273 ETH0.000783446.05917502
Wrap And Swap ET...214546772024-12-22 1:12:5931 hrs ago1734829979IN
Mayan Swap: Bridge
0.02 ETH0.000765325.91904818
Wrap And Swap ET...214533712024-12-21 20:48:5935 hrs ago1734814139IN
Mayan Swap: Bridge
0.02238939 ETH0.000854086.605522
Wrap And Swap ET...214529512024-12-21 19:24:3537 hrs ago1734809075IN
Mayan Swap: Bridge
0.05483052 ETH0.001187349.18297155
Wrap And Swap ET...214523822024-12-21 17:29:1138 hrs ago1734802151IN
Mayan Swap: Bridge
0.12317465 ETH0.000892786.90674893
Wrap And Swap ET...214512512024-12-21 13:42:2342 hrs ago1734788543IN
Mayan Swap: Bridge
0.02503322 ETH0.0014661311.33910221
Wrap And Swap ET...214491132024-12-21 6:32:352 days ago1734762755IN
Mayan Swap: Bridge
0.62227882 ETH0.000946977.32462026
Wrap And Swap ET...214488272024-12-21 5:34:592 days ago1734759299IN
Mayan Swap: Bridge
0.02006953 ETH0.00087586.77351159
Wrap And Swap ET...214473682024-12-21 0:38:592 days ago1734741539IN
Mayan Swap: Bridge
0.07 ETH0.001048428.10931209
Wrap And Swap ET...214468512024-12-20 22:55:112 days ago1734735311IN
Mayan Swap: Bridge
0.20624908 ETH0.001238969.58305195
Wrap And Swap ET...214445892024-12-20 15:20:592 days ago1734708059IN
Mayan Swap: Bridge
0.05515552 ETH0.0060158446.52660859
Wrap And Swap ET...214427642024-12-20 9:13:592 days ago1734686039IN
Mayan Swap: Bridge
1.84098373 ETH0.004929138.12530614
Wrap And Swap ET...214416952024-12-20 5:38:233 days ago1734673103IN
Mayan Swap: Bridge
4.99561852 ETH0.0013511510.45080999
Wrap And Swap ET...214416772024-12-20 5:34:473 days ago1734672887IN
Mayan Swap: Bridge
0.15553384 ETH0.001177879.10969587
Wrap And Swap ET...214411922024-12-20 3:57:353 days ago1734667055IN
Mayan Swap: Bridge
0.03594975 ETH0.001166429.02117873
Wrap And Swap ET...214407122024-12-20 2:21:113 days ago1734661271IN
Mayan Swap: Bridge
0.02517771 ETH0.001216769.41043633
Wrap And Swap ET...214401162024-12-20 0:21:353 days ago1734654095IN
Mayan Swap: Bridge
0.01612454 ETH0.0019104414.7754348
View all transactions

Latest 25 internal transactions (View All)

Advanced mode:
Parent Transaction Hash Block
From
To
214638232024-12-23 7:54:3530 mins ago1734940475
Mayan Swap: Bridge
0.04911091 ETH
214632662024-12-23 6:01:352 hrs ago1734933695
Mayan Swap: Bridge
0.09804181 ETH
214616832024-12-23 0:42:597 hrs ago1734914579
Mayan Swap: Bridge
0.49688343 ETH
214613972024-12-22 23:44:598 hrs ago1734911099
Mayan Swap: Bridge
0.05231 ETH
214613972024-12-22 23:44:598 hrs ago1734911099
Mayan Swap: Bridge
0.00161 ETH
214613972024-12-22 23:44:598 hrs ago1734911099
Mayan Swap: Bridge
0.05392 ETH
214610152024-12-22 22:27:599 hrs ago1734906479
Mayan Swap: Bridge
0.0865014 ETH
214610022024-12-22 22:25:239 hrs ago1734906323
Mayan Swap: Bridge
0.10539995 ETH
214610022024-12-22 22:25:239 hrs ago1734906323
Mayan Swap: Bridge
0.00340953 ETH
214610022024-12-22 22:25:239 hrs ago1734906323
Mayan Swap: Bridge
0.10880948 ETH
214608692024-12-22 21:58:2310 hrs ago1734904703
Mayan Swap: Bridge
2.10250565 ETH
214608622024-12-22 21:56:5910 hrs ago1734904619
Mayan Swap: Bridge
2.10607989 ETH
214608622024-12-22 21:56:5910 hrs ago1734904619
Mayan Swap: Bridge
0.00266936 ETH
214608622024-12-22 21:56:5910 hrs ago1734904619
Mayan Swap: Bridge
2.10874925 ETH
214594872024-12-22 17:20:1115 hrs ago1734888011
Mayan Swap: Bridge
0.007 ETH
214583182024-12-22 13:25:1118 hrs ago1734873911
Mayan Swap: Bridge
0.04901716 ETH
214583182024-12-22 13:25:1118 hrs ago1734873911
Mayan Swap: Bridge
0.00292446 ETH
214583182024-12-22 13:25:1118 hrs ago1734873911
Mayan Swap: Bridge
0.05194162 ETH
214570542024-12-22 9:10:2323 hrs ago1734858623
Mayan Swap: Bridge
0.35090491 ETH
214570542024-12-22 9:10:2323 hrs ago1734858623
Mayan Swap: Bridge
0.00264119 ETH
214570542024-12-22 9:10:2323 hrs ago1734858623
Mayan Swap: Bridge
0.3535461 ETH
214570332024-12-22 9:06:1123 hrs ago1734858371
Mayan Swap: Bridge
0.99665423 ETH
214565212024-12-22 7:23:3525 hrs ago1734852215
Mayan Swap: Bridge
1.50139043 ETH
214561792024-12-22 6:15:1126 hrs ago1734848111
Mayan Swap: Bridge
0.06182273 ETH
214551802024-12-22 2:53:5929 hrs ago1734836039
Mayan Swap: Bridge
0.05922596 ETH
View All Internal Transactions
Loading...
Loading

Contract Source Code Verified (Exact Match)

Contract Name:
MayanSwap

Compiler Version
v0.8.4+commit.c7e474f2

Optimization Enabled:
Yes with 200 runs

Other Settings:
default evmVersion
File 1 of 10 : MayanSwap.sol
// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";

import "./interfaces/ITokenBridge.sol";
import "./interfaces/IWormhole.sol";

import "./MayanStructs.sol";
import "./libs/BytesLib.sol";

contract MayanSwap {
	event Redeemed(uint16 indexed emitterChainId, bytes32 indexed emitterAddress, uint64 indexed sequence);

	using SafeERC20 for IERC20;
	using BytesLib for bytes;

	ITokenBridge tokenBridge;
	address guardian;
	address nextGuardian;
	bool paused;
	IWETH weth;
	uint16 homeChainId;

	struct RelayerFees {
		uint64 swapFee;
		uint64 redeemFee;
		uint64 refundFee;
	}

	struct Criteria {
		uint256 transferDeadline;
		uint64 swapDeadline;
		uint64 amountOutMin;
		bool unwrap;
		uint64 gasDrop;
		bytes customPayload;
	}

	struct Recepient {
		bytes32 mayanAddr;
		uint16 mayanChainId;
		bytes32 auctionAddr;
		bytes32 destAddr;
		uint16 destChainId;
		bytes32 referrer;
		bytes32 refundAddr;
	}

	constructor(address _tokenBridge, address _weth) {
		tokenBridge = ITokenBridge(_tokenBridge);
		homeChainId = tokenBridge.chainId();
		guardian = msg.sender;
		weth = IWETH(_weth);
	}

	function swap(RelayerFees memory relayerFees, Recepient memory recipient, bytes32 tokenOutAddr, uint16 tokenOutChainId, Criteria memory criteria, address tokenIn, uint256 amountIn) public payable returns (uint64 sequence) {
		require(paused == false, 'contract is paused');
		require(block.timestamp <= criteria.transferDeadline, 'deadline passed');
		if (criteria.unwrap) {
			require(criteria.gasDrop == 0, 'gas drop not allowed');
		}

		uint8 decimals = decimalsOf(tokenIn);
		uint256 normalizedAmount = normalizeAmount(amountIn, decimals);

		require(relayerFees.swapFee + relayerFees.refundFee < normalizedAmount, 'fees exceed amount');
		require(relayerFees.redeemFee < criteria.amountOutMin, 'redeem fee exceeds min output');

		amountIn = deNormalizeAmount(normalizedAmount, decimals);

		IERC20(tokenIn).safeTransferFrom(msg.sender, address(this), amountIn);
		IERC20(tokenIn).safeIncreaseAllowance(address(tokenBridge), amountIn);
		uint64 seq1 = tokenBridge.transferTokens{ value: msg.value/2 }(tokenIn, amountIn, recipient.mayanChainId, recipient.mayanAddr, 0, 0);

		MayanStructs.Swap memory swapStruct = MayanStructs.Swap({
			payloadId: criteria.customPayload.length > 0 ? 2 : 1,
			tokenAddr: tokenOutAddr,
			tokenChainId: tokenOutChainId,
			destAddr: recipient.destAddr,
			destChainId: recipient.destChainId,
			sourceAddr: recipient.refundAddr,
			sourceChainId: homeChainId,
			sequence: seq1,
			amountOutMin: criteria.amountOutMin,
			deadline: criteria.swapDeadline,
			swapFee: relayerFees.swapFee,
			redeemFee: relayerFees.redeemFee,
			refundFee: relayerFees.refundFee,
			auctionAddr: recipient.auctionAddr,
			unwrapRedeem: criteria.unwrap,
			unwrapRefund: false
		});

		bytes memory encoded = encodeSwap(swapStruct)
			.concat(abi.encodePacked(swapStruct.unwrapRedeem, swapStruct.unwrapRefund, recipient.referrer, criteria.gasDrop));

		if (swapStruct.payloadId == 2) {
			require(swapStruct.destChainId == recipient.mayanChainId, 'invalid chain id with payload');
			encoded = encoded.concat(abi.encodePacked(criteria.customPayload));
		}

		sequence = tokenBridge.wormhole().publishMessage{
			value : msg.value/2
		}(0, encoded, tokenBridge.finality());
	}

	function wrapAndSwapETH(RelayerFees memory relayerFees, Recepient memory recipient, bytes32 tokenOutAddr, uint16 tokenOutChainId, Criteria memory criteria) public payable returns (uint64 sequence) {
		require(paused == false, 'contract is paused');
		require(block.timestamp <= criteria.transferDeadline, 'deadline passed');
		if (criteria.unwrap) {
			require(criteria.gasDrop == 0, 'gas drop not allowed');
		}

		uint wormholeFee = tokenBridge.wormhole().messageFee();

		uint256 normalizedAmount = normalizeAmount(msg.value - 2*wormholeFee, 18);
		
		require(relayerFees.swapFee + relayerFees.refundFee < normalizedAmount, 'fees exceed amount');
		require(relayerFees.redeemFee < criteria.amountOutMin, 'redeem fee exceeds min output');

		uint256 amountIn = deNormalizeAmount(normalizedAmount, 18);

		uint64 seq1 = tokenBridge.wrapAndTransferETH{ value: amountIn + wormholeFee }(recipient.mayanChainId, recipient.mayanAddr, 0, 0);

		uint dust = msg.value - 2*wormholeFee - amountIn;
		if (dust > 0) {
			payable(msg.sender).transfer(dust);
		}

		MayanStructs.Swap memory swapStruct = MayanStructs.Swap({
			payloadId: criteria.customPayload.length > 0 ? 2 : 1,
			tokenAddr: tokenOutAddr,
			tokenChainId: tokenOutChainId,
			destAddr: recipient.destAddr,
			destChainId: recipient.destChainId,
			sourceAddr: recipient.refundAddr,
			sourceChainId: homeChainId,
			sequence: seq1,
			amountOutMin: criteria.amountOutMin,
			deadline: criteria.swapDeadline,
			swapFee: relayerFees.swapFee,
			redeemFee: relayerFees.redeemFee,
			refundFee: relayerFees.refundFee,
			auctionAddr: recipient.auctionAddr,
			unwrapRedeem: criteria.unwrap,
			unwrapRefund: true
		});

		bytes memory encoded = encodeSwap(swapStruct)
			.concat(abi.encodePacked(swapStruct.unwrapRedeem, swapStruct.unwrapRefund, recipient.referrer, criteria.gasDrop));

		if (swapStruct.payloadId == 2) {
			require(swapStruct.destChainId == recipient.mayanChainId, 'invalid chain id with payload');
			encoded = encoded.concat(abi.encodePacked(criteria.customPayload));
		}

		sequence = tokenBridge.wormhole().publishMessage{
			value : wormholeFee
		}(0, encoded, tokenBridge.finality());
	}

	function redeem(bytes memory encodedVm) public payable {
		IWormhole.VM memory vm = tokenBridge.wormhole().parseVM(encodedVm);
		ITokenBridge.TransferWithPayload memory transferPayload = tokenBridge.parseTransferWithPayload(vm.payload);
		MayanStructs.Redeem memory redeemPayload = parseRedeemPayload(transferPayload.payload);

		address recipient = truncateAddress(redeemPayload.recipient);
		if (redeemPayload.payloadId == 2) {
			require(msg.sender == recipient, 'not recipient');
		}

		address tokenAddr;
		if (transferPayload.tokenChain == homeChainId) {
			tokenAddr = truncateAddress(transferPayload.tokenAddress);
		} else {
			tokenAddr = tokenBridge.wrappedAsset(transferPayload.tokenChain, transferPayload.tokenAddress);
		}

		uint256 amount = IERC20(tokenAddr).balanceOf(address(this));
		tokenBridge.completeTransferWithPayload(encodedVm);
		amount = IERC20(tokenAddr).balanceOf(address(this)) - amount;

		uint256 relayerFee = deNormalizeAmount(uint256(redeemPayload.relayerFee), decimalsOf(tokenAddr));
		require(amount > relayerFee, 'relayer fee exeeds amount');

		if (redeemPayload.gasDrop > 0) {
			uint256 gasDrop = deNormalizeAmount(uint256(redeemPayload.gasDrop), decimalsOf(address(weth)));
			require(msg.value == gasDrop, 'incorrect gas drop');
			payable(recipient).transfer(gasDrop);
		}

		if (redeemPayload.unwrap && tokenAddr == address(weth)) {
			weth.withdraw(amount);
			payable(msg.sender).transfer(relayerFee);
			payable(recipient).transfer(amount - relayerFee);
		} else {
			IERC20(tokenAddr).safeTransfer(msg.sender, relayerFee);
			IERC20(tokenAddr).safeTransfer(recipient, amount - relayerFee);
		}

		emit Redeemed(vm.emitterChainId, vm.emitterAddress, vm.sequence);
	}

	function redeemAndUnwrap(bytes memory encodedVm) public {
		IWormhole.VM memory vm = tokenBridge.wormhole().parseVM(encodedVm);

		ITokenBridge.TransferWithPayload memory transferPayload = tokenBridge.parseTransferWithPayload(vm.payload);
		require(transferPayload.tokenChain == homeChainId, 'not home chain');
		
		address tokenAddr = truncateAddress(transferPayload.tokenAddress);
		require(tokenAddr == address(weth), 'not weth');

		MayanStructs.Redeem memory redeemPayload = parseRedeemPayload(transferPayload.payload);
		require(redeemPayload.unwrap, 'not unwrap');

		address recipient = truncateAddress(redeemPayload.recipient);
		if (redeemPayload.payloadId == 2) {
			require(msg.sender == recipient, 'not recipient');
		}

		uint256 amount = address(this).balance;
		tokenBridge.completeTransferAndUnwrapETHWithPayload(encodedVm);
		amount = address(this).balance - amount;

		uint256 relayerFee = deNormalizeAmount(uint256(redeemPayload.relayerFee), 18);
		require(amount > relayerFee, 'relayer fee exeeds amount');

		payable(msg.sender).transfer(relayerFee);
		payable(recipient).transfer(amount - relayerFee);

		emit Redeemed(vm.emitterChainId, vm.emitterAddress, vm.sequence);
	}

	function parseRedeemPayload(bytes memory encoded) public pure returns (MayanStructs.Redeem memory r) {
		uint index = 0;

		r.payloadId = encoded.toUint8(index);
		index += 1;

		require(r.payloadId == 1 || r.payloadId == 2, 'payload id not supported');

		r.recipient = encoded.toBytes32(index);
		index += 32;

		r.relayerFee = encoded.toUint64(index);
		index += 8;

		r.unwrap = encoded[index] != bytes1(0);
		index += 1;

		r.gasDrop = encoded.toUint64(index);
		index += 8;

		if (r.payloadId == 2) {
			r.customPayload = encoded.slice(index, encoded.length - index);
		} else {
			require(index == encoded.length, 'invalid payload length');
		}
	}

	function truncateAddress(bytes32 b) internal pure returns (address) {
		require(bytes12(b) == 0, 'invalid EVM address');
		return address(uint160(uint256(b)));
	}

	function decimalsOf(address token) internal view returns(uint8) {
		(,bytes memory queriedDecimals) = token.staticcall(abi.encodeWithSignature('decimals()'));
		return abi.decode(queriedDecimals, (uint8));
	}

	function normalizeAmount(uint256 amount, uint8 decimals) internal pure returns(uint256) {
		if (decimals > 8) {
			amount /= 10 ** (decimals - 8);
		}
		return amount;
	}

	function deNormalizeAmount(uint256 amount, uint8 decimals) internal pure returns(uint256) {
		if (decimals > 8) {
			amount *= 10 ** (decimals - 8);
		}
		return amount;
	}

	function encodeSwap(MayanStructs.Swap memory s) public pure returns(bytes memory encoded) {
		encoded = abi.encodePacked(
			s.payloadId,
			s.tokenAddr,
			s.tokenChainId,
			s.destAddr,
			s.destChainId,
			s.sourceAddr,
			s.sourceChainId,
			s.sequence,
			s.amountOutMin,
			s.deadline,
			s.swapFee,
			s.redeemFee,
			s.refundFee,
			s.auctionAddr
		);
	}

	function setPause(bool _pause) public {
		require(msg.sender == guardian, 'only guardian');
		paused = _pause;
	}

	function isPaused() public view returns(bool) {
		return paused;
	}

	function changeGuardian(address newGuardian) public {
		require(msg.sender == guardian, 'only guardian');
		nextGuardian = newGuardian;
	}

	function claimGuardian() public {
		require(msg.sender == nextGuardian, 'only next guardian');
		guardian = nextGuardian;
	}

	function sweepToken(address token, uint256 amount, address to) public {
		require(msg.sender == guardian, 'only guardian');
		IERC20(token).safeTransfer(to, amount);
	}

	function sweepEth(uint256 amount, address payable to) public {
		require(msg.sender == guardian, 'only guardian');
		require(to != address(0), 'transfer to the zero address');
		to.transfer(amount);
	}

	function getWeth() public view returns(address) {
		return address(weth);
	}

    receive() external payable {}
}

File 2 of 10 : MayanStructs.sol
// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

contract MayanStructs {
	struct Swap {
		uint8 payloadId;
		bytes32 tokenAddr;
		uint16 tokenChainId;
		bytes32 destAddr;
		uint16 destChainId;
		bytes32 sourceAddr;
		uint16 sourceChainId;
		uint64 sequence;
		uint64 amountOutMin;
		uint64 deadline;
		uint64 swapFee;
		uint64 redeemFee;
		uint64 refundFee;
		bytes32 auctionAddr;
		bool unwrapRedeem;
		bool unwrapRefund;
	}

	struct Redeem {
		uint8 payloadId;
		bytes32 recipient;
		uint64 relayerFee;
		bool unwrap;
		uint64 gasDrop;
		bytes customPayload;
	}
}

File 3 of 10 : ITokenBridge.sol
// SPDX-License-Identifier: Apache 2

pragma solidity ^0.8.0;

import "./IWETH.sol";
import "./IWormhole.sol";

interface ITokenBridge {
    struct Transfer {
        uint8 payloadID;
        uint256 amount;
        bytes32 tokenAddress;
        uint16 tokenChain;
        bytes32 to;
        uint16 toChain;
        uint256 fee;
    }

    struct TransferWithPayload {
        uint8 payloadID;
        uint256 amount;
        bytes32 tokenAddress;
        uint16 tokenChain;
        bytes32 to;
        uint16 toChain;
        bytes32 fromAddress;
        bytes payload;
    }

    struct AssetMeta {
        uint8 payloadID;
        bytes32 tokenAddress;
        uint16 tokenChain;
        uint8 decimals;
        bytes32 symbol;
        bytes32 name;
    }

    struct RegisterChain {
        bytes32 module;
        uint8 action;
        uint16 chainId;

        uint16 emitterChainID;
        bytes32 emitterAddress;
    }

     struct UpgradeContract {
        bytes32 module;
        uint8 action;
        uint16 chainId;

        bytes32 newContract;
    }

    struct RecoverChainId {
        bytes32 module;
        uint8 action;

        uint256 evmChainId;
        uint16 newChainId;
    }

    event ContractUpgraded(address indexed oldContract, address indexed newContract);

    function _parseTransferCommon(bytes memory encoded) external pure returns (Transfer memory transfer);

    function attestToken(address tokenAddress, uint32 nonce) external payable returns (uint64 sequence);

    function wrapAndTransferETH(uint16 recipientChain, bytes32 recipient, uint256 arbiterFee, uint32 nonce) external payable returns (uint64 sequence);

    function wrapAndTransferETHWithPayload(uint16 recipientChain, bytes32 recipient, uint32 nonce, bytes memory payload) external payable returns (uint64 sequence);

    function transferTokens(address token, uint256 amount, uint16 recipientChain, bytes32 recipient, uint256 arbiterFee, uint32 nonce) external payable returns (uint64 sequence);

    function transferTokensWithPayload(address token, uint256 amount, uint16 recipientChain, bytes32 recipient, uint32 nonce, bytes memory payload) external payable returns (uint64 sequence);

    function updateWrapped(bytes memory encodedVm) external returns (address token);

    function createWrapped(bytes memory encodedVm) external returns (address token);

    function completeTransferWithPayload(bytes memory encodedVm) external returns (bytes memory);

    function completeTransferAndUnwrapETHWithPayload(bytes memory encodedVm) external returns (bytes memory);

    function completeTransfer(bytes memory encodedVm) external;

    function completeTransferAndUnwrapETH(bytes memory encodedVm) external;

    function encodeAssetMeta(AssetMeta memory meta) external pure returns (bytes memory encoded);

    function encodeTransfer(Transfer memory transfer) external pure returns (bytes memory encoded);

    function encodeTransferWithPayload(TransferWithPayload memory transfer) external pure returns (bytes memory encoded);

    function parsePayloadID(bytes memory encoded) external pure returns (uint8 payloadID);

    function parseAssetMeta(bytes memory encoded) external pure returns (AssetMeta memory meta);

    function parseTransfer(bytes memory encoded) external pure returns (Transfer memory transfer);

    function parseTransferWithPayload(bytes memory encoded) external pure returns (TransferWithPayload memory transfer);

    function governanceActionIsConsumed(bytes32 hash) external view returns (bool);

    function isInitialized(address impl) external view returns (bool);

    function isTransferCompleted(bytes32 hash) external view returns (bool);

    function wormhole() external view returns (IWormhole);

    function chainId() external view returns (uint16);

    function evmChainId() external view returns (uint256);

    function isFork() external view returns (bool);

    function governanceChainId() external view returns (uint16);

    function governanceContract() external view returns (bytes32);

    function wrappedAsset(uint16 tokenChainId, bytes32 tokenAddress) external view returns (address);

    function bridgeContracts(uint16 chainId_) external view returns (bytes32);

    function tokenImplementation() external view returns (address);

    function WETH() external view returns (IWETH);

    function outstandingBridged(address token) external view returns (uint256);

    function isWrappedAsset(address token) external view returns (bool);

    function finality() external view returns (uint8);

    function implementation() external view returns (address);

    function initialize() external;

    function registerChain(bytes memory encodedVM) external;

    function upgrade(bytes memory encodedVM) external;

    function submitRecoverChainId(bytes memory encodedVM) external;

    function parseRegisterChain(bytes memory encoded) external pure returns (RegisterChain memory chain);

    function parseUpgrade(bytes memory encoded) external pure returns (UpgradeContract memory chain);

    function parseRecoverChainId(bytes memory encodedRecoverChainId) external pure returns (RecoverChainId memory rci);
}

File 4 of 10 : IWormhole.sol
// SPDX-License-Identifier: Apache 2

pragma solidity ^0.8.0;

interface IWormhole {
    struct GuardianSet {
        address[] keys;
        uint32 expirationTime;
    }

    struct Signature {
        bytes32 r;
        bytes32 s;
        uint8 v;
        uint8 guardianIndex;
    }

    struct VM {
        uint8 version;
        uint32 timestamp;
        uint32 nonce;
        uint16 emitterChainId;
        bytes32 emitterAddress;
        uint64 sequence;
        uint8 consistencyLevel;
        bytes payload;

        uint32 guardianSetIndex;
        Signature[] signatures;

        bytes32 hash;
    }

    struct ContractUpgrade {
        bytes32 module;
        uint8 action;
        uint16 chain;

        address newContract;
    }

    struct GuardianSetUpgrade {
        bytes32 module;
        uint8 action;
        uint16 chain;

        GuardianSet newGuardianSet;
        uint32 newGuardianSetIndex;
    }

    struct SetMessageFee {
        bytes32 module;
        uint8 action;
        uint16 chain;

        uint256 messageFee;
    }

    struct TransferFees {
        bytes32 module;
        uint8 action;
        uint16 chain;

        uint256 amount;
        bytes32 recipient;
    }

    struct RecoverChainId {
        bytes32 module;
        uint8 action;

        uint256 evmChainId;
        uint16 newChainId;
    }

    event LogMessagePublished(address indexed sender, uint64 sequence, uint32 nonce, bytes payload, uint8 consistencyLevel);
    event ContractUpgraded(address indexed oldContract, address indexed newContract);
    event GuardianSetAdded(uint32 indexed index);

    function publishMessage(
        uint32 nonce,
        bytes memory payload,
        uint8 consistencyLevel
    ) external payable returns (uint64 sequence);

    function initialize() external;

    function parseAndVerifyVM(bytes calldata encodedVM) external view returns (VM memory vm, bool valid, string memory reason);

    function verifyVM(VM memory vm) external view returns (bool valid, string memory reason);

    function verifySignatures(bytes32 hash, Signature[] memory signatures, GuardianSet memory guardianSet) external pure returns (bool valid, string memory reason);

    function parseVM(bytes memory encodedVM) external pure returns (VM memory vm);

    function quorum(uint numGuardians) external pure returns (uint numSignaturesRequiredForQuorum);

    function getGuardianSet(uint32 index) external view returns (GuardianSet memory);

    function getCurrentGuardianSetIndex() external view returns (uint32);

    function getGuardianSetExpiry() external view returns (uint32);

    function governanceActionIsConsumed(bytes32 hash) external view returns (bool);

    function isInitialized(address impl) external view returns (bool);

    function chainId() external view returns (uint16);

    function isFork() external view returns (bool);

    function governanceChainId() external view returns (uint16);

    function governanceContract() external view returns (bytes32);

    function messageFee() external view returns (uint256);

    function evmChainId() external view returns (uint256);

    function nextSequence(address emitter) external view returns (uint64);

    function parseContractUpgrade(bytes memory encodedUpgrade) external pure returns (ContractUpgrade memory cu);

    function parseGuardianSetUpgrade(bytes memory encodedUpgrade) external pure returns (GuardianSetUpgrade memory gsu);

    function parseSetMessageFee(bytes memory encodedSetMessageFee) external pure returns (SetMessageFee memory smf);

    function parseTransferFees(bytes memory encodedTransferFees) external pure returns (TransferFees memory tf);

    function parseRecoverChainId(bytes memory encodedRecoverChainId) external pure returns (RecoverChainId memory rci);

    function submitContractUpgrade(bytes memory _vm) external;

    function submitSetMessageFee(bytes memory _vm) external;

    function submitNewGuardianSet(bytes memory _vm) external;

    function submitTransferFees(bytes memory _vm) external;

    function submitRecoverChainId(bytes memory _vm) external;
}

File 5 of 10 : BytesLib.sol
// SPDX-License-Identifier: Unlicense
/*
 * @title Solidity Bytes Arrays Utils
 * @author Gonçalo Sá <[email protected]>
 *
 * @dev Bytes tightly packed arrays utility library for ethereum contracts written in Solidity.
 *      The library lets you concatenate, slice and type cast bytes arrays both in memory and storage.
 */
pragma solidity >=0.8.0 <0.9.0;


library BytesLib {
    function concat(
        bytes memory _preBytes,
        bytes memory _postBytes
    )
        internal
        pure
        returns (bytes memory)
    {
        bytes memory tempBytes;

        assembly {
            // Get a location of some free memory and store it in tempBytes as
            // Solidity does for memory variables.
            tempBytes := mload(0x40)

            // Store the length of the first bytes array at the beginning of
            // the memory for tempBytes.
            let length := mload(_preBytes)
            mstore(tempBytes, length)

            // Maintain a memory counter for the current write location in the
            // temp bytes array by adding the 32 bytes for the array length to
            // the starting location.
            let mc := add(tempBytes, 0x20)
            // Stop copying when the memory counter reaches the length of the
            // first bytes array.
            let end := add(mc, length)

            for {
                // Initialize a copy counter to the start of the _preBytes data,
                // 32 bytes into its memory.
                let cc := add(_preBytes, 0x20)
            } lt(mc, end) {
                // Increase both counters by 32 bytes each iteration.
                mc := add(mc, 0x20)
                cc := add(cc, 0x20)
            } {
                // Write the _preBytes data into the tempBytes memory 32 bytes
                // at a time.
                mstore(mc, mload(cc))
            }

            // Add the length of _postBytes to the current length of tempBytes
            // and store it as the new length in the first 32 bytes of the
            // tempBytes memory.
            length := mload(_postBytes)
            mstore(tempBytes, add(length, mload(tempBytes)))

            // Move the memory counter back from a multiple of 0x20 to the
            // actual end of the _preBytes data.
            mc := end
            // Stop copying when the memory counter reaches the new combined
            // length of the arrays.
            end := add(mc, length)

            for {
                let cc := add(_postBytes, 0x20)
            } lt(mc, end) {
                mc := add(mc, 0x20)
                cc := add(cc, 0x20)
            } {
                mstore(mc, mload(cc))
            }

            // Update the free-memory pointer by padding our last write location
            // to 32 bytes: add 31 bytes to the end of tempBytes to move to the
            // next 32 byte block, then round down to the nearest multiple of
            // 32. If the sum of the length of the two arrays is zero then add
            // one before rounding down to leave a blank 32 bytes (the length block with 0).
            mstore(0x40, and(
              add(add(end, iszero(add(length, mload(_preBytes)))), 31),
              not(31) // Round down to the nearest 32 bytes.
            ))
        }

        return tempBytes;
    }

    function concatStorage(bytes storage _preBytes, bytes memory _postBytes) internal {
        assembly {
            // Read the first 32 bytes of _preBytes storage, which is the length
            // of the array. (We don't need to use the offset into the slot
            // because arrays use the entire slot.)
            let fslot := sload(_preBytes.slot)
            // Arrays of 31 bytes or less have an even value in their slot,
            // while longer arrays have an odd value. The actual length is
            // the slot divided by two for odd values, and the lowest order
            // byte divided by two for even values.
            // If the slot is even, bitwise and the slot with 255 and divide by
            // two to get the length. If the slot is odd, bitwise and the slot
            // with -1 and divide by two.
            let slength := div(and(fslot, sub(mul(0x100, iszero(and(fslot, 1))), 1)), 2)
            let mlength := mload(_postBytes)
            let newlength := add(slength, mlength)
            // slength can contain both the length and contents of the array
            // if length < 32 bytes so let's prepare for that
            // v. http://solidity.readthedocs.io/en/latest/miscellaneous.html#layout-of-state-variables-in-storage
            switch add(lt(slength, 32), lt(newlength, 32))
            case 2 {
                // Since the new array still fits in the slot, we just need to
                // update the contents of the slot.
                // uint256(bytes_storage) = uint256(bytes_storage) + uint256(bytes_memory) + new_length
                sstore(
                    _preBytes.slot,
                    // all the modifications to the slot are inside this
                    // next block
                    add(
                        // we can just add to the slot contents because the
                        // bytes we want to change are the LSBs
                        fslot,
                        add(
                            mul(
                                div(
                                    // load the bytes from memory
                                    mload(add(_postBytes, 0x20)),
                                    // zero all bytes to the right
                                    exp(0x100, sub(32, mlength))
                                ),
                                // and now shift left the number of bytes to
                                // leave space for the length in the slot
                                exp(0x100, sub(32, newlength))
                            ),
                            // increase length by the double of the memory
                            // bytes length
                            mul(mlength, 2)
                        )
                    )
                )
            }
            case 1 {
                // The stored value fits in the slot, but the combined value
                // will exceed it.
                // get the keccak hash to get the contents of the array
                mstore(0x0, _preBytes.slot)
                let sc := add(keccak256(0x0, 0x20), div(slength, 32))

                // save new length
                sstore(_preBytes.slot, add(mul(newlength, 2), 1))

                // The contents of the _postBytes array start 32 bytes into
                // the structure. Our first read should obtain the `submod`
                // bytes that can fit into the unused space in the last word
                // of the stored array. To get this, we read 32 bytes starting
                // from `submod`, so the data we read overlaps with the array
                // contents by `submod` bytes. Masking the lowest-order
                // `submod` bytes allows us to add that value directly to the
                // stored value.

                let submod := sub(32, slength)
                let mc := add(_postBytes, submod)
                let end := add(_postBytes, mlength)
                let mask := sub(exp(0x100, submod), 1)

                sstore(
                    sc,
                    add(
                        and(
                            fslot,
                            0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00
                        ),
                        and(mload(mc), mask)
                    )
                )

                for {
                    mc := add(mc, 0x20)
                    sc := add(sc, 1)
                } lt(mc, end) {
                    sc := add(sc, 1)
                    mc := add(mc, 0x20)
                } {
                    sstore(sc, mload(mc))
                }

                mask := exp(0x100, sub(mc, end))

                sstore(sc, mul(div(mload(mc), mask), mask))
            }
            default {
                // get the keccak hash to get the contents of the array
                mstore(0x0, _preBytes.slot)
                // Start copying to the last used word of the stored array.
                let sc := add(keccak256(0x0, 0x20), div(slength, 32))

                // save new length
                sstore(_preBytes.slot, add(mul(newlength, 2), 1))

                // Copy over the first `submod` bytes of the new data as in
                // case 1 above.
                let slengthmod := mod(slength, 32)
                let mlengthmod := mod(mlength, 32)
                let submod := sub(32, slengthmod)
                let mc := add(_postBytes, submod)
                let end := add(_postBytes, mlength)
                let mask := sub(exp(0x100, submod), 1)

                sstore(sc, add(sload(sc), and(mload(mc), mask)))

                for {
                    sc := add(sc, 1)
                    mc := add(mc, 0x20)
                } lt(mc, end) {
                    sc := add(sc, 1)
                    mc := add(mc, 0x20)
                } {
                    sstore(sc, mload(mc))
                }

                mask := exp(0x100, sub(mc, end))

                sstore(sc, mul(div(mload(mc), mask), mask))
            }
        }
    }

    function slice(
        bytes memory _bytes,
        uint256 _start,
        uint256 _length
    )
        internal
        pure
        returns (bytes memory)
    {
        require(_length + 31 >= _length, "slice_overflow");
        require(_bytes.length >= _start + _length, "slice_outOfBounds");

        bytes memory tempBytes;

        assembly {
            switch iszero(_length)
            case 0 {
                // Get a location of some free memory and store it in tempBytes as
                // Solidity does for memory variables.
                tempBytes := mload(0x40)

                // The first word of the slice result is potentially a partial
                // word read from the original array. To read it, we calculate
                // the length of that partial word and start copying that many
                // bytes into the array. The first word we copy will start with
                // data we don't care about, but the last `lengthmod` bytes will
                // land at the beginning of the contents of the new array. When
                // we're done copying, we overwrite the full first word with
                // the actual length of the slice.
                let lengthmod := and(_length, 31)

                // The multiplication in the next line is necessary
                // because when slicing multiples of 32 bytes (lengthmod == 0)
                // the following copy loop was copying the origin's length
                // and then ending prematurely not copying everything it should.
                let mc := add(add(tempBytes, lengthmod), mul(0x20, iszero(lengthmod)))
                let end := add(mc, _length)

                for {
                    // The multiplication in the next line has the same exact purpose
                    // as the one above.
                    let cc := add(add(add(_bytes, lengthmod), mul(0x20, iszero(lengthmod))), _start)
                } lt(mc, end) {
                    mc := add(mc, 0x20)
                    cc := add(cc, 0x20)
                } {
                    mstore(mc, mload(cc))
                }

                mstore(tempBytes, _length)

                //update free-memory pointer
                //allocating the array padded to 32 bytes like the compiler does now
                mstore(0x40, and(add(mc, 31), not(31)))
            }
            //if we want a zero-length slice let's just return a zero-length array
            default {
                tempBytes := mload(0x40)
                //zero out the 32 bytes slice we are about to return
                //we need to do it because Solidity does not garbage collect
                mstore(tempBytes, 0)

                mstore(0x40, add(tempBytes, 0x20))
            }
        }

        return tempBytes;
    }

    function toAddress(bytes memory _bytes, uint256 _start) internal pure returns (address) {
        require(_bytes.length >= _start + 20, "toAddress_outOfBounds");
        address tempAddress;

        assembly {
            tempAddress := div(mload(add(add(_bytes, 0x20), _start)), 0x1000000000000000000000000)
        }

        return tempAddress;
    }

    function toUint8(bytes memory _bytes, uint256 _start) internal pure returns (uint8) {
        require(_bytes.length >= _start + 1 , "toUint8_outOfBounds");
        uint8 tempUint;

        assembly {
            tempUint := mload(add(add(_bytes, 0x1), _start))
        }

        return tempUint;
    }

    function toUint16(bytes memory _bytes, uint256 _start) internal pure returns (uint16) {
        require(_bytes.length >= _start + 2, "toUint16_outOfBounds");
        uint16 tempUint;

        assembly {
            tempUint := mload(add(add(_bytes, 0x2), _start))
        }

        return tempUint;
    }

    function toUint32(bytes memory _bytes, uint256 _start) internal pure returns (uint32) {
        require(_bytes.length >= _start + 4, "toUint32_outOfBounds");
        uint32 tempUint;

        assembly {
            tempUint := mload(add(add(_bytes, 0x4), _start))
        }

        return tempUint;
    }

    function toUint64(bytes memory _bytes, uint256 _start) internal pure returns (uint64) {
        require(_bytes.length >= _start + 8, "toUint64_outOfBounds");
        uint64 tempUint;

        assembly {
            tempUint := mload(add(add(_bytes, 0x8), _start))
        }

        return tempUint;
    }

    function toUint96(bytes memory _bytes, uint256 _start) internal pure returns (uint96) {
        require(_bytes.length >= _start + 12, "toUint96_outOfBounds");
        uint96 tempUint;

        assembly {
            tempUint := mload(add(add(_bytes, 0xc), _start))
        }

        return tempUint;
    }

    function toUint128(bytes memory _bytes, uint256 _start) internal pure returns (uint128) {
        require(_bytes.length >= _start + 16, "toUint128_outOfBounds");
        uint128 tempUint;

        assembly {
            tempUint := mload(add(add(_bytes, 0x10), _start))
        }

        return tempUint;
    }

    function toUint256(bytes memory _bytes, uint256 _start) internal pure returns (uint256) {
        require(_bytes.length >= _start + 32, "toUint256_outOfBounds");
        uint256 tempUint;

        assembly {
            tempUint := mload(add(add(_bytes, 0x20), _start))
        }

        return tempUint;
    }

    function toBytes32(bytes memory _bytes, uint256 _start) internal pure returns (bytes32) {
        require(_bytes.length >= _start + 32, "toBytes32_outOfBounds");
        bytes32 tempBytes32;

        assembly {
            tempBytes32 := mload(add(add(_bytes, 0x20), _start))
        }

        return tempBytes32;
    }

    function equal(bytes memory _preBytes, bytes memory _postBytes) internal pure returns (bool) {
        bool success = true;

        assembly {
            let length := mload(_preBytes)

            // if lengths don't match the arrays are not equal
            switch eq(length, mload(_postBytes))
            case 1 {
                // cb is a circuit breaker in the for loop since there's
                //  no said feature for inline assembly loops
                // cb = 1 - don't breaker
                // cb = 0 - break
                let cb := 1

                let mc := add(_preBytes, 0x20)
                let end := add(mc, length)

                for {
                    let cc := add(_postBytes, 0x20)
                // the next line is the loop condition:
                // while(uint256(mc < end) + cb == 2)
                } eq(add(lt(mc, end), cb), 2) {
                    mc := add(mc, 0x20)
                    cc := add(cc, 0x20)
                } {
                    // if any of these checks fails then arrays are not equal
                    if iszero(eq(mload(mc), mload(cc))) {
                        // unsuccess:
                        success := 0
                        cb := 0
                    }
                }
            }
            default {
                // unsuccess:
                success := 0
            }
        }

        return success;
    }

    function equalStorage(
        bytes storage _preBytes,
        bytes memory _postBytes
    )
        internal
        view
        returns (bool)
    {
        bool success = true;

        assembly {
            // we know _preBytes_offset is 0
            let fslot := sload(_preBytes.slot)
            // Decode the length of the stored array like in concatStorage().
            let slength := div(and(fslot, sub(mul(0x100, iszero(and(fslot, 1))), 1)), 2)
            let mlength := mload(_postBytes)

            // if lengths don't match the arrays are not equal
            switch eq(slength, mlength)
            case 1 {
                // slength can contain both the length and contents of the array
                // if length < 32 bytes so let's prepare for that
                // v. http://solidity.readthedocs.io/en/latest/miscellaneous.html#layout-of-state-variables-in-storage
                if iszero(iszero(slength)) {
                    switch lt(slength, 32)
                    case 1 {
                        // blank the last byte which is the length
                        fslot := mul(div(fslot, 0x100), 0x100)

                        if iszero(eq(fslot, mload(add(_postBytes, 0x20)))) {
                            // unsuccess:
                            success := 0
                        }
                    }
                    default {
                        // cb is a circuit breaker in the for loop since there's
                        //  no said feature for inline assembly loops
                        // cb = 1 - don't breaker
                        // cb = 0 - break
                        let cb := 1

                        // get the keccak hash to get the contents of the array
                        mstore(0x0, _preBytes.slot)
                        let sc := keccak256(0x0, 0x20)

                        let mc := add(_postBytes, 0x20)
                        let end := add(mc, mlength)

                        // the next line is the loop condition:
                        // while(uint256(mc < end) + cb == 2)
                        for {} eq(add(lt(mc, end), cb), 2) {
                            sc := add(sc, 1)
                            mc := add(mc, 0x20)
                        } {
                            if iszero(eq(sload(sc), mload(mc))) {
                                // unsuccess:
                                success := 0
                                cb := 0
                            }
                        }
                    }
                }
            }
            default {
                // unsuccess:
                success := 0
            }
        }

        return success;
    }
}

File 6 of 10 : IERC20.sol
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.6.0) (token/ERC20/IERC20.sol)

pragma solidity ^0.8.0;

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

    /**
     * @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 `to`.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transfer(address to, 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 `from` to `to` 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 from,
        address to,
        uint256 amount
    ) external returns (bool);
}

File 7 of 10 : SafeERC20.sol
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.7.0) (token/ERC20/utils/SafeERC20.sol)

pragma solidity ^0.8.0;

import "../IERC20.sol";
import "../extensions/draft-IERC20Permit.sol";
import "../../../utils/Address.sol";

/**
 * @title SafeERC20
 * @dev Wrappers around ERC20 operations that throw on failure (when the token
 * contract returns false). Tokens that return no value (and instead revert or
 * throw on failure) are also supported, non-reverting calls are assumed to be
 * successful.
 * To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract,
 * which allows you to call the safe operations as `token.safeTransfer(...)`, etc.
 */
library SafeERC20 {
    using Address for address;

    function safeTransfer(
        IERC20 token,
        address to,
        uint256 value
    ) internal {
        _callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
    }

    function safeTransferFrom(
        IERC20 token,
        address from,
        address to,
        uint256 value
    ) internal {
        _callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
    }

    /**
     * @dev Deprecated. This function has issues similar to the ones found in
     * {IERC20-approve}, and its usage is discouraged.
     *
     * Whenever possible, use {safeIncreaseAllowance} and
     * {safeDecreaseAllowance} instead.
     */
    function safeApprove(
        IERC20 token,
        address spender,
        uint256 value
    ) internal {
        // safeApprove should only be called when setting an initial allowance,
        // or when resetting it to zero. To increase and decrease it, use
        // 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
        require(
            (value == 0) || (token.allowance(address(this), spender) == 0),
            "SafeERC20: approve from non-zero to non-zero allowance"
        );
        _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
    }

    function safeIncreaseAllowance(
        IERC20 token,
        address spender,
        uint256 value
    ) internal {
        uint256 newAllowance = token.allowance(address(this), spender) + value;
        _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
    }

    function safeDecreaseAllowance(
        IERC20 token,
        address spender,
        uint256 value
    ) internal {
        unchecked {
            uint256 oldAllowance = token.allowance(address(this), spender);
            require(oldAllowance >= value, "SafeERC20: decreased allowance below zero");
            uint256 newAllowance = oldAllowance - value;
            _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
        }
    }

    function safePermit(
        IERC20Permit token,
        address owner,
        address spender,
        uint256 value,
        uint256 deadline,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) internal {
        uint256 nonceBefore = token.nonces(owner);
        token.permit(owner, spender, value, deadline, v, r, s);
        uint256 nonceAfter = token.nonces(owner);
        require(nonceAfter == nonceBefore + 1, "SafeERC20: permit did not succeed");
    }

    /**
     * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement
     * on the return value: the return value is optional (but if data is returned, it must not be false).
     * @param token The token targeted by the call.
     * @param data The call data (encoded using abi.encode or one of its variants).
     */
    function _callOptionalReturn(IERC20 token, bytes memory data) private {
        // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since
        // we're implementing it ourselves. We use {Address.functionCall} to perform this call, which verifies that
        // the target address contains contract code and also asserts for success in the low-level call.

        bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
        if (returndata.length > 0) {
            // Return data is optional
            require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
        }
    }
}

File 8 of 10 : IWETH.sol
// SPDX-License-Identifier: Apache 2

pragma solidity ^0.8.0;

import "@openzeppelin/contracts/token/ERC20/IERC20.sol";

interface IWETH is IERC20 {
    function deposit() external payable;
    function withdraw(uint amount) external;
}

File 9 of 10 : draft-IERC20Permit.sol
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (token/ERC20/extensions/draft-IERC20Permit.sol)

pragma solidity ^0.8.0;

/**
 * @dev Interface of the ERC20 Permit extension allowing approvals to be made via signatures, as defined in
 * https://eips.ethereum.org/EIPS/eip-2612[EIP-2612].
 *
 * Adds the {permit} method, which can be used to change an account's ERC20 allowance (see {IERC20-allowance}) by
 * presenting a message signed by the account. By not relying on {IERC20-approve}, the token holder account doesn't
 * need to send a transaction, and thus is not required to hold Ether at all.
 */
interface IERC20Permit {
    /**
     * @dev Sets `value` as the allowance of `spender` over ``owner``'s tokens,
     * given ``owner``'s signed approval.
     *
     * IMPORTANT: The same issues {IERC20-approve} has related to transaction
     * ordering also apply here.
     *
     * Emits an {Approval} event.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     * - `deadline` must be a timestamp in the future.
     * - `v`, `r` and `s` must be a valid `secp256k1` signature from `owner`
     * over the EIP712-formatted function arguments.
     * - the signature must use ``owner``'s current nonce (see {nonces}).
     *
     * For more information on the signature format, see the
     * https://eips.ethereum.org/EIPS/eip-2612#specification[relevant EIP
     * section].
     */
    function permit(
        address owner,
        address spender,
        uint256 value,
        uint256 deadline,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) external;

    /**
     * @dev Returns the current nonce for `owner`. This value must be
     * included whenever a signature is generated for {permit}.
     *
     * Every successful call to {permit} increases ``owner``'s nonce by one. This
     * prevents a signature from being used multiple times.
     */
    function nonces(address owner) external view returns (uint256);

    /**
     * @dev Returns the domain separator used in the encoding of the signature for {permit}, as defined by {EIP712}.
     */
    // solhint-disable-next-line func-name-mixedcase
    function DOMAIN_SEPARATOR() external view returns (bytes32);
}

File 10 of 10 : Address.sol
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.7.0) (utils/Address.sol)

pragma solidity ^0.8.1;

/**
 * @dev Collection of functions related to the address type
 */
library Address {
    /**
     * @dev Returns true if `account` is a contract.
     *
     * [IMPORTANT]
     * ====
     * It is unsafe to assume that an address for which this function returns
     * false is an externally-owned account (EOA) and not a contract.
     *
     * Among others, `isContract` will return false for the following
     * types of addresses:
     *
     *  - an externally-owned account
     *  - a contract in construction
     *  - an address where a contract will be created
     *  - an address where a contract lived, but was destroyed
     * ====
     *
     * [IMPORTANT]
     * ====
     * You shouldn't rely on `isContract` to protect against flash loan attacks!
     *
     * Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets
     * like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract
     * constructor.
     * ====
     */
    function isContract(address account) internal view returns (bool) {
        // This method relies on extcodesize/address.code.length, which returns 0
        // for contracts in construction, since the code is only stored at the end
        // of the constructor execution.

        return account.code.length > 0;
    }

    /**
     * @dev Replacement for Solidity's `transfer`: sends `amount` wei to
     * `recipient`, forwarding all available gas and reverting on errors.
     *
     * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost
     * of certain opcodes, possibly making contracts go over the 2300 gas limit
     * imposed by `transfer`, making them unable to receive funds via
     * `transfer`. {sendValue} removes this limitation.
     *
     * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].
     *
     * IMPORTANT: because control is transferred to `recipient`, care must be
     * taken to not create reentrancy vulnerabilities. Consider using
     * {ReentrancyGuard} or the
     * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
     */
    function sendValue(address payable recipient, uint256 amount) internal {
        require(address(this).balance >= amount, "Address: insufficient balance");

        (bool success, ) = recipient.call{value: amount}("");
        require(success, "Address: unable to send value, recipient may have reverted");
    }

    /**
     * @dev Performs a Solidity function call using a low level `call`. A
     * plain `call` is an unsafe replacement for a function call: use this
     * function instead.
     *
     * If `target` reverts with a revert reason, it is bubbled up by this
     * function (like regular Solidity function calls).
     *
     * Returns the raw returned data. To convert to the expected return value,
     * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].
     *
     * Requirements:
     *
     * - `target` must be a contract.
     * - calling `target` with `data` must not revert.
     *
     * _Available since v3.1._
     */
    function functionCall(address target, bytes memory data) internal returns (bytes memory) {
        return functionCall(target, data, "Address: low-level call failed");
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with
     * `errorMessage` as a fallback revert reason when `target` reverts.
     *
     * _Available since v3.1._
     */
    function functionCall(
        address target,
        bytes memory data,
        string memory errorMessage
    ) internal returns (bytes memory) {
        return functionCallWithValue(target, data, 0, errorMessage);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but also transferring `value` wei to `target`.
     *
     * Requirements:
     *
     * - the calling contract must have an ETH balance of at least `value`.
     * - the called Solidity function must be `payable`.
     *
     * _Available since v3.1._
     */
    function functionCallWithValue(
        address target,
        bytes memory data,
        uint256 value
    ) internal returns (bytes memory) {
        return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
    }

    /**
     * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but
     * with `errorMessage` as a fallback revert reason when `target` reverts.
     *
     * _Available since v3.1._
     */
    function functionCallWithValue(
        address target,
        bytes memory data,
        uint256 value,
        string memory errorMessage
    ) internal returns (bytes memory) {
        require(address(this).balance >= value, "Address: insufficient balance for call");
        require(isContract(target), "Address: call to non-contract");

        (bool success, bytes memory returndata) = target.call{value: value}(data);
        return verifyCallResult(success, returndata, errorMessage);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but performing a static call.
     *
     * _Available since v3.3._
     */
    function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
        return functionStaticCall(target, data, "Address: low-level static call failed");
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
     * but performing a static call.
     *
     * _Available since v3.3._
     */
    function functionStaticCall(
        address target,
        bytes memory data,
        string memory errorMessage
    ) internal view returns (bytes memory) {
        require(isContract(target), "Address: static call to non-contract");

        (bool success, bytes memory returndata) = target.staticcall(data);
        return verifyCallResult(success, returndata, errorMessage);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but performing a delegate call.
     *
     * _Available since v3.4._
     */
    function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
        return functionDelegateCall(target, data, "Address: low-level delegate call failed");
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
     * but performing a delegate call.
     *
     * _Available since v3.4._
     */
    function functionDelegateCall(
        address target,
        bytes memory data,
        string memory errorMessage
    ) internal returns (bytes memory) {
        require(isContract(target), "Address: delegate call to non-contract");

        (bool success, bytes memory returndata) = target.delegatecall(data);
        return verifyCallResult(success, returndata, errorMessage);
    }

    /**
     * @dev Tool to verifies that a low level call was successful, and revert if it wasn't, either by bubbling the
     * revert reason using the provided one.
     *
     * _Available since v4.3._
     */
    function verifyCallResult(
        bool success,
        bytes memory returndata,
        string memory errorMessage
    ) internal pure returns (bytes memory) {
        if (success) {
            return returndata;
        } else {
            // Look for revert reason and bubble it up if present
            if (returndata.length > 0) {
                // The easiest way to bubble the revert reason is using memory via assembly
                /// @solidity memory-safe-assembly
                assembly {
                    let returndata_size := mload(returndata)
                    revert(add(32, returndata), returndata_size)
                }
            } else {
                revert(errorMessage);
            }
        }
    }
}

Settings
{
  "optimizer": {
    "enabled": true,
    "runs": 200
  },
  "outputSelection": {
    "*": {
      "*": [
        "evm.bytecode",
        "evm.deployedBytecode",
        "devdoc",
        "userdoc",
        "metadata",
        "abi"
      ]
    }
  },
  "libraries": {}
}

Contract Security Audit

Contract ABI

[{"inputs":[{"internalType":"address","name":"_tokenBridge","type":"address"},{"internalType":"address","name":"_weth","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint16","name":"emitterChainId","type":"uint16"},{"indexed":true,"internalType":"bytes32","name":"emitterAddress","type":"bytes32"},{"indexed":true,"internalType":"uint64","name":"sequence","type":"uint64"}],"name":"Redeemed","type":"event"},{"inputs":[{"internalType":"address","name":"newGuardian","type":"address"}],"name":"changeGuardian","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"claimGuardian","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"components":[{"internalType":"uint8","name":"payloadId","type":"uint8"},{"internalType":"bytes32","name":"tokenAddr","type":"bytes32"},{"internalType":"uint16","name":"tokenChainId","type":"uint16"},{"internalType":"bytes32","name":"destAddr","type":"bytes32"},{"internalType":"uint16","name":"destChainId","type":"uint16"},{"internalType":"bytes32","name":"sourceAddr","type":"bytes32"},{"internalType":"uint16","name":"sourceChainId","type":"uint16"},{"internalType":"uint64","name":"sequence","type":"uint64"},{"internalType":"uint64","name":"amountOutMin","type":"uint64"},{"internalType":"uint64","name":"deadline","type":"uint64"},{"internalType":"uint64","name":"swapFee","type":"uint64"},{"internalType":"uint64","name":"redeemFee","type":"uint64"},{"internalType":"uint64","name":"refundFee","type":"uint64"},{"internalType":"bytes32","name":"auctionAddr","type":"bytes32"},{"internalType":"bool","name":"unwrapRedeem","type":"bool"},{"internalType":"bool","name":"unwrapRefund","type":"bool"}],"internalType":"struct MayanStructs.Swap","name":"s","type":"tuple"}],"name":"encodeSwap","outputs":[{"internalType":"bytes","name":"encoded","type":"bytes"}],"stateMutability":"pure","type":"function"},{"inputs":[],"name":"getWeth","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"isPaused","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes","name":"encoded","type":"bytes"}],"name":"parseRedeemPayload","outputs":[{"components":[{"internalType":"uint8","name":"payloadId","type":"uint8"},{"internalType":"bytes32","name":"recipient","type":"bytes32"},{"internalType":"uint64","name":"relayerFee","type":"uint64"},{"internalType":"bool","name":"unwrap","type":"bool"},{"internalType":"uint64","name":"gasDrop","type":"uint64"},{"internalType":"bytes","name":"customPayload","type":"bytes"}],"internalType":"struct MayanStructs.Redeem","name":"r","type":"tuple"}],"stateMutability":"pure","type":"function"},{"inputs":[{"internalType":"bytes","name":"encodedVm","type":"bytes"}],"name":"redeem","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"bytes","name":"encodedVm","type":"bytes"}],"name":"redeemAndUnwrap","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bool","name":"_pause","type":"bool"}],"name":"setPause","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"components":[{"internalType":"uint64","name":"swapFee","type":"uint64"},{"internalType":"uint64","name":"redeemFee","type":"uint64"},{"internalType":"uint64","name":"refundFee","type":"uint64"}],"internalType":"struct MayanSwap.RelayerFees","name":"relayerFees","type":"tuple"},{"components":[{"internalType":"bytes32","name":"mayanAddr","type":"bytes32"},{"internalType":"uint16","name":"mayanChainId","type":"uint16"},{"internalType":"bytes32","name":"auctionAddr","type":"bytes32"},{"internalType":"bytes32","name":"destAddr","type":"bytes32"},{"internalType":"uint16","name":"destChainId","type":"uint16"},{"internalType":"bytes32","name":"referrer","type":"bytes32"},{"internalType":"bytes32","name":"refundAddr","type":"bytes32"}],"internalType":"struct MayanSwap.Recepient","name":"recipient","type":"tuple"},{"internalType":"bytes32","name":"tokenOutAddr","type":"bytes32"},{"internalType":"uint16","name":"tokenOutChainId","type":"uint16"},{"components":[{"internalType":"uint256","name":"transferDeadline","type":"uint256"},{"internalType":"uint64","name":"swapDeadline","type":"uint64"},{"internalType":"uint64","name":"amountOutMin","type":"uint64"},{"internalType":"bool","name":"unwrap","type":"bool"},{"internalType":"uint64","name":"gasDrop","type":"uint64"},{"internalType":"bytes","name":"customPayload","type":"bytes"}],"internalType":"struct MayanSwap.Criteria","name":"criteria","type":"tuple"},{"internalType":"address","name":"tokenIn","type":"address"},{"internalType":"uint256","name":"amountIn","type":"uint256"}],"name":"swap","outputs":[{"internalType":"uint64","name":"sequence","type":"uint64"}],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"address payable","name":"to","type":"address"}],"name":"sweepEth","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"token","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"address","name":"to","type":"address"}],"name":"sweepToken","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"components":[{"internalType":"uint64","name":"swapFee","type":"uint64"},{"internalType":"uint64","name":"redeemFee","type":"uint64"},{"internalType":"uint64","name":"refundFee","type":"uint64"}],"internalType":"struct MayanSwap.RelayerFees","name":"relayerFees","type":"tuple"},{"components":[{"internalType":"bytes32","name":"mayanAddr","type":"bytes32"},{"internalType":"uint16","name":"mayanChainId","type":"uint16"},{"internalType":"bytes32","name":"auctionAddr","type":"bytes32"},{"internalType":"bytes32","name":"destAddr","type":"bytes32"},{"internalType":"uint16","name":"destChainId","type":"uint16"},{"internalType":"bytes32","name":"referrer","type":"bytes32"},{"internalType":"bytes32","name":"refundAddr","type":"bytes32"}],"internalType":"struct MayanSwap.Recepient","name":"recipient","type":"tuple"},{"internalType":"bytes32","name":"tokenOutAddr","type":"bytes32"},{"internalType":"uint16","name":"tokenOutChainId","type":"uint16"},{"components":[{"internalType":"uint256","name":"transferDeadline","type":"uint256"},{"internalType":"uint64","name":"swapDeadline","type":"uint64"},{"internalType":"uint64","name":"amountOutMin","type":"uint64"},{"internalType":"bool","name":"unwrap","type":"bool"},{"internalType":"uint64","name":"gasDrop","type":"uint64"},{"internalType":"bytes","name":"customPayload","type":"bytes"}],"internalType":"struct MayanSwap.Criteria","name":"criteria","type":"tuple"}],"name":"wrapAndSwapETH","outputs":[{"internalType":"uint64","name":"sequence","type":"uint64"}],"stateMutability":"payable","type":"function"},{"stateMutability":"payable","type":"receive"}]

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

Deployed Bytecode

0x6080604052600436106100c65760003560e01c80636111ad251161007f578063b187bd2611610059578063b187bd2614610201578063bedb86fb1461022b578063c0e6d1691461024b578063df2ab5bb1461026b57600080fd5b80636111ad25146101ae5780639945e3d3146101c1578063acbb478c146101d457600080fd5b8063107c279f146100d25780631eb1cff0146100ff5780632fcb4f041461012a578063459656ee1461014c5780634df808ce14610161578063580094b71461018e57600080fd5b366100cd57005b600080fd5b3480156100de57600080fd5b506003546040516001600160a01b0390911681526020015b60405180910390f35b61011261010d366004612bf9565b61028b565b6040516001600160401b0390911681526020016100f6565b34801561013657600080fd5b5061014a610145366004612ae4565b610a0c565b005b34801561015857600080fd5b5061014a610a58565b34801561016d57600080fd5b5061018161017c366004612b95565b610acb565b6040516100f69190613258565b34801561019a57600080fd5b5061014a6101a9366004613027565b610cb5565b6101126101bc366004612c77565b610d70565b61014a6101cf366004612b95565b6112e5565b3480156101e057600080fd5b506101f46101ef366004612d15565b6119ee565b6040516100f691906131ec565b34801561020d57600080fd5b50600254600160a01b900460ff1660405190151581526020016100f6565b34801561023757600080fd5b5061014a610246366004612b5d565b611a6f565b34801561025757600080fd5b5061014a610266366004612b95565b611ab7565b34801561027757600080fd5b5061014a610286366004612b1c565b611f75565b600254600090600160a01b900460ff16156102e25760405162461bcd60e51b815260206004820152601260248201527118dbdb9d1c9858dd081a5cc81c185d5cd95960721b60448201526064015b60405180910390fd5b81514211156103255760405162461bcd60e51b815260206004820152600f60248201526e191958591b1a5b99481c185cdcd959608a1b60448201526064016102d9565b8160600151156103815760808201516001600160401b0316156103815760405162461bcd60e51b815260206004820152601460248201527319d85cc8191c9bdc081b9bdd08185b1b1bddd95960621b60448201526064016102d9565b60008060009054906101000a90046001600160a01b03166001600160a01b03166384acd1bb6040518163ffffffff1660e01b815260040160206040518083038186803b1580156103d057600080fd5b505afa1580156103e4573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906104089190612b00565b6001600160a01b0316631a90a2196040518163ffffffff1660e01b815260040160206040518083038186803b15801561044057600080fd5b505afa158015610454573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190610478919061300f565b9050600061049b61048a8360026134f2565b6104949034613511565b6012611fb3565b905080886040015189600001516104b291906133b9565b6001600160401b0316106104fd5760405162461bcd60e51b81526020600482015260126024820152711999595cc8195e18d9595908185b5bdd5b9d60721b60448201526064016102d9565b83604001516001600160401b031688602001516001600160401b0316106105665760405162461bcd60e51b815260206004820152601d60248201527f72656465656d206665652065786365656473206d696e206f757470757400000060448201526064016102d9565b6000610573826012611fed565b60008054919250906001600160a01b0316639981509f61059386856133a1565b60208c01518c5160405160e085901b6001600160e01b031916815261ffff9092166004830152602482015260006044820181905260648201526084016020604051808303818588803b1580156105e857600080fd5b505af11580156105fc573d6000803e3d6000fd5b50505050506040513d601f19601f820116820180604052508101906106219190613056565b90506000826106318660026134f2565b61063b9034613511565b6106459190613511565b9050801561067c57604051339082156108fc029083906000818181858888f1935050505015801561067a573d6000803e3d6000fd5b505b600060405180610200016040528060008a60a00151511161069e5760016106a1565b60025b60ff1681526020018b81526020018a61ffff1681526020018c6060015181526020018c6080015161ffff1681526020018c60c001518152602001600360149054906101000a900461ffff1661ffff168152602001846001600160401b0316815260200189604001516001600160401b0316815260200189602001516001600160401b031681526020018d600001516001600160401b031681526020018d602001516001600160401b031681526020018d604001516001600160401b031681526020018c60400151815260200189606001511515815260200160011515815250905060006107ce826101c00151836101e001518e60a001518c608001516040516020016107b094939291906130cb565b6040516020818303038152906040526107c8846119ee565b9061201b565b9050816000015160ff1660021415610871578b6020015161ffff16826080015161ffff161461083f5760405162461bcd60e51b815260206004820152601d60248201527f696e76616c696420636861696e2069642077697468207061796c6f616400000060448201526064016102d9565b61086e8960a0015160405160200161085791906130fd565b60408051601f19818403018152919052829061201b565b90505b60008054906101000a90046001600160a01b03166001600160a01b03166384acd1bb6040518163ffffffff1660e01b815260040160206040518083038186803b1580156108bd57600080fd5b505afa1580156108d1573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906108f59190612b00565b6001600160a01b031663b19a437e8860008460008054906101000a90046001600160a01b03166001600160a01b031663739fc8d16040518163ffffffff1660e01b815260040160206040518083038186803b15801561095357600080fd5b505afa158015610967573d6000803e3d6000fd5b505050506040513d601f19601f8201168201806040525081019061098b9190613072565b6040518563ffffffff1660e01b81526004016109a9939291906131ff565b6020604051808303818588803b1580156109c257600080fd5b505af11580156109d6573d6000803e3d6000fd5b50505050506040513d601f19601f820116820180604052508101906109fb9190613056565b9d9c50505050505050505050505050565b6001546001600160a01b03163314610a365760405162461bcd60e51b81526004016102d990613231565b600280546001600160a01b0319166001600160a01b0392909216919091179055565b6002546001600160a01b03163314610aa75760405162461bcd60e51b815260206004820152601260248201527137b7363c903732bc3a1033bab0b93234b0b760711b60448201526064016102d9565b600254600180546001600160a01b0319166001600160a01b03909216919091179055565b6040805160c08101825260008082526020820181905291810182905260608082018390526080820183905260a082015290610b068382612098565b60ff168252610b166001826133a1565b9050816000015160ff1660011480610b355750816000015160ff166002145b610b815760405162461bcd60e51b815260206004820152601860248201527f7061796c6f6164206964206e6f7420737570706f72746564000000000000000060448201526064016102d9565b610b8b83826120f4565b602080840191909152610b9e90826133a1565b9050610baa8382612152565b6001600160401b03166040830152610bc36008826133a1565b8351909150600090849083908110610beb57634e487b7160e01b600052603260045260246000fd5b01602001516001600160f81b03191614156060830152610c0c6001826133a1565b9050610c188382612152565b6001600160401b03166080830152610c316008826133a1565b9050816000015160ff1660021415610c6657610c5c81828551610c549190613511565b8591906121af565b60a0830152610caf565b82518114610caf5760405162461bcd60e51b81526020600482015260166024820152750d2dcecc2d8d2c840e0c2f2d8dec2c840d8cadccee8d60531b60448201526064016102d9565b50919050565b6001546001600160a01b03163314610cdf5760405162461bcd60e51b81526004016102d990613231565b6001600160a01b038116610d355760405162461bcd60e51b815260206004820152601c60248201527f7472616e7366657220746f20746865207a65726f20616464726573730000000060448201526064016102d9565b6040516001600160a01b0382169083156108fc029084906000818181858888f19350505050158015610d6b573d6000803e3d6000fd5b505050565b600254600090600160a01b900460ff1615610dc25760405162461bcd60e51b815260206004820152601260248201527118dbdb9d1c9858dd081a5cc81c185d5cd95960721b60448201526064016102d9565b8351421115610e055760405162461bcd60e51b815260206004820152600f60248201526e191958591b1a5b99481c185cdcd959608a1b60448201526064016102d9565b836060015115610e615760808401516001600160401b031615610e615760405162461bcd60e51b815260206004820152601460248201527319d85cc8191c9bdc081b9bdd08185b1b1bddd95960621b60448201526064016102d9565b6000610e6c846122be565b90506000610e7a8483611fb3565b9050808a604001518b60000151610e9191906133b9565b6001600160401b031610610edc5760405162461bcd60e51b81526020600482015260126024820152711999595cc8195e18d9595908185b5bdd5b9d60721b60448201526064016102d9565b85604001516001600160401b03168a602001516001600160401b031610610f455760405162461bcd60e51b815260206004820152601d60248201527f72656465656d206665652065786365656473206d696e206f757470757400000060448201526064016102d9565b610f4f8183611fed565b9350610f666001600160a01b038616333087612359565b600054610f80906001600160a01b038781169116866123ca565b600080546001600160a01b0316630f5287b0610f9d6002346133e4565b60208d01518d5160405160e085901b6001600160e01b03191681526001600160a01b038c166004820152602481018b905261ffff9092166044830152606482015260006084820181905260a482015260c4016020604051808303818588803b15801561100857600080fd5b505af115801561101c573d6000803e3d6000fd5b50505050506040513d601f19601f820116820180604052508101906110419190613056565b9050600060405180610200016040528060008a60a001515111611065576001611068565b60025b60ff1681526020018b81526020018a61ffff1681526020018c6060015181526020018c6080015161ffff1681526020018c60c001518152602001600360149054906101000a900461ffff1661ffff168152602001836001600160401b0316815260200189604001516001600160401b0316815260200189602001516001600160401b031681526020018d600001516001600160401b031681526020018d602001516001600160401b031681526020018d604001516001600160401b031681526020018c6040015181526020018960600151151581526020016000151581525090506000611177826101c00151836101e001518e60a001518c608001516040516020016107b094939291906130cb565b9050816000015160ff1660021415611203578b6020015161ffff16826080015161ffff16146111e85760405162461bcd60e51b815260206004820152601d60248201527f696e76616c696420636861696e2069642077697468207061796c6f616400000060448201526064016102d9565b6112008960a0015160405160200161085791906130fd565b90505b60008054906101000a90046001600160a01b03166001600160a01b03166384acd1bb6040518163ffffffff1660e01b815260040160206040518083038186803b15801561124f57600080fd5b505afa158015611263573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906112879190612b00565b6001600160a01b031663b19a437e6112a06002346133e4565b600080546040805163739fc8d160e01b8152905187926001600160a01b03169163739fc8d1916004808301926020929190829003018186803b15801561095357600080fd5b60008060009054906101000a90046001600160a01b03166001600160a01b03166384acd1bb6040518163ffffffff1660e01b815260040160206040518083038186803b15801561133457600080fd5b505afa158015611348573d6000803e3d6000fd5b505050506040513d601f19601f8201168201806040525081019061136c9190612b00565b6001600160a01b031663a9e11893836040518263ffffffff1660e01b815260040161139791906131ec565b60006040518083038186803b1580156113af57600080fd5b505afa1580156113c3573d6000803e3d6000fd5b505050506040513d6000823e601f3d908101601f191682016040526113eb9190810190612ef0565b6000805460e083015160405163ea63738d60e01b815293945091926001600160a01b039091169163ea63738d9161142591906004016131ec565b60006040518083038186803b15801561143d57600080fd5b505afa158015611451573d6000803e3d6000fd5b505050506040513d6000823e601f3d908101601f191682016040526114799190810190612e2c565b9050600061148a8260e00151610acb565b9050600061149b826020015161248b565b9050816000015160ff16600214156114f557336001600160a01b038216146114f55760405162461bcd60e51b815260206004820152600d60248201526c1b9bdd081c9958da5c1a595b9d609a1b60448201526064016102d9565b6000600360149054906101000a900461ffff1661ffff16846060015161ffff16141561152f57611528846040015161248b565b90506115c1565b60005460608501516040808701519051630ff8f14360e11b815261ffff909216600483015260248201526001600160a01b0390911690631ff1e2869060440160206040518083038186803b15801561158657600080fd5b505afa15801561159a573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906115be9190612b00565b90505b6040516370a0823160e01b81523060048201526000906001600160a01b038316906370a082319060240160206040518083038186803b15801561160357600080fd5b505afa158015611617573d6000803e3d6000fd5b505050506040513d601f19601f8201168201806040525081019061163b919061300f565b60005460405163c3f511c160e01b81529192506001600160a01b03169063c3f511c19061166c908a906004016131ec565b600060405180830381600087803b15801561168657600080fd5b505af115801561169a573d6000803e3d6000fd5b505050506040513d6000823e601f3d908101601f191682016040526116c29190810190612bc7565b506040516370a0823160e01b815230600482015281906001600160a01b038416906370a082319060240160206040518083038186803b15801561170457600080fd5b505afa158015611718573d6000803e3d6000fd5b505050506040513d601f19601f8201168201806040525081019061173c919061300f565b6117469190613511565b9050600061176985604001516001600160401b0316611764856122be565b611fed565b90508082116117b65760405162461bcd60e51b81526020600482015260196024820152781c995b185e595c8819995948195e1959591cc8185b5bdd5b9d603a1b60448201526064016102d9565b60808501516001600160401b0316156118755760808501516003546000916117f6916001600160401b0390911690611764906001600160a01b03166122be565b905080341461183c5760405162461bcd60e51b81526020600482015260126024820152710696e636f7272656374206761732064726f760741b60448201526064016102d9565b6040516001600160a01b0386169082156108fc029083906000818181858888f19350505050158015611872573d6000803e3d6000fd5b50505b8460600151801561189357506003546001600160a01b038481169116145b1561196957600354604051632e1a7d4d60e01b8152600481018490526001600160a01b0390911690632e1a7d4d90602401600060405180830381600087803b1580156118de57600080fd5b505af11580156118f2573d6000803e3d6000fd5b505060405133925083156108fc02915083906000818181858888f19350505050158015611923573d6000803e3d6000fd5b506001600160a01b0384166108fc61193b8385613511565b6040518115909202916000818181858888f19350505050158015611963573d6000803e3d6000fd5b5061199c565b61197d6001600160a01b03841633836124df565b61199c8461198b8385613511565b6001600160a01b03861691906124df565b8660a001516001600160401b03168760800151886060015161ffff167ff02867db6908ee5f81fd178573ae9385837f0a0a72553f8c08306759a7e0f00e60405160405180910390a45050505050505050565b6060816000015182602001518360400151846060015185608001518660a001518760c001518860e001518961010001518a61012001518b61014001518c61016001518d61018001518e6101a00151604051602001611a599e9d9c9b9a99989796959493929190613119565b6040516020818303038152906040529050919050565b6001546001600160a01b03163314611a995760405162461bcd60e51b81526004016102d990613231565b60028054911515600160a01b0260ff60a01b19909216919091179055565b60008060009054906101000a90046001600160a01b03166001600160a01b03166384acd1bb6040518163ffffffff1660e01b815260040160206040518083038186803b158015611b0657600080fd5b505afa158015611b1a573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190611b3e9190612b00565b6001600160a01b031663a9e11893836040518263ffffffff1660e01b8152600401611b6991906131ec565b60006040518083038186803b158015611b8157600080fd5b505afa158015611b95573d6000803e3d6000fd5b505050506040513d6000823e601f3d908101601f19168201604052611bbd9190810190612ef0565b6000805460e083015160405163ea63738d60e01b815293945091926001600160a01b039091169163ea63738d91611bf791906004016131ec565b60006040518083038186803b158015611c0f57600080fd5b505afa158015611c23573d6000803e3d6000fd5b505050506040513d6000823e601f3d908101601f19168201604052611c4b9190810190612e2c565b9050600360149054906101000a900461ffff1661ffff16816060015161ffff1614611ca95760405162461bcd60e51b815260206004820152600e60248201526d3737ba103437b6b29031b430b4b760911b60448201526064016102d9565b6000611cb8826040015161248b565b6003549091506001600160a01b03808316911614611d035760405162461bcd60e51b81526020600482015260086024820152670dcdee840eecae8d60c31b60448201526064016102d9565b6000611d128360e00151610acb565b90508060600151611d525760405162461bcd60e51b815260206004820152600a60248201526906e6f7420756e777261760b41b60448201526064016102d9565b6000611d61826020015161248b565b9050816000015160ff1660021415611dbb57336001600160a01b03821614611dbb5760405162461bcd60e51b815260206004820152600d60248201526c1b9bdd081c9958da5c1a595b9d609a1b60448201526064016102d9565b6000546040516307211d7960e21b815247916001600160a01b031690631c8475e490611deb908a906004016131ec565b600060405180830381600087803b158015611e0557600080fd5b505af1158015611e19573d6000803e3d6000fd5b505050506040513d6000823e601f3d908101601f19168201604052611e419190810190612bc7565b50611e4c8147613511565b90506000611e6884604001516001600160401b03166012611fed565b9050808211611eb55760405162461bcd60e51b81526020600482015260196024820152781c995b185e595c8819995948195e1959591cc8185b5bdd5b9d603a1b60448201526064016102d9565b604051339082156108fc029083906000818181858888f19350505050158015611ee2573d6000803e3d6000fd5b506001600160a01b0383166108fc611efa8385613511565b6040518115909202916000818181858888f19350505050158015611f22573d6000803e3d6000fd5b508660a001516001600160401b03168760800151886060015161ffff167ff02867db6908ee5f81fd178573ae9385837f0a0a72553f8c08306759a7e0f00e60405160405180910390a45050505050505050565b6001546001600160a01b03163314611f9f5760405162461bcd60e51b81526004016102d990613231565b610d6b6001600160a01b03841682846124df565b600060088260ff161115611fe457611fcc600883613528565b611fd790600a613447565b611fe190846133e4565b92505b50815b92915050565b600060088260ff161115611fe457612006600883613528565b61201190600a613447565b611fe190846134f2565b6060806040519050835180825260208201818101602087015b8183101561204c578051835260209283019201612034565b50855184518101855292509050808201602086015b81831015612079578051835260209283019201612061565b508651929092011591909101601f01601f191660405250905092915050565b60006120a58260016133a1565b835110156120eb5760405162461bcd60e51b8152602060048201526013602482015272746f55696e74385f6f75744f66426f756e647360681b60448201526064016102d9565b50016001015190565b60006121018260206133a1565b835110156121495760405162461bcd60e51b8152602060048201526015602482015274746f427974657333325f6f75744f66426f756e647360581b60448201526064016102d9565b50016020015190565b600061215f8260086133a1565b835110156121a65760405162461bcd60e51b8152602060048201526014602482015273746f55696e7436345f6f75744f66426f756e647360601b60448201526064016102d9565b50016008015190565b6060816121bd81601f6133a1565b10156121fc5760405162461bcd60e51b815260206004820152600e60248201526d736c6963655f6f766572666c6f7760901b60448201526064016102d9565b61220682846133a1565b8451101561224a5760405162461bcd60e51b8152602060048201526011602482015270736c6963655f6f75744f66426f756e647360781b60448201526064016102d9565b60608215801561226957604051915060008252602082016040526122b3565b6040519150601f8416801560200281840101858101878315602002848b0101015b818310156122a257805183526020928301920161228a565b5050858452601f01601f1916604052505b5090505b9392505050565b60408051600481526024810182526020810180516001600160e01b031663313ce56760e01b179052905160009182916001600160a01b03851691612301916130fd565b600060405180830381855afa9150503d806000811461233c576040519150601f19603f3d011682016040523d82523d6000602084013e612341565b606091505b50915050808060200190518101906122b79190613072565b6040516001600160a01b03808516602483015283166044820152606481018290526123c49085906323b872dd60e01b906084015b60408051601f198184030181529190526020810180516001600160e01b03166001600160e01b03199093169290921790915261250f565b50505050565b604051636eb1769f60e11b81523060048201526001600160a01b038381166024830152600091839186169063dd62ed3e9060440160206040518083038186803b15801561241657600080fd5b505afa15801561242a573d6000803e3d6000fd5b505050506040513d601f19601f8201168201806040525081019061244e919061300f565b61245891906133a1565b6040516001600160a01b0385166024820152604481018290529091506123c490859063095ea7b360e01b9060640161238d565b60006001600160a01b03198216156124db5760405162461bcd60e51b8152602060048201526013602482015272696e76616c69642045564d206164647265737360681b60448201526064016102d9565b5090565b6040516001600160a01b038316602482015260448101829052610d6b90849063a9059cbb60e01b9060640161238d565b6000612564826040518060400160405280602081526020017f5361666545524332303a206c6f772d6c6576656c2063616c6c206661696c6564815250856001600160a01b03166125e19092919063ffffffff16565b805190915015610d6b57808060200190518101906125829190612b79565b610d6b5760405162461bcd60e51b815260206004820152602a60248201527f5361666545524332303a204552433230206f7065726174696f6e20646964206e6044820152691bdd081cdd58d8d9595960b21b60648201526084016102d9565b60606125f084846000856125f8565b949350505050565b6060824710156126595760405162461bcd60e51b815260206004820152602660248201527f416464726573733a20696e73756666696369656e742062616c616e636520666f6044820152651c8818d85b1b60d21b60648201526084016102d9565b6001600160a01b0385163b6126b05760405162461bcd60e51b815260206004820152601d60248201527f416464726573733a2063616c6c20746f206e6f6e2d636f6e747261637400000060448201526064016102d9565b600080866001600160a01b031685876040516126cc91906130fd565b60006040518083038185875af1925050503d8060008114612709576040519150601f19603f3d011682016040523d82523d6000602084013e61270e565b606091505b509150915061271e828286612729565b979650505050505050565b606083156127385750816122b7565b8251156127485782518084602001fd5b8160405162461bcd60e51b81526004016102d991906131ec565b600082601f830112612772578081fd5b815160206001600160401b0382111561278d5761278d61358d565b61279b818360051b0161334a565b80838252828201915082860187848660071b89010111156127ba578586fd5b855b8581101561282157608080838b0312156127d4578788fd5b6127dc6132b9565b8351815286840151878201526040808501516127f7816135ee565b9082015260608481015161280a816135ee565b9082015285529385019391909101906001016127bc565b5090979650505050505050565b8035612839816135bb565b919050565b600082601f83011261284e578081fd5b813561286161285c8261337a565b61334a565b818152846020838601011115612875578283fd5b816020850160208301379081016020019190915292915050565b600082601f83011261289f578081fd5b81516128ad61285c8261337a565b8181528460208386010111156128c1578283fd5b6125f082602083016020870161354b565b600060c082840312156128e3578081fd5b60405160c081016001600160401b0382821081831117156129065761290661358d565b816040528293508435835260208501359150612921826135d9565b81602084015261293360408601612ab8565b60408401526129446060860161282e565b606084015261295560808601612ab8565b608084015260a085013591508082111561296e57600080fd5b5061297b8582860161283e565b60a0830152505092915050565b600060e08284031215612999578081fd5b60405160e081018181106001600160401b03821117156129bb576129bb61358d565b6040528235815290508060208301356129d3816135c9565b8060208301525060408301356040820152606083013560608201526129fa60808401612a8e565b608082015260a083013560a082015260c083013560c08201525092915050565b600060608284031215612a2b578081fd5b604051606081018181106001600160401b0382111715612a4d57612a4d61358d565b6040529050808235612a5e816135d9565b81526020830135612a6e816135d9565b60208201526040830135612a81816135d9565b6040919091015292915050565b8035612839816135c9565b8051612839816135c9565b805163ffffffff8116811461283957600080fd5b8035612839816135d9565b8051612839816135d9565b8035612839816135ee565b8051612839816135ee565b600060208284031215612af5578081fd5b81356122b7816135a3565b600060208284031215612b11578081fd5b81516122b7816135a3565b600080600060608486031215612b30578182fd5b8335612b3b816135a3565b9250602084013591506040840135612b52816135a3565b809150509250925092565b600060208284031215612b6e578081fd5b81356122b7816135bb565b600060208284031215612b8a578081fd5b81516122b7816135bb565b600060208284031215612ba6578081fd5b81356001600160401b03811115612bbb578182fd5b6125f08482850161283e565b600060208284031215612bd8578081fd5b81516001600160401b03811115612bed578182fd5b6125f08482850161288f565b60008060008060006101a08688031215612c11578283fd5b612c1b8787612a1a565b9450612c2a8760608801612988565b93506101408601359250610160860135612c43816135c9565b91506101808601356001600160401b03811115612c5e578182fd5b612c6a888289016128d2565b9150509295509295909350565b60008060008060008060006101e0888a031215612c92578485fd5b612c9c8989612a1a565b9650612cab8960608a01612988565b95506101408801359450610160880135612cc4816135c9565b93506101808801356001600160401b03811115612cdf578283fd5b612ceb8a828b016128d2565b9350506101a0880135612cfd816135a3565b809250506101c0880135905092959891949750929550565b60006102008284031215612d27578081fd5b612d2f6132e1565b612d3883612ace565b815260208301356020820152612d5060408401612a8e565b604082015260608301356060820152612d6b60808401612a8e565b608082015260a083013560a0820152612d8660c08401612a8e565b60c0820152612d9760e08401612ab8565b60e0820152610100612daa818501612ab8565b90820152610120612dbc848201612ab8565b90820152610140612dce848201612ab8565b90820152610160612de0848201612ab8565b90820152610180612df2848201612ab8565b908201526101a083810135908201526101c0612e0f81850161282e565b908201526101e0612e2184820161282e565b908201529392505050565b600060208284031215612e3d578081fd5b81516001600160401b0380821115612e53578283fd5b908301906101008286031215612e67578283fd5b612e6f613304565b612e7883612ad9565b81526020830151602082015260408301516040820152612e9a60608401612a99565b606082015260808301516080820152612eb560a08401612a99565b60a082015260c083015160c082015260e083015182811115612ed5578485fd5b612ee18782860161288f565b60e08301525095945050505050565b600060208284031215612f01578081fd5b81516001600160401b0380821115612f17578283fd5b908301906101608286031215612f2b578283fd5b612f33613327565b612f3c83612ad9565b8152612f4a60208401612aa4565b6020820152612f5b60408401612aa4565b6040820152612f6c60608401612a99565b606082015260808301516080820152612f8760a08401612ac3565b60a0820152612f9860c08401612ad9565b60c082015260e083015182811115612fae578485fd5b612fba8782860161288f565b60e083015250610100612fce818501612aa4565b908201526101208381015183811115612fe5578586fd5b612ff188828701612762565b91830191909152506101409283015192810192909252509392505050565b600060208284031215613020578081fd5b5051919050565b60008060408385031215613039578182fd5b82359150602083013561304b816135a3565b809150509250929050565b600060208284031215613067578081fd5b81516122b7816135d9565b600060208284031215613083578081fd5b81516122b7816135ee565b600081518084526130a681602086016020860161354b565b601f01601f19169290920160200192915050565b60c01b6001600160c01b0319169052565b93151560f890811b855292151590921b6001840152600283015260c01b6001600160c01b0319166022820152602a0190565b6000825161310f81846020870161354b565b9190910192915050565b60ff60f81b8f60f81b1681528d6001820152613144602182018e60f01b6001600160f01b0319169052565b8b6023820152613163604382018c60f01b6001600160f01b0319169052565b896045820152613182606582018a60f01b6001600160f01b0319169052565b61318f60678201896130ba565b61319c606f8201886130ba565b6131a960778201876130ba565b6131b6607f8201866130ba565b6131c360878201856130ba565b6131d0608f8201846130ba565b609781019190915260b7019d9c50505050505050505050505050565b6020815260006122b7602083018461308e565b63ffffffff8416815260606020820152600061321e606083018561308e565b905060ff83166040830152949350505050565b6020808252600d908201526c37b7363c9033bab0b93234b0b760991b604082015260600190565b6020815260ff825116602082015260208201516040820152600060408301516001600160401b0380821660608501526060850151151560808501528060808601511660a0850152505060a083015160c0808401526125f060e084018261308e565b604051608081016001600160401b03811182821017156132db576132db61358d565b60405290565b60405161020081016001600160401b03811182821017156132db576132db61358d565b60405161010081016001600160401b03811182821017156132db576132db61358d565b60405161016081016001600160401b03811182821017156132db576132db61358d565b604051601f8201601f191681016001600160401b03811182821017156133725761337261358d565b604052919050565b60006001600160401b038211156133935761339361358d565b50601f01601f191660200190565b600082198211156133b4576133b4613577565b500190565b60006001600160401b038083168185168083038211156133db576133db613577565b01949350505050565b6000826133ff57634e487b7160e01b81526012600452602481fd5b500490565b600181815b8085111561343f57816000190482111561342557613425613577565b8085161561343257918102915b93841c9390800290613409565b509250929050565b60006122b760ff84168360008261346057506001611fe7565b8161346d57506000611fe7565b8160018114613483576002811461348d576134a9565b6001915050611fe7565b60ff84111561349e5761349e613577565b50506001821b611fe7565b5060208310610133831016604e8410600b84101617156134cc575081810a611fe7565b6134d68383613404565b80600019048211156134ea576134ea613577565b029392505050565b600081600019048311821515161561350c5761350c613577565b500290565b60008282101561352357613523613577565b500390565b600060ff821660ff84168082101561354257613542613577565b90039392505050565b60005b8381101561356657818101518382015260200161354e565b838111156123c45750506000910152565b634e487b7160e01b600052601160045260246000fd5b634e487b7160e01b600052604160045260246000fd5b6001600160a01b03811681146135b857600080fd5b50565b80151581146135b857600080fd5b61ffff811681146135b857600080fd5b6001600160401b03811681146135b857600080fd5b60ff811681146135b857600080fdfea26469706673582212208ee3cb1fca7394735e8ad3837f71ec56f4c408f0d7fa923a64ff60c27841c77c64736f6c63430008040033

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

0000000000000000000000003ee18b2214aff97000d974cf647e7c347e8fa585000000000000000000000000c02aaa39b223fe8d0a0e5c4f27ead9083c756cc2

-----Decoded View---------------
Arg [0] : _tokenBridge (address): 0x3ee18B2214AFF97000D974cf647E7C347E8fa585
Arg [1] : _weth (address): 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2

-----Encoded View---------------
2 Constructor Arguments found :
Arg [0] : 0000000000000000000000003ee18b2214aff97000d974cf647e7c347e8fa585
Arg [1] : 000000000000000000000000c02aaa39b223fe8d0a0e5c4f27ead9083c756cc2


Block Transaction Difficulty Gas Used Reward
View All Blocks Produced

Block Uncle Number Difficulty Gas Used Reward
View All Uncles
Loading...
Loading
Loading...
Loading

Validator Index Block Amount
View All Withdrawals

Transaction Hash Block Value Eth2 PubKey Valid
View All Deposits
Loading...
Loading
[ Download: CSV Export  ]
[ Download: CSV Export  ]

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.