Contract 0xe6469ba6d2fd6130788e0ea9c0a0515900563b59 3

 
 
Txn Hash Method
Block
From
To
Value [Txn Fee]
0x13b6af8e26f2ee0e3c67d66ba9a23eabf3c546eb54fe12ba76b273a7d4cff88fApprove361471372022-11-27 21:51:5623 hrs 34 mins ago0xace7c2c094f2e82af0e958106e99f98507937165 IN  Wormhole: UST Token0 MATIC0.002168555761 35.28000002
0x1e0e777573d32dd28ba1030dcfa7319d4d940b2048076834ddb87a69a4b4af94Approve360815332022-11-26 7:16:352 days 14 hrs ago0x4e7fb1e8be259a1c5dcabd36c25d9aa21b25226d IN  Wormhole: UST Token0 MATIC0.002243884536.3
0xa76de1be979c69413b72939702494d5cbcf805be4e808e3502b44e2920c9161eApprove360558902022-11-25 16:26:573 days 4 hrs ago0x6b4d44a9eb8dd9ee9d4b64a8e3a0a17b9cb319c6 IN  Wormhole: UST Token0 MATIC0.0019765550
0x26956f9bfac7c78d8f8b79aa74f9e6caafa0fff29c680ca8a72102db23f4c9eaApprove359813262022-11-23 21:05:575 days 20 mins ago0x3a7da9387a482bf2b0a1c05dcba4163c5f3823ff IN  Wormhole: UST Token0 MATIC0.001533802802 38.800000068
0x2b9efa2bb98c5a261d144877efc29c29ffa6154e4d58255c54a4ee4af0f36c30Approve359618872022-11-23 9:44:075 days 11 hrs ago0x5ab6831a52833060f79bcff2f49de79d72f2d366 IN  Wormhole: UST Token0 MATIC0.002047987937 33.130921907
0xd376ada3c9c58836712edddddceaa59133b8e17ca8f26d43a503c65743e1f2caApprove359598132022-11-23 8:30:435 days 12 hrs ago0xc40d11942e762f8eba72b76698a1519f69aea8b3 IN  Wormhole: UST Token0 MATIC0.002154838748 34.859479871
0x8a4521ab5e42bc7d995ab6ee316a874e63fc6d53d4c7363aece3da720f3ff872Approve359480032022-11-23 1:28:365 days 19 hrs ago0xd7295821ac21baafa398545f28f0b012daeb74f2 IN  Wormhole: UST Token0 MATIC0.001341450002 30.000000052
0xa6d9395c927ae160738f29a45894a957a52178bbd7596a8d886f97e744ae2d72Approve359313782022-11-22 15:49:486 days 5 hrs ago0x9a820295e3da3220f782bb1f4dc46065e418c079 IN  Wormhole: UST Token0 MATIC0.018371418297.2
0x8096497465c75dd58c3adb517417bac1b06c6c116da17a17b8bd8203089e95caApprove359300262022-11-22 15:03:206 days 6 hrs ago0x6fce63859a859a0f30ed09b12f5010d790618ca4 IN  Wormhole: UST Token0 MATIC0.008691531077 140.605533887
0xade74932cd42e58f4669e285873e5546cef789f70a2e009b58d1062f401ed718Approve359071412022-11-22 1:43:556 days 19 hrs ago0xd15962cb41e8ce055fcdf8ef52e67f3da0e15c45 IN  Wormhole: UST Token0 MATIC0.00203989500133.000000018
0x9ad494a2638c617368682c1dcebb49d1a958e2b3c930507e37d81983399b3e08Approve359047652022-11-22 0:21:566 days 21 hrs ago0xede67b42ea5e7d56847f1c7bcf5c408447591593 IN  Wormhole: UST Token0 MATIC0.009272261393 150.000184313
0xa751c6911c9eee62fde4e7ad3c052cc51d6c704d7b5216acdda20105ccb2242bApprove358942092022-11-21 18:16:357 days 3 hrs ago0xc13fd7748a6885720ceb172ca36b76e11b626dec IN  Wormhole: UST Token0 MATIC0.002551822241 41.28160223
0x3bc5001101d76f856302675ec82696c623051959a7256456d50874e8db270522Approve358941232022-11-21 18:13:357 days 3 hrs ago0xc13fd7748a6885720ceb172ca36b76e11b626dec IN  Wormhole: UST Token0 MATIC0.005198514631 84.097947611
0x1ef51395d8b37682b211bda6d54e5aad731c9a71943bbd9fdfd403b7ab47cd6dApprove358744712022-11-21 6:49:437 days 14 hrs ago0xe35d5ca7dd27bda27fa571b888ab0b4d085fa831 IN  Wormhole: UST Token0 MATIC0.00184439723 30.00044293
0x1a27c18fe224393a1f55510ba4f46d8bce58a45f8aa91e10c72b2df620436ff8Approve358743892022-11-21 6:46:557 days 14 hrs ago0xe35d5ca7dd27bda27fa571b888ab0b4d085fa831 IN  Wormhole: UST Token0 MATIC0.009221879655 150.000482369
0x72d6bd104c2b687947dc31d741ee7fc63468b78845a14654e544ef642d49a6b2Approve358697042022-11-21 4:01:207 days 17 hrs ago0xd0e6fbfc74c02629c79b30fbf883255fc20400d7 IN  Wormhole: UST Token0 MATIC0.001266094863 32.037624009
0x2bb6e38687ac2ddb9b327c7e550d079e6bcd4e912973cf21d8b66978151e38c3Approve358588402022-11-20 21:30:387 days 23 hrs ago0x5a27e6d28f450cba093eddde16bef93ba7dfd563 IN  Wormhole: UST Token0 MATIC0.001854450001 30.000000021
0xea2f348890d6582a2e2e63d9c288027be27b13aa2e4fd6821fba00caad5115cbApprove358572102022-11-20 20:34:318 days 51 mins ago0xa6ac9160953731ff53742912586387e31d66848c IN  Wormhole: UST Token0 MATIC0.0028012536 45.6
0x6fd360e18bb895caed6b3369c9e1aa12a15c6296d788cf711f4ec863ae62e7f2Approve358396602022-11-20 10:28:178 days 10 hrs ago0x1202fec8938c47108ab5567d4d8b99682bc9d2fd IN  Wormhole: UST Token0 MATIC0.001301882045 32.933192813
0xab43193a1030b23f86d250e24946d4e6ab1ee9087d38cd776eb17ab008f30b4dApprove358393592022-11-20 10:17:548 days 11 hrs ago0x2a9f2ce38c8bb0330cc5eca32da420db393fb4b0 IN  Wormhole: UST Token0 MATIC0.001871390711 30.274055031
0x310f2f7da52df0220d750f5b9c74bdd2b8a03c5dc2f41c4ce915b31a1ff3c8a3Approve358365192022-11-20 8:39:368 days 12 hrs ago0x9328429372db08d406a8953f6b4bf9f6c86797aa IN  Wormhole: UST Token0 MATIC0.001854450003 30.000000058
0x3f8857c8f318bbc9014a731ec85b852c163b73fc05f7b1517db582e90444169cApprove358357522022-11-20 8:13:148 days 13 hrs ago0xf188ccdd5107fc2c04ede0ec04afbbf45dae275d IN  Wormhole: UST Token0 MATIC0.001185930052 30.000001318
0xf5334caa0cef1d6b9850d3c4490a276c657e4eb7844c3328a71422bc08e4c55fApprove358101562022-11-19 17:27:589 days 3 hrs ago0xfcc92f0d50f43a3798041afd7e2c918cfb8b28ad IN  Wormhole: UST Token0 MATIC0.001397885154 35.361745319
0xc203dbd4b3a8158a4b8c6895532bfb768d0d6a93d5a2d31c474fe97588da72fcApprove358026642022-11-19 13:06:109 days 8 hrs ago0x5284b794ad97dc93ca0f6593c5bb0d7116c45d3b IN  Wormhole: UST Token0 MATIC0.001296961182 32.808711705
0xb0fd4cbc3ef36e4effeff4dcf90132f33c8abf629f689646f144907d94f752dbApprove358026362022-11-19 13:05:149 days 8 hrs ago0x5284b794ad97dc93ca0f6593c5bb0d7116c45d3b IN  Wormhole: UST Token0 MATIC0.001316041527 33.291379602
[ Download CSV Export 

OVERVIEW

Wormhole is a generic message passing protocol that connects to multiple chains including Ethereum, Solana, Terra, Binance Smart Chain, Polygon, Avalanche and Oasis.

Latest 1 internal transaction
Parent Txn Hash Block From To Value
0xbd10eab4a1fbb7187aa23978a2e79b41aedc8e65032329715d89a34d08e48330211720802021-11-09 14:39:55384 days 6 hrs ago Wormhole: Token Bridge  Contract Creation0 MATIC
[ Download CSV Export 
Loading

Similar Match Source Code
Note: This contract matches the deployed ByteCode of the Source Code for Contract 0x5E0294Af1732498C77F8dB015a2d52a76298542B

Contract Name:
BridgeToken

Compiler Version
v0.8.4+commit.c7e474f2

Optimization Enabled:
Yes with 1000 runs

Other Settings:
default evmVersion, Apache-2.0 license

Contract Source Code (Solidity)

/**
 *Submitted for verification at polygonscan.com on 2021-12-08
*/

// SPDX-License-Identifier: Apache 2

// File: @openzeppelin/contracts/utils/StorageSlot.sol


// OpenZeppelin Contracts v4.4.0 (utils/StorageSlot.sol)

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

// File: @openzeppelin/contracts/utils/Address.sol


// OpenZeppelin Contracts v4.4.0 (utils/Address.sol)

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

// File: @openzeppelin/contracts/proxy/Proxy.sol


// OpenZeppelin Contracts v4.4.0 (proxy/Proxy.sol)

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

// File: @openzeppelin/contracts/proxy/beacon/IBeacon.sol


// OpenZeppelin Contracts v4.4.0 (proxy/beacon/IBeacon.sol)

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

// File: @openzeppelin/contracts/proxy/ERC1967/ERC1967Upgrade.sol


// OpenZeppelin Contracts v4.4.0 (proxy/ERC1967/ERC1967Upgrade.sol)

pragma solidity ^0.8.2;




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

// File: @openzeppelin/contracts/proxy/beacon/BeaconProxy.sol


// OpenZeppelin Contracts v4.4.0 (proxy/beacon/BeaconProxy.sol)

pragma solidity ^0.8.0;




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

// File: github/certusone/wormhole/ethereum/contracts/bridge/token/Token.sol

// contracts/Structs.sol


pragma solidity ^0.8.0;


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

    }
}

Contract Security Audit

Contract ABI

[{"inputs":[{"internalType":"address","name":"beacon","type":"address"},{"internalType":"bytes","name":"data","type":"bytes"}],"stateMutability":"nonpayable","type":"constructor"},{"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":"implementation","type":"address"}],"name":"Upgraded","type":"event"},{"stateMutability":"payable","type":"fallback"},{"stateMutability":"payable","type":"receive"}]

60806040523480156200001157600080fd5b5060405162000a3138038062000a318339810160408190526200003491620004ca565b81816200006360017fa3f0ad74e5423aebfd80d3ef4346578335a9a72aeaee59ff6cb3582b35133d51620005e7565b600080516020620009ea833981519152146200008f57634e487b7160e01b600052600160045260246000fd5b6200009d82826000620000a7565b5050505062000650565b620000b2836200018c565b6040516001600160a01b038416907f1cf3b03a6cf19fa2baba4df148e9dcabedea7f8a5c07840e207e5c089be95d3e90600090a2600082511180620000f45750805b15620001875762000185836001600160a01b0316635c60da1b6040518163ffffffff1660e01b815260040160206040518083038186803b1580156200013857600080fd5b505afa1580156200014d573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190620001739190620004ad565b836200033d60201b620000291760201c565b505b505050565b620001a2816200036c60201b620000551760201c565b620002025760405162461bcd60e51b815260206004820152602560248201527f455243313936373a206e657720626561636f6e206973206e6f74206120636f6e6044820152641d1c9858dd60da1b60648201526084015b60405180910390fd5b6200028c816001600160a01b0316635c60da1b6040518163ffffffff1660e01b815260040160206040518083038186803b1580156200024057600080fd5b505afa15801562000255573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906200027b9190620004ad565b6200036c60201b620000551760201c565b620002f35760405162461bcd60e51b815260206004820152603060248201527f455243313936373a20626561636f6e20696d706c656d656e746174696f6e206960448201526f1cc81b9bdd08184818dbdb9d1c9858dd60821b6064820152608401620001f9565b806200031c600080516020620009ea83398151915260001b6200037260201b6200005b1760201c565b80546001600160a01b0319166001600160a01b039290921691909117905550565b606062000365838360405180606001604052806027815260200162000a0a6027913962000375565b9392505050565b3b151590565b90565b6060833b620003d65760405162461bcd60e51b815260206004820152602660248201527f416464726573733a2064656c65676174652063616c6c20746f206e6f6e2d636f6044820152651b9d1c9858dd60d21b6064820152608401620001f9565b600080856001600160a01b031685604051620003f3919062000594565b600060405180830381855af49150503d806000811462000430576040519150601f19603f3d011682016040523d82523d6000602084013e62000435565b606091505b5090925090506200044882828662000452565b9695505050505050565b606083156200046357508162000365565b825115620004745782518084602001fd5b8160405162461bcd60e51b8152600401620001f99190620005b2565b80516001600160a01b0381168114620004a857600080fd5b919050565b600060208284031215620004bf578081fd5b620003658262000490565b60008060408385031215620004dd578081fd5b620004e88362000490565b60208401519092506001600160401b038082111562000505578283fd5b818501915085601f83011262000519578283fd5b8151818111156200052e576200052e6200063a565b604051601f8201601f19908116603f011681019083821181831017156200055957620005596200063a565b8160405282815288602084870101111562000572578586fd5b620005858360208301602088016200060b565b80955050505050509250929050565b60008251620005a88184602087016200060b565b9190910192915050565b6020815260008251806020840152620005d38160408501602087016200060b565b601f01601f19169190910160400192915050565b6000828210156200060657634e487b7160e01b81526011600452602481fd5b500390565b60005b83811015620006285781810151838201526020016200060e565b83811115620001855750506000910152565b634e487b7160e01b600052604160045260246000fd5b61038a80620006606000396000f3fe60806040523661001357610011610017565b005b6100115b61002761002261005e565b610120565b565b606061004e838360405180606001604052806027815260200161032e60279139610144565b9392505050565b3b151590565b90565b600061009e7fa3f0ad74e5423aebfd80d3ef4346578335a9a72aeaee59ff6cb3582b35133d505473ffffffffffffffffffffffffffffffffffffffff1690565b73ffffffffffffffffffffffffffffffffffffffff16635c60da1b6040518163ffffffff1660e01b815260040160206040518083038186803b1580156100e357600080fd5b505afa1580156100f7573d6000803e3d6000fd5b505050506040513d601f19601f8201168201806040525081019061011b919061027a565b905090565b3660008037600080366000845af43d6000803e80801561013f573d6000f35b3d6000fd5b6060833b6101bf5760405162461bcd60e51b815260206004820152602660248201527f416464726573733a2064656c65676174652063616c6c20746f206e6f6e2d636f60448201527f6e7472616374000000000000000000000000000000000000000000000000000060648201526084015b60405180910390fd5b6000808573ffffffffffffffffffffffffffffffffffffffff16856040516101e791906102ae565b600060405180830381855af49150503d8060008114610222576040519150601f19603f3d011682016040523d82523d6000602084013e610227565b606091505b5091509150610237828286610241565b9695505050505050565b6060831561025057508161004e565b8251156102605782518084602001fd5b8160405162461bcd60e51b81526004016101b691906102ca565b60006020828403121561028b578081fd5b815173ffffffffffffffffffffffffffffffffffffffff8116811461004e578182fd5b600082516102c08184602087016102fd565b9190910192915050565b60208152600082518060208401526102e98160408501602087016102fd565b601f01601f19169190910160400192915050565b60005b83811015610318578181015183820152602001610300565b83811115610327576000848401525b5050505056fe416464726573733a206c6f772d6c6576656c2064656c65676174652063616c6c206661696c6564a2646970667358221220023fb812aee356ef775e058780e58e0f0e320743ef57a43f3069e9559fd8a41f64736f6c63430008040033a3f0ad74e5423aebfd80d3ef4346578335a9a72aeaee59ff6cb3582b35133d50416464726573733a206c6f772d6c6576656c2064656c65676174652063616c6c206661696c65640000000000000000000000005a58505a96d1dbf8df91cb21b54419fc36e93fde00000000000000000000000000000000000000000000000000000000000000400000000000000000000000000000000000000000000000000000000000000164c71f461500000000000000000000000000000000000000000000000000000000000000e0000000000000000000000000000000000000000000000000000000000000012000000000000000000000000000000000000000000000000000000000000000120000000000000000000000000000000000000000000000000000000000001dcd0000000000000000000000005a58505a96d1dbf8df91cb21b54419fc36e93fde0000000000000000000000000000000000000000000000000000000000000002000000000000000000000000727f064a78dc734d33eec18d5370aef32ffd46e400000000000000000000000000000000000000000000000000000000000000114f72696f6e204d6f6e657920546f6b656e00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000054f52494f4e00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000

Deployed ByteCode Sourcemap

23813:129:0:-:0;;;;;;13768:11;:9;:11::i;:::-;23813:129;;13537:11;13174:113;13251:28;13261:17;:15;:17::i;:::-;13251:9;:28::i;:::-;13174:113::o;9051:200::-;9134:12;9166:77;9187:6;9195:4;9166:77;;;;;;;;;;;;;;;;;:20;:77::i;:::-;9159:84;9051:200;-1:-1:-1;;;9051:200:0:o;3457:387::-;3780:20;3828:8;;;3457:387::o;1717:151::-;1846:4;1821:40::o;23002:140::-;23069:7;23104:12;19974:66;20301:46;;;;20229:126;23104:12;23096:36;;;:38;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;23089:45;;23002:140;:::o;11764:918::-;12107:14;12104:1;12101;12088:34;12325:1;12322;12306:14;12303:1;12287:14;12280:5;12267:60;12404:16;12401:1;12398;12383:38;12444:6;12513:68;;;;12632:16;12629:1;12622:27;12513:68;12549:16;12546:1;12539:27;9445:396;9590:12;3780:20;;9615:69;;;;-1:-1:-1;;;9615:69:0;;1221:2:1;9615:69:0;;;1203:21:1;1260:2;1240:18;;;1233:30;1299:34;1279:18;;;1272:62;1370:8;1350:18;;;1343:36;1396:19;;9615:69:0;;;;;;;;;9698:12;9712:23;9739:6;:19;;9759:4;9739:25;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;9697:67;;;;9782:51;9799:7;9808:10;9820:12;9782:16;:51::i;:::-;9775:58;9445:396;-1:-1:-1;;;;;;9445:396:0:o;10069:712::-;10219:12;10248:7;10244:530;;;-1:-1:-1;10279:10:0;10272:17;;10244:530;10393:17;;:21;10389:374;;10591:10;10585:17;10652:15;10639:10;10635:2;10631:19;10624:44;10539:148;10734:12;10727:20;;-1:-1:-1;;;10727:20:0;;;;;;;;:::i;14:333:1:-;84:6;137:2;125:9;116:7;112:23;108:32;105:2;;;158:6;150;143:22;105:2;195:9;189:16;245:42;238:5;234:54;227:5;224:65;214:2;;308:6;300;293:22;352:274;481:3;519:6;513:13;535:53;581:6;576:3;569:4;561:6;557:17;535:53;:::i;:::-;604:16;;;;;489:137;-1:-1:-1;;489:137:1:o;631:383::-;780:2;769:9;762:21;743:4;812:6;806:13;855:6;850:2;839:9;835:18;828:34;871:66;930:6;925:2;914:9;910:18;905:2;897:6;893:15;871:66;:::i;:::-;998:2;977:15;-1:-1:-1;;973:29:1;958:45;;;;1005:2;954:54;;752:262;-1:-1:-1;;752:262:1:o;1426:258::-;1498:1;1508:113;1522:6;1519:1;1516:13;1508:113;;;1598:11;;;1592:18;1579:11;;;1572:39;1544:2;1537:10;1508:113;;;1639:6;1636:1;1633:13;1630:2;;;1674:1;1665:6;1660:3;1656:16;1649:27;1630:2;;1479:205;;;:::o

Swarm Source

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