Contract 0xe1579dEbdD2DF16Ebdb9db8694391fa74EeA201E 1

 
 
Txn Hash
Method
Block
From
To
Value
0xda42a44c79dd430c81f21d3f19a8dfad4844cefe0bde490bd6a76d4265a749b3Transfer Ownersh...69210042018-12-20 13:38:071506 days 10 hrs ago0x77d8f1a73713d9ccee07a39a837c5c68682fa7d2 IN  Gnosis Chain: Validators0 Ether0.00010023
0xd8f85b50816476c6e38c857f522383f406b79f23b8cd164ee79848350145f958Transfer Proxy O...69209922018-12-20 13:33:251506 days 10 hrs ago0x7fdda1dd4310b99f94af644ccb14b5660e92fd21 IN  Gnosis Chain: Validators0 Ether0.000153265
0x6468fa84c99c415e2c93fbd09356696f73d671d45fcb5cbc75f0138394142699Transfer Proxy O...69150002018-12-19 12:57:461507 days 11 hrs ago0x97009c02849e3092a634c959610d809dbc42218f IN  Gnosis Chain: Validators0 Ether0.000153265
0x0131b0e04be7dc3c2f735a9e5d42e81592a631baffde94af9b51ee6ab78b8e70Set Required Sig...69148582018-12-19 12:21:421507 days 11 hrs ago0x77d8f1a73713d9ccee07a39a837c5c68682fa7d2 IN  Gnosis Chain: Validators0 Ether0.00021857
0x195803c4c1c7d7b90524eff510fc5310b6f72ec46b105613af8e5a9260787ae2Set Required Sig...68857112018-12-14 15:07:501512 days 9 hrs ago0x77d8f1a73713d9ccee07a39a837c5c68682fa7d2 IN  Gnosis Chain: Validators0 Ether0.00021857
0x197dc5738423bc74e0109cd0502defa847177ed80255e38d6a5688ed57daf44eAdd Validator68791792018-12-13 13:16:331513 days 10 hrs ago0x77d8f1a73713d9ccee07a39a837c5c68682fa7d2 IN  Gnosis Chain: Validators0 Ether0.0005460310
0x9da88fdec9ceb49c2cd7f8eb40d69a1da7ce6ac2454acc70731c9abfd800536dAdd Validator68431562018-12-07 14:43:241519 days 9 hrs ago0x77d8f1a73713d9ccee07a39a837c5c68682fa7d2 IN  Gnosis Chain: Validators0 Ether0.0005460310
0xbea477fda9c0452834c22ca2792497ef4aa99602d8d52f507127d9465b89aa45Add Validator68182782018-12-03 11:47:381523 days 12 hrs ago0x77d8f1a73713d9ccee07a39a837c5c68682fa7d2 IN  Gnosis Chain: Validators0 Ether0.0006552312
0x3a078e14ff1a49b925c32d6fa212abf4c8ac05e2dd36c80a2e534e16e9dba73cAdd Validator68180562018-12-03 10:53:571523 days 13 hrs ago0x97009c02849e3092a634c959610d809dbc42218f IN  Gnosis Chain: Validators0 Ether0.0003029212
0xecc7ddc7e6163302a531665ac9358253215ae28856c4cb277b4a49b45c7da7fcTransfer Proxy O...64784192018-10-08 19:49:001579 days 4 hrs agoPOA Network: Deployer 2 IN  Gnosis Chain: Validators0 Ether0.0004588315
0x62bf1cd56a67818ff675a0769c734afb191ad97e2367222476e4fcb912f2b491Initialize64784172018-10-08 19:48:471579 days 4 hrs agoPOA Network: Deployer 2 IN  Gnosis Chain: Validators0 Ether0.0023722915
0x6dbedab00bc4840c459ba44c856c3aa1e7be5acd0c4a4602620a457979e7c4eeUpgrade To64784152018-10-08 19:48:081579 days 4 hrs agoPOA Network: Deployer 2 IN  Gnosis Chain: Validators0 Ether0.000987115
0xe34e3ebab3c3bf20db5e4830df1e7d01843948a7fa8e5bd102728627a209f6210x6080604064784112018-10-08 19:46:581579 days 4 hrs agoPOA Network: Deployer 2 IN  Contract Creation0 Ether0.0056776515
[ Download CSV Export 
View more zero value Internal Transactions in Advanced View mode
Loading

Similar Match Source Code
Note: This contract matches the deployed ByteCode of the Source Code for Contract 0x4aa42145Aa6Ebf72e164C9bBC74fbD3788045016

Contract Name:
EternalStorageProxy

Compiler Version
v0.4.24+commit.e67f0147

Optimization Enabled:
Yes with 200 runs

Other Settings:
default evmVersion
/**
 *Submitted for verification at Etherscan.io on 2018-10-18
*/

pragma solidity 0.4.24;

// File: contracts/upgradeability/EternalStorage.sol

/**
 * @title EternalStorage
 * @dev This contract holds all the necessary state variables to carry out the storage of any contract.
 */
contract EternalStorage {

    mapping(bytes32 => uint256) internal uintStorage;
    mapping(bytes32 => string) internal stringStorage;
    mapping(bytes32 => address) internal addressStorage;
    mapping(bytes32 => bytes) internal bytesStorage;
    mapping(bytes32 => bool) internal boolStorage;
    mapping(bytes32 => int256) internal intStorage;

}

// File: contracts/upgradeability/UpgradeabilityOwnerStorage.sol

/**
 * @title UpgradeabilityOwnerStorage
 * @dev This contract keeps track of the upgradeability owner
 */
contract UpgradeabilityOwnerStorage {
    // Owner of the contract
    address private _upgradeabilityOwner;

    /**
    * @dev Tells the address of the owner
    * @return the address of the owner
    */
    function upgradeabilityOwner() public view returns (address) {
        return _upgradeabilityOwner;
    }

    /**
    * @dev Sets the address of the owner
    */
    function setUpgradeabilityOwner(address newUpgradeabilityOwner) internal {
        _upgradeabilityOwner = newUpgradeabilityOwner;
    }
}

// File: contracts/upgradeability/Proxy.sol

/**
 * @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
  */
    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 () payable public {
        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/upgradeability/UpgradeabilityStorage.sol

/**
 * @title UpgradeabilityStorage
 * @dev This contract holds all the necessary state variables to support the upgrade functionality
 */
contract UpgradeabilityStorage {
    // Version name of the current implementation
    uint256 internal _version;

    // Address of the current implementation
    address internal _implementation;

    /**
    * @dev Tells the version name of the current implementation
    * @return string representing the name of the current version
    */
    function version() public view returns (uint256) {
        return _version;
    }

    /**
    * @dev Tells the address of the current implementation
    * @return address of the current implementation
    */
    function implementation() public view returns (address) {
        return _implementation;
    }
}

// File: contracts/upgradeability/UpgradeabilityProxy.sol

/**
 * @title UpgradeabilityProxy
 * @dev This contract represents a proxy where the implementation address to which it will delegate can be upgraded
 */
contract UpgradeabilityProxy is Proxy, UpgradeabilityStorage {
    /**
    * @dev This event will be emitted every time the implementation gets upgraded
    * @param version representing the version name of the upgraded implementation
    * @param implementation representing the address of the upgraded implementation
    */
    event Upgraded(uint256 version, address indexed implementation);

    /**
    * @dev Upgrades the implementation address
    * @param version representing the version name of the new implementation to be set
    * @param implementation representing the address of the new implementation to be set
    */
    function _upgradeTo(uint256 version, address implementation) internal {
        require(_implementation != implementation);
        require(version > _version);
        _version = version;
        _implementation = implementation;
        emit Upgraded(version, implementation);
    }
}

// File: contracts/upgradeability/OwnedUpgradeabilityProxy.sol

/**
 * @title OwnedUpgradeabilityProxy
 * @dev This contract combines an upgradeability proxy with basic authorization control functionalities
 */
contract OwnedUpgradeabilityProxy is UpgradeabilityOwnerStorage, UpgradeabilityProxy {
  /**
  * @dev Event to show ownership has been transferred
  * @param previousOwner representing the address of the previous owner
  * @param newOwner representing the address of the new owner
  */
    event ProxyOwnershipTransferred(address previousOwner, address newOwner);

    /**
    * @dev the constructor sets the original owner of the contract to the sender account.
    */
    constructor() public {
        setUpgradeabilityOwner(msg.sender);
    }

    /**
    * @dev Throws if called by any account other than the owner.
    */
    modifier onlyProxyOwner() {
        require(msg.sender == proxyOwner());
        _;
    }

    /**
    * @dev Tells the address of the proxy owner
    * @return the address of the proxy owner
    */
    function proxyOwner() public view returns (address) {
        return upgradeabilityOwner();
    }

    /**
    * @dev Allows the current owner to transfer control of the contract to a newOwner.
    * @param newOwner The address to transfer ownership to.
    */
    function transferProxyOwnership(address newOwner) public onlyProxyOwner {
        require(newOwner != address(0));
        emit ProxyOwnershipTransferred(proxyOwner(), newOwner);
        setUpgradeabilityOwner(newOwner);
    }

    /**
    * @dev Allows the upgradeability owner to upgrade the current version of the proxy.
    * @param version representing the version name of the new implementation to be set.
    * @param implementation representing the address of the new implementation to be set.
    */
    function upgradeTo(uint256 version, address implementation) public onlyProxyOwner {
        _upgradeTo(version, implementation);
    }

    /**
    * @dev Allows the upgradeability owner to upgrade the current version of the proxy and call the new implementation
    * to initialize whatever is needed through a low level call.
    * @param version representing the version name of the new implementation to be set.
    * @param implementation representing the address of the new implementation to be set.
    * @param data represents the msg.data to bet sent in the low level call. This parameter may include the function
    * signature of the implementation to be called with the needed payload
    */
    function upgradeToAndCall(uint256 version, address implementation, bytes data) payable public onlyProxyOwner {
        upgradeTo(version, implementation);
        require(address(this).call.value(msg.value)(data));
    }
}

// File: contracts/upgradeability/EternalStorageProxy.sol

/**
 * @title EternalStorageProxy
 * @dev This proxy holds the storage of the token contract and delegates every call to the current implementation set.
 * Besides, it allows to upgrade the token's behaviour towards further implementations, and provides basic
 * authorization control functionalities
 */
contract EternalStorageProxy is OwnedUpgradeabilityProxy, EternalStorage {}

Contract Security Audit

Contract ABI

[{"constant":true,"inputs":[],"name":"proxyOwner","outputs":[{"name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"name":"version","type":"uint256"},{"name":"implementation","type":"address"}],"name":"upgradeTo","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"version","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"implementation","outputs":[{"name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"upgradeabilityOwner","outputs":[{"name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"name":"version","type":"uint256"},{"name":"implementation","type":"address"},{"name":"data","type":"bytes"}],"name":"upgradeToAndCall","outputs":[],"payable":true,"stateMutability":"payable","type":"function"},{"constant":false,"inputs":[{"name":"newOwner","type":"address"}],"name":"transferProxyOwnership","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"payable":true,"stateMutability":"payable","type":"fallback"},{"anonymous":false,"inputs":[{"indexed":false,"name":"previousOwner","type":"address"},{"indexed":false,"name":"newOwner","type":"address"}],"name":"ProxyOwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"name":"version","type":"uint256"},{"indexed":true,"name":"implementation","type":"address"}],"name":"Upgraded","type":"event"}]

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

Swarm Source

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

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.