ETH Price: $3,145.04 (-0.39%)
Gas: 7 Gwei

Contract

0x27df632fd0dcf191C418c803801D521cd579F18e
 

Overview

ETH Balance

0 ETH

Eth Value

$0.00

Multichain Info

No addresses found
Transaction Hash
Method
Block
From
To
Value
Approve190495152024-01-20 17:17:2392 days ago1705771043IN
0x27df632f...cd579F18e
0 ETH0.0004700915.92676486
Approve189837762024-01-11 12:46:59101 days ago1704977219IN
0x27df632f...cd579F18e
0 ETH0.0009005830.51191881
Approve188350582023-12-21 15:13:11122 days ago1703171591IN
0x27df632f...cd579F18e
0 ETH0.001653456.01738057
Approve185355512023-11-09 16:21:59164 days ago1699546919IN
0x27df632f...cd579F18e
0 ETH0.01232777239.20706648
Approve185346622023-11-09 13:23:11164 days ago1699536191IN
0x27df632f...cd579F18e
0 ETH0.0026116150.67549294
Approve185299612023-11-08 21:35:59164 days ago1699479359IN
0x27df632f...cd579F18e
0 ETH0.0027795653.93433871
Approve184595072023-10-30 0:48:59174 days ago1698626939IN
0x27df632f...cd579F18e
0 ETH0.0007178513.23717126
Transfer184594372023-10-30 0:34:47174 days ago1698626087IN
0x27df632f...cd579F18e
0 ETH0.0006253111.36633307
Approve184323222023-10-26 5:30:59178 days ago1698298259IN
0x27df632f...cd579F18e
0 ETH0.0010244119.88231139
Approve184320042023-10-26 4:27:11178 days ago1698294431IN
0x27df632f...cd579F18e
0 ETH0.0013366324.64759055
Approve184305592023-10-25 23:36:23178 days ago1698276983IN
0x27df632f...cd579F18e
0 ETH0.0010961120.21228378
Approve184211482023-10-24 15:55:59180 days ago1698162959IN
0x27df632f...cd579F18e
0 ETH0.0026130148.18395857
Approve184137782023-10-23 15:11:47181 days ago1698073907IN
0x27df632f...cd579F18e
0 ETH0.0023861244
Approve184125452023-10-23 11:03:11181 days ago1698058991IN
0x27df632f...cd579F18e
0 ETH0.0006521412.02548943
Approve184072952023-10-22 17:22:59182 days ago1697995379IN
0x27df632f...cd579F18e
0 ETH0.0005960710.99166716
Approve184045762023-10-22 8:13:59182 days ago1697962439IN
0x27df632f...cd579F18e
0 ETH0.000365746.74433029
Approve184012422023-10-21 21:03:11182 days ago1697922191IN
0x27df632f...cd579F18e
0 ETH0.000264088.94715722
Approve184010092023-10-21 20:16:23183 days ago1697919383IN
0x27df632f...cd579F18e
0 ETH0.000471088.68673156
Approve183968932023-10-21 6:27:23183 days ago1697869643IN
0x27df632f...cd579F18e
0 ETH0.000460558.93654144
Approve183933262023-10-20 18:29:11184 days ago1697826551IN
0x27df632f...cd579F18e
0 ETH0.0008179115.87077537
Approve183932692023-10-20 18:17:47184 days ago1697825867IN
0x27df632f...cd579F18e
0 ETH0.0010038318.51069965
Approve183931482023-10-20 17:53:35184 days ago1697824415IN
0x27df632f...cd579F18e
0 ETH0.0006712213.02430287
Approve183931392023-10-20 17:51:47184 days ago1697824307IN
0x27df632f...cd579F18e
0 ETH0.0007213713.30222516

Latest 1 internal transaction

Advanced mode:
Parent Transaction Hash Block From To Value
183243242023-10-11 2:47:35193 days ago1696992455  Contract Creation0 ETH
Loading...
Loading

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

Contract Name:
TokenProxy

Compiler Version
v0.7.5+commit.eb77ed08

Optimization Enabled:
Yes with 200 runs

Other Settings:
default evmVersion, GNU GPLv3 license
/**
 *Submitted for verification at Etherscan.io on 2021-10-17
*/

// File: contracts/upgradeability/Proxy.sol

pragma solidity 0.7.5;

/**
 * @title Proxy
 * @dev Gives the possibility to delegate any call to a foreign implementation.
 */
abstract contract Proxy {
    /**
     * @dev Tells the address of the implementation where every call will be delegated.
     * @return address of the implementation to which it will be delegated
     */
    function implementation() public view virtual returns (address);

    /**
     * @dev Fallback function allowing to perform a delegatecall to the given implementation.
     * This function will return whatever the implementation call returns
     */
    fallback() external payable {
        // solhint-disable-previous-line no-complex-fallback
        address _impl = implementation();
        require(_impl != address(0));
        assembly {
            /*
                0x40 is the "free memory slot", meaning a pointer to next slot of empty memory. mload(0x40)
                loads the data in the free memory slot, so `ptr` is a pointer to the next slot of empty
                memory. It's needed because we're going to write the return data of delegatecall to the
                free memory slot.
            */
            let ptr := mload(0x40)
            /*
                `calldatacopy` is copy calldatasize bytes from calldata
                First argument is the destination to which data is copied(ptr)
                Second argument specifies the start position of the copied data.
                    Since calldata is sort of its own unique location in memory,
                    0 doesn't refer to 0 in memory or 0 in storage - it just refers to the zeroth byte of calldata.
                    That's always going to be the zeroth byte of the function selector.
                Third argument, calldatasize, specifies how much data will be copied.
                    calldata is naturally calldatasize bytes long (same thing as msg.data.length)
            */
            calldatacopy(ptr, 0, calldatasize())
            /*
                delegatecall params explained:
                gas: the amount of gas to provide for the call. `gas` is an Opcode that gives
                    us the amount of gas still available to execution

                _impl: address of the contract to delegate to

                ptr: to pass copied data

                calldatasize: loads the size of `bytes memory data`, same as msg.data.length

                0, 0: These are for the `out` and `outsize` params. Because the output could be dynamic,
                        these are set to 0, 0 so the output data will not be written to memory. The output
                        data will be read using `returndatasize` and `returdatacopy` instead.

                result: This will be 0 if the call fails and 1 if it succeeds
            */
            let result := delegatecall(gas(), _impl, ptr, calldatasize(), 0, 0)
            /*

            */
            /*
                ptr current points to the value stored at 0x40,
                because we assigned it like ptr := mload(0x40).
                Because we use 0x40 as a free memory pointer,
                we want to make sure that the next time we want to allocate memory,
                we aren't overwriting anything important.
                So, by adding ptr and returndatasize,
                we get a memory location beyond the end of the data we will be copying to ptr.
                We place this in at 0x40, and any reads from 0x40 will now read from free memory
            */
            mstore(0x40, add(ptr, returndatasize()))
            /*
                `returndatacopy` is an Opcode that copies the last return data to a slot. `ptr` is the
                    slot it will copy to, 0 means copy from the beginning of the return data, and size is
                    the amount of data to copy.
                `returndatasize` is an Opcode that gives us the size of the last return data. In this case, that is the size of the data returned from delegatecall
            */
            returndatacopy(ptr, 0, returndatasize())

            /*
                if `result` is 0, revert.
                if `result` is 1, return `size` amount of data from `ptr`. This is the data that was
                copied to `ptr` from the delegatecall return data
            */
            switch result
                case 0 {
                    revert(ptr, returndatasize())
                }
                default {
                    return(ptr, returndatasize())
                }
        }
    }
}

// File: contracts/upgradeable_contracts/modules/factory/TokenProxy.sol

pragma solidity 0.7.5;


interface IPermittableTokenVersion {
    function version() external pure returns (string memory);
}

/**
 * @title TokenProxy
 * @dev Helps to reduces the size of the deployed bytecode for automatically created tokens, by using a proxy contract.
 */
contract TokenProxy is Proxy {
    // storage layout is copied from PermittableToken.sol
    string internal name;
    string internal symbol;
    uint8 internal decimals;
    mapping(address => uint256) internal balances;
    uint256 internal totalSupply;
    mapping(address => mapping(address => uint256)) internal allowed;
    address internal owner;
    bool internal mintingFinished;
    address internal bridgeContractAddr;
    // string public constant version = "1";
    bytes32 internal DOMAIN_SEPARATOR;
    // bytes32 public constant PERMIT_TYPEHASH = 0xea2aa0a1be11a07ed86d755c93467f4f82362b452371d1ba94d1715123511acb;
    mapping(address => uint256) internal nonces;
    mapping(address => mapping(address => uint256)) internal expirations;

    /**
     * @dev Creates a non-upgradeable token proxy for PermitableToken.sol, initializes its eternalStorage.
     * @param _tokenImage address of the token image used for mirroring all functions.
     * @param _name token name.
     * @param _symbol token symbol.
     * @param _decimals token decimals.
     * @param _chainId chain id for current network.
     * @param _owner address of the owner for this contract.
     */
    constructor(
        address _tokenImage,
        string memory _name,
        string memory _symbol,
        uint8 _decimals,
        uint256 _chainId,
        address _owner
    ) {
        string memory version = IPermittableTokenVersion(_tokenImage).version();

        assembly {
            // EIP 1967
            // bytes32(uint256(keccak256('eip1967.proxy.implementation')) - 1)
            sstore(0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc, _tokenImage)
        }
        name = _name;
        symbol = _symbol;
        decimals = _decimals;
        owner = _owner; // _owner == HomeOmnibridge/ForeignOmnibridge mediator
        bridgeContractAddr = _owner;
        DOMAIN_SEPARATOR = keccak256(
            abi.encode(
                keccak256("EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)"),
                keccak256(bytes(_name)),
                keccak256(bytes(version)),
                _chainId,
                address(this)
            )
        );
    }

    /**
     * @dev Retrieves the implementation contract address, mirrored token image.
     * @return impl token image address.
     */
    function implementation() public view override returns (address impl) {
        assembly {
            impl := sload(0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc)
        }
    }

    /**
     * @dev Tells the current version of the token proxy interfaces.
     */
    function getTokenProxyInterfacesVersion()
        external
        pure
        returns (
            uint64 major,
            uint64 minor,
            uint64 patch
        )
    {
        return (1, 0, 0);
    }
}

Contract Security Audit

Contract ABI

[{"inputs":[{"internalType":"address","name":"_tokenImage","type":"address"},{"internalType":"string","name":"_name","type":"string"},{"internalType":"string","name":"_symbol","type":"string"},{"internalType":"uint8","name":"_decimals","type":"uint8"},{"internalType":"uint256","name":"_chainId","type":"uint256"},{"internalType":"address","name":"_owner","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"stateMutability":"payable","type":"fallback"},{"inputs":[],"name":"getTokenProxyInterfacesVersion","outputs":[{"internalType":"uint64","name":"major","type":"uint64"},{"internalType":"uint64","name":"minor","type":"uint64"},{"internalType":"uint64","name":"patch","type":"uint64"}],"stateMutability":"pure","type":"function"},{"inputs":[],"name":"implementation","outputs":[{"internalType":"address","name":"impl","type":"address"}],"stateMutability":"view","type":"function"}]

Deployed Bytecode

0x6080604052600436106100295760003560e01c80632f95b6aa146100725780635c60da1b146100b3575b60006100336100e4565b90506001600160a01b03811661004857600080fd5b60405136600082376000803683855af43d82016040523d6000833e80801561006e573d83f35b3d83fd5b34801561007e57600080fd5b50610087610109565b6040805167ffffffffffffffff9485168152928416602084015292168183015290519081900360600190f35b3480156100bf57600080fd5b506100c86100e4565b604080516001600160a01b039092168252519081900360200190f35b7f360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc5490565b6001600080919256fea2646970667358221220761ef26fb8e839077bbb8f08b17faa303ce8554e0cae0cd68d7b12e86124d94964736f6c63430007050033

Deployed Bytecode Sourcemap

5055:2961:0:-:0;;;;;;;;;;;;;;;;;;;;;;;756:13;772:16;:14;:16::i;:::-;756:32;-1:-1:-1;;;;;;807:19:0;;799:28;;;;;;1265:4;1259:11;2046:14;2043:1;2038:3;2025:36;2983:1;2980;2964:14;2959:3;2952:5;2945;2932:53;3673:16;3668:3;3664:26;3658:4;3651:40;4185:16;4182:1;4177:3;4162:40;4469:6;4493:78;;;;4632:16;4627:3;4620:29;4493:78;4535:16;4530:3;4523:29;7789:224;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;7489:204;;;;;;;;;;;;;:::i;:::-;;;;-1:-1:-1;;;;;7489:204:0;;;;;;;;;;;;;;;7608:66;7602:73;;7579:107::o;7789:224::-;7997:1;7895:12;;7789:224;;:::o

Swarm Source

ipfs://761ef26fb8e839077bbb8f08b17faa303ce8554e0cae0cd68d7b12e86124d949

Block Transaction Difficulty Gas Used Reward
View All Blocks Produced

Block Uncle Number Difficulty Gas Used Reward
View All Uncles
Loading...
Loading
Loading...
Loading

Validator Index Block Amount
View All Withdrawals

Transaction Hash Block Value Eth2 PubKey Valid
View All Deposits
[ Download: CSV Export  ]
[ Download: CSV Export  ]

A contract address hosts a smart contract, which is a set of code stored on the blockchain that runs when predetermined conditions are met. Learn more about addresses in our Knowledge Base.