xDAI Price: $1.00 (+0.03%)
Gas: 1.1 GWei

Contract

0x7838796B6802B18D7Ef58fc8B757705D6c9d12b3
Transaction Hash
Method
Block
From
To
Transfer And Cal...383007032025-01-30 5:59:3516 days ago1738216775IN
Gnosis: MANA Token
0 xDAI0.000433281.2
Transfer379787002025-01-11 0:11:0035 days ago1736554260IN
Gnosis: MANA Token
0 xDAI0.000087911.6
Transfer374639342024-12-11 2:00:0066 days ago1733882400IN
Gnosis: MANA Token
0 xDAI0.000090062.43576055
Transfer374639332024-12-11 1:59:5566 days ago1733882395IN
Gnosis: MANA Token
0 xDAI0.000090062.43576055
Approve370395672024-11-15 18:41:4591 days ago1731696105IN
Gnosis: MANA Token
0 xDAI0.000099891.94000001
Approve360754942024-09-19 4:48:25149 days ago1726721305IN
Gnosis: MANA Token
0 xDAI0.000162622.99999999
Approve351752912024-07-27 7:21:05203 days ago1722064865IN
Gnosis: MANA Token
0 xDAI0.000064892.2
Approve350590852024-07-20 8:33:40210 days ago1721464420IN
Gnosis: MANA Token
0 xDAI0.000064892.2
Approve346143812024-06-23 17:45:10236 days ago1719164710IN
Gnosis: MANA Token
0 xDAI0.002943654.3
Approve345643152024-06-20 17:53:10239 days ago1718905990IN
Gnosis: MANA Token
0 xDAI0.000100283.4
Approve333190042024-04-07 7:44:45314 days ago1712475885IN
Gnosis: MANA Token
0 xDAI0.000045691.54928404
Transfer332026312024-03-31 6:20:20321 days ago1711866020IN
Gnosis: MANA Token
0 xDAI0.000125853.32217603
Transfer332026012024-03-31 6:17:45321 days ago1711865865IN
Gnosis: MANA Token
0 xDAI0.000164452.75256125
Approve330943252024-03-24 16:57:05327 days ago1711299425IN
Gnosis: MANA Token
0 xDAI0.000304985.626
Approve327696692024-03-05 2:15:00347 days ago1709604900IN
Gnosis: MANA Token
0 xDAI0.00023164.5
Approve326424722024-02-26 10:28:45355 days ago1708943325IN
Gnosis: MANA Token
0 xDAI0.000183853.391605
Approve320766462024-01-22 19:49:05389 days ago1705952945IN
Gnosis: MANA Token
0 xDAI0.00008242.61637487
Approve320293132024-01-19 22:30:35392 days ago1705703435IN
Gnosis: MANA Token
0 xDAI0.000160625.1
Approve320292882024-01-19 22:28:25392 days ago1705703305IN
Gnosis: MANA Token
0 xDAI0.000150425.1
Approve316375182023-12-26 16:07:05416 days ago1703606825IN
Gnosis: MANA Token
0 xDAI0.000100593.41063077
Approve312808222023-12-05 0:57:55438 days ago1701737875IN
Gnosis: MANA Token
0 xDAI0.0006821813.24829186
Transfer And Cal...311267242023-11-25 15:53:55447 days ago1700927635IN
Gnosis: MANA Token
0 xDAI0.0030519811.05691007
Approve307470192023-11-01 22:13:35471 days ago1698876815IN
Gnosis: MANA Token
0 xDAI0.0007036312.97984747
Transfer And Cal...306327492023-10-25 15:01:35478 days ago1698246095IN
Gnosis: MANA Token
0 xDAI0.001768496.40702301
Approve304854372023-10-16 11:32:05488 days ago1697455925IN
Gnosis: MANA Token
0 xDAI0.000165815.62165332
View all transactions

Latest 1 internal transaction

Parent Transaction Hash Block From To
116570782020-08-25 11:22:401635 days ago1598354560  Contract Creation0 xDAI
Loading...
Loading

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

Contract Name:
TokenProxy

Compiler Version
v0.4.24+commit.e67f0147

Optimization Enabled:
Yes with 200 runs

Other Settings:
default evmVersion, None license
/**
 *Submitted for verification at gnosisscan.io on 2023-04-16
*/

pragma solidity 0.4.24;

/**
 * @title Proxy
 * @dev Gives the possibility to delegate any call to a foreign implementation.
 */
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
    */
    /* solcov ignore next */
    function implementation() public view returns (address);

    /**
    * @dev Fallback function allowing to perform a delegatecall to the given implementation.
    * This function will return whatever the implementation call returns
    */
    function() public 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)
                }
        }
    }
}

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

/**
* @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 mirrowing all functions.
    * @param _name token name.
    * @param _symbol token symbol.
    * @param _decimals token decimals.
    * @param _chainId chain id for current network.
    */
    constructor(address _tokenImage, string memory _name, string memory _symbol, uint8 _decimals, uint256 _chainId)
        public
    {
        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 = msg.sender; // msg.sender == HomeMultiAMBErc20ToErc677 mediator
        bridgeContractAddr = msg.sender;
        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, mirrowed token image.
    * @return token image address.
    */
    function implementation() public view returns (address impl) {
        assembly {
            impl := sload(0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc)
        }
    }
}

Contract Security Audit

Contract ABI

[{"constant":true,"inputs":[],"name":"implementation","outputs":[{"name":"impl","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"inputs":[{"name":"_tokenImage","type":"address"},{"name":"_name","type":"string"},{"name":"_symbol","type":"string"},{"name":"_decimals","type":"uint8"},{"name":"_chainId","type":"uint256"}],"payable":false,"stateMutability":"nonpayable","type":"constructor"},{"payable":true,"stateMutability":"payable","type":"fallback"}]

Deployed Bytecode

0x608060405260043610603e5763ffffffff7c01000000000000000000000000000000000000000000000000000000006000350416635c60da1b81146092575b6000604660cd565b905073ffffffffffffffffffffffffffffffffffffffff81161515606957600080fd5b60405136600082376000803683855af43d82016040523d6000833e808015608e573d83f35b3d83fd5b348015609d57600080fd5b5060a460cd565b6040805173ffffffffffffffffffffffffffffffffffffffff9092168252519081900360200190f35b7f360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc54905600a165627a7a7230582074808ee101bea5849b0339acc4d06c466b54a9ec6cfe2c1fb57dd2bfd19b7b0b0029

Deployed Bytecode Sourcemap

4887:2504:0:-;;;;;;;;;;;;;;;;;;;;715:13;731:16;:14;:16::i;:::-;715:32;-1:-1:-1;766:19:0;;;;;758:28;;;;;;1224:4;1218:11;2005:12;2002:1;1997:3;1984:34;2936:1;2933;2919:12;2914:3;2907:5;2902:3;2889:49;3626:14;3621:3;3617:24;3611:4;3604:38;4136:14;4133:1;4128:3;4113:38;4418:6;4442:76;;;;4579:14;4574:3;4567:27;4442:76;4484:14;4479:3;4472:27;7193:195;;8:9:-1;5:2;;;30:1;27;20:12;5:2;7193:195:0;;;;;;;;;;;;;;;;;;;;;;;;7303:66;7297:73;;7274:107::o

Swarm Source

bzzr://74808ee101bea5849b0339acc4d06c466b54a9ec6cfe2c1fb57dd2bfd19b7b0b

Block Transaction Gas Used Reward
view all blocks validated

Block Uncle Number Difficulty Gas Used Reward
View All Uncles
Loading...
Loading
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.