1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
pragma solidity ^0.6.0;
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC20/SafeERC20.sol";
import "@openzeppelin/contracts/utils/Address.sol";
import "../Constants.sol";
contract CommonAdapter {
    using SafeERC20 for IERC20;
    using Address for address;
    using Address for address payable;
    /**
     * @dev Performs a swap
     * @param recipient The original msg.sender performing the swap
     * @param aggregator Address of the aggregator's contract
     * @param spender Address to which tokens will be approved
     * @param method Selector of the function to be called in the aggregator's contract
     * @param tokenFrom Token to be swapped
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

1
{"Constants.84ef19f8.sol":{"content":"// SPDX-License-Identifier: MIT\r\n\r\npragma solidity ^0.6.0;\r\n\r\nlibrary Constants {\r\n    address internal 
    constant ETH = 0x0000000000000000000000000000000000000000;\r\n}\r\n"},"Spender.3372a096.sol":{"content":"// SPDX-License-Identifier: 
    MIT\r\n\r\npragma solidity ^0.6.0;\r\n\r\nimport \"./Constants.84ef19f8.sol\";\r\n\r\ncontract Spender {\r\n    address public immutable metaswap
    ;\r\n\r\n    constructor() public {\r\n        metaswap = msg.sender;\r\n    }\r\n\r\n    /// @dev Receives ether from swaps\r\n    fallback() 
    external payable {}\r\n\r\n    function swap(address adapter, bytes calldata data) external payable {\r\n        require(msg.sender == metaswap, 
    \"FORBIDDEN\");\r\n        require(adapter != address(0), \"ADAPTER_NOT_PROVIDED\");\r\n        _delegate(adapter, data, 
    \"ADAPTER_DELEGATECALL_FAILED\");\r\n    }\r\n\r\n    /**\r\n     * @dev Performs a delegatecall and bubbles up the errors, adapted from\r\n     * 
    https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/utils/Address.sol\r\n     * @param target Address of the contract to 
    delegatecall\r\n     * @param data Data passed in the delegatecall\r\n     * @param errorMessage Fallback revert reason\r\n     */\r\n    function 
    _delegate(\r\n        address target,\r\n        bytes memory data,\r\n        string memory errorMessage\r\n    ) private returns (bytes memory) 
    {\r\n        // solhint-disable-next-line avoid-low-level-calls\r\n        (bool success, bytes memory returndata) = target.delegatecall(data);\r\n 
           if (success) {\r\n            return returndata;\r\n        } else {\r\n            // Look for revert reason and bubble it up if 
    present\r\n            if (returndata.length \u003e 0) {\r\n                // The easiest way to bubble the revert reason is using memory via 
    assembly\r\n\r\n                // solhint-disable-next-line no-inline-assembly\r\n                assembly {\r\n                    let 
    returndata_size := mload(returndata)\r\n                    revert(add(32, returndata), returndata_size)\r\n                }\r\n            } else 
    {\r\n                revert(errorMessage);\r\n            }\r\n        }\r\n    }\r\n}\r\n"}}
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

1
{"EIP20.sol":{"content":"/*\nImplements EIP20 token standard: https://github.com/ethereum/EIPs/blob/master/EIPS/eip-20.md\nOriginal code by Consensys: 
    https://github.com/ConsenSys/Tokens/blob/master/contracts/eip20/EIP20.sol\nWith modifications according to aleph.im needs (batch transfer, permit
    ...)\n.*/\n\n\npragma solidity ^0.5.16;\n\nimport \"./EIP20Interface.sol\";\n\n\ncontract EIP20 is EIP20Interface {\n\n    uint256 constant private 
    MAX_UINT256 = 2**256 - 1;\n    mapping (address =\u003e uint256) public balances;\n    mapping (address =\u003e mapping (address =\u003e uint256)) 
    public allowed;\n    /*\n    NOTE:\n    The following variables are OPTIONAL vanities. One does not have to include them.\n    They allow one to 
    customise the token contract \u0026 in no way influences the core functionality.\n    Some wallets/interfaces might not even bother to look at this 
    information.\n    */\n    string public name;                   //fancy name: eg Simon Bucks\n    uint8 public decimals;                //How many 
    decimals to show.\n    string public symbol;                 //An identifier: eg SBX\n\n    bytes32 public DOMAIN_SEPARATOR;\n    // keccak256
    (\"Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)\");\n    bytes32 public constant PERMIT_TYPEHASH = 
    0x6e71edae12b1b97f4d1f60370fef10105fa2faae0126114a169c64845d6126c9;\n\n    mapping(address =\u003e uint) public nonces;\n\n    constructor(\n      
      uint256 _initialAmount,\n        string memory _tokenName,\n        uint8 _decimalUnits,\n        string memory _tokenSymbol\n    ) public {\n   
         uint chainId;\n        assembly {\n            chainId := chainid\n        }\n        \n        balances[msg.sender] = _initialAmount;        
           // Give the creator all initial tokens\n        totalSupply = _initialAmount;                        // Update total supply\n        name = 
    _tokenName;                                   // Set the name for display purposes\n        decimals = _decimalUnits;                            // 
    Amount of decimals for display purposes\n        symbol = _tokenSymbol;                               // Set the symbol for display purposes\n\n   
         DOMAIN_SEPARATOR = keccak256(\n            abi.encode(\n                keccak256(\u0027EIP712Domain(string name,string version,uint256 
    chainId,address verifyingContract)\u0027),\n                keccak256(bytes(name)),\n                keccak256(bytes(\u00271\u0027)),\n            
        chainId,\n                address(this)\n            )\n        );\n    }\n\n    function transfer(address _to, uint256 _value) public returns 
    (bool success) {\n        require(balances[msg.sender] \u003e= _value);\n        balances[msg.sender] -= _value;\n        balances[_to] += _value
    ;\n        emit Transfer(msg.sender, _to, _value); //solhint-disable-line indent, no-unused-vars\n        return true;\n    }\n\n    function 
    transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {\n        uint256 allowance = allowed[_from][msg.sender];\n 
           require(balances[_from] \u003e= _value \u0026\u0026 allowance \u003e= _value);\n        balances[_to] += _value;\n        balances[_from] -= 
    _value;\n        if (allowance \u003c MAX_UINT256) {\n            allowed[_from][msg.sender] -= _value;\n        }\n        emit Transfer(_from, 
    _to, _value); //solhint-disable-line indent, no-unused-vars\n        return true;\n    }\n\n    function balanceOf(address _owner) public view 
    returns (uint256 balance) {\n        return balances[_owner];\n    }\n\n    function _approve(address owner, address spender, uint value) private 
    {\n        allowed[owner][spender] = value;\n        emit Approval(owner, spender, value);\n    }\n\n    function approve(address _spender, uint256 
    _value) public returns (bool success) {\n        _approve(msg.sender, _spender, _value);\n        return true;\n    }\n\n    function allowance
    (address _owner, address _spender) public view returns (uint256 remaining) {\n        return allowed[_owner][_spender];\n    }\n\n    function 
    batchTransfer(address[] memory _targets, uint256[] memory _values) public returns (bool success) {\n        uint8 i = 0;\n        for (i; i \u003c 
    _targets.length; i++) {\n            transfer(_targets[i], _values[i]);\n        }\n        return true;\n    }\n\n    function batchTransferFrom
    (address _from, address[] memory _targets, uint256[] memory _values) public returns (bool success) {\n        uint8 i = 0;\n        for (i; i 
    \u003c _targets.length; i++) {\n            transferFrom(_from, _targets[i], _values[i]);\n        }\n        return true;\n    }\n\n    function 
    permit(address owner, address spender, uint value, uint deadline, uint8 v, bytes32 r, bytes32 s) external {\n        require(deadline \u003e= block
    .timestamp, \u0027PERMIT: EXPIRED\u0027);\n        bytes32 digest = keccak256(\n            abi.encodePacked(\n                
    \u0027\\x19\\x01\u0027,\n                DOMAIN_SEPARATOR,\n                keccak256(abi.encode(PERMIT_TYPEHASH, owner, spender, value, 
    nonces[owner]++, deadline))\n            )\n        );\n        address recoveredAddress = ecrecover(digest, v, r, s);\n        require
    (recoveredAddress != address(0) \u0026\u0026 recoveredAddress == owner, \u0027PERMIT: INVALID_SIGNATURE\u0027);\n        _approve(owner, spender, 
    value);\n    }\n}\n"},"EIP20Interface.sol":{"content":"// Abstract contract for the full ERC 20 Token standard\n// https://github.com/ethereum/EIPs
    /blob/master/EIPS/eip-20.md\n// Original code by Consensys: https://github.com/ConsenSys/Tokens/blob/master/contracts/eip20/EIP20Interface
    .sol\npragma solidity ^0.5.16;\n\n\ncontract EIP20Interface {\n    /* This is a slight change to the ERC20 base standard.\n    function totalSupply
    () constant returns (uint256 supply);\n    is replaced with:\n    uint256 public totalSupply;\n    This automatically creates a getter function for 
    the totalSupply.\n    This is moved to the base contract since public getter functions are not\n    currently recognised as an implementation of 
    the matching abstract\n    function by the compiler.\n    */\n    /// total amount of tokens\n    uint256 public totalSupply;\n\n    /// @param 
    _owner The address from which the balance will be retrieved\n    /// @return The balance\n    function balanceOf(address _owner) public view 
    returns (uint256 balance);\n\n    /// @notice send `_value` token to `_to` from `msg.sender`\n    /// @param _to The address of the recipient\n    
    /// @param _value The amount of token to be transferred\n    /// @return Whether the transfer was successful or not\n    function transfer(address 
    _to, uint256 _value) public returns (bool success);\n\n    /// @notice send `_value` token to `_to` from `_from` on the condition it is approved by 
    `_from`\n    /// @param _from The address of the sender\n    /// @param _to The address of the recipient\n    /// @param _value The amount of token 
    to be transferred\n    /// @return Whether the transfer was successful or not\n    function transferFrom(address _from, address _to, uint256 _value
    ) public returns (bool success);\n\n    /// @notice `msg.sender` approves `_spender` to spend `_value` tokens\n    /// @param _spender The address 
    of the account able to transfer the tokens\n    /// @param _value The amount of tokens to be approved for transfer\n    /// @return Whether the 
    approval was successful or not\n    function approve(address _spender, uint256 _value) public returns (bool success);\n\n    /// @param _owner The 
    address of the account owning tokens\n    /// @param _spender The address of the account able to transfer the tokens\n    /// @return Amount of 
    remaining tokens allowed to spent\n    function allowance(address _owner, address _spender) public view returns (uint256 remaining);\n\n    // 
    solhint-disable-next-line no-simple-event-func-name\n    event Transfer(address indexed _from, address indexed _to, uint256 _value);\n    event 
    Approval(address indexed _owner, address indexed _spender, uint256 _value);\n\n\n    function DOMAIN_SEPARATOR() external view returns (bytes32);\n 
       function PERMIT_TYPEHASH() external pure returns (bytes32);\n    function nonces(address owner) external view returns (uint);\n}\n"}}
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
/*
  Copyright 2020 ZeroEx Intl.
  Licensed under the Apache License, Version 2.0 (the "License");
  you may not use this file except in compliance with the License.
  You may obtain a copy of the License at
    http://www.apache.org/licenses/LICENSE-2.0
  Unless required by applicable law or agreed to in writing, software
  distributed under the License is distributed on an "AS IS" BASIS,
  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  See the License for the specific language governing permissions and
  limitations under the License.
*/
pragma solidity ^0.6.5;
pragma experimental ABIEncoderV2;
import "@0x/contracts-utils/contracts/src/v06/LibBytesV06.sol";
import "./migrations/LibBootstrap.sol";
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
// Copyright (C) 2015, 2016, 2017 Dapphub
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
pragma solidity ^0.4.18;
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
// SPDX-License-Identifier: Apache-2.0
/*
  Copyright 2021 ZeroEx Intl.
  Licensed under the Apache License, Version 2.0 (the "License");
  you may not use this file except in compliance with the License.
  You may obtain a copy of the License at
    http://www.apache.org/licenses/LICENSE-2.0
  Unless required by applicable law or agreed to in writing, software
  distributed under the License is distributed on an "AS IS" BASIS,
  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  See the License for the specific language governing permissions and
  limitations under the License.
*/
pragma solidity ^0.6.5;
pragma experimental ABIEncoderV2;
import "@0x/contracts-erc20/contracts/src/v06/IERC20TokenV06.sol";
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX