MATIC Price: $0.571996 (-0.93%)
Gas: 31 GWei
 

Overview

Max Total Supply

20,280 LayerZero BONUS

Holders

19,922

Market

Volume (24H)

N/A

Min Price (24H)

N/A

Max Price (24H)

N/A

Other Info

Balance
1 LayerZero BONUS
0xc00f5b7a5faaf5354cf62d4969b63dbc7c6d01c0
Loading...
Loading
Loading...
Loading
Loading...
Loading

Click here to update the token information / general information
This contract may be a proxy contract. Click on More Options and select Is this a proxy? to confirm and enable the "Read as Proxy" & "Write as Proxy" tabs.

Contract Source Code Verified (Exact Match)

Contract Name:
ERC721UpgradeableProxy

Compiler Version
v0.8.19+commit.7dd6d404

Optimization Enabled:
No with 200 runs

Other Settings:
default evmVersion, MIT license

Contract Source Code (Solidity)

/**
 *Submitted for verification at polygonscan.com on 2023-07-21
*/

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.19;

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

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


// OpenZeppelin Contracts (last updated v4.9.0) (utils/Address.sol)

/**
 * @dev Collection of functions related to the address type
 */
library Address {
    /**
     * @dev The ETH balance of the account is not enough to perform the operation.
     */
    error AddressInsufficientBalance(address account);

    /**
     * @dev There's no code at `target` (it is not a contract).
     */
    error AddressEmptyCode(address target);

    /**
     * @dev A call to an address target failed. The target may have reverted.
     */
    error FailedInnerCall();

    /**
     * @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://consensys.net/diligence/blog/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.8.0/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
     */
    function sendValue(address payable recipient, uint256 amount) internal {
        if (address(this).balance < amount) {
            revert AddressInsufficientBalance(address(this));
        }

        (bool success, ) = recipient.call{value: amount}("");
        if (!success) {
            revert FailedInnerCall();
        }
    }

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

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with a
     * `customRevert` function as a fallback when `target` reverts.
     *
     * Requirements:
     *
     * - `customRevert` must be a reverting function.
     *
     * _Available since v5.0._
     */
    function functionCall(
        address target,
        bytes memory data,
        function() internal view customRevert
    ) internal returns (bytes memory) {
        return functionCallWithValue(target, data, 0, customRevert);
    }

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

    /**
     * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but
     * with a `customRevert` function as a fallback revert reason when `target` reverts.
     *
     * Requirements:
     *
     * - `customRevert` must be a reverting function.
     *
     * _Available since v5.0._
     */
    function functionCallWithValue(
        address target,
        bytes memory data,
        uint256 value,
        function() internal view customRevert
    ) internal returns (bytes memory) {
        if (address(this).balance < value) {
            revert AddressInsufficientBalance(address(this));
        }
        (bool success, bytes memory returndata) = target.call{value: value}(data);
        return verifyCallResultFromTarget(target, success, returndata, customRevert);
    }

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

    /**
     * @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,
        function() internal view customRevert
    ) internal view returns (bytes memory) {
        (bool success, bytes memory returndata) = target.staticcall(data);
        return verifyCallResultFromTarget(target, success, returndata, customRevert);
    }

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

    /**
     * @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,
        function() internal view customRevert
    ) internal returns (bytes memory) {
        (bool success, bytes memory returndata) = target.delegatecall(data);
        return verifyCallResultFromTarget(target, success, returndata, customRevert);
    }

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

    /**
     * @dev Tool to verify that a low level call was successful, and revert if it wasn't, either by bubbling the
     * revert reason or with a default revert error.
     *
     * _Available since v5.0._
     */
    function verifyCallResult(bool success, bytes memory returndata) internal view returns (bytes memory) {
        return verifyCallResult(success, returndata, defaultRevert);
    }

    /**
     * @dev Same as {xref-Address-verifyCallResult-bool-bytes-}[`verifyCallResult`], but with a
     * `customRevert` function as a fallback when `success` is `false`.
     *
     * Requirements:
     *
     * - `customRevert` must be a reverting function.
     *
     * _Available since v5.0._
     */
    function verifyCallResult(
        bool success,
        bytes memory returndata,
        function() internal view customRevert
    ) internal view returns (bytes memory) {
        if (success) {
            return returndata;
        } else {
            _revert(returndata, customRevert);
        }
    }

    /**
     * @dev Default reverting function when no `customRevert` is provided in a function call.
     */
    function defaultRevert() internal pure {
        revert FailedInnerCall();
    }

    function _revert(bytes memory returndata, function() internal view customRevert) private view {
        // Look for revert reason and bubble it up if present
        if (returndata.length > 0) {
            // The easiest way to bubble the revert reason is using memory via assembly
            /// @solidity memory-safe-assembly
            assembly {
                let returndata_size := mload(returndata)
                revert(add(32, returndata), returndata_size)
            }
        } else {
            customRevert();
            revert FailedInnerCall();
        }
    }
}

// OpenZeppelin Contracts (last updated v4.9.0) (utils/StorageSlot.sol)
// This file was procedurally generated from scripts/generate/templates/StorageSlot.js.

/**
 * @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:
 * ```solidity
 * 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(newImplementation.code.length > 0);
 *         StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value = newImplementation;
 *     }
 * }
 * ```
 *
 * _Available since v4.1 for `address`, `bool`, `bytes32`, `uint256`._
 * _Available since v4.9 for `string`, `bytes`._
 */
library StorageSlot {
    struct AddressSlot {
        address value;
    }

    struct BooleanSlot {
        bool value;
    }

    struct Bytes32Slot {
        bytes32 value;
    }

    struct Uint256Slot {
        uint256 value;
    }

    struct StringSlot {
        string value;
    }

    struct BytesSlot {
        bytes value;
    }

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

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

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

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

    /**
     * @dev Returns an `StringSlot` with member `value` located at `slot`.
     */
    function getStringSlot(bytes32 slot) internal pure returns (StringSlot storage r) {
        /// @solidity memory-safe-assembly
        assembly {
            r.slot := slot
        }
    }

    /**
     * @dev Returns an `StringSlot` representation of the string storage pointer `store`.
     */
    function getStringSlot(string storage store) internal pure returns (StringSlot storage r) {
        /// @solidity memory-safe-assembly
        assembly {
            r.slot := store.slot
        }
    }

    /**
     * @dev Returns an `BytesSlot` with member `value` located at `slot`.
     */
    function getBytesSlot(bytes32 slot) internal pure returns (BytesSlot storage r) {
        /// @solidity memory-safe-assembly
        assembly {
            r.slot := slot
        }
    }

    /**
     * @dev Returns an `BytesSlot` representation of the bytes storage pointer `store`.
     */
    function getBytesSlot(bytes storage store) internal pure returns (BytesSlot storage r) {
        /// @solidity memory-safe-assembly
        assembly {
            r.slot := store.slot
        }
    }
}

// OpenZeppelin Contracts (last updated v4.6.0) (proxy/Proxy.sol)

/**
 * @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 internal 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 overridden 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 internal 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 overridden should call `super._beforeFallback()`.
     */
    function _beforeFallback() internal virtual {}
}

// OpenZeppelin Contracts (last updated v4.9.0) (proxy/ERC1967/ERC1967Utils.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._
 */
library ERC1967Utils {
    // We re-declare ERC-1967 events here because they can't be used directly from IERC1967.
    // This will be fixed in Solidity 0.8.21. At that point we should remove these events.
    /**
     * @dev Emitted when the implementation is upgraded.
     */
    event Upgraded(address indexed implementation);

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

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

    /**
     * @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.
     */
    // solhint-disable-next-line private-vars-leading-underscore
    bytes32 internal constant IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;

    /**
     * @dev The `implementation` of the proxy is invalid.
     */
    error ERC1967InvalidImplementation(address implementation);

    /**
     * @dev The `admin` of the proxy is invalid.
     */
    error ERC1967InvalidAdmin(address admin);

    /**
     * @dev The `beacon` of the proxy is invalid.
     */
    error ERC1967InvalidBeacon(address beacon);

    /**
     * @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 {
        if (newImplementation.code.length == 0) {
            revert ERC1967InvalidImplementation(newImplementation);
        }
        StorageSlot.getAddressSlot(IMPLEMENTATION_SLOT).value = newImplementation;
    }

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

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

    /**
     * @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.
     */
    // solhint-disable-next-line private-vars-leading-underscore
    bytes32 internal constant ADMIN_SLOT = 0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103;

    /**
     * @dev Returns the current admin.
     *
     * TIP: To get this value clients can read directly from the storage slot shown below (specified by EIP1967) using the
     * https://eth.wiki/json-rpc/API#eth_getstorageat[`eth_getStorageAt`] RPC call.
     * `0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103`
     */
    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 {
        if (newAdmin == address(0)) {
            revert ERC1967InvalidAdmin(address(0));
        }
        StorageSlot.getAddressSlot(ADMIN_SLOT).value = newAdmin;
    }

    /**
     * @dev Changes the admin of the proxy.
     *
     * Emits an {IERC1967-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.
     */
    // solhint-disable-next-line private-vars-leading-underscore
    bytes32 internal constant BEACON_SLOT = 0xa3f0ad74e5423aebfd80d3ef4346578335a9a72aeaee59ff6cb3582b35133d50;

    /**
     * @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 {
        if (newBeacon.code.length == 0) {
            revert ERC1967InvalidBeacon(newBeacon);
        }

        address beaconImplementation = IBeacon(newBeacon).implementation();
        if (beaconImplementation.code.length == 0) {
            revert ERC1967InvalidImplementation(beaconImplementation);
        }

        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 an {IERC1967-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);
        }
    }
}

// OpenZeppelin Contracts (last updated v4.7.0) (proxy/ERC1967/ERC1967Proxy.sol)

/**
 * @dev This contract implements an upgradeable proxy. It is upgradeable because calls are delegated to an
 * implementation address that can be changed. This address is stored in storage in the location specified by
 * https://eips.ethereum.org/EIPS/eip-1967[EIP1967], so that it doesn't conflict with the storage layout of the
 * implementation behind the proxy.
 */
contract ERC1967Proxy is Proxy {
    /**
     * @dev Initializes the upgradeable proxy with an initial implementation specified by `_logic`.
     *
     * If `_data` is nonempty, it's used as data in a delegate call to `_logic`. This will typically be an encoded
     * function call, and allows initializing the storage of the proxy like a Solidity constructor.
     */
    constructor(address _logic, bytes memory _data) payable {
        ERC1967Utils.upgradeToAndCall(_logic, _data, false);
    }

    /**
     * @dev Returns the current implementation address.
     *
     * TIP: To get this value clients can read directly from the storage slot shown below (specified by EIP1967) using the
     * https://eth.wiki/json-rpc/API#eth_getstorageat[`eth_getStorageAt`] RPC call.
     * `0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc`
     */
    function _implementation() internal view virtual override returns (address impl) {
        return ERC1967Utils.getImplementation();
    }
}

// OpenZeppelin Contracts (last updated v4.9.0) (interfaces/IERC1967.sol)

/**
 * @dev ERC-1967: Proxy Storage Slots. This interface contains the events defined in the ERC.
 *
 * _Available since v4.8.3._
 */
interface IERC1967 {
    /**
     * @dev Emitted when the implementation is upgraded.
     */
    event Upgraded(address indexed implementation);

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

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


// OpenZeppelin Contracts (last updated v4.9.0) (proxy/transparent/TransparentUpgradeableProxy.sol)

/**
 * @dev Interface for {TransparentUpgradeableProxy}. In order to implement transparency, {TransparentUpgradeableProxy}
 * does not implement this interface directly, and some of its functions are implemented by an internal dispatch
 * mechanism. The compiler is unaware that these functions are implemented by {TransparentUpgradeableProxy} and will not
 * include them in the ABI so this interface must be used to interact with it.
 */
interface ITransparentUpgradeableProxy is IERC1967 {
    function upgradeTo(address) external;

    function upgradeToAndCall(address, bytes memory) external payable;
}

/**
 * @dev This contract implements a proxy that is upgradeable by an immutable admin.
 *
 * To avoid https://medium.com/nomic-labs-blog/malicious-backdoors-in-ethereum-proxies-62629adf3357[proxy selector
 * clashing], which can potentially be used in an attack, this contract uses the
 * https://blog.openzeppelin.com/the-transparent-proxy-pattern/[transparent proxy pattern]. This pattern implies two
 * things that go hand in hand:
 *
 * 1. If any account other than the admin calls the proxy, the call will be forwarded to the implementation, even if
 * that call matches one of the admin functions exposed by the proxy itself.
 * 2. If the admin calls the proxy, it can access the admin functions, but its calls will never be forwarded to the
 * implementation. If the admin tries to call a function on the implementation it will fail with an error indicating the
 * proxy admin cannot fallback to the target implementation.
 *
 * These properties mean that the admin account can only be used for upgrading the proxy, so it's best if it's a dedicated
 * account that is not used for anything else. This will avoid headaches due to sudden errors when trying to call a function
 * from the proxy implementation.
 *
 * Our recommendation is for the dedicated account to be an instance of the {ProxyAdmin} contract. If set up this way,
 * you should think of the `ProxyAdmin` instance as the real administrative interface of your proxy, which extends from the
 * {Ownable} contract to allow for changing the proxy's admin owner.
 *
 * NOTE: The real interface of this proxy is that defined in `ITransparentUpgradeableProxy`. This contract does not
 * inherit from that interface, and instead the admin functions are implicitly implemented using a custom dispatch
 * mechanism in `_fallback`. Consequently, the compiler will not produce an ABI for this contract. This is necessary to
 * fully implement transparency without decoding reverts caused by selector clashes between the proxy and the
 * implementation.
 *
 * IMPORTANT: This contract avoids unnecessary storage reads by setting the admin only during construction as an immutable variable,
 * preventing any changes thereafter. However, the admin slot defined in ERC-1967 can still be overwritten by the implementation
 * logic pointed to by this proxy. In such cases, the contract may end up in an undesirable state where the admin slot is different
 * from the actual admin.
 *
 * WARNING: It is not recommended to extend this contract to add additional external functions. If you do so, the compiler
 * will not check that there are no selector conflicts, due to the note above. A selector clash between any new function
 * and the functions declared in {ITransparentUpgradeableProxy} will be resolved in favor of the new one. This could
 * render the admin operations inaccessible, which could prevent upgradeability. Transparency may also be compromised.
 */
contract TransparentUpgradeableProxy is ERC1967Proxy {
    // An immutable address for the admin avoid unnecessary SLOADs before each call
    // at the expense of removing the ability to change the admin once it's set.
    // This is acceptable if the admin is always a ProxyAdmin instance or similar contract
    // with its own ability to transfer the permissions to another account.
    address private immutable _admin;

    /**
     * @dev The proxy caller is the current admin, and can't fallback to the proxy target.
     */
    error ProxyDeniedAdminAccess();

    /**
     * @dev msg.value is not 0.
     */
    error ProxyNonPayableFunction();

    /**
     * @dev Initializes an upgradeable proxy managed by `_admin`, backed by the implementation at `_logic`, and
     * optionally initialized with `_data` as explained in {ERC1967Proxy-constructor}.
     */
    constructor(address _logic, address admin_, bytes memory _data) payable ERC1967Proxy(_logic, _data) {
        _admin = admin_;
        // Set the storage value and emit an event for ERC-1967 compatibility
        ERC1967Utils.changeAdmin(admin_);
    }

    /**
     * @dev If caller is the admin process the call internally, otherwise transparently fallback to the proxy behavior
     */
    function _fallback() internal virtual override {
        if (msg.sender == _admin) {
            bytes memory ret;
            bytes4 selector = msg.sig;
            if (selector == ITransparentUpgradeableProxy.upgradeTo.selector) {
                ret = _dispatchUpgradeTo();
            } else if (selector == ITransparentUpgradeableProxy.upgradeToAndCall.selector) {
                ret = _dispatchUpgradeToAndCall();
            } else {
                revert ProxyDeniedAdminAccess();
            }
            assembly {
                return(add(ret, 0x20), mload(ret))
            }
        } else {
            super._fallback();
        }
    }

    /**
     * @dev Upgrade the implementation of the proxy.
     */
    function _dispatchUpgradeTo() private returns (bytes memory) {
        _requireZeroValue();

        address newImplementation = abi.decode(msg.data[4:], (address));
        ERC1967Utils.upgradeToAndCall(newImplementation, bytes(""), false);

        return "";
    }

    /**
     * @dev Upgrade the implementation of the proxy, and then call a function from the new implementation as specified
     * by `data`, which should be an encoded function call. This is useful to initialize new storage variables in the
     * proxied contract.
     */
    function _dispatchUpgradeToAndCall() private returns (bytes memory) {
        (address newImplementation, bytes memory data) = abi.decode(msg.data[4:], (address, bytes));
        ERC1967Utils.upgradeToAndCall(newImplementation, data, true);

        return "";
    }

    /**
     * @dev To keep this contract fully transparent, the fallback is payable. This helper is here to enforce
     * non-payability of function implemented through dispatchers while still allowing value to pass through.
     */
    function _requireZeroValue() private {
        if (msg.value != 0) {
            revert ProxyNonPayableFunction();
        }
    }
}

// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

contract ERC721UpgradeableProxy is TransparentUpgradeableProxy {
    constructor(address logic, address admin, bytes memory data) TransparentUpgradeableProxy(logic, admin, data) {}
}

Contract Security Audit

Contract ABI

[{"inputs":[{"internalType":"address","name":"logic","type":"address"},{"internalType":"address","name":"admin","type":"address"},{"internalType":"bytes","name":"data","type":"bytes"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[{"internalType":"address","name":"target","type":"address"}],"name":"AddressEmptyCode","type":"error"},{"inputs":[{"internalType":"address","name":"admin","type":"address"}],"name":"ERC1967InvalidAdmin","type":"error"},{"inputs":[{"internalType":"address","name":"implementation","type":"address"}],"name":"ERC1967InvalidImplementation","type":"error"},{"inputs":[],"name":"FailedInnerCall","type":"error"},{"inputs":[],"name":"ProxyDeniedAdminAccess","type":"error"},{"inputs":[],"name":"ProxyNonPayableFunction","type":"error"},{"stateMutability":"payable","type":"fallback"},{"stateMutability":"payable","type":"receive"}]

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

Deployed Bytecode

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

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

000000000000000000000000ac441f13cceaee3a8fc4026b5930115b564659c6000000000000000000000000000002832498429a823c5a8e5bde2748d2b00000000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000

-----Decoded View---------------
Arg [0] : logic (address): 0xac441f13CCEaEe3A8fC4026B5930115b564659C6
Arg [1] : admin (address): 0x000002832498429a823c5A8E5bdE2748D2b00000
Arg [2] : data (bytes): 0x

-----Encoded View---------------
5 Constructor Arguments found :
Arg [0] : 000000000000000000000000ac441f13cceaee3a8fc4026b5930115b564659c6
Arg [1] : 000000000000000000000000000002832498429a823c5a8e5bde2748d2b00000
Arg [2] : 0000000000000000000000000000000000000000000000000000000000000060
Arg [3] : 0000000000000000000000000000000000000000000000000000000000000000
Arg [4] : 0000000000000000000000000000000000000000000000000000000000000000


Deployed Bytecode Sourcemap

32712:184:0:-:0;;;;;;16939:11;:9;:11::i;:::-;32712:184;;16708:11;:9;:11::i;:::-;32712:184;30611:673;30687:6;30673:20;;:10;:20;;;30669:608;;30710:16;30741:15;30759:7;;;;30741:25;;30797:47;;;30785:59;;;:8;:59;;;;30781:344;;30871:20;:18;:20::i;:::-;30865:26;;30781:344;;;30929:54;;;30917:66;;;:8;:66;;;;30913:212;;31010:27;:25;:27::i;:::-;31004:33;;30913:212;;;31085:24;;;;;;;;;;;;;;30913:212;30781:344;31196:3;31190:10;31183:4;31178:3;31174:14;31167:34;30669:608;31248:17;:15;:17::i;:::-;30611:673::o;9224:82::-;9281:17;;;;;;;;;;;;;;31364:274;31411:12;31436:19;:17;:19::i;:::-;31468:25;31507:8;;31516:1;31507:12;;;;;;;;;:::i;:::-;31496:35;;;;;;;:::i;:::-;31468:63;;31542:66;31572:17;31591:9;;;;;;;;;;;;31602:5;31542:29;:66::i;:::-;31621:9;;;;;;;;;;;;;;;31364:274;:::o;31929:271::-;31983:12;32009:25;32036:17;32068:8;;32077:1;32068:12;;;;;;;;;:::i;:::-;32057:42;;;;;;;:::i;:::-;32008:91;;;;32110:60;32140:17;32159:4;32165;32110:29;:60::i;:::-;32183:9;;;;;;;;;;;;;;;;31929:271;:::o;16345:113::-;16394:17;:15;:17::i;:::-;16422:28;16432:17;:15;:17::i;:::-;16422:9;:28::i;:::-;16345:113::o;32447:134::-;32512:1;32499:9;:14;32495:79;;32537:25;;;;;;;;;;;;;;32495:79;32447:134::o;20001:268::-;20109:28;20119:17;20109:9;:28::i;:::-;20166:1;20152:4;:11;:15;:28;;;;20171:9;20152:28;20148:114;;;20197:53;20226:17;20245:4;20197:28;:53::i;:::-;;20148:114;20001:268;;;:::o;17248:46::-;:::o;24843:139::-;24910:12;24942:32;:30;:32::i;:::-;24935:39;;24843:139;:::o;14959:894::-;15290:14;15287:1;15284;15271:34;15500:1;15497;15481:14;15478:1;15462:14;15455:5;15442:60;15575:16;15572:1;15569;15554:38;15615:6;15689:1;15684:68;;;;15803:16;15800:1;15793:27;15684:68;15720:16;15717:1;15710:27;19697:154;19763:37;19782:17;19763:18;:37::i;:::-;19825:17;19816:27;;;;;;;;;;;;19697:154;:::o;6318:172::-;6401:12;6433:49;6454:6;6462:4;6468:13;6433:20;:49::i;:::-;6426:56;;6318:172;;;;:::o;19053:140::-;19105:7;19132:47;18522:66;19159:19;;19132:26;:47::i;:::-;:53;;;;;;;;;;;;19125:60;;19053:140;:::o;19289:286::-;19400:1;19367:17;:29;;;:34;19363:121;;19454:17;19425:47;;;;;;;;;;;:::i;:::-;;;;;;;;19363:121;19550:17;19494:47;18522:66;19521:19;;19494:26;:47::i;:::-;:53;;;:73;;;;;;;;;;;;;;;;;;19289:286;:::o;6684:343::-;6840:12;6866;6880:23;6907:6;:19;;6927:4;6907:25;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6865:67;;;;6950:69;6977:6;6985:7;6994:10;7006:12;6950:26;:69::i;:::-;6943:76;;;;6684:343;;;;;:::o;11724:195::-;11785:21;11897:4;11887:14;;11724:195;;;:::o;7334:710::-;7530:12;7559:7;7555:482;;;7608:1;7587:10;:17;:22;7583:345;;7836:1;7814:6;:18;;;:23;7810:103;;7886:6;7869:24;;;;;;;;;;;:::i;:::-;;;;;;;;7810:103;7583:345;7949:10;7942:17;;;;7555:482;7992:33;8000:10;8012:12;7992:7;:33::i;:::-;7334:710;;;;;;;:::o;9314:596::-;9506:1;9486:10;:17;:21;9482:421;;;9718:10;9712:17;9775:15;9762:10;9758:2;9754:19;9747:44;9482:421;9838:14;:12;:14;;:::i;:::-;9874:17;;;;;;;;;;;;;;7:75:1;40:6;73:2;67:9;57:19;;7:75;:::o;88:117::-;197:1;194;187:12;211:117;320:1;317;310:12;334:469;439:9;450;488:8;476:10;473:24;470:111;;;500:79;;:::i;:::-;470:111;606:6;596:8;593:20;590:107;;;616:79;;:::i;:::-;590:107;747:1;735:10;731:18;723:6;719:31;706:44;;786:10;776:8;772:25;759:38;;334:469;;;;;;;:::o;809:117::-;918:1;915;908:12;932:117;1041:1;1038;1031:12;1055:126;1092:7;1132:42;1125:5;1121:54;1110:65;;1055:126;;;:::o;1187:104::-;1232:7;1261:24;1279:5;1261:24;:::i;:::-;1250:35;;1187:104;;;:::o;1297:138::-;1378:32;1404:5;1378:32;:::i;:::-;1371:5;1368:43;1358:71;;1425:1;1422;1415:12;1358:71;1297:138;:::o;1441:155::-;1495:5;1533:6;1520:20;1511:29;;1549:41;1584:5;1549:41;:::i;:::-;1441:155;;;;:::o;1602:345::-;1669:6;1718:2;1706:9;1697:7;1693:23;1689:32;1686:119;;;1724:79;;:::i;:::-;1686:119;1844:1;1869:61;1922:7;1913:6;1902:9;1898:22;1869:61;:::i;:::-;1859:71;;1815:125;1602:345;;;;:::o;1953:117::-;2062:1;2059;2052:12;2076:117;2185:1;2182;2175:12;2199:102;2240:6;2291:2;2287:7;2282:2;2275:5;2271:14;2267:28;2257:38;;2199:102;;;:::o;2307:180::-;2355:77;2352:1;2345:88;2452:4;2449:1;2442:15;2476:4;2473:1;2466:15;2493:281;2576:27;2598:4;2576:27;:::i;:::-;2568:6;2564:40;2706:6;2694:10;2691:22;2670:18;2658:10;2655:34;2652:62;2649:88;;;2717:18;;:::i;:::-;2649:88;2757:10;2753:2;2746:22;2536:238;2493:281;;:::o;2780:129::-;2814:6;2841:20;;:::i;:::-;2831:30;;2870:33;2898:4;2890:6;2870:33;:::i;:::-;2780:129;;;:::o;2915:307::-;2976:4;3066:18;3058:6;3055:30;3052:56;;;3088:18;;:::i;:::-;3052:56;3126:29;3148:6;3126:29;:::i;:::-;3118:37;;3210:4;3204;3200:15;3192:23;;2915:307;;;:::o;3228:146::-;3325:6;3320:3;3315;3302:30;3366:1;3357:6;3352:3;3348:16;3341:27;3228:146;;;:::o;3380:423::-;3457:5;3482:65;3498:48;3539:6;3498:48;:::i;:::-;3482:65;:::i;:::-;3473:74;;3570:6;3563:5;3556:21;3608:4;3601:5;3597:16;3646:3;3637:6;3632:3;3628:16;3625:25;3622:112;;;3653:79;;:::i;:::-;3622:112;3743:54;3790:6;3785:3;3780;3743:54;:::i;:::-;3463:340;3380:423;;;;;:::o;3822:338::-;3877:5;3926:3;3919:4;3911:6;3907:17;3903:27;3893:122;;3934:79;;:::i;:::-;3893:122;4051:6;4038:20;4076:78;4150:3;4142:6;4135:4;4127:6;4123:17;4076:78;:::i;:::-;4067:87;;3883:277;3822:338;;;;:::o;4166:668::-;4251:6;4259;4308:2;4296:9;4287:7;4283:23;4279:32;4276:119;;;4314:79;;:::i;:::-;4276:119;4434:1;4459:61;4512:7;4503:6;4492:9;4488:22;4459:61;:::i;:::-;4449:71;;4405:125;4597:2;4586:9;4582:18;4569:32;4628:18;4620:6;4617:30;4614:117;;;4650:79;;:::i;:::-;4614:117;4755:62;4809:7;4800:6;4789:9;4785:22;4755:62;:::i;:::-;4745:72;;4540:287;4166:668;;;;;:::o;4840:96::-;4877:7;4906:24;4924:5;4906:24;:::i;:::-;4895:35;;4840:96;;;:::o;4942:118::-;5029:24;5047:5;5029:24;:::i;:::-;5024:3;5017:37;4942:118;;:::o;5066:222::-;5159:4;5197:2;5186:9;5182:18;5174:26;;5210:71;5278:1;5267:9;5263:17;5254:6;5210:71;:::i;:::-;5066:222;;;;:::o;5294:98::-;5345:6;5379:5;5373:12;5363:22;;5294:98;;;:::o;5398:147::-;5499:11;5536:3;5521:18;;5398:147;;;;:::o;5551:246::-;5632:1;5642:113;5656:6;5653:1;5650:13;5642:113;;;5741:1;5736:3;5732:11;5726:18;5722:1;5717:3;5713:11;5706:39;5678:2;5675:1;5671:10;5666:15;;5642:113;;;5789:1;5780:6;5775:3;5771:16;5764:27;5613:184;5551:246;;;:::o;5803:386::-;5907:3;5935:38;5967:5;5935:38;:::i;:::-;5989:88;6070:6;6065:3;5989:88;:::i;:::-;5982:95;;6086:65;6144:6;6139:3;6132:4;6125:5;6121:16;6086:65;:::i;:::-;6176:6;6171:3;6167:16;6160:23;;5911:278;5803:386;;;;:::o;6195:271::-;6325:3;6347:93;6436:3;6427:6;6347:93;:::i;:::-;6340:100;;6457:3;6450:10;;6195:271;;;;:::o

Swarm Source

ipfs://36a70eeede1c9db49833c225f62aac2f9b7bc3e0aebd679ce8fabfc8cec7ab4c
Loading...
Loading
[ Download: CSV Export  ]
[ Download: CSV Export  ]

A token is a representation of an on-chain or off-chain asset. The token page shows information such as price, total supply, holders, transfers and social links. Learn more about this page in our Knowledge Base.