ETH Price: $3,491.00 (+1.61%)

Token

Fusion (FSN)
 

Overview

Max Total Supply

1,024 FSN

Holders

560

Market

Volume (24H)

N/A

Min Price (24H)

N/A

Max Price (24H)

N/A
Balance
1 FSN
0x4C12647eEE5B2AB6c11cf9C531f4d62e50e67D4C
Loading...
Loading
Loading...
Loading
Loading...
Loading

OVERVIEW

FUSION is an on-chain Generative NFT Collection from Hideki Tsukamoto, the creator of SINGULARITY and CYPHER.

# Exchange Pair Price  24H Volume % Volume

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

Contract Name:
Proxy

Compiler Version
v0.8.7+commit.e28d00a7

Optimization Enabled:
Yes with 200 runs

Other Settings:
default evmVersion, None license
/**
 *Submitted for verification at Etherscan.io on 2021-09-29
*/

// SPDX-License-Identifier: UNLICENSED
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 StorageSlotUpgradeable {
    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
        }
    }
}



contract Proxy
{
    bytes32 private constant _IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;
    bytes32 private constant _ADMIN_SLOT = 0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103;

    constructor(address implementation)
    {
        StorageSlotUpgradeable.getAddressSlot(_IMPLEMENTATION_SLOT).value = implementation;
        StorageSlotUpgradeable.getAddressSlot(_ADMIN_SLOT).value = msg.sender;
    }

    fallback() external payable
    {
        _fallback();
    }

    receive() external payable 
    {
        _fallback();
    }

    function _fallback() private
    {
        address implementation = StorageSlotUpgradeable.getAddressSlot(_IMPLEMENTATION_SLOT).value;

        // from OpenZeppelin/contracts
        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())
            }
        }
    }
}

Contract Security Audit

Contract ABI

[{"inputs":[{"internalType":"address","name":"implementation","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"stateMutability":"payable","type":"fallback"},{"stateMutability":"payable","type":"receive"}]

608060405234801561001057600080fd5b506040516101b83803806101b883398101604081905261002f916100e0565b806100667f360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc60001b6100dd60201b6100611760201c565b80546001600160a01b0319166001600160a01b0392909216919091179055336100b97fb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d61036100dd602090811b61006117901c565b80546001600160a01b0319166001600160a01b039290921691909117905550610110565b90565b6000602082840312156100f257600080fd5b81516001600160a01b038116811461010957600080fd5b9392505050565b609a8061011e6000396000f3fe608060405236601057600e6013565b005b600e5b7f360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc546001600160a01b03163660008037600080366000845af43d6000803e808015605c573d6000f35b3d6000fd5b9056fea264697066735822122090da2d74d6f07cd8f2e9f490082979a89106128fafbe37c3da769f0e075db5f864736f6c63430008070033000000000000000000000000f8b94cd86fd64bd28b7b4988b718052ded52a849

Deployed Bytecode

0x608060405236601057600e6013565b005b600e5b7f360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc546001600160a01b03163660008037600080366000845af43d6000803e808015605c573d6000f35b3d6000fd5b9056fea264697066735822122090da2d74d6f07cd8f2e9f490082979a89106128fafbe37c3da769f0e075db5f864736f6c63430008070033

Deployed Bytecode Sourcemap

2534:1678:0:-:0;;;;;;3137:11;:9;:11::i;:::-;2534:1678;;3066:11;3164:1045;2605:66;3234:65;-1:-1:-1;;;;;3234:65:0;3634:14;3209:22;;3615:34;3852:1;3849;3833:14;3830:1;3814:14;3807:5;3794:60;3931:16;3928:1;3925;3910:38;3971:6;4040:68;;;;4159:16;4156:1;4149:27;4040:68;4076:16;4073:1;4066:27;1610:151;1739:4;1610:151::o

Swarm Source

ipfs://90da2d74d6f07cd8f2e9f490082979a89106128fafbe37c3da769f0e075db5f8
Loading...
Loading
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.