Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

Outline

• interface IERC20
•    - function totalSupply()
•    - function balanceOf(address account)
•    - function transfer(address recipient, ...
•    - function allowance(address owner, add ...
•    - function approve(address spender, uin ...
•    - function transferFrom(address sender, ...
• library SafeMath
•    - function add(uint256 a, uint256 b)
•    - function sub(uint256 a, uint256 b)
•    - function sub(uint256 a, uint256 b, st ...
•    - function mul(uint256 a, uint256 b)
•    - function div(uint256 a, uint256 b)
•    - function div(uint256 a, uint256 b, st ...
•    - function mod(uint256 a, uint256 b)
•    - function mod(uint256 a, uint256 b, st ...
• library Address
•    - function isContract(address account)
•    - function sendValue(address payable re ...
•    - function functionCall(address target, ...
•    - function functionCall(address target, ...
•    - function functionCallWithValue(addres ...
•    - function functionCallWithValue(addres ...
•    - function _functionCallWithValue(addre ...
• library SafeERC20
•    - function safeTransfer(IERC20 token, a ...
•    - function safeTransferFrom(IERC20 toke ...
•    - function safeApprove(IERC20 token, ad ...
•    - function safeIncreaseAllowance(IERC20 ...
•    - function safeDecreaseAllowance(IERC20 ...
•    - function _callOptionalReturn(IERC20 t ...
• library Math
•    - function max(uint256 a, uint256 b)
•    - function min(uint256 a, uint256 b)
•    - function average(uint256 a, uint256 b ...
• interface ITornadoInstance
•    - function deposit(bytes32 commitment)
•    - function withdraw(
• interface ITornadoTrees
•    - function registerDeposit(address inst ...
•    - function registerWithdrawal(address i ...
• interface ENS
•    - function resolver(bytes32 node)
• interface Resolver
•    - function addr(bytes32 node)
•  contract EnsResolve
•    - function resolve(bytes32 node)
•    - function bulkResolve(bytes32[] memory ...
•    - function getChainId()
•  contract TornadoProxy is EnsResolv ... *
•    - function deposit(ITornadoInstance _to ...
•    - function updateInstance(ITornadoInsta ...
•    - function withdraw(
•    - function rescueTokens(

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

/**
 *Submitted for verification at Etherscan.io on 2020-12-19
*/

/**
* https://tornado.cash
*
* d888888P                                           dP              a88888b.                   dP
*    88                                              88             d8'   `88                   88
*    88    .d8888b. 88d888b. 88d888b. .d8888b. .d888b88 .d8888b.    88        .d8888b. .d8888b. 88d888b.
*    88    88'  `88 88'  `88 88'  `88 88'  `88 88'  `88 88'  `88    88        88'  `88 Y8ooooo. 88'  `88
*    88    88.  .88 88       88    88 88.  .88 88.  .88 88.  .88 dP Y8.   .88 88.  .88       88 88    88
*    dP    `88888P' dP       dP    dP `88888P8 `88888P8 `88888P' 88  Y88888P' `88888P8 `88888P' dP    dP
* ooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooo
*/

// File: @openzeppelin/contracts/token/ERC20/IERC20.sol

// SPDX-License-Identifier: MIT

pragma solidity ^0.6.0;

/**
 * @dev Interface of the ERC20 standard as defined in the EIP.
 */
interface IERC20 {
    /**
     * @dev Returns the amount of tokens in existence.
     */
    function totalSupply() external view returns (uint256);

    /**
     * @dev Returns the amount of tokens owned by `account`.
     */
    function balanceOf(address account) external view returns (uint256);

    /**
     * @dev Moves `amount` tokens from the caller's account to `recipient`.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transfer(address recipient, uint256 amount) external returns (bool);

    /**
     * @dev Returns the remaining number of tokens that `spender` will be
     * allowed to spend on behalf of `owner` through {transferFrom}. This is
     * zero by default.
     *
     * This value changes when {approve} or {transferFrom} are called.
     */
    function allowance(address owner, address spender) external view returns (uint256);

    /**
     * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * IMPORTANT: Beware that changing an allowance with this method brings the risk
     * that someone may use both the old and the new allowance by unfortunate
     * transaction ordering. One possible solution to mitigate this race
     * condition is to first reduce the spender's allowance to 0 and set the
     * desired value afterwards:
     * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
     *
     * Emits an {Approval} event.
     */
    function approve(address spender, uint256 amount) external returns (bool);

    /**
     * @dev Moves `amount` tokens from `sender` to `recipient` using the
     * allowance mechanism. `amount` is then deducted from the caller's
     * allowance.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);

    /**
     * @dev Emitted when `value` tokens are moved from one account (`from`) to
     * another (`to`).
     *
     * Note that `value` may be zero.
     */
    event Transfer(address indexed from, address indexed to, uint256 value);

    /**
     * @dev Emitted when the allowance of a `spender` for an `owner` is set by
     * a call to {approve}. `value` is the new allowance.
     */
    event Approval(address indexed owner, address indexed spender, uint256 value);
}

// File: @openzeppelin/contracts/math/SafeMath.sol



pragma solidity ^0.6.0;

/**
 * @dev Wrappers over Solidity's arithmetic operations with added overflow
 * checks.
 *
 * Arithmetic operations in Solidity wrap on overflow. This can easily result
 * in bugs, because programmers usually assume that an overflow raises an
 * error, which is the standard behavior in high level programming languages.
 * `SafeMath` restores this intuition by reverting the transaction when an
 * operation overflows.
 *
 * Using this library instead of the unchecked operations eliminates an entire
 * class of bugs, so it's recommended to use it always.
 */
library SafeMath {
    /**
     * @dev Returns the addition of two unsigned integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `+` operator.
     *
     * Requirements:
     *
     * - Addition cannot overflow.
     */
    function add(uint256 a, uint256 b) internal pure returns (uint256) {
        uint256 c = a + b;
        require(c >= a, "SafeMath: addition overflow");

        return c;
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, reverting on
     * overflow (when the result is negative).
     *
     * Counterpart to Solidity's `-` operator.
     *
     * Requirements:
     *
     * - Subtraction cannot overflow.
     */
    function sub(uint256 a, uint256 b) internal pure returns (uint256) {
        return sub(a, b, "SafeMath: subtraction overflow");
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, reverting with custom message on
     * overflow (when the result is negative).
     *
     * Counterpart to Solidity's `-` operator.
     *
     * Requirements:
     *
     * - Subtraction cannot overflow.
     */
    function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        require(b <= a, errorMessage);
        uint256 c = a - b;

        return c;
    }

    /**
     * @dev Returns the multiplication of two unsigned integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `*` operator.
     *
     * Requirements:
     *
     * - Multiplication cannot overflow.
     */
    function mul(uint256 a, uint256 b) internal pure returns (uint256) {
        // Gas optimization: this is cheaper than requiring 'a' not being zero, but the
        // benefit is lost if 'b' is also tested.
        // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
        if (a == 0) {
            return 0;
        }

        uint256 c = a * b;
        require(c / a == b, "SafeMath: multiplication overflow");

        return c;
    }

    /**
     * @dev Returns the integer division of two unsigned integers. Reverts on
     * division by zero. The result is rounded towards zero.
     *
     * Counterpart to Solidity's `/` operator. Note: this function uses a
     * `revert` opcode (which leaves remaining gas untouched) while Solidity
     * uses an invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function div(uint256 a, uint256 b) internal pure returns (uint256) {
        return div(a, b, "SafeMath: division by zero");
    }

    /**
     * @dev Returns the integer division of two unsigned integers. Reverts with custom message on
     * division by zero. The result is rounded towards zero.
     *
     * Counterpart to Solidity's `/` operator. Note: this function uses a
     * `revert` opcode (which leaves remaining gas untouched) while Solidity
     * uses an invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        require(b > 0, errorMessage);
        uint256 c = a / b;
        // assert(a == b * c + a % b); // There is no case in which this doesn't hold

        return c;
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * Reverts when dividing by zero.
     *
     * Counterpart to Solidity's `%` operator. This function uses a `revert`
     * opcode (which leaves remaining gas untouched) while Solidity uses an
     * invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function mod(uint256 a, uint256 b) internal pure returns (uint256) {
        return mod(a, b, "SafeMath: modulo by zero");
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * Reverts with custom message when dividing by zero.
     *
     * Counterpart to Solidity's `%` operator. This function uses a `revert`
     * opcode (which leaves remaining gas untouched) while Solidity uses an
     * invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        require(b != 0, errorMessage);
        return a % b;
    }
}

// File: @openzeppelin/contracts/utils/Address.sol



pragma solidity ^0.6.2;

/**
 * @dev Collection of functions related to the address type
 */
library Address {
    /**
     * @dev Returns true if `account` is a contract.
     *
     * [IMPORTANT]
     * ====
     * It is unsafe to assume that an address for which this function returns
     * false is an externally-owned account (EOA) and not a contract.
     *
     * Among others, `isContract` will return false for the following
     * types of addresses:
     *
     *  - an externally-owned account
     *  - a contract in construction
     *  - an address where a contract will be created
     *  - an address where a contract lived, but was destroyed
     * ====
     */
    function isContract(address account) internal view returns (bool) {
        // According to EIP-1052, 0x0 is the value returned for not-yet created accounts
        // and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
        // for accounts without code, i.e. `keccak256('')`
        bytes32 codehash;
        bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
        // solhint-disable-next-line no-inline-assembly
        assembly { codehash := extcodehash(account) }
        return (codehash != accountHash && codehash != 0x0);
    }

    /**
     * @dev Replacement for Solidity's `transfer`: sends `amount` wei to
     * `recipient`, forwarding all available gas and reverting on errors.
     *
     * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost
     * of certain opcodes, possibly making contracts go over the 2300 gas limit
     * imposed by `transfer`, making them unable to receive funds via
     * `transfer`. {sendValue} removes this limitation.
     *
     * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].
     *
     * IMPORTANT: because control is transferred to `recipient`, care must be
     * taken to not create reentrancy vulnerabilities. Consider using
     * {ReentrancyGuard} or the
     * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
     */
    function sendValue(address payable recipient, uint256 amount) internal {
        require(address(this).balance >= amount, "Address: insufficient balance");

        // solhint-disable-next-line avoid-low-level-calls, avoid-call-value
        (bool success, ) = recipient.call{ value: amount }("");
        require(success, "Address: unable to send value, recipient may have reverted");
    }

    /**
     * @dev Performs a Solidity function call using a low level `call`. A
     * plain`call` is an unsafe replacement for a function call: use this
     * function instead.
     *
     * If `target` reverts with a revert reason, it is bubbled up by this
     * function (like regular Solidity function calls).
     *
     * Returns the raw returned data. To convert to the expected return value,
     * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].
     *
     * Requirements:
     *
     * - `target` must be a contract.
     * - calling `target` with `data` must not revert.
     *
     * _Available since v3.1._
     */
    function functionCall(address target, bytes memory data) internal returns (bytes memory) {
      return functionCall(target, data, "Address: low-level call failed");
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with
     * `errorMessage` as a fallback revert reason when `target` reverts.
     *
     * _Available since v3.1._
     */
    function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
        return _functionCallWithValue(target, data, 0, errorMessage);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but also transferring `value` wei to `target`.
     *
     * Requirements:
     *
     * - the calling contract must have an ETH balance of at least `value`.
     * - the called Solidity function must be `payable`.
     *
     * _Available since v3.1._
     */
    function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
        return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
    }

    /**
     * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but
     * with `errorMessage` as a fallback revert reason when `target` reverts.
     *
     * _Available since v3.1._
     */
    function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
        require(address(this).balance >= value, "Address: insufficient balance for call");
        return _functionCallWithValue(target, data, value, errorMessage);
    }

    function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
        require(isContract(target), "Address: call to non-contract");

        // solhint-disable-next-line avoid-low-level-calls
        (bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
        if (success) {
            return returndata;
        } else {
            // Look for revert reason and bubble it up if present
            if (returndata.length > 0) {
                // The easiest way to bubble the revert reason is using memory via assembly

                // solhint-disable-next-line no-inline-assembly
                assembly {
                    let returndata_size := mload(returndata)
                    revert(add(32, returndata), returndata_size)
                }
            } else {
                revert(errorMessage);
            }
        }
    }
}

// File: @openzeppelin/contracts/token/ERC20/SafeERC20.sol



pragma solidity ^0.6.0;




/**
 * @title SafeERC20
 * @dev Wrappers around ERC20 operations that throw on failure (when the token
 * contract returns false). Tokens that return no value (and instead revert or
 * throw on failure) are also supported, non-reverting calls are assumed to be
 * successful.
 * To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract,
 * which allows you to call the safe operations as `token.safeTransfer(...)`, etc.
 */
library SafeERC20 {
    using SafeMath for uint256;
    using Address for address;

    function safeTransfer(IERC20 token, address to, uint256 value) internal {
        _callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
    }

    function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
        _callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
    }

    /**
     * @dev Deprecated. This function has issues similar to the ones found in
     * {IERC20-approve}, and its usage is discouraged.
     *
     * Whenever possible, use {safeIncreaseAllowance} and
     * {safeDecreaseAllowance} instead.
     */
    function safeApprove(IERC20 token, address spender, uint256 value) internal {
        // safeApprove should only be called when setting an initial allowance,
        // or when resetting it to zero. To increase and decrease it, use
        // 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
        // solhint-disable-next-line max-line-length
        require((value == 0) || (token.allowance(address(this), spender) == 0),
            "SafeERC20: approve from non-zero to non-zero allowance"
        );
        _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
    }

    function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
        uint256 newAllowance = token.allowance(address(this), spender).add(value);
        _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
    }

    function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
        uint256 newAllowance = token.allowance(address(this), spender).sub(value, "SafeERC20: decreased allowance below zero");
        _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
    }

    /**
     * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement
     * on the return value: the return value is optional (but if data is returned, it must not be false).
     * @param token The token targeted by the call.
     * @param data The call data (encoded using abi.encode or one of its variants).
     */
    function _callOptionalReturn(IERC20 token, bytes memory data) private {
        // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since
        // we're implementing it ourselves. We use {Address.functionCall} to perform this call, which verifies that
        // the target address contains contract code and also asserts for success in the low-level call.

        bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
        if (returndata.length > 0) { // Return data is optional
            // solhint-disable-next-line max-line-length
            require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
        }
    }
}

// File: @openzeppelin/contracts/math/Math.sol



pragma solidity ^0.6.0;

/**
 * @dev Standard math utilities missing in the Solidity language.
 */
library Math {
    /**
     * @dev Returns the largest of two numbers.
     */
    function max(uint256 a, uint256 b) internal pure returns (uint256) {
        return a >= b ? a : b;
    }

    /**
     * @dev Returns the smallest of two numbers.
     */
    function min(uint256 a, uint256 b) internal pure returns (uint256) {
        return a < b ? a : b;
    }

    /**
     * @dev Returns the average of two numbers. The result is rounded towards
     * zero.
     */
    function average(uint256 a, uint256 b) internal pure returns (uint256) {
        // (a + b) / 2 can overflow, so we distribute
        return (a / 2) + (b / 2) + ((a % 2 + b % 2) / 2);
    }
}

// File: contracts/interfaces/ITornadoInstance.sol



pragma solidity ^0.6.0;

interface ITornadoInstance {
  function deposit(bytes32 commitment) external payable;

  function withdraw(
    bytes calldata proof,
    bytes32 root,
    bytes32 nullifierHash,
    address payable recipient,
    address payable relayer,
    uint256 fee,
    uint256 refund
  ) external payable;
}

// File: contracts/interfaces/ITornadoTrees.sol



pragma solidity ^0.6.0;

interface ITornadoTrees {
  function registerDeposit(address instance, bytes32 commitment) external;

  function registerWithdrawal(address instance, bytes32 nullifier) external;
}

// File: torn-token/contracts/ENS.sol



pragma solidity ^0.6.0;

interface ENS {
  function resolver(bytes32 node) external view returns (Resolver);
}

interface Resolver {
  function addr(bytes32 node) external view returns (address);
}

contract EnsResolve {
  function resolve(bytes32 node) public view virtual returns (address) {
    ENS Registry = ENS(
      getChainId() == 1 ? 0x00000000000C2E074eC69A0dFb2997BA6C7d2e1e : 0x8595bFb0D940DfEDC98943FA8a907091203f25EE
    );
    return Registry.resolver(node).addr(node);
  }

  function bulkResolve(bytes32[] memory domains) public view returns (address[] memory result) {
    result = new address[](domains.length);
    for (uint256 i = 0; i < domains.length; i++) {
      result[i] = resolve(domains[i]);
    }
  }

  function getChainId() internal pure returns (uint256) {
    uint256 chainId;
    assembly {
      chainId := chainid()
    }
    return chainId;
  }
}

// File: contracts/TornadoProxy.sol



pragma solidity ^0.6.0;







contract TornadoProxy is EnsResolve {
  using SafeERC20 for IERC20;

  event EncryptedNote(address indexed sender, bytes encryptedNote);

  ITornadoTrees public immutable tornadoTrees;
  address public immutable governance;

  mapping(ITornadoInstance => bool) public instances;
  modifier onlyGovernance() {
    require(msg.sender == governance, "Not authorized");
    _;
  }

  constructor(
    bytes32 _tornadoTrees,
    bytes32 _governance,
    bytes32[] memory _instances
  ) public {
    tornadoTrees = ITornadoTrees(resolve(_tornadoTrees));
    governance = resolve(_governance);

    for (uint256 i = 0; i < _instances.length; i++) {
      instances[ITornadoInstance(resolve(_instances[i]))] = true;
    }
  }

  function deposit(ITornadoInstance _tornado, bytes32 _commitment, bytes calldata _encryptedNote) external payable {
    require(instances[_tornado], "The instance is not supported");

    _tornado.deposit{ value: msg.value }(_commitment);
    tornadoTrees.registerDeposit(address(_tornado), _commitment);
    emit EncryptedNote(msg.sender, _encryptedNote);
  }

  function updateInstance(ITornadoInstance _instance, bool _update) external onlyGovernance {
    instances[_instance] = _update;
  }

  function withdraw(
    ITornadoInstance _tornado,
    bytes calldata _proof,
    bytes32 _root,
    bytes32 _nullifierHash,
    address payable _recipient,
    address payable _relayer,
    uint256 _fee,
    uint256 _refund
  ) external payable {
    require(instances[_tornado], "The instance is not supported");

    _tornado.withdraw{ value: msg.value }(_proof, _root, _nullifierHash, _recipient, _relayer, _fee, _refund);
    tornadoTrees.registerWithdrawal(address(_tornado), _nullifierHash);
  }

  /// @dev Method to claim junk and accidentally sent tokens
  function rescueTokens(
    IERC20 _token,
    address payable _to,
    uint256 _balance
  ) external onlyGovernance {
    require(_to != address(0), "TORN: can not send to zero address");

    if (_token == IERC20(0)) {
      // for Ether
      uint256 totalBalance = address(this).balance;
      uint256 balance = _balance == 0 ? totalBalance : Math.min(totalBalance, _balance);
      _to.transfer(balance);
    } else {
      // any other erc20
      uint256 totalBalance = _token.balanceOf(address(this));
      uint256 balance = _balance == 0 ? totalBalance : Math.min(totalBalance, _balance);
      require(balance > 0, "TORN: trying to send 0 balance");
      _token.safeTransfer(_to, balance);
    }
  }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"bytes32","name":"_tornadoTrees","type":"bytes32"},{"internalType":"bytes32","name":"_governance","type":"bytes32"},{"internalType":"bytes32[]","name":"_instances","type":"bytes32[]"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"sender","type":"address"},{"indexed":false,"internalType":"bytes","name":"encryptedNote","type":"bytes"}],"name":"EncryptedNote","type":"event"},{"inputs":[{"internalType":"bytes32[]","name":"domains","type":"bytes32[]"}],"name":"bulkResolve","outputs":[{"internalType":"address[]","name":"result","type":"address[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"contract ITornadoInstance","name":"_tornado","type":"address"},{"internalType":"bytes32","name":"_commitment","type":"bytes32"},{"internalType":"bytes","name":"_encryptedNote","type":"bytes"}],"name":"deposit","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"governance","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"contract ITornadoInstance","name":"","type":"address"}],"name":"instances","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"contract IERC20","name":"_token","type":"address"},{"internalType":"address payable","name":"_to","type":"address"},{"internalType":"uint256","name":"_balance","type":"uint256"}],"name":"rescueTokens","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"node","type":"bytes32"}],"name":"resolve","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"tornadoTrees","outputs":[{"internalType":"contract ITornadoTrees","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"contract ITornadoInstance","name":"_instance","type":"address"},{"internalType":"bool","name":"_update","type":"bool"}],"name":"updateInstance","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"contract ITornadoInstance","name":"_tornado","type":"address"},{"internalType":"bytes","name":"_proof","type":"bytes"},{"internalType":"bytes32","name":"_root","type":"bytes32"},{"internalType":"bytes32","name":"_nullifierHash","type":"bytes32"},{"internalType":"address payable","name":"_recipient","type":"address"},{"internalType":"address payable","name":"_relayer","type":"address"},{"internalType":"uint256","name":"_fee","type":"uint256"},{"internalType":"uint256","name":"_refund","type":"uint256"}],"name":"withdraw","outputs":[],"stateMutability":"payable","type":"function"}]

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

f364752a68271f46f4a51f0ccd3ecaf066404a7a1cdfc0687e2133606625863094d63e9067c3ab2d966702f604484c43b5ea247ecd08c28762caa50df5dc02bd00000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000004c041982b4f77cbbd82ef3b9ea748738ac6c281d3f1af198770d29f75ac32d80a9e5bc9215eecd103644145a5db4f69d5efaf4885bb5bf968f8db271ec5cd539b917e42347647689051abc744f502bff342c76ad30c0670b46b305b2f7e1f893dddfc726d74f912f49389ef7471e75291969852ce7e5df0509a17bc1e46646985

-----Decoded View---------------
Arg [0] : _tornadoTrees (bytes32): 0xf364752a68271f46f4a51f0ccd3ecaf066404a7a1cdfc0687e21336066258630
Arg [1] : _governance (bytes32): 0x94d63e9067c3ab2d966702f604484c43b5ea247ecd08c28762caa50df5dc02bd
Arg [2] : _instances (bytes32[]): System.Byte[],System.Byte[],System.Byte[],System.Byte[]

-----Encoded View---------------
8 Constructor Arguments found :
Arg [0] : f364752a68271f46f4a51f0ccd3ecaf066404a7a1cdfc0687e21336066258630
Arg [1] : 94d63e9067c3ab2d966702f604484c43b5ea247ecd08c28762caa50df5dc02bd
Arg [2] : 0000000000000000000000000000000000000000000000000000000000000060
Arg [3] : 0000000000000000000000000000000000000000000000000000000000000004
Arg [4] : c041982b4f77cbbd82ef3b9ea748738ac6c281d3f1af198770d29f75ac32d80a
Arg [5] : 9e5bc9215eecd103644145a5db4f69d5efaf4885bb5bf968f8db271ec5cd539b
Arg [6] : 917e42347647689051abc744f502bff342c76ad30c0670b46b305b2f7e1f893d
Arg [7] : ddfc726d74f912f49389ef7471e75291969852ce7e5df0509a17bc1e46646985

21533:2573:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;21768:50;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;21768:50:0;-1:-1:-1;;;;;21768:50:0;;:::i;:::-;;;;;;;;;;;;;;;;;;22281:365;;;;;;;;;;;;;;;;-1:-1:-1;;;;;22281:365:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;22281:365:0;;-1:-1:-1;22281:365:0;-1:-1:-1;22281:365:0;:::i;:::-;;21678:43;;;;;;;;;;;;;:::i;:::-;;;;-1:-1:-1;;;;;21678:43:0;;;;;;;;;;;;;;21726:35;;;;;;;;;;;;;:::i;20764:271::-;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;20764:271:0;;:::i;22652:133::-;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;22652:133:0;;;;;;;;;;:::i;22791:515::-;;;;;;;;;;;;;;;;-1:-1:-1;;;;;22791:515:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;22791:515:0;-1:-1:-1;22791:515:0;;;;;;;;-1:-1:-1;;;;;22791:515:0;;;;;;;;;;;;;;;;;;;;;;;;:::i;23374:729::-;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;23374:729:0;;;;;;;;;;;;;;;;;:::i;21041:243::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;21041:243:0;;-1:-1:-1;21041:243:0;;-1:-1:-1;;;;;21041:243:0:i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;21768:50;;;;;;;;;;;;;;;;:::o;22281:365::-;-1:-1:-1;;;;;22409:19:0;;:9;:19;;;;;;;;;;;;;22401:61;;;;;-1:-1:-1;;;22401:61:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;22471:8;-1:-1:-1;;;;;22471:16:0;;22496:9;22508:11;22471:49;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;22527:12;-1:-1:-1;;;;;22527:28:0;;22564:8;22575:11;22527:60;;;;;;;;;;;;;-1:-1:-1;;;;;22527:60:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;22613:10;-1:-1:-1;;;;;22599:41:0;;22625:14;;22599:41;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;22599:41:0;;;;;;;;-1:-1:-1;22599:41:0;;-1:-1:-1;;;;22599:41:0;22281:365;;;;:::o;21678:43::-;;;:::o;21726:35::-;;;:::o;20764:271::-;20824:7;20840:12;20867;:10;:12::i;:::-;20883:1;20867:17;:107;;20932:42;20867:107;;;20887:42;20867:107;20840:141;;20995:8;-1:-1:-1;;;;;20995:17:0;;21013:4;20995:23;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;20995:23:0;:34;;;-1:-1:-1;;;20995:34:0;;;;;;;;;;-1:-1:-1;;;;;20995:28:0;;;;;;:34;;;;;:23;;:34;;;;;;;;:28;:34;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;20995:34:0;;20764:271;-1:-1:-1;;;20764:271:0:o;22652:133::-;21864:10;-1:-1:-1;;;;;21878:10:0;21864:24;;21856:51;;;;;-1:-1:-1;;;21856:51:0;;;;;;;;;;;;-1:-1:-1;;;21856:51:0;;;;;;;;;;;;;;;-1:-1:-1;;;;;22749:20:0;;;::::1;:9;:20:::0;;;::::1;::::0;;;;;;:30;;-1:-1:-1;;22749:30:0::1;::::0;::::1;;::::0;;;::::1;::::0;;22652:133::o;22791:515::-;-1:-1:-1;;;;;23060:19:0;;:9;:19;;;;;;;;;;;;;23052:61;;;;;-1:-1:-1;;;23052:61:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;23122:8;-1:-1:-1;;;;;23122:17:0;;23148:9;23160:6;;23168:5;23175:14;23191:10;23203:8;23213:4;23219:7;23122:105;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;23122:105:0;;;;;;-1:-1:-1;;;;;23122:105:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;23234:12;-1:-1:-1;;;;;23234:31:0;;23274:8;23285:14;23234:66;;;;;;;;;;;;;-1:-1:-1;;;;;23234:66:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;22791:515;;;;;;;;;:::o;23374:729::-;21864:10;-1:-1:-1;;;;;21878:10:0;21864:24;;21856:51;;;;;-1:-1:-1;;;21856:51:0;;;;;;;;;;;;-1:-1:-1;;;21856:51:0;;;;;;;;;;;;;;;-1:-1:-1;;;;;23509:17:0;::::1;23501:64;;;;-1:-1:-1::0;;;23501:64:0::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1::0;;;;;23578:19:0;::::1;23574:524;;23651:21;23628:20;23699:13:::0;;:63:::1;;23730:32;23739:12;23753:8;23730;:32::i;:::-;23699:63;;;23715:12;23699:63;23771:21;::::0;23681:81;;-1:-1:-1;;;;;;23771:12:0;::::1;::::0;:21;::::1;;;::::0;23681:81;;23771:21:::1;::::0;;;23681:81;23771:12;:21;::::1;;;;;;;;;;;;;::::0;::::1;;;;;;23574:524;;;;;23841:20;23864:6;-1:-1:-1::0;;;;;23864:16:0::1;;23889:4;23864:31;;;;;;;;;;;;;-1:-1:-1::0;;;;;23864:31:0::1;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;::::0;::::1;;-1:-1:-1::0;23864:31:0;;-1:-1:-1;23904:15:0::1;23922:13:::0;;:63:::1;;23953:32;23962:12;23976:8;23953;:32::i;:::-;23922:63;;;23938:12;23922:63;23904:81;;24012:1;24002:7;:11;23994:54;;;::::0;;-1:-1:-1;;;23994:54:0;;::::1;;::::0;::::1;::::0;::::1;::::0;;;;::::1;::::0;;;;;;;;;;;;;::::1;;24057:33;-1:-1:-1::0;;;;;24057:19:0;::::1;24077:3:::0;24082:7;24057:19:::1;:33::i;:::-;23574:524;;;23374:729:::0;;;:::o;21041:243::-;21109:23;21164:7;:14;21150:29;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;21150:29:0;;21141:38;;21191:9;21186:93;21210:7;:14;21206:1;:18;21186:93;;;21252:19;21260:7;21268:1;21260:10;;;;;;;;;;;;;;21252:7;:19::i;:::-;21240:6;21247:1;21240:9;;;;;;;;-1:-1:-1;;;;;21240:31:0;;;:9;;;;;;;;;;;:31;21226:3;;21186:93;;;;21041:243;;;:::o;21290:154::-;21402:9;21290:154;:::o;19391:106::-;19449:7;19480:1;19476;:5;:13;;19488:1;19476:13;;;19484:1;19476:13;19469:20;19391:106;-1:-1:-1;;;19391:106:0:o;15890:177::-;16000:58;;;-1:-1:-1;;;;;16000:58:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;16000:58:0;-1:-1:-1;;;16000:58:0;;;15973:86;;15993:5;;18619:23;18645:69;18673:4;18645:69;;;;;;;;;;;;;;;;;18653:5;-1:-1:-1;;;;;18645:27:0;;;:69;;;;;:::i;:::-;18729:17;;18619:95;;-1:-1:-1;18729:21:0;18725:224;;18871:10;18860:30;;;;;;;;;;;;;;;-1:-1:-1;18860:30:0;18852:85;;;;-1:-1:-1;;;18852:85:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;12869:196;12972:12;13004:53;13027:6;13035:4;13041:1;13044:12;13004:22;:53::i;:::-;12997:60;12869:196;-1:-1:-1;;;;12869:196:0:o;14246:979::-;14376:12;14409:18;14420:6;14409:10;:18::i;:::-;14401:60;;;;;-1:-1:-1;;;14401:60:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;14535:12;14549:23;14576:6;-1:-1:-1;;;;;14576:11:0;14596:8;14607:4;14576:36;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;14576:36:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;14534:78;;;;14627:7;14623:595;;;14658:10;-1:-1:-1;14651:17:0;;-1:-1:-1;14651:17:0;14623:595;14772:17;;:21;14768:439;;15035:10;15029:17;15096:15;15083:10;15079:2;15075:19;15068:44;14983:148;15178:12;15171:20;;-1:-1:-1;;;15171:20:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;9754:619;9814:4;10282:20;;10125:66;10322:23;;;;;;:42;;-1:-1:-1;;10349:15:0;;;10314:51;-1:-1:-1;;9754:619:0:o

ipfs://1ff2be1d5ffc9d5f7474ed8741f10f855c174b9c2fd0b153377a08b25eaf577c