{{ "language": "Solidity", "sources": { "/Users/amir/github/0xproject/0x-monorepo/contracts/asset-proxy/contracts/archive/MixinAssetProxyDispatcher.sol": { "content": "/*\n\n Copyright 2019 ZeroEx Intl.\n\n Licensed under the Apache License, Version 2.0 (the \"License\");\n you may not use this file except in compliance with the License.\n You may obtain a copy of the License at\n\n http://www.apache.org/licenses/LICENSE-2.0\n\n Unless required by applicable law or agreed to in writing, software\n distributed under the License is distributed on an \"AS IS\" BASIS,\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n See the License for the specific language governing permissions and\n limitations under the License.\n\n*/\n\npragma solidity ^0.5.9;\n\nimport \"../archive/Ownable.sol\";\nimport \"../src/interfaces/IAssetProxy.sol\";\nimport \"../src/interfaces/IAssetProxyDispatcher.sol\";\n\n\ncontract MixinAssetProxyDispatcher is\n Ownable,\n IAssetProxyDispatcher\n{\n // Mapping from Asset Proxy Id's to their respective Asset Proxy\n mapping (bytes4 => address) public assetProxies;\n\n /// @dev Registers an asset proxy to its asset proxy id.\n /// Once an asset proxy is registered, it cannot be unregistered.\n /// @param assetProxy Address of new asset proxy to register.\n function registerAssetProxy(address assetProxy)\n external\n onlyOwner\n {\n // Ensure that no asset proxy exists with current id.\n bytes4 assetProxyId = IAssetProxy(assetProxy).getProxyId();\n address currentAssetProxy = assetProxies[assetProxyId];\n require(\n currentAssetProxy == address(0),\n \"ASSET_PROXY_ALREADY_EXISTS\"\n );\n\n // Add asset proxy and log registration.\n assetProxies[assetProxyId] = assetProxy;\n emit AssetProxyRegistered(\n assetProxyId,\n assetProxy\n );\n }\n\n /// @dev Gets an asset proxy.\n /// @param assetProxyId Id of the asset proxy.\n /// @return The asset proxy registered to assetProxyId. Returns 0x0 if no proxy is registered.\n function getAssetProxy(bytes4 assetProxyId)\n external\n view\n returns (address)\n {\n return assetProxies[assetProxyId];\n }\n\n /// @dev Forwards arguments to assetProxy and calls `transferFrom`. Either succeeds or throws.\n /// @param assetData Byte array encoded for the asset.\n /// @param from Address to transfer token from.\n /// @param to Address to transfer token to.\n /// @param amount Amount of token to transfer.\n function _dispatchTransferFrom(\n bytes memory assetData,\n address from,\n address to,\n uint256 amount\n )\n internal\n {\n // Do nothing if no amount should be transferred.\n if (amount > 0 && from != to) {\n // Ensure assetData length is valid\n require(\n assetData.length > 3,\n \"LENGTH_GREATER_THAN_3_REQUIRED\"\n );\n\n // Lookup assetProxy. We do not use `LibBytes.readBytes4` for gas efficiency reasons.\n bytes4 assetProxyId;\n assembly {\n assetProxyId := and(mload(\n add(assetData, 32)),\n 0xFFFFFFFF00000000000000000000000000000000000000000000000000000000\n )\n }\n address assetProxy = assetProxies[assetProxyId];\n\n // Ensure that assetProxy exists\n require(\n assetProxy != address(0),\n \"ASSET_PROXY_DOES_NOT_EXIST\"\n );\n\n // We construct calldata for the `assetProxy.transferFrom` ABI.\n // The layout of this calldata is in the table below.\n //\n // | Area | Offset | Length | Contents |\n // | -------- |--------|---------|-------------------------------------------- |\n // | Header | 0 | 4 | function selector |\n // | Params | | 4 * 32 | function parameters: |\n // | | 4 | | 1. offset to assetData (*) |\n // | | 36 | | 2. from |\n // | | 68 | | 3. to |\n // | | 100 | | 4. amount |\n // | Data | | | assetData: |\n // | | 132 | 32 | assetData Length |\n // | | 164 | ** | assetData Contents |\n\n assembly {\n /////// Setup State ///////\n // `cdStart` is the start of the calldata for `assetProxy.transferFrom` (equal to free memory ptr).\n let cdStart := mload(64)\n // `dataAreaLength` is the total number of words needed to store `assetData`\n // As-per the ABI spec, this value is padded up to the nearest multiple of 32,\n // and includes 32-bytes for length.\n let dataAreaLength := and(add(mload(assetData), 63), 0xFFFFFFFFFFFE0)\n // `cdEnd` is the end of the calldata for `assetProxy.transferFrom`.\n let cdEnd := add(cdStart, add(132, dataAreaLength))\n\n\n /////// Setup Header Area ///////\n // This area holds the 4-byte `transferFromSelector`.\n // bytes4(keccak256(\"transferFrom(bytes,address,address,uint256)\")) = 0xa85e59e4\n mstore(cdStart, 0xa85e59e400000000000000000000000000000000000000000000000000000000)\n\n /////// Setup Params Area ///////\n // Each parameter is padded to 32-bytes. The entire Params Area is 128 bytes.\n // Notes:\n // 1. The offset to `assetData` is the length of the Params Area (128 bytes).\n // 2. A 20-byte mask is applied to addresses to zero-out the unused bytes.\n mstore(add(cdStart, 4), 128)\n mstore(add(cdStart, 36), and(from, 0xffffffffffffffffffffffffffffffffffffffff))\n mstore(add(cdStart, 68), and(to, 0xffffffffffffffffffffffffffffffffffffffff))\n mstore(add(cdStart, 100), amount)\n\n /////// Setup Data Area ///////\n // This area holds `assetData`.\n let dataArea := add(cdStart, 132)\n // solhint-disable-next-line no-empty-blocks\n for {} lt(dataArea, cdEnd) {} {\n mstore(dataArea, mload(assetData))\n dataArea := add(dataArea, 32)\n assetData := add(assetData, 32)\n }\n\n /////// Call `assetProxy.transferFrom` using the constructed calldata ///////\n let success := call(\n gas, // forward all gas\n assetProxy, // call address of asset proxy\n 0, // don't send any ETH\n cdStart, // pointer to start of input\n sub(cdEnd, cdStart), // length of input\n cdStart, // write output over input\n 512 // reserve 512 bytes for output\n )\n if iszero(success) {\n revert(cdStart, returndatasize())\n }\n }\n }\n }\n}\n" }, "/Users/amir/github/0xproject/0x-monorepo/contracts/asset-proxy/contracts/archive/Ownable.sol": { "content": "pragma solidity ^0.5.9;\n\nimport \"@0x/contracts-utils/contracts/src/interfaces/IOwnable.sol\";\n\n\ncontract Ownable is\n IOwnable\n{\n address public owner;\n\n constructor ()\n public\n {\n owner = msg.sender;\n }\n\n modifier onlyOwner() {\n require(\n msg.sender == owner,\n \"ONLY_CONTRACT_OWNER\"\n );\n _;\n }\n\n function transferOwnership(address newOwner)\n public\n onlyOwner\n {\n if (newOwner != address(0)) {\n owner = newOwner;\n }\n }\n}\n" }, "/Users/amir/github/0xproject/0x-monorepo/contracts/asset-proxy/node_modules/@0x/contracts-utils/contracts/src/interfaces/IOwnable.sol": { "content": "/*\n\n Copyright 2019 ZeroEx Intl.\n\n Licensed under the Apache License, Version 2.0 (the \"License\");\n you may not use this file except in compliance with the License.\n You may obtain a copy of the License at\n\n http://www.apache.org/licenses/LICENSE-2.0\n\n Unless required by applicable law or agreed to in writing, software\n distributed under the License is distributed on an \"AS IS\" BASIS,\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n See the License for the specific language governing permissions and\n limitations under the License.\n\n*/\n\npragma solidity ^0.5.9;\n\n\ncontract IOwnable {\n\n /// @dev Emitted by Ownable when ownership is transferred.\n /// @param previousOwner The previous owner of the contract.\n /// @param newOwner The new owner of the contract.\n event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\n\n /// @dev Transfers ownership of the contract to a new address.\n /// @param newOwner The address that will become the owner.\n function transferOwnership(address newOwner)\n public;\n}\n" }, "/Users/amir/github/0xproject/0x-monorepo/contracts/asset-proxy/contracts/src/interfaces/IAssetProxy.sol": { "content": "/*\n\n Copyright 2019 ZeroEx Intl.\n\n Licensed under the Apache License, Version 2.0 (the \"License\");\n you may not use this file except in compliance with the License.\n You may obtain a copy of the License at\n\n http://www.apache.org/licenses/LICENSE-2.0\n\n Unless required by applicable law or agreed to in writing, software\n distributed under the License is distributed on an \"AS IS\" BASIS,\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n See the License for the specific language governing permissions and\n limitations under the License.\n\n*/\n\npragma solidity ^0.5.9;\n\n\ncontract IAssetProxy {\n\n /// @dev Transfers assets. Either succeeds or throws.\n /// @param assetData Byte array encoded for the respective asset proxy.\n /// @param from Address to transfer asset from.\n /// @param to Address to transfer asset to.\n /// @param amount Amount of asset to transfer.\n function transferFrom(\n bytes calldata assetData,\n address from,\n address to,\n uint256 amount\n )\n external;\n \n /// @dev Gets the proxy id associated with the proxy address.\n /// @return Proxy id.\n function getProxyId()\n external\n pure\n returns (bytes4);\n}\n" }, "/Users/amir/github/0xproject/0x-monorepo/contracts/asset-proxy/contracts/src/interfaces/IAssetProxyDispatcher.sol": { "content": "/*\n\n Copyright 2019 ZeroEx Intl.\n\n Licensed under the Apache License, Version 2.0 (the \"License\");\n you may not use this file except in compliance with the License.\n You may obtain a copy of the License at\n\n http://www.apache.org/licenses/LICENSE-2.0\n\n Unless required by applicable law or agreed to in writing, software\n distributed under the License is distributed on an \"AS IS\" BASIS,\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n See the License for the specific language governing permissions and\n limitations under the License.\n\n*/\n\npragma solidity ^0.5.9;\n\n\ncontract IAssetProxyDispatcher {\n\n // Logs registration of new asset proxy\n event AssetProxyRegistered(\n bytes4 id, // Id of new registered AssetProxy.\n address assetProxy // Address of new registered AssetProxy.\n );\n\n /// @dev Registers an asset proxy to its asset proxy id.\n /// Once an asset proxy is registered, it cannot be unregistered.\n /// @param assetProxy Address of new asset proxy to register.\n function registerAssetProxy(address assetProxy)\n external;\n\n /// @dev Gets an asset proxy.\n /// @param assetProxyId Id of the asset proxy.\n /// @return The asset proxy registered to assetProxyId. Returns 0x0 if no proxy is registered.\n function getAssetProxy(bytes4 assetProxyId)\n external\n view\n returns (address);\n}\n" }, "/Users/amir/github/0xproject/0x-monorepo/contracts/asset-proxy/contracts/archive/MixinAuthorizable.sol": { "content": "/*\n\n Copyright 2019 ZeroEx Intl.\n\n Licensed under the Apache License, Version 2.0 (the \"License\");\n you may not use this file except in compliance with the License.\n You may obtain a copy of the License at\n\n http://www.apache.org/licenses/LICENSE-2.0\n\n Unless required by applicable law or agreed to in writing, software\n distributed under the License is distributed on an \"AS IS\" BASIS,\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n See the License for the specific language governing permissions and\n limitations under the License.\n\n*/\n\npragma solidity ^0.5.9;\n\nimport \"../archive/Ownable.sol\";\nimport \"../src/interfaces/IAuthorizable.sol\";\n\n\ncontract MixinAuthorizable is\n Ownable,\n IAuthorizable\n{\n /// @dev Only authorized addresses can invoke functions with this modifier.\n modifier onlyAuthorized {\n require(\n authorized[msg.sender],\n \"SENDER_NOT_AUTHORIZED\"\n );\n _;\n }\n\n mapping (address => bool) public authorized;\n address[] public authorities;\n\n /// @dev Authorizes an address.\n /// @param target Address to authorize.\n function addAuthorizedAddress(address target)\n external\n onlyOwner\n {\n require(\n !authorized[target],\n \"TARGET_ALREADY_AUTHORIZED\"\n );\n\n authorized[target] = true;\n authorities.push(target);\n emit AuthorizedAddressAdded(target, msg.sender);\n }\n\n /// @dev Removes authorizion of an address.\n /// @param target Address to remove authorization from.\n function removeAuthorizedAddress(address target)\n external\n onlyOwner\n {\n require(\n authorized[target],\n \"TARGET_NOT_AUTHORIZED\"\n );\n\n delete authorized[target];\n for (uint256 i = 0; i < authorities.length; i++) {\n if (authorities[i] == target) {\n authorities[i] = authorities[authorities.length - 1];\n authorities.length -= 1;\n break;\n }\n }\n emit AuthorizedAddressRemoved(target, msg.sender);\n }\n\n /// @dev Removes authorizion of an address.\n /// @param target Address to remove authorization from.\n /// @param index Index of target in authorities array.\n function removeAuthorizedAddressAtIndex(\n address target,\n uint256 index\n )\n external\n onlyOwner\n {\n require(\n authorized[target],\n \"TARGET_NOT_AUTHORIZED\"\n );\n require(\n index < authorities.length,\n \"INDEX_OUT_OF_BOUNDS\"\n );\n require(\n authorities[index] == target,\n \"AUTHORIZED_ADDRESS_MISMATCH\"\n );\n\n delete authorized[target];\n authorities[index] = authorities[authorities.length - 1];\n authorities.length -= 1;\n emit AuthorizedAddressRemoved(target, msg.sender);\n }\n\n /// @dev Gets all authorized addresses.\n /// @return Array of authorized addresses.\n function getAuthorizedAddresses()\n external\n view\n returns (address[] memory)\n {\n return authorities;\n }\n}\n" }, "/Users/amir/github/0xproject/0x-monorepo/contracts/asset-proxy/contracts/src/interfaces/IAuthorizable.sol": { "content": "/*\n\n Copyright 2019 ZeroEx Intl.\n\n Licensed under the Apache License, Version 2.0 (the \"License\");\n you may not use this file except in compliance with the License.\n You may obtain a copy of the License at\n\n http://www.apache.org/licenses/LICENSE-2.0\n\n Unless required by applicable law or agreed to in writing, software\n distributed under the License is distributed on an \"AS IS\" BASIS,\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n See the License for the specific language governing permissions and\n limitations under the License.\n\n*/\n\npragma solidity ^0.5.9;\n\nimport \"@0x/contracts-utils/contracts/src/interfaces/IOwnable.sol\";\n\n\ncontract IAuthorizable is\n IOwnable\n{\n // Event logged when a new address is authorized.\n event AuthorizedAddressAdded(\n address indexed target,\n address indexed caller\n );\n\n // Event logged when a currently authorized address is unauthorized.\n event AuthorizedAddressRemoved(\n address indexed target,\n address indexed caller\n );\n\n /// @dev Authorizes an address.\n /// @param target Address to authorize.\n function addAuthorizedAddress(address target)\n external;\n\n /// @dev Removes authorizion of an address.\n /// @param target Address to remove authorization from.\n function removeAuthorizedAddress(address target)\n external;\n\n /// @dev Removes authorizion of an address.\n /// @param target Address to remove authorization from.\n /// @param index Index of target in authorities array.\n function removeAuthorizedAddressAtIndex(\n address target,\n uint256 index\n )\n external;\n\n /// @dev Gets all authorized addresses.\n /// @return Array of authorized addresses.\n function getAuthorizedAddresses()\n external\n view\n returns (address[] memory);\n}\n" }, "/Users/amir/github/0xproject/0x-monorepo/contracts/asset-proxy/contracts/src/ERC1155Proxy.sol": { "content": "/*\n\n Copyright 2019 ZeroEx Intl.\n\n Licensed under the Apache License, Version 2.0 (the \"License\");\n you may not use this file except in compliance with the License.\n You may obtain a copy of the License at\n\n http://www.apache.org/licenses/LICENSE-2.0\n\n Unless required by applicable law or agreed to in writing, software\n distributed under the License is distributed on an \"AS IS\" BASIS,\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n See the License for the specific language governing permissions and\n limitations under the License.\n\n*/\n\npragma solidity ^0.5.9;\n\nimport \"@0x/contracts-utils/contracts/src/LibBytes.sol\";\nimport \"@0x/contracts-utils/contracts/src/LibSafeMath.sol\";\nimport \"@0x/contracts-erc1155/contracts/src/interfaces/IERC1155.sol\";\nimport \"../archive/MixinAuthorizable.sol\";\nimport \"./interfaces/IAssetProxy.sol\";\n\n\ncontract ERC1155Proxy is\n MixinAuthorizable,\n IAssetProxy\n{\n using LibBytes for bytes;\n using LibSafeMath for uint256;\n\n // Id of this proxy.\n bytes4 constant internal PROXY_ID = bytes4(keccak256(\"ERC1155Assets(address,uint256[],uint256[],bytes)\"));\n\n /// @dev Transfers batch of ERC1155 assets. Either succeeds or throws.\n /// @param assetData Byte array encoded with ERC1155 token address, array of ids, array of values, and callback data.\n /// @param from Address to transfer assets from.\n /// @param to Address to transfer assets to.\n /// @param amount Amount that will be multiplied with each element of `assetData.values` to scale the\n /// values that will be transferred.\n function transferFrom(\n bytes calldata assetData,\n address from,\n address to,\n uint256 amount\n )\n external\n onlyAuthorized\n {\n // Decode params from `assetData`\n // solhint-disable indent\n (\n address erc1155TokenAddress,\n uint256[] memory ids,\n uint256[] memory values,\n bytes memory data\n ) = abi.decode(\n assetData.sliceDestructive(4, assetData.length),\n (address, uint256[], uint256[], bytes)\n );\n // solhint-enable indent\n\n // Scale values up by `amount`\n uint256 length = values.length;\n uint256[] memory scaledValues = new uint256[](length);\n for (uint256 i = 0; i != length; i++) {\n // We write the scaled values to an unused location in memory in order\n // to avoid copying over `ids` or `data`. This is possible if they are\n // identical to `values` and the offsets for each are pointing to the\n // same location in the ABI encoded calldata.\n scaledValues[i] = values[i].safeMul(amount);\n }\n\n // Execute `safeBatchTransferFrom` call\n // Either succeeds or throws\n IERC1155(erc1155TokenAddress).safeBatchTransferFrom(\n from,\n to,\n ids,\n scaledValues,\n data\n );\n }\n\n /// @dev Gets the proxy id associated with the proxy address.\n /// @return Proxy id.\n function getProxyId()\n external\n pure\n returns (bytes4)\n {\n return PROXY_ID;\n }\n}\n" }, "/Users/amir/github/0xproject/0x-monorepo/contracts/asset-proxy/node_modules/@0x/contracts-utils/contracts/src/LibBytes.sol": { "content": "/*\n\n Copyright 2019 ZeroEx Intl.\n\n Licensed under the Apache License, Version 2.0 (the \"License\");\n you may not use this file except in compliance with the License.\n You may obtain a copy of the License at\n\n http://www.apache.org/licenses/LICENSE-2.0\n\n Unless required by applicable law or agreed to in writing, software\n distributed under the License is distributed on an \"AS IS\" BASIS,\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n See the License for the specific language governing permissions and\n limitations under the License.\n\n*/\n\npragma solidity ^0.5.9;\n\nimport \"./LibBytesRichErrors.sol\";\nimport \"./LibRichErrors.sol\";\n\n\nlibrary LibBytes {\n\n using LibBytes for bytes;\n\n /// @dev Gets the memory address for a byte array.\n /// @param input Byte array to lookup.\n /// @return memoryAddress Memory address of byte array. This\n /// points to the header of the byte array which contains\n /// the length.\n function rawAddress(bytes memory input)\n internal\n pure\n returns (uint256 memoryAddress)\n {\n assembly {\n memoryAddress := input\n }\n return memoryAddress;\n }\n\n /// @dev Gets the memory address for the contents of a byte array.\n /// @param input Byte array to lookup.\n /// @return memoryAddress Memory address of the contents of the byte array.\n function contentAddress(bytes memory input)\n internal\n pure\n returns (uint256 memoryAddress)\n {\n assembly {\n memoryAddress := add(input, 32)\n }\n return memoryAddress;\n }\n\n /// @dev Copies `length` bytes from memory location `source` to `dest`.\n /// @param dest memory address to copy bytes to.\n /// @param source memory address to copy bytes from.\n /// @param length number of bytes to copy.\n function memCopy(\n uint256 dest,\n uint256 source,\n uint256 length\n )\n internal\n pure\n {\n if (length < 32) {\n // Handle a partial word by reading destination and masking\n // off the bits we are interested in.\n // This correctly handles overlap, zero lengths and source == dest\n assembly {\n let mask := sub(exp(256, sub(32, length)), 1)\n let s := and(mload(source), not(mask))\n let d := and(mload(dest), mask)\n mstore(dest, or(s, d))\n }\n } else {\n // Skip the O(length) loop when source == dest.\n if (source == dest) {\n return;\n }\n\n // For large copies we copy whole words at a time. The final\n // word is aligned to the end of the range (instead of after the\n // previous) to handle partial words. So a copy will look like this:\n //\n // ####\n // ####\n // ####\n // ####\n //\n // We handle overlap in the source and destination range by\n // changing the copying direction. This prevents us from\n // overwriting parts of source that we still need to copy.\n //\n // This correctly handles source == dest\n //\n if (source > dest) {\n assembly {\n // We subtract 32 from `sEnd` and `dEnd` because it\n // is easier to compare with in the loop, and these\n // are also the addresses we need for copying the\n // last bytes.\n length := sub(length, 32)\n let sEnd := add(source, length)\n let dEnd := add(dest, length)\n\n // Remember the last 32 bytes of source\n // This needs to be done here and not after the loop\n // because we may have overwritten the last bytes in\n // source already due to overlap.\n let last := mload(sEnd)\n\n // Copy whole words front to back\n // Note: the first check is always true,\n // this could have been a do-while loop.\n // solhint-disable-next-line no-empty-blocks\n for {} lt(source, sEnd) {} {\n mstore(dest, mload(source))\n source := add(source, 32)\n dest := add(dest, 32)\n }\n\n // Write the last 32 bytes\n mstore(dEnd, last)\n }\n } else {\n assembly {\n // We subtract 32 from `sEnd` and `dEnd` because those\n // are the starting points when copying a word at the end.\n length := sub(length, 32)\n let sEnd := add(source, length)\n let dEnd := add(dest, length)\n\n // Remember the first 32 bytes of source\n // This needs to be done here and not after the loop\n // because we may have overwritten the first bytes in\n // source already due to overlap.\n let first := mload(source)\n\n // Copy whole words back to front\n // We use a signed comparisson here to allow dEnd to become\n // negative (happens when source and dest < 32). Valid\n // addresses in local memory will never be larger than\n // 2**255, so they can be safely re-interpreted as signed.\n // Note: the first check is always true,\n // this could have been a do-while loop.\n // solhint-disable-next-line no-empty-blocks\n for {} slt(dest, dEnd) {} {\n mstore(dEnd, mload(sEnd))\n sEnd := sub(sEnd, 32)\n dEnd := sub(dEnd, 32)\n }\n\n // Write the first 32 bytes\n mstore(dest, first)\n }\n }\n }\n }\n\n /// @dev Returns a slices from a byte array.\n /// @param b The byte array to take a slice from.\n /// @param from The starting index for the slice (inclusive).\n /// @param to The final index for the slice (exclusive).\n /// @return result The slice containing bytes at indices [from, to)\n function slice(\n bytes memory b,\n uint256 from,\n uint256 to\n )\n internal\n pure\n returns (bytes memory result)\n {\n // Ensure that the from and to positions are valid positions for a slice within\n // the byte array that is being used.\n if (from > to) {\n LibRichErrors.rrevert(LibBytesRichErrors.InvalidByteOperationError(\n LibBytesRichErrors.InvalidByteOperationErrorCodes.FromLessThanOrEqualsToRequired,\n from,\n to\n ));\n }\n if (to > b.length) {\n LibRichErrors.rrevert(LibBytesRichErrors.InvalidByteOperationError(\n LibBytesRichErrors.InvalidByteOperationErrorCodes.ToLessThanOrEqualsLengthRequired,\n to,\n b.length\n ));\n }\n\n // Create a new bytes structure and copy contents\n result = new bytes(to - from);\n memCopy(\n result.contentAddress(),\n b.contentAddress() + from,\n result.length\n );\n return result;\n }\n\n /// @dev Returns a slice from a byte array without preserving the input.\n /// @param b The byte array to take a slice from. Will be destroyed in the process.\n /// @param from The starting index for the slice (inclusive).\n /// @param to The final index for the slice (exclusive).\n /// @return result The slice containing bytes at indices [from, to)\n /// @dev When `from == 0`, the original array will match the slice. In other cases its state will be corrupted.\n function sliceDestructive(\n bytes memory b,\n uint256 from,\n uint256 to\n )\n internal\n pure\n returns (bytes memory result)\n {\n // Ensure that the from and to positions are valid positions for a slice within\n // the byte array that is being used.\n if (from > to) {\n LibRichErrors.rrevert(LibBytesRichErrors.InvalidByteOperationError(\n LibBytesRichErrors.InvalidByteOperationErrorCodes.FromLessThanOrEqualsToRequired,\n from,\n to\n ));\n }\n if (to > b.length) {\n LibRichErrors.rrevert(LibBytesRichErrors.InvalidByteOperationError(\n LibBytesRichErrors.InvalidByteOperationErrorCodes.ToLessThanOrEqualsLengthRequired,\n to,\n b.length\n ));\n }\n\n // Create a new bytes structure around [from, to) in-place.\n assembly {\n result := add(b, from)\n mstore(result, sub(to, from))\n }\n return result;\n }\n\n /// @dev Pops the last byte off of a byte array by modifying its length.\n /// @param b Byte array that will be modified.\n /// @return The byte that was popped off.\n function popLastByte(bytes memory b)\n internal\n pure\n returns (bytes1 result)\n {\n if (b.length == 0) {\n LibRichErrors.rrevert(LibBytesRichErrors.InvalidByteOperationError(\n LibBytesRichErrors.InvalidByteOperationErrorCodes.LengthGreaterThanZeroRequired,\n b.length,\n 0\n ));\n }\n\n // Store last byte.\n result = b[b.length - 1];\n\n assembly {\n // Decrement length of byte array.\n let newLen := sub(mload(b), 1)\n mstore(b, newLen)\n }\n return result;\n }\n\n /// @dev Tests equality of two byte arrays.\n /// @param lhs First byte array to compare.\n /// @param rhs Second byte array to compare.\n /// @return True if arrays are the same. False otherwise.\n function equals(\n bytes memory lhs,\n bytes memory rhs\n )\n internal\n pure\n returns (bool equal)\n {\n // Keccak gas cost is 30 + numWords * 6. This is a cheap way to compare.\n // We early exit on unequal lengths, but keccak would also correctly\n // handle this.\n return lhs.length == rhs.length && keccak256(lhs) == keccak256(rhs);\n }\n\n /// @dev Reads an address from a position in a byte array.\n /// @param b Byte array containing an address.\n /// @param index Index in byte array of address.\n /// @return address from byte array.\n function readAddress(\n bytes memory b,\n uint256 index\n )\n internal\n pure\n returns (address result)\n {\n if (b.length < index + 20) {\n LibRichErrors.rrevert(LibBytesRichErrors.InvalidByteOperationError(\n LibBytesRichErrors.InvalidByteOperationErrorCodes.LengthGreaterThanOrEqualsTwentyRequired,\n b.length,\n index + 20 // 20 is length of address\n ));\n }\n\n // Add offset to index:\n // 1. Arrays are prefixed by 32-byte length parameter (add 32 to index)\n // 2. Account for size difference between address length and 32-byte storage word (subtract 12 from index)\n index += 20;\n\n // Read address from array memory\n assembly {\n // 1. Add index to address of bytes array\n // 2. Load 32-byte word from memory\n // 3. Apply 20-byte mask to obtain address\n result := and(mload(add(b, index)), 0xffffffffffffffffffffffffffffffffffffffff)\n }\n return result;\n }\n\n /// @dev Writes an address into a specific position in a byte array.\n /// @param b Byte array to insert address into.\n /// @param index Index in byte array of address.\n /// @param input Address to put into byte array.\n function writeAddress(\n bytes memory b,\n uint256 index,\n address input\n )\n internal\n pure\n {\n if (b.length < index + 20) {\n LibRichErrors.rrevert(LibBytesRichErrors.InvalidByteOperationError(\n LibBytesRichErrors.InvalidByteOperationErrorCodes.LengthGreaterThanOrEqualsTwentyRequired,\n b.length,\n index + 20 // 20 is length of address\n ));\n }\n\n // Add offset to index:\n // 1. Arrays are prefixed by 32-byte length parameter (add 32 to index)\n // 2. Account for size difference between address length and 32-byte storage word (subtract 12 from index)\n index += 20;\n\n // Store address into array memory\n assembly {\n // The address occupies 20 bytes and mstore stores 32 bytes.\n // First fetch the 32-byte word where we'll be storing the address, then\n // apply a mask so we have only the bytes in the word that the address will not occupy.\n // Then combine these bytes with the address and store the 32 bytes back to memory with mstore.\n\n // 1. Add index to address of bytes array\n // 2. Load 32-byte word from memory\n // 3. Apply 12-byte mask to obtain extra bytes occupying word of memory where we'll store the address\n let neighbors := and(\n mload(add(b, index)),\n 0xffffffffffffffffffffffff0000000000000000000000000000000000000000\n )\n\n // Make sure input address is clean.\n // (Solidity does not guarantee this)\n input := and(input, 0xffffffffffffffffffffffffffffffffffffffff)\n\n // Store the neighbors and address into memory\n mstore(add(b, index), xor(input, neighbors))\n }\n }\n\n /// @dev Reads a bytes32 value from a position in a byte array.\n /// @param b Byte array containing a bytes32 value.\n /// @param index Index in byte array of bytes32 value.\n /// @return bytes32 value from byte array.\n function readBytes32(\n bytes memory b,\n uint256 index\n )\n internal\n pure\n returns (bytes32 result)\n {\n if (b.length < index + 32) {\n LibRichErrors.rrevert(LibBytesRichErrors.InvalidByteOperationError(\n LibBytesRichErrors.InvalidByteOperationErrorCodes.LengthGreaterThanOrEqualsThirtyTwoRequired,\n b.length,\n index + 32\n ));\n }\n\n // Arrays are prefixed by a 256 bit length parameter\n index += 32;\n\n // Read the bytes32 from array memory\n assembly {\n result := mload(add(b, index))\n }\n return result;\n }\n\n /// @dev Writes a bytes32 into a specific position in a byte array.\n /// @param b Byte array to insert into.\n /// @param index Index in byte array of .\n /// @param input bytes32 to put into byte array.\n function writeBytes32(\n bytes memory b,\n uint256 index,\n bytes32 input\n )\n internal\n pure\n {\n if (b.length < index + 32) {\n LibRichErrors.rrevert(LibBytesRichErrors.InvalidByteOperationError(\n LibBytesRichErrors.InvalidByteOperationErrorCodes.LengthGreaterThanOrEqualsThirtyTwoRequired,\n b.length,\n index + 32\n ));\n }\n\n // Arrays are prefixed by a 256 bit length parameter\n index += 32;\n\n // Read the bytes32 from array memory\n assembly {\n mstore(add(b, index), input)\n }\n }\n\n /// @dev Reads a uint256 value from a position in a byte array.\n /// @param b Byte array containing a uint256 value.\n /// @param index Index in byte array of uint256 value.\n /// @return uint256 value from byte array.\n function readUint256(\n bytes memory b,\n uint256 index\n )\n internal\n pure\n returns (uint256 result)\n {\n result = uint256(readBytes32(b, index));\n return result;\n }\n\n /// @dev Writes a uint256 into a specific position in a byte array.\n /// @param b Byte array to insert into.\n /// @param index Index in byte array of .\n /// @param input uint256 to put into byte array.\n function writeUint256(\n bytes memory b,\n uint256 index,\n uint256 input\n )\n internal\n pure\n {\n writeBytes32(b, index, bytes32(input));\n }\n\n /// @dev Reads an unpadded bytes4 value from a position in a byte array.\n /// @param b Byte array containing a bytes4 value.\n /// @param index Index in byte array of bytes4 value.\n /// @return bytes4 value from byte array.\n function readBytes4(\n bytes memory b,\n uint256 index\n )\n internal\n pure\n returns (bytes4 result)\n {\n if (b.length < index + 4) {\n LibRichErrors.rrevert(LibBytesRichErrors.InvalidByteOperationError(\n LibBytesRichErrors.InvalidByteOperationErrorCodes.LengthGreaterThanOrEqualsFourRequired,\n b.length,\n index + 4\n ));\n }\n\n // Arrays are prefixed by a 32 byte length field\n index += 32;\n\n // Read the bytes4 from array memory\n assembly {\n result := mload(add(b, index))\n // Solidity does not require us to clean the trailing bytes.\n // We do it anyway\n result := and(result, 0xFFFFFFFF00000000000000000000000000000000000000000000000000000000)\n }\n return result;\n }\n\n /// @dev Writes a new length to a byte array.\n /// Decreasing length will lead to removing the corresponding lower order bytes from the byte array.\n /// Increasing length may lead to appending adjacent in-memory bytes to the end of the byte array.\n /// @param b Bytes array to write new length to.\n /// @param length New length of byte array.\n function writeLength(bytes memory b, uint256 length)\n internal\n pure\n {\n assembly {\n mstore(b, length)\n }\n }\n}\n" }, "/Users/amir/github/0xproject/0x-monorepo/contracts/asset-proxy/node_modules/@0x/contracts-utils/contracts/src/LibBytesRichErrors.sol": { "content": "/*\n\n Copyright 2019 ZeroEx Intl.\n\n Licensed under the Apache License, Version 2.0 (the \"License\");\n you may not use this file except in compliance with the License.\n You may obtain a copy of the License at\n\n http://www.apache.org/licenses/LICENSE-2.0\n\n Unless required by applicable law or agreed to in writing, software\n distributed under the License is distributed on an \"AS IS\" BASIS,\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n See the License for the specific language governing permissions and\n limitations under the License.\n\n*/\n\npragma solidity ^0.5.9;\n\n\nlibrary LibBytesRichErrors {\n\n enum InvalidByteOperationErrorCodes {\n FromLessThanOrEqualsToRequired,\n ToLessThanOrEqualsLengthRequired,\n LengthGreaterThanZeroRequired,\n LengthGreaterThanOrEqualsFourRequired,\n LengthGreaterThanOrEqualsTwentyRequired,\n LengthGreaterThanOrEqualsThirtyTwoRequired,\n LengthGreaterThanOrEqualsNestedBytesLengthRequired,\n DestinationLengthGreaterThanOrEqualSourceLengthRequired\n }\n\n // bytes4(keccak256(\"InvalidByteOperationError(uint8,uint256,uint256)\"))\n bytes4 internal constant INVALID_BYTE_OPERATION_ERROR_SELECTOR =\n 0x28006595;\n\n // solhint-disable func-name-mixedcase\n function InvalidByteOperationError(\n InvalidByteOperationErrorCodes errorCode,\n uint256 offset,\n uint256 required\n )\n internal\n pure\n returns (bytes memory)\n {\n return abi.encodeWithSelector(\n INVALID_BYTE_OPERATION_ERROR_SELECTOR,\n errorCode,\n offset,\n required\n );\n }\n}\n" }, "/Users/amir/github/0xproject/0x-monorepo/contracts/asset-proxy/node_modules/@0x/contracts-utils/contracts/src/LibRichErrors.sol": { "content": "/*\n\n Copyright 2019 ZeroEx Intl.\n\n Licensed under the Apache License, Version 2.0 (the \"License\");\n you may not use this file except in compliance with the License.\n You may obtain a copy of the License at\n\n http://www.apache.org/licenses/LICENSE-2.0\n\n Unless required by applicable law or agreed to in writing, software\n distributed under the License is distributed on an \"AS IS\" BASIS,\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n See the License for the specific language governing permissions and\n limitations under the License.\n\n*/\n\npragma solidity ^0.5.9;\n\n\nlibrary LibRichErrors {\n\n // bytes4(keccak256(\"Error(string)\"))\n bytes4 internal constant STANDARD_ERROR_SELECTOR =\n 0x08c379a0;\n\n // solhint-disable func-name-mixedcase\n /// @dev ABI encode a standard, string revert error payload.\n /// This is the same payload that would be included by a `revert(string)`\n /// solidity statement. It has the function signature `Error(string)`.\n /// @param message The error string.\n /// @return The ABI encoded error.\n function StandardError(\n string memory message\n )\n internal\n pure\n returns (bytes memory)\n {\n return abi.encodeWithSelector(\n STANDARD_ERROR_SELECTOR,\n bytes(message)\n );\n }\n // solhint-enable func-name-mixedcase\n\n /// @dev Reverts an encoded rich revert reason `errorData`.\n /// @param errorData ABI encoded error data.\n function rrevert(bytes memory errorData)\n internal\n pure\n {\n assembly {\n revert(add(errorData, 0x20), mload(errorData))\n }\n }\n}\n" }, "/Users/amir/github/0xproject/0x-monorepo/contracts/asset-proxy/node_modules/@0x/contracts-utils/contracts/src/LibSafeMath.sol": { "content": "pragma solidity ^0.5.9;\n\nimport \"./LibRichErrors.sol\";\nimport \"./LibSafeMathRichErrors.sol\";\n\n\nlibrary LibSafeMath {\n\n function safeMul(uint256 a, uint256 b)\n internal\n pure\n returns (uint256)\n {\n if (a == 0) {\n return 0;\n }\n uint256 c = a * b;\n if (c / a != b) {\n LibRichErrors.rrevert(LibSafeMathRichErrors.Uint256BinOpError(\n LibSafeMathRichErrors.BinOpErrorCodes.MULTIPLICATION_OVERFLOW,\n a,\n b\n ));\n }\n return c;\n }\n\n function safeDiv(uint256 a, uint256 b)\n internal\n pure\n returns (uint256)\n {\n if (b == 0) {\n LibRichErrors.rrevert(LibSafeMathRichErrors.Uint256BinOpError(\n LibSafeMathRichErrors.BinOpErrorCodes.DIVISION_BY_ZERO,\n a,\n b\n ));\n }\n uint256 c = a / b;\n return c;\n }\n\n function safeSub(uint256 a, uint256 b)\n internal\n pure\n returns (uint256)\n {\n if (b > a) {\n LibRichErrors.rrevert(LibSafeMathRichErrors.Uint256BinOpError(\n LibSafeMathRichErrors.BinOpErrorCodes.SUBTRACTION_UNDERFLOW,\n a,\n b\n ));\n }\n return a - b;\n }\n\n function safeAdd(uint256 a, uint256 b)\n internal\n pure\n returns (uint256)\n {\n uint256 c = a + b;\n if (c < a) {\n LibRichErrors.rrevert(LibSafeMathRichErrors.Uint256BinOpError(\n LibSafeMathRichErrors.BinOpErrorCodes.ADDITION_OVERFLOW,\n a,\n b\n ));\n }\n return c;\n }\n\n function max256(uint256 a, uint256 b)\n internal\n pure\n returns (uint256)\n {\n return a >= b ? a : b;\n }\n\n function min256(uint256 a, uint256 b)\n internal\n pure\n returns (uint256)\n {\n return a < b ? a : b;\n }\n}\n" }, "/Users/amir/github/0xproject/0x-monorepo/contracts/asset-proxy/node_modules/@0x/contracts-utils/contracts/src/LibSafeMathRichErrors.sol": { "content": "pragma solidity ^0.5.9;\n\n\nlibrary LibSafeMathRichErrors {\n\n // bytes4(keccak256(\"Uint256BinOpError(uint8,uint256,uint256)\"))\n bytes4 internal constant UINT256_BINOP_ERROR_SELECTOR =\n 0xe946c1bb;\n\n // bytes4(keccak256(\"Uint256DowncastError(uint8,uint256)\"))\n bytes4 internal constant UINT256_DOWNCAST_ERROR_SELECTOR =\n 0xc996af7b;\n\n enum BinOpErrorCodes {\n ADDITION_OVERFLOW,\n MULTIPLICATION_OVERFLOW,\n SUBTRACTION_UNDERFLOW,\n DIVISION_BY_ZERO\n }\n\n enum DowncastErrorCodes {\n VALUE_TOO_LARGE_TO_DOWNCAST_TO_UINT32,\n VALUE_TOO_LARGE_TO_DOWNCAST_TO_UINT64,\n VALUE_TOO_LARGE_TO_DOWNCAST_TO_UINT96\n }\n\n // solhint-disable func-name-mixedcase\n function Uint256BinOpError(\n BinOpErrorCodes errorCode,\n uint256 a,\n uint256 b\n )\n internal\n pure\n returns (bytes memory)\n {\n return abi.encodeWithSelector(\n UINT256_BINOP_ERROR_SELECTOR,\n errorCode,\n a,\n b\n );\n }\n\n function Uint256DowncastError(\n DowncastErrorCodes errorCode,\n uint256 a\n )\n internal\n pure\n returns (bytes memory)\n {\n return abi.encodeWithSelector(\n UINT256_DOWNCAST_ERROR_SELECTOR,\n errorCode,\n a\n );\n }\n}\n" }, "/Users/amir/github/0xproject/0x-monorepo/contracts/asset-proxy/node_modules/@0x/contracts-erc1155/contracts/src/interfaces/IERC1155.sol": { "content": "/*\n\n Copyright 2019 ZeroEx Intl.\n\n Licensed under the Apache License, Version 2.0 (the \"License\");\n you may not use this file except in compliance with the License.\n You may obtain a copy of the License at\n\n http://www.apache.org/licenses/LICENSE-2.0\n\n Unless required by applicable law or agreed to in writing, software\n distributed under the License is distributed on an \"AS IS\" BASIS,\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n See the License for the specific language governing permissions and\n limitations under the License.\n\n*/\n\npragma solidity ^0.5.9;\n\n\n/// @title ERC-1155 Multi Token Standard\n/// @dev See https://github.com/ethereum/EIPs/blob/master/EIPS/eip-1155.md\n/// Note: The ERC-165 identifier for this interface is 0xd9b67a26.\ninterface IERC1155 {\n \n /// @dev Either TransferSingle or TransferBatch MUST emit when tokens are transferred,\n /// including zero value transfers as well as minting or burning.\n /// Operator will always be msg.sender.\n /// Either event from address `0x0` signifies a minting operation.\n /// An event to address `0x0` signifies a burning or melting operation.\n /// The total value transferred from address 0x0 minus the total value transferred to 0x0 may\n /// be used by clients and exchanges to be added to the \"circulating supply\" for a given token ID.\n /// To define a token ID with no initial balance, the contract SHOULD emit the TransferSingle event\n /// from `0x0` to `0x0`, with the token creator as `_operator`.\n event TransferSingle(\n address indexed operator,\n address indexed from,\n address indexed to,\n uint256 id,\n uint256 value\n );\n\n /// @dev Either TransferSingle or TransferBatch MUST emit when tokens are transferred,\n /// including zero value transfers as well as minting or burning.\n ///Operator will always be msg.sender.\n /// Either event from address `0x0` signifies a minting operation.\n /// An event to address `0x0` signifies a burning or melting operation.\n /// The total value transferred from address 0x0 minus the total value transferred to 0x0 may\n /// be used by clients and exchanges to be added to the \"circulating supply\" for a given token ID.\n /// To define multiple token IDs with no initial balance, this SHOULD emit the TransferBatch event\n /// from `0x0` to `0x0`, with the token creator as `_operator`.\n event TransferBatch(\n address indexed operator,\n address indexed from,\n address indexed to,\n uint256[] ids,\n uint256[] values\n );\n\n /// @dev MUST emit when an approval is updated.\n event ApprovalForAll(\n address indexed owner,\n address indexed operator,\n bool approved\n );\n\n /// @dev MUST emit when the URI is updated for a token ID.\n /// URIs are defined in RFC 3986.\n /// The URI MUST point a JSON file that conforms to the \"ERC-1155 Metadata JSON Schema\".\n event URI(\n string value,\n uint256 indexed id\n );\n\n /// @notice Transfers value amount of an _id from the _from address to the _to address specified.\n /// @dev MUST emit TransferSingle event on success.\n /// Caller must be approved to manage the _from account's tokens (see isApprovedForAll).\n /// MUST throw if `_to` is the zero address.\n /// MUST throw if balance of sender for token `_id` is lower than the `_value` sent.\n /// MUST throw on any other error.\n /// When transfer is complete, this function MUST check if `_to` is a smart contract (code size > 0).\n /// If so, it MUST call `onERC1155Received` on `_to` and revert if the return value\n /// is not `bytes4(keccak256(\"onERC1155Received(address,address,uint256,uint256,bytes)\"))`.\n /// @param from Source address\n /// @param to Target address\n /// @param id ID of the token type\n /// @param value Transfer amount\n /// @param data Additional data with no specified format, sent in call to `_to`\n function safeTransferFrom(\n address from,\n address to,\n uint256 id,\n uint256 value,\n bytes calldata data\n )\n external;\n\n /// @notice Send multiple types of Tokens from a 3rd party in one transfer (with safety call).\n /// @dev MUST emit TransferBatch event on success.\n /// Caller must be approved to manage the _from account's tokens (see isApprovedForAll).\n /// MUST throw if `_to` is the zero address.\n /// MUST throw if length of `_ids` is not the same as length of `_values`.\n /// MUST throw if any of the balance of sender for token `_ids` is lower than the respective `_values` sent.\n /// MUST throw on any other error.\n /// When transfer is complete, this function MUST check if `_to` is a smart contract (code size > 0).\n /// If so, it MUST call `onERC1155BatchReceived` on `_to` and revert if the return value\n /// is not `bytes4(keccak256(\"onERC1155BatchReceived(address,address,uint256[],uint256[],bytes)\"))`.\n /// @param from Source addresses\n /// @param to Target addresses\n /// @param ids IDs of each token type\n /// @param values Transfer amounts per token type\n /// @param data Additional data with no specified format, sent in call to `_to`\n function safeBatchTransferFrom(\n address from,\n address to,\n uint256[] calldata ids,\n uint256[] calldata values,\n bytes calldata data\n )\n external;\n\n /// @notice Enable or disable approval for a third party (\"operator\") to manage all of the caller's tokens.\n /// @dev MUST emit the ApprovalForAll event on success.\n /// @param operator Address to add to the set of authorized operators\n /// @param approved True if the operator is approved, false to revoke approval\n function setApprovalForAll(address operator, bool approved) external;\n\n /// @notice Queries the approval status of an operator for a given owner.\n /// @param owner The owner of the Tokens\n /// @param operator Address of authorized operator\n /// @return True if the operator is approved, false if not\n function isApprovedForAll(address owner, address operator) external view returns (bool);\n\n /// @notice Get the balance of an account's Tokens.\n /// @param owner The address of the token holder\n /// @param id ID of the Token\n /// @return The _owner's balance of the Token type requested\n function balanceOf(address owner, uint256 id) external view returns (uint256);\n\n /// @notice Get the balance of multiple account/token pairs\n /// @param owners The addresses of the token holders\n /// @param ids ID of the Tokens\n /// @return The _owner's balance of the Token types requested\n function balanceOfBatch(\n address[] calldata owners,\n uint256[] calldata ids\n )\n external\n view\n returns (uint256[] memory balances_);\n}\n" }, "/Users/amir/github/0xproject/0x-monorepo/contracts/asset-proxy/contracts/src/ERC20BridgeProxy.sol": { "content": "/*\n\n Copyright 2019 ZeroEx Intl.\n\n Licensed under the Apache License, Version 2.0 (the \"License\");\n you may not use this file except in compliance with the License.\n You may obtain a copy of the License at\n\n http://www.apache.org/licenses/LICENSE-2.0\n\n Unless required by applicable law or agreed to in writing, software\n distributed under the License is distributed on an \"AS IS\" BASIS,\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n See the License for the specific language governing permissions and\n limitations under the License.\n\n*/\n\npragma solidity ^0.5.9;\npragma experimental ABIEncoderV2;\n\nimport \"@0x/contracts-utils/contracts/src/LibBytes.sol\";\nimport \"@0x/contracts-utils/contracts/src/LibSafeMath.sol\";\nimport \"@0x/contracts-utils/contracts/src/Authorizable.sol\";\nimport \"@0x/contracts-erc20/contracts/src/interfaces/IERC20Token.sol\";\nimport \"./interfaces/IAssetProxy.sol\";\nimport \"./interfaces/IERC20Bridge.sol\";\n\n\ncontract ERC20BridgeProxy is\n IAssetProxy,\n Authorizable\n{\n using LibBytes for bytes;\n using LibSafeMath for uint256;\n\n // @dev Id of this proxy. Also the result of a successful bridge call.\n // bytes4(keccak256(\"ERC20Bridge(address,address,bytes)\"))\n bytes4 constant private PROXY_ID = 0xdc1600f3;\n\n /// @dev Calls a bridge contract to transfer `amount` of ERC20 from `from`\n /// to `to`. Asserts that the balance of `to` has increased by `amount`.\n /// @param assetData Abi-encoded data for this asset proxy encoded as:\n /// abi.encodeWithSelector(\n /// bytes4 PROXY_ID,\n /// address tokenAddress,\n /// address bridgeAddress,\n /// bytes bridgeData\n /// )\n /// @param from Address to transfer asset from.\n /// @param to Address to transfer asset to.\n /// @param amount Amount of asset to transfer.\n function transferFrom(\n bytes calldata assetData,\n address from,\n address to,\n uint256 amount\n )\n external\n onlyAuthorized\n {\n // Extract asset data fields.\n (\n address tokenAddress,\n address bridgeAddress,\n bytes memory bridgeData\n ) = abi.decode(\n assetData.sliceDestructive(4, assetData.length),\n (address, address, bytes)\n );\n\n // Remember the balance of `to` before calling the bridge.\n uint256 balanceBefore = balanceOf(tokenAddress, to);\n // Call the bridge, who should transfer `amount` of `tokenAddress` to\n // `to`.\n bytes4 success = IERC20Bridge(bridgeAddress).bridgeTransferFrom(\n tokenAddress,\n from,\n to,\n amount,\n bridgeData\n );\n // Bridge must return the proxy ID to indicate success.\n require(success == PROXY_ID, \"BRIDGE_FAILED\");\n // Ensure that the balance of `to` has increased by at least `amount`.\n require(\n balanceBefore.safeAdd(amount) <= balanceOf(tokenAddress, to),\n \"BRIDGE_UNDERPAY\"\n );\n }\n\n /// @dev Gets the proxy id associated with this asset proxy.\n /// @return proxyId The proxy id.\n function getProxyId()\n external\n pure\n returns (bytes4 proxyId)\n {\n return PROXY_ID;\n }\n\n /// @dev Retrieves the balance of `owner` for this asset.\n /// @return balance The balance of the ERC20 token being transferred by this\n /// asset proxy.\n function balanceOf(bytes calldata assetData, address owner)\n external\n view\n returns (uint256 balance)\n {\n (address tokenAddress) = abi.decode(\n assetData.sliceDestructive(4, assetData.length),\n (address)\n );\n return balanceOf(tokenAddress, owner);\n }\n\n /// @dev Retrieves the balance of `owner` given an ERC20 address.\n /// @return balance The balance of the ERC20 token for `owner`.\n function balanceOf(address tokenAddress, address owner)\n private\n view\n returns (uint256 balance)\n {\n return IERC20Token(tokenAddress).balanceOf(owner);\n }\n}\n" }, "/Users/amir/github/0xproject/0x-monorepo/contracts/asset-proxy/node_modules/@0x/contracts-utils/contracts/src/Authorizable.sol": { "content": "/*\n\n Copyright 2019 ZeroEx Intl.\n\n Licensed under the Apache License, Version 2.0 (the \"License\");\n you may not use this file except in compliance with the License.\n You may obtain a copy of the License at\n\n http://www.apache.org/licenses/LICENSE-2.0\n\n Unless required by applicable law or agreed to in writing, software\n distributed under the License is distributed on an \"AS IS\" BASIS,\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n See the License for the specific language governing permissions and\n limitations under the License.\n\n*/\n\npragma solidity ^0.5.9;\n\nimport \"./interfaces/IAuthorizable.sol\";\nimport \"./LibAuthorizableRichErrors.sol\";\nimport \"./LibRichErrors.sol\";\nimport \"./Ownable.sol\";\n\n\n// solhint-disable no-empty-blocks\ncontract Authorizable is\n Ownable,\n IAuthorizable\n{\n /// @dev Only authorized addresses can invoke functions with this modifier.\n modifier onlyAuthorized {\n _assertSenderIsAuthorized();\n _;\n }\n\n mapping (address => bool) public authorized;\n address[] public authorities;\n\n /// @dev Initializes the `owner` address.\n constructor()\n public\n Ownable()\n {}\n\n /// @dev Authorizes an address.\n /// @param target Address to authorize.\n function addAuthorizedAddress(address target)\n external\n onlyOwner\n {\n _addAuthorizedAddress(target);\n }\n\n /// @dev Removes authorizion of an address.\n /// @param target Address to remove authorization from.\n function removeAuthorizedAddress(address target)\n external\n onlyOwner\n {\n if (!authorized[target]) {\n LibRichErrors.rrevert(LibAuthorizableRichErrors.TargetNotAuthorizedError(target));\n }\n for (uint256 i = 0; i < authorities.length; i++) {\n if (authorities[i] == target) {\n _removeAuthorizedAddressAtIndex(target, i);\n break;\n }\n }\n }\n\n /// @dev Removes authorizion of an address.\n /// @param target Address to remove authorization from.\n /// @param index Index of target in authorities array.\n function removeAuthorizedAddressAtIndex(\n address target,\n uint256 index\n )\n external\n onlyOwner\n {\n _removeAuthorizedAddressAtIndex(target, index);\n }\n\n /// @dev Gets all authorized addresses.\n /// @return Array of authorized addresses.\n function getAuthorizedAddresses()\n external\n view\n returns (address[] memory)\n {\n return authorities;\n }\n\n /// @dev Reverts if msg.sender is not authorized.\n function _assertSenderIsAuthorized()\n internal\n view\n {\n if (!authorized[msg.sender]) {\n LibRichErrors.rrevert(LibAuthorizableRichErrors.SenderNotAuthorizedError(msg.sender));\n }\n }\n\n /// @dev Authorizes an address.\n /// @param target Address to authorize.\n function _addAuthorizedAddress(address target)\n internal\n {\n // Ensure that the target is not the zero address.\n if (target == address(0)) {\n LibRichErrors.rrevert(LibAuthorizableRichErrors.ZeroCantBeAuthorizedError());\n }\n\n // Ensure that the target is not already authorized.\n if (authorized[target]) {\n LibRichErrors.rrevert(LibAuthorizableRichErrors.TargetAlreadyAuthorizedError(target));\n }\n\n authorized[target] = true;\n authorities.push(target);\n emit AuthorizedAddressAdded(target, msg.sender);\n }\n\n /// @dev Removes authorizion of an address.\n /// @param target Address to remove authorization from.\n /// @param index Index of target in authorities array.\n function _removeAuthorizedAddressAtIndex(\n address target,\n uint256 index\n )\n internal\n {\n if (!authorized[target]) {\n LibRichErrors.rrevert(LibAuthorizableRichErrors.TargetNotAuthorizedError(target));\n }\n if (index >= authorities.length) {\n LibRichErrors.rrevert(LibAuthorizableRichErrors.IndexOutOfBoundsError(\n index,\n authorities.length\n ));\n }\n if (authorities[index] != target) {\n LibRichErrors.rrevert(LibAuthorizableRichErrors.AuthorizedAddressMismatchError(\n authorities[index],\n target\n ));\n }\n\n delete authorized[target];\n authorities[index] = authorities[authorities.length - 1];\n authorities.length -= 1;\n emit AuthorizedAddressRemoved(target, msg.sender);\n }\n}\n" }, "/Users/amir/github/0xproject/0x-monorepo/contracts/asset-proxy/node_modules/@0x/contracts-utils/contracts/src/interfaces/IAuthorizable.sol": { "content": "/*\n\n Copyright 2019 ZeroEx Intl.\n\n Licensed under the Apache License, Version 2.0 (the \"License\");\n you may not use this file except in compliance with the License.\n You may obtain a copy of the License at\n\n http://www.apache.org/licenses/LICENSE-2.0\n\n Unless required by applicable law or agreed to in writing, software\n distributed under the License is distributed on an \"AS IS\" BASIS,\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n See the License for the specific language governing permissions and\n limitations under the License.\n\n*/\n\npragma solidity ^0.5.9;\n\nimport \"./IOwnable.sol\";\n\n\ncontract IAuthorizable is\n IOwnable\n{\n // Event logged when a new address is authorized.\n event AuthorizedAddressAdded(\n address indexed target,\n address indexed caller\n );\n\n // Event logged when a currently authorized address is unauthorized.\n event AuthorizedAddressRemoved(\n address indexed target,\n address indexed caller\n );\n\n /// @dev Authorizes an address.\n /// @param target Address to authorize.\n function addAuthorizedAddress(address target)\n external;\n\n /// @dev Removes authorizion of an address.\n /// @param target Address to remove authorization from.\n function removeAuthorizedAddress(address target)\n external;\n\n /// @dev Removes authorizion of an address.\n /// @param target Address to remove authorization from.\n /// @param index Index of target in authorities array.\n function removeAuthorizedAddressAtIndex(\n address target,\n uint256 index\n )\n external;\n\n /// @dev Gets all authorized addresses.\n /// @return Array of authorized addresses.\n function getAuthorizedAddresses()\n external\n view\n returns (address[] memory);\n}\n" }, "/Users/amir/github/0xproject/0x-monorepo/contracts/asset-proxy/node_modules/@0x/contracts-utils/contracts/src/LibAuthorizableRichErrors.sol": { "content": "/*\n\n Copyright 2019 ZeroEx Intl.\n\n Licensed under the Apache License, Version 2.0 (the \"License\");\n you may not use this file except in compliance with the License.\n You may obtain a copy of the License at\n\n http://www.apache.org/licenses/LICENSE-2.0\n\n Unless required by applicable law or agreed to in writing, software\n distributed under the License is distributed on an \"AS IS\" BASIS,\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n See the License for the specific language governing permissions and\n limitations under the License.\n\n*/\n\npragma solidity ^0.5.9;\n\n\nlibrary LibAuthorizableRichErrors {\n\n // bytes4(keccak256(\"AuthorizedAddressMismatchError(address,address)\"))\n bytes4 internal constant AUTHORIZED_ADDRESS_MISMATCH_ERROR_SELECTOR =\n 0x140a84db;\n\n // bytes4(keccak256(\"IndexOutOfBoundsError(uint256,uint256)\"))\n bytes4 internal constant INDEX_OUT_OF_BOUNDS_ERROR_SELECTOR =\n 0xe9f83771;\n\n // bytes4(keccak256(\"SenderNotAuthorizedError(address)\"))\n bytes4 internal constant SENDER_NOT_AUTHORIZED_ERROR_SELECTOR =\n 0xb65a25b9;\n\n // bytes4(keccak256(\"TargetAlreadyAuthorizedError(address)\"))\n bytes4 internal constant TARGET_ALREADY_AUTHORIZED_ERROR_SELECTOR =\n 0xde16f1a0;\n\n // bytes4(keccak256(\"TargetNotAuthorizedError(address)\"))\n bytes4 internal constant TARGET_NOT_AUTHORIZED_ERROR_SELECTOR =\n 0xeb5108a2;\n\n // bytes4(keccak256(\"ZeroCantBeAuthorizedError()\"))\n bytes internal constant ZERO_CANT_BE_AUTHORIZED_ERROR_BYTES =\n hex\"57654fe4\";\n\n // solhint-disable func-name-mixedcase\n function AuthorizedAddressMismatchError(\n address authorized,\n address target\n )\n internal\n pure\n returns (bytes memory)\n {\n return abi.encodeWithSelector(\n AUTHORIZED_ADDRESS_MISMATCH_ERROR_SELECTOR,\n authorized,\n target\n );\n }\n\n function IndexOutOfBoundsError(\n uint256 index,\n uint256 length\n )\n internal\n pure\n returns (bytes memory)\n {\n return abi.encodeWithSelector(\n INDEX_OUT_OF_BOUNDS_ERROR_SELECTOR,\n index,\n length\n );\n }\n\n function SenderNotAuthorizedError(address sender)\n internal\n pure\n returns (bytes memory)\n {\n return abi.encodeWithSelector(\n SENDER_NOT_AUTHORIZED_ERROR_SELECTOR,\n sender\n );\n }\n\n function TargetAlreadyAuthorizedError(address target)\n internal\n pure\n returns (bytes memory)\n {\n return abi.encodeWithSelector(\n TARGET_ALREADY_AUTHORIZED_ERROR_SELECTOR,\n target\n );\n }\n\n function TargetNotAuthorizedError(address target)\n internal\n pure\n returns (bytes memory)\n {\n return abi.encodeWithSelector(\n TARGET_NOT_AUTHORIZED_ERROR_SELECTOR,\n target\n );\n }\n\n function ZeroCantBeAuthorizedError()\n internal\n pure\n returns (bytes memory)\n {\n return ZERO_CANT_BE_AUTHORIZED_ERROR_BYTES;\n }\n}\n" }, "/Users/amir/github/0xproject/0x-monorepo/contracts/asset-proxy/node_modules/@0x/contracts-utils/contracts/src/Ownable.sol": { "content": "/*\n\n Copyright 2019 ZeroEx Intl.\n\n Licensed under the Apache License, Version 2.0 (the \"License\");\n you may not use this file except in compliance with the License.\n You may obtain a copy of the License at\n\n http://www.apache.org/licenses/LICENSE-2.0\n\n Unless required by applicable law or agreed to in writing, software\n distributed under the License is distributed on an \"AS IS\" BASIS,\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n See the License for the specific language governing permissions and\n limitations under the License.\n\n*/\n\npragma solidity ^0.5.9;\n\nimport \"./interfaces/IOwnable.sol\";\nimport \"./LibOwnableRichErrors.sol\";\nimport \"./LibRichErrors.sol\";\n\n\ncontract Ownable is\n IOwnable\n{\n address public owner;\n\n constructor ()\n public\n {\n owner = msg.sender;\n }\n\n modifier onlyOwner() {\n _assertSenderIsOwner();\n _;\n }\n\n function transferOwnership(address newOwner)\n public\n onlyOwner\n {\n if (newOwner == address(0)) {\n LibRichErrors.rrevert(LibOwnableRichErrors.TransferOwnerToZeroError());\n } else {\n owner = newOwner;\n emit OwnershipTransferred(msg.sender, newOwner);\n }\n }\n\n function _assertSenderIsOwner()\n internal\n view\n {\n if (msg.sender != owner) {\n LibRichErrors.rrevert(LibOwnableRichErrors.OnlyOwnerError(\n msg.sender,\n owner\n ));\n }\n }\n}\n" }, "/Users/amir/github/0xproject/0x-monorepo/contracts/asset-proxy/node_modules/@0x/contracts-utils/contracts/src/LibOwnableRichErrors.sol": { "content": "pragma solidity ^0.5.9;\n\n\nlibrary LibOwnableRichErrors {\n\n // bytes4(keccak256(\"OnlyOwnerError(address,address)\"))\n bytes4 internal constant ONLY_OWNER_ERROR_SELECTOR =\n 0x1de45ad1;\n\n // bytes4(keccak256(\"TransferOwnerToZeroError()\"))\n bytes internal constant TRANSFER_OWNER_TO_ZERO_ERROR_BYTES =\n hex\"e69edc3e\";\n\n // solhint-disable func-name-mixedcase\n function OnlyOwnerError(\n address sender,\n address owner\n )\n internal\n pure\n returns (bytes memory)\n {\n return abi.encodeWithSelector(\n ONLY_OWNER_ERROR_SELECTOR,\n sender,\n owner\n );\n }\n\n function TransferOwnerToZeroError()\n internal\n pure\n returns (bytes memory)\n {\n return TRANSFER_OWNER_TO_ZERO_ERROR_BYTES;\n }\n}\n" }, "/Users/amir/github/0xproject/0x-monorepo/contracts/asset-proxy/node_modules/@0x/contracts-erc20/contracts/src/interfaces/IERC20Token.sol": { "content": "/*\n\n Copyright 2019 ZeroEx Intl.\n\n Licensed under the Apache License, Version 2.0 (the \"License\");\n you may not use this file except in compliance with the License.\n You may obtain a copy of the License at\n\n http://www.apache.org/licenses/LICENSE-2.0\n\n Unless required by applicable law or agreed to in writing, software\n distributed under the License is distributed on an \"AS IS\" BASIS,\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n See the License for the specific language governing permissions and\n limitations under the License.\n\n*/\n\npragma solidity ^0.5.9;\n\n\ncontract IERC20Token {\n\n // solhint-disable no-simple-event-func-name\n event Transfer(\n address indexed _from,\n address indexed _to,\n uint256 _value\n );\n\n event Approval(\n address indexed _owner,\n address indexed _spender,\n uint256 _value\n );\n\n /// @dev 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 True if transfer was successful\n function transfer(address _to, uint256 _value)\n external\n returns (bool);\n\n /// @dev 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 True if transfer was successful\n function transferFrom(\n address _from,\n address _to,\n uint256 _value\n )\n external\n returns (bool);\n\n /// @dev `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 wei to be approved for transfer\n /// @return Always true if the call has enough gas to complete execution\n function approve(address _spender, uint256 _value)\n external\n returns (bool);\n\n /// @dev Query total supply of token\n /// @return Total supply of token\n function totalSupply()\n external\n view\n returns (uint256);\n\n /// @param _owner The address from which the balance will be retrieved\n /// @return Balance of owner\n function balanceOf(address _owner)\n external\n view\n returns (uint256);\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)\n external\n view\n returns (uint256);\n}\n" }, "/Users/amir/github/0xproject/0x-monorepo/contracts/asset-proxy/contracts/src/interfaces/IERC20Bridge.sol": { "content": "/*\n\n Copyright 2019 ZeroEx Intl.\n\n Licensed under the Apache License, Version 2.0 (the \"License\");\n you may not use this file except in compliance with the License.\n You may obtain a copy of the License at\n\n http://www.apache.org/licenses/LICENSE-2.0\n\n Unless required by applicable law or agreed to in writing, software\n distributed under the License is distributed on an \"AS IS\" BASIS,\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n See the License for the specific language governing permissions and\n limitations under the License.\n\n*/\n\npragma solidity ^0.5.9;\n\n\ncontract IERC20Bridge {\n\n // @dev Result of a successful bridge call.\n bytes4 constant internal BRIDGE_SUCCESS = 0xdc1600f3;\n\n /// @dev Transfers `amount` of the ERC20 `tokenAddress` from `from` to `to`.\n /// @param tokenAddress The address of the ERC20 token to transfer.\n /// @param from Address to transfer asset from.\n /// @param to Address to transfer asset to.\n /// @param amount Amount of asset to transfer.\n /// @param bridgeData Arbitrary asset data needed by the bridge contract.\n /// @return success The magic bytes `0x37708e9b` if successful.\n function bridgeTransferFrom(\n address tokenAddress,\n address from,\n address to,\n uint256 amount,\n bytes calldata bridgeData\n )\n external\n returns (bytes4 success);\n}\n" }, "/Users/amir/github/0xproject/0x-monorepo/contracts/asset-proxy/contracts/src/ERC20Proxy.sol": { "content": "/*\n\n Copyright 2019 ZeroEx Intl.\n\n Licensed under the Apache License, Version 2.0 (the \"License\");\n you may not use this file except in compliance with the License.\n You may obtain a copy of the License at\n\n http://www.apache.org/licenses/LICENSE-2.0\n\n Unless required by applicable law or agreed to in writing, software\n distributed under the License is distributed on an \"AS IS\" BASIS,\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n See the License for the specific language governing permissions and\n limitations under the License.\n\n*/\n\npragma solidity ^0.5.9;\n\nimport \"../archive/MixinAuthorizable.sol\";\n\n\ncontract ERC20Proxy is\n MixinAuthorizable\n{\n // Id of this proxy.\n bytes4 constant internal PROXY_ID = bytes4(keccak256(\"ERC20Token(address)\"));\n\n // solhint-disable-next-line payable-fallback\n function ()\n external\n {\n assembly {\n // The first 4 bytes of calldata holds the function selector\n let selector := and(calldataload(0), 0xffffffff00000000000000000000000000000000000000000000000000000000)\n\n // `transferFrom` will be called with the following parameters:\n // assetData Encoded byte array.\n // from Address to transfer asset from.\n // to Address to transfer asset to.\n // amount Amount of asset to transfer.\n // bytes4(keccak256(\"transferFrom(bytes,address,address,uint256)\")) = 0xa85e59e4\n if eq(selector, 0xa85e59e400000000000000000000000000000000000000000000000000000000) {\n\n // To lookup a value in a mapping, we load from the storage location keccak256(k, p),\n // where k is the key left padded to 32 bytes and p is the storage slot\n let start := mload(64)\n mstore(start, and(caller, 0xffffffffffffffffffffffffffffffffffffffff))\n mstore(add(start, 32), authorized_slot)\n\n // Revert if authorized[msg.sender] == false\n if iszero(sload(keccak256(start, 64))) {\n // Revert with `Error(\"SENDER_NOT_AUTHORIZED\")`\n mstore(0, 0x08c379a000000000000000000000000000000000000000000000000000000000)\n mstore(32, 0x0000002000000000000000000000000000000000000000000000000000000000)\n mstore(64, 0x0000001553454e4445525f4e4f545f415554484f52495a454400000000000000)\n mstore(96, 0)\n revert(0, 100)\n }\n\n // `transferFrom`.\n // The function is marked `external`, so no abi decodeding is done for\n // us. Instead, we expect the `calldata` memory to contain the\n // following:\n //\n // | Area | Offset | Length | Contents |\n // |----------|--------|---------|-------------------------------------|\n // | Header | 0 | 4 | function selector |\n // | Params | | 4 * 32 | function parameters: |\n // | | 4 | | 1. offset to assetData (*) |\n // | | 36 | | 2. from |\n // | | 68 | | 3. to |\n // | | 100 | | 4. amount |\n // | Data | | | assetData: |\n // | | 132 | 32 | assetData Length |\n // | | 164 | ** | assetData Contents |\n //\n // (*): offset is computed from start of function parameters, so offset\n // by an additional 4 bytes in the calldata.\n //\n // (**): see table below to compute length of assetData Contents\n //\n // WARNING: The ABIv2 specification allows additional padding between\n // the Params and Data section. This will result in a larger\n // offset to assetData.\n\n // Asset data itself is encoded as follows:\n //\n // | Area | Offset | Length | Contents |\n // |----------|--------|---------|-------------------------------------|\n // | Header | 0 | 4 | function selector |\n // | Params | | 1 * 32 | function parameters: |\n // | | 4 | 12 + 20 | 1. token address |\n\n // We construct calldata for the `token.transferFrom` ABI.\n // The layout of this calldata is in the table below.\n //\n // | Area | Offset | Length | Contents |\n // |----------|--------|---------|-------------------------------------|\n // | Header | 0 | 4 | function selector |\n // | Params | | 3 * 32 | function parameters: |\n // | | 4 | | 1. from |\n // | | 36 | | 2. to |\n // | | 68 | | 3. amount |\n\n /////// Read token address from calldata ///////\n // * The token address is stored in `assetData`.\n //\n // * The \"offset to assetData\" is stored at offset 4 in the calldata (table 1).\n // [assetDataOffsetFromParams = calldataload(4)]\n //\n // * Notes that the \"offset to assetData\" is relative to the \"Params\" area of calldata;\n // add 4 bytes to account for the length of the \"Header\" area (table 1).\n // [assetDataOffsetFromHeader = assetDataOffsetFromParams + 4]\n //\n // * The \"token address\" is offset 32+4=36 bytes into \"assetData\" (tables 1 & 2).\n // [tokenOffset = assetDataOffsetFromHeader + 36 = calldataload(4) + 4 + 36]\n let token := calldataload(add(calldataload(4), 40))\n\n /////// Setup Header Area ///////\n // This area holds the 4-byte `transferFrom` selector.\n // Any trailing data in transferFromSelector will be\n // overwritten in the next `mstore` call.\n mstore(0, 0x23b872dd00000000000000000000000000000000000000000000000000000000)\n\n /////// Setup Params Area ///////\n // We copy the fields `from`, `to` and `amount` in bulk\n // from our own calldata to the new calldata.\n calldatacopy(4, 36, 96)\n\n /////// Call `token.transferFrom` using the calldata ///////\n let success := call(\n gas, // forward all gas\n token, // call address of token contract\n 0, // don't send any ETH\n 0, // pointer to start of input\n 100, // length of input\n 0, // write output over input\n 32 // output size should be 32 bytes\n )\n\n /////// Check return data. ///////\n // If there is no return data, we assume the token incorrectly\n // does not return a bool. In this case we expect it to revert\n // on failure, which was handled above.\n // If the token does return data, we require that it is a single\n // nonzero 32 bytes value.\n // So the transfer succeeded if the call succeeded and either\n // returned nothing, or returned a non-zero 32 byte value.\n success := and(success, or(\n iszero(returndatasize),\n and(\n eq(returndatasize, 32),\n gt(mload(0), 0)\n )\n ))\n if success {\n return(0, 0)\n }\n\n // Revert with `Error(\"TRANSFER_FAILED\")`\n mstore(0, 0x08c379a000000000000000000000000000000000000000000000000000000000)\n mstore(32, 0x0000002000000000000000000000000000000000000000000000000000000000)\n mstore(64, 0x0000000f5452414e534645525f4641494c454400000000000000000000000000)\n mstore(96, 0)\n revert(0, 100)\n }\n\n // Revert if undefined function is called\n revert(0, 0)\n }\n }\n\n /// @dev Gets the proxy id associated with the proxy address.\n /// @return Proxy id.\n function getProxyId()\n external\n pure\n returns (bytes4)\n {\n return PROXY_ID;\n }\n}\n" }, "/Users/amir/github/0xproject/0x-monorepo/contracts/asset-proxy/contracts/src/ERC721Proxy.sol": { "content": "/*\n\n Copyright 2019 ZeroEx Intl.\n\n Licensed under the Apache License, Version 2.0 (the \"License\");\n you may not use this file except in compliance with the License.\n You may obtain a copy of the License at\n\n http://www.apache.org/licenses/LICENSE-2.0\n\n Unless required by applicable law or agreed to in writing, software\n distributed under the License is distributed on an \"AS IS\" BASIS,\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n See the License for the specific language governing permissions and\n limitations under the License.\n\n*/\n\npragma solidity ^0.5.9;\n\nimport \"../archive/MixinAuthorizable.sol\";\n\n\ncontract ERC721Proxy is\n MixinAuthorizable\n{\n // Id of this proxy.\n bytes4 constant internal PROXY_ID = bytes4(keccak256(\"ERC721Token(address,uint256)\"));\n\n // solhint-disable-next-line payable-fallback\n function ()\n external\n {\n assembly {\n // The first 4 bytes of calldata holds the function selector\n let selector := and(calldataload(0), 0xffffffff00000000000000000000000000000000000000000000000000000000)\n\n // `transferFrom` will be called with the following parameters:\n // assetData Encoded byte array.\n // from Address to transfer asset from.\n // to Address to transfer asset to.\n // amount Amount of asset to transfer.\n // bytes4(keccak256(\"transferFrom(bytes,address,address,uint256)\")) = 0xa85e59e4\n if eq(selector, 0xa85e59e400000000000000000000000000000000000000000000000000000000) {\n\n // To lookup a value in a mapping, we load from the storage location keccak256(k, p),\n // where k is the key left padded to 32 bytes and p is the storage slot\n let start := mload(64)\n mstore(start, and(caller, 0xffffffffffffffffffffffffffffffffffffffff))\n mstore(add(start, 32), authorized_slot)\n\n // Revert if authorized[msg.sender] == false\n if iszero(sload(keccak256(start, 64))) {\n // Revert with `Error(\"SENDER_NOT_AUTHORIZED\")`\n mstore(0, 0x08c379a000000000000000000000000000000000000000000000000000000000)\n mstore(32, 0x0000002000000000000000000000000000000000000000000000000000000000)\n mstore(64, 0x0000001553454e4445525f4e4f545f415554484f52495a454400000000000000)\n mstore(96, 0)\n revert(0, 100)\n }\n\n // `transferFrom`.\n // The function is marked `external`, so no abi decodeding is done for\n // us. Instead, we expect the `calldata` memory to contain the\n // following:\n //\n // | Area | Offset | Length | Contents |\n // |----------|--------|---------|-------------------------------------|\n // | Header | 0 | 4 | function selector |\n // | Params | | 4 * 32 | function parameters: |\n // | | 4 | | 1. offset to assetData (*) |\n // | | 36 | | 2. from |\n // | | 68 | | 3. to |\n // | | 100 | | 4. amount |\n // | Data | | | assetData: |\n // | | 132 | 32 | assetData Length |\n // | | 164 | ** | assetData Contents |\n //\n // (*): offset is computed from start of function parameters, so offset\n // by an additional 4 bytes in the calldata.\n //\n // (**): see table below to compute length of assetData Contents\n //\n // WARNING: The ABIv2 specification allows additional padding between\n // the Params and Data section. This will result in a larger\n // offset to assetData.\n\n // Asset data itself is encoded as follows:\n //\n // | Area | Offset | Length | Contents |\n // |----------|--------|---------|-------------------------------------|\n // | Header | 0 | 4 | function selector |\n // | Params | | 2 * 32 | function parameters: |\n // | | 4 | 12 + 20 | 1. token address |\n // | | 36 | | 2. tokenId |\n\n // We construct calldata for the `token.transferFrom` ABI.\n // The layout of this calldata is in the table below.\n //\n // | Area | Offset | Length | Contents |\n // |----------|--------|---------|-------------------------------------|\n // | Header | 0 | 4 | function selector |\n // | Params | | 3 * 32 | function parameters: |\n // | | 4 | | 1. from |\n // | | 36 | | 2. to |\n // | | 68 | | 3. tokenId |\n\n // There exists only 1 of each token.\n // require(amount == 1, \"INVALID_AMOUNT\")\n if sub(calldataload(100), 1) {\n // Revert with `Error(\"INVALID_AMOUNT\")`\n mstore(0, 0x08c379a000000000000000000000000000000000000000000000000000000000)\n mstore(32, 0x0000002000000000000000000000000000000000000000000000000000000000)\n mstore(64, 0x0000000e494e56414c49445f414d4f554e540000000000000000000000000000)\n mstore(96, 0)\n revert(0, 100)\n }\n\n /////// Setup Header Area ///////\n // This area holds the 4-byte `transferFrom` selector.\n // Any trailing data in transferFromSelector will be\n // overwritten in the next `mstore` call.\n mstore(0, 0x23b872dd00000000000000000000000000000000000000000000000000000000)\n\n /////// Setup Params Area ///////\n // We copy the fields `from` and `to` in bulk\n // from our own calldata to the new calldata.\n calldatacopy(4, 36, 64)\n\n // Copy `tokenId` field from our own calldata to the new calldata.\n let assetDataOffset := calldataload(4)\n calldatacopy(68, add(assetDataOffset, 72), 32)\n\n /////// Call `token.transferFrom` using the calldata ///////\n let token := calldataload(add(assetDataOffset, 40))\n let success := call(\n gas, // forward all gas\n token, // call address of token contract\n 0, // don't send any ETH\n 0, // pointer to start of input\n 100, // length of input\n 0, // write output to null\n 0 // output size is 0 bytes\n )\n if success {\n return(0, 0)\n }\n\n // Revert with `Error(\"TRANSFER_FAILED\")`\n mstore(0, 0x08c379a000000000000000000000000000000000000000000000000000000000)\n mstore(32, 0x0000002000000000000000000000000000000000000000000000000000000000)\n mstore(64, 0x0000000f5452414e534645525f4641494c454400000000000000000000000000)\n mstore(96, 0)\n revert(0, 100)\n }\n\n // Revert if undefined function is called\n revert(0, 0)\n }\n }\n\n /// @dev Gets the proxy id associated with the proxy address.\n /// @return Proxy id.\n function getProxyId()\n external\n pure\n returns (bytes4)\n {\n return PROXY_ID;\n }\n}\n" }, "/Users/amir/github/0xproject/0x-monorepo/contracts/asset-proxy/contracts/src/MultiAssetProxy.sol": { "content": "/*\n\n Copyright 2019 ZeroEx Intl.\n\n Licensed under the Apache License, Version 2.0 (the \"License\");\n you may not use this file except in compliance with the License.\n You may obtain a copy of the License at\n\n http://www.apache.org/licenses/LICENSE-2.0\n\n Unless required by applicable law or agreed to in writing, software\n distributed under the License is distributed on an \"AS IS\" BASIS,\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n See the License for the specific language governing permissions and\n limitations under the License.\n\n*/\n\npragma solidity ^0.5.9;\n\nimport \"../archive/MixinAssetProxyDispatcher.sol\";\nimport \"../archive/MixinAuthorizable.sol\";\n\n\ncontract MultiAssetProxy is\n MixinAssetProxyDispatcher,\n MixinAuthorizable\n{\n // Id of this proxy.\n bytes4 constant internal PROXY_ID = bytes4(keccak256(\"MultiAsset(uint256[],bytes[])\"));\n\n // solhint-disable-next-line payable-fallback\n function ()\n external\n {\n // NOTE: The below assembly assumes that clients do some input validation and that the input is properly encoded according to the AbiV2 specification.\n // It is technically possible for inputs with very large lengths and offsets to cause overflows. However, this would make the calldata prohibitively\n // expensive and we therefore do not check for overflows in these scenarios.\n assembly {\n // The first 4 bytes of calldata holds the function selector\n let selector := and(calldataload(0), 0xffffffff00000000000000000000000000000000000000000000000000000000)\n\n // `transferFrom` will be called with the following parameters:\n // assetData Encoded byte array.\n // from Address to transfer asset from.\n // to Address to transfer asset to.\n // amount Amount of asset to transfer.\n // bytes4(keccak256(\"transferFrom(bytes,address,address,uint256)\")) = 0xa85e59e4\n if eq(selector, 0xa85e59e400000000000000000000000000000000000000000000000000000000) {\n\n // To lookup a value in a mapping, we load from the storage location keccak256(k, p),\n // where k is the key left padded to 32 bytes and p is the storage slot\n mstore(0, caller)\n mstore(32, authorized_slot)\n\n // Revert if authorized[msg.sender] == false\n if iszero(sload(keccak256(0, 64))) {\n // Revert with `Error(\"SENDER_NOT_AUTHORIZED\")`\n mstore(0, 0x08c379a000000000000000000000000000000000000000000000000000000000)\n mstore(32, 0x0000002000000000000000000000000000000000000000000000000000000000)\n mstore(64, 0x0000001553454e4445525f4e4f545f415554484f52495a454400000000000000)\n mstore(96, 0)\n revert(0, 100)\n }\n\n // `transferFrom`.\n // The function is marked `external`, so no abi decoding is done for\n // us. Instead, we expect the `calldata` memory to contain the\n // following:\n //\n // | Area | Offset | Length | Contents |\n // |----------|--------|---------|-------------------------------------|\n // | Header | 0 | 4 | function selector |\n // | Params | | 4 * 32 | function parameters: |\n // | | 4 | | 1. offset to assetData (*) |\n // | | 36 | | 2. from |\n // | | 68 | | 3. to |\n // | | 100 | | 4. amount |\n // | Data | | | assetData: |\n // | | 132 | 32 | assetData Length |\n // | | 164 | ** | assetData Contents |\n //\n // (*): offset is computed from start of function parameters, so offset\n // by an additional 4 bytes in the calldata.\n //\n // (**): see table below to compute length of assetData Contents\n //\n // WARNING: The ABIv2 specification allows additional padding between\n // the Params and Data section. This will result in a larger\n // offset to assetData.\n\n // Load offset to `assetData`\n let assetDataOffset := add(calldataload(4), 4)\n\n // Load length in bytes of `assetData`\n let assetDataLength := calldataload(assetDataOffset)\n\n // Asset data itself is encoded as follows:\n //\n // | Area | Offset | Length | Contents |\n // |----------|-------------|---------|-------------------------------------|\n // | Header | 0 | 4 | assetProxyId |\n // | Params | | 2 * 32 | function parameters: |\n // | | 4 | | 1. offset to amounts (*) |\n // | | 36 | | 2. offset to nestedAssetData (*) |\n // | Data | | | amounts: |\n // | | 68 | 32 | amounts Length |\n // | | 100 | a | amounts Contents |\n // | | | | nestedAssetData: |\n // | | 100 + a | 32 | nestedAssetData Length |\n // | | 132 + a | b | nestedAssetData Contents (offsets) |\n // | | 132 + a + b | | nestedAssetData[0, ..., len] |\n\n // Assert that the length of asset data:\n // 1. Must be at least 68 bytes (see table above)\n // 2. Must be a multiple of 32 (excluding the 4-byte selector)\n if or(lt(assetDataLength, 68), mod(sub(assetDataLength, 4), 32)) {\n // Revert with `Error(\"INVALID_ASSET_DATA_LENGTH\")`\n mstore(0, 0x08c379a000000000000000000000000000000000000000000000000000000000)\n mstore(32, 0x0000002000000000000000000000000000000000000000000000000000000000)\n mstore(64, 0x00000019494e56414c49445f41535345545f444154415f4c454e475448000000)\n mstore(96, 0)\n revert(0, 100)\n }\n\n // End of asset data in calldata\n // assetDataOffset\n // + 32 (assetData len)\n let assetDataEnd := add(assetDataOffset, add(assetDataLength, 32))\n if gt(assetDataEnd, calldatasize()) {\n // Revert with `Error(\"INVALID_ASSET_DATA_END\")`\n mstore(0, 0x08c379a000000000000000000000000000000000000000000000000000000000)\n mstore(32, 0x0000002000000000000000000000000000000000000000000000000000000000)\n mstore(64, 0x00000016494e56414c49445f41535345545f444154415f454e44000000000000)\n mstore(96, 0)\n revert(0, 100)\n }\n\n // In order to find the offset to `amounts`, we must add:\n // assetDataOffset\n // + 32 (assetData len)\n // + 4 (assetProxyId)\n let amountsOffset := calldataload(add(assetDataOffset, 36))\n\n // In order to find the offset to `nestedAssetData`, we must add:\n // assetDataOffset\n // + 32 (assetData len)\n // + 4 (assetProxyId)\n // + 32 (amounts offset)\n let nestedAssetDataOffset := calldataload(add(assetDataOffset, 68))\n\n // In order to find the start of the `amounts` contents, we must add:\n // assetDataOffset\n // + 32 (assetData len)\n // + 4 (assetProxyId)\n // + amountsOffset\n // + 32 (amounts len)\n let amountsContentsStart := add(assetDataOffset, add(amountsOffset, 68))\n\n // Load number of elements in `amounts`\n let amountsLen := calldataload(sub(amountsContentsStart, 32))\n\n // In order to find the start of the `nestedAssetData` contents, we must add:\n // assetDataOffset\n // + 32 (assetData len)\n // + 4 (assetProxyId)\n // + nestedAssetDataOffset\n // + 32 (nestedAssetData len)\n let nestedAssetDataContentsStart := add(assetDataOffset, add(nestedAssetDataOffset, 68))\n\n // Load number of elements in `nestedAssetData`\n let nestedAssetDataLen := calldataload(sub(nestedAssetDataContentsStart, 32))\n\n // Revert if number of elements in `amounts` differs from number of elements in `nestedAssetData`\n if sub(amountsLen, nestedAssetDataLen) {\n // Revert with `Error(\"LENGTH_MISMATCH\")`\n mstore(0, 0x08c379a000000000000000000000000000000000000000000000000000000000)\n mstore(32, 0x0000002000000000000000000000000000000000000000000000000000000000)\n mstore(64, 0x0000000f4c454e4754485f4d49534d4154434800000000000000000000000000)\n mstore(96, 0)\n revert(0, 100)\n }\n\n // Copy `transferFrom` selector, offset to `assetData`, `from`, and `to` from calldata to memory\n calldatacopy(\n 0, // memory can safely be overwritten from beginning\n 0, // start of calldata\n 100 // length of selector (4) and 3 params (32 * 3)\n )\n\n // Overwrite existing offset to `assetData` with our own\n mstore(4, 128)\n\n // Load `amount`\n let amount := calldataload(100)\n\n // Calculate number of bytes in `amounts` contents\n let amountsByteLen := mul(amountsLen, 32)\n\n // Initialize `assetProxyId` and `assetProxy` to 0\n let assetProxyId := 0\n let assetProxy := 0\n\n // Loop through `amounts` and `nestedAssetData`, calling `transferFrom` for each respective element\n for {let i := 0} lt(i, amountsByteLen) {i := add(i, 32)} {\n\n // Calculate the total amount\n let amountsElement := calldataload(add(amountsContentsStart, i))\n let totalAmount := mul(amountsElement, amount)\n\n // Revert if `amount` != 0 and multiplication resulted in an overflow\n if iszero(or(\n iszero(amount),\n eq(div(totalAmount, amount), amountsElement)\n )) {\n // Revert with `Error(\"UINT256_OVERFLOW\")`\n mstore(0, 0x08c379a000000000000000000000000000000000000000000000000000000000)\n mstore(32, 0x0000002000000000000000000000000000000000000000000000000000000000)\n mstore(64, 0x0000001055494e543235365f4f564552464c4f57000000000000000000000000)\n mstore(96, 0)\n revert(0, 100)\n }\n\n // Write `totalAmount` to memory\n mstore(100, totalAmount)\n\n // Load offset to `nestedAssetData[i]`\n let nestedAssetDataElementOffset := calldataload(add(nestedAssetDataContentsStart, i))\n\n // In order to find the start of the `nestedAssetData[i]` contents, we must add:\n // assetDataOffset\n // + 32 (assetData len)\n // + 4 (assetProxyId)\n // + nestedAssetDataOffset\n // + 32 (nestedAssetData len)\n // + nestedAssetDataElementOffset\n // + 32 (nestedAssetDataElement len)\n let nestedAssetDataElementContentsStart := add(\n assetDataOffset,\n add(\n nestedAssetDataOffset,\n add(nestedAssetDataElementOffset, 100)\n )\n )\n\n // Load length of `nestedAssetData[i]`\n let nestedAssetDataElementLenStart := sub(nestedAssetDataElementContentsStart, 32)\n let nestedAssetDataElementLen := calldataload(nestedAssetDataElementLenStart)\n\n // Revert if the `nestedAssetData` does not contain a 4 byte `assetProxyId`\n if lt(nestedAssetDataElementLen, 4) {\n // Revert with `Error(\"LENGTH_GREATER_THAN_3_REQUIRED\")`\n mstore(0, 0x08c379a000000000000000000000000000000000000000000000000000000000)\n mstore(32, 0x0000002000000000000000000000000000000000000000000000000000000000)\n mstore(64, 0x0000001e4c454e4754485f475245415445525f5448414e5f335f524551554952)\n mstore(96, 0x4544000000000000000000000000000000000000000000000000000000000000)\n revert(0, 100)\n }\n\n // Load AssetProxy id\n let currentAssetProxyId := and(\n calldataload(nestedAssetDataElementContentsStart),\n 0xffffffff00000000000000000000000000000000000000000000000000000000\n )\n\n // Only load `assetProxy` if `currentAssetProxyId` does not equal `assetProxyId`\n // We do not need to check if `currentAssetProxyId` is 0 since `assetProxy` is also initialized to 0\n if sub(currentAssetProxyId, assetProxyId) {\n // Update `assetProxyId`\n assetProxyId := currentAssetProxyId\n // To lookup a value in a mapping, we load from the storage location keccak256(k, p),\n // where k is the key left padded to 32 bytes and p is the storage slot\n mstore(132, assetProxyId)\n mstore(164, assetProxies_slot)\n assetProxy := sload(keccak256(132, 64))\n }\n\n // Revert if AssetProxy with given id does not exist\n if iszero(assetProxy) {\n // Revert with `Error(\"ASSET_PROXY_DOES_NOT_EXIST\")`\n mstore(0, 0x08c379a000000000000000000000000000000000000000000000000000000000)\n mstore(32, 0x0000002000000000000000000000000000000000000000000000000000000000)\n mstore(64, 0x0000001a41535345545f50524f58595f444f45535f4e4f545f45584953540000)\n mstore(96, 0)\n revert(0, 100)\n }\n\n // Copy `nestedAssetData[i]` from calldata to memory\n calldatacopy(\n 132, // memory slot after `amounts[i]`\n nestedAssetDataElementLenStart, // location of `nestedAssetData[i]` in calldata\n add(nestedAssetDataElementLen, 32) // `nestedAssetData[i].length` plus 32 byte length\n )\n\n // call `assetProxy.transferFrom`\n let success := call(\n gas, // forward all gas\n assetProxy, // call address of asset proxy\n 0, // don't send any ETH\n 0, // pointer to start of input\n add(164, nestedAssetDataElementLen), // length of input\n 0, // write output over memory that won't be reused\n 0 // don't copy output to memory\n )\n\n // Revert with reason given by AssetProxy if `transferFrom` call failed\n if iszero(success) {\n returndatacopy(\n 0, // copy to memory at 0\n 0, // copy from return data at 0\n returndatasize() // copy all return data\n )\n revert(0, returndatasize())\n }\n }\n\n // Return if no `transferFrom` calls reverted\n return(0, 0)\n }\n\n // Revert if undefined function is called\n revert(0, 0)\n }\n }\n\n /// @dev Gets the proxy id associated with the proxy address.\n /// @return Proxy id.\n function getProxyId()\n external\n pure\n returns (bytes4)\n {\n return PROXY_ID;\n }\n}\n" }, "/Users/amir/github/0xproject/0x-monorepo/contracts/asset-proxy/contracts/src/StaticCallProxy.sol": { "content": "/*\n\n Copyright 2019 ZeroEx Intl.\n\n Licensed under the Apache License, Version 2.0 (the \"License\");\n you may not use this file except in compliance with the License.\n You may obtain a copy of the License at\n\n http://www.apache.org/licenses/LICENSE-2.0\n\n Unless required by applicable law or agreed to in writing, software\n distributed under the License is distributed on an \"AS IS\" BASIS,\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n See the License for the specific language governing permissions and\n limitations under the License.\n\n*/\n\npragma solidity ^0.5.9;\n\nimport \"@0x/contracts-utils/contracts/src/LibBytes.sol\";\n\n\n// solhint-disable no-unused-vars\ncontract StaticCallProxy {\n\n using LibBytes for bytes;\n\n // Id of this proxy.\n bytes4 constant internal PROXY_ID = bytes4(keccak256(\"StaticCall(address,bytes,bytes32)\"));\n\n /// @dev Makes a staticcall to a target address and verifies that the data returned matches the expected return data.\n /// @param assetData Byte array encoded with staticCallTarget, staticCallData, and expectedCallResultHash\n /// @param from This value is ignored.\n /// @param to This value is ignored.\n /// @param amount This value is ignored.\n function transferFrom(\n bytes calldata assetData,\n address from,\n address to,\n uint256 amount\n )\n external\n view\n {\n // Decode params from `assetData`\n (\n address staticCallTarget,\n bytes memory staticCallData,\n bytes32 expectedReturnDataHash\n ) = abi.decode(\n assetData.sliceDestructive(4, assetData.length),\n (address, bytes, bytes32)\n );\n\n // Execute staticcall\n (bool success, bytes memory returnData) = staticCallTarget.staticcall(staticCallData);\n\n // Revert with returned data if staticcall is unsuccessful\n if (!success) {\n assembly {\n revert(add(returnData, 32), mload(returnData))\n }\n }\n\n // Revert if hash of return data is not as expected\n bytes32 returnDataHash = keccak256(returnData);\n require(\n expectedReturnDataHash == returnDataHash,\n \"UNEXPECTED_STATIC_CALL_RESULT\"\n );\n }\n\n /// @dev Gets the proxy id associated with the proxy address.\n /// @return Proxy id.\n function getProxyId()\n external\n pure\n returns (bytes4)\n {\n return PROXY_ID;\n }\n}\n" }, "/Users/amir/github/0xproject/0x-monorepo/contracts/asset-proxy/contracts/src/bridges/Eth2DaiBridge.sol": { "content": "/*\n\n Copyright 2019 ZeroEx Intl.\n\n Licensed under the Apache License, Version 2.0 (the \"License\");\n you may not use this file except in compliance with the License.\n You may obtain a copy of the License at\n\n http://www.apache.org/licenses/LICENSE-2.0\n\n Unless required by applicable law or agreed to in writing, software\n distributed under the License is distributed on an \"AS IS\" BASIS,\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n See the License for the specific language governing permissions and\n limitations under the License.\n\n*/\n\npragma solidity ^0.5.9;\npragma experimental ABIEncoderV2;\n\nimport \"@0x/contracts-erc20/contracts/src/interfaces/IERC20Token.sol\";\nimport \"@0x/contracts-erc20/contracts/src/LibERC20Token.sol\";\nimport \"@0x/contracts-exchange-libs/contracts/src/IWallet.sol\";\nimport \"../interfaces/IERC20Bridge.sol\";\nimport \"../interfaces/IEth2Dai.sol\";\n\n\n// solhint-disable space-after-comma\ncontract Eth2DaiBridge is\n IERC20Bridge,\n IWallet\n{\n /* Mainnet addresses */\n address constant public ETH2DAI_ADDRESS = 0x39755357759cE0d7f32dC8dC45414CCa409AE24e;\n\n /// @dev Callback for `IERC20Bridge`. Tries to buy `amount` of\n /// `toTokenAddress` tokens by selling the entirety of the opposing asset\n /// (DAI or WETH) to the Eth2Dai contract, then transfers the bought\n /// tokens to `to`.\n /// @param toTokenAddress The token to give to `to` (either DAI or WETH).\n /// @param to The recipient of the bought tokens.\n /// @param amount Minimum amount of `toTokenAddress` tokens to buy.\n /// @param bridgeData The abi-encoeded \"from\" token address.\n /// @return success The magic bytes if successful.\n function bridgeTransferFrom(\n address toTokenAddress,\n address /* from */,\n address to,\n uint256 amount,\n bytes calldata bridgeData\n )\n external\n returns (bytes4 success)\n {\n // Decode the bridge data to get the `fromTokenAddress`.\n (address fromTokenAddress) = abi.decode(bridgeData, (address));\n\n IEth2Dai exchange = _getEth2DaiContract();\n // Grant an allowance to the exchange to spend `fromTokenAddress` token.\n LibERC20Token.approve(fromTokenAddress, address(exchange), uint256(-1));\n\n // Try to sell all of this contract's `fromTokenAddress` token balance.\n uint256 boughtAmount = _getEth2DaiContract().sellAllAmount(\n address(fromTokenAddress),\n IERC20Token(fromTokenAddress).balanceOf(address(this)),\n toTokenAddress,\n amount\n );\n // Transfer the converted `toToken`s to `to`.\n LibERC20Token.transfer(toTokenAddress, to, boughtAmount);\n return BRIDGE_SUCCESS;\n }\n\n /// @dev `SignatureType.Wallet` callback, so that this bridge can be the maker\n /// and sign for itself in orders. Always succeeds.\n /// @return magicValue Magic success bytes, always.\n function isValidSignature(\n bytes32,\n bytes calldata\n )\n external\n view\n returns (bytes4 magicValue)\n {\n return LEGACY_WALLET_MAGIC_VALUE;\n }\n\n /// @dev Overridable way to get the eth2dai contract.\n /// @return exchange The Eth2Dai exchange contract.\n function _getEth2DaiContract()\n internal\n view\n returns (IEth2Dai exchange)\n {\n return IEth2Dai(ETH2DAI_ADDRESS);\n }\n}\n" }, "/Users/amir/github/0xproject/0x-monorepo/contracts/asset-proxy/node_modules/@0x/contracts-erc20/contracts/src/LibERC20Token.sol": { "content": "/*\n\n Copyright 2019 ZeroEx Intl.\n\n Licensed under the Apache License, Version 2.0 (the \"License\");\n you may not use this file except in compliance with the License.\n You may obtain a copy of the License at\n\n http://www.apache.org/licenses/LICENSE-2.0\n\n Unless required by applicable law or agreed to in writing, software\n distributed under the License is distributed on an \"AS IS\" BASIS,\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n See the License for the specific language governing permissions and\n limitations under the License.\n\n*/\n\npragma solidity ^0.5.9;\n\nimport \"@0x/contracts-utils/contracts/src/LibRichErrors.sol\";\nimport \"@0x/contracts-utils/contracts/src/LibBytes.sol\";\nimport \"../src/interfaces/IERC20Token.sol\";\n\n\nlibrary LibERC20Token {\n\n /// @dev Calls `IERC20Token(token).approve()`.\n /// Reverts if `false` is returned or if the return\n /// data length is nonzero and not 32 bytes.\n /// @param token The address of the token contract.\n /// @param spender The address that receives an allowance.\n /// @param allowance The allowance to set.\n function approve(\n address token,\n address spender,\n uint256 allowance\n )\n internal\n {\n bytes memory callData = abi.encodeWithSelector(\n IERC20Token(0).approve.selector,\n spender,\n allowance\n );\n _callWithOptionalBooleanResult(token, callData);\n }\n\n /// @dev Calls `IERC20Token(token).transfer()`.\n /// Reverts if `false` is returned or if the return\n /// data length is nonzero and not 32 bytes.\n /// @param token The address of the token contract.\n /// @param to The address that receives the tokens\n /// @param amount Number of tokens to transfer.\n function transfer(\n address token,\n address to,\n uint256 amount\n )\n internal\n {\n bytes memory callData = abi.encodeWithSelector(\n IERC20Token(0).transfer.selector,\n to,\n amount\n );\n _callWithOptionalBooleanResult(token, callData);\n }\n\n /// @dev Calls `IERC20Token(token).transferFrom()`.\n /// Reverts if `false` is returned or if the return\n /// data length is nonzero and not 32 bytes.\n /// @param token The address of the token contract.\n /// @param from The owner of the tokens.\n /// @param to The address that receives the tokens\n /// @param amount Number of tokens to transfer.\n function transferFrom(\n address token,\n address from,\n address to,\n uint256 amount\n )\n internal\n {\n bytes memory callData = abi.encodeWithSelector(\n IERC20Token(0).transferFrom.selector,\n from,\n to,\n amount\n );\n _callWithOptionalBooleanResult(token, callData);\n }\n\n /// @dev Executes a call on address `target` with calldata `callData`\n /// and asserts that either nothing was returned or a single boolean\n /// was returned equal to `true`.\n /// @param target The call target.\n /// @param callData The abi-encoded call data.\n function _callWithOptionalBooleanResult(\n address target,\n bytes memory callData\n )\n private\n {\n (bool didSucceed, bytes memory resultData) = target.call(callData);\n if (didSucceed) {\n if (resultData.length == 0) {\n return;\n }\n if (resultData.length == 32) {\n uint256 result = LibBytes.readUint256(resultData, 0);\n if (result == 1) {\n return;\n }\n }\n }\n LibRichErrors.rrevert(resultData);\n }\n}\n" }, "/Users/amir/github/0xproject/0x-monorepo/node_modules/@0x/contracts-exchange-libs/contracts/src/IWallet.sol": { "content": "/*\n\n Copyright 2019 ZeroEx Intl.\n\n Licensed under the Apache License, Version 2.0 (the \"License\");\n you may not use this file except in compliance with the License.\n You may obtain a copy of the License at\n\n http://www.apache.org/licenses/LICENSE-2.0\n\n Unless required by applicable law or agreed to in writing, software\n distributed under the License is distributed on an \"AS IS\" BASIS,\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n See the License for the specific language governing permissions and\n limitations under the License.\n\n*/\n\npragma solidity ^0.5.9;\npragma experimental ABIEncoderV2;\n\n\ncontract IWallet {\n\n bytes4 internal constant LEGACY_WALLET_MAGIC_VALUE = 0xb0671381;\n\n /// @dev Validates a hash with the `Wallet` signature type.\n /// @param hash Message hash that is signed.\n /// @param signature Proof of signing.\n /// @return magicValue `bytes4(0xb0671381)` if the signature check succeeds.\n function isValidSignature(\n bytes32 hash,\n bytes calldata signature\n )\n external\n view\n returns (bytes4 magicValue);\n}\n" }, "/Users/amir/github/0xproject/0x-monorepo/contracts/asset-proxy/contracts/src/interfaces/IEth2Dai.sol": { "content": "/*\n\n Copyright 2019 ZeroEx Intl.\n\n Licensed under the Apache License, Version 2.0 (the \"License\");\n you may not use this file except in compliance with the License.\n You may obtain a copy of the License at\n\n http://www.apache.org/licenses/LICENSE-2.0\n\n Unless required by applicable law or agreed to in writing, software\n distributed under the License is distributed on an \"AS IS\" BASIS,\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n See the License for the specific language governing permissions and\n limitations under the License.\n\n*/\n\npragma solidity ^0.5.9;\n\n\ninterface IEth2Dai {\n\n /// @dev Sell `sellAmount` of `fromToken` token and receive `toToken` token.\n /// @param fromToken The token being sold.\n /// @param sellAmount The amount of `fromToken` token being sold.\n /// @param toToken The token being bought.\n /// @param minFillAmount Minimum amount of `toToken` token to buy.\n /// @return fillAmount Amount of `toToken` bought.\n function sellAllAmount(\n address fromToken,\n uint256 sellAmount,\n address toToken,\n uint256 minFillAmount\n )\n external\n returns (uint256 fillAmount);\n}\n" }, "/Users/amir/github/0xproject/0x-monorepo/contracts/asset-proxy/contracts/src/bridges/UniswapBridge.sol": { "content": "/*\n\n Copyright 2019 ZeroEx Intl.\n\n Licensed under the Apache License, Version 2.0 (the \"License\");\n you may not use this file except in compliance with the License.\n You may obtain a copy of the License at\n\n http://www.apache.org/licenses/LICENSE-2.0\n\n Unless required by applicable law or agreed to in writing, software\n distributed under the License is distributed on an \"AS IS\" BASIS,\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n See the License for the specific language governing permissions and\n limitations under the License.\n\n*/\n\npragma solidity ^0.5.9;\npragma experimental ABIEncoderV2;\n\nimport \"@0x/contracts-erc20/contracts/src/interfaces/IERC20Token.sol\";\nimport \"@0x/contracts-erc20/contracts/src/interfaces/IEtherToken.sol\";\nimport \"@0x/contracts-erc20/contracts/src/LibERC20Token.sol\";\nimport \"@0x/contracts-exchange-libs/contracts/src/IWallet.sol\";\nimport \"../interfaces/IUniswapExchangeFactory.sol\";\nimport \"../interfaces/IUniswapExchange.sol\";\nimport \"../interfaces/IERC20Bridge.sol\";\n\n\n// solhint-disable space-after-comma\n// solhint-disable not-rely-on-time\ncontract UniswapBridge is\n IERC20Bridge,\n IWallet\n{\n /* Mainnet addresses */\n address constant private UNISWAP_EXCHANGE_FACTORY_ADDRESS = 0xc0a47dFe034B400B47bDaD5FecDa2621de6c4d95;\n address constant private WETH_ADDRESS = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;\n\n // Struct to hold `bridgeTransferFrom()` local variables in memory and to avoid\n // stack overflows.\n struct WithdrawToState {\n IUniswapExchange exchange;\n uint256 fromTokenBalance;\n IEtherToken weth;\n }\n\n // solhint-disable no-empty-blocks\n /// @dev Payable fallback to receive ETH from uniswap.\n function ()\n external\n payable\n {}\n\n /// @dev Callback for `IERC20Bridge`. Tries to buy `amount` of\n /// `toTokenAddress` tokens by selling the entirety of the `fromTokenAddress`\n /// token encoded in the bridge data.\n /// @param toTokenAddress The token to buy and transfer to `to`.\n /// @param to The recipient of the bought tokens.\n /// @param amount Minimum amount of `toTokenAddress` tokens to buy.\n /// @param bridgeData The abi-encoded \"from\" token address.\n /// @return success The magic bytes if successful.\n function bridgeTransferFrom(\n address toTokenAddress,\n address /* from */,\n address to,\n uint256 amount,\n bytes calldata bridgeData\n )\n external\n returns (bytes4 success)\n {\n // State memory object to avoid stack overflows.\n WithdrawToState memory state;\n // Decode the bridge data to get the `fromTokenAddress`.\n (address fromTokenAddress) = abi.decode(bridgeData, (address));\n\n // Just transfer the tokens if they're the same.\n if (fromTokenAddress == toTokenAddress) {\n LibERC20Token.transfer(fromTokenAddress, to, amount);\n return BRIDGE_SUCCESS;\n }\n\n // Get the exchange for the token pair.\n state.exchange = _getUniswapExchangeForTokenPair(\n fromTokenAddress,\n toTokenAddress\n );\n // Get our balance of `fromTokenAddress` token.\n state.fromTokenBalance = IERC20Token(fromTokenAddress).balanceOf(address(this));\n // Get the weth contract.\n state.weth = getWethContract();\n\n // Convert from WETH to a token.\n if (fromTokenAddress == address(state.weth)) {\n // Unwrap the WETH.\n state.weth.withdraw(state.fromTokenBalance);\n // Buy as much of `toTokenAddress` token with ETH as possible and\n // transfer it to `to`.\n state.exchange.ethToTokenTransferInput.value(state.fromTokenBalance)(\n // Minimum buy amount.\n amount,\n // Expires after this block.\n block.timestamp,\n // Recipient is `to`.\n to\n );\n\n // Convert from a token to WETH.\n } else if (toTokenAddress == address(state.weth)) {\n // Grant the exchange an allowance.\n _grantExchangeAllowance(state.exchange, fromTokenAddress);\n // Buy as much ETH with `fromTokenAddress` token as possible.\n uint256 ethBought = state.exchange.tokenToEthSwapInput(\n // Sell all tokens we hold.\n state.fromTokenBalance,\n // Minimum buy amount.\n amount,\n // Expires after this block.\n block.timestamp\n );\n // Wrap the ETH.\n state.weth.deposit.value(ethBought)();\n // Transfer the WETH to `to`.\n IEtherToken(toTokenAddress).transfer(to, ethBought);\n\n // Convert from one token to another.\n } else {\n // Grant the exchange an allowance.\n _grantExchangeAllowance(state.exchange, fromTokenAddress);\n // Buy as much `toTokenAddress` token with `fromTokenAddress` token\n // and transfer it to `to`.\n state.exchange.tokenToTokenTransferInput(\n // Sell all tokens we hold.\n state.fromTokenBalance,\n // Minimum buy amount.\n amount,\n // No minimum intermediate ETH buy amount.\n 0,\n // Expires after this block.\n block.timestamp,\n // Recipient is `to`.\n to,\n // Convert to `toTokenAddress`.\n toTokenAddress\n );\n }\n return BRIDGE_SUCCESS;\n }\n\n /// @dev `SignatureType.Wallet` callback, so that this bridge can be the maker\n /// and sign for itself in orders. Always succeeds.\n /// @return magicValue Success bytes, always.\n function isValidSignature(\n bytes32,\n bytes calldata\n )\n external\n view\n returns (bytes4 magicValue)\n {\n return LEGACY_WALLET_MAGIC_VALUE;\n }\n\n /// @dev Overridable way to get the weth contract.\n /// @return token The WETH contract.\n function getWethContract()\n public\n view\n returns (IEtherToken token)\n {\n return IEtherToken(WETH_ADDRESS);\n }\n\n /// @dev Overridable way to get the uniswap exchange factory contract.\n /// @return factory The exchange factory contract.\n function getUniswapExchangeFactoryContract()\n public\n view\n returns (IUniswapExchangeFactory factory)\n {\n return IUniswapExchangeFactory(UNISWAP_EXCHANGE_FACTORY_ADDRESS);\n }\n\n /// @dev Grants an unlimited allowance to the exchange for its token\n /// on behalf of this contract.\n /// @param exchange The Uniswap token exchange.\n /// @param tokenAddress The token address for the exchange.\n function _grantExchangeAllowance(IUniswapExchange exchange, address tokenAddress)\n private\n {\n LibERC20Token.approve(tokenAddress, address(exchange), uint256(-1));\n }\n\n /// @dev Retrieves the uniswap exchange for a given token pair.\n /// In the case of a WETH-token exchange, this will be the non-WETH token.\n /// In th ecase of a token-token exchange, this will be the first token.\n /// @param fromTokenAddress The address of the token we are converting from.\n /// @param toTokenAddress The address of the token we are converting to.\n /// @return exchange The uniswap exchange.\n function _getUniswapExchangeForTokenPair(\n address fromTokenAddress,\n address toTokenAddress\n )\n private\n view\n returns (IUniswapExchange exchange)\n {\n address exchangeTokenAddress = fromTokenAddress;\n // Whichever isn't WETH is the exchange token.\n if (fromTokenAddress == address(getWethContract())) {\n exchangeTokenAddress = toTokenAddress;\n }\n exchange = getUniswapExchangeFactoryContract().getExchange(exchangeTokenAddress);\n require(address(exchange) != address(0), \"NO_UNISWAP_EXCHANGE_FOR_TOKEN\");\n return exchange;\n }\n}\n" }, "/Users/amir/github/0xproject/0x-monorepo/contracts/asset-proxy/node_modules/@0x/contracts-erc20/contracts/src/interfaces/IEtherToken.sol": { "content": "/*\n\n Copyright 2019 ZeroEx Intl.\n\n Licensed under the Apache License, Version 2.0 (the \"License\");\n you may not use this file except in compliance with the License.\n You may obtain a copy of the License at\n\n http://www.apache.org/licenses/LICENSE-2.0\n\n Unless required by applicable law or agreed to in writing, software\n distributed under the License is distributed on an \"AS IS\" BASIS,\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n See the License for the specific language governing permissions and\n limitations under the License.\n\n*/\n\npragma solidity ^0.5.9;\n\nimport \"./IERC20Token.sol\";\n\n\ncontract IEtherToken is\n IERC20Token\n{\n function deposit()\n public\n payable;\n \n function withdraw(uint256 amount)\n public;\n}\n" }, "/Users/amir/github/0xproject/0x-monorepo/contracts/asset-proxy/contracts/src/interfaces/IUniswapExchangeFactory.sol": { "content": "/*\n\n Copyright 2019 ZeroEx Intl.\n\n Licensed under the Apache License, Version 2.0 (the \"License\");\n you may not use this file except in compliance with the License.\n You may obtain a copy of the License at\n\n http://www.apache.org/licenses/LICENSE-2.0\n\n Unless required by applicable law or agreed to in writing, software\n distributed under the License is distributed on an \"AS IS\" BASIS,\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n See the License for the specific language governing permissions and\n limitations under the License.\n\n*/\n\npragma solidity ^0.5.9;\n\nimport \"./IUniswapExchange.sol\";\n\n\ninterface IUniswapExchangeFactory {\n\n /// @dev Get the exchange for a token.\n /// @param tokenAddress The address of the token contract.\n function getExchange(address tokenAddress)\n external\n view\n returns (IUniswapExchange);\n}\n" }, "/Users/amir/github/0xproject/0x-monorepo/contracts/asset-proxy/contracts/src/interfaces/IUniswapExchange.sol": { "content": "/*\n\n Copyright 2019 ZeroEx Intl.\n\n Licensed under the Apache License, Version 2.0 (the \"License\");\n you may not use this file except in compliance with the License.\n You may obtain a copy of the License at\n\n http://www.apache.org/licenses/LICENSE-2.0\n\n Unless required by applicable law or agreed to in writing, software\n distributed under the License is distributed on an \"AS IS\" BASIS,\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n See the License for the specific language governing permissions and\n limitations under the License.\n\n*/\n\npragma solidity ^0.5.9;\n\n\ninterface IUniswapExchange {\n\n /// @dev Buys at least `minTokensBought` tokens with ETH and transfer them\n /// to `recipient`.\n /// @param minTokensBought The minimum number of tokens to buy.\n /// @param deadline Time when this order expires.\n /// @param recipient Who to transfer the tokens to.\n /// @return tokensBought Amount of tokens bought.\n function ethToTokenTransferInput(\n uint256 minTokensBought,\n uint256 deadline,\n address recipient\n )\n external\n payable\n returns (uint256 tokensBought);\n\n /// @dev Buys at least `minEthBought` ETH with tokens.\n /// @param tokensSold Amount of tokens to sell.\n /// @param minEthBought The minimum amount of ETH to buy.\n /// @param deadline Time when this order expires.\n /// @return ethBought Amount of tokens bought.\n function tokenToEthSwapInput(\n uint256 tokensSold,\n uint256 minEthBought,\n uint256 deadline\n )\n external\n returns (uint256 ethBought);\n\n /// @dev Buys at least `minTokensBought` tokens with the exchange token\n /// and transfer them to `recipient`.\n /// @param minTokensBought The minimum number of tokens to buy.\n /// @param minEthBought The minimum amount of intermediate ETH to buy.\n /// @param deadline Time when this order expires.\n /// @param recipient Who to transfer the tokens to.\n /// @param toTokenAddress The token being bought.\n /// @return tokensBought Amount of tokens bought.\n function tokenToTokenTransferInput(\n uint256 tokensSold,\n uint256 minTokensBought,\n uint256 minEthBought,\n uint256 deadline,\n address recipient,\n address toTokenAddress\n )\n external\n returns (uint256 tokensBought);\n\n /// @dev Retrieves the token that is associated with this exchange.\n /// @return tokenAddress The token address.\n function toTokenAddress()\n external\n view\n returns (address tokenAddress);\n}\n" }, "/Users/amir/github/0xproject/0x-monorepo/contracts/asset-proxy/contracts/src/interfaces/IAssetData.sol": { "content": "/*\n\n Copyright 2019 ZeroEx Intl.\n\n Licensed under the Apache License, Version 2.0 (the \"License\");\n you may not use this file except in compliance with the License.\n You may obtain a copy of the License at\n\n http://www.apache.org/licenses/LICENSE-2.0\n\n Unless required by applicable law or agreed to in writing, software\n distributed under the License is distributed on an \"AS IS\" BASIS,\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n See the License for the specific language governing permissions and\n limitations under the License.\n\n*/\n\n// solhint-disable\npragma solidity ^0.5.9;\npragma experimental ABIEncoderV2;\n\n\n// @dev Interface of the asset proxy's assetData.\n// The asset proxies take an ABI encoded `bytes assetData` as argument.\n// This argument is ABI encoded as one of the methods of this interface.\ninterface IAssetData {\n\n /// @dev Function signature for encoding ERC20 assetData.\n /// @param tokenAddress Address of ERC20Token contract.\n function ERC20Token(address tokenAddress)\n external;\n\n /// @dev Function signature for encoding ERC721 assetData.\n /// @param tokenAddress Address of ERC721 token contract.\n /// @param tokenId Id of ERC721 token to be transferred.\n function ERC721Token(\n address tokenAddress,\n uint256 tokenId\n )\n external;\n\n /// @dev Function signature for encoding ERC1155 assetData.\n /// @param tokenAddress Address of ERC1155 token contract.\n /// @param tokenIds Array of ids of tokens to be transferred.\n /// @param values Array of values that correspond to each token id to be transferred.\n /// Note that each value will be multiplied by the amount being filled in the order before transferring.\n /// @param callbackData Extra data to be passed to receiver's `onERC1155Received` callback function.\n function ERC1155Assets(\n address tokenAddress,\n uint256[] calldata tokenIds,\n uint256[] calldata values,\n bytes calldata callbackData\n )\n external;\n\n /// @dev Function signature for encoding MultiAsset assetData.\n /// @param values Array of amounts that correspond to each asset to be transferred.\n /// Note that each value will be multiplied by the amount being filled in the order before transferring.\n /// @param nestedAssetData Array of assetData fields that will be be dispatched to their correspnding AssetProxy contract.\n function MultiAsset(\n uint256[] calldata values,\n bytes[] calldata nestedAssetData\n )\n external;\n\n /// @dev Function signature for encoding StaticCall assetData.\n /// @param staticCallTargetAddress Address that will execute the staticcall.\n /// @param staticCallData Data that will be executed via staticcall on the staticCallTargetAddress.\n /// @param expectedReturnDataHash Keccak-256 hash of the expected staticcall return data.\n function StaticCall(\n address staticCallTargetAddress,\n bytes calldata staticCallData,\n bytes32 expectedReturnDataHash\n )\n external;\n\n /// @dev Function signature for encoding ERC20Bridge assetData.\n /// @param tokenAddress Address of token to transfer.\n /// @param bridgeAddress Address of the bridge contract.\n /// @param bridgeData Arbitrary data to be passed to the bridge contract.\n function ERC20Bridge(\n address tokenAddress,\n address bridgeAddress,\n bytes calldata bridgeData\n )\n external;\n}\n" }, "/Users/amir/github/0xproject/0x-monorepo/contracts/asset-proxy/contracts/test/TestERC20Bridge.sol": { "content": "/*\n\n Copyright 2019 ZeroEx Intl.\n\n Licensed under the Apache License, Version 2.0 (the \"License\");\n you may not use this file except in compliance with the License.\n You may obtain a copy of the License at\n\n http://www.apache.org/licenses/LICENSE-2.0\n\n Unless required by applicable law or agreed to in writing, software\n distributed under the License is distributed on an \"AS IS\" BASIS,\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n See the License for the specific language governing permissions and\n limitations under the License.\n\n*/\n\npragma solidity ^0.5.9;\npragma experimental ABIEncoderV2;\n\nimport \"../src/interfaces/IERC20Bridge.sol\";\n\n\n/// @dev Test bridge token\ncontract TestERC20BridgeToken {\n mapping (address => uint256) private _balances;\n\n function addBalance(address owner, int256 amount)\n external\n {\n setBalance(owner, uint256(int256(balanceOf(owner)) + amount));\n }\n\n function setBalance(address owner, uint256 balance)\n public\n {\n _balances[owner] = balance;\n }\n\n function balanceOf(address owner)\n public\n view\n returns (uint256)\n {\n return _balances[owner];\n }\n}\n\n\n/// @dev Test bridge contract.\ncontract TestERC20Bridge is\n IERC20Bridge\n{\n TestERC20BridgeToken public testToken;\n\n event BridgeWithdrawTo(\n address tokenAddress,\n address from,\n address to,\n uint256 amount,\n bytes bridgeData\n );\n\n constructor() public {\n testToken = new TestERC20BridgeToken();\n }\n\n function setTestTokenBalance(address owner, uint256 balance)\n external\n {\n testToken.setBalance(owner, balance);\n }\n\n function bridgeTransferFrom(\n address tokenAddress,\n address from,\n address to,\n uint256 amount,\n bytes calldata bridgeData\n )\n external\n returns (bytes4)\n {\n emit BridgeWithdrawTo(\n tokenAddress,\n from,\n to,\n amount,\n bridgeData\n );\n // Unpack the bridgeData.\n (\n int256 transferAmount,\n bytes memory revertData,\n bytes memory returnData\n ) = abi.decode(bridgeData, (int256, bytes, bytes));\n\n // If `revertData` is set, revert.\n if (revertData.length != 0) {\n assembly { revert(add(revertData, 0x20), mload(revertData)) }\n }\n // Increase `to`'s balance by `transferAmount`.\n TestERC20BridgeToken(tokenAddress).addBalance(to, transferAmount);\n // Return `returnData`.\n assembly { return(add(returnData, 0x20), mload(returnData)) }\n }\n}\n" }, "/Users/amir/github/0xproject/0x-monorepo/contracts/asset-proxy/contracts/test/TestEth2DaiBridge.sol": { "content": "/*\n\n Copyright 2019 ZeroEx Intl.\n\n Licensed under the Apache License, Version 2.0 (the \"License\");\n you may not use this file except in compliance with the License.\n You may obtain a copy of the License at\n\n http://www.apache.org/licenses/LICENSE-2.0\n\n Unless required by applicable law or agreed to in writing, software\n distributed under the License is distributed on an \"AS IS\" BASIS,\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n See the License for the specific language governing permissions and\n limitations under the License.\n\n*/\n\npragma solidity ^0.5.9;\npragma experimental ABIEncoderV2;\n\nimport \"@0x/contracts-erc20/contracts/src/interfaces/IERC20Token.sol\";\nimport \"../src/bridges/Eth2DaiBridge.sol\";\nimport \"../src/interfaces/IEth2Dai.sol\";\n\n\n// solhint-disable no-simple-event-func-name\ncontract TestEvents {\n\n event TokenTransfer(\n address token,\n address from,\n address to,\n uint256 amount\n );\n\n event TokenApprove(\n address token,\n address spender,\n uint256 allowance\n );\n\n function raiseTokenTransfer(\n address from,\n address to,\n uint256 amount\n )\n external\n {\n emit TokenTransfer(\n msg.sender,\n from,\n to,\n amount\n );\n }\n\n function raiseTokenApprove(address spender, uint256 allowance)\n external\n {\n emit TokenApprove(msg.sender, spender, allowance);\n }\n}\n\n\n/// @dev A minimalist ERC20 token.\ncontract TestToken {\n\n mapping (address => uint256) public balances;\n string private _nextTransferRevertReason;\n bytes private _nextTransferReturnData;\n\n /// @dev Just calls `raiseTokenTransfer()` on the caller.\n function transfer(address to, uint256 amount)\n external\n returns (bool)\n {\n TestEvents(msg.sender).raiseTokenTransfer(msg.sender, to, amount);\n if (bytes(_nextTransferRevertReason).length != 0) {\n revert(_nextTransferRevertReason);\n }\n bytes memory returnData = _nextTransferReturnData;\n assembly { return(add(returnData, 0x20), mload(returnData)) }\n }\n\n /// @dev Set the balance for `owner`.\n function setBalance(address owner, uint256 balance)\n external\n {\n balances[owner] = balance;\n }\n\n /// @dev Set the behavior of the `transfer()` call.\n function setTransferBehavior(\n string calldata revertReason,\n bytes calldata returnData\n )\n external\n {\n _nextTransferRevertReason = revertReason;\n _nextTransferReturnData = returnData;\n }\n\n /// @dev Just calls `raiseTokenApprove()` on the caller.\n function approve(address spender, uint256 allowance)\n external\n returns (bool)\n {\n TestEvents(msg.sender).raiseTokenApprove(spender, allowance);\n return true;\n }\n\n /// @dev Retrieve the balance for `owner`.\n function balanceOf(address owner)\n external\n view\n returns (uint256)\n {\n return balances[owner];\n }\n}\n\n\n/// @dev Eth2DaiBridge overridden to mock tokens and\n/// implement IEth2Dai.\ncontract TestEth2DaiBridge is\n TestEvents,\n IEth2Dai,\n Eth2DaiBridge\n{\n event SellAllAmount(\n address sellToken,\n uint256 sellTokenAmount,\n address buyToken,\n uint256 minimumFillAmount\n );\n\n mapping (address => TestToken) public testTokens;\n string private _nextRevertReason;\n uint256 private _nextFillAmount;\n\n /// @dev Create a token and set this contract's balance.\n function createToken(uint256 balance)\n external\n returns (address tokenAddress)\n {\n TestToken token = new TestToken();\n testTokens[address(token)] = token;\n token.setBalance(address(this), balance);\n return address(token);\n }\n\n /// @dev Set the behavior for `IEth2Dai.sellAllAmount()`.\n function setFillBehavior(string calldata revertReason, uint256 fillAmount)\n external\n {\n _nextRevertReason = revertReason;\n _nextFillAmount = fillAmount;\n }\n\n /// @dev Set the behavior of a token's `transfer()`.\n function setTransferBehavior(\n address tokenAddress,\n string calldata revertReason,\n bytes calldata returnData\n )\n external\n {\n testTokens[tokenAddress].setTransferBehavior(revertReason, returnData);\n }\n\n /// @dev Implementation of `IEth2Dai.sellAllAmount()`\n function sellAllAmount(\n address sellTokenAddress,\n uint256 sellTokenAmount,\n address buyTokenAddress,\n uint256 minimumFillAmount\n )\n external\n returns (uint256 fillAmount)\n {\n emit SellAllAmount(\n sellTokenAddress,\n sellTokenAmount,\n buyTokenAddress,\n minimumFillAmount\n );\n if (bytes(_nextRevertReason).length != 0) {\n revert(_nextRevertReason);\n }\n return _nextFillAmount;\n }\n\n // @dev This contract will double as the Eth2Dai contract.\n function _getEth2DaiContract()\n internal\n view\n returns (IEth2Dai)\n {\n return IEth2Dai(address(this));\n }\n}\n" }, "/Users/amir/github/0xproject/0x-monorepo/contracts/asset-proxy/contracts/test/TestStaticCallTarget.sol": { "content": "/*\n\n Copyright 2019 ZeroEx Intl.\n\n Licensed under the Apache License, Version 2.0 (the \"License\");\n you may not use this file except in compliance with the License.\n You may obtain a copy of the License at\n\n http://www.apache.org/licenses/LICENSE-2.0\n\n Unless required by applicable law or agreed to in writing, software\n distributed under the License is distributed on an \"AS IS\" BASIS,\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n See the License for the specific language governing permissions and\n limitations under the License.\n\n*/\n\npragma solidity ^0.5.9;\n\nimport \"@0x/contracts-utils/contracts/src/LibBytes.sol\";\n\n\ncontract TestStaticCallTarget {\n\n using LibBytes for bytes;\n\n uint256 internal _state;\n \n function updateState()\n external\n {\n _state++;\n }\n\n function assertEvenNumber(uint256 target)\n external\n pure\n {\n require(\n target % 2 == 0,\n \"TARGET_NOT_EVEN\"\n );\n }\n\n function isOddNumber(uint256 target)\n external\n pure\n returns (bool isOdd)\n {\n isOdd = target % 2 == 1;\n return isOdd;\n }\n\n function noInputFunction()\n external\n pure\n {\n assert(msg.data.length == 4 && msg.data.readBytes4(0) == bytes4(keccak256(\"noInputFunction()\")));\n }\n\n function dynamicInputFunction(bytes calldata a)\n external\n pure\n {\n bytes memory abiEncodedData = abi.encodeWithSignature(\"dynamicInputFunction(bytes)\", a);\n assert(msg.data.equals(abiEncodedData));\n }\n\n function returnComplexType(uint256 a, uint256 b)\n external\n view\n returns (bytes memory result)\n {\n result = abi.encodePacked(\n address(this),\n a,\n b\n );\n return result;\n }\n}" }, "/Users/amir/github/0xproject/0x-monorepo/contracts/asset-proxy/contracts/test/TestUniswapBridge.sol": { "content": "/*\n\n Copyright 2019 ZeroEx Intl.\n\n Licensed under the Apache License, Version 2.0 (the \"License\");\n you may not use this file except in compliance with the License.\n You may obtain a copy of the License at\n\n http://www.apache.org/licenses/LICENSE-2.0\n\n Unless required by applicable law or agreed to in writing, software\n distributed under the License is distributed on an \"AS IS\" BASIS,\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n See the License for the specific language governing permissions and\n limitations under the License.\n\n*/\n\npragma solidity ^0.5.9;\npragma experimental ABIEncoderV2;\n\nimport \"@0x/contracts-erc20/contracts/src/interfaces/IERC20Token.sol\";\nimport \"@0x/contracts-utils/contracts/src/LibSafeMath.sol\";\nimport \"../src/bridges/UniswapBridge.sol\";\nimport \"../src/interfaces/IUniswapExchangeFactory.sol\";\nimport \"../src/interfaces/IUniswapExchange.sol\";\n\n\n// solhint-disable no-simple-event-func-name\ncontract TestEventsRaiser {\n\n event TokenTransfer(\n address token,\n address from,\n address to,\n uint256 amount\n );\n\n event TokenApprove(\n address spender,\n uint256 allowance\n );\n\n event WethDeposit(\n uint256 amount\n );\n\n event WethWithdraw(\n uint256 amount\n );\n\n event EthToTokenTransferInput(\n address exchange,\n uint256 minTokensBought,\n uint256 deadline,\n address recipient\n );\n\n event TokenToEthSwapInput(\n address exchange,\n uint256 tokensSold,\n uint256 minEthBought,\n uint256 deadline\n );\n\n event TokenToTokenTransferInput(\n address exchange,\n uint256 tokensSold,\n uint256 minTokensBought,\n uint256 minEthBought,\n uint256 deadline,\n address recipient,\n address toTokenAddress\n );\n\n function raiseEthToTokenTransferInput(\n uint256 minTokensBought,\n uint256 deadline,\n address recipient\n )\n external\n {\n emit EthToTokenTransferInput(\n msg.sender,\n minTokensBought,\n deadline,\n recipient\n );\n }\n\n function raiseTokenToEthSwapInput(\n uint256 tokensSold,\n uint256 minEthBought,\n uint256 deadline\n )\n external\n {\n emit TokenToEthSwapInput(\n msg.sender,\n tokensSold,\n minEthBought,\n deadline\n );\n }\n\n function raiseTokenToTokenTransferInput(\n uint256 tokensSold,\n uint256 minTokensBought,\n uint256 minEthBought,\n uint256 deadline,\n address recipient,\n address toTokenAddress\n )\n external\n {\n emit TokenToTokenTransferInput(\n msg.sender,\n tokensSold,\n minTokensBought,\n minEthBought,\n deadline,\n recipient,\n toTokenAddress\n );\n }\n\n function raiseTokenTransfer(\n address from,\n address to,\n uint256 amount\n )\n external\n {\n emit TokenTransfer(\n msg.sender,\n from,\n to,\n amount\n );\n }\n\n function raiseTokenApprove(address spender, uint256 allowance)\n external\n {\n emit TokenApprove(spender, allowance);\n }\n\n function raiseWethDeposit(uint256 amount)\n external\n {\n emit WethDeposit(amount);\n }\n\n function raiseWethWithdraw(uint256 amount)\n external\n {\n emit WethWithdraw(amount);\n }\n}\n\n\n/// @dev A minimalist ERC20/WETH token.\ncontract TestToken {\n\n using LibSafeMath for uint256;\n\n mapping (address => uint256) public balances;\n string private _nextRevertReason;\n\n /// @dev Set the balance for `owner`.\n function setBalance(address owner)\n external\n payable\n {\n balances[owner] = msg.value;\n }\n\n /// @dev Set the revert reason for `transfer()`,\n /// `deposit()`, and `withdraw()`.\n function setRevertReason(string calldata reason)\n external\n {\n _nextRevertReason = reason;\n }\n\n /// @dev Just calls `raiseTokenTransfer()` on the caller.\n function transfer(address to, uint256 amount)\n external\n returns (bool)\n {\n _revertIfReasonExists();\n TestEventsRaiser(msg.sender).raiseTokenTransfer(msg.sender, to, amount);\n return true;\n }\n\n /// @dev Just calls `raiseTokenApprove()` on the caller.\n function approve(address spender, uint256 allowance)\n external\n returns (bool)\n {\n TestEventsRaiser(msg.sender).raiseTokenApprove(spender, allowance);\n return true;\n }\n\n /// @dev `IWETH.deposit()` that increases balances and calls\n /// `raiseWethDeposit()` on the caller.\n function deposit()\n external\n payable\n {\n _revertIfReasonExists();\n balances[msg.sender] += balances[msg.sender].safeAdd(msg.value);\n TestEventsRaiser(msg.sender).raiseWethDeposit(msg.value);\n }\n\n /// @dev `IWETH.withdraw()` that just reduces balances and calls\n /// `raiseWethWithdraw()` on the caller.\n function withdraw(uint256 amount)\n external\n {\n _revertIfReasonExists();\n balances[msg.sender] = balances[msg.sender].safeSub(amount);\n msg.sender.transfer(amount);\n TestEventsRaiser(msg.sender).raiseWethWithdraw(amount);\n }\n\n /// @dev Retrieve the balance for `owner`.\n function balanceOf(address owner)\n external\n view\n returns (uint256)\n {\n return balances[owner];\n }\n\n function _revertIfReasonExists()\n private\n view\n {\n if (bytes(_nextRevertReason).length != 0) {\n revert(_nextRevertReason);\n }\n }\n}\n\n\ncontract TestExchange is\n IUniswapExchange\n{\n address public tokenAddress;\n string private _nextRevertReason;\n\n constructor(address _tokenAddress) public {\n tokenAddress = _tokenAddress;\n }\n\n function setFillBehavior(\n string calldata revertReason\n )\n external\n payable\n {\n _nextRevertReason = revertReason;\n }\n\n function ethToTokenTransferInput(\n uint256 minTokensBought,\n uint256 deadline,\n address recipient\n )\n external\n payable\n returns (uint256 tokensBought)\n {\n TestEventsRaiser(msg.sender).raiseEthToTokenTransferInput(\n minTokensBought,\n deadline,\n recipient\n );\n _revertIfReasonExists();\n return address(this).balance;\n }\n\n function tokenToEthSwapInput(\n uint256 tokensSold,\n uint256 minEthBought,\n uint256 deadline\n )\n external\n returns (uint256 ethBought)\n {\n TestEventsRaiser(msg.sender).raiseTokenToEthSwapInput(\n tokensSold,\n minEthBought,\n deadline\n );\n _revertIfReasonExists();\n uint256 fillAmount = address(this).balance;\n msg.sender.transfer(fillAmount);\n return fillAmount;\n }\n\n function tokenToTokenTransferInput(\n uint256 tokensSold,\n uint256 minTokensBought,\n uint256 minEthBought,\n uint256 deadline,\n address recipient,\n address toTokenAddress\n )\n external\n returns (uint256 tokensBought)\n {\n TestEventsRaiser(msg.sender).raiseTokenToTokenTransferInput(\n tokensSold,\n minTokensBought,\n minEthBought,\n deadline,\n recipient,\n toTokenAddress\n );\n _revertIfReasonExists();\n return address(this).balance;\n }\n\n function toTokenAddress()\n external\n view\n returns (address _tokenAddress)\n {\n return tokenAddress;\n }\n\n function _revertIfReasonExists()\n private\n view\n {\n if (bytes(_nextRevertReason).length != 0) {\n revert(_nextRevertReason);\n }\n }\n}\n\n\n/// @dev UniswapBridge overridden to mock tokens and implement IUniswapExchangeFactory.\ncontract TestUniswapBridge is\n IUniswapExchangeFactory,\n TestEventsRaiser,\n UniswapBridge\n{\n TestToken public wethToken;\n // Token address to TestToken instance.\n mapping (address => TestToken) private _testTokens;\n // Token address to TestExchange instance.\n mapping (address => TestExchange) private _testExchanges;\n\n constructor() public {\n wethToken = new TestToken();\n _testTokens[address(wethToken)] = wethToken;\n }\n\n /// @dev Sets the balance of this contract for an existing token.\n /// The wei attached will be the balance.\n function setTokenBalance(address tokenAddress)\n external\n payable\n {\n TestToken token = _testTokens[tokenAddress];\n token.deposit.value(msg.value)();\n }\n\n /// @dev Sets the revert reason for an existing token.\n function setTokenRevertReason(address tokenAddress, string calldata revertReason)\n external\n {\n TestToken token = _testTokens[tokenAddress];\n token.setRevertReason(revertReason);\n }\n\n /// @dev Create a token and exchange (if they don't exist) for a new token\n /// and sets the exchange revert and fill behavior. The wei attached\n /// will be the fill amount for the exchange.\n /// @param tokenAddress The token address. If zero, one will be created.\n /// @param revertReason The revert reason for exchange operations.\n function createTokenAndExchange(\n address tokenAddress,\n string calldata revertReason\n )\n external\n payable\n returns (TestToken token, TestExchange exchange)\n {\n token = TestToken(tokenAddress);\n if (tokenAddress == address(0)) {\n token = new TestToken();\n }\n _testTokens[address(token)] = token;\n exchange = _testExchanges[address(token)];\n if (address(exchange) == address(0)) {\n _testExchanges[address(token)] = exchange = new TestExchange(address(token));\n }\n exchange.setFillBehavior.value(msg.value)(revertReason);\n return (token, exchange);\n }\n\n /// @dev `IUniswapExchangeFactory.getExchange`\n function getExchange(address tokenAddress)\n external\n view\n returns (IUniswapExchange)\n {\n return IUniswapExchange(_testExchanges[tokenAddress]);\n }\n\n // @dev Use `wethToken`.\n function getWethContract()\n public\n view\n returns (IEtherToken)\n {\n return IEtherToken(address(wethToken));\n }\n\n // @dev This contract will double as the Uniswap contract.\n function getUniswapExchangeFactoryContract()\n public\n view\n returns (IUniswapExchangeFactory)\n {\n return IUniswapExchangeFactory(address(this));\n }\n}\n" } }, "settings": { "optimizer": { "enabled": true, "runs": 1000000, "details": { "yul": true, "deduplicate": true, "cse": true, "constantOptimizer": true } }, "outputSelection": { "*": { "*": [ "evm.bytecode", "evm.deployedBytecode", "abi" ] } }, "evmVersion": "constantinople", "remappings": [ "@0x/contracts-utils=/Users/amir/github/0xproject/0x-monorepo/contracts/asset-proxy/node_modules/@0x/contracts-utils", "@0x/contracts-erc1155=/Users/amir/github/0xproject/0x-monorepo/contracts/asset-proxy/node_modules/@0x/contracts-erc1155", "@0x/contracts-erc20=/Users/amir/github/0xproject/0x-monorepo/contracts/asset-proxy/node_modules/@0x/contracts-erc20", "@0x/contracts-exchange-libs=/Users/amir/github/0xproject/0x-monorepo/node_modules/@0x/contracts-exchange-libs" ] } }}

Parameter	Type	Description
toTokenAddress	address
	address
to	address
amount	uint256
bridgeData	bytes