Contract Source Code (Solidity Standard Json-Input format)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta

More Options

• Similar
• Submit Audit
• Compare

// SPDX-License-Identifier: Apache 2
pragma solidity ^0.8.17;

import {IWormhole} from "../interfaces/IWormhole.sol";
import {ITokenBridge} from "../interfaces/ITokenBridge.sol";

import "../libraries/BytesLib.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";

import "./TokenBridgeRelayerGovernance.sol";
import "./TokenBridgeRelayerMessages.sol";

/**
 * @title Wormhole Token Bridge Relayer
 * @notice This contract composes on Wormhole's Token Bridge contracts to faciliate
 * one-click transfers of Token Bridge supported assets cross chain.
 */
contract TokenBridgeRelayer is TokenBridgeRelayerGovernance, TokenBridgeRelayerMessages, ReentrancyGuard {
    using BytesLib for bytes;

    // contract version
    string public constant VERSION = "0.2.0";

    constructor(
        address tokenBridge_,
        address wethAddress,
        address feeRecipient_,
        address ownerAssistant_,
        bool unwrapWeth_
    ) {
        require(tokenBridge_ != address(0), "invalid token bridge address");
        require(wethAddress != address(0), "invalid weth address");
        require(feeRecipient_ != address(0), "invalid fee recipient");
        require(ownerAssistant_ != address(0), "invalid owner assistant");

        // set initial state
        setOwner(msg.sender);
        setFeeRecipient(feeRecipient_);
        setTokenBridge(tokenBridge_);
        setWethAddress(wethAddress);
        setOwnerAssistant(ownerAssistant_);
        setUnwrapWethFlag(unwrapWeth_);

        // fetch wormhole info from token bridge
        ITokenBridge bridge = ITokenBridge(tokenBridge_);
        setChainId(bridge.chainId());
        setWormhole(address(bridge.wormhole()));

        // set the initial swapRate/relayer precisions to 1e8
        setSwapRatePrecision(1e8);
        setRelayerFeePrecision(1e8);
    }

    /**
     * @notice Emitted when a transfer is completed by the Wormhole token bridge
     * @param emitterChainId Wormhole chain ID of emitter contract on the source chain
     * @param emitterAddress Address (bytes32 zero-left-padded) of emitter on the source chain
     * @param sequence Sequence of the Wormhole message
     */
    event TransferRedeemed(
        uint16 indexed emitterChainId,
        bytes32 indexed emitterAddress,
        uint64 indexed sequence
    );

    /**
     * @notice Emitted when a swap is executed with an off-chain relayer
     * @param recipient Address of the recipient of the native assets
     * @param relayer Address of the relayer that performed the swap
     * @param token Address of the token being swapped
     * @param tokenAmount Amount of token being swapped
     * @param nativeAmount Amount of native assets swapped for tokens
     */
    event SwapExecuted(
        address indexed recipient,
        address indexed relayer,
        address indexed token,
        uint256 tokenAmount,
        uint256 nativeAmount
    );

    /**
     * @notice Calls Wormhole's Token Bridge contract to emit a contract-controlled
     * transfer. The transfer message includes an arbitrary payload with instructions
     * for how to handle relayer payments on the target contract and the quantity of
     * tokens to convert into native assets for the user.
     * @param token ERC20 token address to transfer cross chain.
     * @param amount Quantity of tokens to be transferred.
     * @param toNativeTokenAmount Amount of tokens to swap into native assets on
     * the target chain.
     * @param targetChain Wormhole chain ID of the target blockchain.
     * @param targetRecipient User's wallet address on the target blockchain in bytes32 format
     * (zero-left-padded).
     * @param batchId ID for Wormhole message batching
     * @return messageSequence Wormhole sequence for emitted TransferTokensWithRelay message.
     */
    function transferTokensWithRelay(
        address token,
        uint256 amount,
        uint256 toNativeTokenAmount,
        uint16 targetChain,
        bytes32 targetRecipient,
        uint32 batchId
    ) public payable nonReentrant notPaused returns (uint64 messageSequence) {
        // Cache wormhole fee and confirm that the user has passed enough
        // value to cover the wormhole protocol fee.
        uint256 wormholeFee = wormhole().messageFee();
        require(msg.value == wormholeFee, "insufficient value");

        // Cache token decimals, and remove dust from the amount argument. This
        // ensures that the dust is never transferred to this contract.
        uint8 tokenDecimals = getDecimals(token);
        amount = denormalizeAmount(
            normalizeAmount(amount, tokenDecimals),
            tokenDecimals
        );

        // Transfer tokens from user to the this contract, and
        // override amount with actual amount received.
        amount = custodyTokens(token, amount);

        // call the internal _transferTokensWithRelay function
        messageSequence = _transferTokensWithRelay(
            InternalTransferParams({
                token: token,
                amount: amount,
                tokenDecimals: tokenDecimals,
                toNativeTokenAmount: toNativeTokenAmount,
                targetChain: targetChain,
                targetRecipient: targetRecipient
            }),
            batchId,
            wormholeFee
        );
    }

    /**
     * @notice Wraps Ether and calls Wormhole's Token Bridge contract to emit
     * a contract-controlled transfer. The transfer message includes an arbitrary
     * payload with instructions for how to handle relayer payments on the target
     * contract and the quantity of tokens to convert into native assets for the user.
     * @param toNativeTokenAmount Amount of tokens to swap into native assets on
     * the target chain.
     * @param targetChain Wormhole chain ID of the target blockchain.
     * @param targetRecipient User's wallet address on the target blockchain in bytes32 format
     * (zero-left-padded).
     * @param batchId ID for Wormhole message batching
     * @return messageSequence Wormhole sequence for emitted TransferTokensWithRelay message.
     */
    function wrapAndTransferEthWithRelay(
        uint256 toNativeTokenAmount,
        uint16 targetChain,
        bytes32 targetRecipient,
        uint32 batchId
    ) public payable notPaused returns (uint64 messageSequence) {
        require(unwrapWeth(), "WETH functionality not supported");

        // Cache wormhole fee and confirm that the user has passed enough
        // value to cover the wormhole protocol fee.
        uint256 wormholeFee = wormhole().messageFee();
        require(msg.value > wormholeFee, "insufficient value");

        // remove the wormhole protocol fee from the amount
        uint256 amount = msg.value - wormholeFee;

        // refund dust
        uint256 dust = amount - denormalizeAmount(normalizeAmount(amount, 18), 18);
        if (dust > 0) {
            payable(msg.sender).transfer(dust);
        }

        // remove dust from amount and cache WETH
        uint256 amountLessDust = amount - dust;
        IWETH weth = WETH();

        // deposit into the WETH contract
        weth.deposit{
            value : amountLessDust
        }();

        // call the internal _transferTokensWithRelay function
        messageSequence = _transferTokensWithRelay(
            InternalTransferParams({
                token: address(weth),
                tokenDecimals: 18,
                amount: amountLessDust,
                toNativeTokenAmount: toNativeTokenAmount,
                targetChain: targetChain,
                targetRecipient: targetRecipient
            }),
            batchId,
            wormholeFee
        );
    }

    function _transferTokensWithRelay(
        InternalTransferParams memory params,
        uint32 batchId,
        uint256 wormholeFee
    ) internal returns (uint64 messageSequence) {
        // sanity check function arguments
        require(isAcceptedToken(params.token), "token not accepted");
        require(
            params.targetRecipient != bytes32(0),
            "targetRecipient cannot be bytes32(0)"
        );

        /**
         * Cache the normalized amount and verify that it's nonzero.
         * The token bridge peforms the same operation before encoding
         * the amount in the `TransferWithPayload` message.
         */
        uint256 normalizedAmount = normalizeAmount(
            params.amount,
            params.tokenDecimals
        );
        require(normalizedAmount > 0, "normalized amount must be > 0");

        // normalized toNativeTokenAmount should be nonzero
        uint256 normalizedToNativeTokenAmount = normalizeAmount(
            params.toNativeTokenAmount,
            params.tokenDecimals
        );
        require(
            params.toNativeTokenAmount == 0 || normalizedToNativeTokenAmount > 0,
            "invalid toNativeTokenAmount"
        );

        // Cache the target contract address and verify that there
        // is a registered contract for the specified targetChain.
        bytes32 targetContract = getRegisteredContract(params.targetChain);
        require(targetContract != bytes32(0), "target not registered");

        // Confirm that the user has sent enough tokens to cover the native swap
        // on the target chain and to pay the relayer fee.
        uint256 normalizedRelayerFee = normalizeAmount(
            calculateRelayerFee(
                params.targetChain,
                params.token,
                params.tokenDecimals
            ),
            params.tokenDecimals
        );
        require(
            normalizedAmount > normalizedRelayerFee + normalizedToNativeTokenAmount,
            "insufficient amount"
        );

        /**
         * Encode instructions (TransferWithRelay) to send with the token transfer.
         * The `targetRecipient` address is in bytes32 format (zero-left-padded) to
         * support non-evm smart contracts that have addresses that are longer
         * than 20 bytes.
         *
         * We normalize the relayerFee and toNativeTokenAmount to support
         * non-evm smart contracts that can only handle uint64.max values.
         */
        bytes memory messagePayload = encodeTransferWithRelay(
            TransferWithRelay({
                payloadId: 1,
                targetRelayerFee: normalizedRelayerFee,
                toNativeTokenAmount: normalizedToNativeTokenAmount,
                targetRecipient: params.targetRecipient
            })
        );

        // cache TokenBridge instance
        ITokenBridge bridge = tokenBridge();

        // approve the token bridge to spend the specified tokens
        SafeERC20.safeApprove(
            IERC20(params.token),
            address(bridge),
            params.amount
        );

        /**
         * Call `transferTokensWithPayload` method on the token bridge and pay
         * the Wormhole network fee. The token bridge will emit a Wormhole
         * message with an encoded `TransferWithPayload` struct (see the
         * ITokenBridge.sol interface file in this repo).
         */
        messageSequence = bridge.transferTokensWithPayload{value: wormholeFee}(
            params.token,
            params.amount,
            params.targetChain,
            targetContract,
            batchId,
            messagePayload
        );
    }

    /**
     * @notice Calls Wormhole's Token Bridge contract to complete token transfers. Takes
     * custody of the wrapped (or released) tokens and sends the tokens to the target recipient.
     * It pays the fee recipient in the minted token denomination. If requested by the user,
     * it will perform a swap with the off-chain relayer to provide the user with native assets.
     * If the `token` being transferred is WETH, the contract will unwrap native assets and send
     * the transferred amount to the recipient and pay the fee recipient in native assets.
     * @dev reverts if:
     * - the transferred token is not accepted by this contract
     * - the transffered token is not attested on this blockchain's Token Bridge contract
     * - the emitter of the transfer message is not registered with this contract
     * - the relayer fails to provide enough native assets to faciliate a native swap
     * - the recipient attempts to swap native assets when performing a self redemption
     * @param encodedTransferMessage Attested `TransferWithPayload` wormhole message.
     */
    function completeTransferWithRelay(bytes calldata encodedTransferMessage) public payable {
        // complete the transfer by calling the token bridge
        (bytes memory payload, uint256 amount, address token) =
             _completeTransfer(encodedTransferMessage);

        // parse the payload into the `TransferWithRelay` struct
        TransferWithRelay memory transferWithRelay = decodeTransferWithRelay(
            payload
        );

        // cache the recipient address and unwrap weth flag
        address recipient = bytes32ToAddress(transferWithRelay.targetRecipient);
        bool unwrapWeth = unwrapWeth();

        // handle self redemptions
        if (msg.sender == recipient) {
            _completeSelfRedemption(
                token,
                recipient,
                amount,
                unwrapWeth
            );

            // bail out
            return;
        }

        // cache token decimals
        uint8 tokenDecimals = getDecimals(token);

        // denormalize the encoded relayerFee
        transferWithRelay.targetRelayerFee = denormalizeAmount(
            transferWithRelay.targetRelayerFee,
            tokenDecimals
        );

        // unwrap and transfer ETH
        if (token == address(WETH())) {
            _completeWethTransfer(
                amount,
                recipient,
                transferWithRelay.targetRelayerFee,
                unwrapWeth
            );

            // bail out
            return;
        }

        // handle native asset payments and refunds
        if (transferWithRelay.toNativeTokenAmount > 0) {
            // denormalize the toNativeTokenAmount
            transferWithRelay.toNativeTokenAmount = denormalizeAmount(
                transferWithRelay.toNativeTokenAmount,
                tokenDecimals
            );

            /**
             * Compute the maximum amount of tokens that the user is allowed
             * to swap for native assets.
             *
             * Override the toNativeTokenAmount in transferWithRelay if the
             * toNativeTokenAmount is greater than the maxToNativeAllowed.
             *
             * Compute the amount of native assets to send the recipient.
             */
            uint256 maxToNativeAllowed = calculateMaxSwapAmountIn(token);
            if (transferWithRelay.toNativeTokenAmount > maxToNativeAllowed) {
                transferWithRelay.toNativeTokenAmount = maxToNativeAllowed;
            }
            // compute amount of native asset to pay the recipient
            uint256 nativeAmountForRecipient = calculateNativeSwapAmountOut(
                token,
                transferWithRelay.toNativeTokenAmount
            );

            /**
             * The nativeAmountForRecipient can be zero if the user specifed
             * a toNativeTokenAmount that is too little to convert to native
             * asset. We need to override the toNativeTokenAmount to be zero
             * if that is the case, that way the user receives the full amount
             * of transferred tokens.
             */
            if (nativeAmountForRecipient > 0) {
                // check to see if the relayer sent enough value
                require(
                    msg.value >= nativeAmountForRecipient,
                    "insufficient native asset amount"
                );

                // refund excess native asset to relayer if applicable
                uint256 relayerRefund = msg.value - nativeAmountForRecipient;
                if (relayerRefund > 0) {
                    payable(msg.sender).transfer(relayerRefund);
                }

                // send requested native asset to target recipient
                payable(recipient).transfer(nativeAmountForRecipient);

                // emit swap event
                emit SwapExecuted(
                    recipient,
                    msg.sender,
                    token,
                    transferWithRelay.toNativeTokenAmount,
                    nativeAmountForRecipient
                );
            } else {
                // override the toNativeTokenAmount in transferWithRelay
                transferWithRelay.toNativeTokenAmount = 0;

                // refund the relayer any native asset sent to this contract
                if (msg.value > 0) {
                    payable(msg.sender).transfer(msg.value);
                }
            }
        }

        // add the token swap amount to the relayer fee
        uint256 amountForRelayer =
            transferWithRelay.targetRelayerFee + transferWithRelay.toNativeTokenAmount;

        // pay the fee recipient if amountForRelayer > 0
        if (amountForRelayer > 0) {
            SafeERC20.safeTransfer(
                IERC20(token),
                feeRecipient(),
                amountForRelayer
            );
        }

        // pay the target recipient the remaining tokens
        SafeERC20.safeTransfer(
            IERC20(token),
            recipient,
            amount - amountForRelayer
        );
    }

    function _completeTransfer(
        bytes memory encodedTransferMessage
    ) internal returns (bytes memory, uint256, address) {
        /**
         * parse the encoded Wormhole message
         *
         * SECURITY: This message not been verified by the Wormhole core layer yet.
         * The encoded payload can only be trusted once the message has been verified
         * by the Wormhole core contract. In this case, the message will be verified
         * by a call to the token bridge contract in subsequent actions.
         */
        IWormhole.VM memory parsedMessage = wormhole().parseVM(
            encodedTransferMessage
        );

        /**
         * The amount encoded in the payload could be incorrect,
         * since fee-on-transfer tokens are supported by the token bridge.
         *
         * NOTE: The token bridge truncates the encoded amount for any token
         * with decimals greater than 8. This is to support blockchains that
         * cannot handle transfer amounts exceeding max(uint64).
         */
        address localTokenAddress = fetchLocalAddressFromTransferMessage(
            parsedMessage.payload
        );
        require(isAcceptedToken(localTokenAddress), "token not registered");

        // check balance before completing the transfer
        uint256 balanceBefore = getBalance(localTokenAddress);

        // cache the token bridge instance
        ITokenBridge bridge = tokenBridge();

        /**
         * Call `completeTransferWithPayload` on the token bridge. This
         * method acts as a reentrancy protection since it does not allow
         * transfers to be redeemed more than once.
         */
        bytes memory transferPayload = bridge.completeTransferWithPayload(
            encodedTransferMessage
        );

        // compute and save the balance difference after completing the transfer
        uint256 amountReceived = getBalance(localTokenAddress) - balanceBefore;

        // parse the wormhole message payload into the `TransferWithPayload` struct
        ITokenBridge.TransferWithPayload memory transfer =
            bridge.parseTransferWithPayload(transferPayload);

        // confirm that the message sender is a registered TokenBridgeRelayer contract
        require(
            transfer.fromAddress == getRegisteredContract(parsedMessage.emitterChainId),
            "contract not registered"
        );

        // emit event with information about the TransferWithPayload message
        emit TransferRedeemed(
            parsedMessage.emitterChainId,
            parsedMessage.emitterAddress,
            parsedMessage.sequence
        );

        return (
            transfer.payload,
            amountReceived,
            localTokenAddress
        );
    }

    function _completeSelfRedemption(
        address token,
        address recipient,
        uint256 amount,
        bool unwrapWeth
    ) internal {
        // revert if the caller sends ether to this contract
        require(msg.value == 0, "recipient cannot swap native assets");

        // cache WETH instance
        IWETH weth = WETH();

        // transfer the full amount to the recipient
        if (token == address(weth) && unwrapWeth) {
            // withdraw weth and send to the recipient
            weth.withdraw(amount);
            payable(recipient).transfer(amount);
        } else {
            SafeERC20.safeTransfer(
                IERC20(token),
                recipient,
                amount
            );
        }
    }

    function _completeWethTransfer(
        uint256 amount,
        address recipient,
        uint256 relayerFee,
        bool unwrapWeth
    ) internal {
        // revert if the relayer sends ether to this contract
        require(msg.value == 0, "value must be zero");

        /**
         * Check if the weth is unwrappable. Some wrapped native assets
         * are not unwrappable (e.g. CELO) and must be transferred via
         * the ERC20 interface.
         */
        if (unwrapWeth) {
            // withdraw eth
            WETH().withdraw(amount);

            // transfer eth to recipient
            payable(recipient).transfer(amount - relayerFee);

            // transfer relayer fee to the fee recipient
            if (relayerFee > 0) {
                payable(feeRecipient()).transfer(relayerFee);
            }
        } else {
            // cache WETH instance
            IWETH weth = WETH();

            // transfer the native asset to the caller
            SafeERC20.safeTransfer(
                IERC20(address(weth)),
                recipient,
                amount - relayerFee
            );

            // transfer relayer fee to the fee recipient
            if (relayerFee > 0) {
                SafeERC20.safeTransfer(
                    IERC20(address(weth)),
                    feeRecipient(),
                    relayerFee
                );
            }
        }
    }

    /**
     * @notice Parses the encoded address and chainId from a `TransferWithPayload`
     * message. Finds the address of the wrapped token contract if the token is not
     * native to this chain.
     * @param payload Encoded `TransferWithPayload` message
     * @return localAddress Address of the encoded (bytes32 format) token address on
     * this chain.
     */
    function fetchLocalAddressFromTransferMessage(
        bytes memory payload
    ) public view returns (address localAddress) {
        // parse the source token address and chainId
        bytes32 sourceAddress = payload.toBytes32(33);
        uint16 tokenChain = payload.toUint16(65);

        // Fetch the wrapped address from the token bridge if the token
        // is not from this chain.
        if (tokenChain != chainId()) {
            // identify wormhole token bridge wrapper
            localAddress = tokenBridge().wrappedAsset(tokenChain, sourceAddress);
            require(localAddress != address(0), "token not attested");
        } else {
            // return the encoded address if the token is native to this chain
            localAddress = bytes32ToAddress(sourceAddress);
        }
    }

    /**
     * @notice Calculates the max amount of tokens the user can convert to
     * native assets on this chain.
     * @dev The max amount of native assets the contract will swap with the user
     * is governed by the `maxNativeSwapAmount` state variable.
     * @param token Address of token being transferred.
     * @return maxAllowed The maximum number of tokens the user is allowed to
     * swap for native assets.
     */
    function calculateMaxSwapAmountIn(
        address token
    ) public view returns (uint256 maxAllowed) {
        // fetch the decimals for the token and native token
        uint8 tokenDecimals = getDecimals(token);
        uint8 nativeDecimals = getDecimals(address(WETH()));

        if (tokenDecimals > nativeDecimals) {
            maxAllowed =
                maxNativeSwapAmount(token) * nativeSwapRate(token) *
                10 ** (tokenDecimals - nativeDecimals) / swapRatePrecision();
        } else {
            maxAllowed =
                (maxNativeSwapAmount(token) * nativeSwapRate(token)) /
                (10 ** (nativeDecimals - tokenDecimals) * swapRatePrecision());
        }
    }

    /**
     * @notice Calculates the amount of native assets that a user will receive
     * when swapping transferred tokens for native assets.
     * @param token Address of token being transferred.
     * @param toNativeAmount Quantity of tokens to be converted to native assets.
     * @return nativeAmount The exchange rate between native assets and the `toNativeAmount`
     * of transferred tokens.
     */
    function calculateNativeSwapAmountOut(
        address token,
        uint256 toNativeAmount
    ) public view returns (uint256 nativeAmount) {
        // fetch the decimals for the token and native token
        uint8 tokenDecimals = getDecimals(token);
        uint8 nativeDecimals = getDecimals(address(WETH()));

        if (tokenDecimals > nativeDecimals) {
            nativeAmount =
                swapRatePrecision() * toNativeAmount /
                (nativeSwapRate(token) * 10 ** (tokenDecimals - nativeDecimals));
        } else {
            nativeAmount =
                swapRatePrecision() * toNativeAmount *
                10 ** (nativeDecimals - tokenDecimals) /
                nativeSwapRate(token);
        }
    }

    /**
     * @notice Converts the USD denominated relayer fee into the specified token
     * denomination.
     * @param targetChainId Wormhole chain ID of the target blockchain.
     * @param token Address of token being transferred.
     * @param decimals Token decimals of token being transferred.
     * @return feeInTokenDenomination Relayer fee denominated in tokens.
     */
    function calculateRelayerFee(
        uint16 targetChainId,
        address token,
        uint8 decimals
    ) public view returns (uint256 feeInTokenDenomination) {
        // cache swap rate
        uint256 tokenSwapRate = swapRate(token);
        require(tokenSwapRate != 0, "swap rate not set");
        feeInTokenDenomination =
            10 ** decimals * relayerFee(targetChainId) * swapRatePrecision() /
            (tokenSwapRate * relayerFeePrecision());
    }

    function custodyTokens(
        address token,
        uint256 amount
    ) internal returns (uint256) {
        // query own token balance before transfer
        uint256 balanceBefore = getBalance(token);

        // deposit tokens
        SafeERC20.safeTransferFrom(
            IERC20(token),
            msg.sender,
            address(this),
            amount
        );

        // return the balance difference
        return getBalance(token) - balanceBefore;
    }

    function bytes32ToAddress(bytes32 address_) internal pure returns (address) {
        require(bytes12(address_) == 0, "invalid EVM address");
        return address(uint160(uint256(address_)));
    }

    // necessary for receiving native assets
    receive() external payable {}
}

// contracts/Messages.sol
// SPDX-License-Identifier: Apache 2

pragma solidity ^0.8.17;

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

    event LogMessagePublished(address indexed sender, uint64 sequence, uint32 nonce, bytes payload, uint8 consistencyLevel);

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

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

// SPDX-License-Identifier: Apache 2

pragma solidity ^0.8.17;

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

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

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.8.0) (security/ReentrancyGuard.sol)

pragma solidity ^0.8.0;

/**
 * @dev Contract module that helps prevent reentrant calls to a function.
 *
 * Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier
 * available, which can be applied to functions to make sure there are no nested
 * (reentrant) calls to them.
 *
 * Note that because there is a single `nonReentrant` guard, functions marked as
 * `nonReentrant` may not call one another. This can be worked around by making
 * those functions `private`, and then adding `external` `nonReentrant` entry
 * points to them.
 *
 * TIP: If you would like to learn more about reentrancy and alternative ways
 * to protect against it, check out our blog post
 * https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul].
 */
abstract contract ReentrancyGuard {
    // Booleans are more expensive than uint256 or any type that takes up a full
    // word because each write operation emits an extra SLOAD to first read the
    // slot's contents, replace the bits taken up by the boolean, and then write
    // back. This is the compiler's defense against contract upgrades and
    // pointer aliasing, and it cannot be disabled.

    // The values being non-zero value makes deployment a bit more expensive,
    // but in exchange the refund on every call to nonReentrant will be lower in
    // amount. Since refunds are capped to a percentage of the total
    // transaction's gas, it is best to keep them low in cases like this one, to
    // increase the likelihood of the full refund coming into effect.
    uint256 private constant _NOT_ENTERED = 1;
    uint256 private constant _ENTERED = 2;

    uint256 private _status;

    constructor() {
        _status = _NOT_ENTERED;
    }

    /**
     * @dev Prevents a contract from calling itself, directly or indirectly.
     * Calling a `nonReentrant` function from another `nonReentrant`
     * function is not supported. It is possible to prevent this from happening
     * by making the `nonReentrant` function external, and making it call a
     * `private` function that does the actual work.
     */
    modifier nonReentrant() {
        _nonReentrantBefore();
        _;
        _nonReentrantAfter();
    }

    function _nonReentrantBefore() private {
        // On the first call to nonReentrant, _status will be _NOT_ENTERED
        require(_status != _ENTERED, "ReentrancyGuard: reentrant call");

        // Any calls to nonReentrant after this point will fail
        _status = _ENTERED;
    }

    function _nonReentrantAfter() private {
        // By storing the original value once again, a refund is triggered (see
        // https://eips.ethereum.org/EIPS/eip-2200)
        _status = _NOT_ENTERED;
    }
}

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

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.8.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");
        }
    }
}

// SPDX-License-Identifier: Apache 2
pragma solidity ^0.8.17;

import {IWormhole} from "../interfaces/IWormhole.sol";

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

import "./TokenBridgeRelayerGetters.sol";
import "./TokenBridgeRelayerStructs.sol";

abstract contract TokenBridgeRelayerGovernance is TokenBridgeRelayerGetters {
    event OwnershipTransfered(address indexed oldOwner, address indexed newOwner);
    event FeeRecipientUpdated(address indexed oldRecipient, address indexed newRecipient);
    event SwapRateUpdated(TokenBridgeRelayerStructs.SwapRateUpdate[] indexed swapRates);

    /**
     * @notice Starts the ownership transfer process of the contracts. It saves
     * an address in the pending owner state variable.
     * @param chainId_ Wormhole chain ID.
     * @param newOwner Address of the pending owner.
     */
    function submitOwnershipTransferRequest(
        uint16 chainId_,
        address newOwner
    ) public onlyOwner onlyCurrentChain(chainId_) {
        require(newOwner != address(0), "newOwner cannot equal address(0)");

        setPendingOwner(newOwner);
    }

    /**
     * @notice Cancels the ownership transfer process.
     * @dev Sets the pending owner state variable to the zero address.
     */
    function cancelOwnershipTransferRequest(
        uint16 chainId_
    ) public onlyOwner onlyCurrentChain(chainId_) {
        setPendingOwner(address(0));
    }

    /**
     * @notice Finalizes the ownership transfer to the pending owner.
     * @dev It checks that the caller is the pendingOwner to validate the wallet
     * address. It updates the owner state variable with the pendingOwner state
     * variable.
     */
    function confirmOwnershipTransferRequest() public {
        // cache the new owner address
        address newOwner = pendingOwner();

        require(msg.sender == newOwner, "caller must be pendingOwner");

        // cache currentOwner for Event
        address currentOwner = owner();

        // update the owner in the contract state and reset the pending owner
        setOwner(newOwner);
        setPendingOwner(address(0));

        emit OwnershipTransfered(currentOwner, newOwner);
    }

    /**
     * @notice Updates the `ownerAssistant` state variable. This method can
     * only be executed by the owner.
     * @param chainId_ Wormhole chain ID.
     * @param newAssistant Address of the new `ownerAssistant`.
     */
    function updateOwnerAssistant(
        uint16 chainId_,
        address newAssistant
    ) public onlyOwner onlyCurrentChain(chainId_) {
        require(
            newAssistant != address(0),
            "newAssistant cannot equal address(0)"
        );

        // update the owner assistant
        setOwnerAssistant(newAssistant);
    }

    /**
     * @notice Updates the `feeRecipient` state variable. This method can
     * only be executed by the owner.
     * @param chainId_ Wormhole chain ID.
     * @param newFeeRecipient Address of the new `feeRecipient`.
     */
    function updateFeeRecipient(
        uint16 chainId_,
        address newFeeRecipient
    ) public onlyOwner onlyCurrentChain(chainId_) {
        require(
            newFeeRecipient != address(0),
            "newFeeRecipient cannot equal address(0)"
        );

        // cache current fee recipient
        address currentFeeRecipient = feeRecipient();

        // update the fee recipient
        setFeeRecipient(newFeeRecipient);

        emit FeeRecipientUpdated(currentFeeRecipient, newFeeRecipient);
    }

    /**
     * @notice Updates the unwrapWeth state variable.
     * @dev This variable should only be set to true for chains that
     * support a WETH contract. Some chains (e.g. Celo, Karura, Acala)
     * do not support a WETH contract, and the address is set as a placeholder
     * for the native asset address for swapRate lookups.
     * @param chainId_ Wormhole chain ID.
     * @param unwrapWeth_ Boolean that determines if WETH is unwrapped
     * when transferred back to its native blockchain.
     */
    function updateUnwrapWethFlag(
        uint16 chainId_,
        bool unwrapWeth_
    ) public onlyOwner onlyCurrentChain(chainId_) {
        setUnwrapWethFlag(unwrapWeth_);
    }

    /**
     * @notice Registers foreign Token Bridge Relayer contracts.
     * @param chainId_ Wormhole chain ID of the foreign contract.
     * @param contractAddress Address of the foreign contract in bytes32 format
     * (zero-left-padded address).
     */
    function registerContract(
        uint16 chainId_,
        bytes32 contractAddress
    ) public onlyOwner {
        // sanity check both input arguments
        require(
            contractAddress != bytes32(0),
            "contractAddress cannot equal bytes32(0)"
        );
        require(
            chainId_ != 0 && chainId_ != chainId(),
            "chainId_ cannot equal 0 or this chainId"
        );

        // update the registeredContracts state variable
        _registerContract(chainId_, contractAddress);
    }

    /**
     * @notice Register tokens accepted by this contract.
     * @param chainId_ Wormhole chain ID.
     * @param token Address of the token.
     */
    function registerToken(
        uint16 chainId_,
        address token
    ) public onlyOwner onlyCurrentChain(chainId_) {
        require(token != address(0), "invalid token");

        addAcceptedToken(token);
    }

    /**
     * @notice Deregister tokens accepted by this contract.
     * @dev The `removeAcceptedToken` function will revert
     * if the token is not registered.
     * @param chainId_ Wormhole chain ID.
     * @param token Address of the token.
     */
    function deregisterToken(
        uint16 chainId_,
        address token
    ) public onlyOwner onlyCurrentChain(chainId_) {
        require(token != address(0), "invalid token");

        removeAcceptedToken(token);
    }

    /**
     * @notice Updates the fee for relaying transfers to foreign contracts.
     * @param chainId_ Wormhole chain ID.
     * @param amount Amount of USD to pay the relayer upon redemption.
     * @dev The relayerFee is scaled by the relayerFeePrecision. For example,
     * if the relayerFee is $15 and the relayerFeePrecision is 1000000, the
     * relayerFee should be set to 15000000.
     */
    function updateRelayerFee(
        uint16 chainId_,
        uint256 amount
    ) public onlyOwnerOrAssistant {
        require(chainId_ != chainId(), "invalid chain");
        require(
            getRegisteredContract(chainId_) != bytes32(0),
            "contract doesn't exist"
        );

        setRelayerFee(chainId_, amount);
    }

    /**
     * @notice Updates the precision of the relayer fee.
     * @param chainId_ Wormhole chain ID.
     * @param relayerFeePrecision_ Precision of relayer fee.
     */
    function updateRelayerFeePrecision(
        uint16 chainId_,
        uint256 relayerFeePrecision_
    ) public onlyOwner onlyCurrentChain(chainId_) {
        require(relayerFeePrecision_ > 0, "precision must be > 0");

        setRelayerFeePrecision(relayerFeePrecision_);
    }

    /**
     * @notice Updates the swap rates for a batch of tokens.
     * @param chainId_ Wormhole chain ID.
     * @param swapRateUpdate Array of structs with token -> swap rate pairs.
     * @dev The swapRate is the conversion rate using asset prices denominated in
     * USD multiplied by the swapRatePrecision. For example, if the conversion
     * rate is $15 and the swapRatePrecision is 1000000, the swapRate should be set
     * to 15000000.
     *
     * NOTE: This function does NOT check if a token is specified twice. It is up to the
     * owner to correctly construct the `SwapRateUpdate` struct.
     */
    function updateSwapRate(
        uint16 chainId_,
        TokenBridgeRelayerStructs.SwapRateUpdate[] calldata swapRateUpdate
    ) public onlyOwnerOrAssistant onlyCurrentChain(chainId_) {
        // cache length of swapRateUpdate array
        uint256 numTokens = swapRateUpdate.length;
        require(numTokens > 0, "invalid array size");

        // set the swap rate for each token
        for (uint256 i = 0; i < numTokens;) {
            require(
                isAcceptedToken(swapRateUpdate[i].token),
                "token not accepted"
            );
            require(
                swapRateUpdate[i].value > 0,
                "swap rate must be nonzero"
            );

            setSwapRate(swapRateUpdate[i].token, swapRateUpdate[i].value);

            unchecked { i += 1; }
        }

        emit SwapRateUpdated(swapRateUpdate);
    }

    /**
     * @notice Updates the precision of the swap rate.
     * @param chainId_ Wormhole chain ID.
     * @param swapRatePrecision_ Precision of swap rate.
     */
    function updateSwapRatePrecision(
        uint16 chainId_,
        uint256 swapRatePrecision_
    ) public onlyOwner onlyCurrentChain(chainId_) {
        require(swapRatePrecision_ > 0, "precision must be > 0");

        setSwapRatePrecision(swapRatePrecision_);
    }

    /**
     * @notice Updates the max amount of native assets the contract will pay
     * to the target recipient.
     * @param chainId_ Wormhole chain ID.
     * @param token Address of the token to update the max native swap amount for.
     * @param maxAmount Max amount of native assets.
     */
    function updateMaxNativeSwapAmount(
        uint16 chainId_,
        address token,
        uint256 maxAmount
    ) public onlyOwner onlyCurrentChain(chainId_) {
        require(isAcceptedToken(token), "token not accepted");

        setMaxNativeSwapAmount(token, maxAmount);
    }

    /**
     * @notice Sets the pause state of the relayer. If paused, token transfer
     * requests are blocked. In flight transfers, i.e. those that have a VAA
     * emitted, can still be processed if paused.
     * @param chainId_ Wormhole chain ID
     * @param paused If true, requests for token transfers will be blocked
     * and no VAAs will be generated.
     */
    function setPauseForTransfers(
        uint16 chainId_,
        bool paused
    ) public onlyOwner onlyCurrentChain(chainId_) {
        setPaused(paused);
    }

    modifier onlyOwner() {
        require(owner() == msg.sender, "caller not the owner");
        _;
    }

    modifier onlyOwnerOrAssistant() {
        require(
            owner() == msg.sender ||
            ownerAssistant() == msg.sender,
            "caller not the owner or assistant"
        );
        _;
    }

    modifier onlyCurrentChain(uint16 chainId_) {
        require(chainId() == chainId_, "wrong chain");
        _;
    }

    modifier notPaused() {
        require(!getPaused(), "relayer is paused");
        _;
    }
}

// SPDX-License-Identifier: Apache 2
pragma solidity ^0.8.17;

import "../libraries/BytesLib.sol";

import "./TokenBridgeRelayerStructs.sol";

abstract contract TokenBridgeRelayerMessages is TokenBridgeRelayerStructs {
    using BytesLib for bytes;

    /**
     * @notice Encodes the TransferWithRelay struct into bytes.
     * @param transfer TransferWithRelay struct.
     * @return encoded TransferWithRelay struct encoded into bytes.
     */
    function encodeTransferWithRelay(
        TransferWithRelay memory transfer
    ) public pure returns (bytes memory encoded) {
       require(transfer.payloadId == 1, "invalid payloadId");
        encoded = abi.encodePacked(
            transfer.payloadId,
            transfer.targetRelayerFee,
            transfer.toNativeTokenAmount,
            transfer.targetRecipient
        );
    }

    /**
     * @notice Decodes an encoded `TransferWithRelay` struct.
     * @dev reverts if:
     * - the first byte (payloadId) does not equal 1
     * - the length of the payload has an unexpected length
     * @param encoded Encoded `TransferWithRelay` struct.
     * @return transfer `TransferTokenRelay` struct.
     */
    function decodeTransferWithRelay(
        bytes memory encoded
    ) public pure returns (TransferWithRelay memory transfer) {
        uint256 index = 0;

        // parse the payloadId
        transfer.payloadId = encoded.toUint8(index);
        index += 1;

        require(transfer.payloadId == 1, "invalid payloadId");

        // target relayer fee
        transfer.targetRelayerFee = encoded.toUint256(index);
        index += 32;

        // amount of tokens to convert to native assets
        transfer.toNativeTokenAmount = encoded.toUint256(index);
        index += 32;

        // recipient of the transfered tokens and native assets
        transfer.targetRecipient = encoded.toBytes32(index);
        index += 32;

        require(index == encoded.length, "invalid message length");
    }
}

// contracts/Bridge.sol
// SPDX-License-Identifier: Apache 2

pragma solidity ^0.8.17;

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

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

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

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.8.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 functionCallWithValue(target, data, 0, "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");
        (bool success, bytes memory returndata) = target.call{value: value}(data);
        return verifyCallResultFromTarget(target, 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) {
        (bool success, bytes memory returndata) = target.staticcall(data);
        return verifyCallResultFromTarget(target, 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) {
        (bool success, bytes memory returndata) = target.delegatecall(data);
        return verifyCallResultFromTarget(target, success, returndata, errorMessage);
    }

    /**
     * @dev Tool to verify that a low level call to smart-contract was successful, and revert (either by bubbling
     * the revert reason or using the provided one) in case of unsuccessful call or if target was not a contract.
     *
     * _Available since v4.8._
     */
    function verifyCallResultFromTarget(
        address target,
        bool success,
        bytes memory returndata,
        string memory errorMessage
    ) internal view returns (bytes memory) {
        if (success) {
            if (returndata.length == 0) {
                // only check isContract if the call was successful and the return data is empty
                // otherwise we already know that it was a contract
                require(isContract(target), "Address: call to non-contract");
            }
            return returndata;
        } else {
            _revert(returndata, errorMessage);
        }
    }

    /**
     * @dev Tool to verify that a low level call was successful, and revert if it wasn't, either by bubbling the
     * revert reason or 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 {
            _revert(returndata, errorMessage);
        }
    }

    function _revert(bytes memory returndata, string memory errorMessage) private pure {
        // 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);
        }
    }
}

// SPDX-License-Identifier: Apache 2
pragma solidity ^0.8.17;

import {IWormhole} from "../interfaces/IWormhole.sol";
import {ITokenBridge} from "../interfaces/ITokenBridge.sol";
import {IWETH} from "../interfaces/IWETH.sol";

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

import "./TokenBridgeRelayerSetters.sol";

abstract contract TokenBridgeRelayerGetters is TokenBridgeRelayerSetters {
    function owner() public view returns (address) {
        return _state.owner;
    }

    function pendingOwner() public view returns (address) {
        return _state.pendingOwner;
    }

    function ownerAssistant() public view returns (address) {
        return _state.ownerAssistant;
    }

    function feeRecipient() public view returns (address) {
        return _state.feeRecipient;
    }

    function wormhole() public view returns (IWormhole) {
        return IWormhole(_state.wormhole);
    }

    function tokenBridge() public view returns (ITokenBridge) {
        return ITokenBridge(payable(_state.tokenBridge));
    }

    function WETH() public view returns (IWETH) {
        return IWETH(_state.wethAddress);
    }

    function unwrapWeth() public view returns (bool) {
        return _state.unwrapWeth;
    }

    function chainId() public view returns (uint16) {
        return _state.chainId;
    }

    function getPaused() public view returns (bool) {
        return _state.paused;
    }

    function getRegisteredContract(uint16 emitterChainId) public view returns (bytes32) {
        return _state.registeredContracts[emitterChainId];
    }

    function swapRatePrecision() public view returns (uint256) {
        return _state.swapRatePrecision;
    }

    function isAcceptedToken(address token) public view returns (bool) {
        return _state.acceptedTokens[token];
    }

    function getAcceptedTokensList() public view returns (address[] memory) {
        return _state.acceptedTokensList;
    }

    function relayerFeePrecision() public view returns (uint256) {
        return _state.relayerFeePrecision;
    }

    function relayerFee(uint16 chainId_) public view returns (uint256) {
        return _state.relayerFees[chainId_];
    }

    function maxNativeSwapAmount(address token) public view returns (uint256) {
        return _state.maxNativeSwapAmount[token];
    }

    function swapRate(address token) public view returns (uint256) {
        return _state.swapRates[token];
    }

    function nativeSwapRate(address token) public view returns (uint256) {
        uint256 nativeSwapRate_ = swapRate(_state.wethAddress);
        uint256 tokenSwapRate = swapRate(token);

        require(
            nativeSwapRate_ > 0 && tokenSwapRate > 0,
            "swap rate not set"
        );

        return swapRatePrecision() * nativeSwapRate_ / tokenSwapRate;
    }

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

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

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

    function getBalance(address token) internal view returns (uint256 balance) {
        // fetch the specified token balance for this contract
        (, bytes memory queriedBalance) =
            token.staticcall(
                abi.encodeWithSelector(IERC20.balanceOf.selector, address(this))
            );
        balance = abi.decode(queriedBalance, (uint256));
    }
}

// SPDX-License-Identifier: Apache 2
pragma solidity ^0.8.17;

abstract contract TokenBridgeRelayerStructs {
    struct TransferWithRelay {
        uint8 payloadId; // == 1
        uint256 targetRelayerFee;
        uint256 toNativeTokenAmount;
        bytes32 targetRecipient;
    }

    struct InternalTransferParams {
        address token;
        uint8 tokenDecimals;
        uint256 amount;
        uint256 toNativeTokenAmount;
        uint16 targetChain;
        bytes32 targetRecipient;
    }

    struct SwapRateUpdate {
        address token;
        uint256 value;
    }
}

// SPDX-License-Identifier: Apache 2
pragma solidity ^0.8.17;

import "./TokenBridgeRelayerState.sol";

abstract contract TokenBridgeRelayerSetters is TokenBridgeRelayerState {
    function setOwner(address owner_) internal {
        _state.owner = owner_;
    }

    function setPendingOwner(address pendingOwner_) internal {
        _state.pendingOwner = pendingOwner_;
    }

    function setOwnerAssistant(address ownerAssistant_) internal {
        _state.ownerAssistant = ownerAssistant_;
    }

    function setFeeRecipient(address feeRecipient_) internal {
        _state.feeRecipient = feeRecipient_;
    }

    function setWormhole(address wormhole_) internal {
        _state.wormhole = payable(wormhole_);
    }

    function setTokenBridge(address tokenBridge_) internal {
        _state.tokenBridge = payable(tokenBridge_);
    }

    function setUnwrapWethFlag(bool unwrapWeth_) internal {
        _state.unwrapWeth = unwrapWeth_;
    }

    function setWethAddress(address weth_) internal {
        _state.wethAddress = weth_;
    }

    function setChainId(uint16 chainId_) internal {
        _state.chainId = chainId_;
    }

    function setPaused(bool paused) internal {
        _state.paused = paused;
    }

    function _registerContract(uint16 chainId_, bytes32 contract_) internal {
        _state.registeredContracts[chainId_] = contract_;
    }

    function setSwapRatePrecision(uint256 precision) internal {
        _state.swapRatePrecision = precision;
    }

    function setRelayerFeePrecision(uint256 precision) internal {
        _state.relayerFeePrecision = precision;
    }

    function addAcceptedToken(address token) internal {
        require(
            _state.acceptedTokens[token] == false,
            "token already registered"
        );
        _state.acceptedTokens[token] = true;
        _state.acceptedTokensList.push(token);
    }

    function removeAcceptedToken(address token) internal {
        require(
            _state.acceptedTokens[token],
            "token not registered"
        );

        // Remove the token from the acceptedTokens mapping, and
        // clear the token's swapRate and maxNativeSwapAmount.
        _state.acceptedTokens[token] = false;
        _state.swapRates[token] = 0;
        _state.maxNativeSwapAmount[token] = 0;

        // cache array length
        uint256 length_ = _state.acceptedTokensList.length;

        // Replace `token` in the acceptedTokensList with the last
        // element in the acceptedTokensList array.
        uint256 i = 0;
        for (; i < length_;) {
            if (_state.acceptedTokensList[i] == token) {
                break;
            }
            unchecked { i += 1; }
        }

        if (i != length_) {
            if (length_ > 1) {
                _state.acceptedTokensList[i] = _state.acceptedTokensList[length_ - 1];
            }
            _state.acceptedTokensList.pop();
        }
    }

    function setRelayerFee(uint16 chainId_, uint256 fee) internal {
        _state.relayerFees[chainId_] = fee;
    }

    function setSwapRate(address token, uint256 swapRate) internal {
        _state.swapRates[token] = swapRate;
    }

    function setMaxNativeSwapAmount(address token, uint256 maximum) internal {
        _state.maxNativeSwapAmount[token] = maximum;
    }
}

// SPDX-License-Identifier: Apache 2
pragma solidity ^0.8.17;

import {IWormhole} from "../interfaces/IWormhole.sol";

abstract contract TokenBridgeRelayerStorage {
    struct State {
        // Wormhole chain ID of this contract
        uint16 chainId;

        // boolean to determine if weth is unwrappable
        bool unwrapWeth;

        // if true, token transfer requests are blocked
        bool paused;

        // address of WETH on this chain
        address wethAddress;

        // owner of this contract
        address owner;

        // address that can update swap rates and relayer fees
        address ownerAssistant;

        // recipient of relayer fees
        address feeRecipient;

        // intermediate state when transfering contract ownership
        address pendingOwner;

        // address of the Wormhole contract on this chain
        address wormhole;

        // address of the Wormhole TokenBridge contract on this chain
        address tokenBridge;

        // precision of the nativeSwapRates, this value should NEVER be set to zero
        uint256 swapRatePrecision;

        // precision of the relayerFee, this value should NEVER be set to zero
        uint256 relayerFeePrecision;

        // Wormhole chain ID to known relayer contract address mapping
        mapping(uint16 => bytes32) registeredContracts;

        // token swap rate in USD terms
        mapping(address => uint256) swapRates;

        /**
         * Mapping of source token address to maximum native asset swap amount
         * allowed.
         */
        mapping(address => uint256) maxNativeSwapAmount;

        // mapping of chainId to relayerFee in USD
        mapping(uint16 => uint256) relayerFees;

        // accepted token to bool mapping
        mapping(address => bool) acceptedTokens;

        // list of accepted token addresses
        address[] acceptedTokensList;
    }
}

abstract contract TokenBridgeRelayerState {
    TokenBridgeRelayerStorage.State _state;
}

{
  "remappings": [
    "@openzeppelin/=node_modules/@openzeppelin/",
    "@solidity-parser/=node_modules/@solidity-parser/",
    "ds-test/=lib/forge-std/lib/ds-test/src/",
    "forge-std/=lib/forge-std/src/",
    "wormhole-solidity/=modules/src/"
  ],
  "optimizer": {
    "enabled": true,
    "runs": 200
  },
  "metadata": {
    "useLiteralContent": false,
    "bytecodeHash": "ipfs"
  },
  "outputSelection": {
    "*": {
      "*": [
        "evm.bytecode",
        "evm.deployedBytecode",
        "devdoc",
        "userdoc",
        "metadata",
        "abi"
      ]
    }
  },
  "evmVersion": "london",
  "viaIR": false,
  "libraries": {}
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"address","name":"tokenBridge_","type":"address"},{"internalType":"address","name":"wethAddress","type":"address"},{"internalType":"address","name":"feeRecipient_","type":"address"},{"internalType":"address","name":"ownerAssistant_","type":"address"},{"internalType":"bool","name":"unwrapWeth_","type":"bool"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"oldRecipient","type":"address"},{"indexed":true,"internalType":"address","name":"newRecipient","type":"address"}],"name":"FeeRecipientUpdated","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"oldOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransfered","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"recipient","type":"address"},{"indexed":true,"internalType":"address","name":"relayer","type":"address"},{"indexed":true,"internalType":"address","name":"token","type":"address"},{"indexed":false,"internalType":"uint256","name":"tokenAmount","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"nativeAmount","type":"uint256"}],"name":"SwapExecuted","type":"event"},{"anonymous":false,"inputs":[{"components":[{"internalType":"address","name":"token","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"}],"indexed":true,"internalType":"struct TokenBridgeRelayerStructs.SwapRateUpdate[]","name":"swapRates","type":"tuple[]"}],"name":"SwapRateUpdated","type":"event"},{"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":"TransferRedeemed","type":"event"},{"inputs":[],"name":"VERSION","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"WETH","outputs":[{"internalType":"contract IWETH","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"token","type":"address"}],"name":"calculateMaxSwapAmountIn","outputs":[{"internalType":"uint256","name":"maxAllowed","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"token","type":"address"},{"internalType":"uint256","name":"toNativeAmount","type":"uint256"}],"name":"calculateNativeSwapAmountOut","outputs":[{"internalType":"uint256","name":"nativeAmount","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint16","name":"targetChainId","type":"uint16"},{"internalType":"address","name":"token","type":"address"},{"internalType":"uint8","name":"decimals","type":"uint8"}],"name":"calculateRelayerFee","outputs":[{"internalType":"uint256","name":"feeInTokenDenomination","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint16","name":"chainId_","type":"uint16"}],"name":"cancelOwnershipTransferRequest","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"chainId","outputs":[{"internalType":"uint16","name":"","type":"uint16"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes","name":"encodedTransferMessage","type":"bytes"}],"name":"completeTransferWithRelay","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"confirmOwnershipTransferRequest","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes","name":"encoded","type":"bytes"}],"name":"decodeTransferWithRelay","outputs":[{"components":[{"internalType":"uint8","name":"payloadId","type":"uint8"},{"internalType":"uint256","name":"targetRelayerFee","type":"uint256"},{"internalType":"uint256","name":"toNativeTokenAmount","type":"uint256"},{"internalType":"bytes32","name":"targetRecipient","type":"bytes32"}],"internalType":"struct TokenBridgeRelayerStructs.TransferWithRelay","name":"transfer","type":"tuple"}],"stateMutability":"pure","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"uint8","name":"decimals","type":"uint8"}],"name":"denormalizeAmount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"pure","type":"function"},{"inputs":[{"internalType":"uint16","name":"chainId_","type":"uint16"},{"internalType":"address","name":"token","type":"address"}],"name":"deregisterToken","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"components":[{"internalType":"uint8","name":"payloadId","type":"uint8"},{"internalType":"uint256","name":"targetRelayerFee","type":"uint256"},{"internalType":"uint256","name":"toNativeTokenAmount","type":"uint256"},{"internalType":"bytes32","name":"targetRecipient","type":"bytes32"}],"internalType":"struct TokenBridgeRelayerStructs.TransferWithRelay","name":"transfer","type":"tuple"}],"name":"encodeTransferWithRelay","outputs":[{"internalType":"bytes","name":"encoded","type":"bytes"}],"stateMutability":"pure","type":"function"},{"inputs":[],"name":"feeRecipient","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes","name":"payload","type":"bytes"}],"name":"fetchLocalAddressFromTransferMessage","outputs":[{"internalType":"address","name":"localAddress","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getAcceptedTokensList","outputs":[{"internalType":"address[]","name":"","type":"address[]"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getPaused","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint16","name":"emitterChainId","type":"uint16"}],"name":"getRegisteredContract","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"token","type":"address"}],"name":"isAcceptedToken","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"token","type":"address"}],"name":"maxNativeSwapAmount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"token","type":"address"}],"name":"nativeSwapRate","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"uint8","name":"decimals","type":"uint8"}],"name":"normalizeAmount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"pure","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"ownerAssistant","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"pendingOwner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint16","name":"chainId_","type":"uint16"},{"internalType":"bytes32","name":"contractAddress","type":"bytes32"}],"name":"registerContract","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint16","name":"chainId_","type":"uint16"},{"internalType":"address","name":"token","type":"address"}],"name":"registerToken","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint16","name":"chainId_","type":"uint16"}],"name":"relayerFee","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"relayerFeePrecision","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint16","name":"chainId_","type":"uint16"},{"internalType":"bool","name":"paused","type":"bool"}],"name":"setPauseForTransfers","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint16","name":"chainId_","type":"uint16"},{"internalType":"address","name":"newOwner","type":"address"}],"name":"submitOwnershipTransferRequest","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"token","type":"address"}],"name":"swapRate","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"swapRatePrecision","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"tokenBridge","outputs":[{"internalType":"contract ITokenBridge","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"token","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"uint256","name":"toNativeTokenAmount","type":"uint256"},{"internalType":"uint16","name":"targetChain","type":"uint16"},{"internalType":"bytes32","name":"targetRecipient","type":"bytes32"},{"internalType":"uint32","name":"batchId","type":"uint32"}],"name":"transferTokensWithRelay","outputs":[{"internalType":"uint64","name":"messageSequence","type":"uint64"}],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"unwrapWeth","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint16","name":"chainId_","type":"uint16"},{"internalType":"address","name":"newFeeRecipient","type":"address"}],"name":"updateFeeRecipient","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint16","name":"chainId_","type":"uint16"},{"internalType":"address","name":"token","type":"address"},{"internalType":"uint256","name":"maxAmount","type":"uint256"}],"name":"updateMaxNativeSwapAmount","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint16","name":"chainId_","type":"uint16"},{"internalType":"address","name":"newAssistant","type":"address"}],"name":"updateOwnerAssistant","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint16","name":"chainId_","type":"uint16"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"updateRelayerFee","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint16","name":"chainId_","type":"uint16"},{"internalType":"uint256","name":"relayerFeePrecision_","type":"uint256"}],"name":"updateRelayerFeePrecision","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint16","name":"chainId_","type":"uint16"},{"components":[{"internalType":"address","name":"token","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"}],"internalType":"struct TokenBridgeRelayerStructs.SwapRateUpdate[]","name":"swapRateUpdate","type":"tuple[]"}],"name":"updateSwapRate","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint16","name":"chainId_","type":"uint16"},{"internalType":"uint256","name":"swapRatePrecision_","type":"uint256"}],"name":"updateSwapRatePrecision","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint16","name":"chainId_","type":"uint16"},{"internalType":"bool","name":"unwrapWeth_","type":"bool"}],"name":"updateUnwrapWethFlag","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"wormhole","outputs":[{"internalType":"contract IWormhole","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"toNativeTokenAmount","type":"uint256"},{"internalType":"uint16","name":"targetChain","type":"uint16"},{"internalType":"bytes32","name":"targetRecipient","type":"bytes32"},{"internalType":"uint32","name":"batchId","type":"uint32"}],"name":"wrapAndTransferEthWithRelay","outputs":[{"internalType":"uint64","name":"messageSequence","type":"uint64"}],"stateMutability":"payable","type":"function"},{"stateMutability":"payable","type":"receive"}]

60806040523480156200001157600080fd5b50604051620049823803806200498283398101604081905262000034916200038c565b6001600f556001600160a01b038516620000955760405162461bcd60e51b815260206004820152601c60248201527f696e76616c696420746f6b656e2062726964676520616464726573730000000060448201526064015b60405180910390fd5b6001600160a01b038416620000ed5760405162461bcd60e51b815260206004820152601460248201527f696e76616c69642077657468206164647265737300000000000000000000000060448201526064016200008c565b6001600160a01b038316620001455760405162461bcd60e51b815260206004820152601560248201527f696e76616c69642066656520726563697069656e74000000000000000000000060448201526064016200008c565b6001600160a01b0382166200019d5760405162461bcd60e51b815260206004820152601760248201527f696e76616c6964206f776e657220617373697374616e7400000000000000000060448201526064016200008c565b600180546001600160a01b03191633179055600380546001600160a01b0319166001600160a01b038516179055600680546001600160a01b0319166001600160a01b03871617905560008054600160201b600160c01b0319166401000000006001600160a01b03871602179055600280546001600160a01b0319166001600160a01b0384161790556000805462ff0000191662010000831515021790556000859050620002c0816001600160a01b0316639a8a05926040518163ffffffff1660e01b8152600401602060405180830381865afa15801562000282573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190620002a8919062000410565b6000805461ffff191661ffff92909216919091179055565b6200034b816001600160a01b03166384acd1bb6040518163ffffffff1660e01b8152600401602060405180830381865afa15801562000303573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906200032991906200043d565b600580546001600160a01b0319166001600160a01b0392909216919091179055565b620003596305f5e100600755565b620003676305f5e100600855565b5050505050506200045d565b6001600160a01b03811681146200038957600080fd5b50565b600080600080600060a08688031215620003a557600080fd5b8551620003b28162000373565b6020870151909550620003c58162000373565b6040870151909450620003d88162000373565b6060870151909350620003eb8162000373565b608087015190925080151581146200040257600080fd5b809150509295509295909350565b6000602082840312156200042357600080fd5b815161ffff811681146200043657600080fd5b9392505050565b6000602082840312156200045057600080fd5b8151620004368162000373565b614515806200046d6000396000f3fe6080604052600436106102815760003560e01c80636805b84b1161014f5780639fe089ad116100c1578063cd601c781161007a578063cd601c781461083b578063df160d761461085b578063e30c39781461087d578063ea1d2e4a1461089b578063ffa1ad74146108bb578063fff982a8146108ec57600080fd5b80639fe089ad1461076b578063a2f32c8f14610798578063ad5c4648146107b8578063b5419523146107dd578063c6328a46146107fd578063c9c22f9f1461081b57600080fd5b80638da5cb5b116101135780638da5cb5b146106ac5780638e151dd1146106ca57806390a1afaa146106ea57806394cc743d1461070a5780639a8a05921461072a5780639cf278cd1461074d57600080fd5b80636805b84b146105db57806368aa9ef4146105fa5780637c9dec7a146106185780638335572f1461066e57806384acd1bb1461068e57600080fd5b80632def3e16116101f3578063415828bf116101ac578063415828bf14610517578063469048401461052c57806351e2d7b51461054a5780635b9cf0e11461056a578063640d946b1461058a57806366775a6b146105aa57600080fd5b80632def3e16146104145780632efe4f42146104345780632f25e25f1461046a57806339ba66111461047d5780633b6e750f1461049d5780633d62cca0146104e657600080fd5b8063203c509511610245578063203c50951461033357806327105ab91461035357806328ded8e31461037357806329ac8361146103935780632ca8008c146103a65780632d77e8fe146103dc57600080fd5b8063016aa2051461028d578063038c0b66146102af5780631019d654146102c45780631a282195146102f45780631acdab4b1461031457600080fd5b3661028857005b600080fd5b34801561029957600080fd5b506102ad6102a83660046137da565b61090c565b005b3480156102bb57600080fd5b506102ad6109d6565b6102d76102d2366004613825565b610ac3565b6040516001600160401b0390911681526020015b60405180910390f35b34801561030057600080fd5b506102ad61030f36600461389a565b610c63565b34801561032057600080fd5b506007545b6040519081526020016102eb565b34801561033f57600080fd5b506102ad61034e3660046137da565b610cec565b34801561035f57600080fd5b5061032561036e3660046138d7565b610e36565b34801561037f57600080fd5b5061032561038e3660046138d7565b610e70565b6102d76103a13660046138fc565b610e9e565b3480156103b257600080fd5b506103256103c1366004613946565b6001600160a01b03166000908152600a602052604090205490565b3480156103e857600080fd5b506103fc6103f7366004613a3e565b61113c565b6040516001600160a01b0390911681526020016102eb565b34801561042057600080fd5b506102ad61042f366004613abd565b61125c565b34801561044057600080fd5b5061032561044f366004613946565b6001600160a01b03166000908152600b602052604090205490565b6102ad610478366004613ae9565b61131a565b34801561048957600080fd5b50610325610498366004613b5a565b611647565b3480156104a957600080fd5b506104d66104b8366004613946565b6001600160a01b03166000908152600d602052604090205460ff1690565b60405190151581526020016102eb565b3480156104f257600080fd5b50610325610501366004613ba5565b61ffff1660009081526009602052604090205490565b34801561052357600080fd5b50600854610325565b34801561053857600080fd5b506003546001600160a01b03166103fc565b34801561055657600080fd5b506102ad610565366004613abd565b6116fa565b34801561057657600080fd5b506102ad610585366004613abd565b611824565b34801561059657600080fd5b506102ad6105a5366004613bc2565b61193f565b3480156105b657600080fd5b506103256105c5366004613ba5565b61ffff166000908152600c602052604090205490565b3480156105e757600080fd5b506000546301000000900460ff166104d6565b34801561060657600080fd5b506002546001600160a01b03166103fc565b34801561062457600080fd5b50610638610633366004613a3e565b611b83565b6040516102eb9190815160ff16815260208083015190820152604080830151908201526060918201519181019190915260800190565b34801561067a57600080fd5b506102ad61068936600461389a565b611cb4565b34801561069a57600080fd5b506005546001600160a01b03166103fc565b3480156106b857600080fd5b506001546001600160a01b03166103fc565b3480156106d657600080fd5b506103256106e5366004613c49565b611d3b565b3480156106f657600080fd5b506102ad610705366004613abd565b611e1b565b34801561071657600080fd5b506102ad6107253660046137da565b611ed9565b34801561073657600080fd5b5060005460405161ffff90911681526020016102eb565b34801561075957600080fd5b5060005462010000900460ff166104d6565b34801561077757600080fd5b5061078b610786366004613c67565b611fa5565b6040516102eb9190613d25565b3480156107a457600080fd5b506102ad6107b3366004613ba5565b612050565b3480156107c457600080fd5b50600054600160201b90046001600160a01b03166103fc565b3480156107e957600080fd5b506103256107f8366004613946565b6120c7565b34801561080957600080fd5b506006546001600160a01b03166103fc565b34801561082757600080fd5b506102ad6108363660046137da565b612161565b34801561084757600080fd5b50610325610856366004613946565b61221d565b34801561086757600080fd5b50610870612302565b6040516102eb9190613d38565b34801561088957600080fd5b506004546001600160a01b03166103fc565b3480156108a757600080fd5b506102ad6108b63660046137da565b612367565b3480156108c757600080fd5b5061078b604051806040016040528060058152602001640302e322e360dc1b81525081565b3480156108f857600080fd5b506102ad610907366004613d85565b612456565b3361091f6001546001600160a01b031690565b6001600160a01b03161461094e5760405162461bcd60e51b815260040161094590613dc6565b60405180910390fd5b818061ffff1661096160005461ffff1690565b61ffff16146109825760405162461bcd60e51b815260040161094590613df4565b6001600160a01b0382166109c85760405162461bcd60e51b815260206004820152600d60248201526c34b73b30b634b2103a37b5b2b760991b6044820152606401610945565b6109d18261251d565b505050565b60006109ea6004546001600160a01b031690565b9050336001600160a01b03821614610a445760405162461bcd60e51b815260206004820152601b60248201527f63616c6c6572206d7573742062652070656e64696e674f776e657200000000006044820152606401610945565b6000610a586001546001600160a01b031690565b600180546001600160a01b0319166001600160a01b0385161790559050610a7f60006126c2565b816001600160a01b0316816001600160a01b03167f0d18b5fd22306e373229b9439188228edca81207d1667f604daf6cef8aa3ee6760405160405180910390a35050565b6000610acd6126e4565b6000546301000000900460ff1615610b1b5760405162461bcd60e51b81526020600482015260116024820152701c995b185e595c881a5cc81c185d5cd959607a1b6044820152606401610945565b6000610b2f6005546001600160a01b031690565b6001600160a01b0316631a90a2196040518163ffffffff1660e01b8152600401602060405180830381865afa158015610b6c573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190610b909190613e19565b9050803414610bd65760405162461bcd60e51b8152602060048201526012602482015271696e73756666696369656e742076616c756560701b6044820152606401610945565b6000610be18961273d565b9050610bf6610bf08983610e36565b82610e70565b9750610c0289896127df565b9750610c4b6040518060c001604052808b6001600160a01b031681526020018360ff1681526020018a81526020018981526020018861ffff168152602001878152508584612815565b92505050610c596001600f55565b9695505050505050565b33610c766001546001600160a01b031690565b6001600160a01b031614610c9c5760405162461bcd60e51b815260040161094590613dc6565b818061ffff16610caf60005461ffff1690565b61ffff1614610cd05760405162461bcd60e51b815260040161094590613df4565b6000805463ff0000001916630100000084151502179055505050565b33610cff6001546001600160a01b031690565b6001600160a01b031614610d255760405162461bcd60e51b815260040161094590613dc6565b818061ffff16610d3860005461ffff1690565b61ffff1614610d595760405162461bcd60e51b815260040161094590613df4565b6001600160a01b038216610dbf5760405162461bcd60e51b815260206004820152602760248201527f6e6577466565526563697069656e742063616e6e6f7420657175616c206164646044820152667265737328302960c81b6064820152608401610945565b6000610dd36003546001600160a01b031690565b600380546001600160a01b0319166001600160a01b0386161790559050826001600160a01b0316816001600160a01b03167faaebcf1bfa00580e41d966056b48521fa9f202645c86d4ddf28113e617c1b1d360405160405180910390a350505050565b600060088260ff161115610e6757610e4f600883613e48565b610e5a90600a613f45565b610e649084613f54565b92505b50815b92915050565b600060088260ff161115610e6757610e89600883613e48565b610e9490600a613f45565b610e649084613f76565b600080546301000000900460ff1615610eed5760405162461bcd60e51b81526020600482015260116024820152701c995b185e595c881a5cc81c185d5cd959607a1b6044820152606401610945565b60005462010000900460ff16610f455760405162461bcd60e51b815260206004820181905260248201527f574554482066756e6374696f6e616c697479206e6f7420737570706f727465646044820152606401610945565b6000610f596005546001600160a01b031690565b6001600160a01b0316631a90a2196040518163ffffffff1660e01b8152600401602060405180830381865afa158015610f96573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190610fba9190613e19565b90508034116110005760405162461bcd60e51b8152602060048201526012602482015271696e73756666696369656e742076616c756560701b6044820152606401610945565b600061100c8234613f8d565b9050600061102561101e836012610e36565b6012610e70565b61102f9083613f8d565b9050801561106657604051339082156108fc029083906000818181858888f19350505050158015611064573d6000803e3d6000fd5b505b60006110728284613f8d565b905060006110906000546001600160a01b03600160201b9091041690565b9050806001600160a01b031663d0e30db0836040518263ffffffff1660e01b81526004016000604051808303818588803b1580156110cd57600080fd5b505af11580156110e1573d6000803e3d6000fd5b505050505061112e6040518060c00160405280836001600160a01b03168152602001601260ff1681526020018481526020018c81526020018b61ffff1681526020018a8152508887612815565b9a9950505050505050505050565b60008061114a836021612b3d565b90506000611159846041612b9b565b905061116860005461ffff1690565b61ffff168161ffff1614611249576006546001600160a01b0316604051630ff8f14360e11b815261ffff83166004820152602481018490526001600160a01b039190911690631ff1e28690604401602060405180830381865afa1580156111d3573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906111f79190613fa0565b92506001600160a01b0383166112445760405162461bcd60e51b81526020600482015260126024820152711d1bdad95b881b9bdd08185d1d195cdd195960721b6044820152606401610945565b611255565b61125282612bf8565b92505b5050919050565b3361126f6001546001600160a01b031690565b6001600160a01b0316146112955760405162461bcd60e51b815260040161094590613dc6565b818061ffff166112a860005461ffff1690565b61ffff16146112c95760405162461bcd60e51b815260040161094590613df4565b600082116113115760405162461bcd60e51b81526020600482015260156024820152740707265636973696f6e206d757374206265203e203605c1b6044820152606401610945565b6109d182600755565b600080600061135e85858080601f016020809104026020016040519081016040528093929190818152602001838380828437600092019190915250612c4c92505050565b925092509250600061136f84611b83565b905060006113808260600151612bf8565b9050600061139760005460ff620100009091041690565b90506001600160a01b03821633036113bf576113b584838784612f41565b5050505050505050565b60006113ca8561273d565b90506113da846020015182610e70565b6020850152600054600160201b90046001600160a01b03166001600160a01b0316856001600160a01b0316036114255761141a868486602001518561306b565b505050505050505050565b6040840151156115ed5761143d846040015182610e70565b6040850152600061144d8661221d565b9050808560400151111561146357604085018190525b6000611473878760400151611d3b565b905080156115af57803410156114cb5760405162461bcd60e51b815260206004820181905260248201527f696e73756666696369656e74206e617469766520617373657420616d6f756e746044820152606401610945565b60006114d78234613f8d565b9050801561150e57604051339082156108fc029083906000818181858888f1935050505015801561150c573d6000803e3d6000fd5b505b6040516001600160a01b0387169083156108fc029084906000818181858888f19350505050158015611544573d6000803e3d6000fd5b50876001600160a01b0316336001600160a01b0316876001600160a01b03167f764f0dc063c06f32d89a3f3af80c0db4be8a090901f589a478b447e0a51f09f18a60400151866040516115a1929190918252602082015260400190565b60405180910390a4506115ea565b6000604087015234156115ea5760405133903480156108fc02916000818181858888f193505050501580156115e8573d6000803e3d6000fd5b505b50505b6000846040015185602001516116039190613fbd565b9050801561162757611627866116216003546001600160a01b031690565b836131e1565b61163b8685611636848b613f8d565b6131e1565b50505050505050505050565b6001600160a01b0382166000908152600a6020526040812054806000036116a45760405162461bcd60e51b81526020600482015260116024820152701cddd85c081c985d19481b9bdd081cd95d607a1b6044820152606401610945565b6008546116b19082613f76565b60075461ffff87166000908152600c60205260409020546116d386600a613f45565b6116dd9190613f76565b6116e79190613f76565b6116f19190613f54565b95945050505050565b3361170d6001546001600160a01b031690565b6001600160a01b0316146117335760405162461bcd60e51b815260040161094590613dc6565b806117905760405162461bcd60e51b815260206004820152602760248201527f636f6e7472616374416464726573732063616e6e6f7420657175616c206279746044820152666573333228302960c81b6064820152608401610945565b61ffff8216158015906117ac575060005461ffff838116911614155b6118085760405162461bcd60e51b815260206004820152602760248201527f636861696e49645f2063616e6e6f7420657175616c2030206f7220746869732060448201526618da185a5b925960ca1b6064820152608401610945565b61ffff91909116600090815260096020526040902055565b5050565b336118376001546001600160a01b031690565b6001600160a01b0316148061186557503361185a6002546001600160a01b031690565b6001600160a01b0316145b6118815760405162461bcd60e51b815260040161094590613fd0565b60005461ffff1661ffff168261ffff16036118ce5760405162461bcd60e51b815260206004820152600d60248201526c34b73b30b634b21031b430b4b760991b6044820152606401610945565b61ffff82166000908152600960205260409020546119275760405162461bcd60e51b815260206004820152601660248201527518dbdb9d1c9858dd08191bd95cdb89dd08195e1a5cdd60521b6044820152606401610945565b61ffff919091166000908152600c6020526040902055565b336119526001546001600160a01b031690565b6001600160a01b031614806119805750336119756002546001600160a01b031690565b6001600160a01b0316145b61199c5760405162461bcd60e51b815260040161094590613fd0565b828061ffff166119af60005461ffff1690565b61ffff16146119d05760405162461bcd60e51b815260040161094590613df4565b8180611a135760405162461bcd60e51b8152602060048201526012602482015271696e76616c69642061727261792073697a6560701b6044820152606401610945565b60005b81811015611b3b57611a49858583818110611a3357611a33614011565b6104b89260206040909202019081019150613946565b611a655760405162461bcd60e51b815260040161094590614027565b6000858583818110611a7957611a79614011565b9050604002016020013511611ad05760405162461bcd60e51b815260206004820152601960248201527f737761702072617465206d757374206265206e6f6e7a65726f000000000000006044820152606401610945565b611b33858583818110611ae557611ae5614011565b611afb9260206040909202019081019150613946565b868684818110611b0d57611b0d614011565b905060400201602001356001600160a01b039091166000908152600a6020526040902055565b600101611a16565b508383604051611b4c929190614053565b604051908190038120907f7abf49a6ebb116bc314846377cd82a3d2c8c1ea48149a652356009fc37100dd790600090a25050505050565b604080516080810182526000808252602082018190529181018290526060810182905290611bb18382613244565b60ff168252611bc1600182613fbd565b9050816000015160ff16600114611c0e5760405162461bcd60e51b81526020600482015260116024820152701a5b9d985b1a59081c185e5b1bd8591259607a1b6044820152606401610945565b611c1883826132a0565b602080840191909152611c2b9082613fbd565b9050611c3783826132a0565b6040830152611c47602082613fbd565b9050611c538382612b3d565b6060830152611c63602082613fbd565b905082518114611cae5760405162461bcd60e51b81526020600482015260166024820152750d2dcecc2d8d2c840dacae6e6c2ceca40d8cadccee8d60531b6044820152606401610945565b50919050565b33611cc76001546001600160a01b031690565b6001600160a01b031614611ced5760405162461bcd60e51b815260040161094590613dc6565b818061ffff16611d0060005461ffff1690565b61ffff1614611d215760405162461bcd60e51b815260040161094590613df4565b6000805462ff000019166201000084151502179055505050565b600080611d478461273d565b90506000611d6d611d686000546001600160a01b03600160201b9091041690565b61273d565b90508060ff168260ff161115611dca57611d878183613e48565b611d9290600a613f45565b611d9b866120c7565b611da59190613f76565b84611daf60075490565b611db99190613f76565b611dc39190613f54565b9250611e13565b611dd3856120c7565b611ddd8383613e48565b611de890600a613f45565b85611df260075490565b611dfc9190613f76565b611e069190613f76565b611e109190613f54565b92505b505092915050565b33611e2e6001546001600160a01b031690565b6001600160a01b031614611e545760405162461bcd60e51b815260040161094590613dc6565b818061ffff16611e6760005461ffff1690565b61ffff1614611e885760405162461bcd60e51b815260040161094590613df4565b60008211611ed05760405162461bcd60e51b81526020600482015260156024820152740707265636973696f6e206d757374206265203e203605c1b6044820152606401610945565b6109d182600855565b33611eec6001546001600160a01b031690565b6001600160a01b031614611f125760405162461bcd60e51b815260040161094590613dc6565b818061ffff16611f2560005461ffff1690565b61ffff1614611f465760405162461bcd60e51b815260040161094590613df4565b6001600160a01b038216611f9c5760405162461bcd60e51b815260206004820181905260248201527f6e65774f776e65722063616e6e6f7420657175616c20616464726573732830296044820152606401610945565b6109d1826126c2565b6060816000015160ff16600114611ff25760405162461bcd60e51b81526020600482015260116024820152701a5b9d985b1a59081c185e5b1bd8591259607a1b6044820152606401610945565b81516020808401516040808601516060870151915161203a95949192910160f89490941b6001600160f81b031916845260018401929092526021830152604182015260610190565b6040516020818303038152906040529050919050565b336120636001546001600160a01b031690565b6001600160a01b0316146120895760405162461bcd60e51b815260040161094590613dc6565b808061ffff1661209c60005461ffff1690565b61ffff16146120bd5760405162461bcd60e51b815260040161094590613df4565b61182060006126c2565b600080546001600160a01b03600160201b90910481168252600a60205260408083205491841683528220546000821180156121025750600081115b6121425760405162461bcd60e51b81526020600482015260116024820152701cddd85c081c985d19481b9bdd081cd95d607a1b6044820152606401610945565b808261214d60075490565b6121579190613f76565b6112529190613f54565b336121746001546001600160a01b031690565b6001600160a01b03161461219a5760405162461bcd60e51b815260040161094590613dc6565b818061ffff166121ad60005461ffff1690565b61ffff16146121ce5760405162461bcd60e51b815260040161094590613df4565b6001600160a01b0382166122145760405162461bcd60e51b815260206004820152600d60248201526c34b73b30b634b2103a37b5b2b760991b6044820152606401610945565b6109d1826132f5565b6000806122298361273d565b9050600061224a611d686000546001600160a01b03600160201b9091041690565b90508060ff168260ff1611156122b9576007546122678284613e48565b61227290600a613f45565b61227b866120c7565b6001600160a01b0387166000908152600b602052604090205461229e9190613f76565b6122a89190613f76565b6122b29190613f54565b9250611255565b6007546122c68383613e48565b6122d190600a613f45565b6122db9190613f76565b6122e4856120c7565b6001600160a01b0386166000908152600b602052604090205461214d565b60606000600e0180548060200260200160405190810160405280929190818152602001828054801561235d57602002820191906000526020600020905b81546001600160a01b0316815260019091019060200180831161233f575b5050505050905090565b3361237a6001546001600160a01b031690565b6001600160a01b0316146123a05760405162461bcd60e51b815260040161094590613dc6565b818061ffff166123b360005461ffff1690565b61ffff16146123d45760405162461bcd60e51b815260040161094590613df4565b6001600160a01b0382166124365760405162461bcd60e51b8152602060048201526024808201527f6e6577417373697374616e742063616e6e6f7420657175616c206164647265736044820152637328302960e01b6064820152608401610945565b600280546001600160a01b0319166001600160a01b038416179055505050565b336124696001546001600160a01b031690565b6001600160a01b03161461248f5760405162461bcd60e51b815260040161094590613dc6565b828061ffff166124a260005461ffff1690565b61ffff16146124c35760405162461bcd60e51b815260040161094590613df4565b6001600160a01b0383166000908152600d602052604090205460ff166124fb5760405162461bcd60e51b815260040161094590614027565b6001600160a01b0383166000908152600b602052604090208290555b50505050565b6001600160a01b0381166000908152600d602052604090205460ff1661257c5760405162461bcd60e51b81526020600482015260146024820152731d1bdad95b881b9bdd081c9959da5cdd195c995960621b6044820152606401610945565b6001600160a01b0381166000908152600d60209081526040808320805460ff19169055600a8252808320839055600b9091528120819055600e54905b8181101561260257826001600160a01b03166000600e0182815481106125e0576125e0614011565b6000918252602090912001546001600160a01b031614612602576001016125b8565b8181146109d157600182111561268a57600e61261f600184613f8d565b8154811061262f5761262f614011565b600091825260209091200154600e80546001600160a01b03909216918390811061265b5761265b614011565b9060005260206000200160006101000a8154816001600160a01b0302191690836001600160a01b031602179055505b600e80548061269b5761269b61409e565b600082815260209020810160001990810180546001600160a01b0319169055019055505050565b600480546001600160a01b0319166001600160a01b0392909216919091179055565b6002600f54036127365760405162461bcd60e51b815260206004820152601f60248201527f5265656e7472616e637947756172643a207265656e7472616e742063616c6c006044820152606401610945565b6002600f55565b60408051600481526024810182526020810180516001600160e01b031663313ce56760e01b179052905160009182916001600160a01b03851691612780916140b4565b600060405180830381855afa9150503d80600081146127bb576040519150601f19603f3d011682016040523d82523d6000602084013e6127c0565b606091505b50915050808060200190518101906127d891906140e0565b9392505050565b6000806127eb846133c4565b90506127f984333086613470565b80612803856133c4565b61280d9190613f8d565b949350505050565b82516001600160a01b03166000908152600d602052604081205460ff1661284e5760405162461bcd60e51b815260040161094590614027565b60a08401516128ab5760405162461bcd60e51b8152602060048201526024808201527f746172676574526563697069656e742063616e6e6f74206265206279746573336044820152633228302960e01b6064820152608401610945565b60006128bf85604001518660200151610e36565b9050600081116129115760405162461bcd60e51b815260206004820152601d60248201527f6e6f726d616c697a656420616d6f756e74206d757374206265203e20300000006044820152606401610945565b600061292586606001518760200151610e36565b905085606001516000148061293a5750600081115b6129865760405162461bcd60e51b815260206004820152601b60248201527f696e76616c696420746f4e6174697665546f6b656e416d6f756e7400000000006044820152606401610945565b608086015161ffff16600090815260096020526040902054806129e35760405162461bcd60e51b81526020600482015260156024820152741d185c99d95d081b9bdd081c9959da5cdd195c9959605a1b6044820152606401610945565b6000612a096129ff89608001518a600001518b60200151611647565b8960200151610e36565b9050612a158382613fbd565b8411612a595760405162461bcd60e51b81526020600482015260136024820152721a5b9cdd59999a58da595b9d08185b5bdd5b9d606a1b6044820152606401610945565b6000612a8c6040518060800160405280600160ff1681526020018481526020018681526020018b60a00151815250611fa5565b90506000612aa26006546001600160a01b031690565b9050612ab78a60000151828c604001516134a8565b806001600160a01b031663c5a5ebda898c600001518d604001518e60800151898f896040518863ffffffff1660e01b8152600401612afa969594939291906140fd565b60206040518083038185885af1158015612b18573d6000803e3d6000fd5b50505050506040513d601f19601f8201168201806040525081019061112e9190614163565b6000612b4a826020613fbd565b83511015612b925760405162461bcd60e51b8152602060048201526015602482015274746f427974657333325f6f75744f66426f756e647360581b6044820152606401610945565b50016020015190565b6000612ba8826002613fbd565b83511015612bef5760405162461bcd60e51b8152602060048201526014602482015273746f55696e7431365f6f75744f66426f756e647360601b6044820152606401610945565b50016002015190565b60006001600160a01b0319821615612c485760405162461bcd60e51b8152602060048201526013602482015272696e76616c69642045564d206164647265737360681b6044820152606401610945565b5090565b60606000806000612c656005546001600160a01b031690565b6001600160a01b031663a9e11893866040518263ffffffff1660e01b8152600401612c909190613d25565b600060405180830381865afa158015612cad573d6000803e3d6000fd5b505050506040513d6000823e601f3d908101601f19168201604052612cd591908101906142a2565b90506000612ce68260e0015161113c565b9050612d0a816001600160a01b03166000908152600d602052604090205460ff1690565b612d4d5760405162461bcd60e51b81526020600482015260146024820152731d1bdad95b881b9bdd081c9959da5cdd195c995960621b6044820152606401610945565b6000612d58826133c4565b90506000612d6e6006546001600160a01b031690565b90506000816001600160a01b031663c3f511c18a6040518263ffffffff1660e01b8152600401612d9e9190613d25565b6000604051808303816000875af1158015612dbd573d6000803e3d6000fd5b505050506040513d6000823e601f3d908101601f19168201604052612de591908101906143c6565b9050600083612df3866133c4565b612dfd9190613f8d565b90506000836001600160a01b031663ea63738d846040518263ffffffff1660e01b8152600401612e2d9190613d25565b600060405180830381865afa158015612e4a573d6000803e3d6000fd5b505050506040513d6000823e601f3d908101601f19168201604052612e7291908101906143fa565b9050612e92876060015161ffff1660009081526009602052604090205490565b8160c0015114612ee45760405162461bcd60e51b815260206004820152601760248201527f636f6e7472616374206e6f7420726567697374657265640000000000000000006044820152606401610945565b8660a001516001600160401b03168760800151886060015161ffff167fcaf280c8cfeba144da67230d9b009c8f868a75bac9a528fa0474be1ba317c16960405160405180910390a460e001519a9099509397509295505050505050565b3415612f9b5760405162461bcd60e51b815260206004820152602360248201527f726563697069656e742063616e6e6f742073776170206e61746976652061737360448201526265747360e81b6064820152608401610945565b6000546001600160a01b03600160201b909104811690851681148015612fbe5750815b1561305957604051632e1a7d4d60e01b8152600481018490526001600160a01b03821690632e1a7d4d90602401600060405180830381600087803b15801561300557600080fd5b505af1158015613019573d6000803e3d6000fd5b50506040516001600160a01b038716925085156108fc02915085906000818181858888f19350505050158015613053573d6000803e3d6000fd5b50613064565b6130648585856131e1565b5050505050565b34156130ae5760405162461bcd60e51b815260206004820152601260248201527176616c7565206d757374206265207a65726f60701b6044820152606401610945565b80156131a157600054604051632e1a7d4d60e01b815260048101869052600160201b9091046001600160a01b031690632e1a7d4d90602401600060405180830381600087803b15801561310057600080fd5b505af1158015613114573d6000803e3d6000fd5b50505050826001600160a01b03166108fc83866131319190613f8d565b6040518115909202916000818181858888f19350505050158015613159573d6000803e3d6000fd5b50811561319c576003546040516001600160a01b039091169083156108fc029084906000818181858888f1935050505015801561319a573d6000803e3d6000fd5b505b612517565b600054600160201b90046001600160a01b03166131c381856116368689613f8d565b821561306457613064816131df6003546001600160a01b031690565b855b6040516001600160a01b0383166024820152604481018290526109d190849063a9059cbb60e01b906064015b60408051601f198184030181529190526020810180516001600160e01b03166001600160e01b0319909316929092179091526135bd565b6000613251826001613fbd565b835110156132975760405162461bcd60e51b8152602060048201526013602482015272746f55696e74385f6f75744f66426f756e647360681b6044820152606401610945565b50016001015190565b60006132ad826020613fbd565b83511015612b925760405162461bcd60e51b8152602060048201526015602482015274746f55696e743235365f6f75744f66426f756e647360581b6044820152606401610945565b6001600160a01b0381166000908152600d602052604090205460ff161561335e5760405162461bcd60e51b815260206004820152601860248201527f746f6b656e20616c7265616479207265676973746572656400000000000000006044820152606401610945565b6001600160a01b03166000818152600d60205260408120805460ff19166001908117909155600e805491820181559091527fbb7b4a454dc3493923482f07822329ed19e8244eff582cc204f8554c3620c3fd0180546001600160a01b0319169091179055565b604080513060248083019190915282518083039091018152604490910182526020810180516001600160e01b03166370a0823160e01b179052905160009182916001600160a01b03851691613418916140b4565b600060405180830381855afa9150503d8060008114613453576040519150601f19603f3d011682016040523d82523d6000602084013e613458565b606091505b50915050808060200190518101906127d89190613e19565b6040516001600160a01b03808516602483015283166044820152606481018290526125179085906323b872dd60e01b9060840161320d565b8015806135225750604051636eb1769f60e11b81523060048201526001600160a01b03838116602483015284169063dd62ed3e90604401602060405180830381865afa1580156134fc573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906135209190613e19565b155b61358d5760405162461bcd60e51b815260206004820152603660248201527f5361666545524332303a20617070726f76652066726f6d206e6f6e2d7a65726f60448201527520746f206e6f6e2d7a65726f20616c6c6f77616e636560501b6064820152608401610945565b6040516001600160a01b0383166024820152604481018290526109d190849063095ea7b360e01b9060640161320d565b6000613612826040518060400160405280602081526020017f5361666545524332303a206c6f772d6c6576656c2063616c6c206661696c6564815250856001600160a01b031661368f9092919063ffffffff16565b8051909150156109d1578080602001905181019061363091906144c2565b6109d15760405162461bcd60e51b815260206004820152602a60248201527f5361666545524332303a204552433230206f7065726174696f6e20646964206e6044820152691bdd081cdd58d8d9595960b21b6064820152608401610945565b606061280d848460008585600080866001600160a01b031685876040516136b691906140b4565b60006040518083038185875af1925050503d80600081146136f3576040519150601f19603f3d011682016040523d82523d6000602084013e6136f8565b606091505b509150915061370987838387613714565b979650505050505050565b6060831561378357825160000361377c576001600160a01b0385163b61377c5760405162461bcd60e51b815260206004820152601d60248201527f416464726573733a2063616c6c20746f206e6f6e2d636f6e74726163740000006044820152606401610945565b508161280d565b61280d83838151156137985781518083602001fd5b8060405162461bcd60e51b81526004016109459190613d25565b61ffff811681146137c257600080fd5b50565b6001600160a01b03811681146137c257600080fd5b600080604083850312156137ed57600080fd5b82356137f8816137b2565b91506020830135613808816137c5565b809150509250929050565b63ffffffff811681146137c257600080fd5b60008060008060008060c0878903121561383e57600080fd5b8635613849816137c5565b955060208701359450604087013593506060870135613867816137b2565b92506080870135915060a087013561387e81613813565b809150509295509295509295565b80151581146137c257600080fd5b600080604083850312156138ad57600080fd5b82356138b8816137b2565b915060208301356138088161388c565b60ff811681146137c257600080fd5b600080604083850312156138ea57600080fd5b823591506020830135613808816138c8565b6000806000806080858703121561391257600080fd5b843593506020850135613924816137b2565b925060408501359150606085013561393b81613813565b939692955090935050565b60006020828403121561395857600080fd5b81356127d8816137c5565b634e487b7160e01b600052604160045260246000fd5b604051608081016001600160401b038111828210171561399b5761399b613963565b60405290565b60405161016081016001600160401b038111828210171561399b5761399b613963565b60405161010081016001600160401b038111828210171561399b5761399b613963565b604051601f8201601f191681016001600160401b0381118282101715613a0f57613a0f613963565b604052919050565b60006001600160401b03821115613a3057613a30613963565b50601f01601f191660200190565b600060208284031215613a5057600080fd5b81356001600160401b03811115613a6657600080fd5b8201601f81018413613a7757600080fd5b8035613a8a613a8582613a17565b6139e7565b818152856020838501011115613a9f57600080fd5b81602084016020830137600091810160200191909152949350505050565b60008060408385031215613ad057600080fd5b8235613adb816137b2565b946020939093013593505050565b60008060208385031215613afc57600080fd5b82356001600160401b0380821115613b1357600080fd5b818501915085601f830112613b2757600080fd5b813581811115613b3657600080fd5b866020828501011115613b4857600080fd5b60209290920196919550909350505050565b600080600060608486031215613b6f57600080fd5b8335613b7a816137b2565b92506020840135613b8a816137c5565b91506040840135613b9a816138c8565b809150509250925092565b600060208284031215613bb757600080fd5b81356127d8816137b2565b600080600060408486031215613bd757600080fd5b8335613be2816137b2565b925060208401356001600160401b0380821115613bfe57600080fd5b818601915086601f830112613c1257600080fd5b813581811115613c2157600080fd5b8760208260061b8501011115613c3657600080fd5b6020830194508093505050509250925092565b60008060408385031215613c5c57600080fd5b8235613adb816137c5565b600060808284031215613c7957600080fd5b604051608081018181106001600160401b0382111715613c9b57613c9b613963565b6040528235613ca9816138c8565b808252506020830135602082015260408301356040820152606083013560608201528091505092915050565b60005b83811015613cf0578181015183820152602001613cd8565b50506000910152565b60008151808452613d11816020860160208601613cd5565b601f01601f19169290920160200192915050565b6020815260006127d86020830184613cf9565b6020808252825182820181905260009190848201906040850190845b81811015613d795783516001600160a01b031683529284019291840191600101613d54565b50909695505050505050565b600080600060608486031215613d9a57600080fd5b8335613da5816137b2565b92506020840135613db5816137c5565b929592945050506040919091013590565b60208082526014908201527331b0b63632b9103737ba103a34329037bbb732b960611b604082015260600190565b6020808252600b908201526a3bb937b7339031b430b4b760a91b604082015260600190565b600060208284031215613e2b57600080fd5b5051919050565b634e487b7160e01b600052601160045260246000fd5b60ff8281168282160390811115610e6a57610e6a613e32565b600181815b80851115613e9c578160001904821115613e8257613e82613e32565b80851615613e8f57918102915b93841c9390800290613e66565b509250929050565b600082613eb357506001610e6a565b81613ec057506000610e6a565b8160018114613ed65760028114613ee057613efc565b6001915050610e6a565b60ff841115613ef157613ef1613e32565b50506001821b610e6a565b5060208310610133831016604e8410600b8410161715613f1f575081810a610e6a565b613f298383613e61565b8060001904821115613f3d57613f3d613e32565b029392505050565b60006127d860ff841683613ea4565b600082613f7157634e487b7160e01b600052601260045260246000fd5b500490565b8082028115828204841417610e6a57610e6a613e32565b81810381811115610e6a57610e6a613e32565b600060208284031215613fb257600080fd5b81516127d8816137c5565b80820180821115610e6a57610e6a613e32565b60208082526021908201527f63616c6c6572206e6f7420746865206f776e6572206f7220617373697374616e6040820152601d60fa1b606082015260800190565b634e487b7160e01b600052603260045260246000fd5b6020808252601290820152711d1bdad95b881b9bdd081858d8d95c1d195960721b604082015260600190565b60008184825b8581101561409357813561406c816137c5565b6001600160a01b031683526020828101359084015260409283019290910190600101614059565b509095945050505050565b634e487b7160e01b600052603160045260246000fd5b600082516140c6818460208701613cd5565b9190910192915050565b80516140db816138c8565b919050565b6000602082840312156140f257600080fd5b81516127d8816138c8565b60018060a01b038716815285602082015261ffff8516604082015283606082015263ffffffff8316608082015260c060a0820152600061414060c0830184613cf9565b98975050505050505050565b80516001600160401b03811681146140db57600080fd5b60006020828403121561417557600080fd5b6127d88261414c565b80516140db81613813565b80516140db816137b2565b600082601f8301126141a557600080fd5b81516141b3613a8582613a17565b8181528460208386010111156141c857600080fd5b61280d826020830160208701613cd5565b600082601f8301126141ea57600080fd5b815160206001600160401b0382111561420557614205613963565b614213818360051b016139e7565b82815260079290921b8401810191818101908684111561423257600080fd5b8286015b84811015614297576080818903121561424f5760008081fd5b614257613979565b815181528482015185820152604080830151614272816138c8565b90820152606082810151614285816138c8565b90820152835291830191608001614236565b509695505050505050565b6000602082840312156142b457600080fd5b81516001600160401b03808211156142cb57600080fd5b9083019061016082860312156142e057600080fd5b6142e86139a1565b6142f1836140d0565b81526142ff6020840161417e565b60208201526143106040840161417e565b604082015261432160608401614189565b60608201526080830151608082015261433c60a0840161414c565b60a082015261434d60c084016140d0565b60c082015260e08301518281111561436457600080fd5b61437087828601614194565b60e08301525061010061438481850161417e565b90820152610120838101518381111561439c57600080fd5b6143a8888287016141d9565b91830191909152506101409283015192810192909252509392505050565b6000602082840312156143d857600080fd5b81516001600160401b038111156143ee57600080fd5b61280d84828501614194565b60006020828403121561440c57600080fd5b81516001600160401b038082111561442357600080fd5b90830190610100828603121561443857600080fd5b6144406139c4565b614449836140d0565b8152602083015160208201526040830151604082015261446b60608401614189565b60608201526080830151608082015261448660a08401614189565b60a082015260c083015160c082015260e0830151828111156144a757600080fd5b6144b387828601614194565b60e08301525095945050505050565b6000602082840312156144d457600080fd5b81516127d88161388c56fea26469706673582212204380a2c16f3d3a94e16ceec8dd417389a415486e9286774f1ba51d1e17ea374064736f6c634300081100330000000000000000000000000b2402144bb366a632d14b83f244d2e0e21bd39c000000000000000000000000d8369c2eda18dd6518eabb1f85bd60606deb39ec00000000000000000000000053207e216540125e322cda8a693b0b89576deb460000000000000000000000001c00662dbb69366d68496584e5f5668a0b8d265e0000000000000000000000000000000000000000000000000000000000000000

0x6080604052600436106102815760003560e01c80636805b84b1161014f5780639fe089ad116100c1578063cd601c781161007a578063cd601c781461083b578063df160d761461085b578063e30c39781461087d578063ea1d2e4a1461089b578063ffa1ad74146108bb578063fff982a8146108ec57600080fd5b80639fe089ad1461076b578063a2f32c8f14610798578063ad5c4648146107b8578063b5419523146107dd578063c6328a46146107fd578063c9c22f9f1461081b57600080fd5b80638da5cb5b116101135780638da5cb5b146106ac5780638e151dd1146106ca57806390a1afaa146106ea57806394cc743d1461070a5780639a8a05921461072a5780639cf278cd1461074d57600080fd5b80636805b84b146105db57806368aa9ef4146105fa5780637c9dec7a146106185780638335572f1461066e57806384acd1bb1461068e57600080fd5b80632def3e16116101f3578063415828bf116101ac578063415828bf14610517578063469048401461052c57806351e2d7b51461054a5780635b9cf0e11461056a578063640d946b1461058a57806366775a6b146105aa57600080fd5b80632def3e16146104145780632efe4f42146104345780632f25e25f1461046a57806339ba66111461047d5780633b6e750f1461049d5780633d62cca0146104e657600080fd5b8063203c509511610245578063203c50951461033357806327105ab91461035357806328ded8e31461037357806329ac8361146103935780632ca8008c146103a65780632d77e8fe146103dc57600080fd5b8063016aa2051461028d578063038c0b66146102af5780631019d654146102c45780631a282195146102f45780631acdab4b1461031457600080fd5b3661028857005b600080fd5b34801561029957600080fd5b506102ad6102a83660046137da565b61090c565b005b3480156102bb57600080fd5b506102ad6109d6565b6102d76102d2366004613825565b610ac3565b6040516001600160401b0390911681526020015b60405180910390f35b34801561030057600080fd5b506102ad61030f36600461389a565b610c63565b34801561032057600080fd5b506007545b6040519081526020016102eb565b34801561033f57600080fd5b506102ad61034e3660046137da565b610cec565b34801561035f57600080fd5b5061032561036e3660046138d7565b610e36565b34801561037f57600080fd5b5061032561038e3660046138d7565b610e70565b6102d76103a13660046138fc565b610e9e565b3480156103b257600080fd5b506103256103c1366004613946565b6001600160a01b03166000908152600a602052604090205490565b3480156103e857600080fd5b506103fc6103f7366004613a3e565b61113c565b6040516001600160a01b0390911681526020016102eb565b34801561042057600080fd5b506102ad61042f366004613abd565b61125c565b34801561044057600080fd5b5061032561044f366004613946565b6001600160a01b03166000908152600b602052604090205490565b6102ad610478366004613ae9565b61131a565b34801561048957600080fd5b50610325610498366004613b5a565b611647565b3480156104a957600080fd5b506104d66104b8366004613946565b6001600160a01b03166000908152600d602052604090205460ff1690565b60405190151581526020016102eb565b3480156104f257600080fd5b50610325610501366004613ba5565b61ffff1660009081526009602052604090205490565b34801561052357600080fd5b50600854610325565b34801561053857600080fd5b506003546001600160a01b03166103fc565b34801561055657600080fd5b506102ad610565366004613abd565b6116fa565b34801561057657600080fd5b506102ad610585366004613abd565b611824565b34801561059657600080fd5b506102ad6105a5366004613bc2565b61193f565b3480156105b657600080fd5b506103256105c5366004613ba5565b61ffff166000908152600c602052604090205490565b3480156105e757600080fd5b506000546301000000900460ff166104d6565b34801561060657600080fd5b506002546001600160a01b03166103fc565b34801561062457600080fd5b50610638610633366004613a3e565b611b83565b6040516102eb9190815160ff16815260208083015190820152604080830151908201526060918201519181019190915260800190565b34801561067a57600080fd5b506102ad61068936600461389a565b611cb4565b34801561069a57600080fd5b506005546001600160a01b03166103fc565b3480156106b857600080fd5b506001546001600160a01b03166103fc565b3480156106d657600080fd5b506103256106e5366004613c49565b611d3b565b3480156106f657600080fd5b506102ad610705366004613abd565b611e1b565b34801561071657600080fd5b506102ad6107253660046137da565b611ed9565b34801561073657600080fd5b5060005460405161ffff90911681526020016102eb565b34801561075957600080fd5b5060005462010000900460ff166104d6565b34801561077757600080fd5b5061078b610786366004613c67565b611fa5565b6040516102eb9190613d25565b3480156107a457600080fd5b506102ad6107b3366004613ba5565b612050565b3480156107c457600080fd5b50600054600160201b90046001600160a01b03166103fc565b3480156107e957600080fd5b506103256107f8366004613946565b6120c7565b34801561080957600080fd5b506006546001600160a01b03166103fc565b34801561082757600080fd5b506102ad6108363660046137da565b612161565b34801561084757600080fd5b50610325610856366004613946565b61221d565b34801561086757600080fd5b50610870612302565b6040516102eb9190613d38565b34801561088957600080fd5b506004546001600160a01b03166103fc565b3480156108a757600080fd5b506102ad6108b63660046137da565b612367565b3480156108c757600080fd5b5061078b604051806040016040528060058152602001640302e322e360dc1b81525081565b3480156108f857600080fd5b506102ad610907366004613d85565b612456565b3361091f6001546001600160a01b031690565b6001600160a01b03161461094e5760405162461bcd60e51b815260040161094590613dc6565b60405180910390fd5b818061ffff1661096160005461ffff1690565b61ffff16146109825760405162461bcd60e51b815260040161094590613df4565b6001600160a01b0382166109c85760405162461bcd60e51b815260206004820152600d60248201526c34b73b30b634b2103a37b5b2b760991b6044820152606401610945565b6109d18261251d565b505050565b60006109ea6004546001600160a01b031690565b9050336001600160a01b03821614610a445760405162461bcd60e51b815260206004820152601b60248201527f63616c6c6572206d7573742062652070656e64696e674f776e657200000000006044820152606401610945565b6000610a586001546001600160a01b031690565b600180546001600160a01b0319166001600160a01b0385161790559050610a7f60006126c2565b816001600160a01b0316816001600160a01b03167f0d18b5fd22306e373229b9439188228edca81207d1667f604daf6cef8aa3ee6760405160405180910390a35050565b6000610acd6126e4565b6000546301000000900460ff1615610b1b5760405162461bcd60e51b81526020600482015260116024820152701c995b185e595c881a5cc81c185d5cd959607a1b6044820152606401610945565b6000610b2f6005546001600160a01b031690565b6001600160a01b0316631a90a2196040518163ffffffff1660e01b8152600401602060405180830381865afa158015610b6c573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190610b909190613e19565b9050803414610bd65760405162461bcd60e51b8152602060048201526012602482015271696e73756666696369656e742076616c756560701b6044820152606401610945565b6000610be18961273d565b9050610bf6610bf08983610e36565b82610e70565b9750610c0289896127df565b9750610c4b6040518060c001604052808b6001600160a01b031681526020018360ff1681526020018a81526020018981526020018861ffff168152602001878152508584612815565b92505050610c596001600f55565b9695505050505050565b33610c766001546001600160a01b031690565b6001600160a01b031614610c9c5760405162461bcd60e51b815260040161094590613dc6565b818061ffff16610caf60005461ffff1690565b61ffff1614610cd05760405162461bcd60e51b815260040161094590613df4565b6000805463ff0000001916630100000084151502179055505050565b33610cff6001546001600160a01b031690565b6001600160a01b031614610d255760405162461bcd60e51b815260040161094590613dc6565b818061ffff16610d3860005461ffff1690565b61ffff1614610d595760405162461bcd60e51b815260040161094590613df4565b6001600160a01b038216610dbf5760405162461bcd60e51b815260206004820152602760248201527f6e6577466565526563697069656e742063616e6e6f7420657175616c206164646044820152667265737328302960c81b6064820152608401610945565b6000610dd36003546001600160a01b031690565b600380546001600160a01b0319166001600160a01b0386161790559050826001600160a01b0316816001600160a01b03167faaebcf1bfa00580e41d966056b48521fa9f202645c86d4ddf28113e617c1b1d360405160405180910390a350505050565b600060088260ff161115610e6757610e4f600883613e48565b610e5a90600a613f45565b610e649084613f54565b92505b50815b92915050565b600060088260ff161115610e6757610e89600883613e48565b610e9490600a613f45565b610e649084613f76565b600080546301000000900460ff1615610eed5760405162461bcd60e51b81526020600482015260116024820152701c995b185e595c881a5cc81c185d5cd959607a1b6044820152606401610945565b60005462010000900460ff16610f455760405162461bcd60e51b815260206004820181905260248201527f574554482066756e6374696f6e616c697479206e6f7420737570706f727465646044820152606401610945565b6000610f596005546001600160a01b031690565b6001600160a01b0316631a90a2196040518163ffffffff1660e01b8152600401602060405180830381865afa158015610f96573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190610fba9190613e19565b90508034116110005760405162461bcd60e51b8152602060048201526012602482015271696e73756666696369656e742076616c756560701b6044820152606401610945565b600061100c8234613f8d565b9050600061102561101e836012610e36565b6012610e70565b61102f9083613f8d565b9050801561106657604051339082156108fc029083906000818181858888f19350505050158015611064573d6000803e3d6000fd5b505b60006110728284613f8d565b905060006110906000546001600160a01b03600160201b9091041690565b9050806001600160a01b031663d0e30db0836040518263ffffffff1660e01b81526004016000604051808303818588803b1580156110cd57600080fd5b505af11580156110e1573d6000803e3d6000fd5b505050505061112e6040518060c00160405280836001600160a01b03168152602001601260ff1681526020018481526020018c81526020018b61ffff1681526020018a8152508887612815565b9a9950505050505050505050565b60008061114a836021612b3d565b90506000611159846041612b9b565b905061116860005461ffff1690565b61ffff168161ffff1614611249576006546001600160a01b0316604051630ff8f14360e11b815261ffff83166004820152602481018490526001600160a01b039190911690631ff1e28690604401602060405180830381865afa1580156111d3573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906111f79190613fa0565b92506001600160a01b0383166112445760405162461bcd60e51b81526020600482015260126024820152711d1bdad95b881b9bdd08185d1d195cdd195960721b6044820152606401610945565b611255565b61125282612bf8565b92505b5050919050565b3361126f6001546001600160a01b031690565b6001600160a01b0316146112955760405162461bcd60e51b815260040161094590613dc6565b818061ffff166112a860005461ffff1690565b61ffff16146112c95760405162461bcd60e51b815260040161094590613df4565b600082116113115760405162461bcd60e51b81526020600482015260156024820152740707265636973696f6e206d757374206265203e203605c1b6044820152606401610945565b6109d182600755565b600080600061135e85858080601f016020809104026020016040519081016040528093929190818152602001838380828437600092019190915250612c4c92505050565b925092509250600061136f84611b83565b905060006113808260600151612bf8565b9050600061139760005460ff620100009091041690565b90506001600160a01b03821633036113bf576113b584838784612f41565b5050505050505050565b60006113ca8561273d565b90506113da846020015182610e70565b6020850152600054600160201b90046001600160a01b03166001600160a01b0316856001600160a01b0316036114255761141a868486602001518561306b565b505050505050505050565b6040840151156115ed5761143d846040015182610e70565b6040850152600061144d8661221d565b9050808560400151111561146357604085018190525b6000611473878760400151611d3b565b905080156115af57803410156114cb5760405162461bcd60e51b815260206004820181905260248201527f696e73756666696369656e74206e617469766520617373657420616d6f756e746044820152606401610945565b60006114d78234613f8d565b9050801561150e57604051339082156108fc029083906000818181858888f1935050505015801561150c573d6000803e3d6000fd5b505b6040516001600160a01b0387169083156108fc029084906000818181858888f19350505050158015611544573d6000803e3d6000fd5b50876001600160a01b0316336001600160a01b0316876001600160a01b03167f764f0dc063c06f32d89a3f3af80c0db4be8a090901f589a478b447e0a51f09f18a60400151866040516115a1929190918252602082015260400190565b60405180910390a4506115ea565b6000604087015234156115ea5760405133903480156108fc02916000818181858888f193505050501580156115e8573d6000803e3d6000fd5b505b50505b6000846040015185602001516116039190613fbd565b9050801561162757611627866116216003546001600160a01b031690565b836131e1565b61163b8685611636848b613f8d565b6131e1565b50505050505050505050565b6001600160a01b0382166000908152600a6020526040812054806000036116a45760405162461bcd60e51b81526020600482015260116024820152701cddd85c081c985d19481b9bdd081cd95d607a1b6044820152606401610945565b6008546116b19082613f76565b60075461ffff87166000908152600c60205260409020546116d386600a613f45565b6116dd9190613f76565b6116e79190613f76565b6116f19190613f54565b95945050505050565b3361170d6001546001600160a01b031690565b6001600160a01b0316146117335760405162461bcd60e51b815260040161094590613dc6565b806117905760405162461bcd60e51b815260206004820152602760248201527f636f6e7472616374416464726573732063616e6e6f7420657175616c206279746044820152666573333228302960c81b6064820152608401610945565b61ffff8216158015906117ac575060005461ffff838116911614155b6118085760405162461bcd60e51b815260206004820152602760248201527f636861696e49645f2063616e6e6f7420657175616c2030206f7220746869732060448201526618da185a5b925960ca1b6064820152608401610945565b61ffff91909116600090815260096020526040902055565b5050565b336118376001546001600160a01b031690565b6001600160a01b0316148061186557503361185a6002546001600160a01b031690565b6001600160a01b0316145b6118815760405162461bcd60e51b815260040161094590613fd0565b60005461ffff1661ffff168261ffff16036118ce5760405162461bcd60e51b815260206004820152600d60248201526c34b73b30b634b21031b430b4b760991b6044820152606401610945565b61ffff82166000908152600960205260409020546119275760405162461bcd60e51b815260206004820152601660248201527518dbdb9d1c9858dd08191bd95cdb89dd08195e1a5cdd60521b6044820152606401610945565b61ffff919091166000908152600c6020526040902055565b336119526001546001600160a01b031690565b6001600160a01b031614806119805750336119756002546001600160a01b031690565b6001600160a01b0316145b61199c5760405162461bcd60e51b815260040161094590613fd0565b828061ffff166119af60005461ffff1690565b61ffff16146119d05760405162461bcd60e51b815260040161094590613df4565b8180611a135760405162461bcd60e51b8152602060048201526012602482015271696e76616c69642061727261792073697a6560701b6044820152606401610945565b60005b81811015611b3b57611a49858583818110611a3357611a33614011565b6104b89260206040909202019081019150613946565b611a655760405162461bcd60e51b815260040161094590614027565b6000858583818110611a7957611a79614011565b9050604002016020013511611ad05760405162461bcd60e51b815260206004820152601960248201527f737761702072617465206d757374206265206e6f6e7a65726f000000000000006044820152606401610945565b611b33858583818110611ae557611ae5614011565b611afb9260206040909202019081019150613946565b868684818110611b0d57611b0d614011565b905060400201602001356001600160a01b039091166000908152600a6020526040902055565b600101611a16565b508383604051611b4c929190614053565b604051908190038120907f7abf49a6ebb116bc314846377cd82a3d2c8c1ea48149a652356009fc37100dd790600090a25050505050565b604080516080810182526000808252602082018190529181018290526060810182905290611bb18382613244565b60ff168252611bc1600182613fbd565b9050816000015160ff16600114611c0e5760405162461bcd60e51b81526020600482015260116024820152701a5b9d985b1a59081c185e5b1bd8591259607a1b6044820152606401610945565b611c1883826132a0565b602080840191909152611c2b9082613fbd565b9050611c3783826132a0565b6040830152611c47602082613fbd565b9050611c538382612b3d565b6060830152611c63602082613fbd565b905082518114611cae5760405162461bcd60e51b81526020600482015260166024820152750d2dcecc2d8d2c840dacae6e6c2ceca40d8cadccee8d60531b6044820152606401610945565b50919050565b33611cc76001546001600160a01b031690565b6001600160a01b031614611ced5760405162461bcd60e51b815260040161094590613dc6565b818061ffff16611d0060005461ffff1690565b61ffff1614611d215760405162461bcd60e51b815260040161094590613df4565b6000805462ff000019166201000084151502179055505050565b600080611d478461273d565b90506000611d6d611d686000546001600160a01b03600160201b9091041690565b61273d565b90508060ff168260ff161115611dca57611d878183613e48565b611d9290600a613f45565b611d9b866120c7565b611da59190613f76565b84611daf60075490565b611db99190613f76565b611dc39190613f54565b9250611e13565b611dd3856120c7565b611ddd8383613e48565b611de890600a613f45565b85611df260075490565b611dfc9190613f76565b611e069190613f76565b611e109190613f54565b92505b505092915050565b33611e2e6001546001600160a01b031690565b6001600160a01b031614611e545760405162461bcd60e51b815260040161094590613dc6565b818061ffff16611e6760005461ffff1690565b61ffff1614611e885760405162461bcd60e51b815260040161094590613df4565b60008211611ed05760405162461bcd60e51b81526020600482015260156024820152740707265636973696f6e206d757374206265203e203605c1b6044820152606401610945565b6109d182600855565b33611eec6001546001600160a01b031690565b6001600160a01b031614611f125760405162461bcd60e51b815260040161094590613dc6565b818061ffff16611f2560005461ffff1690565b61ffff1614611f465760405162461bcd60e51b815260040161094590613df4565b6001600160a01b038216611f9c5760405162461bcd60e51b815260206004820181905260248201527f6e65774f776e65722063616e6e6f7420657175616c20616464726573732830296044820152606401610945565b6109d1826126c2565b6060816000015160ff16600114611ff25760405162461bcd60e51b81526020600482015260116024820152701a5b9d985b1a59081c185e5b1bd8591259607a1b6044820152606401610945565b81516020808401516040808601516060870151915161203a95949192910160f89490941b6001600160f81b031916845260018401929092526021830152604182015260610190565b6040516020818303038152906040529050919050565b336120636001546001600160a01b031690565b6001600160a01b0316146120895760405162461bcd60e51b815260040161094590613dc6565b808061ffff1661209c60005461ffff1690565b61ffff16146120bd5760405162461bcd60e51b815260040161094590613df4565b61182060006126c2565b600080546001600160a01b03600160201b90910481168252600a60205260408083205491841683528220546000821180156121025750600081115b6121425760405162461bcd60e51b81526020600482015260116024820152701cddd85c081c985d19481b9bdd081cd95d607a1b6044820152606401610945565b808261214d60075490565b6121579190613f76565b6112529190613f54565b336121746001546001600160a01b031690565b6001600160a01b03161461219a5760405162461bcd60e51b815260040161094590613dc6565b818061ffff166121ad60005461ffff1690565b61ffff16146121ce5760405162461bcd60e51b815260040161094590613df4565b6001600160a01b0382166122145760405162461bcd60e51b815260206004820152600d60248201526c34b73b30b634b2103a37b5b2b760991b6044820152606401610945565b6109d1826132f5565b6000806122298361273d565b9050600061224a611d686000546001600160a01b03600160201b9091041690565b90508060ff168260ff1611156122b9576007546122678284613e48565b61227290600a613f45565b61227b866120c7565b6001600160a01b0387166000908152600b602052604090205461229e9190613f76565b6122a89190613f76565b6122b29190613f54565b9250611255565b6007546122c68383613e48565b6122d190600a613f45565b6122db9190613f76565b6122e4856120c7565b6001600160a01b0386166000908152600b602052604090205461214d565b60606000600e0180548060200260200160405190810160405280929190818152602001828054801561235d57602002820191906000526020600020905b81546001600160a01b0316815260019091019060200180831161233f575b5050505050905090565b3361237a6001546001600160a01b031690565b6001600160a01b0316146123a05760405162461bcd60e51b815260040161094590613dc6565b818061ffff166123b360005461ffff1690565b61ffff16146123d45760405162461bcd60e51b815260040161094590613df4565b6001600160a01b0382166124365760405162461bcd60e51b8152602060048201526024808201527f6e6577417373697374616e742063616e6e6f7420657175616c206164647265736044820152637328302960e01b6064820152608401610945565b600280546001600160a01b0319166001600160a01b038416179055505050565b336124696001546001600160a01b031690565b6001600160a01b03161461248f5760405162461bcd60e51b815260040161094590613dc6565b828061ffff166124a260005461ffff1690565b61ffff16146124c35760405162461bcd60e51b815260040161094590613df4565b6001600160a01b0383166000908152600d602052604090205460ff166124fb5760405162461bcd60e51b815260040161094590614027565b6001600160a01b0383166000908152600b602052604090208290555b50505050565b6001600160a01b0381166000908152600d602052604090205460ff1661257c5760405162461bcd60e51b81526020600482015260146024820152731d1bdad95b881b9bdd081c9959da5cdd195c995960621b6044820152606401610945565b6001600160a01b0381166000908152600d60209081526040808320805460ff19169055600a8252808320839055600b9091528120819055600e54905b8181101561260257826001600160a01b03166000600e0182815481106125e0576125e0614011565b6000918252602090912001546001600160a01b031614612602576001016125b8565b8181146109d157600182111561268a57600e61261f600184613f8d565b8154811061262f5761262f614011565b600091825260209091200154600e80546001600160a01b03909216918390811061265b5761265b614011565b9060005260206000200160006101000a8154816001600160a01b0302191690836001600160a01b031602179055505b600e80548061269b5761269b61409e565b600082815260209020810160001990810180546001600160a01b0319169055019055505050565b600480546001600160a01b0319166001600160a01b0392909216919091179055565b6002600f54036127365760405162461bcd60e51b815260206004820152601f60248201527f5265656e7472616e637947756172643a207265656e7472616e742063616c6c006044820152606401610945565b6002600f55565b60408051600481526024810182526020810180516001600160e01b031663313ce56760e01b179052905160009182916001600160a01b03851691612780916140b4565b600060405180830381855afa9150503d80600081146127bb576040519150601f19603f3d011682016040523d82523d6000602084013e6127c0565b606091505b50915050808060200190518101906127d891906140e0565b9392505050565b6000806127eb846133c4565b90506127f984333086613470565b80612803856133c4565b61280d9190613f8d565b949350505050565b82516001600160a01b03166000908152600d602052604081205460ff1661284e5760405162461bcd60e51b815260040161094590614027565b60a08401516128ab5760405162461bcd60e51b8152602060048201526024808201527f746172676574526563697069656e742063616e6e6f74206265206279746573336044820152633228302960e01b6064820152608401610945565b60006128bf85604001518660200151610e36565b9050600081116129115760405162461bcd60e51b815260206004820152601d60248201527f6e6f726d616c697a656420616d6f756e74206d757374206265203e20300000006044820152606401610945565b600061292586606001518760200151610e36565b905085606001516000148061293a5750600081115b6129865760405162461bcd60e51b815260206004820152601b60248201527f696e76616c696420746f4e6174697665546f6b656e416d6f756e7400000000006044820152606401610945565b608086015161ffff16600090815260096020526040902054806129e35760405162461bcd60e51b81526020600482015260156024820152741d185c99d95d081b9bdd081c9959da5cdd195c9959605a1b6044820152606401610945565b6000612a096129ff89608001518a600001518b60200151611647565b8960200151610e36565b9050612a158382613fbd565b8411612a595760405162461bcd60e51b81526020600482015260136024820152721a5b9cdd59999a58da595b9d08185b5bdd5b9d606a1b6044820152606401610945565b6000612a8c6040518060800160405280600160ff1681526020018481526020018681526020018b60a00151815250611fa5565b90506000612aa26006546001600160a01b031690565b9050612ab78a60000151828c604001516134a8565b806001600160a01b031663c5a5ebda898c600001518d604001518e60800151898f896040518863ffffffff1660e01b8152600401612afa969594939291906140fd565b60206040518083038185885af1158015612b18573d6000803e3d6000fd5b50505050506040513d601f19601f8201168201806040525081019061112e9190614163565b6000612b4a826020613fbd565b83511015612b925760405162461bcd60e51b8152602060048201526015602482015274746f427974657333325f6f75744f66426f756e647360581b6044820152606401610945565b50016020015190565b6000612ba8826002613fbd565b83511015612bef5760405162461bcd60e51b8152602060048201526014602482015273746f55696e7431365f6f75744f66426f756e647360601b6044820152606401610945565b50016002015190565b60006001600160a01b0319821615612c485760405162461bcd60e51b8152602060048201526013602482015272696e76616c69642045564d206164647265737360681b6044820152606401610945565b5090565b60606000806000612c656005546001600160a01b031690565b6001600160a01b031663a9e11893866040518263ffffffff1660e01b8152600401612c909190613d25565b600060405180830381865afa158015612cad573d6000803e3d6000fd5b505050506040513d6000823e601f3d908101601f19168201604052612cd591908101906142a2565b90506000612ce68260e0015161113c565b9050612d0a816001600160a01b03166000908152600d602052604090205460ff1690565b612d4d5760405162461bcd60e51b81526020600482015260146024820152731d1bdad95b881b9bdd081c9959da5cdd195c995960621b6044820152606401610945565b6000612d58826133c4565b90506000612d6e6006546001600160a01b031690565b90506000816001600160a01b031663c3f511c18a6040518263ffffffff1660e01b8152600401612d9e9190613d25565b6000604051808303816000875af1158015612dbd573d6000803e3d6000fd5b505050506040513d6000823e601f3d908101601f19168201604052612de591908101906143c6565b9050600083612df3866133c4565b612dfd9190613f8d565b90506000836001600160a01b031663ea63738d846040518263ffffffff1660e01b8152600401612e2d9190613d25565b600060405180830381865afa158015612e4a573d6000803e3d6000fd5b505050506040513d6000823e601f3d908101601f19168201604052612e7291908101906143fa565b9050612e92876060015161ffff1660009081526009602052604090205490565b8160c0015114612ee45760405162461bcd60e51b815260206004820152601760248201527f636f6e7472616374206e6f7420726567697374657265640000000000000000006044820152606401610945565b8660a001516001600160401b03168760800151886060015161ffff167fcaf280c8cfeba144da67230d9b009c8f868a75bac9a528fa0474be1ba317c16960405160405180910390a460e001519a9099509397509295505050505050565b3415612f9b5760405162461bcd60e51b815260206004820152602360248201527f726563697069656e742063616e6e6f742073776170206e61746976652061737360448201526265747360e81b6064820152608401610945565b6000546001600160a01b03600160201b909104811690851681148015612fbe5750815b1561305957604051632e1a7d4d60e01b8152600481018490526001600160a01b03821690632e1a7d4d90602401600060405180830381600087803b15801561300557600080fd5b505af1158015613019573d6000803e3d6000fd5b50506040516001600160a01b038716925085156108fc02915085906000818181858888f19350505050158015613053573d6000803e3d6000fd5b50613064565b6130648585856131e1565b5050505050565b34156130ae5760405162461bcd60e51b815260206004820152601260248201527176616c7565206d757374206265207a65726f60701b6044820152606401610945565b80156131a157600054604051632e1a7d4d60e01b815260048101869052600160201b9091046001600160a01b031690632e1a7d4d90602401600060405180830381600087803b15801561310057600080fd5b505af1158015613114573d6000803e3d6000fd5b50505050826001600160a01b03166108fc83866131319190613f8d565b6040518115909202916000818181858888f19350505050158015613159573d6000803e3d6000fd5b50811561319c576003546040516001600160a01b039091169083156108fc029084906000818181858888f1935050505015801561319a573d6000803e3d6000fd5b505b612517565b600054600160201b90046001600160a01b03166131c381856116368689613f8d565b821561306457613064816131df6003546001600160a01b031690565b855b6040516001600160a01b0383166024820152604481018290526109d190849063a9059cbb60e01b906064015b60408051601f198184030181529190526020810180516001600160e01b03166001600160e01b0319909316929092179091526135bd565b6000613251826001613fbd565b835110156132975760405162461bcd60e51b8152602060048201526013602482015272746f55696e74385f6f75744f66426f756e647360681b6044820152606401610945565b50016001015190565b60006132ad826020613fbd565b83511015612b925760405162461bcd60e51b8152602060048201526015602482015274746f55696e743235365f6f75744f66426f756e647360581b6044820152606401610945565b6001600160a01b0381166000908152600d602052604090205460ff161561335e5760405162461bcd60e51b815260206004820152601860248201527f746f6b656e20616c7265616479207265676973746572656400000000000000006044820152606401610945565b6001600160a01b03166000818152600d60205260408120805460ff19166001908117909155600e805491820181559091527fbb7b4a454dc3493923482f07822329ed19e8244eff582cc204f8554c3620c3fd0180546001600160a01b0319169091179055565b604080513060248083019190915282518083039091018152604490910182526020810180516001600160e01b03166370a0823160e01b179052905160009182916001600160a01b03851691613418916140b4565b600060405180830381855afa9150503d8060008114613453576040519150601f19603f3d011682016040523d82523d6000602084013e613458565b606091505b50915050808060200190518101906127d89190613e19565b6040516001600160a01b03808516602483015283166044820152606481018290526125179085906323b872dd60e01b9060840161320d565b8015806135225750604051636eb1769f60e11b81523060048201526001600160a01b03838116602483015284169063dd62ed3e90604401602060405180830381865afa1580156134fc573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906135209190613e19565b155b61358d5760405162461bcd60e51b815260206004820152603660248201527f5361666545524332303a20617070726f76652066726f6d206e6f6e2d7a65726f60448201527520746f206e6f6e2d7a65726f20616c6c6f77616e636560501b6064820152608401610945565b6040516001600160a01b0383166024820152604481018290526109d190849063095ea7b360e01b9060640161320d565b6000613612826040518060400160405280602081526020017f5361666545524332303a206c6f772d6c6576656c2063616c6c206661696c6564815250856001600160a01b031661368f9092919063ffffffff16565b8051909150156109d1578080602001905181019061363091906144c2565b6109d15760405162461bcd60e51b815260206004820152602a60248201527f5361666545524332303a204552433230206f7065726174696f6e20646964206e6044820152691bdd081cdd58d8d9595960b21b6064820152608401610945565b606061280d848460008585600080866001600160a01b031685876040516136b691906140b4565b60006040518083038185875af1925050503d80600081146136f3576040519150601f19603f3d011682016040523d82523d6000602084013e6136f8565b606091505b509150915061370987838387613714565b979650505050505050565b6060831561378357825160000361377c576001600160a01b0385163b61377c5760405162461bcd60e51b815260206004820152601d60248201527f416464726573733a2063616c6c20746f206e6f6e2d636f6e74726163740000006044820152606401610945565b508161280d565b61280d83838151156137985781518083602001fd5b8060405162461bcd60e51b81526004016109459190613d25565b61ffff811681146137c257600080fd5b50565b6001600160a01b03811681146137c257600080fd5b600080604083850312156137ed57600080fd5b82356137f8816137b2565b91506020830135613808816137c5565b809150509250929050565b63ffffffff811681146137c257600080fd5b60008060008060008060c0878903121561383e57600080fd5b8635613849816137c5565b955060208701359450604087013593506060870135613867816137b2565b92506080870135915060a087013561387e81613813565b809150509295509295509295565b80151581146137c257600080fd5b600080604083850312156138ad57600080fd5b82356138b8816137b2565b915060208301356138088161388c565b60ff811681146137c257600080fd5b600080604083850312156138ea57600080fd5b823591506020830135613808816138c8565b6000806000806080858703121561391257600080fd5b843593506020850135613924816137b2565b925060408501359150606085013561393b81613813565b939692955090935050565b60006020828403121561395857600080fd5b81356127d8816137c5565b634e487b7160e01b600052604160045260246000fd5b604051608081016001600160401b038111828210171561399b5761399b613963565b60405290565b60405161016081016001600160401b038111828210171561399b5761399b613963565b60405161010081016001600160401b038111828210171561399b5761399b613963565b604051601f8201601f191681016001600160401b0381118282101715613a0f57613a0f613963565b604052919050565b60006001600160401b03821115613a3057613a30613963565b50601f01601f191660200190565b600060208284031215613a5057600080fd5b81356001600160401b03811115613a6657600080fd5b8201601f81018413613a7757600080fd5b8035613a8a613a8582613a17565b6139e7565b818152856020838501011115613a9f57600080fd5b81602084016020830137600091810160200191909152949350505050565b60008060408385031215613ad057600080fd5b8235613adb816137b2565b946020939093013593505050565b60008060208385031215613afc57600080fd5b82356001600160401b0380821115613b1357600080fd5b818501915085601f830112613b2757600080fd5b813581811115613b3657600080fd5b866020828501011115613b4857600080fd5b60209290920196919550909350505050565b600080600060608486031215613b6f57600080fd5b8335613b7a816137b2565b92506020840135613b8a816137c5565b91506040840135613b9a816138c8565b809150509250925092565b600060208284031215613bb757600080fd5b81356127d8816137b2565b600080600060408486031215613bd757600080fd5b8335613be2816137b2565b925060208401356001600160401b0380821115613bfe57600080fd5b818601915086601f830112613c1257600080fd5b813581811115613c2157600080fd5b8760208260061b8501011115613c3657600080fd5b6020830194508093505050509250925092565b60008060408385031215613c5c57600080fd5b8235613adb816137c5565b600060808284031215613c7957600080fd5b604051608081018181106001600160401b0382111715613c9b57613c9b613963565b6040528235613ca9816138c8565b808252506020830135602082015260408301356040820152606083013560608201528091505092915050565b60005b83811015613cf0578181015183820152602001613cd8565b50506000910152565b60008151808452613d11816020860160208601613cd5565b601f01601f19169290920160200192915050565b6020815260006127d86020830184613cf9565b6020808252825182820181905260009190848201906040850190845b81811015613d795783516001600160a01b031683529284019291840191600101613d54565b50909695505050505050565b600080600060608486031215613d9a57600080fd5b8335613da5816137b2565b92506020840135613db5816137c5565b929592945050506040919091013590565b60208082526014908201527331b0b63632b9103737ba103a34329037bbb732b960611b604082015260600190565b6020808252600b908201526a3bb937b7339031b430b4b760a91b604082015260600190565b600060208284031215613e2b57600080fd5b5051919050565b634e487b7160e01b600052601160045260246000fd5b60ff8281168282160390811115610e6a57610e6a613e32565b600181815b80851115613e9c578160001904821115613e8257613e82613e32565b80851615613e8f57918102915b93841c9390800290613e66565b509250929050565b600082613eb357506001610e6a565b81613ec057506000610e6a565b8160018114613ed65760028114613ee057613efc565b6001915050610e6a565b60ff841115613ef157613ef1613e32565b50506001821b610e6a565b5060208310610133831016604e8410600b8410161715613f1f575081810a610e6a565b613f298383613e61565b8060001904821115613f3d57613f3d613e32565b029392505050565b60006127d860ff841683613ea4565b600082613f7157634e487b7160e01b600052601260045260246000fd5b500490565b8082028115828204841417610e6a57610e6a613e32565b81810381811115610e6a57610e6a613e32565b600060208284031215613fb257600080fd5b81516127d8816137c5565b80820180821115610e6a57610e6a613e32565b60208082526021908201527f63616c6c6572206e6f7420746865206f776e6572206f7220617373697374616e6040820152601d60fa1b606082015260800190565b634e487b7160e01b600052603260045260246000fd5b6020808252601290820152711d1bdad95b881b9bdd081858d8d95c1d195960721b604082015260600190565b60008184825b8581101561409357813561406c816137c5565b6001600160a01b031683526020828101359084015260409283019290910190600101614059565b509095945050505050565b634e487b7160e01b600052603160045260246000fd5b600082516140c6818460208701613cd5565b9190910192915050565b80516140db816138c8565b919050565b6000602082840312156140f257600080fd5b81516127d8816138c8565b60018060a01b038716815285602082015261ffff8516604082015283606082015263ffffffff8316608082015260c060a0820152600061414060c0830184613cf9565b98975050505050505050565b80516001600160401b03811681146140db57600080fd5b60006020828403121561417557600080fd5b6127d88261414c565b80516140db81613813565b80516140db816137b2565b600082601f8301126141a557600080fd5b81516141b3613a8582613a17565b8181528460208386010111156141c857600080fd5b61280d826020830160208701613cd5565b600082601f8301126141ea57600080fd5b815160206001600160401b0382111561420557614205613963565b614213818360051b016139e7565b82815260079290921b8401810191818101908684111561423257600080fd5b8286015b84811015614297576080818903121561424f5760008081fd5b614257613979565b815181528482015185820152604080830151614272816138c8565b90820152606082810151614285816138c8565b90820152835291830191608001614236565b509695505050505050565b6000602082840312156142b457600080fd5b81516001600160401b03808211156142cb57600080fd5b9083019061016082860312156142e057600080fd5b6142e86139a1565b6142f1836140d0565b81526142ff6020840161417e565b60208201526143106040840161417e565b604082015261432160608401614189565b60608201526080830151608082015261433c60a0840161414c565b60a082015261434d60c084016140d0565b60c082015260e08301518281111561436457600080fd5b61437087828601614194565b60e08301525061010061438481850161417e565b90820152610120838101518381111561439c57600080fd5b6143a8888287016141d9565b91830191909152506101409283015192810192909252509392505050565b6000602082840312156143d857600080fd5b81516001600160401b038111156143ee57600080fd5b61280d84828501614194565b60006020828403121561440c57600080fd5b81516001600160401b038082111561442357600080fd5b90830190610100828603121561443857600080fd5b6144406139c4565b614449836140d0565b8152602083015160208201526040830151604082015261446b60608401614189565b60608201526080830151608082015261448660a08401614189565b60a082015260c083015160c082015260e0830151828111156144a757600080fd5b6144b387828601614194565b60e08301525095945050505050565b6000602082840312156144d457600080fd5b81516127d88161388c56fea26469706673582212204380a2c16f3d3a94e16ceec8dd417389a415486e9286774f1ba51d1e17ea374064736f6c63430008110033

0000000000000000000000000b2402144bb366a632d14b83f244d2e0e21bd39c000000000000000000000000d8369c2eda18dd6518eabb1f85bd60606deb39ec00000000000000000000000053207e216540125e322cda8a693b0b89576deb460000000000000000000000001c00662dbb69366d68496584e5f5668a0b8d265e0000000000000000000000000000000000000000000000000000000000000000

-----Decoded View---------------
Arg [0] : tokenBridge_ (address): 0x0b2402144Bb366A632D14B83F244D2e0e21bD39c
Arg [1] : wethAddress (address): 0xD8369C2EDA18dD6518eABb1F85BD60606dEb39Ec
Arg [2] : feeRecipient_ (address): 0x53207E216540125e322CdA8A693b0b89576DEb46
Arg [3] : ownerAssistant_ (address): 0x1c00662dbB69366D68496584E5F5668A0B8D265E
Arg [4] : unwrapWeth_ (bool): False

-----Encoded View---------------
5 Constructor Arguments found :
Arg [0] : 0000000000000000000000000b2402144bb366a632d14b83f244d2e0e21bd39c
Arg [1] : 000000000000000000000000d8369c2eda18dd6518eabb1f85bd60606deb39ec
Arg [2] : 00000000000000000000000053207e216540125e322cda8a693b0b89576deb46
Arg [3] : 0000000000000000000000001c00662dbb69366d68496584e5f5668a0b8d265e
Arg [4] : 0000000000000000000000000000000000000000000000000000000000000000