Contract

Contract Source Code (Solidity Standard Json-Input format)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

More Options

• Is this a proxy?
• Similar
• Sol2Uml
• Submit Audit
• Compare

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

pragma solidity ^0.8.0;
pragma experimental ABIEncoderV2;

import "@openzeppelin/contracts/proxy/ERC1967/ERC1967Upgrade.sol";

import "./Bridge.sol";


contract BridgeImplementation is Bridge {
    // Beacon getter for the token contracts
    function implementation() public view returns (address) {
        return tokenImplementation();
    }

    function initialize() initializer public virtual {
        // this function needs to be exposed for an upgrade to pass
        address tokenContract;
        uint256 evmChainId;
        uint16 chain = chainId();

        // Wormhole chain ids explicitly enumerated
        if        (chain == 2)  { evmChainId = 1;          // ethereum
            setFinality(1);
            tokenContract = 0x0fD04a68d3c3A692d6Fa30384D1A87Ef93554eE6;
        } else if (chain == 4)  { evmChainId = 56;         // bsc
            tokenContract = 0x7f8C5e730121657E17E452c5a1bA3fA1eF96f22a;
        } else if (chain == 5)  { evmChainId = 137;        // polygon
            tokenContract = 0x7C9Fc5741288cDFdD83CeB07f3ea7e22618D79D2;
        } else if (chain == 6)  { evmChainId = 43114;      // avalanche
            tokenContract = 0xe07548528D7c0C470251CF1374eF762345f298eE;
        } else if (chain == 7)  { evmChainId = 42262;      // oasis
            tokenContract = 0x75d520ed7fE263b96cCC7165aCe270097bC11721;
        } else if (chain == 9)  { evmChainId = 1313161554; // aurora
            tokenContract = 0x20F989Ad4C3B6ddcd940A66013d45f45d5c15463;
        } else if (chain == 10) { evmChainId = 250;        // fantom
            tokenContract = 0x99A3385C5AA40B184F6F6898daeBcD752C4b11F8;
        } else if (chain == 11) { evmChainId = 686;        // karura
            tokenContract = 0x7C9Fc5741288cDFdD83CeB07f3ea7e22618D79D2;
        } else if (chain == 12) { evmChainId = 787;        // acala
        } else if (chain == 13) { evmChainId = 8217;       // klaytn
            tokenContract = 0x7Ec2f3742F5D7ecF85817D67Ae3f89fa70164e8F;
        } else if (chain == 14) { evmChainId = 42220;      // celo
            tokenContract = 0x1a81c975d0e69206a45584BB98520f25dEEC7b6C;
        } else if (chain == 16) { evmChainId = 1284;       // moonbeam
            tokenContract = 0xddA94dA500AF7DCd8DE53482a39eD55d4aA3B392;
        } else if (chain == 17) { evmChainId = 245022934;  // neon
        } else if (chain == 23) { evmChainId = 42161;      // arbitrum
        } else if (chain == 24) { evmChainId = 10;         // optimism
        } else if (chain == 25) { evmChainId = 100;        // gnosis
        } else {
            revert("Unknown chain id.");
        }

        setEvmChainId(evmChainId);
        setTokenImplementation(tokenContract);
    }

    modifier initializer() {
        address impl = ERC1967Upgrade._getImplementation();

        require(
            !isInitialized(impl),
            "already initialized"
        );

        setInitialized(impl);

        _;
    }
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

import "../utils/Context.sol";

/**
 * @dev Contract module which provides a basic access control mechanism, where
 * there is an account (an owner) that can be granted exclusive access to
 * specific functions.
 *
 * By default, the owner account will be the one that deploys the contract. This
 * can later be changed with {transferOwnership}.
 *
 * This module is used through inheritance. It will make available the modifier
 * `onlyOwner`, which can be applied to your functions to restrict their use to
 * the owner.
 */
abstract contract Ownable is Context {
    address private _owner;

    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);

    /**
     * @dev Initializes the contract setting the deployer as the initial owner.
     */
    constructor() {
        _setOwner(_msgSender());
    }

    /**
     * @dev Returns the address of the current owner.
     */
    function owner() public view virtual returns (address) {
        return _owner;
    }

    /**
     * @dev Throws if called by any account other than the owner.
     */
    modifier onlyOwner() {
        require(owner() == _msgSender(), "Ownable: caller is not the owner");
        _;
    }

    /**
     * @dev Leaves the contract without owner. It will not be possible to call
     * `onlyOwner` functions anymore. Can only be called by the current owner.
     *
     * NOTE: Renouncing ownership will leave the contract without an owner,
     * thereby removing any functionality that is only available to the owner.
     */
    function renounceOwnership() public virtual onlyOwner {
        _setOwner(address(0));
    }

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     * Can only be called by the current owner.
     */
    function transferOwnership(address newOwner) public virtual onlyOwner {
        require(newOwner != address(0), "Ownable: new owner is the zero address");
        _setOwner(newOwner);
    }

    function _setOwner(address newOwner) private {
        address oldOwner = _owner;
        _owner = newOwner;
        emit OwnershipTransferred(oldOwner, newOwner);
    }
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.2;

import "../beacon/IBeacon.sol";
import "../../utils/Address.sol";
import "../../utils/StorageSlot.sol";

/**
 * @dev This abstract contract provides getters and event emitting update functions for
 * https://eips.ethereum.org/EIPS/eip-1967[EIP1967] slots.
 *
 * _Available since v4.1._
 *
 * @custom:oz-upgrades-unsafe-allow delegatecall
 */
abstract contract ERC1967Upgrade {
    // This is the keccak-256 hash of "eip1967.proxy.rollback" subtracted by 1
    bytes32 private constant _ROLLBACK_SLOT = 0x4910fdfa16fed3260ed0e7147f7cc6da11a60208b5b9406d12a635614ffd9143;

    /**
     * @dev Storage slot with the address of the current implementation.
     * This is the keccak-256 hash of "eip1967.proxy.implementation" subtracted by 1, and is
     * validated in the constructor.
     */
    bytes32 internal constant _IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;

    /**
     * @dev Emitted when the implementation is upgraded.
     */
    event Upgraded(address indexed implementation);

    /**
     * @dev Returns the current implementation address.
     */
    function _getImplementation() internal view returns (address) {
        return StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value;
    }

    /**
     * @dev Stores a new address in the EIP1967 implementation slot.
     */
    function _setImplementation(address newImplementation) private {
        require(Address.isContract(newImplementation), "ERC1967: new implementation is not a contract");
        StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value = newImplementation;
    }

    /**
     * @dev Perform implementation upgrade
     *
     * Emits an {Upgraded} event.
     */
    function _upgradeTo(address newImplementation) internal {
        _setImplementation(newImplementation);
        emit Upgraded(newImplementation);
    }

    /**
     * @dev Perform implementation upgrade with additional setup call.
     *
     * Emits an {Upgraded} event.
     */
    function _upgradeToAndCall(
        address newImplementation,
        bytes memory data,
        bool forceCall
    ) internal {
        _upgradeTo(newImplementation);
        if (data.length > 0 || forceCall) {
            Address.functionDelegateCall(newImplementation, data);
        }
    }

    /**
     * @dev Perform implementation upgrade with security checks for UUPS proxies, and additional setup call.
     *
     * Emits an {Upgraded} event.
     */
    function _upgradeToAndCallSecure(
        address newImplementation,
        bytes memory data,
        bool forceCall
    ) internal {
        address oldImplementation = _getImplementation();

        // Initial upgrade and setup call
        _setImplementation(newImplementation);
        if (data.length > 0 || forceCall) {
            Address.functionDelegateCall(newImplementation, data);
        }

        // Perform rollback test if not already in progress
        StorageSlot.BooleanSlot storage rollbackTesting = StorageSlot.getBooleanSlot(_ROLLBACK_SLOT);
        if (!rollbackTesting.value) {
            // Trigger rollback using upgradeTo from the new implementation
            rollbackTesting.value = true;
            Address.functionDelegateCall(
                newImplementation,
                abi.encodeWithSignature("upgradeTo(address)", oldImplementation)
            );
            rollbackTesting.value = false;
            // Check rollback was effective
            require(oldImplementation == _getImplementation(), "ERC1967Upgrade: upgrade breaks further upgrades");
            // Finally reset to the new implementation and log the upgrade
            _upgradeTo(newImplementation);
        }
    }

    /**
     * @dev Storage slot with the admin of the contract.
     * This is the keccak-256 hash of "eip1967.proxy.admin" subtracted by 1, and is
     * validated in the constructor.
     */
    bytes32 internal constant _ADMIN_SLOT = 0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103;

    /**
     * @dev Emitted when the admin account has changed.
     */
    event AdminChanged(address previousAdmin, address newAdmin);

    /**
     * @dev Returns the current admin.
     */
    function _getAdmin() internal view returns (address) {
        return StorageSlot.getAddressSlot(_ADMIN_SLOT).value;
    }

    /**
     * @dev Stores a new address in the EIP1967 admin slot.
     */
    function _setAdmin(address newAdmin) private {
        require(newAdmin != address(0), "ERC1967: new admin is the zero address");
        StorageSlot.getAddressSlot(_ADMIN_SLOT).value = newAdmin;
    }

    /**
     * @dev Changes the admin of the proxy.
     *
     * Emits an {AdminChanged} event.
     */
    function _changeAdmin(address newAdmin) internal {
        emit AdminChanged(_getAdmin(), newAdmin);
        _setAdmin(newAdmin);
    }

    /**
     * @dev The storage slot of the UpgradeableBeacon contract which defines the implementation for this proxy.
     * This is bytes32(uint256(keccak256('eip1967.proxy.beacon')) - 1)) and is validated in the constructor.
     */
    bytes32 internal constant _BEACON_SLOT = 0xa3f0ad74e5423aebfd80d3ef4346578335a9a72aeaee59ff6cb3582b35133d50;

    /**
     * @dev Emitted when the beacon is upgraded.
     */
    event BeaconUpgraded(address indexed beacon);

    /**
     * @dev Returns the current beacon.
     */
    function _getBeacon() internal view returns (address) {
        return StorageSlot.getAddressSlot(_BEACON_SLOT).value;
    }

    /**
     * @dev Stores a new beacon in the EIP1967 beacon slot.
     */
    function _setBeacon(address newBeacon) private {
        require(Address.isContract(newBeacon), "ERC1967: new beacon is not a contract");
        require(
            Address.isContract(IBeacon(newBeacon).implementation()),
            "ERC1967: beacon implementation is not a contract"
        );
        StorageSlot.getAddressSlot(_BEACON_SLOT).value = newBeacon;
    }

    /**
     * @dev Perform beacon upgrade with additional setup call. Note: This upgrades the address of the beacon, it does
     * not upgrade the implementation contained in the beacon (see {UpgradeableBeacon-_setImplementation} for that).
     *
     * Emits a {BeaconUpgraded} event.
     */
    function _upgradeBeaconToAndCall(
        address newBeacon,
        bytes memory data,
        bool forceCall
    ) internal {
        _setBeacon(newBeacon);
        emit BeaconUpgraded(newBeacon);
        if (data.length > 0 || forceCall) {
            Address.functionDelegateCall(IBeacon(newBeacon).implementation(), data);
        }
    }
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

/**
 * @dev This abstract contract provides a fallback function that delegates all calls to another contract using the EVM
 * instruction `delegatecall`. We refer to the second contract as the _implementation_ behind the proxy, and it has to
 * be specified by overriding the virtual {_implementation} function.
 *
 * Additionally, delegation to the implementation can be triggered manually through the {_fallback} function, or to a
 * different contract through the {_delegate} function.
 *
 * The success and return data of the delegated call will be returned back to the caller of the proxy.
 */
abstract contract Proxy {
    /**
     * @dev Delegates the current call to `implementation`.
     *
     * This function does not return to its internall call site, it will return directly to the external caller.
     */
    function _delegate(address implementation) internal virtual {
        assembly {
            // Copy msg.data. We take full control of memory in this inline assembly
            // block because it will not return to Solidity code. We overwrite the
            // Solidity scratch pad at memory position 0.
            calldatacopy(0, 0, calldatasize())

            // Call the implementation.
            // out and outsize are 0 because we don't know the size yet.
            let result := delegatecall(gas(), implementation, 0, calldatasize(), 0, 0)

            // Copy the returned data.
            returndatacopy(0, 0, returndatasize())

            switch result
            // delegatecall returns 0 on error.
            case 0 {
                revert(0, returndatasize())
            }
            default {
                return(0, returndatasize())
            }
        }
    }

    /**
     * @dev This is a virtual function that should be overriden so it returns the address to which the fallback function
     * and {_fallback} should delegate.
     */
    function _implementation() internal view virtual returns (address);

    /**
     * @dev Delegates the current call to the address returned by `_implementation()`.
     *
     * This function does not return to its internall call site, it will return directly to the external caller.
     */
    function _fallback() internal virtual {
        _beforeFallback();
        _delegate(_implementation());
    }

    /**
     * @dev Fallback function that delegates calls to the address returned by `_implementation()`. Will run if no other
     * function in the contract matches the call data.
     */
    fallback() external payable virtual {
        _fallback();
    }

    /**
     * @dev Fallback function that delegates calls to the address returned by `_implementation()`. Will run if call data
     * is empty.
     */
    receive() external payable virtual {
        _fallback();
    }

    /**
     * @dev Hook that is called before falling back to the implementation. Can happen as part of a manual `_fallback`
     * call, or as part of the Solidity `fallback` or `receive` functions.
     *
     * If overriden should call `super._beforeFallback()`.
     */
    function _beforeFallback() internal virtual {}
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

import "./IBeacon.sol";
import "../Proxy.sol";
import "../ERC1967/ERC1967Upgrade.sol";

/**
 * @dev This contract implements a proxy that gets the implementation address for each call from a {UpgradeableBeacon}.
 *
 * The beacon address is stored in storage slot `uint256(keccak256('eip1967.proxy.beacon')) - 1`, so that it doesn't
 * conflict with the storage layout of the implementation behind the proxy.
 *
 * _Available since v3.4._
 */
contract BeaconProxy is Proxy, ERC1967Upgrade {
    /**
     * @dev Initializes the proxy with `beacon`.
     *
     * If `data` is nonempty, it's used as data in a delegate call to the implementation returned by the beacon. This
     * will typically be an encoded function call, and allows initializating the storage of the proxy like a Solidity
     * constructor.
     *
     * Requirements:
     *
     * - `beacon` must be a contract with the interface {IBeacon}.
     */
    constructor(address beacon, bytes memory data) payable {
        assert(_BEACON_SLOT == bytes32(uint256(keccak256("eip1967.proxy.beacon")) - 1));
        _upgradeBeaconToAndCall(beacon, data, false);
    }

    /**
     * @dev Returns the current beacon address.
     */
    function _beacon() internal view virtual returns (address) {
        return _getBeacon();
    }

    /**
     * @dev Returns the current implementation address of the associated beacon.
     */
    function _implementation() internal view virtual override returns (address) {
        return IBeacon(_getBeacon()).implementation();
    }

    /**
     * @dev Changes the proxy to use a new beacon. Deprecated: see {_upgradeBeaconToAndCall}.
     *
     * If `data` is nonempty, it's used as data in a delegate call to the implementation returned by the beacon.
     *
     * Requirements:
     *
     * - `beacon` must be a contract.
     * - The implementation returned by `beacon` must be a contract.
     */
    function _setBeacon(address beacon, bytes memory data) internal virtual {
        _upgradeBeaconToAndCall(beacon, data, false);
    }
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

/**
 * @dev This is the interface that {BeaconProxy} expects of its beacon.
 */
interface IBeacon {
    /**
     * @dev Must return an address that can be used as a delegate call target.
     *
     * {BeaconProxy} will check that this address is a contract.
     */
    function implementation() external view returns (address);
}

// SPDX-License-Identifier: MIT

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 make it call a
     * `private` function that does the actual work.
     */
    modifier nonReentrant() {
        // On the first call to nonReentrant, _notEntered will be true
        require(_status != _ENTERED, "ReentrancyGuard: reentrant call");

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

        _;

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

pragma solidity ^0.8.0;

/**
 * @dev Interface of the ERC20 standard as defined in the EIP.
 */
interface IERC20 {
    /**
     * @dev Returns the amount of tokens in existence.
     */
    function totalSupply() external view returns (uint256);

    /**
     * @dev Returns the amount of tokens owned by `account`.
     */
    function balanceOf(address account) external view returns (uint256);

    /**
     * @dev Moves `amount` tokens from the caller's account to `recipient`.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transfer(address recipient, uint256 amount) external returns (bool);

    /**
     * @dev Returns the remaining number of tokens that `spender` will be
     * allowed to spend on behalf of `owner` through {transferFrom}. This is
     * zero by default.
     *
     * This value changes when {approve} or {transferFrom} are called.
     */
    function allowance(address owner, address spender) external view returns (uint256);

    /**
     * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * IMPORTANT: Beware that changing an allowance with this method brings the risk
     * that someone may use both the old and the new allowance by unfortunate
     * transaction ordering. One possible solution to mitigate this race
     * condition is to first reduce the spender's allowance to 0 and set the
     * desired value afterwards:
     * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
     *
     * Emits an {Approval} event.
     */
    function approve(address spender, uint256 amount) external returns (bool);

    /**
     * @dev Moves `amount` tokens from `sender` to `recipient` using the
     * allowance mechanism. `amount` is then deducted from the caller's
     * allowance.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transferFrom(
        address sender,
        address recipient,
        uint256 amount
    ) external returns (bool);

    /**
     * @dev Emitted when `value` tokens are moved from one account (`from`) to
     * another (`to`).
     *
     * Note that `value` may be zero.
     */
    event Transfer(address indexed from, address indexed to, uint256 value);

    /**
     * @dev Emitted when the allowance of a `spender` for an `owner` is set by
     * a call to {approve}. `value` is the new allowance.
     */
    event Approval(address indexed owner, address indexed spender, uint256 value);
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

import "../IERC20.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));
        }
    }

    /**
     * @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: MIT

pragma solidity ^0.8.0;

/**
 * @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
     * ====
     */
    function isContract(address account) internal view returns (bool) {
        // This method relies on extcodesize, which returns 0 for contracts in
        // construction, since the code is only stored at the end of the
        // constructor execution.

        uint256 size;
        assembly {
            size := extcodesize(account)
        }
        return size > 0;
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

                assembly {
                    let returndata_size := mload(returndata)
                    revert(add(32, returndata), returndata_size)
                }
            } else {
                revert(errorMessage);
            }
        }
    }
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

/**
 * @dev Provides information about the current execution context, including the
 * sender of the transaction and its data. While these are generally available
 * via msg.sender and msg.data, they should not be accessed in such a direct
 * manner, since when dealing with meta-transactions the account sending and
 * paying for execution may not be the actual sender (as far as an application
 * is concerned).
 *
 * This contract is only required for intermediate, library-like contracts.
 */
abstract contract Context {
    function _msgSender() internal view virtual returns (address) {
        return msg.sender;
    }

    function _msgData() internal view virtual returns (bytes calldata) {
        return msg.data;
    }
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

/**
 * @title Counters
 * @author Matt Condon (@shrugs)
 * @dev Provides counters that can only be incremented, decremented or reset. This can be used e.g. to track the number
 * of elements in a mapping, issuing ERC721 ids, or counting request ids.
 *
 * Include with `using Counters for Counters.Counter;`
 */
library Counters {
    struct Counter {
        // This variable should never be directly accessed by users of the library: interactions must be restricted to
        // the library's function. As of Solidity v0.5.2, this cannot be enforced, though there is a proposal to add
        // this feature: see https://github.com/ethereum/solidity/issues/4637
        uint256 _value; // default: 0
    }

    function current(Counter storage counter) internal view returns (uint256) {
        return counter._value;
    }

    function increment(Counter storage counter) internal {
        unchecked {
            counter._value += 1;
        }
    }

    function decrement(Counter storage counter) internal {
        uint256 value = counter._value;
        require(value > 0, "Counter: decrement overflow");
        unchecked {
            counter._value = value - 1;
        }
    }

    function reset(Counter storage counter) internal {
        counter._value = 0;
    }
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

/**
 * @dev Library for reading and writing primitive types to specific storage slots.
 *
 * Storage slots are often used to avoid storage conflict when dealing with upgradeable contracts.
 * This library helps with reading and writing to such slots without the need for inline assembly.
 *
 * The functions in this library return Slot structs that contain a `value` member that can be used to read or write.
 *
 * Example usage to set ERC1967 implementation slot:
 * ```
 * contract ERC1967 {
 *     bytes32 internal constant _IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;
 *
 *     function _getImplementation() internal view returns (address) {
 *         return StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value;
 *     }
 *
 *     function _setImplementation(address newImplementation) internal {
 *         require(Address.isContract(newImplementation), "ERC1967: new implementation is not a contract");
 *         StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value = newImplementation;
 *     }
 * }
 * ```
 *
 * _Available since v4.1 for `address`, `bool`, `bytes32`, and `uint256`._
 */
library StorageSlot {
    struct AddressSlot {
        address value;
    }

    struct BooleanSlot {
        bool value;
    }

    struct Bytes32Slot {
        bytes32 value;
    }

    struct Uint256Slot {
        uint256 value;
    }

    /**
     * @dev Returns an `AddressSlot` with member `value` located at `slot`.
     */
    function getAddressSlot(bytes32 slot) internal pure returns (AddressSlot storage r) {
        assembly {
            r.slot := slot
        }
    }

    /**
     * @dev Returns an `BooleanSlot` with member `value` located at `slot`.
     */
    function getBooleanSlot(bytes32 slot) internal pure returns (BooleanSlot storage r) {
        assembly {
            r.slot := slot
        }
    }

    /**
     * @dev Returns an `Bytes32Slot` with member `value` located at `slot`.
     */
    function getBytes32Slot(bytes32 slot) internal pure returns (Bytes32Slot storage r) {
        assembly {
            r.slot := slot
        }
    }

    /**
     * @dev Returns an `Uint256Slot` with member `value` located at `slot`.
     */
    function getUint256Slot(bytes32 slot) internal pure returns (Uint256Slot storage r) {
        assembly {
            r.slot := slot
        }
    }
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

/**
 * @dev Elliptic Curve Digital Signature Algorithm (ECDSA) operations.
 *
 * These functions can be used to verify that a message was signed by the holder
 * of the private keys of a given address.
 */
library ECDSA {
    enum RecoverError {
        NoError,
        InvalidSignature,
        InvalidSignatureLength,
        InvalidSignatureS,
        InvalidSignatureV
    }

    function _throwError(RecoverError error) private pure {
        if (error == RecoverError.NoError) {
            return; // no error: do nothing
        } else if (error == RecoverError.InvalidSignature) {
            revert("ECDSA: invalid signature");
        } else if (error == RecoverError.InvalidSignatureLength) {
            revert("ECDSA: invalid signature length");
        } else if (error == RecoverError.InvalidSignatureS) {
            revert("ECDSA: invalid signature 's' value");
        } else if (error == RecoverError.InvalidSignatureV) {
            revert("ECDSA: invalid signature 'v' value");
        }
    }

    /**
     * @dev Returns the address that signed a hashed message (`hash`) with
     * `signature` or error string. This address can then be used for verification purposes.
     *
     * The `ecrecover` EVM opcode allows for malleable (non-unique) signatures:
     * this function rejects them by requiring the `s` value to be in the lower
     * half order, and the `v` value to be either 27 or 28.
     *
     * IMPORTANT: `hash` _must_ be the result of a hash operation for the
     * verification to be secure: it is possible to craft signatures that
     * recover to arbitrary addresses for non-hashed data. A safe way to ensure
     * this is by receiving a hash of the original message (which may otherwise
     * be too long), and then calling {toEthSignedMessageHash} on it.
     *
     * Documentation for signature generation:
     * - with https://web3js.readthedocs.io/en/v1.3.4/web3-eth-accounts.html#sign[Web3.js]
     * - with https://docs.ethers.io/v5/api/signer/#Signer-signMessage[ethers]
     *
     * _Available since v4.3._
     */
    function tryRecover(bytes32 hash, bytes memory signature) internal pure returns (address, RecoverError) {
        // Check the signature length
        // - case 65: r,s,v signature (standard)
        // - case 64: r,vs signature (cf https://eips.ethereum.org/EIPS/eip-2098) _Available since v4.1._
        if (signature.length == 65) {
            bytes32 r;
            bytes32 s;
            uint8 v;
            // ecrecover takes the signature parameters, and the only way to get them
            // currently is to use assembly.
            assembly {
                r := mload(add(signature, 0x20))
                s := mload(add(signature, 0x40))
                v := byte(0, mload(add(signature, 0x60)))
            }
            return tryRecover(hash, v, r, s);
        } else if (signature.length == 64) {
            bytes32 r;
            bytes32 vs;
            // ecrecover takes the signature parameters, and the only way to get them
            // currently is to use assembly.
            assembly {
                r := mload(add(signature, 0x20))
                vs := mload(add(signature, 0x40))
            }
            return tryRecover(hash, r, vs);
        } else {
            return (address(0), RecoverError.InvalidSignatureLength);
        }
    }

    /**
     * @dev Returns the address that signed a hashed message (`hash`) with
     * `signature`. This address can then be used for verification purposes.
     *
     * The `ecrecover` EVM opcode allows for malleable (non-unique) signatures:
     * this function rejects them by requiring the `s` value to be in the lower
     * half order, and the `v` value to be either 27 or 28.
     *
     * IMPORTANT: `hash` _must_ be the result of a hash operation for the
     * verification to be secure: it is possible to craft signatures that
     * recover to arbitrary addresses for non-hashed data. A safe way to ensure
     * this is by receiving a hash of the original message (which may otherwise
     * be too long), and then calling {toEthSignedMessageHash} on it.
     */
    function recover(bytes32 hash, bytes memory signature) internal pure returns (address) {
        (address recovered, RecoverError error) = tryRecover(hash, signature);
        _throwError(error);
        return recovered;
    }

    /**
     * @dev Overload of {ECDSA-tryRecover} that receives the `r` and `vs` short-signature fields separately.
     *
     * See https://eips.ethereum.org/EIPS/eip-2098[EIP-2098 short signatures]
     *
     * _Available since v4.3._
     */
    function tryRecover(
        bytes32 hash,
        bytes32 r,
        bytes32 vs
    ) internal pure returns (address, RecoverError) {
        bytes32 s;
        uint8 v;
        assembly {
            s := and(vs, 0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff)
            v := add(shr(255, vs), 27)
        }
        return tryRecover(hash, v, r, s);
    }

    /**
     * @dev Overload of {ECDSA-recover} that receives the `r and `vs` short-signature fields separately.
     *
     * _Available since v4.2._
     */
    function recover(
        bytes32 hash,
        bytes32 r,
        bytes32 vs
    ) internal pure returns (address) {
        (address recovered, RecoverError error) = tryRecover(hash, r, vs);
        _throwError(error);
        return recovered;
    }

    /**
     * @dev Overload of {ECDSA-tryRecover} that receives the `v`,
     * `r` and `s` signature fields separately.
     *
     * _Available since v4.3._
     */
    function tryRecover(
        bytes32 hash,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) internal pure returns (address, RecoverError) {
        // EIP-2 still allows signature malleability for ecrecover(). Remove this possibility and make the signature
        // unique. Appendix F in the Ethereum Yellow paper (https://ethereum.github.io/yellowpaper/paper.pdf), defines
        // the valid range for s in (301): 0 < s < secp256k1n ÷ 2 + 1, and for v in (302): v ∈ {27, 28}. Most
        // signatures from current libraries generate a unique signature with an s-value in the lower half order.
        //
        // If your library generates malleable signatures, such as s-values in the upper range, calculate a new s-value
        // with 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141 - s1 and flip v from 27 to 28 or
        // vice versa. If your library also generates signatures with 0/1 for v instead 27/28, add 27 to v to accept
        // these malleable signatures as well.
        if (uint256(s) > 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20A0) {
            return (address(0), RecoverError.InvalidSignatureS);
        }
        if (v != 27 && v != 28) {
            return (address(0), RecoverError.InvalidSignatureV);
        }

        // If the signature is valid (and not malleable), return the signer address
        address signer = ecrecover(hash, v, r, s);
        if (signer == address(0)) {
            return (address(0), RecoverError.InvalidSignature);
        }

        return (signer, RecoverError.NoError);
    }

    /**
     * @dev Overload of {ECDSA-recover} that receives the `v`,
     * `r` and `s` signature fields separately.
     */
    function recover(
        bytes32 hash,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) internal pure returns (address) {
        (address recovered, RecoverError error) = tryRecover(hash, v, r, s);
        _throwError(error);
        return recovered;
    }

    /**
     * @dev Returns an Ethereum Signed Message, created from a `hash`. This
     * produces hash corresponding to the one signed with the
     * https://eth.wiki/json-rpc/API#eth_sign[`eth_sign`]
     * JSON-RPC method as part of EIP-191.
     *
     * See {recover}.
     */
    function toEthSignedMessageHash(bytes32 hash) internal pure returns (bytes32) {
        // 32 is the length in bytes of hash,
        // enforced by the type signature above
        return keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n32", hash));
    }

    /**
     * @dev Returns an Ethereum Signed Typed Data, created from a
     * `domainSeparator` and a `structHash`. This produces hash corresponding
     * to the one signed with the
     * https://eips.ethereum.org/EIPS/eip-712[`eth_signTypedData`]
     * JSON-RPC method as part of EIP-712.
     *
     * See {recover}.
     */
    function toTypedDataHash(bytes32 domainSeparator, bytes32 structHash) internal pure returns (bytes32) {
        return keccak256(abi.encodePacked("\x19\x01", domainSeparator, structHash));
    }
}

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

pragma solidity ^0.8.0;

interface Structs {
	struct Provider {
		uint16 chainId;
		uint16 governanceChainId;
		bytes32 governanceContract;
	}

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

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

pragma solidity ^0.8.0;

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

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

import "./BridgeGetters.sol";
import "./BridgeSetters.sol";
import "./BridgeStructs.sol";
import "./BridgeGovernance.sol";

import "./token/Token.sol";
import "./token/TokenImplementation.sol";

contract Bridge is BridgeGovernance, ReentrancyGuard {
    using BytesLib for bytes;

    /*
     *  @dev Produce a AssetMeta message for a given token
     */
    function attestToken(address tokenAddress, uint32 nonce) public payable returns (uint64 sequence) {
        // decimals, symbol & token are not part of the core ERC20 token standard, so we need to support contracts that dont implement them
        (,bytes memory queriedDecimals) = tokenAddress.staticcall(abi.encodeWithSignature("decimals()"));
        (,bytes memory queriedSymbol) = tokenAddress.staticcall(abi.encodeWithSignature("symbol()"));
        (,bytes memory queriedName) = tokenAddress.staticcall(abi.encodeWithSignature("name()"));

        uint8 decimals = abi.decode(queriedDecimals, (uint8));

        string memory symbolString = abi.decode(queriedSymbol, (string));
        string memory nameString = abi.decode(queriedName, (string));

        bytes32 symbol;
        bytes32 name;
        assembly {
            // first 32 bytes hold string length
            symbol := mload(add(symbolString, 32))
            name := mload(add(nameString, 32))
        }

        BridgeStructs.AssetMeta memory meta = BridgeStructs.AssetMeta({
        payloadID : 2,
        tokenAddress : bytes32(uint256(uint160(tokenAddress))), // Address of the token. Left-zero-padded if shorter than 32 bytes
        tokenChain : chainId(), // Chain ID of the token
        decimals : decimals, // Number of decimals of the token (big-endian uint8)
        symbol : symbol, // Symbol of the token (UTF-8)
        name : name // Name of the token (UTF-8)
        });

        bytes memory encoded = encodeAssetMeta(meta);

        sequence = wormhole().publishMessage{
            value : msg.value
        }(nonce, encoded, finality());
    }

    /*
     *  @notice Send eth through portal by first wrapping it to WETH.
     */
    function wrapAndTransferETH(
        uint16 recipientChain,
        bytes32 recipient,
        uint256 arbiterFee,
        uint32 nonce
    ) public payable returns (uint64 sequence) {
        BridgeStructs.TransferResult
            memory transferResult = _wrapAndTransferETH(arbiterFee);
        sequence = logTransfer(
            transferResult.tokenChain,
            transferResult.tokenAddress,
            transferResult.normalizedAmount,
            recipientChain,
            recipient,
            transferResult.normalizedArbiterFee,
            transferResult.wormholeFee,
            nonce
        );
    }

    /*
     *  @notice Send eth through portal by first wrapping it.
     *
     *  @dev This type of transfer is called a "contract-controlled transfer".
     *  There are three differences from a regular token transfer:
     *  1) Additional arbitrary payload can be attached to the message
     *  2) Only the recipient (typically a contract) can redeem the transaction
     *  3) The sender's address (msg.sender) is also included in the transaction payload
     *
     *  With these three additional components, xDapps can implement cross-chain
     *  composable interactions.
     */
    function wrapAndTransferETHWithPayload(
        uint16 recipientChain,
        bytes32 recipient,
        uint32 nonce,
        bytes memory payload
    ) public payable returns (uint64 sequence) {
        BridgeStructs.TransferResult
            memory transferResult = _wrapAndTransferETH(0);
        sequence = logTransferWithPayload(
            transferResult.tokenChain,
            transferResult.tokenAddress,
            transferResult.normalizedAmount,
            recipientChain,
            recipient,
            transferResult.wormholeFee,
            nonce,
            payload
        );
    }

    function _wrapAndTransferETH(uint256 arbiterFee) internal returns (BridgeStructs.TransferResult memory transferResult) {
        uint wormholeFee = wormhole().messageFee();

        require(wormholeFee < msg.value, "value is smaller than wormhole fee");

        uint amount = msg.value - wormholeFee;

        require(arbiterFee <= amount, "fee is bigger than amount minus wormhole fee");

        uint normalizedAmount = normalizeAmount(amount, 18);
        uint normalizedArbiterFee = normalizeAmount(arbiterFee, 18);

        // refund dust
        uint dust = amount - deNormalizeAmount(normalizedAmount, 18);
        if (dust > 0) {
            payable(msg.sender).transfer(dust);
        }

        // deposit into WETH
        WETH().deposit{
            value : amount - dust
        }();

        // track and check outstanding token amounts
        bridgeOut(address(WETH()), normalizedAmount);

        transferResult = BridgeStructs.TransferResult({
            tokenChain : chainId(),
            tokenAddress : bytes32(uint256(uint160(address(WETH())))),
            normalizedAmount : normalizedAmount,
            normalizedArbiterFee : normalizedArbiterFee,
            wormholeFee : wormholeFee
        });
    }

    /*
     *  @notice Send ERC20 token through portal.
     */
    function transferTokens(
        address token,
        uint256 amount,
        uint16 recipientChain,
        bytes32 recipient,
        uint256 arbiterFee,
        uint32 nonce
    ) public payable nonReentrant returns (uint64 sequence) {
        BridgeStructs.TransferResult memory transferResult = _transferTokens(
            token,
            amount,
            arbiterFee
        );
        sequence = logTransfer(
            transferResult.tokenChain,
            transferResult.tokenAddress,
            transferResult.normalizedAmount,
            recipientChain,
            recipient,
            transferResult.normalizedArbiterFee,
            transferResult.wormholeFee,
            nonce
        );
    }

    /*
     *  @notice Send ERC20 token through portal.
     *
     *  @dev This type of transfer is called a "contract-controlled transfer".
     *  There are three differences from a regular token transfer:
     *  1) Additional arbitrary payload can be attached to the message
     *  2) Only the recipient (typically a contract) can redeem the transaction
     *  3) The sender's address (msg.sender) is also included in the transaction payload
     *
     *  With these three additional components, xDapps can implement cross-chain
     *  composable interactions.
     */
    function transferTokensWithPayload(
        address token,
        uint256 amount,
        uint16 recipientChain,
        bytes32 recipient,
        uint32 nonce,
        bytes memory payload
    ) public payable nonReentrant returns (uint64 sequence) {
        BridgeStructs.TransferResult memory transferResult = _transferTokens(
            token,
            amount,
            0
        );
        sequence = logTransferWithPayload(
            transferResult.tokenChain,
            transferResult.tokenAddress,
            transferResult.normalizedAmount,
            recipientChain,
            recipient,
            transferResult.wormholeFee,
            nonce,
            payload
        );
    }

    /*
     *  @notice Initiate a transfer
     */
    function _transferTokens(address token, uint256 amount, uint256 arbiterFee) internal returns (BridgeStructs.TransferResult memory transferResult) {
        // determine token parameters
        uint16 tokenChain;
        bytes32 tokenAddress;
        if (isWrappedAsset(token)) {
            tokenChain = TokenImplementation(token).chainId();
            tokenAddress = TokenImplementation(token).nativeContract();
        } else {
            tokenChain = chainId();
            tokenAddress = bytes32(uint256(uint160(token)));
        }

        // query tokens decimals
        (,bytes memory queriedDecimals) = token.staticcall(abi.encodeWithSignature("decimals()"));
        uint8 decimals = abi.decode(queriedDecimals, (uint8));

        // don't deposit dust that can not be bridged due to the decimal shift
        amount = deNormalizeAmount(normalizeAmount(amount, decimals), decimals);

        if (tokenChain == chainId()) {
            // query own token balance before transfer
            (,bytes memory queriedBalanceBefore) = token.staticcall(abi.encodeWithSelector(IERC20.balanceOf.selector, address(this)));
            uint256 balanceBefore = abi.decode(queriedBalanceBefore, (uint256));

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

            // query own token balance after transfer
            (,bytes memory queriedBalanceAfter) = token.staticcall(abi.encodeWithSelector(IERC20.balanceOf.selector, address(this)));
            uint256 balanceAfter = abi.decode(queriedBalanceAfter, (uint256));

            // correct amount for potential transfer fees
            amount = balanceAfter - balanceBefore;
        } else {
            SafeERC20.safeTransferFrom(IERC20(token), msg.sender, address(this), amount);

            TokenImplementation(token).burn(address(this), amount);
        }

        // normalize amounts decimals
        uint256 normalizedAmount = normalizeAmount(amount, decimals);
        uint256 normalizedArbiterFee = normalizeAmount(arbiterFee, decimals);

        // track and check outstanding token amounts
        if (tokenChain == chainId()) {
            bridgeOut(token, normalizedAmount);
        }

        transferResult = BridgeStructs.TransferResult({
            tokenChain : tokenChain,
            tokenAddress : tokenAddress,
            normalizedAmount : normalizedAmount,
            normalizedArbiterFee : normalizedArbiterFee,
            wormholeFee : msg.value
        });
    }

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

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

    function logTransfer(
        uint16 tokenChain,
        bytes32 tokenAddress,
        uint256 amount,
        uint16 recipientChain,
        bytes32 recipient,
        uint256 fee,
        uint256 callValue,
        uint32 nonce
    ) internal returns (uint64 sequence) {
        require(fee <= amount, "fee exceeds amount");

        BridgeStructs.Transfer memory transfer = BridgeStructs.Transfer({
            payloadID: 1,
            amount: amount,
            tokenAddress: tokenAddress,
            tokenChain: tokenChain,
            to: recipient,
            toChain: recipientChain,
            fee: fee
        });

        sequence = wormhole().publishMessage{value: callValue}(
            nonce,
            encodeTransfer(transfer),
            finality()
        );
    }

    /*
     * @dev Publish a token transfer message with payload.
     *
     * @return The sequence number of the published message.
     */
    function logTransferWithPayload(
        uint16 tokenChain,
        bytes32 tokenAddress,
        uint256 amount,
        uint16 recipientChain,
        bytes32 recipient,
        uint256 callValue,
        uint32 nonce,
        bytes memory payload
    ) internal returns (uint64 sequence) {
        BridgeStructs.TransferWithPayload memory transfer = BridgeStructs
            .TransferWithPayload({
                payloadID: 3,
                amount: amount,
                tokenAddress: tokenAddress,
                tokenChain: tokenChain,
                to: recipient,
                toChain: recipientChain,
                fromAddress : bytes32(uint256(uint160(msg.sender))),
                payload: payload
            });

        sequence = wormhole().publishMessage{value: callValue}(
            nonce,
            encodeTransferWithPayload(transfer),
            finality()
        );
    }

    function updateWrapped(bytes memory encodedVm) external returns (address token) {
        (IWormhole.VM memory vm, bool valid, string memory reason) = wormhole().parseAndVerifyVM(encodedVm);

        require(valid, reason);
        require(verifyBridgeVM(vm), "invalid emitter");

        BridgeStructs.AssetMeta memory meta = parseAssetMeta(vm.payload);
        return _updateWrapped(meta, vm.sequence);
    }

    function _updateWrapped(BridgeStructs.AssetMeta memory meta, uint64 sequence) internal returns (address token) {
        address wrapped = wrappedAsset(meta.tokenChain, meta.tokenAddress);
        require(wrapped != address(0), "wrapped asset does not exists");

        // Update metadata
        TokenImplementation(wrapped).updateDetails(bytes32ToString(meta.name), bytes32ToString(meta.symbol), sequence);

        return wrapped;
    }

    function createWrapped(bytes memory encodedVm) external returns (address token) {
        (IWormhole.VM memory vm, bool valid, string memory reason) = wormhole().parseAndVerifyVM(encodedVm);

        require(valid, reason);
        require(verifyBridgeVM(vm), "invalid emitter");

        BridgeStructs.AssetMeta memory meta = parseAssetMeta(vm.payload);
        return _createWrapped(meta, vm.sequence);
    }

    // Creates a wrapped asset using AssetMeta
    function _createWrapped(BridgeStructs.AssetMeta memory meta, uint64 sequence) internal returns (address token) {
        require(meta.tokenChain != chainId(), "can only wrap tokens from foreign chains");
        require(wrappedAsset(meta.tokenChain, meta.tokenAddress) == address(0), "wrapped asset already exists");

        // initialize the TokenImplementation
        bytes memory initialisationArgs = abi.encodeWithSelector(
            TokenImplementation.initialize.selector,
            bytes32ToString(meta.name),
            bytes32ToString(meta.symbol),
            meta.decimals,
            sequence,

            address(this),

            meta.tokenChain,
            meta.tokenAddress
        );

        // initialize the BeaconProxy
        bytes memory constructorArgs = abi.encode(address(this), initialisationArgs);

        // deployment code
        bytes memory bytecode = abi.encodePacked(type(BridgeToken).creationCode, constructorArgs);

        bytes32 salt = keccak256(abi.encodePacked(meta.tokenChain, meta.tokenAddress));

        assembly {
            token := create2(0, add(bytecode, 0x20), mload(bytecode), salt)

            if iszero(extcodesize(token)) {
                revert(0, 0)
            }
        }

        setWrappedAsset(meta.tokenChain, meta.tokenAddress, token);
    }

    /*
     * @notice Complete a contract-controlled transfer of an ERC20 token.
     *
     * @dev The transaction can only be redeemed by the recipient, typically a
     * contract.
     *
     * @param encodedVm    A byte array containing a VAA signed by the guardians.
     *
     * @return The byte array representing a BridgeStructs.TransferWithPayload.
     */
    function completeTransferWithPayload(bytes memory encodedVm) public returns (bytes memory) {
        return _completeTransfer(encodedVm, false);
    }

    /*
     * @notice Complete a contract-controlled transfer of WETH, and unwrap to ETH.
     *
     * @dev The transaction can only be redeemed by the recipient, typically a
     * contract.
     *
     * @param encodedVm    A byte array containing a VAA signed by the guardians.
     *
     * @return The byte array representing a BridgeStructs.TransferWithPayload.
     */
    function completeTransferAndUnwrapETHWithPayload(bytes memory encodedVm) public returns (bytes memory) {
        return _completeTransfer(encodedVm, true);
    }

    /*
     * @notice Complete a transfer of an ERC20 token.
     *
     * @dev The msg.sender gets paid the associated fee.
     *
     * @param encodedVm A byte array containing a VAA signed by the guardians.
     */
    function completeTransfer(bytes memory encodedVm) public {
        _completeTransfer(encodedVm, false);
    }

    /*
     * @notice Complete a transfer of WETH and unwrap to eth.
     *
     * @dev The msg.sender gets paid the associated fee.
     *
     * @param encodedVm A byte array containing a VAA signed by the guardians.
     */
    function completeTransferAndUnwrapETH(bytes memory encodedVm) public {
        _completeTransfer(encodedVm, true);
    }

    /*
     * @dev Truncate a 32 byte array to a 20 byte address.
     *      Reverts if the array contains non-0 bytes in the first 12 bytes.
     *
     * @param bytes32 bytes The 32 byte array to be converted.
     */
    function _truncateAddress(bytes32 b) internal pure returns (address) {
        require(bytes12(b) == 0, "invalid EVM address");
        return address(uint160(uint256(b)));
    }

    // Execute a Transfer message
    function _completeTransfer(bytes memory encodedVm, bool unwrapWETH) internal returns (bytes memory) {
        (IWormhole.VM memory vm, bool valid, string memory reason) = wormhole().parseAndVerifyVM(encodedVm);

        require(valid, reason);
        require(verifyBridgeVM(vm), "invalid emitter");

        BridgeStructs.Transfer memory transfer = _parseTransferCommon(vm.payload);

        // payload 3 must be redeemed by the designated proxy contract
        address transferRecipient = _truncateAddress(transfer.to);
        if (transfer.payloadID == 3) {
            require(msg.sender == transferRecipient, "invalid sender");
        }

        require(!isTransferCompleted(vm.hash), "transfer already completed");
        setTransferCompleted(vm.hash);

        require(transfer.toChain == chainId(), "invalid target chain");

        IERC20 transferToken;
        if (transfer.tokenChain == chainId()) {
            transferToken = IERC20(_truncateAddress(transfer.tokenAddress));

            // track outstanding token amounts
            bridgedIn(address(transferToken), transfer.amount);
        } else {
            address wrapped = wrappedAsset(transfer.tokenChain, transfer.tokenAddress);
            require(wrapped != address(0), "no wrapper for this token created yet");

            transferToken = IERC20(wrapped);
        }

        require(unwrapWETH == false || address(transferToken) == address(WETH()), "invalid token, can only unwrap WETH");

        // query decimals
        (,bytes memory queriedDecimals) = address(transferToken).staticcall(abi.encodeWithSignature("decimals()"));
        uint8 decimals = abi.decode(queriedDecimals, (uint8));

        // adjust decimals
        uint256 nativeAmount = deNormalizeAmount(transfer.amount, decimals);
        uint256 nativeFee = deNormalizeAmount(transfer.fee, decimals);

        // transfer fee to arbiter
        if (nativeFee > 0 && transferRecipient != msg.sender) {
            require(nativeFee <= nativeAmount, "fee higher than transferred amount");

            if (unwrapWETH) {
                WETH().withdraw(nativeFee);

                payable(msg.sender).transfer(nativeFee);
            } else {
                if (transfer.tokenChain != chainId()) {
                    // mint wrapped asset
                    TokenImplementation(address(transferToken)).mint(msg.sender, nativeFee);
                } else {
                    SafeERC20.safeTransfer(transferToken, msg.sender, nativeFee);
                }
            }
        } else {
            // set fee to zero in case transferRecipient == feeRecipient
            nativeFee = 0;
        }

        // transfer bridged amount to recipient
        uint transferAmount = nativeAmount - nativeFee;

        if (unwrapWETH) {
            WETH().withdraw(transferAmount);

            payable(transferRecipient).transfer(transferAmount);
        } else {
            if (transfer.tokenChain != chainId()) {
                // mint wrapped asset
                TokenImplementation(address(transferToken)).mint(transferRecipient, transferAmount);
            } else {
                SafeERC20.safeTransfer(transferToken, transferRecipient, transferAmount);
            }
        }

        return vm.payload;
    }

    function bridgeOut(address token, uint normalizedAmount) internal {
        uint outstanding = outstandingBridged(token);
        require(outstanding + normalizedAmount <= type(uint64).max, "transfer exceeds max outstanding bridged token amount");
        setOutstandingBridged(token, outstanding + normalizedAmount);
    }

    function bridgedIn(address token, uint normalizedAmount) internal {
        setOutstandingBridged(token, outstandingBridged(token) - normalizedAmount);
    }

    function verifyBridgeVM(IWormhole.VM memory vm) internal view returns (bool){
        require(!isFork(), "invalid fork");
        return bridgeContracts(vm.emitterChainId) == vm.emitterAddress;
    }

    function encodeAssetMeta(BridgeStructs.AssetMeta memory meta) public pure returns (bytes memory encoded) {
        encoded = abi.encodePacked(
            meta.payloadID,
            meta.tokenAddress,
            meta.tokenChain,
            meta.decimals,
            meta.symbol,
            meta.name
        );
    }

    function encodeTransfer(BridgeStructs.Transfer memory transfer) public pure returns (bytes memory encoded) {
        encoded = abi.encodePacked(
            transfer.payloadID,
            transfer.amount,
            transfer.tokenAddress,
            transfer.tokenChain,
            transfer.to,
            transfer.toChain,
            transfer.fee
        );
    }

    function encodeTransferWithPayload(BridgeStructs.TransferWithPayload memory transfer) public pure returns (bytes memory encoded) {
        encoded = abi.encodePacked(
            transfer.payloadID,
            transfer.amount,
            transfer.tokenAddress,
            transfer.tokenChain,
            transfer.to,
            transfer.toChain,
            transfer.fromAddress,
            transfer.payload
        );
    }

    function parsePayloadID(bytes memory encoded) public pure returns (uint8 payloadID) {
        payloadID = encoded.toUint8(0);
    }

    /*
     * @dev Parse a token metadata attestation (payload id 2)
     */
    function parseAssetMeta(bytes memory encoded) public pure returns (BridgeStructs.AssetMeta memory meta) {
        uint index = 0;

        meta.payloadID = encoded.toUint8(index);
        index += 1;

        require(meta.payloadID == 2, "invalid AssetMeta");

        meta.tokenAddress = encoded.toBytes32(index);
        index += 32;

        meta.tokenChain = encoded.toUint16(index);
        index += 2;

        meta.decimals = encoded.toUint8(index);
        index += 1;

        meta.symbol = encoded.toBytes32(index);
        index += 32;

        meta.name = encoded.toBytes32(index);
        index += 32;

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

    /*
     * @dev Parse a token transfer (payload id 1).
     *
     * @params encoded The byte array corresponding to the token transfer (not
     *                 the whole VAA, only the payload)
     */
    function parseTransfer(bytes memory encoded) public pure returns (BridgeStructs.Transfer memory transfer) {
        uint index = 0;

        transfer.payloadID = encoded.toUint8(index);
        index += 1;

        require(transfer.payloadID == 1, "invalid Transfer");

        transfer.amount = encoded.toUint256(index);
        index += 32;

        transfer.tokenAddress = encoded.toBytes32(index);
        index += 32;

        transfer.tokenChain = encoded.toUint16(index);
        index += 2;

        transfer.to = encoded.toBytes32(index);
        index += 32;

        transfer.toChain = encoded.toUint16(index);
        index += 2;

        transfer.fee = encoded.toUint256(index);
        index += 32;

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

    /*
     * @dev Parse a token transfer with payload (payload id 3).
     *
     * @params encoded The byte array corresponding to the token transfer (not
     *                 the whole VAA, only the payload)
     */
    function parseTransferWithPayload(bytes memory encoded) public pure returns (BridgeStructs.TransferWithPayload memory transfer) {
        uint index = 0;

        transfer.payloadID = encoded.toUint8(index);
        index += 1;

        require(transfer.payloadID == 3, "invalid Transfer");

        transfer.amount = encoded.toUint256(index);
        index += 32;

        transfer.tokenAddress = encoded.toBytes32(index);
        index += 32;

        transfer.tokenChain = encoded.toUint16(index);
        index += 2;

        transfer.to = encoded.toBytes32(index);
        index += 32;

        transfer.toChain = encoded.toUint16(index);
        index += 2;

        transfer.fromAddress = encoded.toBytes32(index);
        index += 32;

        transfer.payload = encoded.slice(index, encoded.length - index);
    }

    /*
     * @dev Parses either a type 1 transfer or a type 3 transfer ("transfer with
     *      payload") as a Transfer struct. The fee is set to 0 for type 3
     *      transfers, since they have no fees associated with them.
     *
     *      The sole purpose of this function is to get around the local
     *      variable count limitation in _completeTransfer.
     */
    function _parseTransferCommon(bytes memory encoded) public pure returns (BridgeStructs.Transfer memory transfer) {
        uint8 payloadID = parsePayloadID(encoded);

        if (payloadID == 1) {
            transfer = parseTransfer(encoded);
        } else if (payloadID == 3) {
            BridgeStructs.TransferWithPayload memory t = parseTransferWithPayload(encoded);
            transfer.payloadID = 3;
            transfer.amount = t.amount;
            transfer.tokenAddress = t.tokenAddress;
            transfer.tokenChain = t.tokenChain;
            transfer.to = t.to;
            transfer.toChain = t.toChain;
            // Type 3 payloads don't have fees.
            transfer.fee = 0;
        } else {
            revert("Invalid payload id");
        }
    }

    function bytes32ToString(bytes32 input) internal pure returns (string memory) {
        uint256 i;
        while (i < 32 && input[i] != 0) {
            i++;
        }
        bytes memory array = new bytes(i);
        for (uint c = 0; c < i; c++) {
            array[c] = input[c];
        }
        return string(array);
    }

    // we need to accept ETH sends to unwrap WETH
    receive() external payable {}
}

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

pragma solidity ^0.8.0;

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

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

import "./BridgeState.sol";

contract BridgeGetters is BridgeState {
    function governanceActionIsConsumed(bytes32 hash) public view returns (bool) {
        return _state.consumedGovernanceActions[hash];
    }

    function isInitialized(address impl) public view returns (bool) {
        return _state.initializedImplementations[impl];
    }

    function isTransferCompleted(bytes32 hash) public view returns (bool) {
        return _state.completedTransfers[hash];
    }

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

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

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

    function isFork() public view returns (bool) {
        return evmChainId() != block.chainid;
    }

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

    function governanceContract() public view returns (bytes32){
        return _state.provider.governanceContract;
    }

    function wrappedAsset(uint16 tokenChainId, bytes32 tokenAddress) public view returns (address){
        return _state.wrappedAssets[tokenChainId][tokenAddress];
    }

    function bridgeContracts(uint16 chainId_) public view returns (bytes32){
        return _state.bridgeImplementations[chainId_];
    }

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

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

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

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

    function finality() public view returns (uint8) {
        return _state.provider.finality;
    }
}

interface IWETH is IERC20 {
    function deposit() external payable;

    function withdraw(uint amount) external;
}

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

pragma solidity ^0.8.0;

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

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

import "./BridgeGetters.sol";
import "./BridgeSetters.sol";
import "./BridgeStructs.sol";

import "./token/Token.sol";
import "./token/TokenImplementation.sol";

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

contract BridgeGovernance is BridgeGetters, BridgeSetters, ERC1967Upgrade {
    using BytesLib for bytes;

    // "TokenBridge" (left padded)
    bytes32 constant module = 0x000000000000000000000000000000000000000000546f6b656e427269646765;

    // Execute a RegisterChain governance message
    function registerChain(bytes memory encodedVM) public {
        (IWormhole.VM memory vm, bool valid, string memory reason) = verifyGovernanceVM(encodedVM);
        require(valid, reason);

        setGovernanceActionConsumed(vm.hash);

        BridgeStructs.RegisterChain memory chain = parseRegisterChain(vm.payload);

        require((chain.chainId == chainId() && !isFork()) || chain.chainId == 0, "invalid chain id");
        require(bridgeContracts(chain.emitterChainID) == bytes32(0), "chain already registered");

        setBridgeImplementation(chain.emitterChainID, chain.emitterAddress);
    }

    // Execute a UpgradeContract governance message
    function upgrade(bytes memory encodedVM) public {
        require(!isFork(), "invalid fork");

        (IWormhole.VM memory vm, bool valid, string memory reason) = verifyGovernanceVM(encodedVM);
        require(valid, reason);

        setGovernanceActionConsumed(vm.hash);

        BridgeStructs.UpgradeContract memory implementation = parseUpgrade(vm.payload);

        require(implementation.chainId == chainId(), "wrong chain id");

        upgradeImplementation(address(uint160(uint256(implementation.newContract))));
    }

    /**
    * @dev Updates the `chainId` and `evmChainId` on a forked chain via Governance VAA/VM
    */
    function submitRecoverChainId(bytes memory encodedVM) public {
        require(isFork(), "not a fork");

        (IWormhole.VM memory vm, bool valid, string memory reason) = verifyGovernanceVM(encodedVM);
        require(valid, reason);

        setGovernanceActionConsumed(vm.hash);

        BridgeStructs.RecoverChainId memory rci = parseRecoverChainId(vm.payload);

        // Verify the VAA is for this chain
        require(rci.evmChainId == block.chainid, "invalid EVM Chain");

        // Update the chainIds
        setEvmChainId(rci.evmChainId);
        setChainId(rci.newChainId);
    }

    function verifyGovernanceVM(bytes memory encodedVM) internal view returns (IWormhole.VM memory parsedVM, bool isValid, string memory invalidReason){
        (IWormhole.VM memory vm, bool valid, string memory reason) = wormhole().parseAndVerifyVM(encodedVM);

        if (!valid) {
            return (vm, valid, reason);
        }

        if (vm.emitterChainId != governanceChainId()) {
            return (vm, false, "wrong governance chain");
        }
        if (vm.emitterAddress != governanceContract()) {
            return (vm, false, "wrong governance contract");
        }

        if (governanceActionIsConsumed(vm.hash)) {
            return (vm, false, "governance action already consumed");
        }

        return (vm, true, "");
    }

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

    function upgradeImplementation(address newImplementation) internal {
        address currentImplementation = _getImplementation();

        _upgradeTo(newImplementation);

        // Call initialize function of the new implementation
        (bool success, bytes memory reason) = newImplementation.delegatecall(abi.encodeWithSignature("initialize()"));

        require(success, string(reason));

        emit ContractUpgraded(currentImplementation, newImplementation);
    }

    function parseRegisterChain(bytes memory encoded) public pure returns (BridgeStructs.RegisterChain memory chain) {
        uint index = 0;

        // governance header

        chain.module = encoded.toBytes32(index);
        index += 32;
        require(chain.module == module, "wrong module");

        chain.action = encoded.toUint8(index);
        index += 1;
        require(chain.action == 1, "wrong action");

        chain.chainId = encoded.toUint16(index);
        index += 2;

        // payload

        chain.emitterChainID = encoded.toUint16(index);
        index += 2;

        chain.emitterAddress = encoded.toBytes32(index);
        index += 32;

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

    function parseUpgrade(bytes memory encoded) public pure returns (BridgeStructs.UpgradeContract memory chain) {
        uint index = 0;

        // governance header

        chain.module = encoded.toBytes32(index);
        index += 32;
        require(chain.module == module, "wrong module");

        chain.action = encoded.toUint8(index);
        index += 1;
        require(chain.action == 2, "wrong action");

        chain.chainId = encoded.toUint16(index);
        index += 2;

        // payload

        chain.newContract = encoded.toBytes32(index);
        index += 32;

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

    /// @dev Parse a recoverChainId (action 3) with minimal validation
    function parseRecoverChainId(bytes memory encodedRecoverChainId) public pure returns (BridgeStructs.RecoverChainId memory rci) {
        uint index = 0;

        rci.module = encodedRecoverChainId.toBytes32(index);
        index += 32;
        require(rci.module == module, "wrong module");

        rci.action = encodedRecoverChainId.toUint8(index);
        index += 1;
        require(rci.action == 3, "wrong action");

        rci.evmChainId = encodedRecoverChainId.toUint256(index);
        index += 32;

        rci.newChainId = encodedRecoverChainId.toUint16(index);
        index += 2;

        require(encodedRecoverChainId.length == index, "wrong length");
    }
}

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

pragma solidity ^0.8.0;

import "./BridgeState.sol";

contract BridgeSetters is BridgeState {
    function setInitialized(address implementatiom) internal {
        _state.initializedImplementations[implementatiom] = true;
    }

    function setGovernanceActionConsumed(bytes32 hash) internal {
        _state.consumedGovernanceActions[hash] = true;
    }

    function setTransferCompleted(bytes32 hash) internal {
        _state.completedTransfers[hash] = true;
    }

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

    function setGovernanceChainId(uint16 chainId) internal {
        _state.provider.governanceChainId = chainId;
    }

    function setGovernanceContract(bytes32 governanceContract) internal {
        _state.provider.governanceContract = governanceContract;
    }

    function setBridgeImplementation(uint16 chainId, bytes32 bridgeContract) internal {
        _state.bridgeImplementations[chainId] = bridgeContract;
    }

    function setTokenImplementation(address impl) internal {
        _state.tokenImplementation = impl;
    }

    function setWETH(address weth) internal {
        _state.provider.WETH = weth;
    }

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

    function setWrappedAsset(uint16 tokenChainId, bytes32 tokenAddress, address wrapper) internal {
        _state.wrappedAssets[tokenChainId][tokenAddress] = wrapper;
        _state.isWrappedAsset[wrapper] = true;
    }

    function setOutstandingBridged(address token, uint256 outstanding) internal {
        _state.outstandingBridged[token] = outstanding;
    }

    function setFinality(uint8 finality) internal {
        _state.provider.finality = finality;
    }

    function setEvmChainId(uint256 evmChainId) internal {
        require(evmChainId == block.chainid, "invalid evmChainId");
        _state.evmChainId = evmChainId;
    }
}

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

pragma solidity ^0.8.0;

import "./BridgeStructs.sol";

contract BridgeStorage {
    struct Provider {
        uint16 chainId;
        uint16 governanceChainId;
        // Required number of block confirmations to assume finality
        uint8 finality;
        bytes32 governanceContract;
        address WETH;
    }

    struct Asset {
        uint16 chainId;
        bytes32 assetAddress;
    }

    struct State {
        address payable wormhole;
        address tokenImplementation;

        Provider provider;

        // Mapping of consumed governance actions
        mapping(bytes32 => bool) consumedGovernanceActions;

        // Mapping of consumed token transfers
        mapping(bytes32 => bool) completedTransfers;

        // Mapping of initialized implementations
        mapping(address => bool) initializedImplementations;

        // Mapping of wrapped assets (chainID => nativeAddress => wrappedAddress)
        mapping(uint16 => mapping(bytes32 => address)) wrappedAssets;

        // Mapping to safely identify wrapped assets
        mapping(address => bool) isWrappedAsset;

        // Mapping of native assets to amount outstanding on other chains
        mapping(address => uint256) outstandingBridged;

        // Mapping of bridge contracts on other chains
        mapping(uint16 => bytes32) bridgeImplementations;

        // EIP-155 Chain ID
        uint256 evmChainId;
    }
}

contract BridgeState {
    BridgeStorage.State _state;
}

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

pragma solidity ^0.8.0;

contract BridgeStructs {
    struct Transfer {
        // PayloadID uint8 = 1
        uint8 payloadID;
        // Amount being transferred (big-endian uint256)
        uint256 amount;
        // Address of the token. Left-zero-padded if shorter than 32 bytes
        bytes32 tokenAddress;
        // Chain ID of the token
        uint16 tokenChain;
        // Address of the recipient. Left-zero-padded if shorter than 32 bytes
        bytes32 to;
        // Chain ID of the recipient
        uint16 toChain;
        // Amount of tokens (big-endian uint256) that the user is willing to pay as relayer fee. Must be <= Amount.
        uint256 fee;
    }

    struct TransferWithPayload {
        // PayloadID uint8 = 3
        uint8 payloadID;
        // Amount being transferred (big-endian uint256)
        uint256 amount;
        // Address of the token. Left-zero-padded if shorter than 32 bytes
        bytes32 tokenAddress;
        // Chain ID of the token
        uint16 tokenChain;
        // Address of the recipient. Left-zero-padded if shorter than 32 bytes
        bytes32 to;
        // Chain ID of the recipient
        uint16 toChain;
        // Address of the message sender. Left-zero-padded if shorter than 32 bytes
        bytes32 fromAddress;
        // An arbitrary payload
        bytes payload;
    }

    struct TransferResult {
        // Chain ID of the token
        uint16  tokenChain;
        // Address of the token. Left-zero-padded if shorter than 32 bytes
        bytes32 tokenAddress;
        // Amount being transferred (big-endian uint256)
        uint256 normalizedAmount;
        // Amount of tokens (big-endian uint256) that the user is willing to pay as relayer fee. Must be <= Amount.
        uint256 normalizedArbiterFee;
        // Portion of msg.value to be paid as the core bridge fee
        uint wormholeFee;
    }

    struct AssetMeta {
        // PayloadID uint8 = 2
        uint8 payloadID;
        // Address of the token. Left-zero-padded if shorter than 32 bytes
        bytes32 tokenAddress;
        // Chain ID of the token
        uint16 tokenChain;
        // Number of decimals of the token (big-endian uint256)
        uint8 decimals;
        // Symbol of the token (UTF-8)
        bytes32 symbol;
        // Name of the token (UTF-8)
        bytes32 name;
    }

    struct RegisterChain {
        // Governance Header
        // module: "TokenBridge" left-padded
        bytes32 module;
        // governance action: 1
        uint8 action;
        // governance paket chain id: this or 0
        uint16 chainId;

        // Chain ID
        uint16 emitterChainID;
        // Emitter address. Left-zero-padded if shorter than 32 bytes
        bytes32 emitterAddress;
    }

    struct UpgradeContract {
        // Governance Header
        // module: "TokenBridge" left-padded
        bytes32 module;
        // governance action: 2
        uint8 action;
        // governance paket chain id
        uint16 chainId;

        // Address of the new contract
        bytes32 newContract;
    }

    struct RecoverChainId {
        // Governance Header
        // module: "TokenBridge" left-padded
        bytes32 module;
        // governance action: 3
        uint8 action;

        // EIP-155 Chain ID
        uint256 evmChainId;
        // Chain ID
        uint16 newChainId;
    }
}

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

pragma solidity ^0.8.0;

import "@openzeppelin/contracts/proxy/beacon/BeaconProxy.sol";

contract BridgeToken is BeaconProxy {
    constructor(address beacon, bytes memory data) BeaconProxy(beacon, data) {

    }
}

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

pragma solidity ^0.8.0;

import "./TokenState.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Context.sol";
import "@openzeppelin/contracts/proxy/beacon/BeaconProxy.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";

// Based on the OpenZepplin ERC20 implementation, licensed under MIT
contract TokenImplementation is TokenState, Context {
    event Transfer(address indexed from, address indexed to, uint256 value);
    event Approval(address indexed owner, address indexed spender, uint256 value);

    function initialize(
        string memory name_,
        string memory symbol_,
        uint8 decimals_,
        uint64 sequence_,
        address owner_,
        uint16 chainId_,
        bytes32 nativeContract_
    ) initializer public {
        _initializeNativeToken(
            name_,
            symbol_,
            decimals_,
            sequence_,
            owner_,
            chainId_,
            nativeContract_
        );

        // initialize w/ EIP712 state variables for domain separator
        _initializePermitStateIfNeeded();
    }

    function _initializeNativeToken(
        string memory name_,
        string memory symbol_,
        uint8 decimals_,
        uint64 sequence_,
        address owner_,
        uint16 chainId_,
        bytes32 nativeContract_
    ) internal {
        _state.name = name_;
        _state.symbol = symbol_;
        _state.decimals = decimals_;
        _state.metaLastUpdatedSequence = sequence_;

        _state.owner = owner_;

        _state.chainId = chainId_;
        _state.nativeContract = nativeContract_;
    }

    function _initializePermitStateIfNeeded() internal {
        // If someone were to change the implementation of name(), we
        // need to make sure we recache.
        bytes32 hashedName = _eip712DomainNameHashed();

        // If for some reason the salt generation changes with newer
        // token implementations, we need to make sure the state reflects
        // the new salt.
        bytes32 salt = _eip712DomainSalt();

        // check cached values
        if (_state.cachedHashedName != hashedName || _state.cachedSalt != salt) {
            _state.cachedChainId = block.chainid;
            _state.cachedThis = address(this);
            _state.cachedDomainSeparator = _buildDomainSeparator(hashedName, salt);
            _state.cachedSalt = salt;
            _state.cachedHashedName = hashedName;
        }
    }

    function name() public view returns (string memory) {
        return _state.name;
    }

    function symbol() public view returns (string memory) {
        return _state.symbol;
    }

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

    function decimals() public view returns (uint8) {
        return _state.decimals;
    }

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

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

    function nativeContract() public view returns (bytes32) {
        return _state.nativeContract;
    }

    function balanceOf(address account_) public view returns (uint256) {
        return _state.balances[account_];
    }

    function transfer(address recipient_, uint256 amount_) public returns (bool) {
        _transfer(_msgSender(), recipient_, amount_);
        return true;
    }

    function allowance(address owner_, address spender_) public view returns (uint256) {
        return _state.allowances[owner_][spender_];
    }

    function approve(address spender_, uint256 amount_) public returns (bool) {
        _approve(_msgSender(), spender_, amount_);
        return true;
    }

    function transferFrom(address sender_, address recipient_, uint256 amount_) public returns (bool) {
        _transfer(sender_, recipient_, amount_);

        uint256 currentAllowance = _state.allowances[sender_][_msgSender()];
        require(currentAllowance >= amount_, "ERC20: transfer amount exceeds allowance");
        _approve(sender_, _msgSender(), currentAllowance - amount_);

        return true;
    }

    function increaseAllowance(address spender_, uint256 addedValue_) public returns (bool) {
        _approve(_msgSender(), spender_, _state.allowances[_msgSender()][spender_] + addedValue_);
        return true;
    }

    function decreaseAllowance(address spender_, uint256 subtractedValue_) public returns (bool) {
        uint256 currentAllowance = _state.allowances[_msgSender()][spender_];
        require(currentAllowance >= subtractedValue_, "ERC20: decreased allowance below zero");
        _approve(_msgSender(), spender_, currentAllowance - subtractedValue_);

        return true;
    }

    function _transfer(address sender_, address recipient_, uint256 amount_) internal {
        require(sender_ != address(0), "ERC20: transfer from the zero address");
        require(recipient_ != address(0), "ERC20: transfer to the zero address");

        uint256 senderBalance = _state.balances[sender_];
        require(senderBalance >= amount_, "ERC20: transfer amount exceeds balance");
        _state.balances[sender_] = senderBalance - amount_;
        _state.balances[recipient_] += amount_;

        emit Transfer(sender_, recipient_, amount_);
    }

    function mint(address account_, uint256 amount_) public onlyOwner {
        _mint(account_, amount_);
    }

    function _mint(address account_, uint256 amount_) internal {
        require(account_ != address(0), "ERC20: mint to the zero address");

        _state.totalSupply += amount_;
        _state.balances[account_] += amount_;
        emit Transfer(address(0), account_, amount_);
    }

    function burn(address account_, uint256 amount_) public onlyOwner {
        _burn(account_, amount_);
    }

    function _burn(address account_, uint256 amount_) internal {
        require(account_ != address(0), "ERC20: burn from the zero address");

        uint256 accountBalance = _state.balances[account_];
        require(accountBalance >= amount_, "ERC20: burn amount exceeds balance");
        _state.balances[account_] = accountBalance - amount_;
        _state.totalSupply -= amount_;

        emit Transfer(account_, address(0), amount_);
    }

    function _approve(address owner_, address spender_, uint256 amount_) internal virtual {
        require(owner_ != address(0), "ERC20: approve from the zero address");
        require(spender_ != address(0), "ERC20: approve to the zero address");

        _state.allowances[owner_][spender_] = amount_;
        emit Approval(owner_, spender_, amount_);
    }

    function updateDetails(string memory name_, string memory symbol_, uint64 sequence_) public onlyOwner {
        require(_state.metaLastUpdatedSequence < sequence_, "current metadata is up to date");

        _state.name = name_;
        _state.symbol = symbol_;
        _state.metaLastUpdatedSequence = sequence_;

        // Because the name is updated, we need to recache the domain separator.
        // For old implementations, none of the caches may have been written to yet.
        _initializePermitStateIfNeeded();
    }

    modifier onlyOwner() {
        require(owner() == _msgSender(), "caller is not the owner");
        _;
    }

    modifier initializer() {
        require(
            !_state.initialized,
            "Already initialized"
        );

        _state.initialized = true;

        _;
    }

    /**
     * @dev Returns the domain separator for the current chain.
     */
    function _domainSeparatorV4() internal view returns (bytes32) {
        if (address(this) == _state.cachedThis && block.chainid == _state.cachedChainId) {
            return _state.cachedDomainSeparator;
        } else {
            return _buildDomainSeparator(
                _eip712DomainNameHashed(), _eip712DomainSalt()
            );
        }
    }

    function _buildDomainSeparator(bytes32 hashedName, bytes32 salt) internal view returns (bytes32) {
        return keccak256(
            abi.encode(
                keccak256(
                    "EIP712Domain(string name,string version,uint256 chainId,address verifyingContract,bytes32 salt)"
                ),
                hashedName,
                keccak256(abi.encodePacked(_eip712DomainVersion())),
                block.chainid,
                address(this),
                salt
            )
        );
    }

    /**
     * @dev Given an already https://eips.ethereum.org/EIPS/eip-712#definition-of-hashstruct[hashed struct], this
     * function returns the hash of the fully encoded EIP712 message for this domain.
     *
     * This hash can be used together with {ECDSA-recover} to obtain the signer of a message. For example:
     *
     * ```solidity
     * bytes32 digest = _hashTypedDataV4(keccak256(abi.encode(
     *     keccak256("Mail(address to,string contents)"),
     *     mailTo,
     *     keccak256(bytes(mailContents))
     * )));
     * address signer = ECDSA.recover(digest, signature);
     * ```
     */
    function _hashTypedDataV4(bytes32 structHash) internal view returns (bytes32) {
        return ECDSA.toTypedDataHash(_domainSeparatorV4(), structHash);
    }

    /**
     * @dev See {IERC20Permit-permit}.
     */
    function permit(
        address owner_,
        address spender_,
        uint256 value_,
        uint256 deadline_,
        uint8 v_,
        bytes32 r_,
        bytes32 s_
    ) public {
        // for those tokens that have been initialized before permit, we need to set
        // the permit state variables if they have not been set before
        _initializePermitStateIfNeeded();

        // permit is only allowed before the signature's deadline
        require(block.timestamp <= deadline_, "ERC20Permit: expired deadline");

        bytes32 structHash = keccak256(
            abi.encode(
                keccak256(
                    "Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)"
                ),
                owner_,
                spender_,
                value_,
                _useNonce(owner_),
                deadline_
            )
        );

        bytes32 message = _hashTypedDataV4(structHash);
        address signer = ECDSA.recover(message, v_, r_, s_);

        // if we cannot recover the token owner, signature is invalid
        require(signer == owner_, "ERC20Permit: invalid signature");

        _approve(owner_, spender_, value_);
    }

    /**
     * @dev See {IERC20Permit-DOMAIN_SEPARATOR}.
     */
    // solhint-disable-next-line func-name-mixedcase
    function DOMAIN_SEPARATOR() public view returns (bytes32) {
        return _domainSeparatorV4();
    }

    function eip712Domain() public view returns (
        bytes1 domainFields,
        string memory domainName,
        string memory domainVersion,
        uint256 domainChainId,
        address domainVerifyingContract,
        bytes32 domainSalt,
        uint256[] memory domainExtensions
    ) {
        return (
            hex"1F", // 11111
            name(),
            _eip712DomainVersion(),
            block.chainid,
            address(this),
            _eip712DomainSalt(),
            new uint256[](0)
        );
    }

    function _eip712DomainVersion() internal pure returns (string memory) {
        return "1";
    }

    function _eip712DomainNameHashed() internal view returns (bytes32) {
        return keccak256(abi.encodePacked(name()));
    }

    function _eip712DomainSalt() internal view returns (bytes32) {
        return keccak256(abi.encodePacked(_state.chainId, _state.nativeContract));
    }
}

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

pragma solidity ^0.8.0;

import "@openzeppelin/contracts/utils/Counters.sol";

contract TokenStorage {
    struct State {
        string name;
        string symbol;

        uint64 metaLastUpdatedSequence;

        uint256 totalSupply;
        uint8 decimals;

        mapping(address => uint256) balances;

        mapping(address => mapping(address => uint256)) allowances;

        address owner;

        bool initialized;

        uint16 chainId;
        bytes32 nativeContract;

        // EIP712
        // Cache the domain separator and salt, but also store the chain id that 
        // it corresponds to, in order to invalidate the cached domain separator
        // if the chain id changes.
        bytes32 cachedDomainSeparator;
        uint256 cachedChainId;
        address cachedThis;
        bytes32 cachedSalt;
        bytes32 cachedHashedName;

        // ERC20Permit draft
        mapping(address => Counters.Counter) nonces;
    }
}

contract TokenState {
    using Counters for Counters.Counter;

    TokenStorage.State _state;

    /**
     * @dev See {IERC20Permit-nonces}.
     */
    function nonces(address owner_) public view returns (uint256) {
        return _state.nonces[owner_].current();
    }

    /**
     * @dev "Consume a nonce": return the current value and increment.
     */
    function _useNonce(address owner_) internal returns (uint256 current) {
        Counters.Counter storage nonce = _state.nonces[owner_];
        current = nonce.current();
        nonce.increment();
    }
}

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

pragma solidity ^0.8.0;

import "../Structs.sol";

interface IWormhole is Structs {
    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 (Structs.VM memory vm, bool valid, string memory reason);

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

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

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

    function getGuardianSet(uint32 index) external view returns (Structs.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) ;
}

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

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

• No Contract Security Audit Submitted- Submit Audit Here

[{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"previousAdmin","type":"address"},{"indexed":false,"internalType":"address","name":"newAdmin","type":"address"}],"name":"AdminChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"beacon","type":"address"}],"name":"BeaconUpgraded","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"oldContract","type":"address"},{"indexed":true,"internalType":"address","name":"newContract","type":"address"}],"name":"ContractUpgraded","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"implementation","type":"address"}],"name":"Upgraded","type":"event"},{"inputs":[],"name":"WETH","outputs":[{"internalType":"contract IWETH","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes","name":"encoded","type":"bytes"}],"name":"_parseTransferCommon","outputs":[{"components":[{"internalType":"uint8","name":"payloadID","type":"uint8"},{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"bytes32","name":"tokenAddress","type":"bytes32"},{"internalType":"uint16","name":"tokenChain","type":"uint16"},{"internalType":"bytes32","name":"to","type":"bytes32"},{"internalType":"uint16","name":"toChain","type":"uint16"},{"internalType":"uint256","name":"fee","type":"uint256"}],"internalType":"struct BridgeStructs.Transfer","name":"transfer","type":"tuple"}],"stateMutability":"pure","type":"function"},{"inputs":[{"internalType":"address","name":"tokenAddress","type":"address"},{"internalType":"uint32","name":"nonce","type":"uint32"}],"name":"attestToken","outputs":[{"internalType":"uint64","name":"sequence","type":"uint64"}],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"uint16","name":"chainId_","type":"uint16"}],"name":"bridgeContracts","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"chainId","outputs":[{"internalType":"uint16","name":"","type":"uint16"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes","name":"encodedVm","type":"bytes"}],"name":"completeTransfer","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes","name":"encodedVm","type":"bytes"}],"name":"completeTransferAndUnwrapETH","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes","name":"encodedVm","type":"bytes"}],"name":"completeTransferAndUnwrapETHWithPayload","outputs":[{"internalType":"bytes","name":"","type":"bytes"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes","name":"encodedVm","type":"bytes"}],"name":"completeTransferWithPayload","outputs":[{"internalType":"bytes","name":"","type":"bytes"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes","name":"encodedVm","type":"bytes"}],"name":"createWrapped","outputs":[{"internalType":"address","name":"token","type":"address"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"components":[{"internalType":"uint8","name":"payloadID","type":"uint8"},{"internalType":"bytes32","name":"tokenAddress","type":"bytes32"},{"internalType":"uint16","name":"tokenChain","type":"uint16"},{"internalType":"uint8","name":"decimals","type":"uint8"},{"internalType":"bytes32","name":"symbol","type":"bytes32"},{"internalType":"bytes32","name":"name","type":"bytes32"}],"internalType":"struct BridgeStructs.AssetMeta","name":"meta","type":"tuple"}],"name":"encodeAssetMeta","outputs":[{"internalType":"bytes","name":"encoded","type":"bytes"}],"stateMutability":"pure","type":"function"},{"inputs":[{"components":[{"internalType":"uint8","name":"payloadID","type":"uint8"},{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"bytes32","name":"tokenAddress","type":"bytes32"},{"internalType":"uint16","name":"tokenChain","type":"uint16"},{"internalType":"bytes32","name":"to","type":"bytes32"},{"internalType":"uint16","name":"toChain","type":"uint16"},{"internalType":"uint256","name":"fee","type":"uint256"}],"internalType":"struct BridgeStructs.Transfer","name":"transfer","type":"tuple"}],"name":"encodeTransfer","outputs":[{"internalType":"bytes","name":"encoded","type":"bytes"}],"stateMutability":"pure","type":"function"},{"inputs":[{"components":[{"internalType":"uint8","name":"payloadID","type":"uint8"},{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"bytes32","name":"tokenAddress","type":"bytes32"},{"internalType":"uint16","name":"tokenChain","type":"uint16"},{"internalType":"bytes32","name":"to","type":"bytes32"},{"internalType":"uint16","name":"toChain","type":"uint16"},{"internalType":"bytes32","name":"fromAddress","type":"bytes32"},{"internalType":"bytes","name":"payload","type":"bytes"}],"internalType":"struct BridgeStructs.TransferWithPayload","name":"transfer","type":"tuple"}],"name":"encodeTransferWithPayload","outputs":[{"internalType":"bytes","name":"encoded","type":"bytes"}],"stateMutability":"pure","type":"function"},{"inputs":[],"name":"evmChainId","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"finality","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"hash","type":"bytes32"}],"name":"governanceActionIsConsumed","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"governanceChainId","outputs":[{"internalType":"uint16","name":"","type":"uint16"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"governanceContract","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"implementation","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"initialize","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"isFork","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"impl","type":"address"}],"name":"isInitialized","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"hash","type":"bytes32"}],"name":"isTransferCompleted","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"token","type":"address"}],"name":"isWrappedAsset","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"token","type":"address"}],"name":"outstandingBridged","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes","name":"encoded","type":"bytes"}],"name":"parseAssetMeta","outputs":[{"components":[{"internalType":"uint8","name":"payloadID","type":"uint8"},{"internalType":"bytes32","name":"tokenAddress","type":"bytes32"},{"internalType":"uint16","name":"tokenChain","type":"uint16"},{"internalType":"uint8","name":"decimals","type":"uint8"},{"internalType":"bytes32","name":"symbol","type":"bytes32"},{"internalType":"bytes32","name":"name","type":"bytes32"}],"internalType":"struct BridgeStructs.AssetMeta","name":"meta","type":"tuple"}],"stateMutability":"pure","type":"function"},{"inputs":[{"internalType":"bytes","name":"encoded","type":"bytes"}],"name":"parsePayloadID","outputs":[{"internalType":"uint8","name":"payloadID","type":"uint8"}],"stateMutability":"pure","type":"function"},{"inputs":[{"internalType":"bytes","name":"encodedRecoverChainId","type":"bytes"}],"name":"parseRecoverChainId","outputs":[{"components":[{"internalType":"bytes32","name":"module","type":"bytes32"},{"internalType":"uint8","name":"action","type":"uint8"},{"internalType":"uint256","name":"evmChainId","type":"uint256"},{"internalType":"uint16","name":"newChainId","type":"uint16"}],"internalType":"struct BridgeStructs.RecoverChainId","name":"rci","type":"tuple"}],"stateMutability":"pure","type":"function"},{"inputs":[{"internalType":"bytes","name":"encoded","type":"bytes"}],"name":"parseRegisterChain","outputs":[{"components":[{"internalType":"bytes32","name":"module","type":"bytes32"},{"internalType":"uint8","name":"action","type":"uint8"},{"internalType":"uint16","name":"chainId","type":"uint16"},{"internalType":"uint16","name":"emitterChainID","type":"uint16"},{"internalType":"bytes32","name":"emitterAddress","type":"bytes32"}],"internalType":"struct BridgeStructs.RegisterChain","name":"chain","type":"tuple"}],"stateMutability":"pure","type":"function"},{"inputs":[{"internalType":"bytes","name":"encoded","type":"bytes"}],"name":"parseTransfer","outputs":[{"components":[{"internalType":"uint8","name":"payloadID","type":"uint8"},{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"bytes32","name":"tokenAddress","type":"bytes32"},{"internalType":"uint16","name":"tokenChain","type":"uint16"},{"internalType":"bytes32","name":"to","type":"bytes32"},{"internalType":"uint16","name":"toChain","type":"uint16"},{"internalType":"uint256","name":"fee","type":"uint256"}],"internalType":"struct BridgeStructs.Transfer","name":"transfer","type":"tuple"}],"stateMutability":"pure","type":"function"},{"inputs":[{"internalType":"bytes","name":"encoded","type":"bytes"}],"name":"parseTransferWithPayload","outputs":[{"components":[{"internalType":"uint8","name":"payloadID","type":"uint8"},{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"bytes32","name":"tokenAddress","type":"bytes32"},{"internalType":"uint16","name":"tokenChain","type":"uint16"},{"internalType":"bytes32","name":"to","type":"bytes32"},{"internalType":"uint16","name":"toChain","type":"uint16"},{"internalType":"bytes32","name":"fromAddress","type":"bytes32"},{"internalType":"bytes","name":"payload","type":"bytes"}],"internalType":"struct BridgeStructs.TransferWithPayload","name":"transfer","type":"tuple"}],"stateMutability":"pure","type":"function"},{"inputs":[{"internalType":"bytes","name":"encoded","type":"bytes"}],"name":"parseUpgrade","outputs":[{"components":[{"internalType":"bytes32","name":"module","type":"bytes32"},{"internalType":"uint8","name":"action","type":"uint8"},{"internalType":"uint16","name":"chainId","type":"uint16"},{"internalType":"bytes32","name":"newContract","type":"bytes32"}],"internalType":"struct BridgeStructs.UpgradeContract","name":"chain","type":"tuple"}],"stateMutability":"pure","type":"function"},{"inputs":[{"internalType":"bytes","name":"encodedVM","type":"bytes"}],"name":"registerChain","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes","name":"encodedVM","type":"bytes"}],"name":"submitRecoverChainId","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"tokenImplementation","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"token","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"uint16","name":"recipientChain","type":"uint16"},{"internalType":"bytes32","name":"recipient","type":"bytes32"},{"internalType":"uint256","name":"arbiterFee","type":"uint256"},{"internalType":"uint32","name":"nonce","type":"uint32"}],"name":"transferTokens","outputs":[{"internalType":"uint64","name":"sequence","type":"uint64"}],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"address","name":"token","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"uint16","name":"recipientChain","type":"uint16"},{"internalType":"bytes32","name":"recipient","type":"bytes32"},{"internalType":"uint32","name":"nonce","type":"uint32"},{"internalType":"bytes","name":"payload","type":"bytes"}],"name":"transferTokensWithPayload","outputs":[{"internalType":"uint64","name":"sequence","type":"uint64"}],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"bytes","name":"encodedVm","type":"bytes"}],"name":"updateWrapped","outputs":[{"internalType":"address","name":"token","type":"address"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes","name":"encodedVM","type":"bytes"}],"name":"upgrade","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"wormhole","outputs":[{"internalType":"contract IWormhole","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint16","name":"recipientChain","type":"uint16"},{"internalType":"bytes32","name":"recipient","type":"bytes32"},{"internalType":"uint256","name":"arbiterFee","type":"uint256"},{"internalType":"uint32","name":"nonce","type":"uint32"}],"name":"wrapAndTransferETH","outputs":[{"internalType":"uint64","name":"sequence","type":"uint64"}],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"uint16","name":"recipientChain","type":"uint16"},{"internalType":"bytes32","name":"recipient","type":"bytes32"},{"internalType":"uint32","name":"nonce","type":"uint32"},{"internalType":"bytes","name":"payload","type":"bytes"}],"name":"wrapAndTransferETHWithPayload","outputs":[{"internalType":"uint64","name":"sequence","type":"uint64"}],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"uint16","name":"tokenChainId","type":"uint16"},{"internalType":"bytes32","name":"tokenAddress","type":"bytes32"}],"name":"wrappedAsset","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"stateMutability":"payable","type":"receive"}]

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