ETH Price: $2,685.03 (-1.05%)

Contract

0x5566B3E5Fc300A1B28C214b49a5950C34d00eb33
 

Overview

ETH Balance

0 ETH

Eth Value

$0.00

Multichain Info

No addresses found
Transaction Hash
Method
Block
From
To
Forward205240182024-08-14 2:55:11188 days ago1723604111IN
0x5566B3E5...34d00eb33
0 ETH0.000841881.97399923
Forward204643312024-08-05 19:03:35197 days ago1722884615IN
0x5566B3E5...34d00eb33
0 ETH0.0197208211.18571474
Forward203833262024-07-25 11:40:59208 days ago1721907659IN
0x5566B3E5...34d00eb33
0 ETH0.000874772.15718041
Forward203832152024-07-25 11:18:35208 days ago1721906315IN
0x5566B3E5...34d00eb33
0 ETH0.000982882.29255528
Forward203832102024-07-25 11:17:23208 days ago1721906243IN
0x5566B3E5...34d00eb33
0 ETH0.001395853.25571308
Forward203829562024-07-25 10:26:11208 days ago1721903171IN
0x5566B3E5...34d00eb33
0 ETH0.001417063.30574127
Forward203829312024-07-25 10:21:11208 days ago1721902871IN
0x5566B3E5...34d00eb33
0 ETH0.001773354.13712434
Forward203827112024-07-25 9:36:59208 days ago1721900219IN
0x5566B3E5...34d00eb33
0 ETH0.001540223.59346172
Forward203826602024-07-25 9:26:47208 days ago1721899607IN
0x5566B3E5...34d00eb33
0 ETH0.001161082.70880541
Forward203826482024-07-25 9:24:23208 days ago1721899463IN
0x5566B3E5...34d00eb33
0 ETH0.00098242.42131197
Forward203776882024-07-24 16:47:11209 days ago1721839631IN
0x5566B3E5...34d00eb33
0 ETH0.002791837.18848914
Forward203776852024-07-24 16:46:35209 days ago1721839595IN
0x5566B3E5...34d00eb33
0 ETH0.002908287.488331
Forward203645522024-07-22 20:47:47211 days ago1721681267IN
0x5566B3E5...34d00eb33
0 ETH0.001777915.24185634
Forward203205732024-07-16 17:29:35217 days ago1721150975IN
0x5566B3E5...34d00eb33
0 ETH0.0062168116.04452167
Forward203205672024-07-16 17:28:23217 days ago1721150903IN
0x5566B3E5...34d00eb33
0 ETH0.0051193713.21222262
Forward203205592024-07-16 17:26:47217 days ago1721150807IN
0x5566B3E5...34d00eb33
0 ETH0.0055853214.41473908
Forward203205492024-07-16 17:24:47217 days ago1721150687IN
0x5566B3E5...34d00eb33
0 ETH0.0054956514.18332848
Forward203205422024-07-16 17:23:23217 days ago1721150603IN
0x5566B3E5...34d00eb33
0 ETH0.0061339115.83055982
Forward203205342024-07-16 17:21:47217 days ago1721150507IN
0x5566B3E5...34d00eb33
0 ETH0.0065631916.93846855
Forward203205182024-07-16 17:18:35217 days ago1721150315IN
0x5566B3E5...34d00eb33
0 ETH0.0062715416.1857541
Forward203205122024-07-16 17:17:23217 days ago1721150243IN
0x5566B3E5...34d00eb33
0 ETH0.006221716.05763655
Forward203204942024-07-16 17:13:47217 days ago1721150027IN
0x5566B3E5...34d00eb33
0 ETH0.0062047915.89392494
Forward203204762024-07-16 17:10:11217 days ago1721149811IN
0x5566B3E5...34d00eb33
0 ETH0.0058872215.08043821
Forward173762952023-05-31 3:49:35629 days ago1685504975IN
0x5566B3E5...34d00eb33
0 ETH0.0128559326.96158953
Forward173762912023-05-31 3:48:47629 days ago1685504927IN
0x5566B3E5...34d00eb33
0 ETH0.0121433525.466529
View all transactions

Latest 4 internal transactions

Advanced mode:
Parent Transaction Hash Block
From
To
141601522022-02-07 17:00:321107 days ago1644253232
0x5566B3E5...34d00eb33
0.01211113 ETH
117181982021-01-24 12:04:001486 days ago1611489840
0x5566B3E5...34d00eb33
2.8 ETH
117179772021-01-24 11:13:071486 days ago1611486787
0x5566B3E5...34d00eb33
2.8 ETH
112609782020-11-15 7:14:581556 days ago1605424498  Contract Creation0 ETH
Loading...
Loading

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

Contract Name:
AppProxyUpgradeable

Compiler Version
v0.4.24+commit.e67f0147

Optimization Enabled:
Yes with 10000 runs

Other Settings:
default evmVersion, GNU GPLv3 license

Contract Source Code (Solidity)

/**
 *Submitted for verification at Etherscan.io on 2019-09-06
*/

// File: contracts/common/UnstructuredStorage.sol

/*
 * SPDX-License-Identitifer:    MIT
 */

pragma solidity ^0.4.24;


library UnstructuredStorage {
    function getStorageBool(bytes32 position) internal view returns (bool data) {
        assembly { data := sload(position) }
    }

    function getStorageAddress(bytes32 position) internal view returns (address data) {
        assembly { data := sload(position) }
    }

    function getStorageBytes32(bytes32 position) internal view returns (bytes32 data) {
        assembly { data := sload(position) }
    }

    function getStorageUint256(bytes32 position) internal view returns (uint256 data) {
        assembly { data := sload(position) }
    }

    function setStorageBool(bytes32 position, bool data) internal {
        assembly { sstore(position, data) }
    }

    function setStorageAddress(bytes32 position, address data) internal {
        assembly { sstore(position, data) }
    }

    function setStorageBytes32(bytes32 position, bytes32 data) internal {
        assembly { sstore(position, data) }
    }

    function setStorageUint256(bytes32 position, uint256 data) internal {
        assembly { sstore(position, data) }
    }
}

// File: contracts/acl/IACL.sol

/*
 * SPDX-License-Identitifer:    MIT
 */

pragma solidity ^0.4.24;


interface IACL {
    function initialize(address permissionsCreator) external;

    // TODO: this should be external
    // See https://github.com/ethereum/solidity/issues/4832
    function hasPermission(address who, address where, bytes32 what, bytes how) public view returns (bool);
}

// File: contracts/common/IVaultRecoverable.sol

/*
 * SPDX-License-Identitifer:    MIT
 */

pragma solidity ^0.4.24;


interface IVaultRecoverable {
    event RecoverToVault(address indexed vault, address indexed token, uint256 amount);

    function transferToVault(address token) external;

    function allowRecoverability(address token) external view returns (bool);
    function getRecoveryVault() external view returns (address);
}

// File: contracts/kernel/IKernel.sol

/*
 * SPDX-License-Identitifer:    MIT
 */

pragma solidity ^0.4.24;




interface IKernelEvents {
    event SetApp(bytes32 indexed namespace, bytes32 indexed appId, address app);
}


// This should be an interface, but interfaces can't inherit yet :(
contract IKernel is IKernelEvents, IVaultRecoverable {
    function acl() public view returns (IACL);
    function hasPermission(address who, address where, bytes32 what, bytes how) public view returns (bool);

    function setApp(bytes32 namespace, bytes32 appId, address app) public;
    function getApp(bytes32 namespace, bytes32 appId) public view returns (address);
}

// File: contracts/apps/AppStorage.sol

/*
 * SPDX-License-Identitifer:    MIT
 */

pragma solidity ^0.4.24;




contract AppStorage {
    using UnstructuredStorage for bytes32;

    /* Hardcoded constants to save gas
    bytes32 internal constant KERNEL_POSITION = keccak256("aragonOS.appStorage.kernel");
    bytes32 internal constant APP_ID_POSITION = keccak256("aragonOS.appStorage.appId");
    */
    bytes32 internal constant KERNEL_POSITION = 0x4172f0f7d2289153072b0a6ca36959e0cbe2efc3afe50fc81636caa96338137b;
    bytes32 internal constant APP_ID_POSITION = 0xd625496217aa6a3453eecb9c3489dc5a53e6c67b444329ea2b2cbc9ff547639b;

    function kernel() public view returns (IKernel) {
        return IKernel(KERNEL_POSITION.getStorageAddress());
    }

    function appId() public view returns (bytes32) {
        return APP_ID_POSITION.getStorageBytes32();
    }

    function setKernel(IKernel _kernel) internal {
        KERNEL_POSITION.setStorageAddress(address(_kernel));
    }

    function setAppId(bytes32 _appId) internal {
        APP_ID_POSITION.setStorageBytes32(_appId);
    }
}

// File: contracts/common/IsContract.sol

/*
 * SPDX-License-Identitifer:    MIT
 */

pragma solidity ^0.4.24;


contract IsContract {
    /*
    * NOTE: this should NEVER be used for authentication
    * (see pitfalls: https://github.com/fergarrui/ethereum-security/tree/master/contracts/extcodesize).
    *
    * This is only intended to be used as a sanity check that an address is actually a contract,
    * RATHER THAN an address not being a contract.
    */
    function isContract(address _target) internal view returns (bool) {
        if (_target == address(0)) {
            return false;
        }

        uint256 size;
        assembly { size := extcodesize(_target) }
        return size > 0;
    }
}

// File: contracts/lib/misc/ERCProxy.sol

/*
 * SPDX-License-Identitifer:    MIT
 */

pragma solidity ^0.4.24;


contract ERCProxy {
    uint256 internal constant FORWARDING = 1;
    uint256 internal constant UPGRADEABLE = 2;

    function proxyType() public pure returns (uint256 proxyTypeId);
    function implementation() public view returns (address codeAddr);
}

// File: contracts/common/DelegateProxy.sol

pragma solidity 0.4.24;




contract DelegateProxy is ERCProxy, IsContract {
    uint256 internal constant FWD_GAS_LIMIT = 10000;

    /**
    * @dev Performs a delegatecall and returns whatever the delegatecall returned (entire context execution will return!)
    * @param _dst Destination address to perform the delegatecall
    * @param _calldata Calldata for the delegatecall
    */
    function delegatedFwd(address _dst, bytes _calldata) internal {
        require(isContract(_dst));
        uint256 fwdGasLimit = FWD_GAS_LIMIT;

        assembly {
            let result := delegatecall(sub(gas, fwdGasLimit), _dst, add(_calldata, 0x20), mload(_calldata), 0, 0)
            let size := returndatasize
            let ptr := mload(0x40)
            returndatacopy(ptr, 0, size)

            // revert instead of invalid() bc if the underlying call failed with invalid() it already wasted gas.
            // if the call returned error data, forward it
            switch result case 0 { revert(ptr, size) }
            default { return(ptr, size) }
        }
    }
}

// File: contracts/common/DepositableStorage.sol

pragma solidity 0.4.24;



contract DepositableStorage {
    using UnstructuredStorage for bytes32;

    // keccak256("aragonOS.depositableStorage.depositable")
    bytes32 internal constant DEPOSITABLE_POSITION = 0x665fd576fbbe6f247aff98f5c94a561e3f71ec2d3c988d56f12d342396c50cea;

    function isDepositable() public view returns (bool) {
        return DEPOSITABLE_POSITION.getStorageBool();
    }

    function setDepositable(bool _depositable) internal {
        DEPOSITABLE_POSITION.setStorageBool(_depositable);
    }
}

// File: contracts/common/DepositableDelegateProxy.sol

pragma solidity 0.4.24;




contract DepositableDelegateProxy is DepositableStorage, DelegateProxy {
    event ProxyDeposit(address sender, uint256 value);

    function () external payable {
        uint256 forwardGasThreshold = FWD_GAS_LIMIT;
        bytes32 isDepositablePosition = DEPOSITABLE_POSITION;

        // Optimized assembly implementation to prevent EIP-1884 from breaking deposits, reference code in Solidity:
        // https://github.com/aragon/aragonOS/blob/v4.2.1/contracts/common/DepositableDelegateProxy.sol#L10-L20
        assembly {
            // Continue only if the gas left is lower than the threshold for forwarding to the implementation code,
            // otherwise continue outside of the assembly block.
            if lt(gas, forwardGasThreshold) {
                // Only accept the deposit and emit an event if all of the following are true:
                // the proxy accepts deposits (isDepositable), msg.data.length == 0, and msg.value > 0
                if and(and(sload(isDepositablePosition), iszero(calldatasize)), gt(callvalue, 0)) {
                    // Equivalent Solidity code for emitting the event:
                    // emit ProxyDeposit(msg.sender, msg.value);

                    let logData := mload(0x40) // free memory pointer
                    mstore(logData, caller) // add 'msg.sender' to the log data (first event param)
                    mstore(add(logData, 0x20), callvalue) // add 'msg.value' to the log data (second event param)

                    // Emit an event with one topic to identify the event: keccak256('ProxyDeposit(address,uint256)') = 0x15ee...dee1
                    log1(logData, 0x40, 0x15eeaa57c7bd188c1388020bcadc2c436ec60d647d36ef5b9eb3c742217ddee1)

                    stop() // Stop. Exits execution context
                }

                // If any of above checks failed, revert the execution (if ETH was sent, it is returned to the sender)
                revert(0, 0)
            }
        }

        address target = implementation();
        delegatedFwd(target, msg.data);
    }
}

// File: contracts/kernel/KernelConstants.sol

/*
 * SPDX-License-Identitifer:    MIT
 */

pragma solidity ^0.4.24;


contract KernelAppIds {
    /* Hardcoded constants to save gas
    bytes32 internal constant KERNEL_CORE_APP_ID = apmNamehash("kernel");
    bytes32 internal constant KERNEL_DEFAULT_ACL_APP_ID = apmNamehash("acl");
    bytes32 internal constant KERNEL_DEFAULT_VAULT_APP_ID = apmNamehash("vault");
    */
    bytes32 internal constant KERNEL_CORE_APP_ID = 0x3b4bf6bf3ad5000ecf0f989d5befde585c6860fea3e574a4fab4c49d1c177d9c;
    bytes32 internal constant KERNEL_DEFAULT_ACL_APP_ID = 0xe3262375f45a6e2026b7e7b18c2b807434f2508fe1a2a3dfb493c7df8f4aad6a;
    bytes32 internal constant KERNEL_DEFAULT_VAULT_APP_ID = 0x7e852e0fcfce6551c13800f1e7476f982525c2b5277ba14b24339c68416336d1;
}


contract KernelNamespaceConstants {
    /* Hardcoded constants to save gas
    bytes32 internal constant KERNEL_CORE_NAMESPACE = keccak256("core");
    bytes32 internal constant KERNEL_APP_BASES_NAMESPACE = keccak256("base");
    bytes32 internal constant KERNEL_APP_ADDR_NAMESPACE = keccak256("app");
    */
    bytes32 internal constant KERNEL_CORE_NAMESPACE = 0xc681a85306374a5ab27f0bbc385296a54bcd314a1948b6cf61c4ea1bc44bb9f8;
    bytes32 internal constant KERNEL_APP_BASES_NAMESPACE = 0xf1f3eb40f5bc1ad1344716ced8b8a0431d840b5783aea1fd01786bc26f35ac0f;
    bytes32 internal constant KERNEL_APP_ADDR_NAMESPACE = 0xd6f028ca0e8edb4a8c9757ca4fdccab25fa1e0317da1188108f7d2dee14902fb;
}

// File: contracts/apps/AppProxyBase.sol

pragma solidity 0.4.24;






contract AppProxyBase is AppStorage, DepositableDelegateProxy, KernelNamespaceConstants {
    /**
    * @dev Initialize AppProxy
    * @param _kernel Reference to organization kernel for the app
    * @param _appId Identifier for app
    * @param _initializePayload Payload for call to be made after setup to initialize
    */
    constructor(IKernel _kernel, bytes32 _appId, bytes _initializePayload) public {
        setKernel(_kernel);
        setAppId(_appId);

        // Implicit check that kernel is actually a Kernel
        // The EVM doesn't actually provide a way for us to make sure, but we can force a revert to
        // occur if the kernel is set to 0x0 or a non-code address when we try to call a method on
        // it.
        address appCode = getAppBase(_appId);

        // If initialize payload is provided, it will be executed
        if (_initializePayload.length > 0) {
            require(isContract(appCode));
            // Cannot make delegatecall as a delegateproxy.delegatedFwd as it
            // returns ending execution context and halts contract deployment
            require(appCode.delegatecall(_initializePayload));
        }
    }

    function getAppBase(bytes32 _appId) internal view returns (address) {
        return kernel().getApp(KERNEL_APP_BASES_NAMESPACE, _appId);
    }
}

// File: contracts/apps/AppProxyUpgradeable.sol

pragma solidity 0.4.24;



contract AppProxyUpgradeable is AppProxyBase {
    /**
    * @dev Initialize AppProxyUpgradeable (makes it an upgradeable Aragon app)
    * @param _kernel Reference to organization kernel for the app
    * @param _appId Identifier for app
    * @param _initializePayload Payload for call to be made after setup to initialize
    */
    constructor(IKernel _kernel, bytes32 _appId, bytes _initializePayload)
        AppProxyBase(_kernel, _appId, _initializePayload)
        public // solium-disable-line visibility-first
    {
        // solium-disable-previous-line no-empty-blocks
    }

    /**
     * @dev ERC897, the address the proxy would delegate calls to
     */
    function implementation() public view returns (address) {
        return getAppBase(appId());
    }

    /**
     * @dev ERC897, whether it is a forwarding (1) or an upgradeable (2) proxy
     */
    function proxyType() public pure returns (uint256 proxyTypeId) {
        return UPGRADEABLE;
    }
}

Contract Security Audit

Contract ABI

[{"constant":true,"inputs":[],"name":"proxyType","outputs":[{"name":"proxyTypeId","type":"uint256"}],"payable":false,"stateMutability":"pure","type":"function"},{"constant":true,"inputs":[],"name":"isDepositable","outputs":[{"name":"","type":"bool"}],"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":"appId","outputs":[{"name":"","type":"bytes32"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"kernel","outputs":[{"name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"inputs":[{"name":"_kernel","type":"address"},{"name":"_appId","type":"bytes32"},{"name":"_initializePayload","type":"bytes"}],"payable":false,"stateMutability":"nonpayable","type":"constructor"},{"payable":true,"stateMutability":"payable","type":"fallback"},{"anonymous":false,"inputs":[{"indexed":false,"name":"sender","type":"address"},{"indexed":false,"name":"value","type":"uint256"}],"name":"ProxyDeposit","type":"event"}]

Deployed Bytecode

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

Deployed Bytecode Sourcemap

12048:1002:0:-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;5242:5;6492:66;7084:27;5242:5;7647:3;7644:28;7641:2;;;7970:1;7959:9;7956:16;7940:12;7933:20;7909:21;7903:28;7899:55;7895:78;7892:2;;;8159:4;8153:11;8225:6;8216:7;8209:23;8337:9;8330:4;8321:7;8317:18;8310:37;8582:66;8576:4;8567:7;8562:87;8673:6;7892:2;8881:1;8878;8871:12;7641:2;8938:16;:14;:16::i;:::-;8921:33;;8965:30;8978:6;8986:8;;8965:30;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;8965:12:0;;-1:-1:-1;;;;;8965:30:0:i;:::-;7044:1959;;;12048:1002;12947:100;;8:9:-1;5:2;;;30:1;27;20:12;5:2;12947:100:0;;;;;;;;;;;;;;;;;;;;6567:115;;8:9:-1;5:2;;;30:1;27;20:12;5:2;6567:115:0;;;;;;;;;;;;;;;;;;;;;;12740:101;;8:9:-1;5:2;;;30:1;27;20:12;5:2;12740:101:0;;;;;;;;;;;;;;;;;;;;;;;3588:108;;8:9:-1;5:2;;;30:1;27;20:12;5:2;3588:108:0;;;;3462:118;;8:9:-1;5:2;;;30:1;27;20:12;5:2;3462:118:0;;;;12740:101;12787:7;12814:19;12825:7;:5;:7::i;:::-;12814:10;:19::i;:::-;12807:26;;12740:101;:::o;5517:694::-;5626:19;5598:16;5609:4;5598:10;:16::i;:::-;5590:25;;;;;;;;5242:5;5626:35;;5797:1;5794;5782:9;5776:16;5769:4;5758:9;5754:20;5748:4;5734:11;5729:3;5725:21;5712:87;5825:14;5870:4;5864:11;5912:4;5909:1;5904:3;5889:28;6115:6;6122:28;;;;6186:4;6181:3;6174:17;6122:28;6143:4;6138:3;6131:17;12947:100;4915:1;12947:100;:::o;6567:115::-;6613:4;6637:37;6492:66;6637:35;:37::i;3588:108::-;3626:7;3653:35;3387:66;3653:33;:35::i;3462:118::-;3501:7;3536:35;3270:66;3536:33;:35::i;11814:145::-;11873:7;11900:8;:6;:8::i;:::-;:51;;;;;;10327:66;11900:51;;;;;;;;;;;;:15;;;;;;;;:51;;;;;;;;;;;;;;;;:15;:51;;;5:2:-1;;;;30:1;27;20:12;5:2;11900:51:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;11900:51:0;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;11900:51:0;;11814:145;-1:-1:-1;;11814:145:0:o;4422:252::-;4482:4;;4503:21;;;;4499:66;;;4548:5;4541:12;;;;4499:66;4631:7;4619:20;4611:28;;4665:1;4658:4;:8;4651:15;;4422:252;;;;;:::o;166:130::-;272:15;;262:27::o;304:136::-;416:15;;406:27::o;859:121::-;949:22;;947:26::o;988:121::-;1078:22;;1076:26::o

Swarm Source

bzzr://976bd9d6f6ad7a0d339ea3b373704842cdb3d9e15e7463676c04c1fa6ffb5641

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
Loading...
Loading
[ 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.