Contract 0xCc7FF230365bD730eE4B352cC2492CEdAC49383e 11

 
Txn Hash Method
Block
From
To
Value
0x6896c6b1f6372b58b41c12c1112aeedb96064132bfb93f8af41e58f695b1a424Approve132249082024-04-16 3:46:0311 mins ago0x4b46b7fff3242ea936e78d1f6db37bbc13504840 IN  Reserve: hyUSD0 ETH0.0000013316270.025412889
0xf4566a2bc8f66dceb546e175c558ade8bdb398c572c82d8108fda33ce4f5bb9eApprove132249012024-04-16 3:45:4911 mins ago0x4c0b490060f56d8b72d5f9a8630767cceb2ca94a IN  Reserve: hyUSD0 ETH0.0000013308740.025464752
0x551cda2c5f01da587c802f76d251be421d6a52b11984922a96b0c4955e776ebcApprove132247412024-04-16 3:40:2917 mins ago0x26ac6b58c7ce33589397ea296f2afde70e905efd IN  Reserve: hyUSD0 ETH0.0000011903490.022754348
0xe9e66a07691e8dd20c4bc6697901cf2bc1f40a88e5a52938b6da9fc431ad6691Approve132246372024-04-16 3:37:0120 mins ago0x52b5a3afd5b591aec0551173db7327869fefd443 IN  Reserve: hyUSD0 ETH0.0000477061771.521730451
0xbfa85e58d33c15a2c0a4dd1d45fcad434f00eca0a951b2e770ad719917091de7Approve132246202024-04-16 3:36:2721 mins ago0x52b5a3afd5b591aec0551173db7327869fefd443 IN  Reserve: hyUSD0 ETH0.0000477059471.521683642
0x94591c8d85108d545fb1286737b6eeed16ffb98d1ef4d353a2fddf9f2d469d34Approve132245622024-04-16 3:34:3123 mins ago0x52b5a3afd5b591aec0551173db7327869fefd443 IN  Reserve: hyUSD0 ETH0.0000780117441.522132715
0x6d5bad22d03a3c4f92aaf8be6e80a8da6104542f4d604de296e21b912e724689Approve132245272024-04-16 3:33:2124 mins ago0x4c0b490060f56d8b72d5f9a8630767cceb2ca94a IN  Reserve: hyUSD0 ETH0.0000011916760.022887341
0x2074401eaab44c46093fd8355846986fb554dc23525667d0ee4ba95d4b8a3143Approve132242422024-04-16 3:23:5133 mins ago0x266921c2424aac83244a245cc714d3d42329fa10 IN  Reserve: hyUSD0 ETH0.0000012927720.024830262
0x5ce29c7521381234a9c0a3719ab8cfdf2c7868fa644f2ca0eda78f457ae5be94Approve132242402024-04-16 3:23:4733 mins ago0x929f39e807f8a0a6ddc962e9156b497510ab7b61 IN  Reserve: hyUSD0 ETH0.0000008708220.024903873
0x29d636954893ea77ab4c21dcdf241a9b6f2b2deb82cbec29c924509214efdd07Approve132242282024-04-16 3:23:2334 mins ago0x8475135349d643940ddedc33ffc731afc5f9f4ce IN  Reserve: hyUSD0 ETH0.0000781526771.524887849
0xabe464eed66469a3811dc9d98bc3e6040dfc280d141cd769912568067e64a196Approve132240952024-04-16 3:18:5738 mins ago0x8475135349d643940ddedc33ffc731afc5f9f4ce IN  Reserve: hyUSD0 ETH0.000052131251.527644002
0x4a381cf380a2f35ca83c8f1177c009af059cc07702a18d831160fca75a47fb4dApprove132240772024-04-16 3:18:2139 mins ago0xc1000697e6fcd64ba12965f91b4a93c8ea9e1d3d IN  Reserve: hyUSD0 ETH0.0000014787070.028434807
0x3fa287eaaf95260ba5f3701ed99d3d16d99fbc6e2a27da44f4d740c2099234bfApprove132240272024-04-16 3:16:4141 mins ago0x266921c2424aac83244a245cc714d3d42329fa10 IN  Reserve: hyUSD0 ETH0.000001502550.028897455
0xf748ac027cdfedc123bc72661eb4cd65c3e8a2f67d3aea674bf8274c0b486646Approve132239492024-04-16 3:14:0543 mins ago0x8475135349d643940ddedc33ffc731afc5f9f4ce IN  Reserve: hyUSD0 ETH0.0000521816771.529016536
0x2c2af01d531c484604ed8405c0707b45f906717ad92bc5b29ae6ca5905949aa7Approve132238222024-04-16 3:09:5147 mins ago0x8475135349d643940ddedc33ffc731afc5f9f4ce IN  Reserve: hyUSD0 ETH0.0000522319361.530533434
0x97d3d08b82e3403f7c6f28a8a43e044231301734a72333a501ce0b1427b0c7a6Approve132237752024-04-16 3:08:1749 mins ago0xdec18efb10ab7c17155662cbb6e4ad0223863a3a IN  Reserve: hyUSD0 ETH0.0000018475610.0356
0x2e52f7beddbb7bbde3401b726068750eb72212a99e1487e3ab1ee6e264d3bffeApprove132236032024-04-16 3:02:3355 mins ago0x8475135349d643940ddedc33ffc731afc5f9f4ce IN  Reserve: hyUSD0 ETH0.0000784787751.531956445
0xfc2b1e724745b8b12cd082e89492d3e47833d1877322c9d5840e0a2340eeddc8Approve132234732024-04-16 2:58:1359 mins ago0xa0b7a9b3d184596332f8a3665ee540226379cbcf IN  Reserve: hyUSD0 ETH0.0000021037920.0407
0x9f7665f9c4945d9179aa595e73f8be8893e9219ee482d5d10b3acd56ceda5c47Approve132234552024-04-16 2:57:371 hr ago0xa0b7a9b3d184596332f8a3665ee540226379cbcf IN  Reserve: hyUSD0 ETH0.000003595390.0698
0x54c13703d98393101fe86ed70e93057c7e3eb78327854d34703d633bd98e5d4aApprove132234102024-04-16 2:56:071 hr 1 min ago0xc4097edbe2de310d042a1a6ac23d1388ee7fd373 IN  Reserve: hyUSD0 ETH0.0000018325010.035301981
0x591e2213c4887f53c1ac2d034cf1847bfb1802ba19a4a5561f9a807ded8f7718Approve132233112024-04-16 2:52:491 hr 4 mins ago0x0ee2a6f6ad07cef7110cb13964c2d803f8ff4dee IN  Reserve: hyUSD0 ETH0.0000013308390.038415224
0x95366ef8b49b097d56cc8a7302c69c822b1b6182b05f092c926b487b708bde1cApprove132231172024-04-16 2:46:211 hr 11 mins ago0x0ee2a6f6ad07cef7110cb13964c2d803f8ff4dee IN  Reserve: hyUSD0 ETH0.0000020825620.040272777
0xd2372c98c570f001519e800cbcb8b08185b55d39ce8779c3dce9abdce8f868e0Approve132229872024-04-16 2:42:011 hr 15 mins ago0xf66acae83dbe128c98d86aa32bc3cc07329441ad IN  Reserve: hyUSD0 ETH0.0000020886840.040374105
0x302e191374b5c5b1b30f6dc2d651b06688f49e3bf0f37517adf5236afefc9f7fApprove132228022024-04-16 2:35:511 hr 21 mins ago0xc4097edbe2de310d042a1a6ac23d1388ee7fd373 IN  Reserve: hyUSD0 ETH0.0000020625160.0397759
0x4323604ff433587f6039c0e23bbf7cd5a531041aea8118aac280f97d518ad924Approve132226972024-04-16 2:32:211 hr 25 mins ago0x18dc0d6a082d9af491c627e2452c59f0793e2576 IN  Reserve: hyUSD0 ETH0.0000020104110.038838584
[ Download CSV Export 
Latest 1 internal transaction
Parent Txn Hash Block From To Value
0x420b586e5f999a06b2a5b869cfdc08b963a4f29413b0ec6b9db2ee7dbbd693db51745332023-10-12 19:20:13186 days 8 hrs ago 0x9c75314afd011f22648ca9c655b61674e27ba4ac  Contract Creation0 ETH
[ Download CSV Export 
Loading

Similar Match Source Code
This contract matches the deployed Bytecode of the Source Code for Contract 0xE9E22548C92EF74c02A9dab73c33eBcEb53cA216
The constructor portion of the code might be different and could alter the actual behaviour of the contract

Contract Name:
ERC1967Proxy

Compiler Version
v0.8.19+commit.7dd6d404

Optimization Enabled:
Yes with 200 runs

Other Settings:
default evmVersion, GNU GPLv3 license

Contract Source Code (Solidity)

/**
 *Submitted for verification at basescan.org on 2023-09-28
*/

/**
 *Submitted for verification at Etherscan.io on 2023-02-24
*/

pragma solidity 0.8.19;

interface IERC1822Proxiable {
    /**
     * @dev Returns the storage slot that the proxiable contract assumes is being used to store the implementation
     * address.
     *
     * IMPORTANT: A proxy pointing at a proxiable contract should not be considered proxiable itself, because this risks
     * bricking a proxy that upgrades to it, by delegating to itself until out of gas. Thus it is critical that this
     * function revert if invoked through a proxy.
     */
    function proxiableUUID() external view returns (bytes32);
}

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

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

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


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

        return account.code.length > 0;
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

/**
 * @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 _upgradeToAndCallUUPS(
        address newImplementation,
        bytes memory data,
        bool forceCall
    ) internal {
        // Upgrades from old implementations will perform a rollback test. This test requires the new
        // implementation to upgrade back to the old, non-ERC1822 compliant, implementation. Removing
        // this special case will break upgrade paths from old UUPS implementation to new ones.
        if (StorageSlot.getBooleanSlot(_ROLLBACK_SLOT).value) {
            _setImplementation(newImplementation);
        } else {
            try IERC1822Proxiable(newImplementation).proxiableUUID() returns (bytes32 slot) {
                require(slot == _IMPLEMENTATION_SLOT, "ERC1967Upgrade: unsupported proxiableUUID");
            } catch {
                revert("ERC1967Upgrade: new implementation is not UUPS");
            }
            _upgradeToAndCall(newImplementation, data, forceCall);
        }
    }

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


contract ERC1967Proxy is Proxy, ERC1967Upgrade {
    /**
     * @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 {
        _upgradeToAndCall(_logic, _data, false);
    }

    /**
     * @dev Returns the current implementation address.
     */
    function _implementation() internal view virtual override returns (address impl) {
        return ERC1967Upgrade._getImplementation();
    }
}

Contract Security Audit

Contract ABI

[{"inputs":[{"internalType":"address","name":"_logic","type":"address"},{"internalType":"bytes","name":"_data","type":"bytes"}],"stateMutability":"payable","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"}]

Deployed Bytecode

0x608060405236601057600e6013565b005b600e5b601f601b6021565b6058565b565b600060537f360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc546001600160a01b031690565b905090565b3660008037600080366000845af43d6000803e8080156076573d6000f35b3d6000fdfea2646970667358221220d696190f1462e196c18783d2bcdbe9f7498512203fe6ebde6d2044021dbc255d64736f6c63430008130033

Deployed ByteCode Sourcemap

19689:740:0:-:0;;;;;;3145:11;:9;:11::i;:::-;19689:740;;2914:11;2551:113;2628:28;2638:17;:15;:17::i;:::-;2628:9;:28::i;:::-;2551:113::o;20284:142::-;20351:12;20383:35;14043:66;14404:54;-1:-1:-1;;;;;14404:54:0;;14324:142;20383:35;20376:42;;20284:142;:::o;1141:918::-;1484:14;1481:1;1478;1465:34;1702:1;1699;1683:14;1680:1;1664:14;1657:5;1644:60;1781:16;1778:1;1775;1760:38;1821:6;1890:68;;;;2009:16;2006:1;1999:27;1890:68;1926:16;1923:1;1916:27

Swarm Source

ipfs://d696190f1462e196c18783d2bcdbe9f7498512203fe6ebde6d2044021dbc255d
Block Transaction Difficulty Gas Used Reward
Block Uncle Number Difficulty Gas Used Reward
Loading
Make sure to use the "Vote Down" button for any spammy posts, and the "Vote Up" for interesting conversations.