1. /**
    2.  *Submitted for verification at Etherscan.io on 2020-12-18
    3. */
    5. /**
    6. * https://tornado.cash
    7. *
    8. * d888888P                                           dP              a88888b.                   dP
    9. *    88                                              88             d8'   `88                   88
    10. *    88    .d8888b. 88d888b. 88d888b. .d8888b. .d888b88 .d8888b.    88        .d8888b. .d8888b. 88d888b.
    11. *    88    88'  `88 88'  `88 88'  `88 88'  `88 88'  `88 88'  `88    88        88'  `88 Y8ooooo. 88'  `88
    12. *    88    88.  .88 88       88    88 88.  .88 88.  .88 88.  .88 dP Y8.   .88 88.  .88       88 88    88
    13. *    dP    `88888P' dP       dP    dP `88888P8 `88888P8 `88888P' 88  Y88888P' `88888P8 `88888P' dP    dP
    14. * ooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooo
    15. */
    17. // File: @openzeppelin/contracts/proxy/Proxy.sol
    19. // SPDX-License-Identifier: MIT
    21. pragma solidity ^0.6.0;
    23. /**
    24.  * @dev This abstract contract provides a fallback function that delegates all calls to another contract using the EVM
    25.  * instruction `delegatecall`. We refer to the second contract as the _implementation_ behind the proxy, and it has to
    26.  * be specified by overriding the virtual {_implementation} function.
    27.  * 
    28.  * Additionally, delegation to the implementation can be triggered manually through the {_fallback} function, or to a
    29.  * different contract through the {_delegate} function.
    30.  * 
    31.  * The success and return data of the delegated call will be returned back to the caller of the proxy.
    32.  */
    33. abstract contract Proxy {
    34.     /**
    35.      * @dev Delegates the current call to `implementation`.
    36.      * 
    37.      * This function does not return to its internall call site, it will return directly to the external caller.
    38.      */
    39.     function _delegate(address implementation) internal {
    40.         // solhint-disable-next-line no-inline-assembly
    41.         assembly {
    42.             // Copy msg.data. We take full control of memory in this inline assembly
    43.             // block because it will not return to Solidity code. We overwrite the
    44.             // Solidity scratch pad at memory position 0.
    45.             calldatacopy(0, 0, calldatasize())
    47.             // Call the implementation.
    48.             // out and outsize are 0 because we don't know the size yet.
    49.             let result := delegatecall(gas(), implementation, 0, calldatasize(), 0, 0)
    51.             // Copy the returned data.
    52.             returndatacopy(0, 0, returndatasize())
    54.             switch result
    55.             // delegatecall returns 0 on error.
    56.             case 0 { revert(0, returndatasize()) }
    57.             default { return(0, returndatasize()) }
    58.         }
    59.     }
    61.     /**
    62.      * @dev This is a virtual function that should be overriden so it returns the address to which the fallback function
    63.      * and {_fallback} should delegate.
    64.      */
    65.     function _implementation() internal virtual view returns (address);
    67.     /**
    68.      * @dev Delegates the current call to the address returned by `_implementation()`.
    69.      * 
    70.      * This function does not return to its internall call site, it will return directly to the external caller.
    71.      */
    72.     function _fallback() internal {
    73.         _beforeFallback();
    74.         _delegate(_implementation());
    75.     }
    77.     /**
    78.      * @dev Fallback function that delegates calls to the address returned by `_implementation()`. Will run if no other
    79.      * function in the contract matches the call data.
    80.      */
    81.     fallback () payable external {
    82.         _fallback();
    83.     }
    85.     /**
    86.      * @dev Fallback function that delegates calls to the address returned by `_implementation()`. Will run if call data
    87.      * is empty.
    88.      */
    89.     receive () payable external {
    90.         _fallback();
    91.     }
    93.     /**
    94.      * @dev Hook that is called before falling back to the implementation. Can happen as part of a manual `_fallback`
    95.      * call, or as part of the Solidity `fallback` or `receive` functions.
    96.      * 
    97.      * If overriden should call `super._beforeFallback()`.
    98.      */
    99.     function _beforeFallback() internal virtual {
    100.     }
    101. }
    103. // File: @openzeppelin/contracts/utils/Address.sol
    107. pragma solidity ^0.6.2;
    109. /**
    110.  * @dev Collection of functions related to the address type
    111.  */
    112. library Address {
    113.     /**
    114.      * @dev Returns true if `account` is a contract.
    115.      *
    116.      * [IMPORTANT]
    117.      * ====
    118.      * It is unsafe to assume that an address for which this function returns
    119.      * false is an externally-owned account (EOA) and not a contract.
    120.      *
    121.      * Among others, `isContract` will return false for the following
    122.      * types of addresses:
    123.      *
    124.      *  - an externally-owned account
    125.      *  - a contract in construction
    126.      *  - an address where a contract will be created
    127.      *  - an address where a contract lived, but was destroyed
    128.      * ====
    129.      */
    130.     function isContract(address account) internal view returns (bool) {
    131.         // This method relies in extcodesize, which returns 0 for contracts in
    132.         // construction, since the code is only stored at the end of the
    133.         // constructor execution.
    135.         uint256 size;
    136.         // solhint-disable-next-line no-inline-assembly
    137.         assembly { size := extcodesize(account) }
    138.         return size > 0;
    139.     }
    141.     /**
    142.      * @dev Replacement for Solidity's `transfer`: sends `amount` wei to
    143.      * `recipient`, forwarding all available gas and reverting on errors.
    144.      *
    145.      * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost
    146.      * of certain opcodes, possibly making contracts go over the 2300 gas limit
    147.      * imposed by `transfer`, making them unable to receive funds via
    148.      * `transfer`. {sendValue} removes this limitation.
    149.      *
    150.      * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].
    151.      *
    152.      * IMPORTANT: because control is transferred to `recipient`, care must be
    153.      * taken to not create reentrancy vulnerabilities. Consider using
    154.      * {ReentrancyGuard} or the
    155.      * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
    156.      */
    157.     function sendValue(address payable recipient, uint256 amount) internal {
    158.         require(address(this).balance >= amount, "Address: insufficient balance");
    160.         // solhint-disable-next-line avoid-low-level-calls, avoid-call-value
    161.         (bool success, ) = recipient.call{ value: amount }("");
    162.         require(success, "Address: unable to send value, recipient may have reverted");
    163.     }
    165.     /**
    166.      * @dev Performs a Solidity function call using a low level `call`. A
    167.      * plain`call` is an unsafe replacement for a function call: use this
    168.      * function instead.
    169.      *
    170.      * If `target` reverts with a revert reason, it is bubbled up by this
    171.      * function (like regular Solidity function calls).
    172.      *
    173.      * Returns the raw returned data. To convert to the expected return value,
    174.      * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].
    175.      *
    176.      * Requirements:
    177.      *
    178.      * - `target` must be a contract.
    179.      * - calling `target` with `data` must not revert.
    180.      *
    181.      * _Available since v3.1._
    182.      */
    183.     function functionCall(address target, bytes memory data) internal returns (bytes memory) {
    184.       return functionCall(target, data, "Address: low-level call failed");
    185.     }
    187.     /**
    188.      * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with
    189.      * `errorMessage` as a fallback revert reason when `target` reverts.
    190.      *
    191.      * _Available since v3.1._
    192.      */
    193.     function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
    194.         return _functionCallWithValue(target, data, 0, errorMessage);
    195.     }
    197.     /**
    198.      * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
    199.      * but also transferring `value` wei to `target`.
    200.      *
    201.      * Requirements:
    202.      *
    203.      * - the calling contract must have an ETH balance of at least `value`.
    204.      * - the called Solidity function must be `payable`.
    205.      *
    206.      * _Available since v3.1._
    207.      */
    208.     function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
    209.         return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
    210.     }
    212.     /**
    213.      * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but
    214.      * with `errorMessage` as a fallback revert reason when `target` reverts.
    215.      *
    216.      * _Available since v3.1._
    217.      */
    218.     function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
    219.         require(address(this).balance >= value, "Address: insufficient balance for call");
    220.         return _functionCallWithValue(target, data, value, errorMessage);
    221.     }
    223.     function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
    224.         require(isContract(target), "Address: call to non-contract");
    226.         // solhint-disable-next-line avoid-low-level-calls
    227.         (bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
    228.         if (success) {
    229.             return returndata;
    230.         } else {
    231.             // Look for revert reason and bubble it up if present
    232.             if (returndata.length > 0) {
    233.                 // The easiest way to bubble the revert reason is using memory via assembly
    235.                 // solhint-disable-next-line no-inline-assembly
    236.                 assembly {
    237.                     let returndata_size := mload(returndata)
    238.                     revert(add(32, returndata), returndata_size)
    239.                 }
    240.             } else {
    241.                 revert(errorMessage);
    242.             }
    243.         }
    244.     }
    245. }
    247. // File: @openzeppelin/contracts/proxy/UpgradeableProxy.sol
    251. pragma solidity ^0.6.0;
    255. /**
    256.  * @dev This contract implements an upgradeable proxy. It is upgradeable because calls are delegated to an
    257.  * implementation address that can be changed. This address is stored in storage in the location specified by
    258.  * https://eips.ethereum.org/EIPS/eip-1967[EIP1967], so that it doesn't conflict with the storage layout of the
    259.  * implementation behind the proxy.
    260.  * 
    261.  * Upgradeability is only provided internally through {_upgradeTo}. For an externally upgradeable proxy see
    262.  * {TransparentUpgradeableProxy}.
    263.  */
    264. contract UpgradeableProxy is Proxy {
    265.     /**
    266.      * @dev Initializes the upgradeable proxy with an initial implementation specified by `_logic`.
    267.      * 
    268.      * If `_data` is nonempty, it's used as data in a delegate call to `_logic`. This will typically be an encoded
    269.      * function call, and allows initializating the storage of the proxy like a Solidity constructor.
    270.      */
    271.     constructor(address _logic, bytes memory _data) public payable {
    272.         assert(_IMPLEMENTATION_SLOT == bytes32(uint256(keccak256("eip1967.proxy.implementation")) - 1));
    273.         _setImplementation(_logic);
    274.         if(_data.length > 0) {
    275.             // solhint-disable-next-line avoid-low-level-calls
    276.             (bool success,) = _logic.delegatecall(_data);
    277.             require(success);
    278.         }
    279.     }
    281.     /**
    282.      * @dev Emitted when the implementation is upgraded.
    283.      */
    284.     event Upgraded(address indexed implementation);
    286.     /**
    287.      * @dev Storage slot with the address of the current implementation.
    288.      * This is the keccak-256 hash of "eip1967.proxy.implementation" subtracted by 1, and is
    289.      * validated in the constructor.
    290.      */
    291.     bytes32 private constant _IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;
    293.     /**
    294.      * @dev Returns the current implementation address.
    295.      */
    296.     function _implementation() internal override view returns (address impl) {
    297.         bytes32 slot = _IMPLEMENTATION_SLOT;
    298.         // solhint-disable-next-line no-inline-assembly
    299.         assembly {
    300.             impl := sload(slot)
    301.         }
    302.     }
    304.     /**
    305.      * @dev Upgrades the proxy to a new implementation.
    306.      * 
    307.      * Emits an {Upgraded} event.
    308.      */
    309.     function _upgradeTo(address newImplementation) internal {
    310.         _setImplementation(newImplementation);
    311.         emit Upgraded(newImplementation);
    312.     }
    314.     /**
    315.      * @dev Stores a new address in the EIP1967 implementation slot.
    316.      */
    317.     function _setImplementation(address newImplementation) private {
    318.         require(Address.isContract(newImplementation), "UpgradeableProxy: new implementation is not a contract");
    320.         bytes32 slot = _IMPLEMENTATION_SLOT;
    322.         // solhint-disable-next-line no-inline-assembly
    323.         assembly {
    324.             sstore(slot, newImplementation)
    325.         }
    326.     }
    327. }
    329. // File: @openzeppelin/contracts/proxy/TransparentUpgradeableProxy.sol
    333. pragma solidity ^0.6.0;
    336. /**
    337.  * @dev This contract implements a proxy that is upgradeable by an admin.
    338.  * 
    339.  * To avoid https://medium.com/nomic-labs-blog/malicious-backdoors-in-ethereum-proxies-62629adf3357[proxy selector
    340.  * clashing], which can potentially be used in an attack, this contract uses the
    341.  * https://blog.openzeppelin.com/the-transparent-proxy-pattern/[transparent proxy pattern]. This pattern implies two
    342.  * things that go hand in hand:
    343.  * 
    344.  * 1. If any account other than the admin calls the proxy, the call will be forwarded to the implementation, even if
    345.  * that call matches one of the admin functions exposed by the proxy itself.
    346.  * 2. If the admin calls the proxy, it can access the admin functions, but its calls will never be forwarded to the
    347.  * implementation. If the admin tries to call a function on the implementation it will fail with an error that says
    348.  * "admin cannot fallback to proxy target".
    349.  * 
    350.  * These properties mean that the admin account can only be used for admin actions like upgrading the proxy or changing
    351.  * the admin, so it's best if it's a dedicated account that is not used for anything else. This will avoid headaches due
    352.  * to sudden errors when trying to call a function from the proxy implementation.
    353.  * 
    354.  * Our recommendation is for the dedicated account to be an instance of the {ProxyAdmin} contract. If set up this way,
    355.  * you should think of the `ProxyAdmin` instance as the real administrative inerface of your proxy.
    356.  */
    357. contract TransparentUpgradeableProxy is UpgradeableProxy {
    358.     /**
    359.      * @dev Initializes an upgradeable proxy managed by `_admin`, backed by the implementation at `_logic`, and
    360.      * optionally initialized with `_data` as explained in {UpgradeableProxy-constructor}.
    361.      */
    362.     constructor(address _logic, address _admin, bytes memory _data) public payable UpgradeableProxy(_logic, _data) {
    363.         assert(_ADMIN_SLOT == bytes32(uint256(keccak256("eip1967.proxy.admin")) - 1));
    364.         _setAdmin(_admin);
    365.     }
    367.     /**
    368.      * @dev Emitted when the admin account has changed.
    369.      */
    370.     event AdminChanged(address previousAdmin, address newAdmin);
    372.     /**
    373.      * @dev Storage slot with the admin of the contract.
    374.      * This is the keccak-256 hash of "eip1967.proxy.admin" subtracted by 1, and is
    375.      * validated in the constructor.
    376.      */
    377.     bytes32 private constant _ADMIN_SLOT = 0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103;
    379.     /**
    380.      * @dev Modifier used internally that will delegate the call to the implementation unless the sender is the admin.
    381.      */
    382.     modifier ifAdmin() {
    383.         if (msg.sender == _admin()) {
    384.             _;
    385.         } else {
    386.             _fallback();
    387.         }
    388.     }
    390.     /**
    391.      * @dev Returns the current admin.
    392.      * 
    393.      * NOTE: Only the admin can call this function. See {ProxyAdmin-getProxyAdmin}.
    394.      * 
    395.      * TIP: To get this value clients can read directly from the storage slot shown below (specified by EIP1967) using the
    396.      * https://eth.wiki/json-rpc/API#eth_getstorageat[`eth_getStorageAt`] RPC call.
    397.      * `0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103`
    398.      */
    399.     function admin() external ifAdmin returns (address) {
    400.         return _admin();
    401.     }
    403.     /**
    404.      * @dev Returns the current implementation.
    405.      * 
    406.      * NOTE: Only the admin can call this function. See {ProxyAdmin-getProxyImplementation}.
    407.      * 
    408.      * TIP: To get this value clients can read directly from the storage slot shown below (specified by EIP1967) using the
    409.      * https://eth.wiki/json-rpc/API#eth_getstorageat[`eth_getStorageAt`] RPC call.
    410.      * `0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc`
    411.      */
    412.     function implementation() external ifAdmin returns (address) {
    413.         return _implementation();
    414.     }
    416.     /**
    417.      * @dev Changes the admin of the proxy.
    418.      * 
    419.      * Emits an {AdminChanged} event.
    420.      * 
    421.      * NOTE: Only the admin can call this function. See {ProxyAdmin-changeProxyAdmin}.
    422.      */
    423.     function changeAdmin(address newAdmin) external ifAdmin {
    424.         require(newAdmin != address(0), "TransparentUpgradeableProxy: new admin is the zero address");
    425.         emit AdminChanged(_admin(), newAdmin);
    426.         _setAdmin(newAdmin);
    427.     }
    429.     /**
    430.      * @dev Upgrade the implementation of the proxy.
    431.      * 
    432.      * NOTE: Only the admin can call this function. See {ProxyAdmin-upgrade}.
    433.      */
    434.     function upgradeTo(address newImplementation) external ifAdmin {
    435.         _upgradeTo(newImplementation);
    436.     }
    438.     /**
    439.      * @dev Upgrade the implementation of the proxy, and then call a function from the new implementation as specified
    440.      * by `data`, which should be an encoded function call. This is useful to initialize new storage variables in the
    441.      * proxied contract.
    442.      * 
    443.      * NOTE: Only the admin can call this function. See {ProxyAdmin-upgradeAndCall}.
    444.      */
    445.     function upgradeToAndCall(address newImplementation, bytes calldata data) external payable ifAdmin {
    446.         _upgradeTo(newImplementation);
    447.         // solhint-disable-next-line avoid-low-level-calls
    448.         (bool success,) = newImplementation.delegatecall(data);
    449.         require(success);
    450.     }
    452.     /**
    453.      * @dev Returns the current admin.
    454.      */
    455.     function _admin() internal view returns (address adm) {
    456.         bytes32 slot = _ADMIN_SLOT;
    457.         // solhint-disable-next-line no-inline-assembly
    458.         assembly {
    459.             adm := sload(slot)
    460.         }
    461.     }
    463.     /**
    464.      * @dev Stores a new address in the EIP1967 admin slot.
    465.      */
    466.     function _setAdmin(address newAdmin) private {
    467.         bytes32 slot = _ADMIN_SLOT;
    469.         // solhint-disable-next-line no-inline-assembly
    470.         assembly {
    471.             sstore(slot, newAdmin)
    472.         }
    473.     }
    475.     /**
    476.      * @dev Makes sure the admin cannot access the fallback function. See {Proxy-_beforeFallback}.
    477.      */
    478.     function _beforeFallback() internal override virtual {
    479.         require(msg.sender != _admin(), "TransparentUpgradeableProxy: admin cannot fallback to proxy target");
    480.         super._beforeFallback();
    481.     }
    482. }
    484. // File: torn-token/contracts/ENS.sol
    488. pragma solidity ^0.6.0;
    490. interface ENS {
    491.   function resolver(bytes32 node) external view returns (Resolver);
    492. }
    494. interface Resolver {
    495.   function addr(bytes32 node) external view returns (address);
    496. }
    498. contract EnsResolve {
    499.   function resolve(bytes32 node) public view virtual returns (address) {
    500.     ENS Registry = ENS(
    501.       getChainId() == 1 ? 0x00000000000C2E074eC69A0dFb2997BA6C7d2e1e : 0x8595bFb0D940DfEDC98943FA8a907091203f25EE
    502.     );
    503.     return Registry.resolver(node).addr(node);
    504.   }
    506.   function bulkResolve(bytes32[] memory domains) public view returns (address[] memory result) {
    507.     result = new address[](domains.length);
    508.     for (uint256 i = 0; i < domains.length; i++) {
    509.       result[i] = resolve(domains[i]);
    510.     }
    511.   }
    513.   function getChainId() internal pure returns (uint256) {
    514.     uint256 chainId;
    515.     assembly {
    516.       chainId := chainid()
    517.     }
    518.     return chainId;
    519.   }
    520. }
    522. // File: contracts/LoopbackProxy.sol
    525. pragma solidity ^0.6.0;
    529. /**
    530.  * @dev TransparentUpgradeableProxy that sets its admin to the implementation itself.
    531.  * It is also allowed to call implementation methods.
    532.  */
    533. contract LoopbackProxy is TransparentUpgradeableProxy, EnsResolve {
    534.   /**
    535.    * @dev Initializes an upgradeable proxy backed by the implementation at `_logic`.
    536.    */
    537.   constructor(bytes32 _logic, bytes memory _data)
    538.     public
    539.     payable
    540.     TransparentUpgradeableProxy(resolve(_logic), address(this), _data)
    541.   {}
    543.   /**
    544.    * @dev Override to allow admin (itself) access the fallback function.
    545.    */
    546.   function _beforeFallback() internal override {}
    547. }