ETH Price: $2,730.43 (-3.54%)
Gas: 1 Gwei

Contract

0x78329f10318a71DE8b65172D1024067F3BD32952
 

Overview

ETH Balance

208.833975079783279941 ETH

Eth Value

$570,206.84 (@ $2,730.43/ETH)

Token Holdings

Multichain Info

No addresses found
Transaction Hash
Method
Block
From
To
Transfer217916212025-02-07 2:23:116 hrs ago1738894991IN
0x78329f10...F3BD32952
0.01871624 ETH0.000025520.92735093
Transfer217867462025-02-06 10:04:3522 hrs ago1738836275IN
0x78329f10...F3BD32952
0.01816238 ETH0.000032381.17663618
Transfer217857642025-02-06 6:47:3526 hrs ago1738824455IN
0x78329f10...F3BD32952
0.00999467 ETH0.000030131.09471989
Transfer217803032025-02-05 12:30:2344 hrs ago1738758623IN
0x78329f10...F3BD32952
0.27408589 ETH0.00003771.36987315
Transfer217802752025-02-05 12:24:4744 hrs ago1738758287IN
0x78329f10...F3BD32952
0.01586891 ETH0.000041281.49974265
Transfer217791122025-02-05 8:30:592 days ago1738744259IN
0x78329f10...F3BD32952
0.01647595 ETH0.00003651.32614343
Transfer217782042025-02-05 5:27:472 days ago1738733267IN
0x78329f10...F3BD32952
0.00790312 ETH0.000033371.21228929
Transfer217778742025-02-05 4:21:232 days ago1738729283IN
0x78329f10...F3BD32952
0.02562955 ETH0.000032111.16667827
Transfer217775442025-02-05 3:14:472 days ago1738725287IN
0x78329f10...F3BD32952
0.01084657 ETH0.000050831.8465914
Transfer217748392025-02-04 18:10:592 days ago1738692659IN
0x78329f10...F3BD32952
0.03635762 ETH0.000083693.0404772
Transfer217738992025-02-04 15:01:472 days ago1738681307IN
0x78329f10...F3BD32952
0.23345643 ETH0.000081572.96340863
Transfer217729742025-02-04 11:55:592 days ago1738670159IN
0x78329f10...F3BD32952
0.03822025 ETH0.000038181.38701331
Transfer217692402025-02-03 23:23:473 days ago1738625027IN
0x78329f10...F3BD32952
0.05376487 ETH0.000174426.33640948
Transfer217634422025-02-03 3:57:354 days ago1738555055IN
0x78329f10...F3BD32952
0.19781113 ETH0.0014763253.63174177
Transfer217634292025-02-03 3:54:594 days ago1738554899IN
0x78329f10...F3BD32952
0.69779952 ETH0.0014643353.19639655
Transfer217621642025-02-02 23:39:594 days ago1738539599IN
0x78329f10...F3BD32952
0.13873962 ETH0.0005218118.95651467
Transfer217559702025-02-02 2:52:235 days ago1738464743IN
0x78329f10...F3BD32952
0.02179556 ETH0.000052481.90652072
Transfer217558822025-02-02 2:34:355 days ago1738463675IN
0x78329f10...F3BD32952
0.0158868 ETH0.000043171.56844242
Transfer217548802025-02-01 23:13:595 days ago1738451639IN
0x78329f10...F3BD32952
0.03173441 ETH0.000117464.2673242
Transfer217531972025-02-01 17:35:235 days ago1738431323IN
0x78329f10...F3BD32952
0.01214534 ETH0.000087493.17833472
Transfer217507332025-02-01 9:20:115 days ago1738401611IN
0x78329f10...F3BD32952
0.0122762 ETH0.000056512.05301659
Transfer217502972025-02-01 7:52:356 days ago1738396355IN
0x78329f10...F3BD32952
0.00984575 ETH0.000043231.57049729
Transfer217467892025-01-31 20:07:116 days ago1738354031IN
0x78329f10...F3BD32952
0.04592673 ETH0.000094443.43090284
Transfer217467732025-01-31 20:03:596 days ago1738353839IN
0x78329f10...F3BD32952
0.0345486 ETH0.000097093.52728725
Transfer217462382025-01-31 18:16:356 days ago1738347395IN
0x78329f10...F3BD32952
0.21545013 ETH0.000209927.62628387
View all transactions

Latest 25 internal transactions (View All)

Advanced mode:
Parent Transaction Hash Block
From
To
214647522024-12-23 11:01:1145 days ago1734951671
0x78329f10...F3BD32952
56,839 ETH
214623742024-12-23 3:01:4746 days ago1734922907
0x78329f10...F3BD32952
188.57338083 ETH
214623662024-12-23 3:00:1146 days ago1734922811
0x78329f10...F3BD32952
97.38874869 ETH
214623582024-12-23 2:58:3546 days ago1734922715
0x78329f10...F3BD32952
26,941.41408207 ETH
213534532024-12-07 22:00:2361 days ago1733608823
0x78329f10...F3BD32952
0.00008991 ETH
213534532024-12-07 22:00:2361 days ago1733608823
0x78329f10...F3BD32952
0.00504545 ETH
212820262024-11-27 22:20:2371 days ago1732746023
0x78329f10...F3BD32952
0.00052959 ETH
212820262024-11-27 22:20:2371 days ago1732746023
0x78329f10...F3BD32952
0.01033491 ETH
212107142024-11-17 23:27:5981 days ago1731886079
0x78329f10...F3BD32952
1.59552079 ETH
208636162024-09-30 12:57:59129 days ago1727701079
0x78329f10...F3BD32952
951.99 ETH
208633802024-09-30 12:10:23129 days ago1727698223
0x78329f10...F3BD32952
0.01 ETH
208265432024-09-25 8:51:11135 days ago1727254271
0x78329f10...F3BD32952
0.001 ETH
208265432024-09-25 8:51:11135 days ago1727254271
0x78329f10...F3BD32952
0.0035 ETH
207894842024-09-20 4:42:11140 days ago1726807331
0x78329f10...F3BD32952
393.0417801 ETH
205048842024-08-11 10:50:23179 days ago1723373423
0x78329f10...F3BD32952
0.0000284 ETH
205048842024-08-11 10:50:23179 days ago1723373423
0x78329f10...F3BD32952
0.00094182 ETH
204595422024-08-05 3:01:23186 days ago1722826883
0x78329f10...F3BD32952
0.05226357 ETH
203889012024-07-26 6:22:23196 days ago1721974943
0x78329f10...F3BD32952
0.00002905 ETH
203889012024-07-26 6:22:23196 days ago1721974943
0x78329f10...F3BD32952
0.00005228 ETH
203889012024-07-26 6:22:23196 days ago1721974943
0x78329f10...F3BD32952
0.00019805 ETH
203889012024-07-26 6:22:23196 days ago1721974943
0x78329f10...F3BD32952
0.00021538 ETH
203889012024-07-26 6:22:23196 days ago1721974943
0x78329f10...F3BD32952
0.00042997 ETH
203889012024-07-26 6:22:23196 days ago1721974943
0x78329f10...F3BD32952
0.00071744 ETH
203889012024-07-26 6:22:23196 days ago1721974943
0x78329f10...F3BD32952
0.00360191 ETH
203889012024-07-26 6:22:23196 days ago1721974943
0x78329f10...F3BD32952
0.00844285 ETH
View All Internal Transactions
Loading...
Loading

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

Contract Name:
MultiSigWalletProxy

Compiler Version
v0.8.17+commit.8df45f5f

Optimization Enabled:
No with 200 runs

Other Settings:
default evmVersion, MIT license

Contract Source Code (Solidity Multiple files format)

File 1 of 4: MultiSigWalletProxy.sol
// SPDX-License-Identifier: Unlicense
pragma solidity ^0.8.0;

contract MultiSigWalletProxy {
    address public implementation;

    constructor(address _implementation, bytes memory _data) {
        implementation = _implementation;
        if(_data.length > 0) {
            (bool success,) = _implementation.delegatecall(_data);
            require(success, "MultiSigWalletProxy: Initialization failed");
        }
    }

    fallback() external payable {
        _delegate(implementation);
    }

    receive() external payable {
        _delegate(implementation);
    }

    function _delegate(address _implementation) internal {
        assembly {
            calldatacopy(0, 0, calldatasize())
            let result := delegatecall(gas(), _implementation, 0, calldatasize(), 0, 0)
            returndatacopy(0, 0, returndatasize())
            switch result
            case 0 { 
                revert(0, returndatasize()) 
            } default { 
                return(0, returndatasize())
            }
        }
    }
}

File 2 of 4: MultiSigWalletFactory.sol
// SPDX-License-Identifier: Unlicense
pragma solidity ^0.8.0;

import "./MultiSigWalletProxy.sol";
import "./MultiSigWalletImplementation.sol";

contract MultiSigWalletFactory {

    event NewMultiSigWalletCreated(address wallet);

    function createMultiSigWallet(
        address _implementation,
        address[] memory owners,
        uint required,
        uint256 nonce
    ) public payable returns (address payable) {
        bytes32 salt = keccak256(abi.encodePacked(nonce, owners, required));
        bytes memory initCode = abi.encodePacked(
            type(MultiSigWalletProxy).creationCode,
            abi.encode(address(_implementation), abi.encodeWithSignature("initialize(address[],uint256)", owners, required))
        );

        address payable wallet;
        assembly {
            wallet := create2(0, add(initCode, 0x20), mload(initCode), salt)
            if iszero(extcodesize(wallet)) {
                revert(0, 0)
            }
        }

        emit NewMultiSigWalletCreated(wallet);

        return wallet;
    }
    
    function calculateMultiSigWalletAddress(
        address _implementation,
        address[] memory owners,
        uint required,
        uint256 nonce
    ) public view returns (address wallet) {
        bytes32 salt = keccak256(abi.encodePacked(nonce, owners, required));
        bytes memory initCode = abi.encodePacked(
            type(MultiSigWalletProxy).creationCode,
            abi.encode(address(_implementation), abi.encodeWithSignature("initialize(address[],uint256)", owners, required))
        );
        bytes32 hash = keccak256(abi.encodePacked(
            bytes1(0xff),
            address(this),
            salt,
            keccak256(initCode)
        ));

        return address(uint160(uint(hash)));
    }

    function createMultiSigWalletWithTransaction(
        address _implementation,
        address[] memory owners,
        uint required,
        uint256 nonce,
        MultiSigWalletImplementation.Transaction memory transaction,
        MultiSigWalletImplementation.Signature[] memory signatures
    ) public payable returns (address payable, bool) {
        address payable wallet = createMultiSigWallet(_implementation, owners, required, nonce);
        bool isOk = MultiSigWalletImplementation(wallet).batchSignature(transaction, signatures);
        return (wallet, isOk);
    }
}

File 3 of 4: MultiSigWalletImplementation.sol
// SPDX-License-Identifier: Unlicense
pragma solidity ^0.8.0;

/// @title Multisignature wallet - Allows multiple parties to agree on transactions before execution.
/// @author Stefan George - <[email protected]>
contract MultiSigWalletImplementation {
    /*
     *  Events
     */
    event Confirmation(address indexed sender, uint indexed transactionId);
    event Revocation(address indexed sender, uint indexed transactionId);
    event Submission(uint indexed transactionId);
    event Execution(uint indexed transactionId);
    event ExecutionFailure(uint indexed transactionId);
    event Deposit(address indexed sender, uint value);
    event OwnerAddition(address indexed owner);
    event OwnerRemoval(address indexed owner);
    event RequirementChange(uint required);

    /*
     *  Constants
     */
    uint public constant MAX_OWNER_COUNT = 50;

    /*
     *  Storage
     */
    mapping(uint => Transaction) public transactions;
    mapping(uint => mapping(address => bool)) public confirmations;
    mapping(address => bool) public isOwner;
    mapping(bytes32 => bool) public txNonces;

    address[] public owners;
    uint public required;
    uint public transactionCount;

    bytes32 public DOMAIN_SEPARATOR;
    bytes32 constant EIP712DOMAIN_TYPEHASH = keccak256("EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)");
    bytes32 internal constant TRANSACTION_TYPEHASH = keccak256("Transaction(uint nonce,address destination,uint value,bytes data)");

    bool initialized;

    struct Transaction {
        uint nonce;
        address destination;
        uint value;
        bytes data;
        bool executed;
    }

    struct Signature {
        address signer;
        uint8 v;
        bytes32 r;
        bytes32 s;
    }

    /*
     *  Modifiers
     */
    modifier onlyWallet() {
        require(msg.sender == address(this));
        _;
    }

    modifier ownerDoesNotExist(address owner) {
        require(!isOwner[owner]);
        _;
    }

    modifier ownerExists(address owner) {
        require(isOwner[owner]);
        _;
    }

    modifier transactionExists(uint transactionId) {
        require(transactions[transactionId].destination != address(0));
        _;
    }

    modifier confirmed(uint transactionId, address owner) {
        require(confirmations[transactionId][owner]);
        _;
    }

    modifier notConfirmed(uint transactionId, address owner) {
        require(!confirmations[transactionId][owner]);
        _;
    }

    modifier notExecuted(uint transactionId) {
        require(!transactions[transactionId].executed);
        _;
    }

    modifier notNull(address _address) {
        require(_address != address(0));
        _;
    }

    modifier validRequirement(uint ownerCount, uint _required) {
        require(
            ownerCount <= MAX_OWNER_COUNT &&
                _required <= ownerCount &&
                _required != 0 &&
                ownerCount != 0
        );
        _;
    }

    /// @dev Receive function allows to deposit ether.
    receive() external payable {
        if (msg.value > 0) emit Deposit(msg.sender, msg.value);
    }

    /// @dev Fallback function allows to deposit ether.
    fallback() external payable {
        if (msg.value > 0) emit Deposit(msg.sender, msg.value);
    }

    /*
     * Public functions
     */
    /// @dev Contract constructor sets initial owners and required number of confirmations.
    constructor() {}

    function initialize(
        address[] memory _owners,
        uint _required
    ) validRequirement(_owners.length, _required) public {
        require(!initialized, "already initialized");

        DOMAIN_SEPARATOR = keccak256(
            abi.encode(
                EIP712DOMAIN_TYPEHASH,
                keccak256("MultiSigWallet"), // name
                keccak256("2"), // version
                block.chainid,
                address(this)
            )
        );

        for (uint i = 0; i < _owners.length; i++) {
            require(!isOwner[_owners[i]] && _owners[i] != address(0));
            isOwner[_owners[i]] = true;
        }
        owners = _owners;
        required = _required;

        initialized = true;
    }
    

    /// @dev Allows to add a new owner. Transaction has to be sent by wallet.
    /// @param owner Address of new owner.
    function addOwner(
        address owner
    )
        public
        onlyWallet
        ownerDoesNotExist(owner)
        notNull(owner)
        validRequirement(owners.length + 1, required)
    {
        isOwner[owner] = true;
        owners.push(owner);
        emit OwnerAddition(owner);
    }

    /// @dev Allows to remove an owner. Transaction has to be sent by wallet.
    /// @param owner Address of owner.
    function removeOwner(address owner) public onlyWallet ownerExists(owner) {
        isOwner[owner] = false;
        for (uint i = 0; i < owners.length - 1; i++)
            if (owners[i] == owner) {
                owners[i] = owners[owners.length - 1];
                delete owners[i];
                break;
            }
        if (required > owners.length) changeRequirement(owners.length);
        emit OwnerRemoval(owner);
    }

    /// @dev Allows to replace an owner with a new owner. Transaction has to be sent by wallet.
    /// @param owner Address of owner to be replaced.
    /// @param newOwner Address of new owner.
    function replaceOwner(
        address owner,
        address newOwner
    ) public onlyWallet ownerExists(owner) ownerDoesNotExist(newOwner) {
        for (uint i = 0; i < owners.length; i++)
            if (owners[i] == owner) {
                owners[i] = newOwner;
                break;
            }
        isOwner[owner] = false;
        isOwner[newOwner] = true;
        emit OwnerRemoval(owner);
        emit OwnerAddition(newOwner);
    }

    /// @dev Allows to change the number of required confirmations. Transaction has to be sent by wallet.
    /// @param _required Number of required confirmations.
    function changeRequirement(
        uint _required
    ) public onlyWallet validRequirement(owners.length, _required) {
        required = _required;
        emit RequirementChange(_required);
    }

    /// @dev Allows an owner to submit and confirm a transaction.
    /// @param destination Transaction target address.
    /// @param value Transaction ether value.
    /// @param data Transaction data payload.
    /// @return transactionId Returns transaction ID.
    function submitTransaction(
        address destination,
        uint value,
        bytes memory data
    ) public returns (uint transactionId) {
        transactionId = addTransaction(destination, value, data);
        confirmTransaction(transactionId);
    }

    /// @dev Allows an owner to confirm a transaction.
    /// @param transactionId Transaction ID.
    function confirmTransaction(
        uint transactionId
    )
        public
        ownerExists(msg.sender)
        transactionExists(transactionId)
        notConfirmed(transactionId, msg.sender)
    {
        confirmations[transactionId][msg.sender] = true;
        emit Confirmation(msg.sender, transactionId);
        executeTransaction(transactionId);
    }

    /// @dev Allows an owner to revoke a confirmation for a transaction.
    /// @param transactionId Transaction ID.
    function revokeConfirmation(
        uint transactionId
    )
        public
        ownerExists(msg.sender)
        confirmed(transactionId, msg.sender)
        notExecuted(transactionId)
    {
        confirmations[transactionId][msg.sender] = false;
        emit Revocation(msg.sender, transactionId);
    }

    /// @dev Allows anyone to execute a confirmed transaction.
    /// @param transactionId Transaction ID.
    function executeTransaction(
        uint transactionId
    )
        public
        ownerExists(msg.sender)
        confirmed(transactionId, msg.sender)
        notExecuted(transactionId)
    {
        _executeTransaction(transactionId);
    }

    function _executeTransaction(
        uint transactionId
    ) internal notExecuted(transactionId) {
        if (isConfirmed(transactionId)) {
            Transaction storage txn = transactions[transactionId];
            txn.executed = true;
            if (
                external_call(
                    txn.destination,
                    txn.value,
                    txn.data.length,
                    txn.data
                )
            ) emit Execution(transactionId);
            else {
                emit ExecutionFailure(transactionId);
                txn.executed = false;
            }
        }
    }

    // call has been separated into its own function in order to take advantage
    // of the Solidity's code generator to produce a loop that copies tx.data into memory.
    function external_call(
        address destination,
        uint value,
        uint dataLength,
        bytes memory data
    ) internal returns (bool) {
        bool result;
        assembly {
            let x := mload(0x40) // "Allocate" memory for output (0x40 is where "free memory" pointer is stored by convention)
            let d := add(data, 32) // First 32 bytes are the padded length of data, so exclude that
            result := call(
                sub(gas(), 34710), // 34710 is the value that solidity is currently emitting
                // It includes callGas (700) + callVeryLow (3, to pay for SUB) + callValueTransferGas (9000) +
                // callNewAccountGas (25000, in case the destination address does not exist and needs creating)
                destination,
                value,
                d,
                dataLength, // Size of the input (in bytes) - this is what fixes the padding problem
                x,
                0 // Output is ignored, therefore the output size is zero
            )
        }
        return result;
    }

    /// @dev Returns the confirmation status of a transaction.
    /// @param transactionId Transaction ID.
    /// @return status Confirmation status.
    function isConfirmed(uint transactionId) public view returns (bool status) {
        uint count = 0;
        for (uint i = 0; i < owners.length; i++) {
            if (confirmations[transactionId][owners[i]]) count += 1;
            if (count == required) return true;
        }
    }

    /*
     * Internal functions
     */
    /// @dev Adds a new transaction to the transaction mapping, if transaction does not exist yet.
    /// @param destination Transaction target address.
    /// @param value Transaction ether value.
    /// @param data Transaction data payload.
    /// @return transactionId Returns transaction ID.
    function addTransaction(
        address destination,
        uint value,
        bytes memory data
    ) internal notNull(destination) returns (uint transactionId) {
        if(transactions[transactionId].destination == address(0)) {
            transactionId = transactionCount;
            transactions[transactionId] = Transaction({
                nonce: transactionId,
                destination: destination,
                value: value,
                data: data,
                executed: false
            });
            transactionCount += 1;
            
            emit Submission(transactionId);
        } else {
            revert("transactionId already exist");
        }
    }

    /*
     * Web3 call functions
     */
    /// @dev Returns number of confirmations of a transaction.
    /// @param transactionId Transaction ID.
    /// @return count Number of confirmations.
    function getConfirmationCount(
        uint transactionId
    ) public view returns (uint count) {
        for (uint i = 0; i < owners.length; i++)
            if (confirmations[transactionId][owners[i]]) count += 1;
    }

    /// @dev Returns total number of transactions after filers are applied.
    /// @param pending Include pending transactions.
    /// @param executed Include executed transactions.
    /// @return count Total number of transactions after filters are applied.
    function getTransactionCount(
        bool pending,
        bool executed
    ) public view returns (uint count) {
        for (uint i = 0; i < transactionCount; i++)
            if (
                (pending && !transactions[i].executed) ||
                (executed && transactions[i].executed)
            ) count += 1;
    }

    /// @dev Returns list of owners.
    /// @return List of owner addresses.
    function getOwners() public view returns (address[] memory) {
        return owners;
    }

    /// @dev Returns array with owner addresses, which confirmed transaction.
    /// @param transactionId Transaction ID.
    /// @return _confirmations Returns array of owner addresses.
    function getConfirmations(
        uint transactionId
    ) public view returns (address[] memory _confirmations) {
        address[] memory confirmationsTemp = new address[](owners.length);
        uint count = 0;
        uint i;
        for (i = 0; i < owners.length; i++)
            if (confirmations[transactionId][owners[i]]) {
                confirmationsTemp[count] = owners[i];
                count += 1;
            }
        _confirmations = new address[](count);
        for (i = 0; i < count; i++) _confirmations[i] = confirmationsTemp[i];
    }

    /// @dev Returns list of transaction IDs in defined range.
    /// @param from Index start position of transaction array.
    /// @param to Index end position of transaction array.
    /// @param pending Include pending transactions.
    /// @param executed Include executed transactions.
    /// @return _transactionIds Returns array of transaction IDs.
    function getTransactionIds(
        uint from,
        uint to,
        bool pending,
        bool executed
    ) public view returns (uint[] memory _transactionIds) {
        uint[] memory transactionIdsTemp = new uint[](transactionCount);
        uint count = 0;
        uint i;
        for (i = 0; i < transactionCount; i++)
            if (
                (pending && !transactions[i].executed) ||
                (executed && transactions[i].executed)
            ) {
                transactionIdsTemp[count] = i;
                count += 1;
            }
        _transactionIds = new uint[](to - from);
        for (i = from; i < to; i++)
            _transactionIds[i - from] = transactionIdsTemp[i];
    }

    function hashTransaction(
        Transaction memory transaction
    ) public pure returns (bytes32) {
        return
            keccak256(
                abi.encode(
                    TRANSACTION_TYPEHASH,
                    transaction.nonce,
                    transaction.destination,
                    transaction.value,
                    keccak256(bytes(transaction.data))
                )
            );
    }

    function getTransactionMessage(
        Transaction memory transaction
    ) public view returns (bytes32) {
        bytes32 digest = keccak256(
            abi.encodePacked(
                "\x19\x01",
                DOMAIN_SEPARATOR,
                hashTransaction(transaction)
            )
        );
        return digest;
    }

    function batchSignature(Transaction memory txn, Signature[] memory sortedSignatures) public returns (bool isOK) {
        require(sortedSignatures.length >= required, "invalid signature data length");

        bytes32 digest = keccak256(
            abi.encodePacked(
                "\x19\x01",
                DOMAIN_SEPARATOR,
                hashTransaction(txn)
            )
        );
        require(!txNonces[digest], "tx-executed");

        uint256 txId = txn.nonce;
        address lastOwner = address(0);
        for(uint i = 0; i < sortedSignatures.length; i++) {
            Signature memory signature = sortedSignatures[i];
            address signer = signature.signer;
            uint8 v = signature.v;
            bytes32 r = signature.r;
            bytes32 s = signature.s;

            address currentOwner = ecrecover(digest, v, r, s);

            // to save gas, must need signature.signer sorted
            require(currentOwner > lastOwner && isOwner[currentOwner] && signer == currentOwner, "error-sig");
            lastOwner = currentOwner;
            emit Confirmation(signer, txId);
        }

        txn.executed = true;
        txNonces[digest] = true;
        if (external_call(txn.destination, txn.value, txn.data.length, txn.data)) {
            emit Execution(txId);
        } else {
            emit ExecutionFailure(txId);
            txn.executed = false;
        }

        return txn.executed;
    }

    struct Call {
        address target;
        uint value;
        bytes data;
    }

    function multiCall(
        Call[] memory calls
    ) public onlyWallet {
        for (uint i = 0; i < calls.length; i++) {
            if (external_call(
                calls[i].target,
                calls[i].value,
                calls[i].data.length,
                calls[i].data
            )) {}
            else {
                revert("internal call failed");
            }
        }
    }
}

File 4 of 4: MultiSigWalletImplementationBeacon.sol
// SPDX-License-Identifier: Unlicense
pragma solidity ^0.8.0;

import "./MultiSigWalletImplementation.sol";


contract MultiSigWalletImplementationBeacon {

    event MultiSigWalletImplementationDeployed(address indexed implementation);

    constructor() {
        MultiSigWalletImplementation implementation = new MultiSigWalletImplementation();

        address[] memory owners = new address[](1);
        owners[0] = msg.sender;

        implementation.initialize(owners, 1);
        
        emit MultiSigWalletImplementationDeployed(address(implementation));
    }
}

Contract Security Audit

Contract ABI

[{"inputs":[{"internalType":"address","name":"_implementation","type":"address"},{"internalType":"bytes","name":"_data","type":"bytes"}],"stateMutability":"nonpayable","type":"constructor"},{"stateMutability":"payable","type":"fallback"},{"inputs":[],"name":"implementation","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"stateMutability":"payable","type":"receive"}]

Deployed Bytecode

0x6080604052600436106100225760003560e01c80635c60da1b1461007d57610052565b366100525761005060008054906101000a900473ffffffffffffffffffffffffffffffffffffffff166100a8565b005b61007b60008054906101000a900473ffffffffffffffffffffffffffffffffffffffff166100a8565b005b34801561008957600080fd5b506100926100ce565b60405161009f9190610133565b60405180910390f35b3660008037600080366000845af43d6000803e80600081146100c9573d6000f35b3d6000fd5b60008054906101000a900473ffffffffffffffffffffffffffffffffffffffff1681565b600073ffffffffffffffffffffffffffffffffffffffff82169050919050565b600061011d826100f2565b9050919050565b61012d81610112565b82525050565b60006020820190506101486000830184610124565b9291505056fea26469706673582212209ddd38ba0d1790de3f61b13242414d0a219eeb1743a9f9d028636e2b2243263564736f6c63430008110033

Deployed Bytecode Sourcemap

63:971:3:-:0;;;;;;;;;;;;;;;;;;;;;;;543:25;553:14;;;;;;;;;;543:9;:25::i;:::-;63:971;;468:25;478:14;;;;;;;;;;468:9;:25::i;:::-;63:971;98:29;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;581:451;686:14;683:1;680;667:34;787:1;784;768:14;765:1;748:15;741:5;728:61;823:16;820:1;817;802:38;860:6;884:1;879:68;;;;985:16;982:1;975:27;879:68;915:16;912:1;905:27;98:29;;;;;;;;;;;;:::o;7:126:4:-;44:7;84:42;77:5;73:54;62:65;;7:126;;;:::o;139:96::-;176:7;205:24;223:5;205:24;:::i;:::-;194:35;;139:96;;;:::o;241:118::-;328:24;346:5;328:24;:::i;:::-;323:3;316:37;241:118;;:::o;365:222::-;458:4;496:2;485:9;481:18;473:26;;509:71;577:1;566:9;562:17;553:6;509:71;:::i;:::-;365:222;;;;:::o

Swarm Source

ipfs://9ddd38ba0d1790de3f61b13242414d0a219eeb1743a9f9d028636e2b22432635

 Latest 25 blocks (From a total of 29 blocks with 1.21 Ether produced)

Block Transaction Difficulty Gas Used Reward
213534532024-12-07 22:00:2361 days ago17336088231230.00 TH8,373,574 (27.91%)
0.014394945539614356 ETH
213004382024-11-30 12:17:2368 days ago17329690431120.00 TH10,986,474 (36.62%)
0.056725927245934954 ETH
212820262024-11-27 22:20:2371 days ago17327460231600.00 TH11,411,562 (38.04%)
0.017544474248341736 ETH
212194912024-11-19 4:49:1180 days ago17319917511240.00 TH11,632,514 (38.78%)
0.028241308238846734 ETH
208265432024-09-25 8:51:11135 days ago17272542711560.00 TH15,963,297 (53.21%)
0.068906687958077041 ETH
207094482024-09-09 0:24:11151 days ago17258414511810.00 TH13,045,320 (43.48%)
0.012622372083962275 ETH
206701192024-09-03 12:41:59156 days ago17253673191210.00 TH17,830,833 (59.44%)
0.050665641765776964 ETH
206524542024-09-01 1:32:47159 days ago17251543671050.00 TH7,273,132 (24.24%)
0.01515042561940963 ETH
206315542024-08-29 3:26:47162 days ago17249020071740.00 TH12,381,110 (41.27%)
0.037387361925754975 ETH
206203362024-08-27 13:51:35163 days ago17247666951600.00 TH15,493,345 (51.64%)
0.037399018965282148 ETH
206120112024-08-26 9:56:59164 days ago17246662192130.00 TH14,550,094 (48.50%)
0.021318013044396516 ETH
206077842024-08-25 19:46:59165 days ago17246152191000.00 TH29,957,903 (99.86%)
0.024262124900204402 ETH
205863332024-08-22 19:47:59168 days ago17243560791850.00 TH21,617,806 (72.06%)
0.033083004711088208 ETH
205436912024-08-16 20:50:59174 days ago17238414591780.00 TH22,651,829 (75.51%)
0.02222059517597721 ETH
205048842024-08-11 10:50:23179 days ago17233734231900.00 TH21,464,686 (71.55%)
0.037041081792893134 ETH
205040562024-08-11 8:03:35180 days ago17233634152180.00 TH19,844,499 (66.15%)
0.023122604769148094 ETH
204690412024-08-06 10:50:23184 days ago17229414231210.00 TH11,757,548 (39.19%)
0.023885585397144783 ETH
204595422024-08-05 3:01:23186 days ago1722826883970.00 TH9,837,821 (32.79%)
0.14935439134661522 ETH
204577972024-08-04 21:11:35186 days ago17228058951350.00 TH14,325,823 (47.75%)
0.048913147851237904 ETH
204466082024-08-03 7:45:59188 days ago17226711591420.00 TH14,801,949 (49.34%)
0.028847011028430768 ETH
204287832024-07-31 20:00:47190 days ago17224560473970.00 TH28,095,702 (93.65%)
0.053762772921568747 ETH
204168122024-07-30 3:50:59192 days ago17223114591050.00 TH29,993,979 (99.98%)
0.039645862085014403 ETH
204125032024-07-29 13:25:23192 days ago17222595231740.00 TH29,957,999 (99.86%)
0.043389293671586503 ETH
203889012024-07-26 6:22:23196 days ago17219749431510.00 TH17,080,679 (56.94%)
0.02330431246840053 ETH
202402952024-07-05 12:26:23216 days ago17201823831680.00 TH16,180,550 (53.94%)
0.071295659819830385 ETH
View All Blocks Produced

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

Latest 25 from a total of 34778 withdrawals (31,000.21808095 ETH withdrawn)

Validator Index Block Amount
1471620217631802025-02-03 3:04:474 days ago17385518870.019091138 ETH
1471619217631802025-02-03 3:04:474 days ago17385518870.019126903 ETH
1471618217631802025-02-03 3:04:474 days ago17385518870.01913032 ETH
1471617217631802025-02-03 3:04:474 days ago17385518870.019114304 ETH
1471616217631802025-02-03 3:04:474 days ago17385518870.019173579 ETH
1471615217631802025-02-03 3:04:474 days ago17385518870.019115008 ETH
1471614217631802025-02-03 3:04:474 days ago17385518870.019136885 ETH
1471613217631802025-02-03 3:04:474 days ago17385518870.019132301 ETH
1471612217631802025-02-03 3:04:474 days ago17385518870.019093966 ETH
1471611217631802025-02-03 3:04:474 days ago17385518870.019169794 ETH
1471610217631792025-02-03 3:04:354 days ago17385518750.019132551 ETH
1471609217631792025-02-03 3:04:354 days ago17385518750.019157871 ETH
1471608217631792025-02-03 3:04:354 days ago17385518750.019141547 ETH
1471607217631792025-02-03 3:04:354 days ago17385518750.019149756 ETH
1471606217631792025-02-03 3:04:354 days ago17385518750.064783176 ETH
1471605217631792025-02-03 3:04:354 days ago17385518750.019120679 ETH
1471604217631792025-02-03 3:04:354 days ago17385518750.019164027 ETH
1471603217631792025-02-03 3:04:354 days ago17385518750.019151596 ETH
1471602217631792025-02-03 3:04:354 days ago17385518750.01915259 ETH
1471601217631792025-02-03 3:04:354 days ago17385518750.019152509 ETH
1471600217631792025-02-03 3:04:354 days ago17385518750.019107256 ETH
1471599217631792025-02-03 3:04:354 days ago17385518750.019127443 ETH
1471598217631792025-02-03 3:04:354 days ago17385518750.019141518 ETH
1471597217631792025-02-03 3:04:354 days ago17385518750.019125405 ETH
1471596217631792025-02-03 3:04:354 days ago17385518750.019142681 ETH
View All Withdrawals

Transaction Hash Block Value Eth2 PubKey Valid
View All Deposits
Loading...
Loading
[ Download: CSV Export  ]
[ 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.