Contract Source Code (Solidity Standard Json-Input format)

IDE

• Blockscan IDE

More Options

• Similar
• Submit Audit
• Compare

// SPDX-License-Identifier: MIT
pragma solidity 0.8.24;

import {EnumerableSet} from "../lib/openzeppelin-contracts/contracts/utils/structs/EnumerableSet.sol";

/**
 * @title MultiSignatureWallet
 * @dev A multisignature wallet contract that requires multiple owners to confirm transactions.
 */
contract MultiSignatureWallet {
    using EnumerableSet for EnumerableSet.AddressSet;

    /**
     * @dev Emitted when a deposit is made to the contract.
     * @param sender The address that sent the funds.
     * @param amount The amount of funds deposited.
     * @param balance The new balance of the contract after the deposit.
     */
    event Deposit(address indexed sender, uint256 amount, uint256 balance);

    /**
     * @dev Emitted when a new transaction is submitted.
     * @param owner The address of the owner who submitted the transaction.
     * @param txIndex The index of the transaction in the transactions array.
     * @param to The contract address the transaction is directed to.
     * @param value The amount of ether to be sent with the transaction.
     * @param data The data payload of the transaction.
     */
    event SubmitTransaction(
        address indexed owner,
        uint256 indexed txIndex,
        address indexed to,
        uint256 value,
        bytes data
    );

    /**
     * @dev Emitted when a transaction is confirmed by an owner.
     * @param owner The address of the owner who confirmed the transaction.
     * @param txIndex The index of the transaction in the transactions array.
     */
    event ConfirmTransaction(address indexed owner, uint256 indexed txIndex);

    /**
     * @dev Emitted when a confirmation is revoked by an owner.
     * @param owner The address of the owner who revoked the confirmation.
     * @param txIndex The index of the transaction in the transactions array.
     */
    event RevokeConfirmation(address indexed owner, uint256 indexed txIndex);

    /**
     * @dev Emitted when a transaction is executed.
     * @param owner The address of the owner who executed the transaction.
     * @param txIndex The index of the transaction in the transactions array.
     * @param txData The data returned by the transaction call.
     */
    event ExecuteTransaction(address indexed owner, uint256 indexed txIndex, bytes txData);

    /**
     * @dev Emitted when new owners are added to the contract.
     * @param owners An array of addresses representing the newly added owners.
     */
    event OwnersAdded(address[] owners);

    /**
     * @dev Emitted when owners are removed from the contract.
     * @param owners An array of addresses representing the removed owners.
     */
    event OwnersRemoved(address[] owners);

    /**
     * @dev Emitted when the number of confirmations required is updated.
     * @param newNumConfirmation The new number of confirmations required for a transaction.
     */
    event NumConfirmationUpdated(uint256 newNumConfirmation);


    // Custom error definitions

    /**
     * @dev Error for when the function caller is not an owner.
     */
    error NotAnOwner();

    /**
     * @dev Error for when a transaction ID is invalid (e.g., out of bounds).
     */
    error InvalidTxnId();

    /**
     * @dev Error for when a transaction has already been executed.
     */
    error TxnAlreadyExecuted();

    /**
     * @dev Error for when a transaction has already been confirmed by the caller.
     */
    error TxnAlreadyConfirmed();

    /**
     * @dev Error for when the owners array is empty upon contract creation.
     */
    error OwnersRequired();

    /**
     * @dev Error for when the number of required confirmations is invalid (0 or more than the number of owners).
     */
    error InvalidNumberOfConfirmations();

    /**
     * @dev Error for when an invalid owner address is provided (e.g., zero address).
     */
    error InvalidOwner();

    /**
     * @dev Error for when a duplicate owner address is provided.
     */
    error OwnerNotUnique();

    /**
     * @dev Error for when a transaction does not have enough confirmations to be executed.
     */
    error NotEnoughConfirmation();

    /**
     * @dev Error for when a transaction has not been confirmed by the caller.
     */
    error TransactionNotConfirmed();

    /**
     * @dev Error for when a transaction has already expired.
     */
    error TransactionAlreadyExpired();

    /**
     * @dev Error for when a function is called by an account other than the multisig wallet itself.
     */
    error OnlyMultisigAccountCanCall();

    EnumerableSet.AddressSet private owners;
    uint256 public numConfirmationsRequired;

    // Structure to hold transaction details
    struct Transaction {
        address to; // Transaction target address
        bool executed; // Flag indicating if the transaction has been executed
        uint64 timeout; // Expiry timestamp of the transaction
        uint24 numConfirmations; // Number of confirmations received for the transaction
        uint256 value; // Amount of ether sent with the transaction
        bytes data; // Data payload of the transaction
    }

    // Mapping to track confirmations for each transaction by each owner
    mapping(uint256 transactionIndex => mapping(address owner => bool permissionToExecute)) public isConfirmed;

    // Array to store all transactions
    Transaction[] private transactions;

    // Function to ensure the caller is an owner
    function onlyOwner(address owner) private {
        if (!owners.contains(owner)) 
        revert NotAnOwner();
    }

    // Function to ensure the caller is the multisig contract itself
    function onlyMultiSig() private {
        if (msg.sender != address(this)) {
            revert OnlyMultisigAccountCanCall();
        }
    }

    // Function to check if a transaction exists
    function txExists(uint256 _txIndex) private {
        if (_txIndex >= transactions.length) 
        revert InvalidTxnId();
    }

    // Function to check if a transaction has not been executed
    function notExecuted(uint256 _txIndex) private {
        if (transactions[_txIndex].executed) 
        revert TxnAlreadyExecuted();
    }

    // Function to check if a transaction has not been expired or not
    function txNotExpired(uint256 _txIndex) private {
        if (transactions[_txIndex].timeout < block.timestamp)
            revert TransactionAlreadyExpired();
    }

    // Function to check if a transaction has not been confirmed by the caller
    function notConfirmed(uint256 _txIndex) private {
        if (isConfirmed[_txIndex][msg.sender])  revert TxnAlreadyConfirmed();
    }

    /**
     * @dev Constructor to initialize the contract with initial owners and required confirmations.
     * @param _owners Array of initial owner addresses.
     * @param _numConfirmationsRequired Number of confirmations required for transactions.
     */
    constructor(address[] memory _owners, uint256 _numConfirmationsRequired) {
        if (_owners.length == 0) revert OwnersRequired();
        if (
            _numConfirmationsRequired == 0 ||
            _numConfirmationsRequired > _owners.length
        ) revert InvalidNumberOfConfirmations();

        for (uint256 i = 0; i < _owners.length; i++) {
            address owner = _owners[i];
            if (owner == address(0)) revert InvalidOwner();
            if (owners.contains(owner)) revert OwnerNotUnique();
            owners.add(owner);
        }

        numConfirmationsRequired = _numConfirmationsRequired;
    }

    /**
     * @dev Fallback function to receive ether and emit a deposit event.
     */
    receive() external payable {
        emit Deposit(msg.sender, msg.value, address(this).balance);
    }

    /**
     * @dev Function to submit a new transaction to the wallet.
     * @param _to Address of the contract the transaction is directed to.
     * @param _value Amount of ether to be sent with the transaction.
     * @param _timeoutDuration Duration after which the transaction will get expire.
     * @param _data Data payload of the transaction.
     */
    function submitTransaction(
        address _to,
        uint256 _value,
        uint64 _timeoutDuration,
        bytes memory _data
    ) external payable {
        onlyOwner(msg.sender);
        uint256 txIndex = transactions.length;

        transactions.push(
            Transaction({
                to: _to,
                executed: false,
                timeout: uint64(block.timestamp) + _timeoutDuration,
               //We assume the act of submission is an implicit confirmation
                numConfirmations: 1,
                value: _value,
                data: _data
            })
        );

        isConfirmed[txIndex][msg.sender] = true;

        emit SubmitTransaction(msg.sender, txIndex, _to, _value, _data);
    }

    /**
     * @dev Function to confirm an existing transaction.
     * @param _txIndex Index of the transaction to confirm.
     */
    function confirmTransaction(uint256 _txIndex) public {
        onlyOwner(msg.sender);
        txExists(_txIndex);
        notExecuted(_txIndex);
        notConfirmed(_txIndex);
        txNotExpired(_txIndex);
        Transaction storage transaction = transactions[_txIndex];
        transaction.numConfirmations += 1;
        isConfirmed[_txIndex][msg.sender] = true;

        emit ConfirmTransaction(msg.sender, _txIndex);
    }

    /**
     * @dev Function to execute a confirmed transaction.
     * @param _txIndex Index of the transaction to execute.
     */
    function executeTransaction(uint256 _txIndex) public {
        onlyOwner(msg.sender);
        txExists(_txIndex);
        notExecuted(_txIndex);
        txNotExpired(_txIndex);
        Transaction storage transaction = transactions[_txIndex];
        if (transaction.numConfirmations < numConfirmationsRequired)
            revert NotEnoughConfirmation();
        transaction.executed = true;
        (bool success, bytes memory data) = transaction.to.call{
            value: transaction.value
        }(transaction.data);
        require(success, "tx failed");

        emit ExecuteTransaction(msg.sender, _txIndex, data);
    }

    /**
     * @dev Function to revoke a previously given confirmation for a transaction.
     * @param _txIndex Index of the transaction to revoke confirmation.
     */
    function revokeConfirmation(uint256 _txIndex) external {
        onlyOwner(msg.sender);
        txExists(_txIndex);
        notExecuted(_txIndex);
        txNotExpired(_txIndex);
        if (!isConfirmed[_txIndex][msg.sender]) {
            revert TransactionNotConfirmed();
        }

        Transaction storage transaction = transactions[_txIndex];

        transaction.numConfirmations -= 1;
        isConfirmed[_txIndex][msg.sender] = false;

        emit RevokeConfirmation(msg.sender, _txIndex);
    }

    /**
     * @dev Function to add new owners to the wallet.
     * @param _owners Array of new owner addresses to be added.
     */
    function addOwners(address[] memory _owners) public {
        onlyMultiSig();
        if (_owners.length == 0) revert OwnersRequired();

        address[] memory ownnersToUpdate = new address[](_owners.length);
        uint256 c = 0;

        for (uint256 i = 0; i < _owners.length; i++) {
            address owner = _owners[i];
            if (owner == address(0)) revert InvalidOwner();
            if (!owners.contains(owner)) {
                owners.add(owner);
                ownnersToUpdate[c++] = owner;
            }
        }
        if (c > 0)
        emit OwnersAdded(ownnersToUpdate);
    }

    /**
     * @dev Function to remove existing owners from the wallet.
     * @param _owners Array of existing owner addresses to be removed.
     */
    function removeOwners(address[] memory _owners) public {
        onlyMultiSig();
        if (_owners.length == 0) revert OwnersRequired();
        address[] memory ownnersToUpdate = new address[](_owners.length);
        uint256 c = 0;

        for (uint256 i = 0; i < _owners.length; i++) {
            address owner = _owners[i];
            if (owners.contains(owner)){
                owners.remove(owner);
                ownnersToUpdate[c++] = owner;
            }
        }

        if (owners.length() < numConfirmationsRequired) {
            revert InvalidNumberOfConfirmations();
        }

        if (c > 0)
        emit OwnersRemoved(ownnersToUpdate);
    }

    /**
     * @dev Function to update the number of required confirmations for transactions.
     * @param _numConfirmationsRequired New number of confirmations required for transactions.
     */
    function updateNumConfirmations(uint256 _numConfirmationsRequired) public {
        onlyMultiSig();
        if (
            _numConfirmationsRequired == 0 ||
            _numConfirmationsRequired > owners.length()
        ) revert InvalidNumberOfConfirmations();
        numConfirmationsRequired = _numConfirmationsRequired;
        emit NumConfirmationUpdated(_numConfirmationsRequired);
    }

    /**
     * @dev Function to retrieve the list of current owners of the wallet.
     * @return Array of addresses representing the current owners.
     */
    function getOwners() public view returns (address[] memory) {
        return owners.values();
    }

    /**
     * @dev Function to retrieve the count of transactions submitted to the wallet.
     * @return Total number of transactions in the wallet.
     */
    function getTransactionCount() public view returns (uint256) {
        return transactions.length;
    }

    /**
     * @dev Function to retrieve details of a specific transaction.
     * @param _txIndex Index of the transaction to retrieve details for.
     * @return to Transaction target address.
     * @return value Amount of ether sent with the transaction.
     * @return executed Boolean indicating if the transaction has been executed.
     * @return numConfirmations Number of confirmations received for the transaction.
     * @return timeout Expiry timestamp of the transaction.
     * @return data Data payload of the transaction.
     */
    function getTransaction(
        uint256 _txIndex
    )
        public
        view
        returns (
            address to,
            uint256 value,
            bool executed,
            uint256 numConfirmations,
            uint64 timeout,
            bytes memory data
        )
    {
        Transaction storage transaction = transactions[_txIndex];

        return (
            transaction.to,
            transaction.value,
            transaction.executed,
            transaction.numConfirmations,
            transaction.timeout,
            transaction.data
        );
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (utils/structs/EnumerableSet.sol)
// This file was procedurally generated from scripts/generate/templates/EnumerableSet.js.

pragma solidity ^0.8.0;

/**
 * @dev Library for managing
 * https://en.wikipedia.org/wiki/Set_(abstract_data_type)[sets] of primitive
 * types.
 *
 * Sets have the following properties:
 *
 * - Elements are added, removed, and checked for existence in constant time
 * (O(1)).
 * - Elements are enumerated in O(n). No guarantees are made on the ordering.
 *
 * ```solidity
 * contract Example {
 *     // Add the library methods
 *     using EnumerableSet for EnumerableSet.AddressSet;
 *
 *     // Declare a set state variable
 *     EnumerableSet.AddressSet private mySet;
 * }
 * ```
 *
 * As of v3.3.0, sets of type `bytes32` (`Bytes32Set`), `address` (`AddressSet`)
 * and `uint256` (`UintSet`) are supported.
 *
 * [WARNING]
 * ====
 * Trying to delete such a structure from storage will likely result in data corruption, rendering the structure
 * unusable.
 * See https://github.com/ethereum/solidity/pull/11843[ethereum/solidity#11843] for more info.
 *
 * In order to clean an EnumerableSet, you can either remove all elements one by one or create a fresh instance using an
 * array of EnumerableSet.
 * ====
 */
library EnumerableSet {
    // To implement this library for multiple types with as little code
    // repetition as possible, we write it in terms of a generic Set type with
    // bytes32 values.
    // The Set implementation uses private functions, and user-facing
    // implementations (such as AddressSet) are just wrappers around the
    // underlying Set.
    // This means that we can only create new EnumerableSets for types that fit
    // in bytes32.

    struct Set {
        // Storage of set values
        bytes32[] _values;
        // Position of the value in the `values` array, plus 1 because index 0
        // means a value is not in the set.
        mapping(bytes32 => uint256) _indexes;
    }

    /**
     * @dev Add a value to a set. O(1).
     *
     * Returns true if the value was added to the set, that is if it was not
     * already present.
     */
    function _add(Set storage set, bytes32 value) private returns (bool) {
        if (!_contains(set, value)) {
            set._values.push(value);
            // The value is stored at length-1, but we add 1 to all indexes
            // and use 0 as a sentinel value
            set._indexes[value] = set._values.length;
            return true;
        } else {
            return false;
        }
    }

    /**
     * @dev Removes a value from a set. O(1).
     *
     * Returns true if the value was removed from the set, that is if it was
     * present.
     */
    function _remove(Set storage set, bytes32 value) private returns (bool) {
        // We read and store the value's index to prevent multiple reads from the same storage slot
        uint256 valueIndex = set._indexes[value];

        if (valueIndex != 0) {
            // Equivalent to contains(set, value)
            // To delete an element from the _values array in O(1), we swap the element to delete with the last one in
            // the array, and then remove the last element (sometimes called as 'swap and pop').
            // This modifies the order of the array, as noted in {at}.

            uint256 toDeleteIndex = valueIndex - 1;
            uint256 lastIndex = set._values.length - 1;

            if (lastIndex != toDeleteIndex) {
                bytes32 lastValue = set._values[lastIndex];

                // Move the last value to the index where the value to delete is
                set._values[toDeleteIndex] = lastValue;
                // Update the index for the moved value
                set._indexes[lastValue] = valueIndex; // Replace lastValue's index to valueIndex
            }

            // Delete the slot where the moved value was stored
            set._values.pop();

            // Delete the index for the deleted slot
            delete set._indexes[value];

            return true;
        } else {
            return false;
        }
    }

    /**
     * @dev Returns true if the value is in the set. O(1).
     */
    function _contains(Set storage set, bytes32 value) private view returns (bool) {
        return set._indexes[value] != 0;
    }

    /**
     * @dev Returns the number of values on the set. O(1).
     */
    function _length(Set storage set) private view returns (uint256) {
        return set._values.length;
    }

    /**
     * @dev Returns the value stored at position `index` in the set. O(1).
     *
     * Note that there are no guarantees on the ordering of values inside the
     * array, and it may change when more values are added or removed.
     *
     * Requirements:
     *
     * - `index` must be strictly less than {length}.
     */
    function _at(Set storage set, uint256 index) private view returns (bytes32) {
        return set._values[index];
    }

    /**
     * @dev Return the entire set in an array
     *
     * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
     * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
     * this function has an unbounded cost, and using it as part of a state-changing function may render the function
     * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
     */
    function _values(Set storage set) private view returns (bytes32[] memory) {
        return set._values;
    }

    // Bytes32Set

    struct Bytes32Set {
        Set _inner;
    }

    /**
     * @dev Add a value to a set. O(1).
     *
     * Returns true if the value was added to the set, that is if it was not
     * already present.
     */
    function add(Bytes32Set storage set, bytes32 value) internal returns (bool) {
        return _add(set._inner, value);
    }

    /**
     * @dev Removes a value from a set. O(1).
     *
     * Returns true if the value was removed from the set, that is if it was
     * present.
     */
    function remove(Bytes32Set storage set, bytes32 value) internal returns (bool) {
        return _remove(set._inner, value);
    }

    /**
     * @dev Returns true if the value is in the set. O(1).
     */
    function contains(Bytes32Set storage set, bytes32 value) internal view returns (bool) {
        return _contains(set._inner, value);
    }

    /**
     * @dev Returns the number of values in the set. O(1).
     */
    function length(Bytes32Set storage set) internal view returns (uint256) {
        return _length(set._inner);
    }

    /**
     * @dev Returns the value stored at position `index` in the set. O(1).
     *
     * Note that there are no guarantees on the ordering of values inside the
     * array, and it may change when more values are added or removed.
     *
     * Requirements:
     *
     * - `index` must be strictly less than {length}.
     */
    function at(Bytes32Set storage set, uint256 index) internal view returns (bytes32) {
        return _at(set._inner, index);
    }

    /**
     * @dev Return the entire set in an array
     *
     * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
     * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
     * this function has an unbounded cost, and using it as part of a state-changing function may render the function
     * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
     */
    function values(Bytes32Set storage set) internal view returns (bytes32[] memory) {
        bytes32[] memory store = _values(set._inner);
        bytes32[] memory result;

        /// @solidity memory-safe-assembly
        assembly {
            result := store
        }

        return result;
    }

    // AddressSet

    struct AddressSet {
        Set _inner;
    }

    /**
     * @dev Add a value to a set. O(1).
     *
     * Returns true if the value was added to the set, that is if it was not
     * already present.
     */
    function add(AddressSet storage set, address value) internal returns (bool) {
        return _add(set._inner, bytes32(uint256(uint160(value))));
    }

    /**
     * @dev Removes a value from a set. O(1).
     *
     * Returns true if the value was removed from the set, that is if it was
     * present.
     */
    function remove(AddressSet storage set, address value) internal returns (bool) {
        return _remove(set._inner, bytes32(uint256(uint160(value))));
    }

    /**
     * @dev Returns true if the value is in the set. O(1).
     */
    function contains(AddressSet storage set, address value) internal view returns (bool) {
        return _contains(set._inner, bytes32(uint256(uint160(value))));
    }

    /**
     * @dev Returns the number of values in the set. O(1).
     */
    function length(AddressSet storage set) internal view returns (uint256) {
        return _length(set._inner);
    }

    /**
     * @dev Returns the value stored at position `index` in the set. O(1).
     *
     * Note that there are no guarantees on the ordering of values inside the
     * array, and it may change when more values are added or removed.
     *
     * Requirements:
     *
     * - `index` must be strictly less than {length}.
     */
    function at(AddressSet storage set, uint256 index) internal view returns (address) {
        return address(uint160(uint256(_at(set._inner, index))));
    }

    /**
     * @dev Return the entire set in an array
     *
     * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
     * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
     * this function has an unbounded cost, and using it as part of a state-changing function may render the function
     * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
     */
    function values(AddressSet storage set) internal view returns (address[] memory) {
        bytes32[] memory store = _values(set._inner);
        address[] memory result;

        /// @solidity memory-safe-assembly
        assembly {
            result := store
        }

        return result;
    }

    // UintSet

    struct UintSet {
        Set _inner;
    }

    /**
     * @dev Add a value to a set. O(1).
     *
     * Returns true if the value was added to the set, that is if it was not
     * already present.
     */
    function add(UintSet storage set, uint256 value) internal returns (bool) {
        return _add(set._inner, bytes32(value));
    }

    /**
     * @dev Removes a value from a set. O(1).
     *
     * Returns true if the value was removed from the set, that is if it was
     * present.
     */
    function remove(UintSet storage set, uint256 value) internal returns (bool) {
        return _remove(set._inner, bytes32(value));
    }

    /**
     * @dev Returns true if the value is in the set. O(1).
     */
    function contains(UintSet storage set, uint256 value) internal view returns (bool) {
        return _contains(set._inner, bytes32(value));
    }

    /**
     * @dev Returns the number of values in the set. O(1).
     */
    function length(UintSet storage set) internal view returns (uint256) {
        return _length(set._inner);
    }

    /**
     * @dev Returns the value stored at position `index` in the set. O(1).
     *
     * Note that there are no guarantees on the ordering of values inside the
     * array, and it may change when more values are added or removed.
     *
     * Requirements:
     *
     * - `index` must be strictly less than {length}.
     */
    function at(UintSet storage set, uint256 index) internal view returns (uint256) {
        return uint256(_at(set._inner, index));
    }

    /**
     * @dev Return the entire set in an array
     *
     * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
     * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
     * this function has an unbounded cost, and using it as part of a state-changing function may render the function
     * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
     */
    function values(UintSet storage set) internal view returns (uint256[] memory) {
        bytes32[] memory store = _values(set._inner);
        uint256[] memory result;

        /// @solidity memory-safe-assembly
        assembly {
            result := store
        }

        return result;
    }
}

{
  "remappings": [
    "ds-test/=lib/forge-std/lib/ds-test/src/",
    "erc4626-tests/=lib/openzeppelin-contracts/lib/erc4626-tests/",
    "forge-std/=lib/forge-std/src/",
    "openzeppelin-contracts-upgradeable/=lib/openzeppelin-contracts-upgradeable/",
    "openzeppelin-contracts/=lib/openzeppelin-contracts/",
    "openzeppelin/=lib/openzeppelin-contracts/contracts/"
  ],
  "optimizer": {
    "enabled": true,
    "runs": 200
  },
  "metadata": {
    "useLiteralContent": false,
    "bytecodeHash": "ipfs",
    "appendCBOR": true
  },
  "outputSelection": {
    "*": {
      "*": [
        "evm.bytecode",
        "evm.deployedBytecode",
        "abi"
      ]
    }
  },
  "evmVersion": "paris",
  "viaIR": true,
  "libraries": {}
}

[{"inputs":[{"internalType":"address[]","name":"_owners","type":"address[]"},{"internalType":"uint256","name":"_numConfirmationsRequired","type":"uint256"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"name":"InvalidNumberOfConfirmations","type":"error"},{"inputs":[],"name":"InvalidOwner","type":"error"},{"inputs":[],"name":"InvalidTxnId","type":"error"},{"inputs":[],"name":"NotAnOwner","type":"error"},{"inputs":[],"name":"NotEnoughConfirmation","type":"error"},{"inputs":[],"name":"OnlyMultisigAccountCanCall","type":"error"},{"inputs":[],"name":"OwnerNotUnique","type":"error"},{"inputs":[],"name":"OwnersRequired","type":"error"},{"inputs":[],"name":"TransactionAlreadyExpired","type":"error"},{"inputs":[],"name":"TransactionNotConfirmed","type":"error"},{"inputs":[],"name":"TxnAlreadyConfirmed","type":"error"},{"inputs":[],"name":"TxnAlreadyExecuted","type":"error"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"uint256","name":"txIndex","type":"uint256"}],"name":"ConfirmTransaction","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"sender","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"balance","type":"uint256"}],"name":"Deposit","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"uint256","name":"txIndex","type":"uint256"},{"indexed":false,"internalType":"bytes","name":"txData","type":"bytes"}],"name":"ExecuteTransaction","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"newNumConfirmation","type":"uint256"}],"name":"NumConfirmationUpdated","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address[]","name":"owners","type":"address[]"}],"name":"OwnersAdded","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address[]","name":"owners","type":"address[]"}],"name":"OwnersRemoved","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"uint256","name":"txIndex","type":"uint256"}],"name":"RevokeConfirmation","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"uint256","name":"txIndex","type":"uint256"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"},{"indexed":false,"internalType":"bytes","name":"data","type":"bytes"}],"name":"SubmitTransaction","type":"event"},{"inputs":[{"internalType":"address[]","name":"_owners","type":"address[]"}],"name":"addOwners","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_txIndex","type":"uint256"}],"name":"confirmTransaction","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_txIndex","type":"uint256"}],"name":"executeTransaction","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"getOwners","outputs":[{"internalType":"address[]","name":"","type":"address[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_txIndex","type":"uint256"}],"name":"getTransaction","outputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"},{"internalType":"bool","name":"executed","type":"bool"},{"internalType":"uint256","name":"numConfirmations","type":"uint256"},{"internalType":"uint64","name":"timeout","type":"uint64"},{"internalType":"bytes","name":"data","type":"bytes"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getTransactionCount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"transactionIndex","type":"uint256"},{"internalType":"address","name":"owner","type":"address"}],"name":"isConfirmed","outputs":[{"internalType":"bool","name":"permissionToExecute","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"numConfirmationsRequired","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address[]","name":"_owners","type":"address[]"}],"name":"removeOwners","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_txIndex","type":"uint256"}],"name":"revokeConfirmation","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_to","type":"address"},{"internalType":"uint256","name":"_value","type":"uint256"},{"internalType":"uint64","name":"_timeoutDuration","type":"uint64"},{"internalType":"bytes","name":"_data","type":"bytes"}],"name":"submitTransaction","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_numConfirmationsRequired","type":"uint256"}],"name":"updateNumConfirmations","outputs":[],"stateMutability":"nonpayable","type":"function"},{"stateMutability":"payable","type":"receive"}]

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

296:14408:1:-:0;;;;;;;;;;;-1:-1:-1;296:14408:1;;;;;;;;;;;7683:9;296:14408;;7694:21;296:14408;;;;7671:10;;7663:53;;;296:14408;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;9616:10;;;;:::i;:::-;9646:8;;;:::i;:::-;9677;;;:::i;:::-;9709;;;:::i;:::-;9762:22;;;:::i;:::-;296:14408;;;9829:24;296:14408;;;;9798:55;9794:103;;-1:-1:-1;;;;296:14408:1;;-1:-1:-1;;;296:14408:1;;;;10020:17;;;296:14408;;;9829:24;10048:16;;;296:14408;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;9980:85;;;;;;;296:14408;;;;;;;9980:85;;;296:14408;;;;;;;;;:::i;:::-;;;;;;;;:::i;:::-;;;;;;;;;;;;;;10120:46;296:14408;;;;;;;;;;9616:10;296:14408;;;;;:::i;:::-;10120:46;;;296:14408;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;296:14408:1;;;;;;;;;;;;;;;;;-1:-1:-1;296:14408:1;;;;;;;;;-1:-1:-1;;;296:14408:1;;;-1:-1:-1;296:14408:1;;;;;;;;;;;;;;;;;;-1:-1:-1;296:14408:1;;;;;;;-1:-1:-1;;296:14408:1;;;-1:-1:-1;;;296:14408:1;;;;;;;-1:-1:-1;296:14408:1;;;;;9794:103;-1:-1:-1;;296:14408:1;-1:-1:-1;;;9874:23:1;;;296:14408;;;;;;;;;;;;;;;;-1:-1:-1;;296:14408:1;;;;;;12633:395;;;:::i;:::-;12758:30;;:89;;;;296:14408;12741:154;;296:14408;;;;12972:49;296:14408;12905:52;296:14408;;;;;12972:49;296:14408;;12741:154;296:14408;;-1:-1:-1;;;12865:30:1;;;12758:89;296:14408;;;12804:43;;12758:89;;296:14408;;;;;;;;;;;;;;;;4609:39;296:14408;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;296:14408:1;;;;;;9048:10;;;;:::i;:::-;9078:8;;;:::i;:::-;9109;;;:::i;:::-;296:14408;;;6561:11;296:14408;;;;;9048:10;296:14408;;;;;;;;;;6557:68;;9173:8;;;:::i;:::-;9226:22;;;:::i;:::-;296:14408;;;;;;;;;;;;;;;-1:-1:-1;;;;;296:14408:1;;;;;;-1:-1:-1;;;;;;296:14408:1;;;;;;;;;;6561:11;296:14408;;;;;9048:10;296:14408;;;;;;;;;;;;;;;9048:10;9357:40;;;;296:14408;;;-1:-1:-1;;;296:14408:1;;;;;;;;6557:68;296:14408;-1:-1:-1;;;6604:21:1;;296:14408;;6604:21;296:14408;;;;;;;;;:::i;:::-;11759:671;;:::i;:::-;296:14408;;11852:19;11848:48;;11941:29;296:14408;;11941:29;:::i;:::-;11980:13;;12009;;12044:3;296:14408;;12024:18;;;;;296:14408;;-1:-1:-1;;;;;12079:10:1;296:14408;12079:10;;:::i;:::-;296:14408;;8963:55:0;;296:14408:1;;4351:12:0;296:14408:1;;;;;;4351:24:0;;4255:127;;8963:55;12103:126:1;;12044:3;;296:14408;12009:13;;12103:126;8719:53:0;;;:::i;:::-;;12186:28:1;12202:3;;;:::i;:::-;12186:28;;;:::i;:::-;296:14408;12103:126;;;12024:18;;;;;;296:14408;;12271:24;296:14408;-1:-1:-1;12249:110:1;;12373:5;12369:54;;296:14408;;;12369:54;296:14408;12393:30;;296:14408;;12393:30;;296:14408;12393:30;:::i;:::-;;;;12369:54;;296:14408;;;12249:110;296:14408;;-1:-1:-1;;;12318:30:1;;;11848:48;-1:-1:-1;296:14408:1;-1:-1:-1;;;11880:16:1;;;296:14408;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;296:14408:1;;;;;;;;;;;;;;;;;;5209:106;296:14408;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;10997:605;;:::i;:::-;296:14408;;11087:19;11083:48;;11177:29;296:14408;;11177:29;:::i;:::-;11216:13;;11245;;11280:3;296:14408;;11260:18;;;;;-1:-1:-1;;;;;11315:10:1;;;;:::i;:::-;296:14408;;11343:19;;11339:46;;8963:55:0;;;296:14408:1;8963:55:0;296:14408:1;;4351:12:0;296:14408:1;;;;;;4351:24:0;;4255:127;;8963:55;11403:23:1;11399:125;;11280:3;;296:14408;11245:13;;11399:125;8398:50:0;;;:::i;:::-;;11481:28:1;11497:3;;;:::i;:::-;11481:28;;;:::i;:::-;296:14408;11399:125;;;11339:46;296:14408;;-1:-1:-1;;;11371:14:1;;296:14408;;11371:14;11260:18;;;;;11543:52;;296:14408;;;11543:52;296:14408;11567:28;;296:14408;;11567:28;;296:14408;11567:28;:::i;11083:48::-;296:14408;;-1:-1:-1;;;11115:16:1;;296:14408;;11115:16;296:14408;;;;;;;;;;;;;;;;14447:22;296:14408;;14447:22;:::i;:::-;296:14408;;;;;;14529:17;14669:16;296:14408;14529:17;;296:14408;14669:16;;296:14408;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;-1:-1:-1;;;296:14408:1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;296:14408:1;;;;;;;;;;;;;;;;-1:-1:-1;296:14408:1;;-1:-1:-1;296:14408:1;;-1:-1:-1;296:14408:1;;-1:-1:-1;296:14408:1;;-1:-1:-1;296:14408:1;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;296:14408:1;;-1:-1:-1;;296:14408:1;;;;-1:-1:-1;;;;;296:14408:1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;8267:10;;;:::i;:::-;296:14408;;8471:15;;;296:14408;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8367:328;;;;296:14408;;;8367:328;;;;296:14408;;;;;8367:328;;296:14408;;;;;;;8367:328;;296:14408;;;;-1:-1:-1;;;8367:328:1;;;296:14408;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;-1:-1:-1;;;;;296:14408:1;;;;;;;;;;;;;-1:-1:-1;;;296:14408:1;;;;;;;-1:-1:-1;;;296:14408:1;;;;;;;;;;-1:-1:-1;;;;;;296:14408:1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;8771:58;296:14408;;;;;;;;;;;;;;-1:-1:-1;;;;296:14408:1;;;;;;;;;;;;;;;;;8716:11;296:14408;;;;;8267:10;296:14408;;;;;;;;;;;;;;;;;;;;;;;;;;;8267:10;296:14408;;;;;:::i;:::-;8771:58;;;296:14408;;;;;;-1:-1:-1;296:14408:1;;;;;-1:-1:-1;296:14408:1;;;;;;;;-1:-1:-1;;296:14408:1;;;;;;;;;;;;;;;;;;;8771:58;296:14408;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;296:14408:1;;;;;-1:-1:-1;;;296:14408:1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;296:14408:1;;;;;;;;;-1:-1:-1;;;;296:14408:1;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;296:14408:1;;;;;;10424:10;;;;:::i;:::-;10454:8;;;:::i;:::-;10485;;;:::i;:::-;10517;;;:::i;:::-;296:14408;;;10541:11;296:14408;;;;;10424:10;296:14408;;;;;;;;;;10540:34;10536:97;;10677:22;;;:::i;:::-;-1:-1:-1;296:14408:1;;;;-1:-1:-1;;296:14408:1;;;;;;;;;-1:-1:-1;;;;;296:14408:1;;;;;;-1:-1:-1;;;;;;296:14408:1;;;;;;;;;;10541:11;296:14408;;;;;10424:10;296:14408;;;;;;;;;;;;;10424:10;10810:40;;;;296:14408;;10536:97;296:14408;-1:-1:-1;;;10597:25:1;;296:14408;;10597:25;296:14408;;;;;;;;;;;;;;;;;;;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;296:14408:1;;;;:::o;:::-;;;;;;;;;-1:-1:-1;296:14408:1;;;;;;;;;-1:-1:-1;296:14408:1;;;;;;;;;;;;;;;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;:::-;;;-1:-1:-1;;;;;296:14408:1;;;;;;;;;;;;;;;;;-1:-1:-1;296:14408:1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;:::-;;;-1:-1:-1;;;;;296:14408:1;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;296:14408:1;;;;;-1:-1:-1;296:14408:1;:::o;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;;;;:::i;:::-;;;;;;;;:::o;:::-;;;;;;;;;;;;;;;:::o;:::-;-1:-1:-1;;296:14408:1;;;;;;;:::o;:::-;;;;;;;;;;;;5451:116;-1:-1:-1;;;;;296:14408:1;;;;;;;;;;;;4351:24:0;5503:57:1;;5451:116::o;5503:57::-;296:14408;;-1:-1:-1;;;5548:12:1;;;;;5838:128;5908:12;296:14408;-1:-1:-1;5896:31:1;5892:67;;5838:128::o;5892:67::-;296:14408;;-1:-1:-1;;;5945:14:1;;5908:12;;5945:14;6036:137;6097:22;296:14408;6036:137;6097:22;:::i;:::-;296:14408;;;;;6093:73;;6036:137::o;6093:73::-;296:14408;;-1:-1:-1;;;6146:20:1;;6097:12;;6146:20;6249:165;6311:22;296:14408;6249:165;6311:22;:::i;:::-;296:14408;;;;;6344:15;-1:-1:-1;6307:100:1;;6249:165::o;6307:100::-;296:14408;;-1:-1:-1;;;6380:27:1;;6311:12;;6380:27;5642:141;5710:4;5688:10;:27;5684:93;;5642:141::o;5684:93::-;296:14408;;-1:-1:-1;;;5738:28:1;;;;;296:14408;;;;;;;;;;;;;;;;;;:::o;:::-;-1:-1:-1;;;296:14408:1;;;;;;;;2214:404:0;296:14408:1;;;;4351:12:0;296:14408:1;;;;;;;;;;-1:-1:-1;;;296:14408:1;;;;;;;;;;4351:12:0;296:14408:1;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4351:12:0;296:14408:1;;;;4351:12:0;2547:11;:::o;296:14408:1:-;-1:-1:-1;;;296:14408:1;;;;;;;;2293:319:0;2589:12;;;:::o;2786:1388::-;296:14408:1;;;;2989:12:0;296:14408:1;;;;;;;;;3023:15:0;;;;-1:-1:-1;;296:14408:1;;;;;;;;;;;;;;;;;;;;3505:26:0;;;3501:398;;3019:1149;296:14408:1;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;2989:12:0;296:14408:1;;;;;;2989:12:0;4103:11;:::o;296:14408:1:-;-1:-1:-1;;;296:14408:1;;;;;;;;3501:398:0;296:14408:1;3571:22:0;3693:26;3571:22;;:::i;:::-;296:14408:1;;;;;;3693:26:0;;;;:::i;296:14408:1:-;;;;;2989:12:0;296:14408:1;;;;;;3501:398:0;;;;;296:14408:1;-1:-1:-1;;;296:14408:1;;;;;;;;;-1:-1:-1;;;296:14408:1;;;;;;;;3019:1149:0;4145:12;;;:::o

ipfs://e24d69710ce5cf9c69f94cf250a18ae996edb852b35ef138d1ccf44950e20cd6