PulseChain Explorer - BlockScout

Contract Address

Is Yul contract

No

Yes

Contract Name

Include nightly builds

No

Yes

Compiler

EVM Version

Optimization

No

Yes

Optimization runs

Enter the Solidity Contract Code

// SPDX-License-Identifier: UNLICENSED
pragma solidity 0.8.12;

interface INFT {
    struct Initialization {
        string name;
        string symbol;
        string baseTokenURI;
        uint256 limitSupply;
        uint256 presaleSupply;
        uint256 presalePrice;
        uint256 publicSalePrice;
        uint256 PRESALE_MAX_MINT;
        uint256 MAX_PER_MINT;
        address royaltyReceiverAddress;
        uint96 royaltyFee;
    }

function initialize(Initialization calldata initialization) external;
}

contract NFTProxy {
    struct AddressSlot {
        address value;
    }

event Upgraded(address indexed implementation);

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

constructor(address implementation, INFT.Initialization memory initialization) {
        getAddressSlot(_IMPLEMENTATION_SLOT).value = implementation;
        emit Upgraded(implementation);

(bool success, bytes memory returndata) = implementation.delegatecall(
            abi.encodeWithSelector(
                INFT.initialize.selector,
                initialization
            )
        );
        if (!success) {
            if (returndata.length == 0) revert();
            assembly {
                revert(add(32, returndata), mload(returndata))
            }
        }
    }

/**
     * @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) {
        return getAddressSlot(_IMPLEMENTATION_SLOT).value;
    }

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

Try to fetch constructor arguments automatically

No

Yes

ABI-encoded Constructor Arguments (if required by the contract)

0x0000000000000000000000004386d4eb8d788f882909106ebc5714ea64dfb9ee0000000000000000000000000000000000000000000000000000000000000040000000000000000000000000000000000000000000000000000000000000016000000000000000000000000000000000000000000000000000000000000001a000000000000000000000000000000000000000000000000000000000000001e00000000000000000000000000000000000000000000000000000000000000064000000000000000000000000000000000000000000000000000000000000001400000000000000000000000000000000000000000000000000005af3107a40000000000000000000000000000000000000000000000000000001c6bf5263400000000000000000000000000000000000000000000000000000000000000000030000000000000000000000000000000000000000000000000000000000000014000000000000000000000000ba4db2a52109e538c5b6ded452202e87ed9a57fc00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000015537175697272656c204475706c6963617465203131000000000000000000000000000000000000000000000000000000000000000000000000000000000000045343443800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005b68747470733a2f2f62616679626569646766683267656f7834346778746d36766266716865633771676a337576656864676a647562346d7035736f7975796c6a7934342e697066732e7733732e6c696e6b2f6d657461646174612f0000000000

New Solidity Smart Contract Verification

Contract Libraries