ETH Price: $2,700.28 (-0.21%)

Contract

0xBA6FB2A9390BAEEdCc4C0Aa485a367C90cDc37a8
 

Overview

ETH Balance

0.004 ETH

Eth Value

$10.80 (@ $2,700.28/ETH)

Multichain Info

No addresses found
Transaction Hash
Method
Block
From
To
Exec Transaction139462612022-01-05 15:36:101136 days ago1641396970IN
0xBA6FB2A9...90cDc37a8
0 ETH0.00615764130.71617405
Exec Transaction139462472022-01-05 15:33:261136 days ago1641396806IN
0xBA6FB2A9...90cDc37a8
0 ETH0.0174931191.8040565
Exec Transaction139039542021-12-30 2:10:431143 days ago1640830243IN
0xBA6FB2A9...90cDc37a8
0 ETH0.0058706980.67470947
Exec Transaction139032102021-12-29 23:29:361143 days ago1640820576IN
0xBA6FB2A9...90cDc37a8
0 ETH0.0113643173.96037999
Exec Transaction139032042021-12-29 23:27:341143 days ago1640820454IN
0xBA6FB2A9...90cDc37a8
0 ETH0.00888447136
Exec Transaction139031952021-12-29 23:26:171143 days ago1640820377IN
0xBA6FB2A9...90cDc37a8
0 ETH0.01227922188
Exec Transaction139031912021-12-29 23:25:161143 days ago1640820316IN
0xBA6FB2A9...90cDc37a8
0 ETH0.01139492174.39694289
Exec Transaction139031032021-12-29 23:04:401143 days ago1640819080IN
0xBA6FB2A9...90cDc37a8
0 ETH0.00839682128.51167576
Exec Transaction138983762021-12-29 5:38:111144 days ago1640756291IN
0xBA6FB2A9...90cDc37a8
0 ETH0.0055496362.36878732
Exec Transaction138980502021-12-29 4:29:001144 days ago1640752140IN
0xBA6FB2A9...90cDc37a8
0 ETH0.0060345478
Exec Transaction138961062021-12-28 21:16:571144 days ago1640726217IN
0xBA6FB2A9...90cDc37a8
0 ETH0.01133335120.59842422
Exec Transaction138960962021-12-28 21:13:491144 days ago1640726029IN
0xBA6FB2A9...90cDc37a8
0 ETH0.00949157101
Exec Transaction138960942021-12-28 21:12:171144 days ago1640725937IN
0xBA6FB2A9...90cDc37a8
0 ETH0.0084364989.78432527
Exec Transaction138960742021-12-28 21:07:521144 days ago1640725672IN
0xBA6FB2A9...90cDc37a8
0 ETH0.0081803587.04726589
Exec Transaction138625832021-12-23 16:44:071149 days ago1640277847IN
0xBA6FB2A9...90cDc37a8
0 ETH0.0044844460.94326023
Exec Transaction138549002021-12-22 12:04:431150 days ago1640174683IN
0xBA6FB2A9...90cDc37a8
0 ETH0.0049207566.8726425
Exec Transaction138531082021-12-22 5:28:131151 days ago1640150893IN
0xBA6FB2A9...90cDc37a8
0 ETH0.0035599446
Exec Transaction138502582021-12-21 18:52:591151 days ago1640112779IN
0xBA6FB2A9...90cDc37a8
0 ETH0.0048078853.01802875
Transfer138496882021-12-21 16:45:241151 days ago1640105124IN
0xBA6FB2A9...90cDc37a8
2 ETH0.0019102569.89861192

Latest 11 internal transactions

Advanced mode:
Parent Transaction Hash Block
From
To
139039542021-12-30 2:10:431143 days ago1640830243
0xBA6FB2A9...90cDc37a8
15.672 ETH
138980502021-12-29 4:29:001144 days ago1640752140
0xBA6FB2A9...90cDc37a8
1.02 ETH
138961062021-12-28 21:16:571144 days ago1640726217
0xBA6FB2A9...90cDc37a8
15.646 ETH
138960962021-12-28 21:13:491144 days ago1640726029
0xBA6FB2A9...90cDc37a8
15.646 ETH
138960942021-12-28 21:12:171144 days ago1640725937
0xBA6FB2A9...90cDc37a8
15.646 ETH
138960742021-12-28 21:07:521144 days ago1640725672
0xBA6FB2A9...90cDc37a8
15.646 ETH
138625832021-12-23 16:44:071149 days ago1640277847
0xBA6FB2A9...90cDc37a8
20.62 ETH
138549002021-12-22 12:04:431150 days ago1640174683
0xBA6FB2A9...90cDc37a8
21.99 ETH
138531082021-12-22 5:28:131151 days ago1640150893
0xBA6FB2A9...90cDc37a8
17.84 ETH
138502582021-12-21 18:52:591151 days ago1640112779
0xBA6FB2A9...90cDc37a8
14.79 ETH
138235622021-12-17 16:02:071155 days ago1639756927  Contract Creation0 ETH
Loading...
Loading

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

Contract Name:
GnosisSafeProxy

Compiler Version
v0.7.6+commit.7338295f

Optimization Enabled:
No with 200 runs

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

// SPDX-License-Identifier: LGPL-3.0-only
pragma solidity >=0.7.0 <0.9.0;

/// @title IProxy - Helper interface to access masterCopy of the Proxy on-chain
/// @author Richard Meissner - <[email protected]>
interface IProxy {
    function masterCopy() external view returns (address);
}

/// @title GnosisSafeProxy - Generic proxy contract allows to execute all transactions applying the code of a master contract.
/// @author Stefan George - <[email protected]>
/// @author Richard Meissner - <[email protected]>
contract GnosisSafeProxy {
    // singleton always needs to be first declared variable, to ensure that it is at the same location in the contracts to which calls are delegated.
    // To reduce deployment costs this variable is internal and needs to be retrieved via `getStorageAt`
    address internal singleton;

    /// @dev Constructor function sets address of singleton contract.
    /// @param _singleton Singleton address.
    constructor(address _singleton) {
        require(_singleton != address(0), "Invalid singleton address provided");
        singleton = _singleton;
    }

    /// @dev Fallback function forwards all transactions and returns all received return data.
    fallback() external payable {
        // solhint-disable-next-line no-inline-assembly
        assembly {
            let _singleton := and(sload(0), 0xffffffffffffffffffffffffffffffffffffffff)
            // 0xa619486e == keccak("masterCopy()"). The value is right padded to 32-bytes with 0s
            if eq(calldataload(0), 0xa619486e00000000000000000000000000000000000000000000000000000000) {
                mstore(0, _singleton)
                return(0, 0x20)
            }
            calldatacopy(0, 0, calldatasize())
            let success := delegatecall(gas(), _singleton, 0, calldatasize(), 0, 0)
            returndatacopy(0, 0, returndatasize())
            if eq(success, 0) {
                revert(0, returndatasize())
            }
            return(0, returndatasize())
        }
    }
}

/// @title Proxy Factory - Allows to create new proxy contact and execute a message call to the new proxy within one transaction.
/// @author Stefan George - <[email protected]>
contract GnosisSafeProxyFactory {
    event ProxyCreation(GnosisSafeProxy proxy, address singleton);

    /// @dev Allows to create new proxy contact and execute a message call to the new proxy within one transaction.
    /// @param singleton Address of singleton contract.
    /// @param data Payload for message call sent to new proxy contract.
    function createProxy(address singleton, bytes memory data) public returns (GnosisSafeProxy proxy) {
        proxy = new GnosisSafeProxy(singleton);
        if (data.length > 0)
            // solhint-disable-next-line no-inline-assembly
            assembly {
                if eq(call(gas(), proxy, 0, add(data, 0x20), mload(data), 0, 0), 0) {
                    revert(0, 0)
                }
            }
        emit ProxyCreation(proxy, singleton);
    }

    /// @dev Allows to retrieve the runtime code of a deployed Proxy. This can be used to check that the expected Proxy was deployed.
    function proxyRuntimeCode() public pure returns (bytes memory) {
        return type(GnosisSafeProxy).runtimeCode;
    }

    /// @dev Allows to retrieve the creation code used for the Proxy deployment. With this it is easily possible to calculate predicted address.
    function proxyCreationCode() public pure returns (bytes memory) {
        return type(GnosisSafeProxy).creationCode;
    }

    /// @dev Allows to create new proxy contact using CREATE2 but it doesn't run the initializer.
    ///      This method is only meant as an utility to be called from other methods
    /// @param _singleton Address of singleton contract.
    /// @param initializer Payload for message call sent to new proxy contract.
    /// @param saltNonce Nonce that will be used to generate the salt to calculate the address of the new proxy contract.
    function deployProxyWithNonce(
        address _singleton,
        bytes memory initializer,
        uint256 saltNonce
    ) internal returns (GnosisSafeProxy proxy) {
        // If the initializer changes the proxy address should change too. Hashing the initializer data is cheaper than just concatinating it
        bytes32 salt = keccak256(abi.encodePacked(keccak256(initializer), saltNonce));
        bytes memory deploymentData = abi.encodePacked(type(GnosisSafeProxy).creationCode, uint256(uint160(_singleton)));
        // solhint-disable-next-line no-inline-assembly
        assembly {
            proxy := create2(0x0, add(0x20, deploymentData), mload(deploymentData), salt)
        }
        require(address(proxy) != address(0), "Create2 call failed");
    }

    /// @dev Allows to create new proxy contact and execute a message call to the new proxy within one transaction.
    /// @param _singleton Address of singleton contract.
    /// @param initializer Payload for message call sent to new proxy contract.
    /// @param saltNonce Nonce that will be used to generate the salt to calculate the address of the new proxy contract.
    function createProxyWithNonce(
        address _singleton,
        bytes memory initializer,
        uint256 saltNonce
    ) public returns (GnosisSafeProxy proxy) {
        proxy = deployProxyWithNonce(_singleton, initializer, saltNonce);
        if (initializer.length > 0)
            // solhint-disable-next-line no-inline-assembly
            assembly {
                if eq(call(gas(), proxy, 0, add(initializer, 0x20), mload(initializer), 0, 0), 0) {
                    revert(0, 0)
                }
            }
        emit ProxyCreation(proxy, _singleton);
    }

    /// @dev Allows to create new proxy contact, execute a message call to the new proxy and call a specified callback within one transaction
    /// @param _singleton Address of singleton contract.
    /// @param initializer Payload for message call sent to new proxy contract.
    /// @param saltNonce Nonce that will be used to generate the salt to calculate the address of the new proxy contract.
    /// @param callback Callback that will be invoced after the new proxy contract has been successfully deployed and initialized.
    function createProxyWithCallback(
        address _singleton,
        bytes memory initializer,
        uint256 saltNonce,
        IProxyCreationCallback callback
    ) public returns (GnosisSafeProxy proxy) {
        uint256 saltNonceWithCallback = uint256(keccak256(abi.encodePacked(saltNonce, callback)));
        proxy = createProxyWithNonce(_singleton, initializer, saltNonceWithCallback);
        if (address(callback) != address(0)) callback.proxyCreated(proxy, _singleton, initializer, saltNonce);
    }

    /// @dev Allows to get the address for a new proxy contact created via `createProxyWithNonce`
    ///      This method is only meant for address calculation purpose when you use an initializer that would revert,
    ///      therefore the response is returned with a revert. When calling this method set `from` to the address of the proxy factory.
    /// @param _singleton Address of singleton contract.
    /// @param initializer Payload for message call sent to new proxy contract.
    /// @param saltNonce Nonce that will be used to generate the salt to calculate the address of the new proxy contract.
    function calculateCreateProxyWithNonceAddress(
        address _singleton,
        bytes calldata initializer,
        uint256 saltNonce
    ) external returns (GnosisSafeProxy proxy) {
        proxy = deployProxyWithNonce(_singleton, initializer, saltNonce);
        revert(string(abi.encodePacked(proxy)));
    }
}

interface IProxyCreationCallback {
    function proxyCreated(
        GnosisSafeProxy proxy,
        address _singleton,
        bytes calldata initializer,
        uint256 saltNonce
    ) external;
}

Contract Security Audit

Contract ABI

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

Deployed Bytecode

0x608060405273ffffffffffffffffffffffffffffffffffffffff600054167fa619486e0000000000000000000000000000000000000000000000000000000060003514156050578060005260206000f35b3660008037600080366000845af43d6000803e60008114156070573d6000fd5b3d6000f3fea2646970667358221220d1429297349653a4918076d650332de1a1068c5f3e07c5c82360c277770b955264736f6c63430007060033

Deployed Bytecode Sourcemap

524:1528:0:-:0;;;1376:42;1372:1;1366:8;1362:57;1556:66;1552:1;1539:15;1536:87;1533:2;;;1653:10;1650:1;1643:21;1692:4;1689:1;1682:15;1533:2;1745:14;1742:1;1739;1726:34;1843:1;1840;1824:14;1821:1;1809:10;1802:5;1789:56;1880:16;1877:1;1874;1859:38;1926:1;1917:7;1914:14;1911:2;;;1958:16;1955:1;1948:27;1911:2;2014:16;2011:1;2004:27

Swarm Source

ipfs://d1429297349653a4918076d650332de1a1068c5f3e07c5c82360c277770b9552

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.