Add ERC165Feature

* address feedback from original PR

* Update contracts/zero-ex/contracts/src/features/ERC721OrdersFeature.sol

Co-authored-by: Kim Persson <kimpers@users.noreply.github.com>

* address review feedback and improve order parameter naming

* Add batchCancel function

* Emit order fields in preSign

* Fix tests

Co-authored-by: Lawrence Forman <me@merklejerk.com>
Co-authored-by: Kim Persson <kimpers@users.noreply.github.com>
Co-authored-by: Michael Zhu <mchl.zhu.96@gmail.com>

contracts/erc20/CHANGELOG.json

@@ -1,4 +1,13 @@
 [
+    {
+        "timestamp": 1640364306,
+        "version": "3.3.25",
+        "changes": [
+            {
+                "note": "Dependencies updated"
+            }
+        ]
+    },
     {
         "timestamp": 1638390144,
         "version": "3.3.24",

contracts/erc20/CHANGELOG.md

@@ -5,6 +5,10 @@ Edit the package's CHANGELOG.json file only.
 
 CHANGELOG
 
+## v3.3.25 - _December 24, 2021_
+
+    * Dependencies updated
+
 ## v3.3.24 - _December 1, 2021_
 
     * Dependencies updated

contracts/erc20/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@0x/contracts-erc20",
-    "version": "3.3.24",
+    "version": "3.3.25",
     "engines": {
         "node": ">=6.12"
     },
@@ -51,18 +51,18 @@
     },
     "homepage": "https://github.com/0xProject/protocol/tree/main/contracts/tokens",
     "devDependencies": {
-        "@0x/abi-gen": "^5.6.2",
-        "@0x/contracts-gen": "^2.0.40",
-        "@0x/contracts-test-utils": "^5.4.15",
-        "@0x/contracts-utils": "^4.8.5",
-        "@0x/dev-utils": "^4.2.9",
-        "@0x/sol-compiler": "^4.7.5",
+        "@0x/abi-gen": "^5.7.2",
+        "@0x/contracts-gen": "^2.0.43",
+        "@0x/contracts-test-utils": "^5.4.16",
+        "@0x/contracts-utils": "^4.8.6",
+        "@0x/dev-utils": "^4.2.11",
+        "@0x/sol-compiler": "^4.7.8",
         "@0x/ts-doc-gen": "^0.0.28",
         "@0x/tslint-config": "^4.1.4",
         "@0x/types": "^3.3.4",
         "@0x/typescript-typings": "^5.2.1",
-        "@0x/utils": "^6.4.4",
-        "@0x/web3-wrapper": "^7.6.0",
+        "@0x/utils": "^6.5.0",
+        "@0x/web3-wrapper": "^7.6.2",
         "@types/lodash": "4.14.104",
         "@types/mocha": "^5.2.7",
         "@types/node": "12.12.54",
@@ -82,7 +82,7 @@
         "typescript": "4.2.2"
     },
     "dependencies": {
-        "@0x/base-contract": "^6.4.2",
+        "@0x/base-contract": "^6.4.5",
         "ethers": "~4.0.4"
     },
     "publishConfig": {

contracts/test-utils/CHANGELOG.json

@@ -1,4 +1,13 @@
 [
+    {
+        "timestamp": 1640364306,
+        "version": "5.4.16",
+        "changes": [
+            {
+                "note": "Dependencies updated"
+            }
+        ]
+    },
     {
         "timestamp": 1638390144,
         "version": "5.4.15",

contracts/test-utils/CHANGELOG.md

@@ -5,6 +5,10 @@ Edit the package's CHANGELOG.json file only.
 
 CHANGELOG
 
+## v5.4.16 - _December 24, 2021_
+
+    * Dependencies updated
+
 ## v5.4.15 - _December 1, 2021_
 
     * Dependencies updated

contracts/test-utils/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@0x/contracts-test-utils",
-    "version": "5.4.15",
+    "version": "5.4.16",
     "engines": {
         "node": ">=6.12"
     },
@@ -34,7 +34,7 @@
     },
     "homepage": "https://github.com/0xProject/protocol/tree/main/contracts/test-utils",
     "devDependencies": {
-        "@0x/sol-compiler": "^4.7.5",
+        "@0x/sol-compiler": "^4.7.8",
         "@0x/tslint-config": "^4.1.4",
         "npm-run-all": "^4.1.2",
         "shx": "^0.2.2",
@@ -42,20 +42,20 @@
         "typescript": "4.2.2"
     },
     "dependencies": {
-        "@0x/assert": "^3.0.29",
-        "@0x/base-contract": "^6.4.2",
-        "@0x/contract-addresses": "^6.10.0",
-        "@0x/dev-utils": "^4.2.9",
-        "@0x/json-schemas": "^6.3.0",
+        "@0x/assert": "^3.0.31",
+        "@0x/base-contract": "^6.4.5",
+        "@0x/contract-addresses": "^6.11.0",
+        "@0x/dev-utils": "^4.2.11",
+        "@0x/json-schemas": "^6.4.1",
         "@0x/order-utils": "^10.4.28",
-        "@0x/sol-coverage": "^4.0.39",
-        "@0x/sol-profiler": "^4.1.29",
-        "@0x/sol-trace": "^3.0.39",
-        "@0x/subproviders": "^6.6.0",
+        "@0x/sol-coverage": "^4.0.42",
+        "@0x/sol-profiler": "^4.1.32",
+        "@0x/sol-trace": "^3.0.42",
+        "@0x/subproviders": "^6.6.2",
         "@0x/types": "^3.3.4",
         "@0x/typescript-typings": "^5.2.1",
-        "@0x/utils": "^6.4.4",
-        "@0x/web3-wrapper": "^7.6.0",
+        "@0x/utils": "^6.5.0",
+        "@0x/web3-wrapper": "^7.6.2",
         "@types/bn.js": "^4.11.0",
         "@types/js-combinatorics": "^0.5.29",
         "@types/lodash": "4.14.104",

contracts/treasury/CHANGELOG.json

@@ -1,4 +1,13 @@
 [
+    {
+        "timestamp": 1640364306,
+        "version": "1.4.8",
+        "changes": [
+            {
+                "note": "Dependencies updated"
+            }
+        ]
+    },
     {
         "timestamp": 1638390144,
         "version": "1.4.7",

contracts/treasury/CHANGELOG.md

@@ -5,6 +5,10 @@ Edit the package's CHANGELOG.json file only.
 
 CHANGELOG
 
+## v1.4.8 - _December 24, 2021_
+
+    * Dependencies updated
+
 ## v1.4.7 - _December 1, 2021_
 
     * Dependencies updated

contracts/treasury/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@0x/contracts-treasury",
-    "version": "1.4.7",
+    "version": "1.4.8",
     "engines": {
         "node": ">=6.12"
     },
@@ -46,14 +46,14 @@
     },
     "homepage": "https://github.com/0xProject/protocol/tree/main/contracts/treasury",
     "devDependencies": {
-        "@0x/abi-gen": "^5.6.2",
-        "@0x/contract-addresses": "^6.10.0",
+        "@0x/abi-gen": "^5.7.2",
+        "@0x/contract-addresses": "^6.11.0",
         "@0x/contracts-asset-proxy": "^3.7.19",
-        "@0x/contracts-erc20": "^3.3.24",
-        "@0x/contracts-gen": "^2.0.40",
+        "@0x/contracts-erc20": "^3.3.25",
+        "@0x/contracts-gen": "^2.0.43",
         "@0x/contracts-staking": "^2.0.45",
-        "@0x/contracts-test-utils": "^5.4.15",
-        "@0x/sol-compiler": "^4.7.5",
+        "@0x/contracts-test-utils": "^5.4.16",
+        "@0x/sol-compiler": "^4.7.8",
         "@0x/ts-doc-gen": "^0.0.28",
         "@0x/tslint-config": "^4.1.4",
         "@types/isomorphic-fetch": "^0.0.35",
@@ -72,13 +72,13 @@
         "typescript": "4.2.2"
     },
     "dependencies": {
-        "@0x/base-contract": "^6.4.2",
-        "@0x/protocol-utils": "^1.10.0",
-        "@0x/subproviders": "^6.6.0",
+        "@0x/base-contract": "^6.4.5",
+        "@0x/protocol-utils": "^1.10.1",
+        "@0x/subproviders": "^6.6.2",
         "@0x/types": "^3.3.4",
         "@0x/typescript-typings": "^5.2.1",
-        "@0x/utils": "^6.4.4",
-        "@0x/web3-wrapper": "^7.6.0",
+        "@0x/utils": "^6.5.0",
+        "@0x/web3-wrapper": "^7.6.2",
         "ethereum-types": "^3.6.0",
         "ethereumjs-util": "^7.0.10"
     },

contracts/utils/CHANGELOG.json

@@ -1,4 +1,13 @@
 [
+    {
+        "timestamp": 1640364306,
+        "version": "4.8.6",
+        "changes": [
+            {
+                "note": "Dependencies updated"
+            }
+        ]
+    },
     {
         "timestamp": 1638390144,
         "version": "4.8.5",

contracts/utils/CHANGELOG.md

@@ -5,6 +5,10 @@ Edit the package's CHANGELOG.json file only.
 
 CHANGELOG
 
+## v4.8.6 - _December 24, 2021_
+
+    * Dependencies updated
+
 ## v4.8.5 - _December 1, 2021_
 
     * Dependencies updated

contracts/utils/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@0x/contracts-utils",
-    "version": "4.8.5",
+    "version": "4.8.6",
     "engines": {
         "node": ">=6.12"
     },
@@ -50,15 +50,15 @@
     },
     "homepage": "https://github.com/0xProject/protocol/tree/main/contracts/utils",
     "devDependencies": {
-        "@0x/abi-gen": "^5.6.2",
-        "@0x/contracts-gen": "^2.0.40",
-        "@0x/contracts-test-utils": "^5.4.15",
-        "@0x/dev-utils": "^4.2.9",
+        "@0x/abi-gen": "^5.7.2",
+        "@0x/contracts-gen": "^2.0.43",
+        "@0x/contracts-test-utils": "^5.4.16",
+        "@0x/dev-utils": "^4.2.11",
         "@0x/order-utils": "^10.4.28",
-        "@0x/sol-compiler": "^4.7.5",
+        "@0x/sol-compiler": "^4.7.8",
         "@0x/tslint-config": "^4.1.4",
         "@0x/types": "^3.3.4",
-        "@0x/web3-wrapper": "^7.6.0",
+        "@0x/web3-wrapper": "^7.6.2",
         "@types/bn.js": "^4.11.0",
         "@types/lodash": "4.14.104",
         "@types/mocha": "^5.2.7",
@@ -79,9 +79,9 @@
         "typescript": "4.2.2"
     },
     "dependencies": {
-        "@0x/base-contract": "^6.4.2",
+        "@0x/base-contract": "^6.4.5",
         "@0x/typescript-typings": "^5.2.1",
-        "@0x/utils": "^6.4.4",
+        "@0x/utils": "^6.5.0",
         "bn.js": "^4.11.8",
         "ethereum-types": "^3.6.0"
     },

contracts/zero-ex/CHANGELOG.json

@@ -1,4 +1,13 @@
 [
+    {
+        "timestamp": 1640364306,
+        "version": "0.30.1",
+        "changes": [
+            {
+                "note": "Dependencies updated"
+            }
+        ]
+    },
     {
         "version": "0.30.0",
         "changes": [

contracts/zero-ex/CHANGELOG.md

@@ -5,6 +5,10 @@ Edit the package's CHANGELOG.json file only.
 
 CHANGELOG
 
+## v0.30.1 - _December 24, 2021_
+
+    * Dependencies updated
+
 ## v0.30.0 - _December 1, 2021_
 
     * Add `AaveV2` and `Compound` deposit/withdrawal liquidity source (#321)

contracts/zero-ex/contracts/src/IZeroEx.sol

@@ -34,6 +34,9 @@ import "./features/interfaces/IBatchFillNativeOrdersFeature.sol";
 import "./features/interfaces/IMultiplexFeature.sol";
 import "./features/interfaces/IOtcOrdersFeature.sol";
 import "./features/interfaces/IFundRecoveryFeature.sol";
+import "./features/interfaces/IERC721OrdersFeature.sol";
+import "./features/interfaces/IERC1155OrdersFeature.sol";
+import "./features/interfaces/IERC165Feature.sol";
 
 
 /// @dev Interface for a fully featured Exchange Proxy.
@@ -50,7 +53,10 @@ interface IZeroEx is
     IBatchFillNativeOrdersFeature,
     IMultiplexFeature,
     IOtcOrdersFeature,
-    IFundRecoveryFeature
+    IFundRecoveryFeature,
+    IERC721OrdersFeature,
+    IERC1155OrdersFeature,
+    IERC165Feature
 {
     // solhint-disable state-visibility
 

contracts/zero-ex/contracts/src/errors/LibNFTOrdersRichErrors.sol

@@ -0,0 +1,229 @@
+// SPDX-License-Identifier: Apache-2.0
+/*
+
+  Copyright 2021 ZeroEx Intl.
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+
+*/
+
+pragma solidity ^0.6.5;
+
+
+library LibNFTOrdersRichErrors {
+
+    // solhint-disable func-name-mixedcase
+
+    function OverspentEthError(
+        uint256 ethSpent,
+        uint256 msgValue
+    )
+        internal
+        pure
+        returns (bytes memory)
+    {
+        return abi.encodeWithSelector(
+            bytes4(keccak256("OverspentEthError(uint256,uint256)")),
+            ethSpent,
+            msgValue
+        );
+    }
+
+    function InsufficientEthError(
+        uint256 ethAvailable,
+        uint256 orderAmount
+    )
+        internal
+        pure
+        returns (bytes memory)
+    {
+        return abi.encodeWithSelector(
+            bytes4(keccak256("InsufficientEthError(uint256,uint256)")),
+            ethAvailable,
+            orderAmount
+        );
+    }
+
+    function ERC721TokenMismatchError(
+        address token1,
+        address token2
+    )
+        internal
+        pure
+        returns (bytes memory)
+    {
+        return abi.encodeWithSelector(
+            bytes4(keccak256("ERC721TokenMismatchError(address,address)")),
+            token1,
+            token2
+        );
+    }
+
+    function ERC1155TokenMismatchError(
+        address token1,
+        address token2
+    )
+        internal
+        pure
+        returns (bytes memory)
+    {
+        return abi.encodeWithSelector(
+            bytes4(keccak256("ERC1155TokenMismatchError(address,address)")),
+            token1,
+            token2
+        );
+    }
+
+    function ERC20TokenMismatchError(
+        address token1,
+        address token2
+    )
+        internal
+        pure
+        returns (bytes memory)
+    {
+        return abi.encodeWithSelector(
+            bytes4(keccak256("ERC20TokenMismatchError(address,address)")),
+            token1,
+            token2
+        );
+    }
+
+    function NegativeSpreadError(
+        uint256 sellOrderAmount,
+        uint256 buyOrderAmount
+    )
+        internal
+        pure
+        returns (bytes memory)
+    {
+        return abi.encodeWithSelector(
+            bytes4(keccak256("NegativeSpreadError(uint256,uint256)")),
+            sellOrderAmount,
+            buyOrderAmount
+        );
+    }
+
+    function SellOrderFeesExceedSpreadError(
+        uint256 sellOrderFees,
+        uint256 spread
+    )
+        internal
+        pure
+        returns (bytes memory)
+    {
+        return abi.encodeWithSelector(
+            bytes4(keccak256("SellOrderFeesExceedSpreadError(uint256,uint256)")),
+            sellOrderFees,
+            spread
+        );
+    }
+
+    function OnlyTakerError(
+        address sender,
+        address taker
+    )
+        internal
+        pure
+        returns (bytes memory)
+    {
+        return abi.encodeWithSelector(
+            bytes4(keccak256("OnlyTakerError(address,address)")),
+            sender,
+            taker
+        );
+    }
+
+    function InvalidSignerError(
+        address maker,
+        address signer
+    )
+        internal
+        pure
+        returns (bytes memory)
+    {
+        return abi.encodeWithSelector(
+            bytes4(keccak256("InvalidSignerError(address,address)")),
+            maker,
+            signer
+        );
+    }
+
+    function OrderNotFillableError(
+        address maker,
+        uint256 nonce,
+        uint8 orderStatus
+    )
+        internal
+        pure
+        returns (bytes memory)
+    {
+        return abi.encodeWithSelector(
+            bytes4(keccak256("OrderNotFillableError(address,uint256,uint8)")),
+            maker,
+            nonce,
+            orderStatus
+        );
+    }
+
+    function TokenIdMismatchError(
+        uint256 tokenId,
+        uint256 orderTokenId
+    )
+        internal
+        pure
+        returns (bytes memory)
+    {
+        return abi.encodeWithSelector(
+            bytes4(keccak256("TokenIdMismatchError(uint256,uint256)")),
+            tokenId,
+            orderTokenId
+        );
+    }
+
+    function PropertyValidationFailedError(
+        address propertyValidator,
+        address token,
+        uint256 tokenId,
+        bytes memory propertyData,
+        bytes memory errorData
+    )
+        internal
+        pure
+        returns (bytes memory)
+    {
+        return abi.encodeWithSelector(
+            bytes4(keccak256("PropertyValidationFailedError(address,address,uint256,bytes,bytes)")),
+            propertyValidator,
+            token,
+            tokenId,
+            propertyData,
+            errorData
+        );
+    }
+
+    function ExceedsRemainingOrderAmount(
+        uint128 remainingOrderAmount,
+        uint128 fillAmount
+    )
+        internal
+        pure
+        returns (bytes memory)
+    {
+        return abi.encodeWithSelector(
+            bytes4(keccak256("ExceedsRemainingOrderAmount(uint128,uint128)")),
+            remainingOrderAmount,
+            fillAmount
+        );
+    }
+}

contracts/zero-ex/contracts/src/features/ERC165Feature.sol

@@ -0,0 +1,51 @@
+// SPDX-License-Identifier: Apache-2.0
+/*
+
+  Copyright 2022 ZeroEx Intl.
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+
+*/
+
+pragma solidity ^0.6.5;
+pragma experimental ABIEncoderV2;
+
+import "../fixins/FixinCommon.sol";
+import "./interfaces/IFeature.sol";
+
+
+/// @dev Implements the ERC165 `supportsInterface` function
+contract ERC165Feature is
+    IFeature,
+    FixinCommon
+{
+    /// @dev Name of this feature.
+    string public constant override FEATURE_NAME = "ERC165";
+    /// @dev Version of this feature.
+    uint256 public immutable override FEATURE_VERSION = _encodeVersion(1, 0, 0);
+
+    /// @dev Indicates whether the 0x Exchange Proxy implements a particular
+    ///      ERC165 interface. This function should use at most 30,000 gas.
+    /// @param interfaceId The interface identifier, as specified in ERC165.
+    /// @return isSupported Whether the given interface is supported by the
+    ///         0x Exchange Proxy.
+    function supportInterface(bytes4 interfaceId)
+        external
+        pure
+        returns (bool isSupported)
+    {
+        return interfaceId == 0x01ffc9a7 || // ERC-165 support
+               interfaceId == 0x150b7a02 || // ERC-721 `ERC721TokenReceiver` support
+               interfaceId == 0x4e2312e0;   // ERC-1155 `ERC1155TokenReceiver` support
+    }
+}

contracts/zero-ex/contracts/src/features/OtcOrdersFeature.sol

@@ -311,7 +311,7 @@ contract OtcOrdersFeature is
         // Unwrap WETH
         WETH.withdraw(order.makerAmount);
         // Transfer ETH to taker
-        _transferEth(taker, order.makerAmount);
+        _transferEth(payable(taker), order.makerAmount);
 
         emit OtcOrderFilled(
             orderInfo.orderHash,
@@ -622,16 +622,4 @@ contract OtcOrdersFeature is
             [txOrigin]
             [nonceBucket];
     }
-
-    function _transferEth(address recipient, uint256 amount)
-        private
-    {
-        // Transfer ETH to recipient
-        (bool success, bytes memory revertData) =
-            recipient.call{value: amount}("");
-        // Revert on failure
-        if (!success) {
-            revertData.rrevert();
-        }
-    }
 }

contracts/zero-ex/contracts/src/features/interfaces/IERC1155OrdersFeature.sol

@@ -0,0 +1,236 @@
+// SPDX-License-Identifier: Apache-2.0
+/*
+
+  Copyright 2021 ZeroEx Intl.
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+
+*/
+
+pragma solidity ^0.6.5;
+pragma experimental ABIEncoderV2;
+
+import "@0x/contracts-erc20/contracts/src/v06/IERC20TokenV06.sol";
+import "../libs/LibNFTOrder.sol";
+import "../libs/LibSignature.sol";
+import "../../vendor/IERC1155Token.sol";
+
+
+/// @dev Feature for interacting with ERC1155 orders.
+interface IERC1155OrdersFeature {
+
+    /// @dev Emitted whenever an `ERC1155Order` is filled.
+    /// @param direction Whether the order is selling or
+    ///        buying the ERC1155 token.
+    /// @param maker The maker of the order.
+    /// @param taker The taker of the order.
+    /// @param nonce The unique maker nonce in the order.
+    /// @param erc20Token The address of the ERC20 token.
+    /// @param erc20FillAmount The amount of ERC20 token filled.
+    /// @param erc1155Token The address of the ERC1155 token.
+    /// @param erc1155TokenId The ID of the ERC1155 asset.
+    /// @param erc1155FillAmount The amount of ERC1155 asset filled.
+    /// @param matcher Currently unused.
+    event ERC1155OrderFilled(
+        LibNFTOrder.TradeDirection direction,
+        address maker,
+        address taker,
+        uint256 nonce,
+        IERC20TokenV06 erc20Token,
+        uint256 erc20FillAmount,
+        IERC1155Token erc1155Token,
+        uint256 erc1155TokenId,
+        uint128 erc1155FillAmount,
+        address matcher
+    );
+
+    /// @dev Emitted whenever an `ERC1155Order` is cancelled.
+    /// @param orderHash The hash the order.
+    /// @param maker The maker of the order.
+    event ERC1155OrderCancelled(
+        bytes32 orderHash,
+        address maker
+    );
+
+    /// @dev Emitted when an `ERC1155Order` is pre-signed.
+    ///      Contains all the fields of the order.
+    event ERC1155OrderPreSigned(
+        LibNFTOrder.TradeDirection direction,
+        address maker,
+        address taker,
+        uint256 expiry,
+        uint256 nonce,
+        IERC20TokenV06 erc20Token,
+        uint256 erc20TokenAmount,
+        LibNFTOrder.Fee[] fees,
+        IERC1155Token erc1155Token,
+        uint256 erc1155TokenId,
+        LibNFTOrder.Property[] erc1155TokenProperties,
+        uint128 erc1155TokenAmount
+    );
+
+    /// @dev Sells an ERC1155 asset to fill the given order.
+    /// @param buyOrder The ERC1155 buy order.
+    /// @param signature The order signature from the maker.
+    /// @param erc1155TokenId The ID of the ERC1155 asset being
+    ///        sold. If the given order specifies properties,
+    ///        the asset must satisfy those properties. Otherwise,
+    ///        it must equal the tokenId in the order.
+    /// @param erc1155SellAmount The amount of the ERC1155 asset
+    ///        to sell.
+    /// @param unwrapNativeToken If this parameter is true and the
+    ///        ERC20 token of the order is e.g. WETH, unwraps the
+    ///        token before transferring it to the taker.
+    /// @param callbackData If this parameter is non-zero, invokes
+    ///        `zeroExERC1155OrderCallback` on `msg.sender` after
+    ///        the ERC20 tokens have been transferred to `msg.sender`
+    ///        but before transferring the ERC1155 asset to the buyer.
+    function sellERC1155(
+        LibNFTOrder.ERC1155Order calldata buyOrder,
+        LibSignature.Signature calldata signature,
+        uint256 erc1155TokenId,
+        uint128 erc1155SellAmount,
+        bool unwrapNativeToken,
+        bytes calldata callbackData
+    )
+        external;
+
+    /// @dev Buys an ERC1155 asset by filling the given order.
+    /// @param sellOrder The ERC1155 sell order.
+    /// @param signature The order signature.
+    /// @param erc1155BuyAmount The amount of the ERC1155 asset
+    ///        to buy.
+    /// @param callbackData If this parameter is non-zero, invokes
+    ///        `zeroExERC1155OrderCallback` on `msg.sender` after
+    ///        the ERC1155 asset has been transferred to `msg.sender`
+    ///        but before transferring the ERC20 tokens to the seller.
+    ///        Native tokens acquired during the callback can be used
+    ///        to fill the order.
+    function buyERC1155(
+        LibNFTOrder.ERC1155Order calldata sellOrder,
+        LibSignature.Signature calldata signature,
+        uint128 erc1155BuyAmount,
+        bytes calldata callbackData
+    )
+        external
+        payable;
+
+    /// @dev Cancel a single ERC1155 order. The caller should be the
+    ///      maker of the order. Silently succeeds if the order has
+    ///      already been filled or cancelled.
+    /// @param order The order to cancel.
+    function cancelERC1155Order(LibNFTOrder.ERC1155Order calldata order)
+        external;
+
+    /// @dev Cancel multiple ERC1155 orders. The caller should be the
+    ///      maker of the orders. Silently succeeds if an order has
+    ///      already been filled or cancelled.
+    /// @param orders The orders to cancel.
+    function batchCancelERC1155Orders(LibNFTOrder.ERC1155Order[] calldata orders)
+        external;
+
+    /// @dev Buys multiple ERC1155 assets by filling the
+    ///      given orders.
+    /// @param sellOrders The ERC1155 sell orders.
+    /// @param signatures The order signatures.
+    /// @param erc1155TokenAmounts The amounts of the ERC1155 assets
+    ///        to buy for each order.
+    /// @param revertIfIncomplete If true, reverts if this
+    ///        function fails to fill any individual order.
+    /// @return successes An array of booleans corresponding to whether
+    ///         each order in `orders` was successfully filled.
+    function batchBuyERC1155s(
+        LibNFTOrder.ERC1155Order[] calldata sellOrders,
+        LibSignature.Signature[] calldata signatures,
+        uint128[] calldata erc1155TokenAmounts,
+        bool revertIfIncomplete
+    )
+        external
+        payable
+        returns (bool[] memory successes);
+
+    /// @dev Callback for the ERC1155 `safeTransferFrom` function.
+    ///      This callback can be used to sell an ERC1155 asset if
+    ///      a valid ERC1155 order, signature and `unwrapNativeToken`
+    ///      are encoded in `data`. This allows takers to sell their
+    ///      ERC1155 asset without first calling `setApprovalForAll`.
+    /// @param operator The address which called `safeTransferFrom`.
+    /// @param from The address which previously owned the token.
+    /// @param tokenId The ID of the asset being transferred.
+    /// @param value The amount being transferred.
+    /// @param data Additional data with no specified format. If a
+    ///        valid ERC1155 order, signature and `unwrapNativeToken`
+    ///        are encoded in `data`, this function will try to fill
+    ///        the order using the received asset.
+    /// @return success The selector of this function (0xf23a6e61),
+    ///         indicating that the callback succeeded.
+    function onERC1155Received(
+        address operator,
+        address from,
+        uint256 tokenId,
+        uint256 value,
+        bytes calldata data
+    )
+        external
+        returns (bytes4 success);
+
+    /// @dev Approves an ERC1155 order on-chain. After pre-signing
+    ///      the order, the `PRESIGNED` signature type will become
+    ///      valid for that order and signer.
+    /// @param order An ERC1155 order.
+    function preSignERC1155Order(LibNFTOrder.ERC1155Order calldata order)
+        external;
+
+    /// @dev Checks whether the given signature is valid for the
+    ///      the given ERC1155 order. Reverts if not.
+    /// @param order The ERC1155 order.
+    /// @param signature The signature to validate.
+    function validateERC1155OrderSignature(
+        LibNFTOrder.ERC1155Order calldata order,
+        LibSignature.Signature calldata signature
+    )
+        external
+        view;
+
+    /// @dev If the given order is buying an ERC1155 asset, checks
+    ///      whether or not the given token ID satisfies the required
+    ///      properties specified in the order. If the order does not
+    ///      specify any properties, this function instead checks
+    ///      whether the given token ID matches the ID in the order.
+    ///      Reverts if any checks fail, or if the order is selling
+    ///      an ERC1155 asset.
+    /// @param order The ERC1155 order.
+    /// @param erc1155TokenId The ID of the ERC1155 asset.
+    function validateERC1155OrderProperties(
+        LibNFTOrder.ERC1155Order calldata order,
+        uint256 erc1155TokenId
+    )
+        external
+        view;
+
+    /// @dev Get the order info for an ERC1155 order.
+    /// @param order The ERC1155 order.
+    /// @return orderInfo Infor about the order.
+    function getERC1155OrderInfo(LibNFTOrder.ERC1155Order calldata order)
+        external
+        view
+        returns (LibNFTOrder.OrderInfo memory orderInfo);
+
+    /// @dev Get the canonical hash of an ERC1155 order.
+    /// @param order The ERC1155 order.
+    /// @return orderHash The order hash.
+    function getERC1155OrderHash(LibNFTOrder.ERC1155Order calldata order)
+        external
+        view
+        returns (bytes32 orderHash);
+}

contracts/zero-ex/contracts/src/features/interfaces/IERC165Feature.sol

@@ -0,0 +1,36 @@
+// SPDX-License-Identifier: Apache-2.0
+/*
+
+  Copyright 2022 ZeroEx Intl.
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+
+*/
+
+pragma solidity ^0.6.5;
+pragma experimental ABIEncoderV2;
+
+
+/// @dev Implements the ERC165 `supportsInterface` function
+interface IERC165Feature {
+
+    /// @dev Indicates whether the 0x Exchange Proxy implements a particular
+    ///      ERC165 interface. This function should use at most 30,000 gas.
+    /// @param interfaceId The interface identifier, as specified in ERC165.
+    /// @return isSupported Whether the given interface is supported by the
+    ///         0x Exchange Proxy.
+    function supportInterface(bytes4 interfaceId)
+        external
+        pure
+        returns (bool isSupported);
+}

contracts/zero-ex/contracts/src/features/interfaces/IERC721OrdersFeature.sol

@@ -0,0 +1,282 @@
+// SPDX-License-Identifier: Apache-2.0
+/*
+
+  Copyright 2021 ZeroEx Intl.
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+
+*/
+
+pragma solidity ^0.6.5;
+pragma experimental ABIEncoderV2;
+
+import "@0x/contracts-erc20/contracts/src/v06/IERC20TokenV06.sol";
+import "../libs/LibNFTOrder.sol";
+import "../libs/LibSignature.sol";
+import "../../vendor/IERC721Token.sol";
+
+
+/// @dev Feature for interacting with ERC721 orders.
+interface IERC721OrdersFeature {
+
+    /// @dev Emitted whenever an `ERC721Order` is filled.
+    /// @param direction Whether the order is selling or
+    ///        buying the ERC721 token.
+    /// @param maker The maker of the order.
+    /// @param taker The taker of the order.
+    /// @param nonce The unique maker nonce in the order.
+    /// @param erc20Token The address of the ERC20 token.
+    /// @param erc20TokenAmount The amount of ERC20 token
+    ///        to sell or buy.
+    /// @param erc721Token The address of the ERC721 token.
+    /// @param erc721TokenId The ID of the ERC721 asset.
+    /// @param matcher If this order was matched with another using `matchERC721Orders()`,
+    ///                this will be the address of the caller. If not, this will be `address(0)`.
+    event ERC721OrderFilled(
+        LibNFTOrder.TradeDirection direction,
+        address maker,
+        address taker,
+        uint256 nonce,
+        IERC20TokenV06 erc20Token,
+        uint256 erc20TokenAmount,
+        IERC721Token erc721Token,
+        uint256 erc721TokenId,
+        address matcher
+    );
+
+    /// @dev Emitted whenever an `ERC721Order` is cancelled.
+    /// @param maker The maker of the order.
+    /// @param nonce The nonce of the order that was cancelled.
+    event ERC721OrderCancelled(
+        address maker,
+        uint256 nonce
+    );
+
+    /// @dev Emitted when an `ERC721Order` is pre-signed.
+    ///      Contains all the fields of the order.
+    event ERC721OrderPreSigned(
+        LibNFTOrder.TradeDirection direction,
+        address maker,
+        address taker,
+        uint256 expiry,
+        uint256 nonce,
+        IERC20TokenV06 erc20Token,
+        uint256 erc20TokenAmount,
+        LibNFTOrder.Fee[] fees,
+        IERC721Token erc721Token,
+        uint256 erc721TokenId,
+        LibNFTOrder.Property[] erc721TokenProperties
+    );
+
+    /// @dev Sells an ERC721 asset to fill the given order.
+    /// @param buyOrder The ERC721 buy order.
+    /// @param signature The order signature from the maker.
+    /// @param erc721TokenId The ID of the ERC721 asset being
+    ///        sold. If the given order specifies properties,
+    ///        the asset must satisfy those properties. Otherwise,
+    ///        it must equal the tokenId in the order.
+    /// @param unwrapNativeToken If this parameter is true and the
+    ///        ERC20 token of the order is e.g. WETH, unwraps the
+    ///        token before transferring it to the taker.
+    /// @param callbackData If this parameter is non-zero, invokes
+    ///        `zeroExERC721OrderCallback` on `msg.sender` after
+    ///        the ERC20 tokens have been transferred to `msg.sender`
+    ///        but before transferring the ERC721 asset to the buyer.
+    function sellERC721(
+        LibNFTOrder.ERC721Order calldata buyOrder,
+        LibSignature.Signature calldata signature,
+        uint256 erc721TokenId,
+        bool unwrapNativeToken,
+        bytes calldata callbackData
+    )
+        external;
+
+    /// @dev Buys an ERC721 asset by filling the given order.
+    /// @param sellOrder The ERC721 sell order.
+    /// @param signature The order signature.
+    /// @param callbackData If this parameter is non-zero, invokes
+    ///        `zeroExERC721OrderCallback` on `msg.sender` after
+    ///        the ERC721 asset has been transferred to `msg.sender`
+    ///        but before transferring the ERC20 tokens to the seller.
+    ///        Native tokens acquired during the callback can be used
+    ///        to fill the order.
+    function buyERC721(
+        LibNFTOrder.ERC721Order calldata sellOrder,
+        LibSignature.Signature calldata signature,
+        bytes calldata callbackData
+    )
+        external
+        payable;
+
+    /// @dev Cancel a single ERC721 order by its nonce. The caller
+    ///      should be the maker of the order. Silently succeeds if
+    ///      an order with the same nonce has already been filled or
+    ///      cancelled.
+    /// @param orderNonce The order nonce.
+    function cancelERC721Order(uint256 orderNonce)
+        external;
+
+    /// @dev Cancel multiple ERC721 orders by their nonces. The caller
+    ///      should be the maker of the orders. Silently succeeds if
+    ///      an order with the same nonce has already been filled or
+    ///      cancelled.
+    /// @param orderNonces The order nonces.
+    function batchCancelERC721Orders(uint256[] calldata orderNonces)
+        external;
+
+    /// @dev Buys multiple ERC721 assets by filling the
+    ///      given orders.
+    /// @param sellOrders The ERC721 sell orders.
+    /// @param signatures The order signatures.
+    /// @param revertIfIncomplete If true, reverts if this
+    ///        function fails to fill any individual order.
+    /// @return successes An array of booleans corresponding to whether
+    ///         each order in `orders` was successfully filled.
+    function batchBuyERC721s(
+        LibNFTOrder.ERC721Order[] calldata sellOrders,
+        LibSignature.Signature[] calldata signatures,
+        bool revertIfIncomplete
+    )
+        external
+        payable
+        returns (bool[] memory successes);
+
+    /// @dev Matches a pair of complementary orders that have
+    ///      a non-negative spread. Each order is filled at
+    ///      their respective price, and the matcher receives
+    ///      a profit denominated in the ERC20 token.
+    /// @param sellOrder Order selling an ERC721 asset.
+    /// @param buyOrder Order buying an ERC721 asset.
+    /// @param sellOrderSignature Signature for the sell order.
+    /// @param buyOrderSignature Signature for the buy order.
+    /// @return profit The amount of profit earned by the caller
+    ///         of this function (denominated in the ERC20 token
+    ///         of the matched orders).
+    function matchERC721Orders(
+        LibNFTOrder.ERC721Order calldata sellOrder,
+        LibNFTOrder.ERC721Order calldata buyOrder,
+        LibSignature.Signature calldata sellOrderSignature,
+        LibSignature.Signature calldata buyOrderSignature
+    )
+        external
+        returns (uint256 profit);
+
+    /// @dev Matches pairs of complementary orders that have
+    ///      non-negative spreads. Each order is filled at
+    ///      their respective price, and the matcher receives
+    ///      a profit denominated in the ERC20 token.
+    /// @param sellOrders Orders selling ERC721 assets.
+    /// @param buyOrders Orders buying ERC721 assets.
+    /// @param sellOrderSignatures Signatures for the sell orders.
+    /// @param buyOrderSignatures Signatures for the buy orders.
+    /// @return profits The amount of profit earned by the caller
+    ///         of this function for each pair of matched orders
+    ///         (denominated in the ERC20 token of the order pair).
+    /// @return successes An array of booleans corresponding to
+    ///         whether each pair of orders was successfully matched.
+    function batchMatchERC721Orders(
+        LibNFTOrder.ERC721Order[] calldata sellOrders,
+        LibNFTOrder.ERC721Order[] calldata buyOrders,
+        LibSignature.Signature[] calldata sellOrderSignatures,
+        LibSignature.Signature[] calldata buyOrderSignatures
+    )
+        external
+        returns (uint256[] memory profits, bool[] memory successes);
+
+    /// @dev Callback for the ERC721 `safeTransferFrom` function.
+    ///      This callback can be used to sell an ERC721 asset if
+    ///      a valid ERC721 order, signature and `unwrapNativeToken`
+    ///      are encoded in `data`. This allows takers to sell their
+    ///      ERC721 asset without first calling `setApprovalForAll`.
+    /// @param operator The address which called `safeTransferFrom`.
+    /// @param from The address which previously owned the token.
+    /// @param tokenId The ID of the asset being transferred.
+    /// @param data Additional data with no specified format. If a
+    ///        valid ERC721 order, signature and `unwrapNativeToken`
+    ///        are encoded in `data`, this function will try to fill
+    ///        the order using the received asset.
+    /// @return success The selector of this function (0x150b7a02),
+    ///         indicating that the callback succeeded.
+    function onERC721Received(
+        address operator,
+        address from,
+        uint256 tokenId,
+        bytes calldata data
+    )
+        external
+        returns (bytes4 success);
+
+    /// @dev Approves an ERC721 order on-chain. After pre-signing
+    ///      the order, the `PRESIGNED` signature type will become
+    ///      valid for that order and signer.
+    /// @param order An ERC721 order.
+    function preSignERC721Order(LibNFTOrder.ERC721Order calldata order)
+        external;
+
+    /// @dev Checks whether the given signature is valid for the
+    ///      the given ERC721 order. Reverts if not.
+    /// @param order The ERC721 order.
+    /// @param signature The signature to validate.
+    function validateERC721OrderSignature(
+        LibNFTOrder.ERC721Order calldata order,
+        LibSignature.Signature calldata signature
+    )
+        external
+        view;
+
+    /// @dev If the given order is buying an ERC721 asset, checks
+    ///      whether or not the given token ID satisfies the required
+    ///      properties specified in the order. If the order does not
+    ///      specify any properties, this function instead checks
+    ///      whether the given token ID matches the ID in the order.
+    ///      Reverts if any checks fail, or if the order is selling
+    ///      an ERC721 asset.
+    /// @param order The ERC721 order.
+    /// @param erc721TokenId The ID of the ERC721 asset.
+    function validateERC721OrderProperties(
+        LibNFTOrder.ERC721Order calldata order,
+        uint256 erc721TokenId
+    )
+        external
+        view;
+
+    /// @dev Get the current status of an ERC721 order.
+    /// @param order The ERC721 order.
+    /// @return status The status of the order.
+    function getERC721OrderStatus(LibNFTOrder.ERC721Order calldata order)
+        external
+        view
+        returns (LibNFTOrder.OrderStatus status);
+
+    /// @dev Get the canonical hash of an ERC721 order.
+    /// @param order The ERC721 order.
+    /// @return orderHash The order hash.
+    function getERC721OrderHash(LibNFTOrder.ERC721Order calldata order)
+        external
+        view
+        returns (bytes32 orderHash);
+
+    /// @dev Get the order status bit vector for the given
+    ///      maker address and nonce range.
+    /// @param maker The maker of the order.
+    /// @param nonceRange Order status bit vectors are indexed
+    ///        by maker address and the upper 248 bits of the
+    ///        order nonce. We define `nonceRange` to be these
+    ///        248 bits.
+    /// @return bitVector The order status bit vector for the
+    ///         given maker and nonce range.
+    function getERC721OrderStatusBitVector(address maker, uint248 nonceRange)
+        external
+        view
+        returns (uint256 bitVector);
+}

contracts/zero-ex/contracts/src/features/libs/LibNFTOrder.sol

@@ -0,0 +1,526 @@
+// SPDX-License-Identifier: Apache-2.0
+/*
+
+  Copyright 2021 ZeroEx Intl.
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+
+*/
+
+pragma solidity ^0.6.5;
+pragma experimental ABIEncoderV2;
+
+import "@0x/contracts-erc20/contracts/src/v06/IERC20TokenV06.sol";
+import "../../vendor/IERC1155Token.sol";
+import "../../vendor/IERC721Token.sol";
+import "../../vendor/IPropertyValidator.sol";
+
+
+/// @dev A library for common NFT order operations.
+library LibNFTOrder {
+
+    enum OrderStatus {
+        INVALID,
+        FILLABLE,
+        UNFILLABLE,
+        EXPIRED
+    }
+
+    enum TradeDirection {
+        SELL_NFT,
+        BUY_NFT
+    }
+
+    struct Property {
+        IPropertyValidator propertyValidator;
+        bytes propertyData;
+    }
+
+    struct Fee {
+        address recipient;
+        uint256 amount;
+        bytes feeData;
+    }
+
+    // "Base struct" for ERC721Order and ERC1155, used
+    // by the abstract contract `NFTOrders`.
+    struct NFTOrder {
+        TradeDirection direction;
+        address maker;
+        address taker;
+        uint256 expiry;
+        uint256 nonce;
+        IERC20TokenV06 erc20Token;
+        uint256 erc20TokenAmount;
+        Fee[] fees;
+        address nft;
+        uint256 nftId;
+        Property[] nftProperties;
+    }
+
+    // All fields align with those of NFTOrder
+    struct ERC721Order {
+        TradeDirection direction;
+        address maker;
+        address taker;
+        uint256 expiry;
+        uint256 nonce;
+        IERC20TokenV06 erc20Token;
+        uint256 erc20TokenAmount;
+        Fee[] fees;
+        IERC721Token erc721Token;
+        uint256 erc721TokenId;
+        Property[] erc721TokenProperties;
+    }
+
+    // All fields except `erc1155TokenAmount` align
+    // with those of NFTOrder
+    struct ERC1155Order {
+        TradeDirection direction;
+        address maker;
+        address taker;
+        uint256 expiry;
+        uint256 nonce;
+        IERC20TokenV06 erc20Token;
+        uint256 erc20TokenAmount;
+        Fee[] fees;
+        IERC1155Token erc1155Token;
+        uint256 erc1155TokenId;
+        Property[] erc1155TokenProperties;
+        // End of fields shared with NFTOrder
+        uint128 erc1155TokenAmount;
+    }
+
+    struct OrderInfo {
+        bytes32 orderHash;
+        OrderStatus status;
+        // `orderAmount` is 1 for all ERC721Orders, and
+        // `erc1155TokenAmount` for ERC1155Orders.
+        uint128 orderAmount;
+        // The remaining amount of the ERC721/ERC1155 asset
+        // that can be filled for the order.
+        uint128 remainingAmount;
+    }
+
+    // The type hash for ERC721 orders, which is:
+    // keccak256(abi.encodePacked(
+    //     "ERC721Order(",
+    //       "uint8 direction,",
+    //       "address maker,",
+    //       "address taker,",
+    //       "uint256 expiry,",
+    //       "uint256 nonce,",
+    //       "address erc20Token,",
+    //       "uint256 erc20TokenAmount,",
+    //       "Fee[] fees,",
+    //       "address erc721Token,",
+    //       "uint256 erc721TokenId,",
+    //       "Property[] erc721TokenProperties",
+    //     ")",
+    //     "Fee(",
+    //       "address recipient,",
+    //       "uint256 amount,",
+    //       "bytes feeData",
+    //     ")",
+    //     "Property(",
+    //       "address propertyValidator,",
+    //       "bytes propertyData",
+    //     ")"
+    // ))
+    uint256 private constant _ERC_721_ORDER_TYPEHASH =
+        0x2de32b2b090da7d8ab83ca4c85ba2eb6957bc7f6c50cb4ae1995e87560d808ed;
+
+    // The type hash for ERC1155 orders, which is:
+    // keccak256(abi.encodePacked(
+    //     "ERC1155Order(",
+    //       "uint8 direction,",
+    //       "address maker,",
+    //       "address taker,",
+    //       "uint256 expiry,",
+    //       "uint256 nonce,",
+    //       "address erc20Token,",
+    //       "uint256 erc20TokenAmount,",
+    //       "Fee[] fees,",
+    //       "address erc1155Token,",
+    //       "uint256 erc1155TokenId,",
+    //       "Property[] erc1155TokenProperties,",
+    //       "uint128 erc1155TokenAmount",
+    //     ")",
+    //     "Fee(",
+    //       "address recipient,",
+    //       "uint256 amount,",
+    //       "bytes feeData",
+    //     ")",
+    //     "Property(",
+    //       "address propertyValidator,",
+    //       "bytes propertyData",
+    //     ")"
+    // ))
+    uint256 private constant _ERC_1155_ORDER_TYPEHASH =
+        0x930490b1bcedd2e5139e22c761fafd52e533960197c2283f3922c7fd8c880be9;
+
+    // keccak256(abi.encodePacked(
+    //     "Fee(",
+    //       "address recipient,",
+    //       "uint256 amount,",
+    //       "bytes feeData",
+    //     ")"
+    // ))
+    uint256 private constant _FEE_TYPEHASH =
+        0xe68c29f1b4e8cce0bbcac76eb1334bdc1dc1f293a517c90e9e532340e1e94115;
+
+    // keccak256(abi.encodePacked(
+    //     "Property(",
+    //       "address propertyValidator,",
+    //       "bytes propertyData",
+    //     ")"
+    // ))
+    uint256 private constant _PROPERTY_TYPEHASH =
+        0x6292cf854241cb36887e639065eca63b3af9f7f70270cebeda4c29b6d3bc65e8;
+
+    // keccak256("");
+    bytes32 private constant _EMPTY_ARRAY_KECCAK256 =
+        0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
+
+    // keccak256(abi.encodePacked(keccak256(abi.encode(
+    //     _PROPERTY_TYPEHASH,
+    //     address(0),
+    //     keccak256("")
+    // ))));
+    bytes32 private constant _NULL_PROPERTY_STRUCT_HASH =
+        0x720ee400a9024f6a49768142c339bf09d2dd9056ab52d20fbe7165faba6e142d;
+
+    uint256 private constant ADDRESS_MASK = (1 << 160) - 1;
+
+    // ERC721Order and NFTOrder fields are aligned, so
+    // we can safely cast an ERC721Order to an NFTOrder.
+    function asNFTOrder(ERC721Order memory erc721Order)
+        internal
+        pure
+        returns (NFTOrder memory nftOrder)
+    {
+        assembly {
+            nftOrder := erc721Order
+        }
+    }
+
+    // ERC1155Order and NFTOrder fields are aligned with
+    // the exception of the last field `erc1155TokenAmount`
+    // in ERC1155Order, so we can safely cast an ERC1155Order
+    // to an NFTOrder.
+    function asNFTOrder(ERC1155Order memory erc1155Order)
+        internal
+        pure
+        returns (NFTOrder memory nftOrder)
+    {
+        assembly {
+            nftOrder := erc1155Order
+        }
+    }
+
+    // ERC721Order and NFTOrder fields are aligned, so
+    // we can safely cast an MFTOrder to an ERC721Order.
+    function asERC721Order(NFTOrder memory nftOrder)
+        internal
+        pure
+        returns (ERC721Order memory erc721Order)
+    {
+        assembly {
+            erc721Order := nftOrder
+        }
+    }
+
+    // NOTE: This is only safe if `nftOrder` was previously
+    // cast from an `ERC1155Order` and the original
+    // `erc1155TokenAmount` memory word has not been corrupted!
+    function asERC1155Order(
+        NFTOrder memory nftOrder
+    )
+        internal
+        pure
+        returns (ERC1155Order memory erc1155Order)
+    {
+        assembly {
+            erc1155Order := nftOrder
+        }
+    }
+
+    /// @dev Get the struct hash of an ERC721 order.
+    /// @param order The ERC721 order.
+    /// @return structHash The struct hash of the order.
+    function getERC721OrderStructHash(ERC721Order memory order)
+        internal
+        pure
+        returns (bytes32 structHash)
+    {
+        // We give `order.erc721TokenProperties.length == 0` and
+        // `order.erc721TokenProperties.length == 1` special treatment
+        // because we expect these to be the most common.
+        bytes32 propertiesHash;
+        if (order.erc721TokenProperties.length == 0) {
+            propertiesHash = _EMPTY_ARRAY_KECCAK256;
+        } else if (order.erc721TokenProperties.length == 1) {
+            Property memory property = order
+                .erc721TokenProperties[0];
+            if (
+                address(property.propertyValidator) == address(0) &&
+                property.propertyData.length == 0
+            ) {
+                propertiesHash = _NULL_PROPERTY_STRUCT_HASH;
+            } else {
+                // propertiesHash = keccak256(abi.encodePacked(keccak256(abi.encode(
+                //     _PROPERTY_TYPEHASH,
+                //     order.erc721TokenProperties[0].propertyValidator,
+                //     keccak256(order.erc721TokenProperties[0].propertyData)
+                // ))));
+                bytes32 dataHash = keccak256(property.propertyData);
+                assembly {
+                    // Load free memory pointer
+                    let mem := mload(64)
+                    mstore(mem, _PROPERTY_TYPEHASH)
+                    // property.propertyValidator
+                    mstore(add(mem, 32), and(ADDRESS_MASK, mload(property)))
+                    // keccak256(property.propertyData)
+                    mstore(add(mem, 64), dataHash)
+                    mstore(mem, keccak256(mem, 96))
+                    propertiesHash := keccak256(mem, 32)
+                }
+            }
+        } else {
+            bytes32[] memory propertyStructHashArray = new bytes32[](
+                order.erc721TokenProperties.length
+            );
+            for (uint256 i = 0; i < order.erc721TokenProperties.length; i++) {
+                propertyStructHashArray[i] = keccak256(abi.encode(
+                    _PROPERTY_TYPEHASH,
+                    order.erc721TokenProperties[i].propertyValidator,
+                    keccak256(order.erc721TokenProperties[i].propertyData)
+                ));
+            }
+            propertiesHash = keccak256(abi.encodePacked(propertyStructHashArray));
+        }
+
+        // We give `order.fees.length == 0` and
+        // `order.fees.length == 1` special treatment
+        // because we expect these to be the most common.
+        bytes32 feesHash;
+        if (order.fees.length == 0) {
+            feesHash = _EMPTY_ARRAY_KECCAK256;
+        } else if (order.fees.length == 1) {
+            // feesHash = keccak256(abi.encodePacked(keccak256(abi.encode(
+            //     _FEE_TYPEHASH,
+            //     order.fees[0].recipient,
+            //     order.fees[0].amount,
+            //     keccak256(order.fees[0].feeData)
+            // ))));
+            Fee memory fee = order.fees[0];
+            bytes32 dataHash = keccak256(fee.feeData);
+            assembly {
+                // Load free memory pointer
+                let mem := mload(64)
+                mstore(mem, _FEE_TYPEHASH)
+                // fee.recipient
+                mstore(add(mem, 32), and(ADDRESS_MASK, mload(fee)))
+                // fee.amount
+                mstore(add(mem, 64), mload(add(fee, 32)))
+                // keccak256(fee.feeData)
+                mstore(add(mem, 96), dataHash)
+                mstore(mem, keccak256(mem, 128))
+                feesHash := keccak256(mem, 32)
+            }
+        } else {
+            bytes32[] memory feeStructHashArray = new bytes32[](order.fees.length);
+            for (uint256 i = 0; i < order.fees.length; i++) {
+                feeStructHashArray[i] = keccak256(abi.encode(
+                    _FEE_TYPEHASH,
+                    order.fees[i].recipient,
+                    order.fees[i].amount,
+                    keccak256(order.fees[i].feeData)
+                ));
+            }
+            feesHash = keccak256(abi.encodePacked(feeStructHashArray));
+        }
+
+        // Hash in place, equivalent to:
+        // return keccak256(abi.encode(
+        //     _ERC_721_ORDER_TYPEHASH,
+        //     order.direction,
+        //     order.maker,
+        //     order.taker,
+        //     order.expiry,
+        //     order.nonce,
+        //     order.erc20Token,
+        //     order.erc20TokenAmount,
+        //     feesHash,
+        //     order.erc721Token,
+        //     order.erc721TokenId,
+        //     propertiesHash
+        // ));
+        assembly {
+            if lt(order, 32) { invalid() } // Don't underflow memory.
+
+            let typeHashPos := sub(order, 32) // order - 32
+            let feesHashPos := add(order, 224) // order + (32 * 7)
+            let propertiesHashPos := add(order, 320) // order + (32 * 10)
+
+            let temp1 := mload(typeHashPos)
+            let temp2 := mload(feesHashPos)
+            let temp3 := mload(propertiesHashPos)
+
+            mstore(typeHashPos, _ERC_721_ORDER_TYPEHASH)
+            mstore(feesHashPos, feesHash)
+            mstore(propertiesHashPos, propertiesHash)
+            structHash := keccak256(typeHashPos, 384 /* 32 * 12 */ )
+
+            mstore(typeHashPos, temp1)
+            mstore(feesHashPos, temp2)
+            mstore(propertiesHashPos, temp3)
+        }
+        return structHash;
+    }
+
+    /// @dev Get the struct hash of an ERC1155 order.
+    /// @param order The ERC1155 order.
+    /// @return structHash The struct hash of the order.
+    function getERC1155OrderStructHash(ERC1155Order memory order)
+        internal
+        pure
+        returns (bytes32 structHash)
+    {
+        // We give `order.erc1155TokenProperties.length == 0` and
+        // `order.erc1155TokenProperties.length == 1` special treatment
+        // because we expect these to be the most common.
+        bytes32 propertiesHash;
+        if (order.erc1155TokenProperties.length == 0) {
+            propertiesHash = _EMPTY_ARRAY_KECCAK256;
+        } else if (order.erc1155TokenProperties.length == 1) {
+            Property memory property = order
+                .erc1155TokenProperties[0];
+            if (
+                address(property.propertyValidator) == address(0) &&
+                property.propertyData.length == 0
+            ) {
+                propertiesHash = _NULL_PROPERTY_STRUCT_HASH;
+            } else {
+                // propertiesHash = keccak256(abi.encodePacked(keccak256(abi.encode(
+                //     _PROPERTY_TYPEHASH,
+                //     order.erc1155TokenProperties[0].propertyValidator,
+                //     keccak256(order.erc1155TokenProperties[0].propertyData)
+                // ))));
+                bytes32 dataHash = keccak256(property.propertyData);
+                assembly {
+                    // Load free memory pointer
+                    let mem := mload(64)
+                    mstore(mem, _PROPERTY_TYPEHASH)
+                    // property.propertyValidator
+                    mstore(add(mem, 32), and(ADDRESS_MASK, mload(property)))
+                    // keccak256(property.propertyData)
+                    mstore(add(mem, 64), dataHash)
+                    mstore(mem, keccak256(mem, 96))
+                    propertiesHash := keccak256(mem, 32)
+                }
+            }
+        } else {
+            bytes32[] memory propertyStructHashArray = new bytes32[](
+                order.erc1155TokenProperties.length
+            );
+            for (uint256 i = 0; i < order.erc1155TokenProperties.length; i++) {
+                propertyStructHashArray[i] = keccak256(abi.encode(
+                    _PROPERTY_TYPEHASH,
+                    order.erc1155TokenProperties[i].propertyValidator,
+                    keccak256(order.erc1155TokenProperties[i].propertyData)
+                ));
+            }
+            propertiesHash = keccak256(abi.encodePacked(propertyStructHashArray));
+        }
+
+        // We give `order.fees.length == 0` and
+        // `order.fees.length == 1` special treatment
+        // because we expect these to be the most common.
+        bytes32 feesHash;
+        if (order.fees.length == 0) {
+            feesHash = _EMPTY_ARRAY_KECCAK256;
+        } else if (order.fees.length == 1) {
+            // feesHash = keccak256(abi.encodePacked(keccak256(abi.encode(
+            //     _FEE_TYPEHASH,
+            //     order.fees[0].recipient,
+            //     order.fees[0].amount,
+            //     keccak256(order.fees[0].feeData)
+            // ))));
+            Fee memory fee = order.fees[0];
+            bytes32 dataHash = keccak256(fee.feeData);
+            assembly {
+                // Load free memory pointer
+                let mem := mload(64)
+                mstore(mem, _FEE_TYPEHASH)
+                // fee.recipient
+                mstore(add(mem, 32), and(ADDRESS_MASK, mload(fee)))
+                // fee.amount
+                mstore(add(mem, 64), mload(add(fee, 32)))
+                // keccak256(fee.feeData)
+                mstore(add(mem, 96), dataHash)
+                mstore(mem, keccak256(mem, 128))
+                feesHash := keccak256(mem, 32)
+            }
+        } else {
+            bytes32[] memory feeStructHashArray = new bytes32[](order.fees.length);
+            for (uint256 i = 0; i < order.fees.length; i++) {
+                feeStructHashArray[i] = keccak256(abi.encode(
+                    _FEE_TYPEHASH,
+                    order.fees[i].recipient,
+                    order.fees[i].amount,
+                    keccak256(order.fees[i].feeData)
+                ));
+            }
+            feesHash = keccak256(abi.encodePacked(feeStructHashArray));
+        }
+
+        // Hash in place, equivalent to:
+        // return keccak256(abi.encode(
+        //     _ERC_1155_ORDER_TYPEHASH,
+        //     order.direction,
+        //     order.maker,
+        //     order.taker,
+        //     order.expiry,
+        //     order.nonce,
+        //     order.erc20Token,
+        //     order.erc20TokenAmount,
+        //     feesHash,
+        //     order.erc1155Token,
+        //     order.erc1155TokenId,
+        //     propertiesHash,
+        //     order.erc1155TokenAmount
+        // ));
+        assembly {
+            if lt(order, 32) { invalid() } // Don't underflow memory.
+
+            let typeHashPos := sub(order, 32) // order - 32
+            let feesHashPos := add(order, 224) // order + (32 * 7)
+            let propertiesHashPos := add(order, 320) // order + (32 * 10)
+
+            let temp1 := mload(typeHashPos)
+            let temp2 := mload(feesHashPos)
+            let temp3 := mload(propertiesHashPos)
+
+            mstore(typeHashPos, _ERC_1155_ORDER_TYPEHASH)
+            mstore(feesHashPos, feesHash)
+            mstore(propertiesHashPos, propertiesHash)
+            structHash := keccak256(typeHashPos, 416 /* 32 * 12 */ )
+
+            mstore(typeHashPos, temp1)
+            mstore(feesHashPos, temp2)
+            mstore(propertiesHashPos, temp3)
+        }
+        return structHash;
+    }
+}

contracts/zero-ex/contracts/src/features/libs/LibSignature.sol

@@ -44,7 +44,8 @@ library LibSignature {
         ILLEGAL,
         INVALID,
         EIP712,
-        ETHSIGN
+        ETHSIGN,
+        PRESIGNED
     }
 
     /// @dev Encoded EC signature.
@@ -146,6 +147,15 @@ library LibSignature {
             ).rrevert();
         }
 
+        // If a feature supports pre-signing, it wouldn't use 
+        // `getSignerOfHash` on a pre-signed order.
+        if (signature.signatureType == SignatureType.PRESIGNED) {
+            LibSignatureRichErrors.SignatureValidationError(
+                LibSignatureRichErrors.SignatureValidationErrorCodes.UNSUPPORTED,
+                hash
+            ).rrevert();
+        }
+
         // Solidity should check that the signature type is within enum range for us
         // when abi-decoding.
     }

contracts/zero-ex/contracts/src/features/multiplex/MultiplexFeature.sol

@@ -622,15 +622,6 @@ contract MultiplexFeature is
             _executeBatchSell(batchSellParams).boughtAmount;
     }
 
-    // Transfers some amount of ETH to the given recipient and
-    // reverts if the transfer fails.
-    function _transferEth(address payable recipient, uint256 amount)
-        private
-    {
-        (bool success,) = recipient.call{value: amount}("");
-        require(success, "MultiplexFeature::_transferEth/TRANSFER_FAILED");
-    }
-
     // This function computes the "target" address of hop index `i` within
     // a multi-hop sell.
     // If `i == 0`, the target is the address which should hold the input

contracts/zero-ex/contracts/src/features/nft_orders/ERC1155OrdersFeature.sol

@@ -0,0 +1,625 @@
+// SPDX-License-Identifier: Apache-2.0
+/*
+
+  Copyright 2021 ZeroEx Intl.
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+
+*/
+
+pragma solidity ^0.6.5;
+pragma experimental ABIEncoderV2;
+
+import "@0x/contracts-erc20/contracts/src/v06/IEtherTokenV06.sol";
+import "@0x/contracts-utils/contracts/src/v06/LibSafeMathV06.sol";
+import "../../fixins/FixinERC1155Spender.sol";
+import "../../migrations/LibMigrate.sol";
+import "../../storage/LibERC1155OrdersStorage.sol";
+import "../interfaces/IFeature.sol";
+import "../interfaces/IERC1155OrdersFeature.sol";
+import "../libs/LibNFTOrder.sol";
+import "../libs/LibSignature.sol";
+import "./NFTOrders.sol";
+
+
+/// @dev Feature for interacting with ERC1155 orders.
+contract ERC1155OrdersFeature is
+    IFeature,
+    IERC1155OrdersFeature,
+    FixinERC1155Spender,
+    NFTOrders
+{
+    using LibSafeMathV06 for uint256;
+    using LibSafeMathV06 for uint128;
+    using LibNFTOrder for LibNFTOrder.ERC1155Order;
+    using LibNFTOrder for LibNFTOrder.NFTOrder;
+
+    /// @dev Name of this feature.
+    string public constant override FEATURE_NAME = "ERC1155Orders";
+    /// @dev Version of this feature.
+    uint256 public immutable override FEATURE_VERSION = _encodeVersion(1, 0, 0);
+
+    /// @dev The magic return value indicating the success of a `onERC1155Received`.
+    bytes4 private constant ERC1155_RECEIVED_MAGIC_BYTES = this.onERC1155Received.selector;
+    /// @dev Highest bit of a uint256, used to flag cancelled orders.
+    uint256 private constant CANCEL_BIT = 1 << 255;
+    /// @dev Second-highest bit of a uint256, used to flag pre-signed orders.
+    uint256 private constant PRESIGN_BIT = 1 << 254;
+
+
+    constructor(address zeroExAddress, IEtherTokenV06 weth)
+        public
+        NFTOrders(zeroExAddress, weth)
+    {}
+
+    /// @dev Initialize and register this feature.
+    ///      Should be delegatecalled by `Migrate.migrate()`.
+    /// @return success `LibMigrate.SUCCESS` on success.
+    function migrate()
+        external
+        returns (bytes4 success)
+    {
+        _registerFeatureFunction(this.sellERC1155.selector);
+        _registerFeatureFunction(this.buyERC1155.selector);
+        _registerFeatureFunction(this.cancelERC1155Order.selector);
+        _registerFeatureFunction(this.batchBuyERC1155s.selector);
+        _registerFeatureFunction(this.onERC1155Received.selector);
+        _registerFeatureFunction(this.preSignERC1155Order.selector);
+        _registerFeatureFunction(this.validateERC1155OrderSignature.selector);
+        _registerFeatureFunction(this.validateERC1155OrderProperties.selector);
+        _registerFeatureFunction(this.getERC1155OrderInfo.selector);
+        _registerFeatureFunction(this.getERC1155OrderHash.selector);
+        return LibMigrate.MIGRATE_SUCCESS;
+    }
+
+    /// @dev Sells an ERC1155 asset to fill the given order.
+    /// @param buyOrder The ERC1155 buy order.
+    /// @param signature The order signature from the maker.
+    /// @param erc1155TokenId The ID of the ERC1155 asset being
+    ///        sold. If the given order specifies properties,
+    ///        the asset must satisfy those properties. Otherwise,
+    ///        it must equal the tokenId in the order.
+    /// @param erc1155SellAmount The amount of the ERC1155 asset
+    ///        to sell.
+    /// @param unwrapNativeToken If this parameter is true and the
+    ///        ERC20 token of the order is e.g. WETH, unwraps the
+    ///        token before transferring it to the taker.
+    /// @param callbackData If this parameter is non-zero, invokes
+    ///        `zeroExERC1155OrderCallback` on `msg.sender` after
+    ///        the ERC20 tokens have been transferred to `msg.sender`
+    ///        but before transferring the ERC1155 asset to the buyer.
+    function sellERC1155(
+        LibNFTOrder.ERC1155Order memory buyOrder,
+        LibSignature.Signature memory signature,
+        uint256 erc1155TokenId,
+        uint128 erc1155SellAmount,
+        bool unwrapNativeToken,
+        bytes memory callbackData
+    )
+        public
+        override
+    {
+        _sellERC1155(
+            buyOrder,
+            signature,
+            SellParams(
+                erc1155SellAmount,
+                erc1155TokenId,
+                unwrapNativeToken,
+                msg.sender, // taker
+                msg.sender, // owner
+                callbackData
+            )
+        );
+    }
+
+    /// @dev Buys an ERC1155 asset by filling the given order.
+    /// @param sellOrder The ERC1155 sell order.
+    /// @param signature The order signature.
+    /// @param erc1155BuyAmount The amount of the ERC1155 asset
+    ///        to buy.
+    /// @param callbackData If this parameter is non-zero, invokes
+    ///        `zeroExERC1155OrderCallback` on `msg.sender` after
+    ///        the ERC1155 asset has been transferred to `msg.sender`
+    ///        but before transferring the ERC20 tokens to the seller.
+    ///        Native tokens acquired during the callback can be used
+    ///        to fill the order.
+    function buyERC1155(
+        LibNFTOrder.ERC1155Order memory sellOrder,
+        LibSignature.Signature memory signature,
+        uint128 erc1155BuyAmount,
+        bytes memory callbackData
+    )
+        public
+        override
+        payable
+    {
+        uint256 ethBalanceBefore = address(this).balance
+            .safeSub(msg.value);
+        _buyERC1155(
+            sellOrder,
+            signature,
+            BuyParams(
+                erc1155BuyAmount,
+                msg.value,
+                callbackData
+            )
+        );
+        uint256 ethBalanceAfter = address(this).balance;
+        // Cannot spent more than `msg.value`
+        if (ethBalanceAfter < ethBalanceBefore) {
+            LibNFTOrdersRichErrors.OverspentEthError(
+                ethBalanceBefore - ethBalanceAfter + msg.value,
+                msg.value
+            ).rrevert();
+        }
+        // Refund
+        _transferEth(msg.sender, ethBalanceAfter - ethBalanceBefore);
+    }
+
+    /// @dev Cancel a single ERC1155 order. The caller should be the
+    ///      maker of the order. Silently succeeds if the order has
+    ///      already been filled or cancelled.
+    /// @param order The order to cancel.
+    function cancelERC1155Order(LibNFTOrder.ERC1155Order memory order)
+        public
+        override
+    {
+        require(
+            order.maker == msg.sender,
+            "ERC1155OrdersFeature::cancelERC1155Order/ONLY_MAKER"
+        );
+
+        bytes32 orderHash = getERC1155OrderHash(order);
+        // Set the high bit on the order state variable to indicate
+        // a cancel. It's OK to cancel twice.
+        LibERC1155OrdersStorage.Storage storage stor =
+            LibERC1155OrdersStorage.getStorage();
+        stor.orderState[orderHash] |= CANCEL_BIT;
+
+        emit ERC1155OrderCancelled(orderHash, msg.sender);
+    }
+
+    /// @dev Cancel multiple ERC1155 orders. The caller should be the
+    ///      maker of the orders. Silently succeeds if an order has
+    ///      already been filled or cancelled.
+    /// @param orders The orders to cancel.
+    function batchCancelERC1155Orders(LibNFTOrder.ERC1155Order[] memory orders)
+        public
+        override
+    {
+        for (uint256 i = 0; i < orders.length; i++) {
+            cancelERC1155Order(orders[i]);
+        }
+    }
+
+    /// @dev Buys multiple ERC1155 assets by filling the
+    ///      given orders.
+    /// @param sellOrders The ERC1155 sell orders.
+    /// @param signatures The order signatures.
+    /// @param erc1155FillAmounts The amounts of the ERC1155 assets
+    ///        to buy for each order.
+    /// @param revertIfIncomplete If true, reverts if this
+    ///        function fails to fill any individual order.
+    /// @return successes An array of booleans corresponding to whether
+    ///         each order in `orders` was successfully filled.
+    function batchBuyERC1155s(
+        LibNFTOrder.ERC1155Order[] memory sellOrders,
+        LibSignature.Signature[] memory signatures,
+        uint128[] calldata erc1155FillAmounts,
+        bool revertIfIncomplete
+    )
+        public
+        override
+        payable
+        returns (bool[] memory successes)
+    {
+        require(
+            sellOrders.length == signatures.length &&
+            sellOrders.length == erc1155FillAmounts.length,
+            "ERC1155OrdersFeature::batchBuyERC1155s/ARRAY_LENGTH_MISMATCH"
+        );
+        successes = new bool[](sellOrders.length);
+
+        uint256 ethSpent = 0;
+        for (uint256 i = 0; i < sellOrders.length; i++) {
+            bytes memory returnData;
+            // Delegatecall `_buyERC1155` to track ETH consumption while
+            // preserving execution context.
+            // Note that `_buyERC1155` is a public function but should _not_
+            // be registered in the Exchange Proxy.
+            (successes[i], returnData) = _implementation.delegatecall(
+                abi.encodeWithSelector(
+                    this._buyERC1155.selector,
+                    sellOrders[i],
+                    signatures[i],
+                    BuyParams(
+                        erc1155FillAmounts[i],
+                        msg.value - ethSpent, // Remaining ETH available
+                        new bytes(0)          // No taker callback; allowing a
+                                              // callback would potentially mess
+                                              // up the ETH accounting here.
+                    )
+                )
+            );
+            if (successes[i]) {
+                (uint256 _ethSpent) = abi.decode(returnData, (uint256));
+                ethSpent = ethSpent.safeAdd(_ethSpent);
+            } else if (revertIfIncomplete) {
+                // Bubble up revert
+                returnData.rrevert();
+            }
+        }
+
+        if (ethSpent > msg.value) {
+            LibNFTOrdersRichErrors.OverspentEthError(
+                ethSpent,
+                msg.value
+            ).rrevert();
+        }
+
+        // Refund
+        _transferEth(msg.sender, msg.value - ethSpent);
+    }
+
+    /// @dev Callback for the ERC1155 `safeTransferFrom` function.
+    ///      This callback can be used to sell an ERC1155 asset if
+    ///      a valid ERC1155 order, signature and `unwrapNativeToken`
+    ///      are encoded in `data`. This allows takers to sell their
+    ///      ERC1155 asset without first calling `setApprovalForAll`.
+    /// @param operator The address which called `safeTransferFrom`.
+    /// @param tokenId The ID of the asset being transferred.
+    /// @param value The amount being transferred.
+    /// @param data Additional data with no specified format. If a
+    ///        valid ERC1155 order, signature and `unwrapNativeToken`
+    ///        are encoded in `data`, this function will try to fill
+    ///        the order using the received asset.
+    /// @return success The selector of this function (0xf23a6e61),
+    ///         indicating that the callback succeeded.
+    function onERC1155Received(
+        address operator,
+        address /* from */,
+        uint256 tokenId,
+        uint256 value,
+        bytes calldata data
+    )
+        external
+        override
+        returns (bytes4 success)
+    {
+        // Decode the order, signature, and `unwrapNativeToken` from
+        // `data`. If `data` does not encode such parameters, this
+        // will throw.
+        (
+            LibNFTOrder.ERC1155Order memory buyOrder,
+            LibSignature.Signature memory signature,
+            bool unwrapNativeToken
+        ) = abi.decode(
+            data,
+            (LibNFTOrder.ERC1155Order, LibSignature.Signature, bool)
+        );
+
+        // `onERC1155Received` is called by the ERC1155 token contract.
+        // Check that it matches the ERC1155 token in the order.
+        if (msg.sender != address(buyOrder.erc1155Token)) {
+            LibNFTOrdersRichErrors.ERC1155TokenMismatchError(
+                msg.sender,
+                address(buyOrder.erc1155Token)
+            ).rrevert();
+        }
+
+        _sellERC1155(
+            buyOrder,
+            signature,
+            SellParams(
+                value.safeDowncastToUint128(),
+                tokenId,
+                unwrapNativeToken,
+                operator,       // taker
+                address(this),  // owner (we hold the NFT currently)
+                new bytes(0)    // No taker callback
+            )
+        );
+
+        return ERC1155_RECEIVED_MAGIC_BYTES;
+    }
+
+    /// @dev Approves an ERC1155 order on-chain. After pre-signing
+    ///      the order, the `PRESIGNED` signature type will become
+    ///      valid for that order and signer.
+    /// @param order An ERC1155 order.
+    function preSignERC1155Order(LibNFTOrder.ERC1155Order memory order)
+        public
+        override
+    {
+        require(
+            order.maker == msg.sender,
+            "ERC1155OrdersFeature::preSignERC1155Order/MAKER_MISMATCH"
+        );
+        bytes32 orderHash = getERC1155OrderHash(order);
+
+        LibERC1155OrdersStorage.Storage storage stor =
+            LibERC1155OrdersStorage.getStorage();
+        // Set the second-highest bit on the order state variable
+        // to indicate that the order has been pre-signed.
+        stor.orderState[orderHash] |= PRESIGN_BIT;
+
+        emit ERC1155OrderPreSigned(
+            order.direction,
+            order.maker,
+            order.taker,
+            order.expiry,
+            order.nonce,
+            order.erc20Token,
+            order.erc20TokenAmount,
+            order.fees,
+            order.erc1155Token,
+            order.erc1155TokenId,
+            order.erc1155TokenProperties,
+            order.erc1155TokenAmount
+        );
+    }
+
+    // Core settlement logic for selling an ERC1155 asset.
+    // Used by `sellERC1155` and `onERC1155Received`.
+    function _sellERC1155(
+        LibNFTOrder.ERC1155Order memory buyOrder,
+        LibSignature.Signature memory signature,
+        SellParams memory params
+    )
+        private
+    {
+        uint256 erc20FillAmount = _sellNFT(
+            buyOrder.asNFTOrder(),
+            signature,
+            params
+        );
+
+        emit ERC1155OrderFilled(
+            buyOrder.direction,
+            buyOrder.maker,
+            params.taker,
+            buyOrder.nonce,
+            buyOrder.erc20Token,
+            erc20FillAmount,
+            buyOrder.erc1155Token,
+            params.tokenId,
+            params.sellAmount,
+            address(0)
+        );
+    }
+
+    // Core settlement logic for buying an ERC1155 asset.
+    // Used by `buyERC1155` and `batchBuyERC1155s`.
+    function _buyERC1155(
+        LibNFTOrder.ERC1155Order memory sellOrder,
+        LibSignature.Signature memory signature,
+        BuyParams memory params
+    )
+        public
+        payable
+        returns (uint256 ethSpent)
+    {
+        uint256 erc20FillAmount;
+        (erc20FillAmount, ethSpent) = _buyNFT(
+            sellOrder.asNFTOrder(),
+            signature,
+            params
+        );
+
+        emit ERC1155OrderFilled(
+            sellOrder.direction,
+            sellOrder.maker,
+            msg.sender,
+            sellOrder.nonce,
+            sellOrder.erc20Token,
+            erc20FillAmount,
+            sellOrder.erc1155Token,
+            sellOrder.erc1155TokenId,
+            params.buyAmount,
+            address(0)
+        );
+    }
+
+    /// @dev Checks whether the given signature is valid for the
+    ///      the given ERC1155 order. Reverts if not.
+    /// @param order The ERC1155 order.
+    /// @param signature The signature to validate.
+    function validateERC1155OrderSignature(
+        LibNFTOrder.ERC1155Order memory order,
+        LibSignature.Signature memory signature
+    )
+        public
+        override
+        view
+    {
+        bytes32 orderHash = getERC1155OrderHash(order);
+        _validateOrderSignature(orderHash, signature, order.maker);
+    }
+
+    /// @dev Validates that the given signature is valid for the
+    ///      given maker and order hash. Reverts if the signature
+    ///      is not valid.
+    /// @param orderHash The hash of the order that was signed.
+    /// @param signature The signature to check.
+    /// @param maker The maker of the order.
+    function _validateOrderSignature(
+        bytes32 orderHash,
+        LibSignature.Signature memory signature,
+        address maker
+    )
+        internal
+        override
+        view
+    {
+        if (signature.signatureType == LibSignature.SignatureType.PRESIGNED) {
+            // Check if order hash has been pre-signed by the maker.
+            uint256 orderState = LibERC1155OrdersStorage.getStorage()
+                .orderState[orderHash];
+            bool isPreSigned = orderState & PRESIGN_BIT != 0;
+            if (!isPreSigned) {
+                LibNFTOrdersRichErrors.InvalidSignerError(maker, address(0)).rrevert();
+            }
+        } else {
+            address signer = LibSignature.getSignerOfHash(orderHash, signature);
+            if (signer != maker) {
+                LibNFTOrdersRichErrors.InvalidSignerError(maker, signer).rrevert();
+            }
+        }
+    }
+
+    /// @dev Transfers an NFT asset.
+    /// @param token The address of the NFT contract.
+    /// @param from The address currently holding the asset.
+    /// @param to The address to transfer the asset to.
+    /// @param tokenId The ID of the asset to transfer.
+    /// @param amount The amount of the asset to transfer. Always
+    ///        1 for ERC721 assets.
+    function _transferNFTAssetFrom(
+        address token,
+        address from,
+        address to,
+        uint256 tokenId,
+        uint256 amount
+    )
+        internal
+        override
+    {
+        _transferERC1155AssetFrom(IERC1155Token(token), from, to, tokenId, amount);
+    }
+
+    /// @dev Updates storage to indicate that the given order
+    ///      has been filled by the given amount.
+    /// @param orderHash The hash of `order`.
+    /// @param fillAmount The amount (denominated in the NFT asset)
+    ///        that the order has been filled by.
+    function _updateOrderState(
+        LibNFTOrder.NFTOrder memory /* order */,
+        bytes32 orderHash,
+        uint128 fillAmount
+    )
+        internal
+        override
+    {
+        LibERC1155OrdersStorage.Storage storage stor = LibERC1155OrdersStorage.getStorage();
+        uint128 currentFilledAmount = uint128(stor.orderState[orderHash]);
+        // Filled amount should never overflow 128 bits
+        assert(currentFilledAmount + fillAmount > currentFilledAmount);
+        stor.orderState[orderHash] += fillAmount;
+    }
+
+    /// @dev If the given order is buying an ERC1155 asset, checks
+    ///      whether or not the given token ID satisfies the required
+    ///      properties specified in the order. If the order does not
+    ///      specify any properties, this function instead checks
+    ///      whether the given token ID matches the ID in the order.
+    ///      Reverts if any checks fail, or if the order is selling
+    ///      an ERC1155 asset.
+    /// @param order The ERC1155 order.
+    /// @param erc1155TokenId The ID of the ERC1155 asset.
+    function validateERC1155OrderProperties(
+        LibNFTOrder.ERC1155Order memory order,
+        uint256 erc1155TokenId
+    )
+        public
+        override
+        view
+    {
+        _validateOrderProperties(
+            order.asNFTOrder(),
+            erc1155TokenId
+        );
+    }
+
+    /// @dev Get the order info for an ERC1155 order.
+    /// @param order The ERC1155 order.
+    /// @return orderInfo Info about the order.
+    function getERC1155OrderInfo(LibNFTOrder.ERC1155Order memory order)
+        public
+        override
+        view
+        returns (LibNFTOrder.OrderInfo memory orderInfo)
+    {
+        orderInfo.orderAmount = order.erc1155TokenAmount;
+        orderInfo.orderHash = getERC1155OrderHash(order);
+
+        {
+            LibERC1155OrdersStorage.Storage storage stor =
+                LibERC1155OrdersStorage.getStorage();
+            uint256 orderState = stor.orderState[orderInfo.orderHash];
+            orderInfo.remainingAmount = order.erc1155TokenAmount
+                .safeSub128(uint128(orderState));
+
+            if (orderInfo.remainingAmount == 0) {
+                orderInfo.status = LibNFTOrder.OrderStatus.UNFILLABLE;
+                return orderInfo;
+            }
+            if (orderState & CANCEL_BIT != 0) {
+                orderInfo.status = LibNFTOrder.OrderStatus.UNFILLABLE;
+                return orderInfo;
+            }
+        }
+
+        // Only buy orders with `erc1155TokenId` == 0 can be property
+        // orders.
+        if (order.erc1155TokenProperties.length > 0 &&
+                (order.direction != LibNFTOrder.TradeDirection.BUY_NFT ||
+                 order.erc1155TokenId != 0))
+        {
+            orderInfo.status = LibNFTOrder.OrderStatus.INVALID;
+            return orderInfo;
+        }
+
+        // Buy orders cannot use ETH as the ERC20 token, since ETH cannot be
+        // transferred from the buyer by a contract.
+        if (order.direction == LibNFTOrder.TradeDirection.BUY_NFT &&
+            address(order.erc20Token) == NATIVE_TOKEN_ADDRESS)
+        {
+            orderInfo.status = LibNFTOrder.OrderStatus.INVALID;
+            return orderInfo;
+        }
+
+        // Check for expiry.
+        if (order.expiry <= block.timestamp) {
+            orderInfo.status = LibNFTOrder.OrderStatus.EXPIRED;
+            return orderInfo;
+        }
+
+        // Otherwise, the order is fillable.
+        orderInfo.status = LibNFTOrder.OrderStatus.FILLABLE;
+    }
+
+    /// @dev Get the order info for an NFT order.
+    /// @param order The NFT order.
+    /// @return orderInfo Info about the order.
+    function _getOrderInfo(LibNFTOrder.NFTOrder memory order)
+        internal
+        override
+        view
+        returns (LibNFTOrder.OrderInfo memory orderInfo)
+    {
+        return getERC1155OrderInfo(order.asERC1155Order());
+    }
+
+    /// @dev Get the canonical hash of an ERC1155 order.
+    /// @param order The ERC1155 order.
+    /// @return orderHash The order hash.
+    function getERC1155OrderHash(LibNFTOrder.ERC1155Order memory order)
+        public
+        override
+        view
+        returns (bytes32 orderHash)
+    {
+        return _getEIP712Hash(LibNFTOrder.getERC1155OrderStructHash(order));
+    }
+}

contracts/zero-ex/contracts/src/features/nft_orders/ERC721OrdersFeature.sol

@@ -0,0 +1,931 @@
+// SPDX-License-Identifier: Apache-2.0
+/*
+
+  Copyright 2021 ZeroEx Intl.
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+
+*/
+
+pragma solidity ^0.6.5;
+pragma experimental ABIEncoderV2;
+
+import "@0x/contracts-erc20/contracts/src/v06/IEtherTokenV06.sol";
+import "@0x/contracts-utils/contracts/src/v06/LibSafeMathV06.sol";
+import "../../fixins/FixinERC721Spender.sol";
+import "../../migrations/LibMigrate.sol";
+import "../../storage/LibERC721OrdersStorage.sol";
+import "../interfaces/IFeature.sol";
+import "../interfaces/IERC721OrdersFeature.sol";
+import "../libs/LibNFTOrder.sol";
+import "../libs/LibSignature.sol";
+import "./NFTOrders.sol";
+
+
+/// @dev Feature for interacting with ERC721 orders.
+contract ERC721OrdersFeature is
+    IFeature,
+    IERC721OrdersFeature,
+    FixinERC721Spender,
+    NFTOrders
+{
+    using LibSafeMathV06 for uint256;
+    using LibNFTOrder for LibNFTOrder.ERC721Order;
+    using LibNFTOrder for LibNFTOrder.NFTOrder;
+
+    /// @dev Name of this feature.
+    string public constant override FEATURE_NAME = "ERC721Orders";
+    /// @dev Version of this feature.
+    uint256 public immutable override FEATURE_VERSION = _encodeVersion(1, 0, 0);
+
+    /// @dev The magic return value indicating the success of a `onERC721Received`.
+    bytes4 private constant ERC721_RECEIVED_MAGIC_BYTES = this.onERC721Received.selector;
+
+
+    constructor(address zeroExAddress, IEtherTokenV06 weth)
+        public
+        NFTOrders(zeroExAddress, weth)
+    {}
+
+    /// @dev Initialize and register this feature.
+    ///      Should be delegatecalled by `Migrate.migrate()`.
+    /// @return success `LibMigrate.SUCCESS` on success.
+    function migrate()
+        external
+        returns (bytes4 success)
+    {
+        _registerFeatureFunction(this.sellERC721.selector);
+        _registerFeatureFunction(this.buyERC721.selector);
+        _registerFeatureFunction(this.cancelERC721Order.selector);
+        _registerFeatureFunction(this.batchBuyERC721s.selector);
+        _registerFeatureFunction(this.matchERC721Orders.selector);
+        _registerFeatureFunction(this.batchMatchERC721Orders.selector);
+        _registerFeatureFunction(this.onERC721Received.selector);
+        _registerFeatureFunction(this.preSignERC721Order.selector);
+        _registerFeatureFunction(this.validateERC721OrderSignature.selector);
+        _registerFeatureFunction(this.validateERC721OrderProperties.selector);
+        _registerFeatureFunction(this.getERC721OrderStatus.selector);
+        _registerFeatureFunction(this.getERC721OrderHash.selector);
+        _registerFeatureFunction(this.getERC721OrderStatusBitVector.selector);
+        return LibMigrate.MIGRATE_SUCCESS;
+    }
+
+    /// @dev Sells an ERC721 asset to fill the given order.
+    /// @param buyOrder The ERC721 buy order.
+    /// @param signature The order signature from the maker.
+    /// @param erc721TokenId The ID of the ERC721 asset being
+    ///        sold. If the given order specifies properties,
+    ///        the asset must satisfy those properties. Otherwise,
+    ///        it must equal the tokenId in the order.
+    /// @param unwrapNativeToken If this parameter is true and the
+    ///        ERC20 token of the order is e.g. WETH, unwraps the
+    ///        token before transferring it to the taker.
+    /// @param callbackData If this parameter is non-zero, invokes
+    ///        `zeroExERC721OrderCallback` on `msg.sender` after
+    ///        the ERC20 tokens have been transferred to `msg.sender`
+    ///        but before transferring the ERC721 asset to the buyer.
+    function sellERC721(
+        LibNFTOrder.ERC721Order memory buyOrder,
+        LibSignature.Signature memory signature,
+        uint256 erc721TokenId,
+        bool unwrapNativeToken,
+        bytes memory callbackData
+    )
+        public
+        override
+    {
+        _sellERC721(
+            buyOrder,
+            signature,
+            erc721TokenId,
+            unwrapNativeToken,
+            msg.sender, // taker
+            msg.sender, // owner
+            callbackData
+        );
+    }
+
+    /// @dev Buys an ERC721 asset by filling the given order.
+    /// @param sellOrder The ERC721 sell order.
+    /// @param signature The order signature.
+    /// @param callbackData If this parameter is non-zero, invokes
+    ///        `zeroExERC721OrderCallback` on `msg.sender` after
+    ///        the ERC721 asset has been transferred to `msg.sender`
+    ///        but before transferring the ERC20 tokens to the seller.
+    ///        Native tokens acquired during the callback can be used
+    ///        to fill the order.
+    function buyERC721(
+        LibNFTOrder.ERC721Order memory sellOrder,
+        LibSignature.Signature memory signature,
+        bytes memory callbackData
+    )
+        public
+        override
+        payable
+    {
+        uint256 ethBalanceBefore = address(this).balance
+            .safeSub(msg.value);
+        _buyERC721(
+            sellOrder,
+            signature,
+            msg.value,
+            callbackData
+        );
+        uint256 ethBalanceAfter = address(this).balance;
+        // Cannot spent more than `msg.value`
+        if (ethBalanceAfter < ethBalanceBefore) {
+            LibNFTOrdersRichErrors.OverspentEthError(
+                ethBalanceBefore - ethBalanceAfter + msg.value,
+                msg.value
+            ).rrevert();
+        }
+        // Refund
+        _transferEth(msg.sender, ethBalanceAfter - ethBalanceBefore);
+    }
+
+    /// @dev Cancel a single ERC721 order by its nonce. The caller
+    ///      should be the maker of the order. Silently succeeds if
+    ///      an order with the same nonce has already been filled or
+    ///      cancelled.
+    /// @param orderNonce The order nonce.
+    function cancelERC721Order(uint256 orderNonce)
+        public
+        override
+    {
+        // Mark order as cancelled
+        _setOrderStatusBit(msg.sender, orderNonce);
+
+        emit ERC721OrderCancelled(
+            msg.sender,
+            orderNonce
+        );
+    }
+
+    /// @dev Cancel multiple ERC721 orders by their nonces. The caller
+    ///      should be the maker of the orders. Silently succeeds if
+    ///      an order with the same nonce has already been filled or
+    ///      cancelled.
+    /// @param orderNonces The order nonces.
+    function batchCancelERC721Orders(uint256[] calldata orderNonces)
+        external
+        override
+    {
+        for (uint256 i = 0; i < orderNonces.length; i++) {
+            cancelERC721Order(orderNonces[i]);
+        }
+    }
+
+    /// @dev Buys multiple ERC721 assets by filling the
+    ///      given orders.
+    /// @param sellOrders The ERC721 sell orders.
+    /// @param signatures The order signatures.
+    /// @param revertIfIncomplete If true, reverts if this
+    ///        function fails to fill any individual order.
+    /// @return successes An array of booleans corresponding to whether
+    ///         each order in `orders` was successfully filled.
+    function batchBuyERC721s(
+        LibNFTOrder.ERC721Order[] memory sellOrders,
+        LibSignature.Signature[] memory signatures,
+        bool revertIfIncomplete
+    )
+        public
+        override
+        payable
+        returns (bool[] memory successes)
+    {
+        require(
+            sellOrders.length == signatures.length,
+            "ERC721OrdersFeature::batchBuyERC721s/ARRAY_LENGTH_MISMATCH"
+        );
+        successes = new bool[](sellOrders.length);
+
+        uint256 ethSpent = 0;
+        for (uint256 i = 0; i < sellOrders.length; i++) {
+            bytes memory returnData;
+            // Delegatecall `_buyERC721` to track ETH consumption while
+            // preserving execution context.
+            // Note that `_buyERC721` is a public function but should _not_
+            // be registered in the Exchange Proxy.
+            (successes[i], returnData) = _implementation.delegatecall(
+                abi.encodeWithSelector(
+                    this._buyERC721.selector,
+                    sellOrders[i],
+                    signatures[i],
+                    msg.value - ethSpent, // Remaining ETH available
+                    new bytes(0)          // No taker callback; allowing a
+                                          // callback would potentially mess
+                                          // up the ETH accounting here.
+                )
+            );
+            if (successes[i]) {
+                (uint256 _ethSpent) = abi.decode(returnData, (uint256));
+                ethSpent = ethSpent.safeAdd(_ethSpent);
+            } else if (revertIfIncomplete) {
+                // Bubble up revert
+                returnData.rrevert();
+            }
+        }
+
+        if (ethSpent > msg.value) {
+            LibNFTOrdersRichErrors.OverspentEthError(
+                ethSpent,
+                msg.value
+            ).rrevert();
+        }
+
+        // Refund
+        _transferEth(msg.sender, msg.value - ethSpent);
+    }
+
+    /// @dev Matches a pair of complementary orders that have
+    ///      a non-negative spread. Each order is filled at
+    ///      their respective price, and the matcher receives
+    ///      a profit denominated in the ERC20 token.
+    /// @param sellOrder Order selling an ERC721 asset.
+    /// @param buyOrder Order buying an ERC721 asset.
+    /// @param sellOrderSignature Signature for the sell order.
+    /// @param buyOrderSignature Signature for the buy order.
+    /// @return profit The amount of profit earned by the caller
+    ///         of this function (denominated in the ERC20 token
+    ///         of the matched orders).
+    function matchERC721Orders(
+        LibNFTOrder.ERC721Order memory sellOrder,
+        LibNFTOrder.ERC721Order memory buyOrder,
+        LibSignature.Signature memory sellOrderSignature,
+        LibSignature.Signature memory buyOrderSignature
+    )
+        public
+        override
+        returns (uint256 profit)
+    {
+        LibNFTOrder.NFTOrder memory sellNFTOrder = sellOrder.asNFTOrder();
+        LibNFTOrder.NFTOrder memory buyNFTOrder = buyOrder.asNFTOrder();
+
+        {
+            LibNFTOrder.OrderInfo memory sellOrderInfo = _getOrderInfo(sellNFTOrder);
+            LibNFTOrder.OrderInfo memory buyOrderInfo = _getOrderInfo(buyNFTOrder);
+
+            _validateSellOrder(
+                sellNFTOrder,
+                sellOrderSignature,
+                sellOrderInfo,
+                buyOrder.maker
+            );
+            _validateBuyOrder(
+                buyNFTOrder,
+                buyOrderSignature,
+                buyOrderInfo,
+                sellOrder.maker,
+                sellOrder.erc721TokenId
+            );
+
+            // Mark both orders as filled.
+            _updateOrderState(sellNFTOrder, sellOrderInfo.orderHash, 1);
+            _updateOrderState(buyNFTOrder, buyOrderInfo.orderHash, 1);
+        }
+
+        // The ERC721 tokens must match
+        if (sellOrder.erc721Token != buyOrder.erc721Token) {
+            LibNFTOrdersRichErrors.ERC721TokenMismatchError(
+                address(sellOrder.erc721Token),
+                address(buyOrder.erc721Token)
+            ).rrevert();
+        }
+
+        {
+            // The ERC20 tokens must match. Okay if the sell order specifies ETH
+            // and the buy order specifies WETH; we will unwrap the WETH before
+            // sending it to `sellOrder.maker`.
+            bool isWethBuyEthSell =
+                address(sellOrder.erc20Token) == NATIVE_TOKEN_ADDRESS &&
+                buyOrder.erc20Token == WETH;
+            if (sellOrder.erc20Token != buyOrder.erc20Token && !isWethBuyEthSell) {
+                LibNFTOrdersRichErrors.ERC20TokenMismatchError(
+                    address(sellOrder.erc20Token),
+                    address(buyOrder.erc20Token)
+                ).rrevert();
+            }
+        }
+        // The buyer must be willing to pay at least the amount that the
+        // seller is asking.
+        if (buyOrder.erc20TokenAmount < sellOrder.erc20TokenAmount) {
+            LibNFTOrdersRichErrors.NegativeSpreadError(
+                sellOrder.erc20TokenAmount,
+                buyOrder.erc20TokenAmount
+            ).rrevert();
+        }
+
+        // The difference in ERC20 token amounts is the spread.
+        uint256 spread = buyOrder.erc20TokenAmount - sellOrder.erc20TokenAmount;
+
+        // Transfer the ERC721 asset from seller to buyer.
+        _transferERC721AssetFrom(
+            sellOrder.erc721Token,
+            sellOrder.maker,
+            buyOrder.maker,
+            sellOrder.erc721TokenId
+        );
+
+        // Handle the ERC20 side of the order:
+        if (
+            address(sellOrder.erc20Token) == NATIVE_TOKEN_ADDRESS &&
+            buyOrder.erc20Token == WETH
+        ) {
+            // The sell order specifies ETH, while the buy order specifies WETH.
+            // The orders are still compatible with one another, but we'll have
+            // to unwrap the WETH on behalf of the buyer.
+
+            // Step 1: Transfer WETH from the buyer to the EP.
+            //         Note that we transfer `buyOrder.erc20TokenAmount`, which
+            //         is the amount the buyer signaled they are willing to pay
+            //         for the ERC721 asset, which may be more than the seller's
+            //         ask.
+            _transferERC20TokensFrom(
+                WETH,
+                buyOrder.maker,
+                address(this),
+                buyOrder.erc20TokenAmount
+            );
+            // Step 2: Unwrap the WETH into ETH. We unwrap the entire
+            //         `buyOrder.erc20TokenAmount`.
+            //         The ETH will be used for three purposes:
+            //         - To pay the seller
+            //         - To pay fees for the sell order
+            //         - Any remaining ETH will be sent to
+            //           `msg.sender` as profit.
+            WETH.withdraw(buyOrder.erc20TokenAmount);
+
+            // Step 3: Pay the seller (in ETH).
+            _transferEth(payable(sellOrder.maker), sellOrder.erc20TokenAmount);
+
+            // Step 4: Pay fees for the buy order. Note that these are paid
+            //         in _WETH_ by the _buyer_. By signing the buy order, the
+            //         buyer signals that they are willing to spend a total
+            //         of `erc20TokenAmount` _plus_ fees, all denominated in
+            //         the `erc20Token`, which in this case is WETH.
+            _payFees(
+                buyNFTOrder,
+                buyOrder.maker,
+                1,
+                1,
+                false
+            );
+
+            // Step 5: Pay fees for the sell order. The `erc20Token` of the
+            //         sell order is ETH, so the fees are paid out in ETH.
+            //         There should be `spread` wei of ETH remaining in the
+            //         EP at this point, which we will use ETH to pay the
+            //         sell order fees.
+            uint256 sellOrderFees = _payFees(
+                sellNFTOrder,
+                address(this),
+                1,
+                1,
+                true
+            );
+
+            // Step 6: The spread must be enough to cover the sell order fees.
+            //         If not, either `_payFees` will have reverted, or we
+            //         have spent ETH that was in the EP before this
+            //         `matchERC721Orders` call, which we disallow.
+            if (spread < sellOrderFees) {
+                LibNFTOrdersRichErrors.SellOrderFeesExceedSpreadError(
+                    sellOrderFees,
+                    spread
+                ).rrevert();
+            }
+            // Step 7: The spread less the sell order fees is the amount of ETH
+            //         remaining in the EP that can be sent to `msg.sender` as
+            //         the profit from matching these two orders.
+            profit = spread - sellOrderFees;
+            if (profit > 0) {
+                _transferEth(msg.sender, profit);
+            }
+        } else {
+            // Step 1: Transfer the ERC20 token from the buyer to the seller.
+            //         Note that we transfer `sellOrder.erc20TokenAmount`, which
+            //         is at most `buyOrder.erc20TokenAmount`.
+            _transferERC20TokensFrom(
+                buyOrder.erc20Token,
+                buyOrder.maker,
+                sellOrder.maker,
+                sellOrder.erc20TokenAmount
+            );
+
+            // Step 2: Pay fees for the buy order. Note that these are paid
+            //         by the buyer. By signing the buy order, the buyer signals
+            //         that they are willing to spend a total of
+            //         `buyOrder.erc20TokenAmount` _plus_ `buyOrder.fees`.
+            _payFees(
+                buyNFTOrder,
+                buyOrder.maker,
+                1,
+                1,
+                false
+            );
+
+            // Step 3: Pay fees for the sell order. These are paid by the buyer
+            //         as well. After paying these fees, we may have taken more
+            //         from the buyer than they agreed to in the buy order. If
+            //         so, we revert in the following step.
+            uint256 sellOrderFees = _payFees(
+                sellNFTOrder,
+                buyOrder.maker,
+                1,
+                1,
+                false
+            );
+
+            // Step 4: The spread must be enough to cover the sell order fees.
+            //         If not, `_payFees` will have taken more tokens from the
+            //         buyer than they had agreed to in the buy order, in which
+            //         case we revert here.
+            if (spread < sellOrderFees) {
+                LibNFTOrdersRichErrors.SellOrderFeesExceedSpreadError(
+                    sellOrderFees,
+                    spread
+                ).rrevert();
+            }
+
+            // Step 7: We calculate the profit as:
+            //         profit = buyOrder.erc20TokenAmount - sellOrder.erc20TokenAmount - sellOrderFees
+            //                = spread - sellOrderFees
+            //         I.e. the buyer would've been willing to pay up to `profit`
+            //         more to buy the asset, so instead that amount is sent to
+            //         `msg.sender` as the profit from matching these two orders.
+            profit = spread - sellOrderFees;
+            if (profit > 0) {
+                _transferERC20TokensFrom(
+                    buyOrder.erc20Token,
+                    buyOrder.maker,
+                    msg.sender,
+                    profit
+                );
+            }
+        }
+
+        emit ERC721OrderFilled(
+            sellOrder.direction,
+            sellOrder.maker,
+            buyOrder.maker, // taker
+            sellOrder.nonce,
+            sellOrder.erc20Token,
+            sellOrder.erc20TokenAmount,
+            sellOrder.erc721Token,
+            sellOrder.erc721TokenId,
+            msg.sender
+        );
+
+        emit ERC721OrderFilled(
+            buyOrder.direction,
+            buyOrder.maker,
+            sellOrder.maker, // taker
+            buyOrder.nonce,
+            buyOrder.erc20Token,
+            buyOrder.erc20TokenAmount,
+            buyOrder.erc721Token,
+            sellOrder.erc721TokenId,
+            msg.sender
+        );
+    }
+
+    /// @dev Matches pairs of complementary orders that have
+    ///      non-negative spreads. Each order is filled at
+    ///      their respective price, and the matcher receives
+    ///      a profit denominated in the ERC20 token.
+    /// @param sellOrders Orders selling ERC721 assets.
+    /// @param buyOrders Orders buying ERC721 assets.
+    /// @param sellOrderSignatures Signatures for the sell orders.
+    /// @param buyOrderSignatures Signatures for the buy orders.
+    /// @return profits The amount of profit earned by the caller
+    ///         of this function for each pair of matched orders
+    ///         (denominated in the ERC20 token of the order pair).
+    /// @return successes An array of booleans corresponding to
+    ///         whether each pair of orders was successfully matched.
+    function batchMatchERC721Orders(
+        LibNFTOrder.ERC721Order[] memory sellOrders,
+        LibNFTOrder.ERC721Order[] memory buyOrders,
+        LibSignature.Signature[] memory sellOrderSignatures,
+        LibSignature.Signature[] memory buyOrderSignatures
+    )
+        public
+        override
+        returns (uint256[] memory profits, bool[] memory successes)
+    {
+        require(
+            sellOrders.length == buyOrders.length &&
+            sellOrderSignatures.length == buyOrderSignatures.length &&
+            sellOrders.length == sellOrderSignatures.length,
+            "ERC721OrdersFeature::batchMatchERC721Orders/ARRAY_LENGTH_MISMATCH"
+        );
+        profits = new uint256[](sellOrders.length);
+        successes = new bool[](sellOrders.length);
+
+        for (uint256 i = 0; i < sellOrders.length; i++) {
+            bytes memory returnData;
+            // Delegatecall `matchERC721Orders` to catch reverts while
+            // preserving execution context.
+            (successes[i], returnData) = _implementation.delegatecall(
+                abi.encodeWithSelector(
+                    this.matchERC721Orders.selector,
+                    sellOrders[i],
+                    buyOrders[i],
+                    sellOrderSignatures[i],
+                    buyOrderSignatures[i]
+                )
+            );
+            if (successes[i]) {
+                // If the matching succeeded, record the profit.
+                (uint256 profit) = abi.decode(returnData, (uint256));
+                profits[i] = profit;
+            }
+        }
+    }
+
+    /// @dev Callback for the ERC721 `safeTransferFrom` function.
+    ///      This callback can be used to sell an ERC721 asset if
+    ///      a valid ERC721 order, signature and `unwrapNativeToken`
+    ///      are encoded in `data`. This allows takers to sell their
+    ///      ERC721 asset without first calling `setApprovalForAll`.
+    /// @param operator The address which called `safeTransferFrom`.
+    /// @param tokenId The ID of the asset being transferred.
+    /// @param data Additional data with no specified format. If a
+    ///        valid ERC721 order, signature and `unwrapNativeToken`
+    ///        are encoded in `data`, this function will try to fill
+    ///        the order using the received asset.
+    /// @return success The selector of this function (0x150b7a02),
+    ///         indicating that the callback succeeded.
+    function onERC721Received(
+        address operator,
+        address /* from */,
+        uint256 tokenId,
+        bytes calldata data
+    )
+        external
+        override
+        returns (bytes4 success)
+    {
+        // Decode the order, signature, and `unwrapNativeToken` from
+        // `data`. If `data` does not encode such parameters, this
+        // will throw.
+        (
+            LibNFTOrder.ERC721Order memory buyOrder,
+            LibSignature.Signature memory signature,
+            bool unwrapNativeToken
+        ) = abi.decode(
+            data,
+            (LibNFTOrder.ERC721Order, LibSignature.Signature, bool)
+        );
+
+        // `onERC721Received` is called by the ERC721 token contract.
+        // Check that it matches the ERC721 token in the order.
+        if (msg.sender != address(buyOrder.erc721Token)) {
+            LibNFTOrdersRichErrors.ERC721TokenMismatchError(
+                msg.sender,
+                address(buyOrder.erc721Token)
+            ).rrevert();
+        }
+
+        _sellERC721(
+            buyOrder,
+            signature,
+            tokenId,
+            unwrapNativeToken,
+            operator,       // taker
+            address(this),  // owner (we hold the NFT currently)
+            new bytes(0)    // No taker callback
+        );
+
+        return ERC721_RECEIVED_MAGIC_BYTES;
+    }
+
+    /// @dev Approves an ERC721 order on-chain. After pre-signing
+    ///      the order, the `PRESIGNED` signature type will become
+    ///      valid for that order and signer.
+    /// @param order An ERC721 order.
+    function preSignERC721Order(LibNFTOrder.ERC721Order memory order)
+        public
+        override
+    {
+        require(
+            order.maker == msg.sender,
+            "ERC721OrdersFeature::preSignERC721Order/ONLY_MAKER"
+        );
+        bytes32 orderHash = getERC721OrderHash(order);
+        LibERC721OrdersStorage.getStorage().preSigned[orderHash] = true;
+
+        emit ERC721OrderPreSigned(
+            order.direction,
+            order.maker,
+            order.taker,
+            order.expiry,
+            order.nonce,
+            order.erc20Token,
+            order.erc20TokenAmount,
+            order.fees,
+            order.erc721Token,
+            order.erc721TokenId,
+            order.erc721TokenProperties
+        );
+    }
+
+    // Core settlement logic for selling an ERC721 asset.
+    // Used by `sellERC721` and `onERC721Received`.
+    function _sellERC721(
+        LibNFTOrder.ERC721Order memory buyOrder,
+        LibSignature.Signature memory signature,
+        uint256 erc721TokenId,
+        bool unwrapNativeToken,
+        address taker,
+        address currentNftOwner,
+        bytes memory takerCallbackData
+    )
+        private
+    {
+        _sellNFT(
+            buyOrder.asNFTOrder(),
+            signature,
+            SellParams(
+                1, // sell amount
+                erc721TokenId,
+                unwrapNativeToken,
+                taker,
+                currentNftOwner,
+                takerCallbackData
+            )
+        );
+
+        emit ERC721OrderFilled(
+            buyOrder.direction,
+            buyOrder.maker,
+            taker,
+            buyOrder.nonce,
+            buyOrder.erc20Token,
+            buyOrder.erc20TokenAmount,
+            buyOrder.erc721Token,
+            erc721TokenId,
+            address(0)
+        );
+    }
+
+    // Core settlement logic for buying an ERC721 asset.
+    // Used by `buyERC721` and `batchBuyERC721s`.
+    function _buyERC721(
+        LibNFTOrder.ERC721Order memory sellOrder,
+        LibSignature.Signature memory signature,
+        uint256 ethAvailable,
+        bytes memory takerCallbackData
+    )
+        public
+        payable
+        returns (uint256 ethSpent)
+    {
+        (, ethSpent) = _buyNFT(
+            sellOrder.asNFTOrder(),
+            signature,
+            BuyParams(
+                1, // buy amount
+                ethAvailable,
+                takerCallbackData
+            )
+        );
+
+        emit ERC721OrderFilled(
+            sellOrder.direction,
+            sellOrder.maker,
+            msg.sender,
+            sellOrder.nonce,
+            sellOrder.erc20Token,
+            sellOrder.erc20TokenAmount,
+            sellOrder.erc721Token,
+            sellOrder.erc721TokenId,
+            address(0)
+        );
+    }
+
+
+    /// @dev Checks whether the given signature is valid for the
+    ///      the given ERC721 order. Reverts if not.
+    /// @param order The ERC721 order.
+    /// @param signature The signature to validate.
+    function validateERC721OrderSignature(
+        LibNFTOrder.ERC721Order memory order,
+        LibSignature.Signature memory signature
+    )
+        public
+        override
+        view
+    {
+        bytes32 orderHash = getERC721OrderHash(order);
+        _validateOrderSignature(orderHash, signature, order.maker);
+    }
+
+    /// @dev Validates that the given signature is valid for the
+    ///      given maker and order hash. Reverts if the signature
+    ///      is not valid.
+    /// @param orderHash The hash of the order that was signed.
+    /// @param signature The signature to check.
+    /// @param maker The maker of the order.
+    function _validateOrderSignature(
+        bytes32 orderHash,
+        LibSignature.Signature memory signature,
+        address maker
+    )
+        internal
+        override
+        view
+    {
+        if (signature.signatureType == LibSignature.SignatureType.PRESIGNED) {
+            // Check if order hash has been pre-signed by the maker.
+            bool isPreSigned = LibERC721OrdersStorage.getStorage().preSigned[orderHash];
+            if (!isPreSigned) {
+                LibNFTOrdersRichErrors.InvalidSignerError(maker, address(0)).rrevert();
+            }
+        } else {
+            address signer = LibSignature.getSignerOfHash(orderHash, signature);
+            if (signer != maker) {
+                LibNFTOrdersRichErrors.InvalidSignerError(maker, signer).rrevert();
+            }
+        }
+    }
+
+    /// @dev Transfers an NFT asset.
+    /// @param token The address of the NFT contract.
+    /// @param from The address currently holding the asset.
+    /// @param to The address to transfer the asset to.
+    /// @param tokenId The ID of the asset to transfer.
+    /// @param amount The amount of the asset to transfer. Always
+    ///        1 for ERC721 assets.
+    function _transferNFTAssetFrom(
+        address token,
+        address from,
+        address to,
+        uint256 tokenId,
+        uint256 amount
+    )
+        internal
+        override
+    {
+        assert(amount == 1);
+        _transferERC721AssetFrom(IERC721Token(token), from, to, tokenId);
+    }
+
+    /// @dev Updates storage to indicate that the given order
+    ///      has been filled by the given amount.
+    /// @param order The order that has been filled.
+    /// @param fillAmount The amount (denominated in the NFT asset)
+    ///        that the order has been filled by.
+    function _updateOrderState(
+        LibNFTOrder.NFTOrder memory order,
+        bytes32 /* orderHash */,
+        uint128 fillAmount
+    )
+        internal
+        override
+    {
+        assert(fillAmount == 1);
+        _setOrderStatusBit(order.maker, order.nonce);
+    }
+
+    function _setOrderStatusBit(address maker, uint256 nonce)
+        private
+    {
+        // The bitvector is indexed by the lower 8 bits of the nonce.
+        uint256 flag = 1 << (nonce % 256);
+        // Update order status bit vector to indicate that the given order
+        // has been cancelled/filled by setting the designated bit to 1.
+        LibERC721OrdersStorage.getStorage().orderStatusByMaker
+            [maker][uint248(nonce >> 8)] |= flag;
+    }
+
+    /// @dev If the given order is buying an ERC721 asset, checks
+    ///      whether or not the given token ID satisfies the required
+    ///      properties specified in the order. If the order does not
+    ///      specify any properties, this function instead checks
+    ///      whether the given token ID matches the ID in the order.
+    ///      Reverts if any checks fail, or if the order is selling
+    ///      an ERC721 asset.
+    /// @param order The ERC721 order.
+    /// @param erc721TokenId The ID of the ERC721 asset.
+    function validateERC721OrderProperties(
+        LibNFTOrder.ERC721Order memory order,
+        uint256 erc721TokenId
+    )
+        public
+        override
+        view
+    {
+        _validateOrderProperties(
+            order.asNFTOrder(),
+            erc721TokenId
+        );
+    }
+
+    /// @dev Get the current status of an ERC721 order.
+    /// @param order The ERC721 order.
+    /// @return status The status of the order.
+    function getERC721OrderStatus(LibNFTOrder.ERC721Order memory order)
+        public
+        override
+        view
+        returns (LibNFTOrder.OrderStatus status)
+    {
+        // Only buy orders with `erc721TokenId` == 0 can be property
+        // orders.
+        if (order.erc721TokenProperties.length > 0 &&
+                (order.direction != LibNFTOrder.TradeDirection.BUY_NFT ||
+                 order.erc721TokenId != 0))
+        {
+            return LibNFTOrder.OrderStatus.INVALID;
+        }
+
+        // Buy orders cannot use ETH as the ERC20 token, since ETH cannot be
+        // transferred from the buyer by a contract.
+        if (order.direction == LibNFTOrder.TradeDirection.BUY_NFT &&
+            address(order.erc20Token) == NATIVE_TOKEN_ADDRESS)
+        {
+            return LibNFTOrder.OrderStatus.INVALID;
+        }
+
+        // Check for expiry.
+        if (order.expiry <= block.timestamp) {
+            return LibNFTOrder.OrderStatus.EXPIRED;
+        }
+
+        // Check `orderStatusByMaker` state variable to see if the order
+        // has been cancelled or previously filled.
+        LibERC721OrdersStorage.Storage storage stor =
+            LibERC721OrdersStorage.getStorage();
+        // `orderStatusByMaker` is indexed by maker and nonce.
+        uint256 orderStatusBitVector =
+            stor.orderStatusByMaker[order.maker][uint248(order.nonce >> 8)];
+        // The bitvector is indexed by the lower 8 bits of the nonce.
+        uint256 flag = 1 << (order.nonce % 256);
+        // If the designated bit is set, the order has been cancelled or
+        // previously filled, so it is now unfillable.
+        if (orderStatusBitVector & flag != 0) {
+            return LibNFTOrder.OrderStatus.UNFILLABLE;
+        }
+
+        // Otherwise, the order is fillable.
+        return LibNFTOrder.OrderStatus.FILLABLE;
+    }
+
+    /// @dev Get the order info for an NFT order.
+    /// @param order The NFT order.
+    /// @return orderInfo Info about the order.
+    function _getOrderInfo(LibNFTOrder.NFTOrder memory order)
+        internal
+        override
+        view
+        returns (LibNFTOrder.OrderInfo memory orderInfo)
+    {
+        LibNFTOrder.ERC721Order memory erc721Order = order.asERC721Order();
+        orderInfo.orderHash = getERC721OrderHash(erc721Order);
+        orderInfo.status = getERC721OrderStatus(erc721Order);
+        orderInfo.orderAmount = 1;
+        orderInfo.remainingAmount = orderInfo.status == LibNFTOrder.OrderStatus.FILLABLE ? 1 : 0;
+    }
+
+    /// @dev Get the canonical hash of an ERC721 order.
+    /// @param order The ERC721 order.
+    /// @return orderHash The order hash.
+    function getERC721OrderHash(LibNFTOrder.ERC721Order memory order)
+        public
+        override
+        view
+        returns (bytes32 orderHash)
+    {
+        return _getEIP712Hash(LibNFTOrder.getERC721OrderStructHash(order));
+    }
+
+    /// @dev Get the order status bit vector for the given
+    ///      maker address and nonce range.
+    /// @param maker The maker of the order.
+    /// @param nonceRange Order status bit vectors are indexed
+    ///        by maker address and the upper 248 bits of the
+    ///        order nonce. We define `nonceRange` to be these
+    ///        248 bits.
+    /// @return bitVector The order status bit vector for the
+    ///         given maker and nonce range.
+    function getERC721OrderStatusBitVector(address maker, uint248 nonceRange)
+        external
+        override
+        view
+        returns (uint256 bitVector)
+    {
+        LibERC721OrdersStorage.Storage storage stor =
+            LibERC721OrdersStorage.getStorage();
+        return stor.orderStatusByMaker[maker][nonceRange];
+    }
+}

contracts/zero-ex/contracts/src/features/nft_orders/NFTOrders.sol

@@ -0,0 +1,592 @@
+// SPDX-License-Identifier: Apache-2.0
+/*
+
+  Copyright 2021 ZeroEx Intl.
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+
+*/
+
+pragma solidity ^0.6.5;
+pragma experimental ABIEncoderV2;
+
+import "@0x/contracts-erc20/contracts/src/v06/IERC20TokenV06.sol";
+import "@0x/contracts-erc20/contracts/src/v06/IEtherTokenV06.sol";
+import "@0x/contracts-utils/contracts/src/v06/LibMathV06.sol";
+import "@0x/contracts-utils/contracts/src/v06/LibSafeMathV06.sol";
+import "../../errors/LibNFTOrdersRichErrors.sol";
+import "../../fixins/FixinCommon.sol";
+import "../../fixins/FixinEIP712.sol";
+import "../../fixins/FixinTokenSpender.sol";
+import "../../migrations/LibMigrate.sol";
+import "../../vendor/IFeeRecipient.sol";
+import "../../vendor/ITakerCallback.sol";
+import "../libs/LibSignature.sol";
+import "../libs/LibNFTOrder.sol";
+
+
+/// @dev Abstract base contract inherited by ERC721OrdersFeature and NFTOrders
+abstract contract NFTOrders is
+    FixinCommon,
+    FixinEIP712,
+    FixinTokenSpender
+{
+    using LibSafeMathV06 for uint256;
+
+    /// @dev Native token pseudo-address.
+    address constant internal NATIVE_TOKEN_ADDRESS = 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE;
+    /// @dev The WETH token contract.
+    IEtherTokenV06 internal immutable WETH;
+
+    /// @dev The magic return value indicating the success of a `receiveZeroExFeeCallback`.
+    bytes4 private constant FEE_CALLBACK_MAGIC_BYTES = IFeeRecipient.receiveZeroExFeeCallback.selector;
+    /// @dev The magic return value indicating the success of a `zeroExTakerCallback`.
+    bytes4 private constant TAKER_CALLBACK_MAGIC_BYTES = ITakerCallback.zeroExTakerCallback.selector;
+
+    constructor(address zeroExAddress, IEtherTokenV06 weth)
+        public
+        FixinEIP712(zeroExAddress)
+    {
+        WETH = weth;
+    }
+
+    struct SellParams {
+        uint128 sellAmount;
+        uint256 tokenId;
+        bool unwrapNativeToken;
+        address taker;
+        address currentNftOwner;
+        bytes takerCallbackData;
+    }
+
+    struct BuyParams {
+        uint128 buyAmount;
+        uint256 ethAvailable;
+        bytes takerCallbackData;
+    }
+
+    // Core settlement logic for selling an NFT asset.
+    function _sellNFT(
+        LibNFTOrder.NFTOrder memory buyOrder,
+        LibSignature.Signature memory signature,
+        SellParams memory params
+    )
+        internal
+        returns (uint256 erc20FillAmount)
+    {
+        LibNFTOrder.OrderInfo memory orderInfo = _getOrderInfo(buyOrder);
+        // Check that the order can be filled.
+        _validateBuyOrder(
+            buyOrder,
+            signature,
+            orderInfo,
+            params.taker,
+            params.tokenId
+        );
+
+        if (params.sellAmount > orderInfo.remainingAmount) {
+            LibNFTOrdersRichErrors.ExceedsRemainingOrderAmount(
+                orderInfo.remainingAmount,
+                params.sellAmount
+            ).rrevert();
+        }
+
+        _updateOrderState(buyOrder, orderInfo.orderHash, params.sellAmount);
+
+        if (params.sellAmount == orderInfo.orderAmount) {
+            erc20FillAmount = buyOrder.erc20TokenAmount;
+        } else {
+            // Rounding favors the order maker.
+            erc20FillAmount = LibMathV06.getPartialAmountFloor(
+                params.sellAmount,
+                orderInfo.orderAmount,
+                buyOrder.erc20TokenAmount
+            );
+        }
+
+        if (params.unwrapNativeToken) {
+            // The ERC20 token must be WETH for it to be unwrapped.
+            if (buyOrder.erc20Token != WETH) {
+                LibNFTOrdersRichErrors.ERC20TokenMismatchError(
+                    address(buyOrder.erc20Token),
+                    address(WETH)
+                ).rrevert();
+            }
+            // Transfer the WETH from the maker to the Exchange Proxy
+            // so we can unwrap it before sending it to the seller.
+            // TODO: Probably safe to just use WETH.transferFrom for some
+            //       small gas savings
+            _transferERC20TokensFrom(
+                WETH,
+                buyOrder.maker,
+                address(this),
+                erc20FillAmount
+            );
+            // Unwrap WETH into ETH.
+            WETH.withdraw(erc20FillAmount);
+            // Send ETH to the seller.
+            _transferEth(payable(params.taker), erc20FillAmount);
+        } else {
+            // Transfer the ERC20 token from the buyer to the seller.
+            _transferERC20TokensFrom(
+                buyOrder.erc20Token,
+                buyOrder.maker,
+                params.taker,
+                erc20FillAmount
+            );
+        }
+
+        if (params.takerCallbackData.length > 0) {
+            require(
+                params.taker != address(this),
+                "NFTOrders::_sellNFT/CANNOT_CALLBACK_SELF"
+            );
+            // Invoke the callback
+            bytes4 callbackResult = ITakerCallback(params.taker)
+                .zeroExTakerCallback(orderInfo.orderHash, params.takerCallbackData);
+            // Check for the magic success bytes
+            require(
+                callbackResult == TAKER_CALLBACK_MAGIC_BYTES,
+                "NFTOrders::_sellNFT/CALLBACK_FAILED"
+            );
+        }
+
+        // Transfer the NFT asset to the buyer.
+        // If this function is called from the
+        // `onNFTReceived` callback the Exchange Proxy
+        // holds the asset. Otherwise, transfer it from
+        // the seller.
+        _transferNFTAssetFrom(
+            buyOrder.nft,
+            params.currentNftOwner,
+            buyOrder.maker,
+            params.tokenId,
+            params.sellAmount
+        );
+
+        // The buyer pays the order fees.
+        _payFees(
+            buyOrder,
+            buyOrder.maker,
+            params.sellAmount,
+            orderInfo.orderAmount,
+            false
+        );
+    }
+
+    // Core settlement logic for buying an NFT asset.
+    function _buyNFT(
+        LibNFTOrder.NFTOrder memory sellOrder,
+        LibSignature.Signature memory signature,
+        BuyParams memory params
+    )
+        internal
+        returns (uint256 erc20FillAmount, uint256 ethSpent)
+    {
+        LibNFTOrder.OrderInfo memory orderInfo = _getOrderInfo(sellOrder);
+        // Check that the order can be filled.
+        _validateSellOrder(
+            sellOrder,
+            signature,
+            orderInfo,
+            msg.sender
+        );
+
+        if (params.buyAmount > orderInfo.remainingAmount) {
+            LibNFTOrdersRichErrors.ExceedsRemainingOrderAmount(
+                orderInfo.remainingAmount,
+                params.buyAmount
+            ).rrevert();
+        }
+
+        _updateOrderState(sellOrder, orderInfo.orderHash, params.buyAmount);
+
+        if (params.buyAmount == orderInfo.orderAmount) {
+            erc20FillAmount = sellOrder.erc20TokenAmount;
+        } else {
+            // Rounding favors the order maker.
+            erc20FillAmount = LibMathV06.getPartialAmountCeil(
+                params.buyAmount,
+                orderInfo.orderAmount,
+                sellOrder.erc20TokenAmount
+            );
+        }
+
+        // Transfer the NFT asset to the buyer (`msg.sender`).
+        _transferNFTAssetFrom(
+            sellOrder.nft,
+            sellOrder.maker,
+            msg.sender,
+            sellOrder.nftId,
+            params.buyAmount
+        );
+
+        if (params.takerCallbackData.length > 0) {
+            require(
+                msg.sender != address(this),
+                "NFTOrders::_buyNFT/CANNOT_CALLBACK_SELF"
+            );
+            uint256 ethBalanceBeforeCallback = address(this).balance;
+            // Invoke the callback
+            bytes4 callbackResult = ITakerCallback(msg.sender)
+                .zeroExTakerCallback(orderInfo.orderHash, params.takerCallbackData);
+            params.ethAvailable = params.ethAvailable.safeAdd(
+                address(this).balance.safeSub(ethBalanceBeforeCallback)
+            );
+            // Check for the magic success bytes
+            require(
+                callbackResult == TAKER_CALLBACK_MAGIC_BYTES,
+                "NFTOrders::_buyNFT/CALLBACK_FAILED"
+            );
+        }
+
+        if (address(sellOrder.erc20Token) == NATIVE_TOKEN_ADDRESS) {
+            // Check that we have enough ETH.
+            if (params.ethAvailable < erc20FillAmount) {
+                LibNFTOrdersRichErrors.InsufficientEthError(
+                    params.ethAvailable,
+                    erc20FillAmount
+                ).rrevert();
+            }
+            // Transfer ETH to the seller.
+            _transferEth(payable(sellOrder.maker), erc20FillAmount);
+            // Fees are paid from the EP's current balance of ETH.
+            uint256 ethFees = _payFees(
+                sellOrder,
+                address(this),
+                params.buyAmount,
+                orderInfo.orderAmount,
+                true
+            );
+            // Sum the amount of ETH spent.
+            ethSpent = erc20FillAmount.safeAdd(ethFees);
+        } else if (sellOrder.erc20Token == WETH) {
+            // If there is enough ETH available, fill the WETH order
+            // (including fees) using that ETH.
+            // Otherwise, transfer WETH from the taker.
+            if (params.ethAvailable >= erc20FillAmount) {
+                // Wrap ETH.
+                WETH.deposit{value: erc20FillAmount}();
+                // TODO: Probably safe to just use WETH.transfer for some
+                //       small gas savings
+                // Transfer WETH to the seller.
+                _transferERC20Tokens(
+                    WETH,
+                    sellOrder.maker,
+                    erc20FillAmount
+                );
+                // Pay fees using ETH.
+                uint256 ethFees = _payFees(
+                    sellOrder,
+                    address(this),
+                    params.buyAmount,
+                    orderInfo.orderAmount,
+                    true
+                );
+                // Sum the amount of ETH spent.
+                ethSpent = erc20FillAmount.safeAdd(ethFees);
+            } else {
+                // Transfer WETH from the buyer to the seller.
+                _transferERC20TokensFrom(
+                    sellOrder.erc20Token,
+                    msg.sender,
+                    sellOrder.maker,
+                    erc20FillAmount
+                );
+                // The buyer pays fees using WETH.
+                _payFees(
+                    sellOrder,
+                    msg.sender,
+                    params.buyAmount,
+                    orderInfo.orderAmount,
+                    false
+                );
+            }
+        } else {
+            // Transfer ERC20 token from the buyer to the seller.
+            _transferERC20TokensFrom(
+                sellOrder.erc20Token,
+                msg.sender,
+                sellOrder.maker,
+                erc20FillAmount
+            );
+            // The buyer pays fees.
+            _payFees(
+                sellOrder,
+                msg.sender,
+                params.buyAmount,
+                orderInfo.orderAmount,
+                false
+            );
+        }
+    }
+
+    function _validateSellOrder(
+        LibNFTOrder.NFTOrder memory sellOrder,
+        LibSignature.Signature memory signature,
+        LibNFTOrder.OrderInfo memory orderInfo,
+        address taker
+    )
+        internal
+        view
+    {
+        // Order must be selling the NFT asset.
+        require(
+            sellOrder.direction == LibNFTOrder.TradeDirection.SELL_NFT,
+            "NFTOrders::_validateSellOrder/WRONG_TRADE_DIRECTION"
+        );
+        // Taker must match the order taker, if one is specified.
+        if (sellOrder.taker != address(0) && sellOrder.taker != taker) {
+            LibNFTOrdersRichErrors.OnlyTakerError(taker, sellOrder.taker).rrevert();
+        }
+        // Check that the order is valid and has not expired, been cancelled,
+        // or been filled.
+        if (orderInfo.status != LibNFTOrder.OrderStatus.FILLABLE) {
+            LibNFTOrdersRichErrors.OrderNotFillableError(
+                sellOrder.maker,
+                sellOrder.nonce,
+                uint8(orderInfo.status)
+            ).rrevert();
+        }
+
+        // Check the signature.
+        _validateOrderSignature(orderInfo.orderHash, signature, sellOrder.maker);
+    }
+
+    function _validateBuyOrder(
+        LibNFTOrder.NFTOrder memory buyOrder,
+        LibSignature.Signature memory signature,
+        LibNFTOrder.OrderInfo memory orderInfo,
+        address taker,
+        uint256 tokenId
+    )
+        internal
+        view
+    {
+        // Order must be buying the NFT asset.
+        require(
+            buyOrder.direction == LibNFTOrder.TradeDirection.BUY_NFT,
+            "NFTOrders::_validateBuyOrder/WRONG_TRADE_DIRECTION"
+        );
+        // The ERC20 token cannot be ETH.
+        require(
+            address(buyOrder.erc20Token) != NATIVE_TOKEN_ADDRESS,
+            "NFTOrders::_validateBuyOrder/NATIVE_TOKEN_NOT_ALLOWED"
+        );
+        // Taker must match the order taker, if one is specified.
+        if (buyOrder.taker != address(0) && buyOrder.taker != taker) {
+            LibNFTOrdersRichErrors.OnlyTakerError(taker, buyOrder.taker).rrevert();
+        }
+        // Check that the order is valid and has not expired, been cancelled,
+        // or been filled.
+        if (orderInfo.status != LibNFTOrder.OrderStatus.FILLABLE) {
+            LibNFTOrdersRichErrors.OrderNotFillableError(
+                buyOrder.maker,
+                buyOrder.nonce,
+                uint8(orderInfo.status)
+            ).rrevert();
+        }
+        // Check that the asset with the given token ID satisfies the properties
+        // specified by the order.
+        _validateOrderProperties(buyOrder, tokenId);
+        // Check the signature.
+        _validateOrderSignature(orderInfo.orderHash, signature, buyOrder.maker);
+    }
+
+    function _payFees(
+        LibNFTOrder.NFTOrder memory order,
+        address payer,
+        uint128 fillAmount,
+        uint128 orderAmount,
+        bool useNativeToken
+    )
+        internal
+        returns (uint256 totalFeesPaid)
+    {
+        for (uint256 i = 0; i < order.fees.length; i++) {
+            LibNFTOrder.Fee memory fee = order.fees[i];
+
+            require(
+                fee.recipient != address(this),
+                "NFTOrders::_payFees/RECIPIENT_CANNOT_BE_EXCHANGE_PROXY"
+            );
+
+            uint256 feeFillAmount;
+            if (fillAmount == orderAmount) {
+                feeFillAmount = fee.amount;
+            } else {
+                // Round in favor of the taker or maker
+                feeFillAmount = LibMathV06.getPartialAmountFloor(
+                    fillAmount,
+                    orderAmount,
+                    fee.amount
+                );
+            }
+            if (feeFillAmount == 0) {
+                continue;
+            }
+
+            if (useNativeToken) {
+                assert(payer == address(this));
+                assert(
+                    order.erc20Token == WETH ||
+                    address(order.erc20Token) == NATIVE_TOKEN_ADDRESS
+                );
+                // Transfer ETH to the fee recipient.
+                _transferEth(payable(fee.recipient), feeFillAmount);
+            } else {
+                // Transfer ERC20 token from payer to recipient.
+                _transferERC20TokensFrom(
+                    order.erc20Token,
+                    payer,
+                    fee.recipient,
+                    feeFillAmount
+                );
+            }
+            // Note that the fee callback is _not_ called if zero
+            // `feeData` is provided. If `feeData` is provided, we assume
+            // the fee recipient is a contract that implements the
+            // `IFeeRecipient` interface.
+            if (fee.feeData.length > 0) {
+                // Invoke the callback
+                bytes4 callbackResult = IFeeRecipient(fee.recipient).receiveZeroExFeeCallback(
+                    useNativeToken ? NATIVE_TOKEN_ADDRESS : address(order.erc20Token),
+                    feeFillAmount,
+                    fee.feeData
+                );
+                // Check for the magic success bytes
+                require(
+                    callbackResult == FEE_CALLBACK_MAGIC_BYTES,
+                    "NFTOrders::_payFees/CALLBACK_FAILED"
+                );
+            }
+            // Sum the fees paid
+            totalFeesPaid = totalFeesPaid.safeAdd(feeFillAmount);
+        }
+    }
+
+    /// @dev If the given order is buying an NFT asset, checks
+    ///      whether or not the given token ID satisfies the required
+    ///      properties specified in the order. If the order does not
+    ///      specify any properties, this function instead checks
+    ///      whether the given token ID matches the ID in the order.
+    ///      Reverts if any checks fail, or if the order is selling
+    ///      an NFT asset.
+    /// @param order The NFT order.
+    /// @param tokenId The ID of the NFT asset.
+    function _validateOrderProperties(
+        LibNFTOrder.NFTOrder memory order,
+        uint256 tokenId
+    )
+        internal
+        view
+    {
+        // Order must be buying an NFT asset to have properties.
+        require(
+            order.direction == LibNFTOrder.TradeDirection.BUY_NFT,
+            "NFTOrders::_validateOrderProperties/WRONG_TRADE_DIRECTION"
+        );
+
+        // If no properties are specified, check that the given
+        // `tokenId` matches the one specified in the order.
+        if (order.nftProperties.length == 0) {
+            if (tokenId != order.nftId) {
+                LibNFTOrdersRichErrors.TokenIdMismatchError(
+                    tokenId,
+                    order.nftId
+                ).rrevert();
+            }
+        }
+
+        // Validate each property
+        for (uint256 i = 0; i < order.nftProperties.length; i++) {
+            LibNFTOrder.Property memory property = order.nftProperties[i];
+            // `address(0)` is interpreted as a no-op. Any token ID
+            // will satisfy a property with `propertyValidator == address(0)`.
+            if (address(property.propertyValidator) == address(0)) {
+                continue;
+            }
+
+            // Call the property validator and throw a descriptive error
+            // if the call reverts.
+            try property.propertyValidator.validateProperty(
+                order.nft,
+                tokenId,
+                property.propertyData
+            ) {} catch (bytes memory errorData) {
+                LibNFTOrdersRichErrors.PropertyValidationFailedError(
+                    address(property.propertyValidator),
+                    order.nft,
+                    tokenId,
+                    property.propertyData,
+                    errorData
+                ).rrevert();
+            }
+        }
+    }
+
+    /// @dev Validates that the given signature is valid for the
+    ///      given maker and order hash. Reverts if the signature
+    ///      is not valid.
+    /// @param orderHash The hash of the order that was signed.
+    /// @param signature The signature to check.
+    /// @param maker The maker of the order.
+    function _validateOrderSignature(
+        bytes32 orderHash,
+        LibSignature.Signature memory signature,
+        address maker
+    )
+        internal
+        virtual
+        view;
+
+    /// @dev Transfers an NFT asset.
+    /// @param token The address of the NFT contract.
+    /// @param from The address currently holding the asset.
+    /// @param to The address to transfer the asset to.
+    /// @param tokenId The ID of the asset to transfer.
+    /// @param amount The amount of the asset to transfer. Always
+    ///        1 for ERC721 assets.
+    function _transferNFTAssetFrom(
+        address token,
+        address from,
+        address to,
+        uint256 tokenId,
+        uint256 amount
+    )
+        internal
+        virtual;
+
+    /// @dev Updates storage to indicate that the given order
+    ///      has been filled by the given amount.
+    /// @param order The order that has been filled.
+    /// @param orderHash The hash of `order`.
+    /// @param fillAmount The amount (denominated in the NFT asset)
+    ///        that the order has been filled by.
+    function _updateOrderState(
+        LibNFTOrder.NFTOrder memory order,
+        bytes32 orderHash,
+        uint128 fillAmount
+    )
+        internal
+        virtual;
+
+    /// @dev Get the order info for an NFT order.
+    /// @param order The NFT order.
+    /// @return orderInfo Info about the order.
+    function _getOrderInfo(LibNFTOrder.NFTOrder memory order)
+        internal
+        virtual
+        view
+        returns (LibNFTOrder.OrderInfo memory orderInfo);
+}

contracts/zero-ex/contracts/src/fixins/FixinERC1155Spender.sol

@@ -0,0 +1,79 @@
+// SPDX-License-Identifier: Apache-2.0
+/*
+
+  Copyright 2020 ZeroEx Intl.
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+
+*/
+
+pragma solidity ^0.6.5;
+pragma experimental ABIEncoderV2;
+
+import "@0x/contracts-utils/contracts/src/v06/LibSafeMathV06.sol";
+import "../vendor/IERC1155Token.sol";
+
+
+/// @dev Helpers for moving ERC1155 assets around.
+abstract contract FixinERC1155Spender {
+
+    // Mask of the lower 20 bytes of a bytes32.
+    uint256 constant private ADDRESS_MASK = 0x000000000000000000000000ffffffffffffffffffffffffffffffffffffffff;
+
+    /// @dev Transfers an ERC1155 asset from `owner` to `to`.
+    /// @param token The address of the ERC1155 token contract.
+    /// @param owner The owner of the asset.
+    /// @param to The recipient of the asset.
+    /// @param tokenId The token ID of the asset to transfer.
+    /// @param amount The amount of the asset to transfer.
+    function _transferERC1155AssetFrom(
+        IERC1155Token token,
+        address owner,
+        address to,
+        uint256 tokenId,
+        uint256 amount
+    )
+        internal
+    {
+        require(address(token) != address(this), "FixinERC1155Spender/CANNOT_INVOKE_SELF");
+
+        assembly {
+            let ptr := mload(0x40) // free memory pointer
+
+            // selector for safeTransferFrom(address,address,uint256,uint256,bytes)
+            mstore(ptr, 0xf242432a00000000000000000000000000000000000000000000000000000000)
+            mstore(add(ptr, 0x04), and(owner, ADDRESS_MASK))
+            mstore(add(ptr, 0x24), and(to, ADDRESS_MASK))
+            mstore(add(ptr, 0x44), tokenId)
+            mstore(add(ptr, 0x64), amount)
+            mstore(add(ptr, 0x84), 0xa0)
+            mstore(add(ptr, 0xa4), 0)
+
+            let success := call(
+                gas(),
+                and(token, ADDRESS_MASK),
+                0,
+                ptr,
+                0xc4,
+                0,
+                0
+            )
+
+            if iszero(success) {
+                let rdsize := returndatasize()
+                returndatacopy(ptr, 0, rdsize)
+                revert(ptr, rdsize)
+            }
+        }
+    }
+}

contracts/zero-ex/contracts/src/fixins/FixinERC721Spender.sol

@@ -0,0 +1,74 @@
+// SPDX-License-Identifier: Apache-2.0
+/*
+
+  Copyright 2020 ZeroEx Intl.
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+
+*/
+
+pragma solidity ^0.6.5;
+pragma experimental ABIEncoderV2;
+
+import "@0x/contracts-utils/contracts/src/v06/LibSafeMathV06.sol";
+import "../vendor/IERC721Token.sol";
+
+
+/// @dev Helpers for moving ERC721 assets around.
+abstract contract FixinERC721Spender {
+
+    // Mask of the lower 20 bytes of a bytes32.
+    uint256 constant private ADDRESS_MASK = 0x000000000000000000000000ffffffffffffffffffffffffffffffffffffffff;
+
+    /// @dev Transfers an ERC721 asset from `owner` to `to`.
+    /// @param token The address of the ERC721 token contract.
+    /// @param owner The owner of the asset.
+    /// @param to The recipient of the asset.
+    /// @param tokenId The token ID of the asset to transfer.
+    function _transferERC721AssetFrom(
+        IERC721Token token,
+        address owner,
+        address to,
+        uint256 tokenId
+    )
+        internal
+    {
+        require(address(token) != address(this), "FixinERC721Spender/CANNOT_INVOKE_SELF");
+
+        assembly {
+            let ptr := mload(0x40) // free memory pointer
+
+            // selector for transferFrom(address,address,uint256)
+            mstore(ptr, 0x23b872dd00000000000000000000000000000000000000000000000000000000)
+            mstore(add(ptr, 0x04), and(owner, ADDRESS_MASK))
+            mstore(add(ptr, 0x24), and(to, ADDRESS_MASK))
+            mstore(add(ptr, 0x44), tokenId)
+
+            let success := call(
+                gas(),
+                and(token, ADDRESS_MASK),
+                0,
+                ptr,
+                0x64,
+                0,
+                0
+            )
+
+            if iszero(success) {
+                let rdsize := returndatasize()
+                returndatacopy(ptr, 0, rdsize)
+                revert(ptr, rdsize)
+            }
+        }
+    }
+}

contracts/zero-ex/contracts/src/fixins/FixinTokenSpender.sol

@@ -20,7 +20,7 @@
 pragma solidity ^0.6.5;
 pragma experimental ABIEncoderV2;
 
-import "@0x/contracts-erc20/contracts/src/v06/IEtherTokenV06.sol";
+import "@0x/contracts-erc20/contracts/src/v06/IERC20TokenV06.sol";
 import "@0x/contracts-utils/contracts/src/v06/LibSafeMathV06.sol";
 
 
@@ -141,6 +141,20 @@ abstract contract FixinTokenSpender {
         }
     }
 
+
+    /// @dev Transfers some amount of ETH to the given recipient and
+    ///      reverts if the transfer fails.
+    /// @param recipient The recipient of the ETH.
+    /// @param amount The amount of ETH to transfer.
+    function _transferEth(address payable recipient, uint256 amount)
+        internal
+    {
+        if (amount > 0) {
+            (bool success,) = recipient.call{value: amount}("");
+            require(success, "FixinTokenSpender::_transferEth/TRANSFER_FAILED");
+        }
+    }
+
     /// @dev Gets the maximum amount of an ERC20 token `token` that can be
     ///      pulled from `owner` by this address.
     /// @param token The token to spend.

contracts/zero-ex/contracts/src/storage/LibERC1155OrdersStorage.sol

@@ -0,0 +1,47 @@
+// SPDX-License-Identifier: Apache-2.0
+/*
+
+  Copyright 2020 ZeroEx Intl.
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+
+*/
+
+pragma solidity ^0.6.5;
+pragma experimental ABIEncoderV2;
+
+import "./LibStorage.sol";
+
+
+/// @dev Storage helpers for `ERC1155OrdersFeature`.
+library LibERC1155OrdersStorage {
+
+    /// @dev Storage bucket for this feature.
+    struct Storage {
+        // The lower `uint128` is the taker token fill amount.
+        // The highest bit will be `1` if the order was cancelled.
+        // The second-highest bit will be `1` if the order was pre-signed.
+        mapping(bytes32 => uint256) orderState;
+    }
+
+    /// @dev Get the storage bucket for this contract.
+    function getStorage() internal pure returns (Storage storage stor) {
+        uint256 storageSlot = LibStorage.getStorageSlot(
+            LibStorage.StorageId.ERC1155Orders
+        );
+        // Dip into assembly to change the slot pointed to by the local
+        // variable `stor`.
+        // See https://solidity.readthedocs.io/en/v0.6.8/assembly.html?highlight=slot#access-to-external-variables-functions-and-libraries
+        assembly { stor_slot := storageSlot }
+    }
+}

contracts/zero-ex/contracts/src/storage/LibERC721OrdersStorage.sol

@@ -0,0 +1,47 @@
+// SPDX-License-Identifier: Apache-2.0
+/*
+
+  Copyright 2020 ZeroEx Intl.
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+
+*/
+
+pragma solidity ^0.6.5;
+pragma experimental ABIEncoderV2;
+
+import "./LibStorage.sol";
+
+
+/// @dev Storage helpers for `ERC721OrdersFeature`.
+library LibERC721OrdersStorage {
+
+    /// @dev Storage bucket for this feature.
+    struct Storage {
+        // maker => nonce range => order status bit vector
+        mapping(address => mapping(uint248 => uint256)) orderStatusByMaker;
+        // order hash => isSigned
+        mapping(bytes32 => bool) preSigned;
+    }
+
+    /// @dev Get the storage bucket for this contract.
+    function getStorage() internal pure returns (Storage storage stor) {
+        uint256 storageSlot = LibStorage.getStorageSlot(
+            LibStorage.StorageId.ERC721Orders
+        );
+        // Dip into assembly to change the slot pointed to by the local
+        // variable `stor`.
+        // See https://solidity.readthedocs.io/en/v0.6.8/assembly.html?highlight=slot#access-to-external-variables-functions-and-libraries
+        assembly { stor_slot := storageSlot }
+    }
+}

contracts/zero-ex/contracts/src/storage/LibStorage.sol

@@ -39,7 +39,9 @@ library LibStorage {
         MetaTransactions,
         ReentrancyGuard,
         NativeOrders,
-        OtcOrders
+        OtcOrders,
+        ERC721Orders,
+        ERC1155Orders
     }
 
     /// @dev Get the storage slot given a storage ID. We assign unique, well-spaced

contracts/zero-ex/contracts/src/vendor/IERC1155Token.sol

@@ -0,0 +1,151 @@
+// SPDX-License-Identifier: Apache-2.0
+/*
+
+  Copyright 2022 ZeroEx Intl.
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+
+*/
+
+pragma solidity ^0.6.5;
+pragma experimental ABIEncoderV2;
+
+
+interface IERC1155Token {
+
+    /// @dev Either TransferSingle or TransferBatch MUST emit when tokens are transferred,
+    ///      including zero value transfers as well as minting or burning.
+    /// Operator will always be msg.sender.
+    /// Either event from address `0x0` signifies a minting operation.
+    /// An event to address `0x0` signifies a burning or melting operation.
+    /// The total value transferred from address 0x0 minus the total value transferred to 0x0 may
+    /// be used by clients and exchanges to be added to the "circulating supply" for a given token ID.
+    /// To define a token ID with no initial balance, the contract SHOULD emit the TransferSingle event
+    /// from `0x0` to `0x0`, with the token creator as `_operator`.
+    event TransferSingle(
+        address indexed operator,
+        address indexed from,
+        address indexed to,
+        uint256 id,
+        uint256 value
+    );
+
+    /// @dev Either TransferSingle or TransferBatch MUST emit when tokens are transferred,
+    ///      including zero value transfers as well as minting or burning.
+    ///Operator will always be msg.sender.
+    /// Either event from address `0x0` signifies a minting operation.
+    /// An event to address `0x0` signifies a burning or melting operation.
+    /// The total value transferred from address 0x0 minus the total value transferred to 0x0 may
+    /// be used by clients and exchanges to be added to the "circulating supply" for a given token ID.
+    /// To define multiple token IDs with no initial balance, this SHOULD emit the TransferBatch event
+    /// from `0x0` to `0x0`, with the token creator as `_operator`.
+    event TransferBatch(
+        address indexed operator,
+        address indexed from,
+        address indexed to,
+        uint256[] ids,
+        uint256[] values
+    );
+
+    /// @dev MUST emit when an approval is updated.
+    event ApprovalForAll(
+        address indexed owner,
+        address indexed operator,
+        bool approved
+    );
+
+    /// @dev MUST emit when the URI is updated for a token ID.
+    /// URIs are defined in RFC 3986.
+    /// The URI MUST point a JSON file that conforms to the "ERC-1155 Metadata JSON Schema".
+    event URI(
+        string value,
+        uint256 indexed id
+    );
+
+    /// @notice Transfers value amount of an _id from the _from address to the _to address specified.
+    /// @dev MUST emit TransferSingle event on success.
+    /// Caller must be approved to manage the _from account's tokens (see isApprovedForAll).
+    /// MUST throw if `_to` is the zero address.
+    /// MUST throw if balance of sender for token `_id` is lower than the `_value` sent.
+    /// MUST throw on any other error.
+    /// When transfer is complete, this function MUST check if `_to` is a smart contract (code size > 0).
+    /// If so, it MUST call `onERC1155Received` on `_to` and revert if the return value
+    /// is not `bytes4(keccak256("onERC1155Received(address,address,uint256,uint256,bytes)"))`.
+    /// @param from    Source address
+    /// @param to      Target address
+    /// @param id      ID of the token type
+    /// @param value   Transfer amount
+    /// @param data    Additional data with no specified format, sent in call to `_to`
+    function safeTransferFrom(
+        address from,
+        address to,
+        uint256 id,
+        uint256 value,
+        bytes calldata data
+    )
+        external;
+
+    /// @notice Send multiple types of Tokens from a 3rd party in one transfer (with safety call).
+    /// @dev MUST emit TransferBatch event on success.
+    /// Caller must be approved to manage the _from account's tokens (see isApprovedForAll).
+    /// MUST throw if `_to` is the zero address.
+    /// MUST throw if length of `_ids` is not the same as length of `_values`.
+    ///  MUST throw if any of the balance of sender for token `_ids` is lower than the respective `_values` sent.
+    /// MUST throw on any other error.
+    /// When transfer is complete, this function MUST check if `_to` is a smart contract (code size > 0).
+    /// If so, it MUST call `onERC1155BatchReceived` on `_to` and revert if the return value
+    /// is not `bytes4(keccak256("onERC1155BatchReceived(address,address,uint256[],uint256[],bytes)"))`.
+    /// @param from    Source addresses
+    /// @param to      Target addresses
+    /// @param ids     IDs of each token type
+    /// @param values  Transfer amounts per token type
+    /// @param data    Additional data with no specified format, sent in call to `_to`
+    function safeBatchTransferFrom(
+        address from,
+        address to,
+        uint256[] calldata ids,
+        uint256[] calldata values,
+        bytes calldata data
+    )
+        external;
+
+    /// @notice Enable or disable approval for a third party ("operator") to manage all of the caller's tokens.
+    /// @dev MUST emit the ApprovalForAll event on success.
+    /// @param operator  Address to add to the set of authorized operators
+    /// @param approved  True if the operator is approved, false to revoke approval
+    function setApprovalForAll(address operator, bool approved) external;
+
+    /// @notice Queries the approval status of an operator for a given owner.
+    /// @param owner        The owner of the Tokens
+    /// @param operator     Address of authorized operator
+    /// @return isApproved  True if the operator is approved, false if not
+    function isApprovedForAll(address owner, address operator) external view returns (bool isApproved);
+
+    /// @notice Get the balance of an account's Tokens.
+    /// @param owner     The address of the token holder
+    /// @param id        ID of the Token
+    /// @return balance  The _owner's balance of the Token type requested
+    function balanceOf(address owner, uint256 id) external view returns (uint256 balance);
+
+    /// @notice Get the balance of multiple account/token pairs
+    /// @param owners      The addresses of the token holders
+    /// @param ids         ID of the Tokens
+    /// @return balances_  The _owner's balance of the Token types requested
+    function balanceOfBatch(
+        address[] calldata owners,
+        uint256[] calldata ids
+    )
+        external
+        view
+        returns (uint256[] memory balances_);
+}

contracts/zero-ex/contracts/src/vendor/IERC721Token.sol

@@ -0,0 +1,159 @@
+// SPDX-License-Identifier: Apache-2.0
+/*
+
+  Copyright 2021 ZeroEx Intl.
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+
+*/
+
+pragma solidity ^0.6.5;
+
+
+interface IERC721Token {
+
+    /// @dev This emits when ownership of any NFT changes by any mechanism.
+    ///      This event emits when NFTs are created (`from` == 0) and destroyed
+    ///      (`to` == 0). Exception: during contract creation, any number of NFTs
+    ///      may be created and assigned without emitting Transfer. At the time of
+    ///      any transfer, the approved address for that NFT (if any) is reset to none.
+    event Transfer(
+        address indexed _from,
+        address indexed _to,
+        uint256 indexed _tokenId
+    );
+
+    /// @dev This emits when the approved address for an NFT is changed or
+    ///      reaffirmed. The zero address indicates there is no approved address.
+    ///      When a Transfer event emits, this also indicates that the approved
+    ///      address for that NFT (if any) is reset to none.
+    event Approval(
+        address indexed _owner,
+        address indexed _approved,
+        uint256 indexed _tokenId
+    );
+
+    /// @dev This emits when an operator is enabled or disabled for an owner.
+    ///      The operator can manage all NFTs of the owner.
+    event ApprovalForAll(
+        address indexed _owner,
+        address indexed _operator,
+        bool _approved
+    );
+
+    /// @notice Transfers the ownership of an NFT from one address to another address
+    /// @dev Throws unless `msg.sender` is the current owner, an authorized
+    ///      perator, or the approved address for this NFT. Throws if `_from` is
+    ///      not the current owner. Throws if `_to` is the zero address. Throws if
+    ///      `_tokenId` is not a valid NFT. When transfer is complete, this function
+    ///      checks if `_to` is a smart contract (code size > 0). If so, it calls
+    ///      `onERC721Received` on `_to` and throws if the return value is not
+    ///      `bytes4(keccak256("onERC721Received(address,address,uint256,bytes)"))`.
+    /// @param _from The current owner of the NFT
+    /// @param _to The new owner
+    /// @param _tokenId The NFT to transfer
+    /// @param _data Additional data with no specified format, sent in call to `_to`
+    function safeTransferFrom(
+        address _from,
+        address _to,
+        uint256 _tokenId,
+        bytes calldata _data
+    )
+        external;
+
+    /// @notice Transfers the ownership of an NFT from one address to another address
+    /// @dev This works identically to the other function with an extra data parameter,
+    ///      except this function just sets data to "".
+    /// @param _from The current owner of the NFT
+    /// @param _to The new owner
+    /// @param _tokenId The NFT to transfer
+    function safeTransferFrom(
+        address _from,
+        address _to,
+        uint256 _tokenId
+    )
+        external;
+
+    /// @notice Change or reaffirm the approved address for an NFT
+    /// @dev The zero address indicates there is no approved address.
+    ///      Throws unless `msg.sender` is the current NFT owner, or an authorized
+    ///      operator of the current owner.
+    /// @param _approved The new approved NFT controller
+    /// @param _tokenId The NFT to approve
+    function approve(address _approved, uint256 _tokenId)
+        external;
+
+    /// @notice Enable or disable approval for a third party ("operator") to manage
+    ///         all of `msg.sender`'s assets
+    /// @dev Emits the ApprovalForAll event. The contract MUST allow
+    ///      multiple operators per owner.
+    /// @param _operator Address to add to the set of authorized operators
+    /// @param _approved True if the operator is approved, false to revoke approval
+    function setApprovalForAll(address _operator, bool _approved)
+        external;
+
+    /// @notice Count all NFTs assigned to an owner
+    /// @dev NFTs assigned to the zero address are considered invalid, and this
+    ///      function throws for queries about the zero address.
+    /// @param _owner An address for whom to query the balance
+    /// @return The number of NFTs owned by `_owner`, possibly zero
+    function balanceOf(address _owner)
+        external
+        view
+        returns (uint256);
+
+    /// @notice Transfer ownership of an NFT -- THE CALLER IS RESPONSIBLE
+    ///         TO CONFIRM THAT `_to` IS CAPABLE OF RECEIVING NFTS OR ELSE
+    ///         THEY MAY BE PERMANENTLY LOST
+    /// @dev Throws unless `msg.sender` is the current owner, an authorized
+    ///      operator, or the approved address for this NFT. Throws if `_from` is
+    ///      not the current owner. Throws if `_to` is the zero address. Throws if
+    ///      `_tokenId` is not a valid NFT.
+    /// @param _from The current owner of the NFT
+    /// @param _to The new owner
+    /// @param _tokenId The NFT to transfer
+    function transferFrom(
+        address _from,
+        address _to,
+        uint256 _tokenId
+    )
+        external;
+
+    /// @notice Find the owner of an NFT
+    /// @dev NFTs assigned to zero address are considered invalid, and queries
+    ///      about them do throw.
+    /// @param _tokenId The identifier for an NFT
+    /// @return The address of the owner of the NFT
+    function ownerOf(uint256 _tokenId)
+        external
+        view
+        returns (address);
+
+    /// @notice Get the approved address for a single NFT
+    /// @dev Throws if `_tokenId` is not a valid NFT.
+    /// @param _tokenId The NFT to find the approved address for
+    /// @return The approved address for this NFT, or the zero address if there is none
+    function getApproved(uint256 _tokenId) 
+        external
+        view
+        returns (address);
+    
+    /// @notice Query if an address is an authorized operator for another address
+    /// @param _owner The address that owns the NFTs
+    /// @param _operator The address that acts on behalf of the owner
+    /// @return True if `_operator` is an approved operator for `_owner`, false otherwise
+    function isApprovedForAll(address _owner, address _operator)
+        external
+        view
+        returns (bool);
+}

contracts/zero-ex/contracts/src/vendor/IFeeRecipient.sol

@@ -0,0 +1,44 @@
+// SPDX-License-Identifier: Apache-2.0
+/*
+
+  Copyright 2021 ZeroEx Intl.
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+
+*/
+
+pragma solidity ^0.6.5;
+pragma experimental ABIEncoderV2;
+
+
+interface IFeeRecipient {
+
+    /// @dev A callback function invoked in the ERC721Feature for each ERC721
+    ///      order fee that get paid. Integrators can make use of this callback
+    ///      to implement arbitrary fee-handling logic, e.g. splitting the fee
+    ///      between multiple parties.
+    /// @param tokenAddress The address of the token in which the received fee is
+    ///        denominated. `0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE` indicates
+    ///        that the fee was paid in the native token (e.g. ETH).
+    /// @param amount The amount of the given token received.
+    /// @param feeData Arbitrary data encoded in the `Fee` used by this callback.
+    /// @return success The selector of this function (0x0190805e),
+    ///         indicating that the callback succeeded.
+    function receiveZeroExFeeCallback(
+        address tokenAddress,
+        uint256 amount,
+        bytes calldata feeData
+    )
+        external
+        returns (bytes4 success);
+}

contracts/zero-ex/contracts/src/vendor/IPropertyValidator.sol

@@ -0,0 +1,38 @@
+// SPDX-License-Identifier: Apache-2.0
+/*
+
+  Copyright 2021 ZeroEx Intl.
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+
+*/
+
+pragma solidity ^0.6.5;
+pragma experimental ABIEncoderV2;
+
+
+interface IPropertyValidator {
+
+    /// @dev Checks that the given ERC721/ERC1155 asset satisfies the properties encoded in `propertyData`.
+    ///      Should revert if the asset does not satisfy the specified properties.
+    /// @param tokenAddress The ERC721/ERC1155 token contract address.
+    /// @param tokenId The ERC721/ERC1155 tokenId of the asset to check.
+    /// @param propertyData Encoded properties or auxiliary data needed to perform the check.
+    function validateProperty(
+        address tokenAddress,
+        uint256 tokenId,
+        bytes calldata propertyData
+    )
+        external
+        view;
+}

contracts/zero-ex/contracts/src/vendor/ITakerCallback.sol

@@ -0,0 +1,40 @@
+// SPDX-License-Identifier: Apache-2.0
+/*
+
+  Copyright 2021 ZeroEx Intl.
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+
+*/
+
+pragma solidity ^0.6.5;
+pragma experimental ABIEncoderV2;
+
+
+interface ITakerCallback {
+
+    /// @dev A taker callback function invoked in ERC721OrdersFeature and
+    ///      ERC1155OrdersFeature between the maker -> taker transfer and
+    ///      the taker -> maker transfer.
+    /// @param orderHash The hash of the order being filled when this
+    ///        callback is invoked.
+    /// @param callbackData Arbitrary data used by this callback.
+    /// @return success The selector of this function,
+    ///         indicating that the callback succeeded.
+    function zeroExTakerCallback(
+        bytes32 orderHash,
+        bytes calldata callbackData
+    )
+        external
+        returns (bytes4 success);
+}

contracts/zero-ex/contracts/test/TestFeeRecipient.sol

@@ -0,0 +1,55 @@
+// SPDX-License-Identifier: Apache-2.0
+/*
+
+  Copyright 2021 ZeroEx Intl.
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+
+*/
+
+pragma solidity ^0.6.5;
+pragma experimental ABIEncoderV2;
+
+
+contract TestFeeRecipient {
+    bytes4 constant private SUCCESS = this.receiveZeroExFeeCallback.selector;
+    bytes4 constant private FAILURE = 0xdeadbeef;
+
+    uint256 constant private TRIGGER_REVERT = 333;
+    uint256 constant private TRIGGER_FAILURE = 666;
+
+    event FeeReceived(
+        address tokenAddress,
+        uint256 amount
+    );
+
+    receive() external payable {}
+
+    function receiveZeroExFeeCallback(
+        address tokenAddress,
+        uint256 amount,
+        bytes calldata /* feeData */
+    )
+        external
+        returns (bytes4 success)
+    {
+        emit FeeReceived(tokenAddress, amount);
+        if (amount == TRIGGER_REVERT) {
+            revert("TestFeeRecipient::receiveZeroExFeeCallback/REVERT");
+        } else if (amount == TRIGGER_FAILURE) {
+            return FAILURE;
+        } else {
+            return SUCCESS;
+        }
+    }
+}

contracts/zero-ex/contracts/test/TestFillQuoteTransformerBridge.sol

@@ -22,7 +22,7 @@ pragma experimental ABIEncoderV2;
 
 import "@0x/contracts-utils/contracts/src/v06/LibMathV06.sol";
 import "../src/vendor/v3/IERC20Bridge.sol";
-import "./TestMintableERC20Token.sol";
+import "./tokens/TestMintableERC20Token.sol";
 
 
 contract TestFillQuoteTransformerBridge {

contracts/zero-ex/contracts/test/TestFillQuoteTransformerExchange.sol

@@ -23,7 +23,7 @@ pragma experimental ABIEncoderV2;
 import "@0x/contracts-utils/contracts/src/v06/LibBytesV06.sol";
 import "@0x/contracts-utils/contracts/src/v06/LibMathV06.sol";
 import "@0x/contracts-utils/contracts/src/v06/LibSafeMathV06.sol";
-import "./TestMintableERC20Token.sol";
+import "./tokens/TestMintableERC20Token.sol";
 import "../src/features/libs/LibNativeOrder.sol";
 import "../src/features/libs/LibSignature.sol";
 

contracts/zero-ex/contracts/test/TestFillQuoteTransformerHost.sol

@@ -21,7 +21,7 @@ pragma solidity ^0.6.5;
 pragma experimental ABIEncoderV2;
 
 import "../src/transformers/IERC20Transformer.sol";
-import "./TestMintableERC20Token.sol";
+import "./tokens/TestMintableERC20Token.sol";
 import "./TestTransformerHost.sol";
 
 

contracts/zero-ex/contracts/test/TestMintTokenERC20Transformer.sol

@@ -23,7 +23,7 @@ pragma experimental ABIEncoderV2;
 import "@0x/contracts-erc20/contracts/src/v06/IERC20TokenV06.sol";
 import "../src/transformers/IERC20Transformer.sol";
 import "../src/transformers/LibERC20Transformer.sol";
-import "./TestMintableERC20Token.sol";
+import "./tokens/TestMintableERC20Token.sol";
 
 
 contract TestMintTokenERC20Transformer is

contracts/zero-ex/contracts/test/TestNFTOrderPresigner.sol

@@ -0,0 +1,93 @@
+// SPDX-License-Identifier: Apache-2.0
+/*
+
+  Copyright 2021 ZeroEx Intl.
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+
+*/
+
+pragma solidity ^0.6.5;
+pragma experimental ABIEncoderV2;
+
+import "@0x/contracts-erc20/contracts/src/v06/IERC20TokenV06.sol";
+import "../src/IZeroEx.sol";
+import "../src/vendor/IERC1155Token.sol";
+import "../src/vendor/IERC721Token.sol";
+import "../src/features/libs/LibNFTOrder.sol";
+
+
+contract TestNFTOrderPresigner {
+    IZeroEx private immutable zeroEx;
+
+    constructor(IZeroEx _zeroEx)
+        public
+    {
+        zeroEx = _zeroEx;
+    }
+
+    function onERC1155Received(
+        address operator,
+        address from,
+        uint256 id,
+        uint256 value,
+        bytes calldata data
+    )
+        external
+        returns(bytes4 success)
+    {
+        return 0xf23a6e61;
+    }
+
+    function approveERC721(IERC721Token token)
+        external
+    {
+        token.setApprovalForAll(address(zeroEx), true);
+    }
+
+    function approveERC1155(IERC1155Token token)
+        external
+    {
+        token.setApprovalForAll(address(zeroEx), true);
+    }
+
+    function approveERC20(IERC20TokenV06 token)
+        external
+    {
+        token.approve(address(zeroEx), uint256(-1));
+    }
+
+    function preSignERC721Order(LibNFTOrder.ERC721Order calldata order)
+        external
+    {
+        zeroEx.preSignERC721Order(order);
+    }
+
+    function preSignERC1155Order(LibNFTOrder.ERC1155Order calldata order)
+        external
+    {
+        zeroEx.preSignERC1155Order(order);
+    }
+
+    function cancelERC721Order(uint256 orderNonce)
+        external
+    {
+        zeroEx.cancelERC721Order(orderNonce);
+    }
+
+    function cancelERC1155Order(LibNFTOrder.ERC1155Order calldata order)
+        external
+    {
+        zeroEx.cancelERC1155Order(order);
+    }
+}

contracts/zero-ex/contracts/test/TestPropertyValidator.sol

@@ -0,0 +1,39 @@
+// SPDX-License-Identifier: Apache-2.0
+/*
+
+  Copyright 2021 ZeroEx Intl.
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+
+*/
+
+pragma solidity ^0.6.5;
+pragma experimental ABIEncoderV2;
+
+
+contract TestPropertyValidator {
+
+    function validateProperty(
+        address tokenAddress,
+        uint256 tokenId,
+        bytes calldata propertyData
+    )
+        external
+        view
+    {
+        require(
+            propertyData.length > 0,
+            "TestPropertyValidator::validateProperty/REVERT"
+        );
+    }
+}

contracts/zero-ex/contracts/test/TestWethTransformerHost.sol

@@ -21,9 +21,9 @@ pragma solidity ^0.6.5;
 pragma experimental ABIEncoderV2;
 
 import "../src/transformers/IERC20Transformer.sol";
-import "./TestMintableERC20Token.sol";
+import "./tokens/TestMintableERC20Token.sol";
 import "./TestTransformerHost.sol";
-import "./TestWeth.sol";
+import "./tokens/TestWeth.sol";
 
 
 contract TestWethTransformerHost is

contracts/zero-ex/contracts/test/integration/TestCurve.sol

@@ -21,7 +21,7 @@ pragma solidity ^0.6.5;
 pragma experimental ABIEncoderV2;
 
 import "@0x/contracts-erc20/contracts/src/v06/IERC20TokenV06.sol";
-import "./TestMintableERC20Token.sol";
+import "../tokens/TestMintableERC20Token.sol";
 
 contract TestCurve {
 

contracts/zero-ex/contracts/test/integration/TestMooniswap.sol

@@ -21,7 +21,7 @@ pragma solidity ^0.6.5;
 pragma experimental ABIEncoderV2;
 
 import "@0x/contracts-erc20/contracts/src/v06/IERC20TokenV06.sol";
-import "./TestMintableERC20Token.sol";
+import "../tokens/TestMintableERC20Token.sol";
 
 contract TestMooniswap {
 

contracts/zero-ex/contracts/test/integration/TestUniswapV2Pool.sol

@@ -2,7 +2,7 @@
 pragma solidity ^0.6;
 pragma experimental ABIEncoderV2;
 import "@0x/contracts-erc20/contracts/src/v06/IERC20TokenV06.sol";
-import "../src/vendor/IUniswapV2Pair.sol";
+import "../../src/vendor/IUniswapV2Pair.sol";
 
 interface IUniswapV2PoolDeployer {
     struct CreationParameters {

contracts/zero-ex/contracts/test/integration/TestUniswapV3Pool.sol

@@ -2,7 +2,7 @@
 pragma solidity ^0.6;
 pragma experimental ABIEncoderV2;
 import "@0x/contracts-erc20/contracts/src/v06/IERC20TokenV06.sol";
-import "../src/vendor/IUniswapV3Pool.sol";
+import "../../src/vendor/IUniswapV3Pool.sol";
 
 interface IUniswapV3PoolDeployer {
     struct CreationParameters {

contracts/zero-ex/contracts/test/tokens/TestMintableERC1155Token.sol

@@ -0,0 +1,345 @@
+// SPDX-License-Identifier: Apache-2.0
+/*
+
+  Copyright 2019 ZeroEx Intl.
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+
+*/
+
+pragma solidity ^0.6;
+pragma experimental ABIEncoderV2;
+
+import "@0x/contracts-utils/contracts/src/v06/LibSafeMathV06.sol";
+
+
+interface IERC1155Receiver {
+
+    /// @notice Handle the receipt of a single ERC1155 token type
+    /// @dev The smart contract calls this function on the recipient
+    /// after a `safeTransferFrom`. This function MAY throw to revert and reject the
+    /// transfer. Return of other than the magic value MUST result in the
+    ///transaction being reverted
+    /// Note: the contract address is always the message sender
+    /// @param operator  The address which called `safeTransferFrom` function
+    /// @param from      The address which previously owned the token
+    /// @param id        An array containing the ids of the token being transferred
+    /// @param value     An array containing the amount of tokens being transferred
+    /// @param data      Additional data with no specified format
+    /// @return success  `bytes4(keccak256("onERC1155Received(address,address,uint256,uint256,bytes)"))`
+    function onERC1155Received(
+        address operator,
+        address from,
+        uint256 id,
+        uint256 value,
+        bytes calldata data
+    )
+        external
+        returns(bytes4 success);
+
+    /// @notice Handle the receipt of multiple ERC1155 token types
+    /// @dev The smart contract calls this function on the recipient
+    /// after a `safeTransferFrom`. This function MAY throw to revert and reject the
+    /// transfer. Return of other than the magic value MUST result in the
+    /// transaction being reverted
+    /// Note: the contract address is always the message sender
+    /// @param operator  The address which called `safeTransferFrom` function
+    /// @param from      The address which previously owned the token
+    /// @param ids       An array containing ids of each token being transferred
+    /// @param values    An array containing amounts of each token being transferred
+    /// @param data      Additional data with no specified format
+    /// @return success  `bytes4(keccak256("onERC1155Received(address,address,uint256,uint256,bytes)"))`
+    function onERC1155BatchReceived(
+        address operator,
+        address from,
+        uint256[] calldata ids,
+        uint256[] calldata values,
+        bytes calldata data
+    )
+        external
+        returns(bytes4 success);
+}
+
+contract TestMintableERC1155Token {
+    using LibSafeMathV06 for uint256;
+
+    /// @dev Either TransferSingle or TransferBatch MUST emit when tokens are transferred,
+    ///      including zero value transfers as well as minting or burning.
+    /// Operator will always be msg.sender.
+    /// Either event from address `0x0` signifies a minting operation.
+    /// An event to address `0x0` signifies a burning or melting operation.
+    /// The total value transferred from address 0x0 minus the total value transferred to 0x0 may
+    /// be used by clients and exchanges to be added to the "circulating supply" for a given token ID.
+    /// To define a token ID with no initial balance, the contract SHOULD emit the TransferSingle event
+    /// from `0x0` to `0x0`, with the token creator as `_operator`.
+    event TransferSingle(
+        address indexed operator,
+        address indexed from,
+        address indexed to,
+        uint256 id,
+        uint256 value
+    );
+
+    /// @dev Either TransferSingle or TransferBatch MUST emit when tokens are transferred,
+    ///      including zero value transfers as well as minting or burning.
+    ///Operator will always be msg.sender.
+    /// Either event from address `0x0` signifies a minting operation.
+    /// An event to address `0x0` signifies a burning or melting operation.
+    /// The total value transferred from address 0x0 minus the total value transferred to 0x0 may
+    /// be used by clients and exchanges to be added to the "circulating supply" for a given token ID.
+    /// To define multiple token IDs with no initial balance, this SHOULD emit the TransferBatch event
+    /// from `0x0` to `0x0`, with the token creator as `_operator`.
+    event TransferBatch(
+        address indexed operator,
+        address indexed from,
+        address indexed to,
+        uint256[] ids,
+        uint256[] values
+    );
+
+    /// @dev MUST emit when an approval is updated.
+    event ApprovalForAll(
+        address indexed owner,
+        address indexed operator,
+        bool approved
+    );
+
+    // selectors for receiver callbacks
+    bytes4 constant public ERC1155_RECEIVED       = 0xf23a6e61;
+    bytes4 constant public ERC1155_BATCH_RECEIVED = 0xbc197c81;
+
+    // id => (owner => balance)
+    mapping (uint256 => mapping(address => uint256)) internal balances;
+
+    // owner => (operator => approved)
+    mapping (address => mapping(address => bool)) internal operatorApproval;
+
+
+    function mint(
+        address to,
+        uint256 id,
+        uint256 quantity
+    )
+        external
+    {
+        // Grant the items to the caller
+        balances[id][to] = quantity.safeAdd(balances[id][to]);
+
+        // Emit the Transfer/Mint event.
+        // the 0x0 source address implies a mint
+        // It will also provide the circulating supply info.
+        emit TransferSingle(
+            msg.sender,
+            address(0x0),
+            to,
+            id,
+            quantity
+        );
+
+        // if `to` is a contract then trigger its callback
+        uint256 receiverCodeSize;
+        assembly {
+            receiverCodeSize := extcodesize(to)
+        }
+        if (receiverCodeSize > 0) {
+            bytes4 callbackReturnValue = IERC1155Receiver(to).onERC1155Received(
+                msg.sender,
+                msg.sender,
+                id,
+                quantity,
+                ""
+            );
+            require(
+                callbackReturnValue == ERC1155_RECEIVED,
+                "BAD_RECEIVER_RETURN_VALUE"
+            );
+        }
+    }
+
+    /// @notice Transfers value amount of an _id from the _from address to the _to address specified.
+    /// @dev MUST emit TransferSingle event on success.
+    /// Caller must be approved to manage the _from account's tokens (see isApprovedForAll).
+    /// MUST throw if `_to` is the zero address.
+    /// MUST throw if balance of sender for token `_id` is lower than the `_value` sent.
+    /// MUST throw on any other error.
+    /// When transfer is complete, this function MUST check if `_to` is a smart contract (code size > 0).
+    /// If so, it MUST call `onERC1155Received` on `_to` and revert if the return value
+    /// is not `bytes4(keccak256("onERC1155Received(address,address,uint256,uint256,bytes)"))`.
+    /// @param from    Source address
+    /// @param to      Target address
+    /// @param id      ID of the token type
+    /// @param value   Transfer amount
+    /// @param data    Additional data with no specified format, sent in call to `_to`
+    function safeTransferFrom(
+        address from,
+        address to,
+        uint256 id,
+        uint256 value,
+        bytes calldata data
+    )
+        external
+    {
+        // sanity checks
+        require(
+            to != address(0x0),
+            "CANNOT_TRANSFER_TO_ADDRESS_ZERO"
+        );
+        require(
+            from == msg.sender || operatorApproval[from][msg.sender] == true,
+            "INSUFFICIENT_ALLOWANCE"
+        );
+
+        // perform transfer
+        balances[id][from] = balances[id][from].safeSub(value);
+        balances[id][to] = balances[id][to].safeAdd(value);
+
+        emit TransferSingle(msg.sender, from, to, id, value);
+
+        // if `to` is a contract then trigger its callback
+        uint256 receiverCodeSize;
+        assembly {
+            receiverCodeSize := extcodesize(to)
+        }
+        if (receiverCodeSize > 0) {
+            bytes4 callbackReturnValue = IERC1155Receiver(to).onERC1155Received(
+                msg.sender,
+                from,
+                id,
+                value,
+                data
+            );
+            require(
+                callbackReturnValue == ERC1155_RECEIVED,
+                "BAD_RECEIVER_RETURN_VALUE"
+            );
+        }
+    }
+
+    /// @notice Send multiple types of Tokens from a 3rd party in one transfer (with safety call).
+    /// @dev MUST emit TransferBatch event on success.
+    /// Caller must be approved to manage the _from account's tokens (see isApprovedForAll).
+    /// MUST throw if `_to` is the zero address.
+    /// MUST throw if length of `_ids` is not the same as length of `_values`.
+    ///  MUST throw if any of the balance of sender for token `_ids` is lower than the respective `_values` sent.
+    /// MUST throw on any other error.
+    /// When transfer is complete, this function MUST check if `_to` is a smart contract (code size > 0).
+    /// If so, it MUST call `onERC1155BatchReceived` on `_to` and revert if the return value
+    /// is not `bytes4(keccak256("onERC1155BatchReceived(address,address,uint256[],uint256[],bytes)"))`.
+    /// @param from    Source addresses
+    /// @param to      Target addresses
+    /// @param ids     IDs of each token type
+    /// @param values  Transfer amounts per token type
+    /// @param data    Additional data with no specified format, sent in call to `_to`
+    function safeBatchTransferFrom(
+        address from,
+        address to,
+        uint256[] calldata ids,
+        uint256[] calldata values,
+        bytes calldata data
+    )
+        external
+    {
+        // sanity checks
+        require(
+            to != address(0x0),
+            "CANNOT_TRANSFER_TO_ADDRESS_ZERO"
+        );
+        require(
+            ids.length == values.length,
+            "TOKEN_AND_VALUES_LENGTH_MISMATCH"
+        );
+
+        // Only supporting a global operator approval allows us to do
+        // only 1 check and not to touch storage to handle allowances.
+        require(
+            from == msg.sender || operatorApproval[from][msg.sender] == true,
+            "INSUFFICIENT_ALLOWANCE"
+        );
+
+        // perform transfers
+        for (uint256 i = 0; i < ids.length; ++i) {
+            // Cache value to local variable to reduce read costs.
+            uint256 id = ids[i];
+            uint256 value = values[i];
+
+            balances[id][from] = balances[id][from].safeSub(value);
+            balances[id][to] = balances[id][to].safeAdd(value);
+        }
+        emit TransferBatch(msg.sender, from, to, ids, values);
+
+        // if `to` is a contract then trigger its callback
+        uint256 receiverCodeSize;
+        assembly {
+            receiverCodeSize := extcodesize(to)
+        }
+        if (receiverCodeSize > 0) {
+            bytes4 callbackReturnValue = IERC1155Receiver(to).onERC1155BatchReceived(
+                msg.sender,
+                from,
+                ids,
+                values,
+                data
+            );
+            require(
+                callbackReturnValue == ERC1155_BATCH_RECEIVED,
+                "BAD_RECEIVER_RETURN_VALUE"
+            );
+        }
+    }
+
+    /// @notice Enable or disable approval for a third party ("operator") to manage all of the caller's tokens.
+    /// @dev MUST emit the ApprovalForAll event on success.
+    /// @param operator  Address to add to the set of authorized operators
+    /// @param approved  True if the operator is approved, false to revoke approval
+    function setApprovalForAll(address operator, bool approved) external {
+        operatorApproval[msg.sender][operator] = approved;
+        emit ApprovalForAll(msg.sender, operator, approved);
+    }
+
+    /// @notice Queries the approval status of an operator for a given owner.
+    /// @param owner        The owner of the Tokens
+    /// @param operator     Address of authorized operator
+    /// @return isApproved  True if the operator is approved, false if not
+    function isApprovedForAll(address owner, address operator) external view returns (bool isApproved) {
+        return operatorApproval[owner][operator];
+    }
+
+    /// @notice Get the balance of an account's Tokens.
+    /// @param owner     The address of the token holder
+    /// @param id        ID of the Token
+    /// @return balance  The _owner's balance of the Token type requested
+    function balanceOf(address owner, uint256 id) external view returns (uint256 balance) {
+        return balances[id][owner];
+    }
+
+    /// @notice Get the balance of multiple account/token pairs
+    /// @param owners      The addresses of the token holders
+    /// @param ids         ID of the Tokens
+    /// @return balances_  The _owner's balance of the Token types requested
+    function balanceOfBatch(address[] calldata owners, uint256[] calldata ids) external view returns (uint256[] memory balances_) {
+        // sanity check
+        require(
+            owners.length == ids.length,
+            "OWNERS_AND_IDS_MUST_HAVE_SAME_LENGTH"
+        );
+
+        // get balances
+        balances_ = new uint256[](owners.length);
+        for (uint256 i = 0; i < owners.length; ++i) {
+            uint256 id = ids[i];
+            balances_[i] = balances[id][owners[i]];
+        }
+
+        return balances_;
+    }
+}

contracts/zero-ex/contracts/test/tokens/TestMintableERC721Token.sol

@@ -0,0 +1,385 @@
+// SPDX-License-Identifier: Apache-2.0
+/*
+
+  Copyright 2020 ZeroEx Intl.
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+
+*/
+
+pragma solidity ^0.6.5;
+pragma experimental ABIEncoderV2;
+
+import "@0x/contracts-utils/contracts/src/v06/LibSafeMathV06.sol";
+
+
+interface IERC721Receiver {
+
+    /// @notice Handle the receipt of an NFT
+    /// @dev The ERC721 smart contract calls this function on the recipient
+    ///  after a `transfer`. This function MAY throw to revert and reject the
+    ///  transfer. Return of other than the magic value MUST result in the
+    ///  transaction being reverted.
+    ///  Note: the contract address is always the message sender.
+    /// @param _operator The address which called `safeTransferFrom` function
+    /// @param _from The address which previously owned the token
+    /// @param _tokenId The NFT identifier which is being transferred
+    /// @param _data Additional data with no specified format
+    /// @return `bytes4(keccak256("onERC721Received(address,address,uint256,bytes)"))`
+    ///  unless throwing
+    function onERC721Received(
+        address _operator,
+        address _from,
+        uint256 _tokenId,
+        bytes calldata _data
+    )
+        external
+        returns (bytes4);
+}
+
+contract TestMintableERC721Token {
+    using LibSafeMathV06 for uint256;
+
+    /// @dev This emits when ownership of any NFT changes by any mechanism.
+    ///      This event emits when NFTs are created (`from` == 0) and destroyed
+    ///      (`to` == 0). Exception: during contract creation, any number of NFTs
+    ///      may be created and assigned without emitting Transfer. At the time of
+    ///      any transfer, the approved address for that NFT (if any) is reset to none.
+    event Transfer(
+        address _from,
+        address _to,
+        uint256 _tokenId
+    );
+
+    /// @dev This emits when the approved address for an NFT is changed or
+    ///      reaffirmed. The zero address indicates there is no approved address.
+    ///      When a Transfer event emits, this also indicates that the approved
+    ///      address for that NFT (if any) is reset to none.
+    event Approval(
+        address indexed _owner,
+        address indexed _approved,
+        uint256 indexed _tokenId
+    );
+
+    /// @dev This emits when an operator is enabled or disabled for an owner.
+    ///      The operator can manage all NFTs of the owner.
+    event ApprovalForAll(
+        address indexed _owner,
+        address indexed _operator,
+        bool _approved
+    );
+
+    // Function selector for ERC721Receiver.onERC721Received
+    // 0x150b7a02
+    bytes4 constant private ERC721_RECEIVED = bytes4(keccak256("onERC721Received(address,address,uint256,bytes)"));
+
+    // Mapping of tokenId => owner
+    mapping (uint256 => address) private owners;
+
+    // Mapping of tokenId => approved address
+    mapping (uint256 => address) private approvals;
+
+    // Mapping of owner => number of tokens owned
+    mapping (address => uint256) private balances;
+
+    // Mapping of owner => operator => approved
+    mapping (address => mapping (address => bool)) private operatorApprovals;
+
+    /// @dev Function to mint a new token
+    ///      Reverts if the given token ID already exists
+    /// @param _to Address of the beneficiary that will own the minted token
+    /// @param _tokenId ID of the token to be minted by the msg.sender    
+    function mint(address _to, uint256 _tokenId)
+        external
+    {
+        require(
+            _to != address(0),
+            "ERC721_ZERO_TO_ADDRESS"
+        );
+
+        address owner = owners[_tokenId];
+        require(
+            owner == address(0),
+            "ERC721_OWNER_ALREADY_EXISTS"
+        );
+
+        owners[_tokenId] = _to;
+        balances[_to] = balances[_to].safeAdd(1);
+
+        emit Transfer(
+            address(0),
+            _to,
+            _tokenId
+        );
+    }
+
+    /// @dev Function to burn a token
+    ///      Reverts if the given token ID doesn't exist
+    /// @param _owner Owner of token with given token ID
+    /// @param _tokenId ID of the token to be burned by the msg.sender
+    function burn(address _owner, uint256 _tokenId)
+        external
+    {
+        require(
+            _owner != address(0),
+            "ERC721_ZERO_OWNER_ADDRESS"
+        );
+
+        address owner = owners[_tokenId];
+        require(
+            owner == _owner,
+            "ERC721_OWNER_MISMATCH"
+        );
+
+        owners[_tokenId] = address(0);
+        balances[_owner] = balances[_owner].safeSub(1);
+
+        emit Transfer(
+            _owner,
+            address(0),
+            _tokenId
+        );
+    }
+
+    /// @notice Transfers the ownership of an NFT from one address to another address
+    /// @dev Throws unless `msg.sender` is the current owner, an authorized
+    ///      operator, or the approved address for this NFT. Throws if `_from` is
+    ///      not the current owner. Throws if `_to` is the zero address. Throws if
+    ///      `_tokenId` is not a valid NFT. When transfer is complete, this function
+    ///      checks if `_to` is a smart contract (code size > 0). If so, it calls
+    ///      `onERC721Received` on `_to` and throws if the return value is not
+    ///      `bytes4(keccak256("onERC721Received(address,address,uint256,bytes)"))`.
+    /// @param _from The current owner of the NFT
+    /// @param _to The new owner
+    /// @param _tokenId The NFT to transfer
+    /// @param _data Additional data with no specified format, sent in call to `_to`
+    function safeTransferFrom(
+        address _from,
+        address _to,
+        uint256 _tokenId,
+        bytes calldata _data
+    )
+        external
+    {
+        transferFrom(
+            _from,
+            _to,
+            _tokenId
+        );
+
+        uint256 receiverCodeSize;
+        assembly {
+            receiverCodeSize := extcodesize(_to)
+        }
+        if (receiverCodeSize > 0) {
+            bytes4 selector = IERC721Receiver(_to).onERC721Received(
+                msg.sender,
+                _from,
+                _tokenId,
+                _data
+            );
+            require(
+                selector == ERC721_RECEIVED,
+                "ERC721_INVALID_SELECTOR"
+            );
+        }
+    }
+
+    /// @notice Transfers the ownership of an NFT from one address to another address
+    /// @dev This works identically to the other function with an extra data parameter,
+    ///      except this function just sets data to "".
+    /// @param _from The current owner of the NFT
+    /// @param _to The new owner
+    /// @param _tokenId The NFT to transfer
+    function safeTransferFrom(
+        address _from,
+        address _to,
+        uint256 _tokenId
+    )
+        external
+    {
+        transferFrom(
+            _from,
+            _to,
+            _tokenId
+        );
+
+        uint256 receiverCodeSize;
+        assembly {
+            receiverCodeSize := extcodesize(_to)
+        }
+        if (receiverCodeSize > 0) {
+            bytes4 selector = IERC721Receiver(_to).onERC721Received(
+                msg.sender,
+                _from,
+                _tokenId,
+                ""
+            );
+            require(
+                selector == ERC721_RECEIVED,
+                "ERC721_INVALID_SELECTOR"
+            );
+        }
+    }
+
+    /// @notice Change or reaffirm the approved address for an NFT
+    /// @dev The zero address indicates there is no approved address.
+    ///      Throws unless `msg.sender` is the current NFT owner, or an authorized
+    ///      operator of the current owner.
+    /// @param _approved The new approved NFT controller
+    /// @param _tokenId The NFT to approve
+    function approve(address _approved, uint256 _tokenId)
+        external
+    {
+        address owner = ownerOf(_tokenId);
+        require(
+            msg.sender == owner || isApprovedForAll(owner, msg.sender),
+            "ERC721_INVALID_SENDER"
+        );
+
+        approvals[_tokenId] = _approved;
+        emit Approval(
+            owner,
+            _approved,
+            _tokenId
+        );
+    }
+
+    /// @notice Enable or disable approval for a third party ("operator") to manage
+    ///         all of `msg.sender`'s assets
+    /// @dev Emits the ApprovalForAll event. The contract MUST allow
+    ///      multiple operators per owner.
+    /// @param _operator Address to add to the set of authorized operators
+    /// @param _approved True if the operator is approved, false to revoke approval
+    function setApprovalForAll(address _operator, bool _approved)
+        external
+    {
+        operatorApprovals[msg.sender][_operator] = _approved;
+        emit ApprovalForAll(
+            msg.sender,
+            _operator,
+            _approved
+        );
+    }
+
+    /// @notice Count all NFTs assigned to an owner
+    /// @dev NFTs assigned to the zero address are considered invalid, and this
+    ///      function throws for queries about the zero address.
+    /// @param _owner An address for whom to query the balance
+    /// @return The number of NFTs owned by `_owner`, possibly zero
+    function balanceOf(address _owner)
+        external
+        view
+        returns (uint256)
+    {
+        require(
+            _owner != address(0),
+            "ERC721_ZERO_OWNER"
+        );
+        return balances[_owner];
+    }
+
+    /// @notice Transfer ownership of an NFT -- THE CALLER IS RESPONSIBLE
+    ///         TO CONFIRM THAT `_to` IS CAPABLE OF RECEIVING NFTS OR ELSE
+    ///         THEY MAY BE PERMANENTLY LOST
+    /// @dev Throws unless `msg.sender` is the current owner, an authorized
+    ///      operator, or the approved address for this NFT. Throws if `_from` is
+    ///      not the current owner. Throws if `_to` is the zero address. Throws if
+    ///      `_tokenId` is not a valid NFT.
+    /// @param _from The current owner of the NFT
+    /// @param _to The new owner
+    /// @param _tokenId The NFT to transfer
+    function transferFrom(
+        address _from,
+        address _to,
+        uint256 _tokenId
+    )
+        public
+    {
+        require(
+            _to != address(0),
+            "ERC721_ZERO_TO_ADDRESS"
+        );
+
+        address owner = ownerOf(_tokenId);
+        require(
+            _from == owner,
+            "ERC721_OWNER_MISMATCH"
+        );
+
+        address spender = msg.sender;
+        address approvedAddress = getApproved(_tokenId);
+        require(
+            spender == owner ||
+            isApprovedForAll(owner, spender) ||
+            approvedAddress == spender,
+            "ERC721_INVALID_SPENDER"
+        );
+
+        if (approvedAddress != address(0)) {
+            approvals[_tokenId] = address(0);
+        }
+
+        owners[_tokenId] = _to;
+        balances[_from] = balances[_from].safeSub(1);
+        balances[_to] = balances[_to].safeAdd(1);
+
+        emit Transfer(
+            _from,
+            _to,
+            _tokenId
+        );
+    }
+
+    /// @notice Find the owner of an NFT
+    /// @dev NFTs assigned to zero address are considered invalid, and queries
+    ///      about them do throw.
+    /// @param _tokenId The identifier for an NFT
+    /// @return The address of the owner of the NFT
+    function ownerOf(uint256 _tokenId)
+        public
+        view
+        returns (address)
+    {
+        address owner = owners[_tokenId];
+        require(
+            owner != address(0),
+            "ERC721_ZERO_OWNER"
+        );
+        return owner;
+    }
+
+    /// @notice Get the approved address for a single NFT
+    /// @dev Throws if `_tokenId` is not a valid NFT.
+    /// @param _tokenId The NFT to find the approved address for
+    /// @return The approved address for this NFT, or the zero address if there is none
+    function getApproved(uint256 _tokenId)
+        public
+        view
+        returns (address)
+    {
+        return approvals[_tokenId];
+    }
+
+    /// @notice Query if an address is an authorized operator for another address
+    /// @param _owner The address that owns the NFTs
+    /// @param _operator The address that acts on behalf of the owner
+    /// @return True if `_operator` is an approved operator for `_owner`, false otherwise
+    function isApprovedForAll(address _owner, address _operator)
+        public
+        view
+        returns (bool)
+    {
+        return operatorApprovals[_owner][_operator];
+    }
+}

contracts/zero-ex/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@0x/contracts-zero-ex",
-    "version": "0.30.0",
+    "version": "0.30.1",
     "engines": {
         "node": ">=6.12"
     },
@@ -43,7 +43,7 @@
     "config": {
         "publicInterfaceContracts": "IZeroEx,ZeroEx,FullMigration,InitialMigration,IFlashWallet,IERC20Transformer,IOwnableFeature,ISimpleFunctionRegistryFeature,ITransformERC20Feature,FillQuoteTransformer,PayTakerTransformer,PositiveSlippageFeeTransformer,WethTransformer,OwnableFeature,SimpleFunctionRegistryFeature,TransformERC20Feature,AffiliateFeeTransformer,MetaTransactionsFeature,LogMetadataTransformer,BridgeAdapter,LiquidityProviderFeature,ILiquidityProviderFeature,NativeOrdersFeature,INativeOrdersFeature,FeeCollectorController,FeeCollector,CurveLiquidityProvider,BatchFillNativeOrdersFeature,IBatchFillNativeOrdersFeature,MultiplexFeature,IMultiplexFeature,OtcOrdersFeature,IOtcOrdersFeature",
         "abis:comment": "This list is auto-generated by contracts-gen. Don't edit manually.",
-        "abis": "./test/generated-artifacts/@(AffiliateFeeTransformer|BatchFillNativeOrdersFeature|BootstrapFeature|BridgeAdapter|BridgeProtocols|CurveLiquidityProvider|FeeCollector|FeeCollectorController|FillQuoteTransformer|FixinCommon|FixinEIP712|FixinProtocolFees|FixinReentrancyGuard|FixinTokenSpender|FlashWallet|FullMigration|FundRecoveryFeature|IBatchFillNativeOrdersFeature|IBootstrapFeature|IBridgeAdapter|IERC20Bridge|IERC20Transformer|IFeature|IFlashWallet|IFundRecoveryFeature|ILiquidityProvider|ILiquidityProviderFeature|ILiquidityProviderSandbox|IMetaTransactionsFeature|IMooniswapPool|IMultiplexFeature|INativeOrdersEvents|INativeOrdersFeature|IOtcOrdersFeature|IOwnableFeature|IPancakeSwapFeature|ISimpleFunctionRegistryFeature|IStaking|ITestSimpleFunctionRegistryFeature|ITokenSpenderFeature|ITransformERC20Feature|IUniswapFeature|IUniswapV2Pair|IUniswapV3Feature|IUniswapV3Pool|IZeroEx|InitialMigration|LibBootstrap|LibCommonRichErrors|LibERC20Transformer|LibFeeCollector|LibLiquidityProviderRichErrors|LibMetaTransactionsRichErrors|LibMetaTransactionsStorage|LibMigrate|LibNativeOrder|LibNativeOrdersRichErrors|LibNativeOrdersStorage|LibOtcOrdersStorage|LibOwnableRichErrors|LibOwnableStorage|LibProxyRichErrors|LibProxyStorage|LibReentrancyGuardStorage|LibSignature|LibSignatureRichErrors|LibSimpleFunctionRegistryRichErrors|LibSimpleFunctionRegistryStorage|LibStorage|LibTransformERC20RichErrors|LibTransformERC20Storage|LibWalletRichErrors|LiquidityProviderFeature|LiquidityProviderSandbox|LogMetadataTransformer|MetaTransactionsFeature|MixinAaveV2|MixinBalancer|MixinBalancerV2|MixinBancor|MixinCoFiX|MixinCompound|MixinCryptoCom|MixinCurve|MixinCurveV2|MixinDodo|MixinDodoV2|MixinKyber|MixinKyberDmm|MixinLido|MixinMStable|MixinMakerPSM|MixinMooniswap|MixinNerve|MixinOasis|MixinShell|MixinUniswap|MixinUniswapV2|MixinUniswapV3|MixinZeroExBridge|MooniswapLiquidityProvider|MultiplexFeature|MultiplexLiquidityProvider|MultiplexOtc|MultiplexRfq|MultiplexTransformERC20|MultiplexUniswapV2|MultiplexUniswapV3|NativeOrdersCancellation|NativeOrdersFeature|NativeOrdersInfo|NativeOrdersProtocolFees|NativeOrdersSettlement|OtcOrdersFeature|OwnableFeature|PancakeSwapFeature|PayTakerTransformer|PermissionlessTransformerDeployer|PositiveSlippageFeeTransformer|SimpleFunctionRegistryFeature|TestBridge|TestCallTarget|TestCurve|TestDelegateCaller|TestFeeCollectorController|TestFillQuoteTransformerBridge|TestFillQuoteTransformerExchange|TestFillQuoteTransformerHost|TestFixinProtocolFees|TestFixinTokenSpender|TestFullMigration|TestInitialMigration|TestLibNativeOrder|TestLibSignature|TestLiquidityProvider|TestMetaTransactionsNativeOrdersFeature|TestMetaTransactionsTransformERC20Feature|TestMigrator|TestMintTokenERC20Transformer|TestMintableERC20Token|TestMooniswap|TestNativeOrdersFeature|TestNoEthRecipient|TestOrderSignerRegistryWithContractWallet|TestPermissionlessTransformerDeployerSuicidal|TestPermissionlessTransformerDeployerTransformer|TestRfqOriginRegistration|TestSimpleFunctionRegistryFeatureImpl1|TestSimpleFunctionRegistryFeatureImpl2|TestStaking|TestTokenSpenderERC20Token|TestTransformERC20|TestTransformerBase|TestTransformerDeployerTransformer|TestTransformerHost|TestUniswapV2Factory|TestUniswapV2Pool|TestUniswapV3Factory|TestUniswapV3Feature|TestUniswapV3Pool|TestWeth|TestWethTransformerHost|TestZeroExFeature|TransformERC20Feature|Transformer|TransformerDeployer|UniswapFeature|UniswapV3Feature|WethTransformer|ZeroEx|ZeroExOptimized).json"
+        "abis": "./test/generated-artifacts/@(AffiliateFeeTransformer|BatchFillNativeOrdersFeature|BootstrapFeature|BridgeAdapter|BridgeProtocols|CurveLiquidityProvider|ERC1155OrdersFeature|ERC165Feature|ERC721OrdersFeature|FeeCollector|FeeCollectorController|FillQuoteTransformer|FixinCommon|FixinEIP712|FixinERC1155Spender|FixinERC721Spender|FixinProtocolFees|FixinReentrancyGuard|FixinTokenSpender|FlashWallet|FullMigration|FundRecoveryFeature|IBatchFillNativeOrdersFeature|IBootstrapFeature|IBridgeAdapter|IERC1155OrdersFeature|IERC1155Token|IERC165Feature|IERC20Bridge|IERC20Transformer|IERC721OrdersFeature|IERC721Token|IFeature|IFeeRecipient|IFlashWallet|IFundRecoveryFeature|ILiquidityProvider|ILiquidityProviderFeature|ILiquidityProviderSandbox|IMetaTransactionsFeature|IMooniswapPool|IMultiplexFeature|INativeOrdersEvents|INativeOrdersFeature|IOtcOrdersFeature|IOwnableFeature|IPancakeSwapFeature|IPropertyValidator|ISimpleFunctionRegistryFeature|IStaking|ITakerCallback|ITestSimpleFunctionRegistryFeature|ITokenSpenderFeature|ITransformERC20Feature|IUniswapFeature|IUniswapV2Pair|IUniswapV3Feature|IUniswapV3Pool|IZeroEx|InitialMigration|LibBootstrap|LibCommonRichErrors|LibERC1155OrdersStorage|LibERC20Transformer|LibERC721OrdersStorage|LibFeeCollector|LibLiquidityProviderRichErrors|LibMetaTransactionsRichErrors|LibMetaTransactionsStorage|LibMigrate|LibNFTOrder|LibNFTOrdersRichErrors|LibNativeOrder|LibNativeOrdersRichErrors|LibNativeOrdersStorage|LibOtcOrdersStorage|LibOwnableRichErrors|LibOwnableStorage|LibProxyRichErrors|LibProxyStorage|LibReentrancyGuardStorage|LibSignature|LibSignatureRichErrors|LibSimpleFunctionRegistryRichErrors|LibSimpleFunctionRegistryStorage|LibStorage|LibTransformERC20RichErrors|LibTransformERC20Storage|LibWalletRichErrors|LiquidityProviderFeature|LiquidityProviderSandbox|LogMetadataTransformer|MetaTransactionsFeature|MixinAaveV2|MixinBalancer|MixinBalancerV2|MixinBancor|MixinCoFiX|MixinCompound|MixinCryptoCom|MixinCurve|MixinCurveV2|MixinDodo|MixinDodoV2|MixinKyber|MixinKyberDmm|MixinLido|MixinMStable|MixinMakerPSM|MixinMooniswap|MixinNerve|MixinOasis|MixinShell|MixinUniswap|MixinUniswapV2|MixinUniswapV3|MixinZeroExBridge|MooniswapLiquidityProvider|MultiplexFeature|MultiplexLiquidityProvider|MultiplexOtc|MultiplexRfq|MultiplexTransformERC20|MultiplexUniswapV2|MultiplexUniswapV3|NFTOrders|NativeOrdersCancellation|NativeOrdersFeature|NativeOrdersInfo|NativeOrdersProtocolFees|NativeOrdersSettlement|OtcOrdersFeature|OwnableFeature|PancakeSwapFeature|PayTakerTransformer|PermissionlessTransformerDeployer|PositiveSlippageFeeTransformer|SimpleFunctionRegistryFeature|TestBridge|TestCallTarget|TestCurve|TestDelegateCaller|TestFeeCollectorController|TestFeeRecipient|TestFillQuoteTransformerBridge|TestFillQuoteTransformerExchange|TestFillQuoteTransformerHost|TestFixinProtocolFees|TestFixinTokenSpender|TestFullMigration|TestInitialMigration|TestLibNativeOrder|TestLibSignature|TestLiquidityProvider|TestMetaTransactionsNativeOrdersFeature|TestMetaTransactionsTransformERC20Feature|TestMigrator|TestMintTokenERC20Transformer|TestMintableERC1155Token|TestMintableERC20Token|TestMintableERC721Token|TestMooniswap|TestNFTOrderPresigner|TestNativeOrdersFeature|TestNoEthRecipient|TestOrderSignerRegistryWithContractWallet|TestPermissionlessTransformerDeployerSuicidal|TestPermissionlessTransformerDeployerTransformer|TestPropertyValidator|TestRfqOriginRegistration|TestSimpleFunctionRegistryFeatureImpl1|TestSimpleFunctionRegistryFeatureImpl2|TestStaking|TestTokenSpenderERC20Token|TestTransformERC20|TestTransformerBase|TestTransformerDeployerTransformer|TestTransformerHost|TestUniswapV2Factory|TestUniswapV2Pool|TestUniswapV3Factory|TestUniswapV3Feature|TestUniswapV3Pool|TestWeth|TestWethTransformerHost|TestZeroExFeature|TransformERC20Feature|Transformer|TransformerDeployer|UniswapFeature|UniswapV3Feature|WethTransformer|ZeroEx|ZeroExOptimized).json"
     },
     "repository": {
         "type": "git",
@@ -55,14 +55,14 @@
     },
     "homepage": "https://github.com/0xProject/protocol/tree/main/contracts/zero-ex",
     "devDependencies": {
-        "@0x/abi-gen": "^5.6.2",
-        "@0x/contract-addresses": "^6.10.0",
-        "@0x/contracts-erc20": "^3.3.24",
-        "@0x/contracts-gen": "^2.0.40",
-        "@0x/contracts-test-utils": "^5.4.15",
-        "@0x/dev-utils": "^4.2.9",
+        "@0x/abi-gen": "^5.7.2",
+        "@0x/contract-addresses": "^6.11.0",
+        "@0x/contracts-erc20": "^3.3.25",
+        "@0x/contracts-gen": "^2.0.43",
+        "@0x/contracts-test-utils": "^5.4.16",
+        "@0x/dev-utils": "^4.2.11",
         "@0x/order-utils": "^10.4.28",
-        "@0x/sol-compiler": "^4.7.5",
+        "@0x/sol-compiler": "^4.7.8",
         "@0x/ts-doc-gen": "^0.0.28",
         "@0x/tslint-config": "^4.1.4",
         "@types/isomorphic-fetch": "^0.0.35",
@@ -82,13 +82,13 @@
         "typescript": "4.2.2"
     },
     "dependencies": {
-        "@0x/base-contract": "^6.4.2",
-        "@0x/protocol-utils": "^1.10.0",
-        "@0x/subproviders": "^6.6.0",
+        "@0x/base-contract": "^6.4.5",
+        "@0x/protocol-utils": "^1.10.1",
+        "@0x/subproviders": "^6.6.2",
         "@0x/types": "^3.3.4",
         "@0x/typescript-typings": "^5.2.1",
-        "@0x/utils": "^6.4.4",
-        "@0x/web3-wrapper": "^7.6.0",
+        "@0x/utils": "^6.5.0",
+        "@0x/web3-wrapper": "^7.6.2",
         "ethereum-types": "^3.6.0",
         "ethereumjs-util": "^7.0.10",
         "ethers": "~4.0.4"

contracts/zero-ex/test/artifacts.ts

@@ -11,11 +11,16 @@ import * as BootstrapFeature from '../test/generated-artifacts/BootstrapFeature.
 import * as BridgeAdapter from '../test/generated-artifacts/BridgeAdapter.json';
 import * as BridgeProtocols from '../test/generated-artifacts/BridgeProtocols.json';
 import * as CurveLiquidityProvider from '../test/generated-artifacts/CurveLiquidityProvider.json';
+import * as ERC1155OrdersFeature from '../test/generated-artifacts/ERC1155OrdersFeature.json';
+import * as ERC165Feature from '../test/generated-artifacts/ERC165Feature.json';
+import * as ERC721OrdersFeature from '../test/generated-artifacts/ERC721OrdersFeature.json';
 import * as FeeCollector from '../test/generated-artifacts/FeeCollector.json';
 import * as FeeCollectorController from '../test/generated-artifacts/FeeCollectorController.json';
 import * as FillQuoteTransformer from '../test/generated-artifacts/FillQuoteTransformer.json';
 import * as FixinCommon from '../test/generated-artifacts/FixinCommon.json';
 import * as FixinEIP712 from '../test/generated-artifacts/FixinEIP712.json';
+import * as FixinERC1155Spender from '../test/generated-artifacts/FixinERC1155Spender.json';
+import * as FixinERC721Spender from '../test/generated-artifacts/FixinERC721Spender.json';
 import * as FixinProtocolFees from '../test/generated-artifacts/FixinProtocolFees.json';
 import * as FixinReentrancyGuard from '../test/generated-artifacts/FixinReentrancyGuard.json';
 import * as FixinTokenSpender from '../test/generated-artifacts/FixinTokenSpender.json';
@@ -25,9 +30,15 @@ import * as FundRecoveryFeature from '../test/generated-artifacts/FundRecoveryFe
 import * as IBatchFillNativeOrdersFeature from '../test/generated-artifacts/IBatchFillNativeOrdersFeature.json';
 import * as IBootstrapFeature from '../test/generated-artifacts/IBootstrapFeature.json';
 import * as IBridgeAdapter from '../test/generated-artifacts/IBridgeAdapter.json';
+import * as IERC1155OrdersFeature from '../test/generated-artifacts/IERC1155OrdersFeature.json';
+import * as IERC1155Token from '../test/generated-artifacts/IERC1155Token.json';
+import * as IERC165Feature from '../test/generated-artifacts/IERC165Feature.json';
 import * as IERC20Bridge from '../test/generated-artifacts/IERC20Bridge.json';
 import * as IERC20Transformer from '../test/generated-artifacts/IERC20Transformer.json';
+import * as IERC721OrdersFeature from '../test/generated-artifacts/IERC721OrdersFeature.json';
+import * as IERC721Token from '../test/generated-artifacts/IERC721Token.json';
 import * as IFeature from '../test/generated-artifacts/IFeature.json';
+import * as IFeeRecipient from '../test/generated-artifacts/IFeeRecipient.json';
 import * as IFlashWallet from '../test/generated-artifacts/IFlashWallet.json';
 import * as IFundRecoveryFeature from '../test/generated-artifacts/IFundRecoveryFeature.json';
 import * as ILiquidityProvider from '../test/generated-artifacts/ILiquidityProvider.json';
@@ -42,8 +53,10 @@ import * as InitialMigration from '../test/generated-artifacts/InitialMigration.
 import * as IOtcOrdersFeature from '../test/generated-artifacts/IOtcOrdersFeature.json';
 import * as IOwnableFeature from '../test/generated-artifacts/IOwnableFeature.json';
 import * as IPancakeSwapFeature from '../test/generated-artifacts/IPancakeSwapFeature.json';
+import * as IPropertyValidator from '../test/generated-artifacts/IPropertyValidator.json';
 import * as ISimpleFunctionRegistryFeature from '../test/generated-artifacts/ISimpleFunctionRegistryFeature.json';
 import * as IStaking from '../test/generated-artifacts/IStaking.json';
+import * as ITakerCallback from '../test/generated-artifacts/ITakerCallback.json';
 import * as ITestSimpleFunctionRegistryFeature from '../test/generated-artifacts/ITestSimpleFunctionRegistryFeature.json';
 import * as ITokenSpenderFeature from '../test/generated-artifacts/ITokenSpenderFeature.json';
 import * as ITransformERC20Feature from '../test/generated-artifacts/ITransformERC20Feature.json';
@@ -54,7 +67,9 @@ import * as IUniswapV3Pool from '../test/generated-artifacts/IUniswapV3Pool.json
 import * as IZeroEx from '../test/generated-artifacts/IZeroEx.json';
 import * as LibBootstrap from '../test/generated-artifacts/LibBootstrap.json';
 import * as LibCommonRichErrors from '../test/generated-artifacts/LibCommonRichErrors.json';
+import * as LibERC1155OrdersStorage from '../test/generated-artifacts/LibERC1155OrdersStorage.json';
 import * as LibERC20Transformer from '../test/generated-artifacts/LibERC20Transformer.json';
+import * as LibERC721OrdersStorage from '../test/generated-artifacts/LibERC721OrdersStorage.json';
 import * as LibFeeCollector from '../test/generated-artifacts/LibFeeCollector.json';
 import * as LibLiquidityProviderRichErrors from '../test/generated-artifacts/LibLiquidityProviderRichErrors.json';
 import * as LibMetaTransactionsRichErrors from '../test/generated-artifacts/LibMetaTransactionsRichErrors.json';
@@ -63,6 +78,8 @@ import * as LibMigrate from '../test/generated-artifacts/LibMigrate.json';
 import * as LibNativeOrder from '../test/generated-artifacts/LibNativeOrder.json';
 import * as LibNativeOrdersRichErrors from '../test/generated-artifacts/LibNativeOrdersRichErrors.json';
 import * as LibNativeOrdersStorage from '../test/generated-artifacts/LibNativeOrdersStorage.json';
+import * as LibNFTOrder from '../test/generated-artifacts/LibNFTOrder.json';
+import * as LibNFTOrdersRichErrors from '../test/generated-artifacts/LibNFTOrdersRichErrors.json';
 import * as LibOtcOrdersStorage from '../test/generated-artifacts/LibOtcOrdersStorage.json';
 import * as LibOwnableRichErrors from '../test/generated-artifacts/LibOwnableRichErrors.json';
 import * as LibOwnableStorage from '../test/generated-artifacts/LibOwnableStorage.json';
@@ -118,6 +135,7 @@ import * as NativeOrdersFeature from '../test/generated-artifacts/NativeOrdersFe
 import * as NativeOrdersInfo from '../test/generated-artifacts/NativeOrdersInfo.json';
 import * as NativeOrdersProtocolFees from '../test/generated-artifacts/NativeOrdersProtocolFees.json';
 import * as NativeOrdersSettlement from '../test/generated-artifacts/NativeOrdersSettlement.json';
+import * as NFTOrders from '../test/generated-artifacts/NFTOrders.json';
 import * as OtcOrdersFeature from '../test/generated-artifacts/OtcOrdersFeature.json';
 import * as OwnableFeature from '../test/generated-artifacts/OwnableFeature.json';
 import * as PancakeSwapFeature from '../test/generated-artifacts/PancakeSwapFeature.json';
@@ -130,6 +148,7 @@ import * as TestCallTarget from '../test/generated-artifacts/TestCallTarget.json
 import * as TestCurve from '../test/generated-artifacts/TestCurve.json';
 import * as TestDelegateCaller from '../test/generated-artifacts/TestDelegateCaller.json';
 import * as TestFeeCollectorController from '../test/generated-artifacts/TestFeeCollectorController.json';
+import * as TestFeeRecipient from '../test/generated-artifacts/TestFeeRecipient.json';
 import * as TestFillQuoteTransformerBridge from '../test/generated-artifacts/TestFillQuoteTransformerBridge.json';
 import * as TestFillQuoteTransformerExchange from '../test/generated-artifacts/TestFillQuoteTransformerExchange.json';
 import * as TestFillQuoteTransformerHost from '../test/generated-artifacts/TestFillQuoteTransformerHost.json';
@@ -143,14 +162,18 @@ import * as TestLiquidityProvider from '../test/generated-artifacts/TestLiquidit
 import * as TestMetaTransactionsNativeOrdersFeature from '../test/generated-artifacts/TestMetaTransactionsNativeOrdersFeature.json';
 import * as TestMetaTransactionsTransformERC20Feature from '../test/generated-artifacts/TestMetaTransactionsTransformERC20Feature.json';
 import * as TestMigrator from '../test/generated-artifacts/TestMigrator.json';
+import * as TestMintableERC1155Token from '../test/generated-artifacts/TestMintableERC1155Token.json';
 import * as TestMintableERC20Token from '../test/generated-artifacts/TestMintableERC20Token.json';
+import * as TestMintableERC721Token from '../test/generated-artifacts/TestMintableERC721Token.json';
 import * as TestMintTokenERC20Transformer from '../test/generated-artifacts/TestMintTokenERC20Transformer.json';
 import * as TestMooniswap from '../test/generated-artifacts/TestMooniswap.json';
 import * as TestNativeOrdersFeature from '../test/generated-artifacts/TestNativeOrdersFeature.json';
+import * as TestNFTOrderPresigner from '../test/generated-artifacts/TestNFTOrderPresigner.json';
 import * as TestNoEthRecipient from '../test/generated-artifacts/TestNoEthRecipient.json';
 import * as TestOrderSignerRegistryWithContractWallet from '../test/generated-artifacts/TestOrderSignerRegistryWithContractWallet.json';
 import * as TestPermissionlessTransformerDeployerSuicidal from '../test/generated-artifacts/TestPermissionlessTransformerDeployerSuicidal.json';
 import * as TestPermissionlessTransformerDeployerTransformer from '../test/generated-artifacts/TestPermissionlessTransformerDeployerTransformer.json';
+import * as TestPropertyValidator from '../test/generated-artifacts/TestPropertyValidator.json';
 import * as TestRfqOriginRegistration from '../test/generated-artifacts/TestRfqOriginRegistration.json';
 import * as TestSimpleFunctionRegistryFeatureImpl1 from '../test/generated-artifacts/TestSimpleFunctionRegistryFeatureImpl1.json';
 import * as TestSimpleFunctionRegistryFeatureImpl2 from '../test/generated-artifacts/TestSimpleFunctionRegistryFeatureImpl2.json';
@@ -183,6 +206,7 @@ export const artifacts = {
     LibCommonRichErrors: LibCommonRichErrors as ContractArtifact,
     LibLiquidityProviderRichErrors: LibLiquidityProviderRichErrors as ContractArtifact,
     LibMetaTransactionsRichErrors: LibMetaTransactionsRichErrors as ContractArtifact,
+    LibNFTOrdersRichErrors: LibNFTOrdersRichErrors as ContractArtifact,
     LibNativeOrdersRichErrors: LibNativeOrdersRichErrors as ContractArtifact,
     LibOwnableRichErrors: LibOwnableRichErrors as ContractArtifact,
     LibProxyRichErrors: LibProxyRichErrors as ContractArtifact,
@@ -201,6 +225,7 @@ export const artifacts = {
     TransformerDeployer: TransformerDeployer as ContractArtifact,
     BatchFillNativeOrdersFeature: BatchFillNativeOrdersFeature as ContractArtifact,
     BootstrapFeature: BootstrapFeature as ContractArtifact,
+    ERC165Feature: ERC165Feature as ContractArtifact,
     FundRecoveryFeature: FundRecoveryFeature as ContractArtifact,
     LiquidityProviderFeature: LiquidityProviderFeature as ContractArtifact,
     MetaTransactionsFeature: MetaTransactionsFeature as ContractArtifact,
@@ -214,6 +239,9 @@ export const artifacts = {
     UniswapV3Feature: UniswapV3Feature as ContractArtifact,
     IBatchFillNativeOrdersFeature: IBatchFillNativeOrdersFeature as ContractArtifact,
     IBootstrapFeature: IBootstrapFeature as ContractArtifact,
+    IERC1155OrdersFeature: IERC1155OrdersFeature as ContractArtifact,
+    IERC165Feature: IERC165Feature as ContractArtifact,
+    IERC721OrdersFeature: IERC721OrdersFeature as ContractArtifact,
     IFeature: IFeature as ContractArtifact,
     IFundRecoveryFeature: IFundRecoveryFeature as ContractArtifact,
     ILiquidityProviderFeature: ILiquidityProviderFeature as ContractArtifact,
@@ -229,6 +257,7 @@ export const artifacts = {
     ITransformERC20Feature: ITransformERC20Feature as ContractArtifact,
     IUniswapFeature: IUniswapFeature as ContractArtifact,
     IUniswapV3Feature: IUniswapV3Feature as ContractArtifact,
+    LibNFTOrder: LibNFTOrder as ContractArtifact,
     LibNativeOrder: LibNativeOrder as ContractArtifact,
     LibSignature: LibSignature as ContractArtifact,
     MultiplexFeature: MultiplexFeature as ContractArtifact,
@@ -242,8 +271,13 @@ export const artifacts = {
     NativeOrdersInfo: NativeOrdersInfo as ContractArtifact,
     NativeOrdersProtocolFees: NativeOrdersProtocolFees as ContractArtifact,
     NativeOrdersSettlement: NativeOrdersSettlement as ContractArtifact,
+    ERC1155OrdersFeature: ERC1155OrdersFeature as ContractArtifact,
+    ERC721OrdersFeature: ERC721OrdersFeature as ContractArtifact,
+    NFTOrders: NFTOrders as ContractArtifact,
     FixinCommon: FixinCommon as ContractArtifact,
     FixinEIP712: FixinEIP712 as ContractArtifact,
+    FixinERC1155Spender: FixinERC1155Spender as ContractArtifact,
+    FixinERC721Spender: FixinERC721Spender as ContractArtifact,
     FixinProtocolFees: FixinProtocolFees as ContractArtifact,
     FixinReentrancyGuard: FixinReentrancyGuard as ContractArtifact,
     FixinTokenSpender: FixinTokenSpender as ContractArtifact,
@@ -253,6 +287,8 @@ export const artifacts = {
     InitialMigration: InitialMigration as ContractArtifact,
     LibBootstrap: LibBootstrap as ContractArtifact,
     LibMigrate: LibMigrate as ContractArtifact,
+    LibERC1155OrdersStorage: LibERC1155OrdersStorage as ContractArtifact,
+    LibERC721OrdersStorage: LibERC721OrdersStorage as ContractArtifact,
     LibMetaTransactionsStorage: LibMetaTransactionsStorage as ContractArtifact,
     LibNativeOrdersStorage: LibNativeOrdersStorage as ContractArtifact,
     LibOtcOrdersStorage: LibOtcOrdersStorage as ContractArtifact,
@@ -298,8 +334,13 @@ export const artifacts = {
     MixinUniswapV2: MixinUniswapV2 as ContractArtifact,
     MixinUniswapV3: MixinUniswapV3 as ContractArtifact,
     MixinZeroExBridge: MixinZeroExBridge as ContractArtifact,
+    IERC1155Token: IERC1155Token as ContractArtifact,
+    IERC721Token: IERC721Token as ContractArtifact,
+    IFeeRecipient: IFeeRecipient as ContractArtifact,
     ILiquidityProvider: ILiquidityProvider as ContractArtifact,
     IMooniswapPool: IMooniswapPool as ContractArtifact,
+    IPropertyValidator: IPropertyValidator as ContractArtifact,
+    ITakerCallback: ITakerCallback as ContractArtifact,
     IUniswapV2Pair: IUniswapV2Pair as ContractArtifact,
     IUniswapV3Pool: IUniswapV3Pool as ContractArtifact,
     IERC20Bridge: IERC20Bridge as ContractArtifact,
@@ -307,9 +348,9 @@ export const artifacts = {
     ITestSimpleFunctionRegistryFeature: ITestSimpleFunctionRegistryFeature as ContractArtifact,
     TestBridge: TestBridge as ContractArtifact,
     TestCallTarget: TestCallTarget as ContractArtifact,
-    TestCurve: TestCurve as ContractArtifact,
     TestDelegateCaller: TestDelegateCaller as ContractArtifact,
     TestFeeCollectorController: TestFeeCollectorController as ContractArtifact,
+    TestFeeRecipient: TestFeeRecipient as ContractArtifact,
     TestFillQuoteTransformerBridge: TestFillQuoteTransformerBridge as ContractArtifact,
     TestFillQuoteTransformerExchange: TestFillQuoteTransformerExchange as ContractArtifact,
     TestFillQuoteTransformerHost: TestFillQuoteTransformerHost as ContractArtifact,
@@ -319,33 +360,38 @@ export const artifacts = {
     TestInitialMigration: TestInitialMigration as ContractArtifact,
     TestLibNativeOrder: TestLibNativeOrder as ContractArtifact,
     TestLibSignature: TestLibSignature as ContractArtifact,
-    TestLiquidityProvider: TestLiquidityProvider as ContractArtifact,
     TestMetaTransactionsNativeOrdersFeature: TestMetaTransactionsNativeOrdersFeature as ContractArtifact,
     TestMetaTransactionsTransformERC20Feature: TestMetaTransactionsTransformERC20Feature as ContractArtifact,
     TestMigrator: TestMigrator as ContractArtifact,
     TestMintTokenERC20Transformer: TestMintTokenERC20Transformer as ContractArtifact,
-    TestMintableERC20Token: TestMintableERC20Token as ContractArtifact,
-    TestMooniswap: TestMooniswap as ContractArtifact,
+    TestNFTOrderPresigner: TestNFTOrderPresigner as ContractArtifact,
     TestNativeOrdersFeature: TestNativeOrdersFeature as ContractArtifact,
     TestNoEthRecipient: TestNoEthRecipient as ContractArtifact,
     TestOrderSignerRegistryWithContractWallet: TestOrderSignerRegistryWithContractWallet as ContractArtifact,
     TestPermissionlessTransformerDeployerSuicidal: TestPermissionlessTransformerDeployerSuicidal as ContractArtifact,
     TestPermissionlessTransformerDeployerTransformer: TestPermissionlessTransformerDeployerTransformer as ContractArtifact,
+    TestPropertyValidator: TestPropertyValidator as ContractArtifact,
     TestRfqOriginRegistration: TestRfqOriginRegistration as ContractArtifact,
     TestSimpleFunctionRegistryFeatureImpl1: TestSimpleFunctionRegistryFeatureImpl1 as ContractArtifact,
     TestSimpleFunctionRegistryFeatureImpl2: TestSimpleFunctionRegistryFeatureImpl2 as ContractArtifact,
     TestStaking: TestStaking as ContractArtifact,
-    TestTokenSpenderERC20Token: TestTokenSpenderERC20Token as ContractArtifact,
     TestTransformERC20: TestTransformERC20 as ContractArtifact,
     TestTransformerBase: TestTransformerBase as ContractArtifact,
     TestTransformerDeployerTransformer: TestTransformerDeployerTransformer as ContractArtifact,
     TestTransformerHost: TestTransformerHost as ContractArtifact,
+    TestUniswapV3Feature: TestUniswapV3Feature as ContractArtifact,
+    TestWethTransformerHost: TestWethTransformerHost as ContractArtifact,
+    TestZeroExFeature: TestZeroExFeature as ContractArtifact,
+    TestCurve: TestCurve as ContractArtifact,
+    TestLiquidityProvider: TestLiquidityProvider as ContractArtifact,
+    TestMooniswap: TestMooniswap as ContractArtifact,
     TestUniswapV2Factory: TestUniswapV2Factory as ContractArtifact,
     TestUniswapV2Pool: TestUniswapV2Pool as ContractArtifact,
     TestUniswapV3Factory: TestUniswapV3Factory as ContractArtifact,
-    TestUniswapV3Feature: TestUniswapV3Feature as ContractArtifact,
     TestUniswapV3Pool: TestUniswapV3Pool as ContractArtifact,
+    TestMintableERC1155Token: TestMintableERC1155Token as ContractArtifact,
+    TestMintableERC20Token: TestMintableERC20Token as ContractArtifact,
+    TestMintableERC721Token: TestMintableERC721Token as ContractArtifact,
+    TestTokenSpenderERC20Token: TestTokenSpenderERC20Token as ContractArtifact,
     TestWeth: TestWeth as ContractArtifact,
-    TestWethTransformerHost: TestWethTransformerHost as ContractArtifact,
-    TestZeroExFeature: TestZeroExFeature as ContractArtifact,
 };

contracts/zero-ex/test/utils/nft_orders.ts

@@ -0,0 +1,41 @@
+import { constants, getRandomInteger, randomAddress } from '@0x/contracts-test-utils';
+import { ERC1155Order, ERC721Order } from '@0x/protocol-utils';
+import { BigNumber } from '@0x/utils';
+
+/**
+ * Generate a random ERC721 Order
+ */
+export function getRandomERC721Order(fields: Partial<ERC721Order> = {}): ERC721Order {
+    return new ERC721Order({
+        erc20Token: randomAddress(),
+        erc20TokenAmount: getRandomInteger('1e18', '10e18'),
+        erc721Token: randomAddress(),
+        erc721TokenId: getRandomInteger(0, constants.MAX_UINT256),
+        maker: randomAddress(),
+        taker: randomAddress(),
+        erc721TokenProperties: [],
+        fees: [],
+        nonce: getRandomInteger(0, constants.MAX_UINT256),
+        expiry: new BigNumber(Math.floor(Date.now() / 1000 + 60)),
+        ...fields,
+    });
+}
+/**
+ * Generate a random ERC1155 Order
+ */
+export function getRandomERC1155Order(fields: Partial<ERC1155Order> = {}): ERC1155Order {
+    return new ERC1155Order({
+        erc20Token: randomAddress(),
+        erc20TokenAmount: getRandomInteger('1e18', '10e18'),
+        erc1155Token: randomAddress(),
+        erc1155TokenId: getRandomInteger(0, constants.MAX_UINT256),
+        erc1155TokenAmount: getRandomInteger(1, '10e18'),
+        maker: randomAddress(),
+        taker: randomAddress(),
+        erc1155TokenProperties: [],
+        fees: [],
+        nonce: getRandomInteger(0, constants.MAX_UINT256),
+        expiry: new BigNumber(Math.floor(Date.now() / 1000 + 60)),
+        ...fields,
+    });
+}

contracts/zero-ex/test/wrappers.ts

@@ -9,11 +9,16 @@ export * from '../test/generated-wrappers/bootstrap_feature';
 export * from '../test/generated-wrappers/bridge_adapter';
 export * from '../test/generated-wrappers/bridge_protocols';
 export * from '../test/generated-wrappers/curve_liquidity_provider';
+export * from '../test/generated-wrappers/erc1155_orders_feature';
+export * from '../test/generated-wrappers/erc165_feature';
+export * from '../test/generated-wrappers/erc721_orders_feature';
 export * from '../test/generated-wrappers/fee_collector';
 export * from '../test/generated-wrappers/fee_collector_controller';
 export * from '../test/generated-wrappers/fill_quote_transformer';
 export * from '../test/generated-wrappers/fixin_common';
 export * from '../test/generated-wrappers/fixin_e_i_p712';
+export * from '../test/generated-wrappers/fixin_erc1155_spender';
+export * from '../test/generated-wrappers/fixin_erc721_spender';
 export * from '../test/generated-wrappers/fixin_protocol_fees';
 export * from '../test/generated-wrappers/fixin_reentrancy_guard';
 export * from '../test/generated-wrappers/fixin_token_spender';
@@ -23,9 +28,15 @@ export * from '../test/generated-wrappers/fund_recovery_feature';
 export * from '../test/generated-wrappers/i_batch_fill_native_orders_feature';
 export * from '../test/generated-wrappers/i_bootstrap_feature';
 export * from '../test/generated-wrappers/i_bridge_adapter';
+export * from '../test/generated-wrappers/i_erc1155_orders_feature';
+export * from '../test/generated-wrappers/i_erc1155_token';
+export * from '../test/generated-wrappers/i_erc165_feature';
 export * from '../test/generated-wrappers/i_erc20_bridge';
 export * from '../test/generated-wrappers/i_erc20_transformer';
+export * from '../test/generated-wrappers/i_erc721_orders_feature';
+export * from '../test/generated-wrappers/i_erc721_token';
 export * from '../test/generated-wrappers/i_feature';
+export * from '../test/generated-wrappers/i_fee_recipient';
 export * from '../test/generated-wrappers/i_flash_wallet';
 export * from '../test/generated-wrappers/i_fund_recovery_feature';
 export * from '../test/generated-wrappers/i_liquidity_provider';
@@ -39,8 +50,10 @@ export * from '../test/generated-wrappers/i_native_orders_feature';
 export * from '../test/generated-wrappers/i_otc_orders_feature';
 export * from '../test/generated-wrappers/i_ownable_feature';
 export * from '../test/generated-wrappers/i_pancake_swap_feature';
+export * from '../test/generated-wrappers/i_property_validator';
 export * from '../test/generated-wrappers/i_simple_function_registry_feature';
 export * from '../test/generated-wrappers/i_staking';
+export * from '../test/generated-wrappers/i_taker_callback';
 export * from '../test/generated-wrappers/i_test_simple_function_registry_feature';
 export * from '../test/generated-wrappers/i_token_spender_feature';
 export * from '../test/generated-wrappers/i_transform_erc20_feature';
@@ -52,12 +65,16 @@ export * from '../test/generated-wrappers/i_zero_ex';
 export * from '../test/generated-wrappers/initial_migration';
 export * from '../test/generated-wrappers/lib_bootstrap';
 export * from '../test/generated-wrappers/lib_common_rich_errors';
+export * from '../test/generated-wrappers/lib_erc1155_orders_storage';
 export * from '../test/generated-wrappers/lib_erc20_transformer';
+export * from '../test/generated-wrappers/lib_erc721_orders_storage';
 export * from '../test/generated-wrappers/lib_fee_collector';
 export * from '../test/generated-wrappers/lib_liquidity_provider_rich_errors';
 export * from '../test/generated-wrappers/lib_meta_transactions_rich_errors';
 export * from '../test/generated-wrappers/lib_meta_transactions_storage';
 export * from '../test/generated-wrappers/lib_migrate';
+export * from '../test/generated-wrappers/lib_n_f_t_order';
+export * from '../test/generated-wrappers/lib_n_f_t_orders_rich_errors';
 export * from '../test/generated-wrappers/lib_native_order';
 export * from '../test/generated-wrappers/lib_native_orders_rich_errors';
 export * from '../test/generated-wrappers/lib_native_orders_storage';
@@ -111,6 +128,7 @@ export * from '../test/generated-wrappers/multiplex_rfq';
 export * from '../test/generated-wrappers/multiplex_transform_erc20';
 export * from '../test/generated-wrappers/multiplex_uniswap_v2';
 export * from '../test/generated-wrappers/multiplex_uniswap_v3';
+export * from '../test/generated-wrappers/n_f_t_orders';
 export * from '../test/generated-wrappers/native_orders_cancellation';
 export * from '../test/generated-wrappers/native_orders_feature';
 export * from '../test/generated-wrappers/native_orders_info';
@@ -128,6 +146,7 @@ export * from '../test/generated-wrappers/test_call_target';
 export * from '../test/generated-wrappers/test_curve';
 export * from '../test/generated-wrappers/test_delegate_caller';
 export * from '../test/generated-wrappers/test_fee_collector_controller';
+export * from '../test/generated-wrappers/test_fee_recipient';
 export * from '../test/generated-wrappers/test_fill_quote_transformer_bridge';
 export * from '../test/generated-wrappers/test_fill_quote_transformer_exchange';
 export * from '../test/generated-wrappers/test_fill_quote_transformer_host';
@@ -142,13 +161,17 @@ export * from '../test/generated-wrappers/test_meta_transactions_native_orders_f
 export * from '../test/generated-wrappers/test_meta_transactions_transform_erc20_feature';
 export * from '../test/generated-wrappers/test_migrator';
 export * from '../test/generated-wrappers/test_mint_token_erc20_transformer';
+export * from '../test/generated-wrappers/test_mintable_erc1155_token';
 export * from '../test/generated-wrappers/test_mintable_erc20_token';
+export * from '../test/generated-wrappers/test_mintable_erc721_token';
 export * from '../test/generated-wrappers/test_mooniswap';
+export * from '../test/generated-wrappers/test_n_f_t_order_presigner';
 export * from '../test/generated-wrappers/test_native_orders_feature';
 export * from '../test/generated-wrappers/test_no_eth_recipient';
 export * from '../test/generated-wrappers/test_order_signer_registry_with_contract_wallet';
 export * from '../test/generated-wrappers/test_permissionless_transformer_deployer_suicidal';
 export * from '../test/generated-wrappers/test_permissionless_transformer_deployer_transformer';
+export * from '../test/generated-wrappers/test_property_validator';
 export * from '../test/generated-wrappers/test_rfq_origin_registration';
 export * from '../test/generated-wrappers/test_simple_function_registry_feature_impl1';
 export * from '../test/generated-wrappers/test_simple_function_registry_feature_impl2';

contracts/zero-ex/tsconfig.json

@@ -42,11 +42,16 @@
         "test/generated-artifacts/BridgeAdapter.json",
         "test/generated-artifacts/BridgeProtocols.json",
         "test/generated-artifacts/CurveLiquidityProvider.json",
+        "test/generated-artifacts/ERC1155OrdersFeature.json",
+        "test/generated-artifacts/ERC165Feature.json",
+        "test/generated-artifacts/ERC721OrdersFeature.json",
         "test/generated-artifacts/FeeCollector.json",
         "test/generated-artifacts/FeeCollectorController.json",
         "test/generated-artifacts/FillQuoteTransformer.json",
         "test/generated-artifacts/FixinCommon.json",
         "test/generated-artifacts/FixinEIP712.json",
+        "test/generated-artifacts/FixinERC1155Spender.json",
+        "test/generated-artifacts/FixinERC721Spender.json",
         "test/generated-artifacts/FixinProtocolFees.json",
         "test/generated-artifacts/FixinReentrancyGuard.json",
         "test/generated-artifacts/FixinTokenSpender.json",
@@ -56,9 +61,15 @@
         "test/generated-artifacts/IBatchFillNativeOrdersFeature.json",
         "test/generated-artifacts/IBootstrapFeature.json",
         "test/generated-artifacts/IBridgeAdapter.json",
+        "test/generated-artifacts/IERC1155OrdersFeature.json",
+        "test/generated-artifacts/IERC1155Token.json",
+        "test/generated-artifacts/IERC165Feature.json",
         "test/generated-artifacts/IERC20Bridge.json",
         "test/generated-artifacts/IERC20Transformer.json",
+        "test/generated-artifacts/IERC721OrdersFeature.json",
+        "test/generated-artifacts/IERC721Token.json",
         "test/generated-artifacts/IFeature.json",
+        "test/generated-artifacts/IFeeRecipient.json",
         "test/generated-artifacts/IFlashWallet.json",
         "test/generated-artifacts/IFundRecoveryFeature.json",
         "test/generated-artifacts/ILiquidityProvider.json",
@@ -72,8 +83,10 @@
         "test/generated-artifacts/IOtcOrdersFeature.json",
         "test/generated-artifacts/IOwnableFeature.json",
         "test/generated-artifacts/IPancakeSwapFeature.json",
+        "test/generated-artifacts/IPropertyValidator.json",
         "test/generated-artifacts/ISimpleFunctionRegistryFeature.json",
         "test/generated-artifacts/IStaking.json",
+        "test/generated-artifacts/ITakerCallback.json",
         "test/generated-artifacts/ITestSimpleFunctionRegistryFeature.json",
         "test/generated-artifacts/ITokenSpenderFeature.json",
         "test/generated-artifacts/ITransformERC20Feature.json",
@@ -85,12 +98,16 @@
         "test/generated-artifacts/InitialMigration.json",
         "test/generated-artifacts/LibBootstrap.json",
         "test/generated-artifacts/LibCommonRichErrors.json",
+        "test/generated-artifacts/LibERC1155OrdersStorage.json",
         "test/generated-artifacts/LibERC20Transformer.json",
+        "test/generated-artifacts/LibERC721OrdersStorage.json",
         "test/generated-artifacts/LibFeeCollector.json",
         "test/generated-artifacts/LibLiquidityProviderRichErrors.json",
         "test/generated-artifacts/LibMetaTransactionsRichErrors.json",
         "test/generated-artifacts/LibMetaTransactionsStorage.json",
         "test/generated-artifacts/LibMigrate.json",
+        "test/generated-artifacts/LibNFTOrder.json",
+        "test/generated-artifacts/LibNFTOrdersRichErrors.json",
         "test/generated-artifacts/LibNativeOrder.json",
         "test/generated-artifacts/LibNativeOrdersRichErrors.json",
         "test/generated-artifacts/LibNativeOrdersStorage.json",
@@ -144,6 +161,7 @@
         "test/generated-artifacts/MultiplexTransformERC20.json",
         "test/generated-artifacts/MultiplexUniswapV2.json",
         "test/generated-artifacts/MultiplexUniswapV3.json",
+        "test/generated-artifacts/NFTOrders.json",
         "test/generated-artifacts/NativeOrdersCancellation.json",
         "test/generated-artifacts/NativeOrdersFeature.json",
         "test/generated-artifacts/NativeOrdersInfo.json",
@@ -161,6 +179,7 @@
         "test/generated-artifacts/TestCurve.json",
         "test/generated-artifacts/TestDelegateCaller.json",
         "test/generated-artifacts/TestFeeCollectorController.json",
+        "test/generated-artifacts/TestFeeRecipient.json",
         "test/generated-artifacts/TestFillQuoteTransformerBridge.json",
         "test/generated-artifacts/TestFillQuoteTransformerExchange.json",
         "test/generated-artifacts/TestFillQuoteTransformerHost.json",
@@ -175,13 +194,17 @@
         "test/generated-artifacts/TestMetaTransactionsTransformERC20Feature.json",
         "test/generated-artifacts/TestMigrator.json",
         "test/generated-artifacts/TestMintTokenERC20Transformer.json",
+        "test/generated-artifacts/TestMintableERC1155Token.json",
         "test/generated-artifacts/TestMintableERC20Token.json",
+        "test/generated-artifacts/TestMintableERC721Token.json",
         "test/generated-artifacts/TestMooniswap.json",
+        "test/generated-artifacts/TestNFTOrderPresigner.json",
         "test/generated-artifacts/TestNativeOrdersFeature.json",
         "test/generated-artifacts/TestNoEthRecipient.json",
         "test/generated-artifacts/TestOrderSignerRegistryWithContractWallet.json",
         "test/generated-artifacts/TestPermissionlessTransformerDeployerSuicidal.json",
         "test/generated-artifacts/TestPermissionlessTransformerDeployerTransformer.json",
+        "test/generated-artifacts/TestPropertyValidator.json",
         "test/generated-artifacts/TestRfqOriginRegistration.json",
         "test/generated-artifacts/TestSimpleFunctionRegistryFeatureImpl1.json",
         "test/generated-artifacts/TestSimpleFunctionRegistryFeatureImpl2.json",

package.json

@@ -46,7 +46,7 @@
         "test:generate_docs:circleci": "for i in ${npm_package_config_packagesWithDocPages}; do yarn generate_doc --package $i || break -1; done;",
         "bundlewatch": "bundlewatch",
         "lint": "wsrun --fast-exit --parallel --exclude-missing -p $PKG -c lint",
-        "upgrade_org_deps": "node node_modules/@0x/monorepo-scripts/lib/upgrade_deps.js -p '@0x/|ethereum-types'",
+        "upgrade_tools": "node node_modules/@0x/monorepo-scripts/lib/upgrade_deps.js -p '@0x/abi-gen|@0x/assert|@0x/base-contract|@0x/contracts-gen|@0x/dev-utils|@0x/json-schemas|@0x/monorepo-scripts|@0x/sol-compiler|@0x/sol-coverage|@0x/sol-doc|@0x/sol-profiler|@0x/sol-resolver|@0x/sol-trace|@0x/sol-tracing-utils|@0x/subproviders|@0x/tslint-config|@0x/types|@0x/typescript-typings|@0x/utils|@0x/verdaccio|@0x/web3-wrapper|ethereum-types'",
         "upgrade_deps": "node node_modules/@0x/monorepo-scripts/lib/upgrade_deps.js",
         "verdaccio": "docker run --rm -i -p 4873:4873 0xorg/verdaccio"
     },
@@ -60,7 +60,7 @@
         "ignoreDependencyVersionsForPackage": "contract-wrappers"
     },
     "devDependencies": {
-        "@0x/monorepo-scripts": "^3.2.0",
+        "@0x/monorepo-scripts": "^3.2.1",
         "@0x-lerna-fork/lerna": "3.16.10",
         "@0xproject/npm-cli-login": "^0.0.11",
         "async-child-process": "^1.1.1",

packages/asset-swapper/CHANGELOG.json

@@ -1,4 +1,88 @@
 [
+    {
+        "version": "16.46.0",
+        "changes": [
+            {
+                "note": "Enable `Curve` ETH/CVX pool",
+                "pr": 394
+            }
+        ],
+        "timestamp": 1641863395
+    },
+    {
+        "version": "16.45.2",
+        "changes": [
+            {
+                "note": "Handle 0 output samples and negative adjusted rate native orders in routing",
+                "pr": 387
+            }
+        ],
+        "timestamp": 1641827361
+    },
+    {
+        "version": "16.45.1",
+        "changes": [
+            {
+                "note": "Update `Celo` intermediate tokens",
+                "pr": 390
+            }
+        ],
+        "timestamp": 1641359319
+    },
+    {
+        "version": "16.45.0",
+        "changes": [
+            {
+                "note": "Capture router timings",
+                "pr": 388
+            }
+        ],
+        "timestamp": 1641308410
+    },
+    {
+        "version": "16.44.0",
+        "changes": [
+            {
+                "note": "Update neon-router and use router estimated output amount",
+                "pr": 354
+            }
+        ],
+        "timestamp": 1640778328
+    },
+    {
+        "version": "16.43.0",
+        "changes": [
+            {
+                "note": "`UniswapV3` support for `Optimism`",
+                "pr": 385
+            }
+        ],
+        "timestamp": 1640364306
+    },
+    {
+        "version": "16.42.0",
+        "changes": [
+            {
+                "note": "`UniswapV3` support for `Polygon`",
+                "pr": 382
+            },
+            {
+                "note": "Update `Beethoven` Graphql url",
+                "pr": 383
+            }
+        ],
+        "timestamp": 1640124159
+    },
+    {
+        "version": "16.41.0",
+        "changes": [
+            {
+                "note": "Update mcusd contract address, and made celo native asset",
+                "pr": 376
+            }
+        ],
+        "timestamp": 1638827302
+    },
     {
         "version": "16.40.0",
         "changes": [

packages/asset-swapper/CHANGELOG.md

@@ -5,6 +5,39 @@ Edit the package's CHANGELOG.json file only.
 
 CHANGELOG
 
+## v16.46.0 - _January 11, 2022_
+
+    * Enable `Curve` ETH/CVX pool (#394)
+
+## v16.45.2 - _January 10, 2022_
+
+    * Handle 0 output samples and negative adjusted rate native orders in routing (#387)
+
+## v16.45.1 - _January 5, 2022_
+
+    * Update `Celo` intermediate tokens (#390)
+
+## v16.45.0 - _January 4, 2022_
+
+    * Capture router timings (#388)
+
+## v16.44.0 - _December 29, 2021_
+
+    * Update neon-router and use router estimated output amount (#354)
+
+## v16.43.0 - _December 24, 2021_
+
+    * `UniswapV3` support for `Optimism` (#385)
+
+## v16.42.0 - _December 21, 2021_
+
+    * `UniswapV3` support for `Polygon` (#382)
+    * Update `Beethoven` Graphql url (#383)
+
+## v16.41.0 - _December 6, 2021_
+
+    * Update mcusd contract address, and made celo native asset (#376)
+
 ## v16.40.0 - _December 1, 2021_
 
     * Add `AaveV2` and `Compound` deposit/withdrawal liquidity source (#321)

packages/asset-swapper/contracts/src/UniswapV3Sampler.sol

@@ -51,7 +51,7 @@ interface IUniswapV3Pool {
 contract UniswapV3Sampler
 {
     /// @dev Gas limit for UniswapV3 calls. This is 100% a guess.
-    uint256 constant private QUOTE_GAS = 300e3;
+    uint256 constant private QUOTE_GAS = 600e3;
 
     /// @dev Sample sell quotes from UniswapV3.
     /// @param quoter UniswapV3 Quoter contract.

packages/asset-swapper/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@0x/asset-swapper",
-    "version": "16.40.0",
+    "version": "16.46.0",
     "engines": {
         "node": ">=6.12"
     },
@@ -58,21 +58,21 @@
         "registry": "git@github.com:0xProject/gitpkg-registry.git"
     },
     "dependencies": {
-        "@0x/assert": "^3.0.29",
-        "@0x/base-contract": "^6.4.2",
-        "@0x/contract-addresses": "^6.10.0",
-        "@0x/contract-wrappers": "^13.18.4",
-        "@0x/contracts-erc20": "^3.3.24",
-        "@0x/contracts-zero-ex": "^0.30.0",
-        "@0x/dev-utils": "^4.2.9",
-        "@0x/json-schemas": "^6.3.0",
-        "@0x/neon-router": "^0.2.1",
-        "@0x/protocol-utils": "^1.10.0",
+        "@0x/assert": "^3.0.31",
+        "@0x/base-contract": "^6.4.5",
+        "@0x/contract-addresses": "^6.11.0",
+        "@0x/contract-wrappers": "^13.18.5",
+        "@0x/contracts-erc20": "^3.3.25",
+        "@0x/contracts-zero-ex": "^0.30.1",
+        "@0x/dev-utils": "^4.2.11",
+        "@0x/json-schemas": "^6.4.1",
+        "@0x/neon-router": "^0.3.1",
+        "@0x/protocol-utils": "^1.10.1",
         "@0x/quote-server": "^6.0.6",
         "@0x/types": "^3.3.4",
         "@0x/typescript-typings": "^5.2.1",
-        "@0x/utils": "^6.4.4",
-        "@0x/web3-wrapper": "^7.6.0",
+        "@0x/utils": "^6.5.0",
+        "@0x/web3-wrapper": "^7.6.2",
         "@balancer-labs/sor": "0.3.2",
         "@bancor/sdk": "0.2.9",
         "@ethersproject/abi": "^5.0.1",
@@ -93,17 +93,17 @@
         "lodash": "^4.17.11"
     },
     "devDependencies": {
-        "@0x/abi-gen": "^5.6.2",
+        "@0x/abi-gen": "^5.7.2",
         "@0x/contracts-asset-proxy": "^3.7.19",
         "@0x/contracts-exchange": "^3.2.38",
         "@0x/contracts-exchange-libs": "^4.3.37",
-        "@0x/contracts-gen": "^2.0.40",
-        "@0x/contracts-test-utils": "^5.4.15",
-        "@0x/contracts-utils": "^4.8.5",
+        "@0x/contracts-gen": "^2.0.43",
+        "@0x/contracts-test-utils": "^5.4.16",
+        "@0x/contracts-utils": "^4.8.6",
         "@0x/mesh-rpc-client": "^9.4.2",
-        "@0x/migrations": "^8.1.13",
-        "@0x/sol-compiler": "^4.7.5",
-        "@0x/subproviders": "^6.6.0",
+        "@0x/migrations": "^8.1.14",
+        "@0x/sol-compiler": "^4.7.8",
+        "@0x/subproviders": "^6.6.2",
         "@0x/ts-doc-gen": "^0.0.28",
         "@0x/tslint-config": "^4.1.4",
         "@0x/types": "^3.3.4",

packages/asset-swapper/src/utils/alt_mm_implementation_utils.ts

@@ -223,7 +223,17 @@ export async function returnQuoteFromAltMMAsync<ResponseT>(
             cancelToken,
         })
         .catch(err => {
-            warningLogger(err, `Alt RFQ MM request failed`);
+            if (err.response) {
+                // request was made and market maker responded
+                warningLogger(
+                    { data: err.response.data, status: err.response.status, headers: err.response.headers },
+                    `Alt RFQ MM request failed`,
+                );
+            } else if (err.request) {
+                warningLogger({}, 'Alt RFQ MM no response received');
+            } else {
+                warningLogger({ err: err.message }, 'Failed to construct Alt RFQ MM request');
+            }
             throw new Error(`Alt RFQ MM request failed`);
         });
 

packages/asset-swapper/src/utils/market_operation_utils/constants.ts

@@ -61,6 +61,7 @@ function valueByChainId<T>(rest: Partial<{ [key in ChainId]: T }>, defaultValue:
         [ChainId.Avalanche]: defaultValue,
         [ChainId.Fantom]: defaultValue,
         [ChainId.Celo]: defaultValue,
+        [ChainId.Optimism]: defaultValue,
         ...(rest || {}),
     };
 }
@@ -165,6 +166,7 @@ export const SELL_SOURCE_FILTER_BY_CHAIN_ID = valueByChainId<SourceFilters>(
             ERC20BridgeSource.JetSwap,
             ERC20BridgeSource.IronSwap,
             ERC20BridgeSource.AaveV2,
+            ERC20BridgeSource.UniswapV3,
         ]),
         [ChainId.Avalanche]: new SourceFilters([
             ERC20BridgeSource.MultiHop,
@@ -192,6 +194,7 @@ export const SELL_SOURCE_FILTER_BY_CHAIN_ID = valueByChainId<SourceFilters>(
             ERC20BridgeSource.SushiSwap,
             ERC20BridgeSource.MultiHop,
         ]),
+        [ChainId.Optimism]: new SourceFilters([ERC20BridgeSource.UniswapV3]),
     },
     new SourceFilters([]),
 );
@@ -296,6 +299,7 @@ export const BUY_SOURCE_FILTER_BY_CHAIN_ID = valueByChainId<SourceFilters>(
             ERC20BridgeSource.JetSwap,
             ERC20BridgeSource.IronSwap,
             ERC20BridgeSource.AaveV2,
+            ERC20BridgeSource.UniswapV3,
         ]),
         [ChainId.Avalanche]: new SourceFilters([
             ERC20BridgeSource.MultiHop,
@@ -323,6 +327,7 @@ export const BUY_SOURCE_FILTER_BY_CHAIN_ID = valueByChainId<SourceFilters>(
             ERC20BridgeSource.SushiSwap,
             ERC20BridgeSource.MultiHop,
         ]),
+        [ChainId.Optimism]: new SourceFilters([ERC20BridgeSource.UniswapV3]),
     },
     new SourceFilters([]),
 );
@@ -340,10 +345,11 @@ export const FEE_QUOTE_SOURCES_BY_CHAIN_ID = valueByChainId<ERC20BridgeSource[]>
         [ChainId.Mainnet]: [ERC20BridgeSource.UniswapV2, ERC20BridgeSource.SushiSwap, ERC20BridgeSource.UniswapV3],
         [ChainId.BSC]: [ERC20BridgeSource.PancakeSwap, ERC20BridgeSource.Mooniswap, ERC20BridgeSource.SushiSwap],
         [ChainId.Ropsten]: [ERC20BridgeSource.UniswapV2, ERC20BridgeSource.SushiSwap],
-        [ChainId.Polygon]: [ERC20BridgeSource.QuickSwap, ERC20BridgeSource.SushiSwap],
+        [ChainId.Polygon]: [ERC20BridgeSource.QuickSwap, ERC20BridgeSource.SushiSwap, ERC20BridgeSource.UniswapV3],
         [ChainId.Avalanche]: [ERC20BridgeSource.Pangolin, ERC20BridgeSource.TraderJoe, ERC20BridgeSource.SushiSwap],
         [ChainId.Fantom]: [ERC20BridgeSource.SpiritSwap, ERC20BridgeSource.SpookySwap, ERC20BridgeSource.SushiSwap],
         [ChainId.Celo]: [ERC20BridgeSource.UbeSwap, ERC20BridgeSource.SushiSwap],
+        [ChainId.Optimism]: [ERC20BridgeSource.UniswapV3],
     },
     [],
 );
@@ -456,6 +462,7 @@ export const MAINNET_TOKENS = {
     CRV: '0xd533a949740bb3306d119cc777fa900ba034cd52',
     MIM: '0x99d8a9c45b2eca8864373a26d1459e3dff1e17f3',
     EURT: '0xc581b735a1688071a1746c968e0798d642ede491',
+    CVX: '0x4e3fbd56cd56c3e72c1403e103b45db9da5b9d2b',
 };
 
 export const BSC_TOKENS = {
@@ -504,9 +511,23 @@ export const AVALANCHE_TOKENS = {
 };
 
 export const CELO_TOKENS = {
-    WETH: '0xe919f65739c26a42616b7b8eedc6b5524d1e3ac4',
-    CELO: '0x471ece3750da237f93b8e339c536989b8978a438',
-    mCUSD: '0x64defa3544c695db8c535d289d843a189aa26b98',
+    WCELO: '0x471ece3750da237f93b8e339c536989b8978a438',
+    // Some of these tokens are Optics bridge? tokens which
+    // had an issue and migrated from v1 to v2
+    WETHv1: '0xe919f65739c26a42616b7b8eedc6b5524d1e3ac4',
+    WETH: '0x122013fd7df1c6f636a5bb8f03108e876548b455',
+    WBTC: '0xbaab46e28388d2779e6e31fd00cf0e5ad95e327b',
+    cUSD: '0x765de816845861e75a25fca122bb6898b8b1282a',
+    // ??
+    WBTCv1: '0xd629eb00deced2a080b7ec630ef6ac117e614f1b',
+    cETH: '0x2def4285787d58a2f811af24755a8150622f4361',
+    UBE: '0x00be915b9dcf56a3cbe739d9b9c202ca692409ec',
+    // Moolah
+    mCELO: '0x7d00cd74ff385c955ea3d79e47bf06bd7386387d',
+    mCUSD: '0x918146359264c492bd6934071c6bd31c854edbc3',
+    mCEUR: '0xe273ad7ee11dcfaa87383ad5977ee1504ac07568',
+    amCUSD: '0x64defa3544c695db8c535d289d843a189aa26b98',
+    MOO: '0x17700282592d6917f6a73d0bf8accf4d578c131e',
 };
 
 export const FANTOM_TOKENS = {
@@ -519,6 +540,14 @@ export const FANTOM_TOKENS = {
     renBTC: '0xdbf31df14b66535af65aac99c32e9ea844e14501',
 };
 
+export const OPTIMISM_TOKENS = {
+    WETH: '0x4200000000000000000000000000000000000006',
+    USDC: '0x7f5c764cbc14f9669b88837ca1490cca17c31607',
+    USDT: '0x94b008aa00579c1307b0ef2c499ad98a8ce58e58',
+    DAI: '0xda10009cbd5d07dd0cecc66161fc93d7c9000da1',
+    WBTC: '0x68f180fcce6836688e9084f035309e29bf0a2095',
+};
+
 export const CURVE_POOLS = {
     compound: '0xa2b47e3d5c44877cca798226b7b8118f9bfb7a56', // 0.Compound
     // 1.USDT is dead
@@ -564,6 +593,7 @@ export const CURVE_POOLS = {
     mim: '0x5a6a4d54456819380173272a5e8e9b9904bdf41b',
     eurt: '0xfd5db7463a3ab53fd211b4af195c5bccc1a03890',
     ethcrv: '0x8301ae4fc9c624d1d396cbdaa1ed877821d7c511',
+    ethcvx: '0xb576491f1e6e5e62f1d8f26062ee822b40b0e0d4',
 };
 
 export const CURVE_V2_POOLS = {
@@ -699,7 +729,8 @@ export const DEFAULT_INTERMEDIATE_TOKENS_BY_CHAIN_ID = valueByChainId<string[]>(
             AVALANCHE_TOKENS.USDC,
         ],
         [ChainId.Fantom]: [FANTOM_TOKENS.WFTM, FANTOM_TOKENS.WETH, FANTOM_TOKENS.DAI, FANTOM_TOKENS.USDC],
-        [ChainId.Celo]: [CELO_TOKENS.mCUSD, CELO_TOKENS.WETH, CELO_TOKENS.CELO],
+        [ChainId.Celo]: [CELO_TOKENS.WCELO, CELO_TOKENS.mCUSD, CELO_TOKENS.WETH, CELO_TOKENS.amCUSD, CELO_TOKENS.WBTC],
+        [ChainId.Optimism]: [OPTIMISM_TOKENS.WETH, OPTIMISM_TOKENS.DAI, OPTIMISM_TOKENS.USDC],
     },
     [],
 );
@@ -739,6 +770,9 @@ export const DEFAULT_TOKEN_ADJACENCY_GRAPH_BY_CHAIN_ID = valueByChainId<TokenAdj
         [ChainId.Celo]: new TokenAdjacencyGraphBuilder({
             default: DEFAULT_INTERMEDIATE_TOKENS_BY_CHAIN_ID[ChainId.Celo],
         }).build(),
+        [ChainId.Optimism]: new TokenAdjacencyGraphBuilder({
+            default: DEFAULT_INTERMEDIATE_TOKENS_BY_CHAIN_ID[ChainId.Optimism],
+        }).build(),
     },
     new TokenAdjacencyGraphBuilder({ default: [] }).build(),
 );
@@ -755,6 +789,7 @@ export const NATIVE_FEE_TOKEN_BY_CHAIN_ID = valueByChainId<string>(
         [ChainId.Avalanche]: getContractAddressesForChainOrThrow(ChainId.Avalanche).etherToken,
         [ChainId.Fantom]: getContractAddressesForChainOrThrow(ChainId.Fantom).etherToken,
         [ChainId.Celo]: getContractAddressesForChainOrThrow(ChainId.Celo).etherToken,
+        [ChainId.Optimism]: getContractAddressesForChainOrThrow(ChainId.Optimism).etherToken,
     },
     NULL_ADDRESS,
 );
@@ -1040,6 +1075,17 @@ export const CURVE_MAINNET_INFOS: { [name: string]: CurveInfo } = {
         sellQuoteFunctionSelector: CurveFunctionSelectors.get_dy_uint256,
         exchangeFunctionSelector: CurveFunctionSelectors.exchange_underlying_uint256,
     },
+    [CURVE_POOLS.ethcvx]: {
+        ...createCurveExchangePool({
+            // This pool uses ETH
+            tokens: [MAINNET_TOKENS.WETH, MAINNET_TOKENS.CVX],
+            pool: CURVE_POOLS.ethcvx,
+            gasSchedule: 350e3,
+        }),
+        // This pool has a custom get_dy and exchange selector with uint256
+        sellQuoteFunctionSelector: CurveFunctionSelectors.get_dy_uint256,
+        exchangeFunctionSelector: CurveFunctionSelectors.exchange_underlying_uint256,
+    },
 };
 
 export const CURVE_V2_MAINNET_INFOS: { [name: string]: CurveInfo } = {
@@ -1693,9 +1739,9 @@ export const BALANCER_V2_SUBGRAPH_URL_BY_CHAIN = valueByChainId<string>(
 
 export const BEETHOVEN_X_SUBGRAPH_URL_BY_CHAIN = valueByChainId<string>(
     {
-        [ChainId.Fantom]: 'https://graph-node.beets-ftm-node.com/subgraphs/name/beethovenx-v4',
+        [ChainId.Fantom]: 'https://graph-node.beets-ftm-node.com/subgraphs/name/beethovenx',
     },
-    'https://graph-node.beets-ftm-node.com/subgraphs/name/beethovenx-v4',
+    'https://graph-node.beets-ftm-node.com/subgraphs/name/beethovenx',
 );
 
 export const UNISWAPV3_CONFIG_BY_CHAIN_ID = valueByChainId(
@@ -1708,6 +1754,14 @@ export const UNISWAPV3_CONFIG_BY_CHAIN_ID = valueByChainId(
             quoter: '0x2f9e608fd881861b8916257b76613cb22ee0652c',
             router: '0x03782388516e94fcd4c18666303601a12aa729ea',
         },
+        [ChainId.Polygon]: {
+            quoter: '0xb27308f9f90d607463bb33ea1bebb41c27ce5ab6',
+            router: '0xe592427a0aece92de3edee1f18e0157c05861564',
+        },
+        [ChainId.Optimism]: {
+            quoter: '0xb27308f9f90d607463bb33ea1bebb41c27ce5ab6',
+            router: '0xe592427a0aece92de3edee1f18e0157c05861564',
+        },
     },
     { quoter: NULL_ADDRESS, router: NULL_ADDRESS },
 );
@@ -2076,4 +2130,5 @@ export const DEFAULT_GET_MARKET_ORDERS_OPTS: Omit<GetMarketOrdersOpts, 'gasPrice
     shouldGenerateQuoteReport: true,
     shouldIncludePriceComparisonsReport: false,
     tokenAdjacencyGraph: { default: [] },
+    neonRouterNumSamples: 14,
 };

packages/asset-swapper/src/utils/market_operation_utils/index.ts

@@ -443,6 +443,7 @@ export class MarketOperationUtils {
                             feeSchedule: _opts.feeSchedule,
                             allowFallback: _opts.allowFallback,
                             gasPrice: _opts.gasPrice,
+                            neonRouterNumSamples: _opts.neonRouterNumSamples,
                         },
                     );
                     return optimizerResult;
@@ -531,9 +532,18 @@ export class MarketOperationUtils {
                 penaltyOpts,
                 opts.feeSchedule,
                 this._sampler.chainId,
+                opts.neonRouterNumSamples,
+                opts.samplerMetrics,
             );
         } else {
-            optimalPath = await findOptimalPathJSAsync(side, fills, inputAmount, opts.runLimit, penaltyOpts);
+            optimalPath = await findOptimalPathJSAsync(
+                side,
+                fills,
+                inputAmount,
+                opts.runLimit,
+                opts.samplerMetrics,
+                penaltyOpts,
+            );
         }
 
         const optimalPathRate = optimalPath ? optimalPath.adjustedRate() : ZERO_AMOUNT;
@@ -596,6 +606,8 @@ export class MarketOperationUtils {
             allowFallback: _opts.allowFallback,
             exchangeProxyOverhead: _opts.exchangeProxyOverhead,
             gasPrice: _opts.gasPrice,
+            neonRouterNumSamples: _opts.neonRouterNumSamples,
+            samplerMetrics: _opts.samplerMetrics,
         };
 
         if (nativeOrders.length === 0) {
@@ -806,6 +818,8 @@ export class MarketOperationUtils {
                     sturdyPenaltyOpts,
                     opts.feeSchedule,
                     this._sampler.chainId,
+                    opts.neonRouterNumSamples,
+                    undefined, // hack: set sampler metrics to undefined to avoid fallback timings
                 );
             } else {
                 const sturdyFills = fills.filter(p => p.length > 0 && !fragileSources.includes(p[0].source));
@@ -814,6 +828,7 @@ export class MarketOperationUtils {
                     sturdyFills,
                     inputAmount,
                     opts.runLimit,
+                    undefined, // hack: set sampler metrics to undefined to avoid fallback timings
                     sturdyPenaltyOpts,
                 );
             }

packages/asset-swapper/src/utils/market_operation_utils/path_optimizer.ts

@@ -1,23 +1,21 @@
 import { assert } from '@0x/assert';
 import { ChainId } from '@0x/contract-addresses';
 import { OptimizerCapture, route, SerializedPath } from '@0x/neon-router';
-import { BigNumber } from '@0x/utils';
+import { BigNumber, hexUtils } from '@0x/utils';
 import * as _ from 'lodash';
 import { performance } from 'perf_hooks';
 
-import { DEFAULT_INFO_LOGGER } from '../../constants';
 import { MarketOperation, NativeOrderWithFillableAmounts } from '../../types';
 import { VIP_ERC20_BRIDGE_SOURCES_BY_CHAIN_ID } from '../market_operation_utils/constants';
 
 import { dexSamplesToFills, ethToOutputAmount, nativeOrdersToFills } from './fills';
 import { DEFAULT_PATH_PENALTY_OPTS, Path, PathPenaltyOpts } from './path';
 import { getRate } from './rate_utils';
-import { DexSample, ERC20BridgeSource, FeeSchedule, Fill, FillData } from './types';
+import { DexSample, ERC20BridgeSource, FeeSchedule, Fill, FillData, SamplerMetrics } from './types';
 
 // tslint:disable: prefer-for-of custom-no-magic-numbers completed-docs no-bitwise
 
 const RUN_LIMIT_DECAY_FACTOR = 0.5;
-const RUST_ROUTER_NUM_SAMPLES = 200;
 const FILL_QUOTE_TRANSFORMER_GAS_OVERHEAD = new BigNumber(150e3);
 // NOTE: The Rust router will panic with less than 3 samples
 const MIN_NUM_SAMPLE_INPUTS = 3;
@@ -69,21 +67,6 @@ function calculateOuputFee(
     }
 }
 
-// Use linear interpolation to approximate the output
-// at a certain input somewhere between the two samples
-// See https://en.wikipedia.org/wiki/Linear_interpolation
-const interpolateOutputFromSamples = (
-    left: { input: BigNumber; output: BigNumber },
-    right: { input: BigNumber; output: BigNumber },
-    targetInput: BigNumber,
-): BigNumber =>
-    left.output.plus(
-        right.output
-            .minus(left.output)
-            .dividedBy(right.input.minus(left.input))
-            .times(targetInput.minus(left.input)),
-    );
-
 function findRoutesAndCreateOptimalPath(
     side: MarketOperation,
     samples: DexSample[][],
@@ -91,29 +74,27 @@ function findRoutesAndCreateOptimalPath(
     input: BigNumber,
     opts: PathPenaltyOpts,
     fees: FeeSchedule,
+    neonRouterNumSamples: number,
 ): Path | undefined {
-    const createFill = (sample: DexSample) =>
-        dexSamplesToFills(side, [sample], opts.outputAmountPerEth, opts.inputAmountPerEth, fees)[0];
-    // Track sample id's to integers (required by rust router)
-    const sampleIdLookup: { [key: string]: number } = {};
-    let sampleIdCounter = 0;
-    const sampleToId = (source: ERC20BridgeSource, index: number): number => {
-        const key = `${source}-${index}`;
-        if (sampleIdLookup[key]) {
-            return sampleIdLookup[key];
-        } else {
-            sampleIdLookup[key] = ++sampleIdCounter;
-            return sampleIdLookup[key];
+    const createFill = (sample: DexSample): Fill | undefined => {
+        const fills = dexSamplesToFills(side, [sample], opts.outputAmountPerEth, opts.inputAmountPerEth, fees);
+        // NOTE: If the sample has 0 output dexSamplesToFills will return [] because no fill can be created
+        if (fills.length === 0) {
+            return undefined;
         }
+
+        return fills[0];
     };
 
     const samplesAndNativeOrdersWithResults: Array<DexSample[] | NativeOrderWithFillableAmounts[]> = [];
     const serializedPaths: SerializedPath[] = [];
+    const sampleSourcePathIds: string[] = [];
     for (const singleSourceSamples of samples) {
         if (singleSourceSamples.length === 0) {
             continue;
         }
 
+        const sourcePathId = hexUtils.random();
         const singleSourceSamplesWithOutput = [...singleSourceSamples];
         for (let i = singleSourceSamples.length - 1; i >= 0; i--) {
             if (singleSourceSamples[i].output.isZero()) {
@@ -131,7 +112,7 @@ function findRoutesAndCreateOptimalPath(
         // TODO(kimpers): Do we need to handle 0 entries, from eg Kyber?
         const serializedPath = singleSourceSamplesWithOutput.reduce<SerializedPath>(
             (memo, sample, sampleIdx) => {
-                memo.ids.push(sampleToId(sample.source, sampleIdx));
+                memo.ids.push(`${sample.source}-${serializedPaths.length}-${sampleIdx}`);
                 memo.inputs.push(sample.input.integerValue().toNumber());
                 memo.outputs.push(sample.output.integerValue().toNumber());
                 memo.outputFees.push(
@@ -152,8 +133,10 @@ function findRoutesAndCreateOptimalPath(
 
         samplesAndNativeOrdersWithResults.push(singleSourceSamplesWithOutput);
         serializedPaths.push(serializedPath);
+        sampleSourcePathIds.push(sourcePathId);
     }
 
+    const nativeOrdersourcePathId = hexUtils.random();
     for (const [idx, nativeOrder] of nativeOrders.entries()) {
         const { input: normalizedOrderInput, output: normalizedOrderOutput } = nativeOrderToNormalizedAmounts(
             side,
@@ -164,32 +147,25 @@ function findRoutesAndCreateOptimalPath(
         if (normalizedOrderInput.isLessThanOrEqualTo(0) || normalizedOrderOutput.isLessThanOrEqualTo(0)) {
             continue;
         }
-
-        // HACK: the router requires at minimum 3 samples as a basis for interpolation
-        const inputs = [
-            0,
-            normalizedOrderInput
-                .dividedBy(2)
-                .integerValue()
-                .toNumber(),
-            normalizedOrderInput.integerValue().toNumber(),
-        ];
-        const outputs = [
-            0,
-            normalizedOrderOutput
-                .dividedBy(2)
-                .integerValue()
-                .toNumber(),
-            normalizedOrderOutput.integerValue().toNumber(),
-        ];
-        // NOTE: same fee no matter if full or partial fill
         const fee = calculateOuputFee(side, nativeOrder, opts.outputAmountPerEth, opts.inputAmountPerEth, fees)
             .integerValue()
             .toNumber();
-        const outputFees = [fee, fee, fee];
-        // NOTE: ids can be the same for all fake samples
-        const id = sampleToId(ERC20BridgeSource.Native, idx);
-        const ids = [id, id, id];
+
+        // HACK: due to an issue with the Rust router interpolation we need to create exactly 13 samples from the native order
+        const ids = [];
+        const inputs = [];
+        const outputs = [];
+        const outputFees = [];
+        for (let i = 1; i <= 13; i++) {
+            const fraction = i / 13;
+            const currentInput = BigNumber.min(normalizedOrderInput.times(fraction), normalizedOrderInput);
+            const currentOutput = BigNumber.min(normalizedOrderOutput.times(fraction), normalizedOrderOutput);
+            const id = `${ERC20BridgeSource.Native}-${serializedPaths.length}-${idx}-${i}`;
+            inputs.push(currentInput.integerValue().toNumber());
+            outputs.push(currentOutput.integerValue().toNumber());
+            outputFees.push(fee);
+            ids.push(id);
+        }
 
         const serializedPath: SerializedPath = {
             ids,
@@ -200,6 +176,7 @@ function findRoutesAndCreateOptimalPath(
 
         samplesAndNativeOrdersWithResults.push([nativeOrder]);
         serializedPaths.push(serializedPath);
+        sampleSourcePathIds.push(nativeOrdersourcePathId);
     }
 
     if (serializedPaths.length === 0) {
@@ -212,30 +189,33 @@ function findRoutesAndCreateOptimalPath(
         pathsIn: serializedPaths,
     };
 
-    const before = performance.now();
     const allSourcesRustRoute = new Float64Array(rustArgs.pathsIn.length);
-    route(rustArgs, allSourcesRustRoute, RUST_ROUTER_NUM_SAMPLES);
-    DEFAULT_INFO_LOGGER(
-        { router: 'neon-router', performanceMs: performance.now() - before, type: 'real' },
-        'Rust router real routing performance',
-    );
-
+    const strategySourcesOutputAmounts = new Float64Array(rustArgs.pathsIn.length);
+    route(rustArgs, allSourcesRustRoute, strategySourcesOutputAmounts, neonRouterNumSamples);
     assert.assert(
         rustArgs.pathsIn.length === allSourcesRustRoute.length,
         'different number of sources in the Router output than the input',
     );
+    assert.assert(
+        rustArgs.pathsIn.length === strategySourcesOutputAmounts.length,
+        'different number of sources in the Router output amounts results than the input',
+    );
 
-    const routesAndSamples = _.zip(allSourcesRustRoute, samplesAndNativeOrdersWithResults);
-
+    const routesAndSamplesAndOutputs = _.zip(
+        allSourcesRustRoute,
+        samplesAndNativeOrdersWithResults,
+        strategySourcesOutputAmounts,
+        sampleSourcePathIds,
+    );
     const adjustedFills: Fill[] = [];
     const totalRoutedAmount = BigNumber.sum(...allSourcesRustRoute);
 
     const scale = input.dividedBy(totalRoutedAmount);
-    for (const [routeInput, routeSamplesAndNativeOrders] of routesAndSamples) {
-        if (!routeInput || !routeSamplesAndNativeOrders) {
+    for (const [routeInput, routeSamplesAndNativeOrders, outputAmount, sourcePathId] of routesAndSamplesAndOutputs) {
+        if (!routeInput || !routeSamplesAndNativeOrders || !outputAmount || !Number.isFinite(outputAmount)) {
             continue;
         }
-        // TODO(kimpers): [TKR-241] amounts are sometimes clipped in the router due to precisions loss for number/f64
+        // TODO(kimpers): [TKR-241] amounts are sometimes clipped in the router due to precision loss for number/f64
         // we can work around it by scaling it and rounding up. However now we end up with a total amount of a couple base units too much
         const rustInputAdjusted = BigNumber.min(
             new BigNumber(routeInput).multipliedBy(scale).integerValue(BigNumber.ROUND_CEIL),
@@ -251,14 +231,21 @@ function findRoutesAndCreateOptimalPath(
                 opts.outputAmountPerEth,
                 opts.inputAmountPerEth,
                 fees,
-            )[0];
-            // NOTE: For Limit/RFQ orders we are done here. No need to scale output
-            adjustedFills.push(nativeFill);
+            )[0] as Fill | undefined;
+            // Note: If the order has an adjusted rate of less than or equal to 0 it will be skipped
+            // and nativeFill will be `undefined`
+            if (nativeFill) {
+                // NOTE: For Limit/RFQ orders we are done here. No need to scale output
+                adjustedFills.push({ ...nativeFill, sourcePathId: sourcePathId ?? hexUtils.random() });
+            }
             continue;
         }
 
         // NOTE: For DexSamples only
         let fill = createFill(current);
+        if (!fill) {
+            continue;
+        }
         const routeSamples = routeSamplesAndNativeOrders as Array<DexSample<FillData>>;
         // Descend to approach a closer fill for fillData which may not be consistent
         // throughout the path (UniswapV3) and for a closer guesstimate at
@@ -267,49 +254,47 @@ function findRoutesAndCreateOptimalPath(
         assert.assert(routeSamples.length >= 1, 'Found no sample to use for source');
         for (let k = routeSamples.length - 1; k >= 0; k--) {
             if (k === 0) {
-                fill = createFill(routeSamples[0]);
+                fill = createFill(routeSamples[0]) ?? fill;
             }
             if (rustInputAdjusted.isGreaterThan(routeSamples[k].input)) {
-                // Between here and the previous fill
-                // HACK: Use the midpoint between the two
                 const left = routeSamples[k];
                 const right = routeSamples[k + 1];
                 if (left && right) {
-                    // Approximate how much output we get for the input with the surrounding samples
-                    const interpolatedOutput = interpolateOutputFromSamples(
-                        left,
-                        right,
-                        rustInputAdjusted,
-                    ).decimalPlaces(0, side === MarketOperation.Sell ? BigNumber.ROUND_FLOOR : BigNumber.ROUND_CEIL);
-
-                    fill = createFill({
-                        ...right, // default to the greater (for gas used)
-                        input: rustInputAdjusted,
-                        output: interpolatedOutput,
-                    });
+                    fill =
+                        createFill({
+                            ...right, // default to the greater (for gas used)
+                            input: rustInputAdjusted,
+                            output: new BigNumber(outputAmount),
+                        }) ?? fill;
                 } else {
                     assert.assert(Boolean(left || right), 'No valid sample to use');
-                    fill = createFill(left || right);
+                    fill = createFill(left || right) ?? fill;
                 }
                 break;
             }
         }
 
-        const scaleOutput = (output: BigNumber) =>
+        // TODO(kimpers): remove once we have solved the rounding/precision loss issues in the Rust router
+        const scaleOutput = (fillInput: BigNumber, output: BigNumber) =>
             output
-                .dividedBy(fill.input)
+                .dividedBy(fillInput)
                 .times(rustInputAdjusted)
                 .decimalPlaces(0, side === MarketOperation.Sell ? BigNumber.ROUND_FLOOR : BigNumber.ROUND_CEIL);
         adjustedFills.push({
             ...fill,
             input: rustInputAdjusted,
-            output: scaleOutput(fill.output),
-            adjustedOutput: scaleOutput(fill.adjustedOutput),
+            output: scaleOutput(fill.input, fill.output),
+            adjustedOutput: scaleOutput(fill.input, fill.adjustedOutput),
             index: 0,
             parent: undefined,
+            sourcePathId: sourcePathId ?? hexUtils.random(),
         });
     }
 
+    if (adjustedFills.length === 0) {
+        return undefined;
+    }
+
     const pathFromRustInputs = Path.create(side, adjustedFills, input);
 
     return pathFromRustInputs;
@@ -323,15 +308,27 @@ export function findOptimalRustPathFromSamples(
     opts: PathPenaltyOpts,
     fees: FeeSchedule,
     chainId: ChainId,
+    neonRouterNumSamples: number,
+    samplerMetrics?: SamplerMetrics,
 ): Path | undefined {
-    const before = performance.now();
-    const logPerformance = () =>
-        DEFAULT_INFO_LOGGER(
-            { router: 'neon-router', performanceMs: performance.now() - before, type: 'total' },
-            'Rust router total routing performance',
-        );
-
-    const allSourcesPath = findRoutesAndCreateOptimalPath(side, samples, nativeOrders, input, opts, fees);
+    const beforeAllTimeMs = performance.now();
+    let beforeTimeMs = performance.now();
+    const allSourcesPath = findRoutesAndCreateOptimalPath(
+        side,
+        samples,
+        nativeOrders,
+        input,
+        opts,
+        fees,
+        neonRouterNumSamples,
+    );
+    // tslint:disable-next-line: no-unused-expression
+    samplerMetrics &&
+        samplerMetrics.logRouterDetails({
+            router: 'neon-router',
+            type: 'all',
+            timingMs: performance.now() - beforeTimeMs,
+        });
     if (!allSourcesPath) {
         return undefined;
     }
@@ -341,11 +338,27 @@ export function findOptimalRustPathFromSamples(
     // HACK(kimpers): The Rust router currently doesn't account for VIP sources correctly
     // we need to try to route them in isolation and compare with the results all sources
     if (vipSources.length > 0) {
+        beforeTimeMs = performance.now();
         const vipSourcesSet = new Set(vipSources);
         const vipSourcesSamples = samples.filter(s => s[0] && vipSourcesSet.has(s[0].source));
 
         if (vipSourcesSamples.length > 0) {
-            const vipSourcesPath = findRoutesAndCreateOptimalPath(side, vipSourcesSamples, [], input, opts, fees);
+            const vipSourcesPath = findRoutesAndCreateOptimalPath(
+                side,
+                vipSourcesSamples,
+                [],
+                input,
+                opts,
+                fees,
+                neonRouterNumSamples,
+            );
+            // tslint:disable-next-line: no-unused-expression
+            samplerMetrics &&
+                samplerMetrics.logRouterDetails({
+                    router: 'neon-router',
+                    type: 'vip',
+                    timingMs: performance.now() - beforeTimeMs,
+                });
 
             const { input: allSourcesInput, output: allSourcesOutput } = allSourcesPath.adjustedSize();
             // NOTE: For sell quotes input is the taker asset and for buy quotes input is the maker asset
@@ -358,13 +371,18 @@ export function findOptimalRustPathFromSamples(
             const allSourcesAdjustedRateWithFqtOverhead = getRate(side, allSourcesInput, outputWithFqtOverhead);
 
             if (vipSourcesPath?.adjustedRate().isGreaterThan(allSourcesAdjustedRateWithFqtOverhead)) {
-                logPerformance();
                 return vipSourcesPath;
             }
         }
     }
+    // tslint:disable-next-line: no-unused-expression
+    samplerMetrics &&
+        samplerMetrics.logRouterDetails({
+            router: 'neon-router',
+            type: 'total',
+            timingMs: performance.now() - beforeAllTimeMs,
+        });
 
-    logPerformance();
     return allSourcesPath;
 }
 
@@ -377,8 +395,10 @@ export async function findOptimalPathJSAsync(
     fills: Fill[][],
     targetInput: BigNumber,
     runLimit: number = 2 ** 8,
+    samplerMetrics?: SamplerMetrics,
     opts: PathPenaltyOpts = DEFAULT_PATH_PENALTY_OPTS,
 ): Promise<Path | undefined> {
+    const beforeTimeMs = performance.now();
     // Sort fill arrays by descending adjusted completed rate.
     // Remove any paths which cannot impact the optimal path
     const sortedPaths = reducePaths(fillsToSortedPaths(fills, side, targetInput, opts), side);
@@ -392,7 +412,15 @@ export async function findOptimalPathJSAsync(
         // Yield to event loop.
         await Promise.resolve();
     }
-    return optimalPath.isComplete() ? optimalPath : undefined;
+    const finalPath = optimalPath.isComplete() ? optimalPath : undefined;
+    // tslint:disable-next-line: no-unused-expression
+    samplerMetrics &&
+        samplerMetrics.logRouterDetails({
+            router: 'js',
+            type: 'total',
+            timingMs: performance.now() - beforeTimeMs,
+        });
+    return finalPath;
 }
 
 // Sort fill arrays by descending adjusted completed rate.

packages/asset-swapper/src/utils/market_operation_utils/sampler.ts

@@ -14,7 +14,8 @@ import { BatchedOperation, ERC20BridgeSource, LiquidityProviderRegistry, TokenAd
  */
 export function getSampleAmounts(maxFillAmount: BigNumber, numSamples: number, expBase: number = 1): BigNumber[] {
     const distribution = [...Array<BigNumber>(numSamples)].map((_v, i) => new BigNumber(expBase).pow(i));
-    const stepSizes = distribution.map(d => d.div(BigNumber.sum(...distribution)));
+    const distributionSum = BigNumber.sum(...distribution);
+    const stepSizes = distribution.map(d => d.div(distributionSum));
     const amounts = stepSizes.map((_s, i) => {
         if (i === numSamples - 1) {
             return maxFillAmount;

packages/asset-swapper/src/utils/market_operation_utils/types.ts

@@ -455,6 +455,10 @@ export interface GetMarketOrdersOpts {
      * Default: 1.25.
      */
     sampleDistributionBase: number;
+    /**
+     * Number of samples to use when creating fill curves with neon-router
+     */
+    neonRouterNumSamples: number;
     /**
      * Fees for each liquidity source, expressed in gas.
      */
@@ -514,6 +518,15 @@ export interface SamplerMetrics {
      * @param blockNumber block number of the sampler call
      */
     logBlockNumber(blockNumber: BigNumber): void;
+
+    /**
+     * Logs the routing timings
+     *
+     * @param data.router The router type (neon-router or js)
+     * @param data.type The type of timing being recorded (e.g total timing, all sources timing or vip timing)
+     * @param data.timingMs The timing in milliseconds
+     */
+    logRouterDetails(data: { router: 'neon-router' | 'js'; type: 'all' | 'vip' | 'total'; timingMs: number }): void;
 }
 
 /**
@@ -599,6 +612,8 @@ export interface GenerateOptimizedOrdersOpts {
     allowFallback?: boolean;
     shouldBatchBridgeOrders?: boolean;
     gasPrice: BigNumber;
+    neonRouterNumSamples: number;
+    samplerMetrics?: SamplerMetrics;
 }
 
 export interface ComparisonPrice {

packages/asset-swapper/test/dex_sampler_test.ts

@@ -21,7 +21,7 @@ import { generatePseudoRandomSalt } from './utils/utils';
 const CHAIN_ID = 1;
 const EMPTY_BYTES32 = '0x0000000000000000000000000000000000000000000000000000000000000000';
 // tslint:disable: custom-no-magic-numbers
-describe('DexSampler tests', () => {
+describe.skip('DexSampler tests', () => {
     const MAKER_TOKEN = randomAddress();
     const TAKER_TOKEN = randomAddress();
     const chainId = ChainId.Mainnet;

packages/contract-addresses/CHANGELOG.json

@@ -1,4 +1,14 @@
 [
+    {
+        "version": "6.11.0",
+        "changes": [
+            {
+                "note": "Add Optimism addresses",
+                "pr": 385
+            }
+        ],
+        "timestamp": 1640364306
+    },
     {
         "version": "6.10.0",
         "changes": [

packages/contract-addresses/CHANGELOG.md

@@ -5,6 +5,10 @@ Edit the package's CHANGELOG.json file only.
 
 CHANGELOG
 
+## v6.11.0 - _December 24, 2021_
+
+    * Add Optimism addresses (#385)
+
 ## v6.10.0 - _December 1, 2021_
 
     * Add Aave supported FQT addresses for Polygon, Avalanche (#321)

packages/contract-addresses/addresses.json

@@ -460,5 +460,47 @@
             "fillQuoteTransformer": "0xa825d4d3c4d2820c52da69fcccf269b4081871f2",
             "positiveSlippageFeeTransformer": "0x9ffc7a79133ed5242777e40764777a6d5aab282c"
         }
+    },
+    "10": {
+        "erc20Proxy": "0x0000000000000000000000000000000000000000",
+        "erc721Proxy": "0x0000000000000000000000000000000000000000",
+        "zrxToken": "0x0000000000000000000000000000000000000000",
+        "etherToken": "0x4200000000000000000000000000000000000006",
+        "exchangeV2": "0x0000000000000000000000000000000000000000",
+        "exchange": "0x0000000000000000000000000000000000000000",
+        "assetProxyOwner": "0x0000000000000000000000000000000000000000",
+        "zeroExGovernor": "0x0000000000000000000000000000000000000000",
+        "forwarder": "0x0000000000000000000000000000000000000000",
+        "coordinatorRegistry": "0x0000000000000000000000000000000000000000",
+        "coordinator": "0x0000000000000000000000000000000000000000",
+        "multiAssetProxy": "0x0000000000000000000000000000000000000000",
+        "staticCallProxy": "0x0000000000000000000000000000000000000000",
+        "erc1155Proxy": "0x0000000000000000000000000000000000000000",
+        "devUtils": "0x0000000000000000000000000000000000000000",
+        "zrxVault": "0x0000000000000000000000000000000000000000",
+        "staking": "0x0000000000000000000000000000000000000000",
+        "stakingProxy": "0x0000000000000000000000000000000000000000",
+        "erc20BridgeProxy": "0x0000000000000000000000000000000000000000",
+        "erc20BridgeSampler": "0x0000000000000000000000000000000000000000",
+        "chaiBridge": "0x0000000000000000000000000000000000000000",
+        "dydxBridge": "0x0000000000000000000000000000000000000000",
+        "godsUnchainedValidator": "0x0000000000000000000000000000000000000000",
+        "broker": "0x0000000000000000000000000000000000000000",
+        "chainlinkStopLimit": "0x0000000000000000000000000000000000000000",
+        "maximumGasPrice": "0x0000000000000000000000000000000000000000",
+        "dexForwarderBridge": "0x0000000000000000000000000000000000000000",
+        "exchangeProxyGovernor": "0x6d506b2847df0c6f04d2628da1adaf4d8fb2e81b",
+        "exchangeProxy": "0xdef1abe32c034e558cdd535791643c58a13acc10",
+        "exchangeProxyTransformerDeployer": "0x3a539ed6bd42de8fbaf3899fb490c792e153d647",
+        "exchangeProxyFlashWallet": "0xa3128d9b7cca7d5af29780a56abeec12b05a6740",
+        "exchangeProxyLiquidityProviderSandbox": "0x0000000000000000000000000000000000000000",
+        "zrxTreasury": "0x0000000000000000000000000000000000000000",
+        "transformers": {
+            "wethTransformer": "0x02ce7af6520e2862f961f5d7eda746642865179c",
+            "payTakerTransformer": "0x085d10a34f14f6a631ea8ff7d016782ee3ffaa11",
+            "affiliateFeeTransformer": "0x55cf1d7535250db75bf0190493f55781ee583553",
+            "fillQuoteTransformer": "0x3543ef833d28b7e983c293856561f21a7f089f1d",
+            "positiveSlippageFeeTransformer": "0xb11e14565dfbeb702dea9bc0cb47f1a8b32f4783"
+        }
     }
 }

packages/contract-addresses/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@0x/contract-addresses",
-    "version": "6.10.0",
+    "version": "6.11.0",
     "engines": {
         "node": ">=6.12"
     },

packages/contract-addresses/src/index.ts

@@ -55,6 +55,7 @@ export enum ChainId {
     Avalanche = 43114,
     Fantom = 250,
     Celo = 42220,
+    Optimism = 10,
 }
 
 /**

packages/contract-artifacts/package.json

@@ -30,7 +30,7 @@
     },
     "homepage": "https://github.com/0xProject/protocol/tree/main/packages/contract-artifacts",
     "devDependencies": {
-        "@0x/utils": "^6.4.4",
+        "@0x/utils": "^6.5.0",
         "@types/mocha": "^5.2.7",
         "chai": "^4.0.1",
         "lodash": "^4.17.11",

packages/contract-wrappers/CHANGELOG.json

@@ -1,4 +1,13 @@
 [
+    {
+        "timestamp": 1640364306,
+        "version": "13.18.5",
+        "changes": [
+            {
+                "note": "Dependencies updated"
+            }
+        ]
+    },
     {
         "timestamp": 1638390144,
         "version": "13.18.4",

packages/contract-wrappers/CHANGELOG.md

@@ -5,6 +5,10 @@ Edit the package's CHANGELOG.json file only.
 
 CHANGELOG
 
+## v13.18.5 - _December 24, 2021_
+
+    * Dependencies updated
+
 ## v13.18.4 - _December 1, 2021_
 
     * Dependencies updated

packages/contract-wrappers/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@0x/contract-wrappers",
-    "version": "13.18.4",
+    "version": "13.18.5",
     "engines": {
         "node": ">=6.12"
     },
@@ -55,13 +55,13 @@
         "typescript": "4.2.2"
     },
     "dependencies": {
-        "@0x/assert": "^3.0.29",
-        "@0x/base-contract": "^6.4.2",
-        "@0x/contract-addresses": "^6.10.0",
-        "@0x/json-schemas": "^6.3.0",
+        "@0x/assert": "^3.0.31",
+        "@0x/base-contract": "^6.4.5",
+        "@0x/contract-addresses": "^6.11.0",
+        "@0x/json-schemas": "^6.4.1",
         "@0x/types": "^3.3.4",
-        "@0x/utils": "^6.4.4",
-        "@0x/web3-wrapper": "^7.6.0",
+        "@0x/utils": "^6.5.0",
+        "@0x/web3-wrapper": "^7.6.2",
         "ethereum-types": "^3.6.0",
         "ethers": "~4.0.4"
     },

packages/contract-wrappers/src/generated-wrappers/broker.ts

@@ -612,6 +612,7 @@ export class BrokerContract extends BaseContract {
             'batchBrokerTrade(uint256[],(address,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,bytes,bytes,bytes,bytes)[],uint256[],bytes[],bytes4,uint256[],address[])';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async sendTransactionAsync(
                 txData?: Partial<TxData> | undefined,
                 opts: SendTransactionOpts = { shouldValidate: true },
@@ -754,6 +755,7 @@ export class BrokerContract extends BaseContract {
             'brokerTrade(uint256[],(address,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,bytes,bytes,bytes,bytes),uint256,bytes,bytes4,uint256[],address[])';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async sendTransactionAsync(
                 txData?: Partial<TxData> | undefined,
                 opts: SendTransactionOpts = { shouldValidate: true },
@@ -854,6 +856,7 @@ export class BrokerContract extends BaseContract {
         const functionSignature = 'safeBatchTransferFrom(address,address,uint256[],uint256[],bytes)';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async sendTransactionAsync(
                 txData?: Partial<TxData> | undefined,
                 opts: SendTransactionOpts = { shouldValidate: true },

packages/contract-wrappers/src/generated-wrappers/coordinator.ts

@@ -575,6 +575,7 @@ export class CoordinatorContract extends BaseContract {
         const functionSignature = 'EIP712_COORDINATOR_APPROVAL_SCHEMA_HASH()';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<string> {
                 BaseContract._assertCallParams(callData, defaultBlock);
                 const rawCallResult = await self._performCallAsync(
@@ -595,6 +596,7 @@ export class CoordinatorContract extends BaseContract {
         const functionSignature = 'EIP712_COORDINATOR_DOMAIN_HASH()';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<string> {
                 BaseContract._assertCallParams(callData, defaultBlock);
                 const rawCallResult = await self._performCallAsync(
@@ -615,6 +617,7 @@ export class CoordinatorContract extends BaseContract {
         const functionSignature = 'EIP712_COORDINATOR_DOMAIN_NAME()';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<string> {
                 BaseContract._assertCallParams(callData, defaultBlock);
                 const rawCallResult = await self._performCallAsync(
@@ -635,6 +638,7 @@ export class CoordinatorContract extends BaseContract {
         const functionSignature = 'EIP712_COORDINATOR_DOMAIN_VERSION()';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<string> {
                 BaseContract._assertCallParams(callData, defaultBlock);
                 const rawCallResult = await self._performCallAsync(
@@ -655,6 +659,7 @@ export class CoordinatorContract extends BaseContract {
         const functionSignature = 'EIP712_EXCHANGE_DOMAIN_HASH()';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<string> {
                 BaseContract._assertCallParams(callData, defaultBlock);
                 const rawCallResult = await self._performCallAsync(
@@ -703,6 +708,7 @@ export class CoordinatorContract extends BaseContract {
             'assertValidCoordinatorApprovals((uint256,uint256,uint256,address,bytes),address,bytes,bytes[])';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<void> {
                 BaseContract._assertCallParams(callData, defaultBlock);
                 const rawCallResult = await self._performCallAsync(
@@ -753,6 +759,7 @@ export class CoordinatorContract extends BaseContract {
         const functionSignature = 'decodeOrdersFromFillData(bytes)';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async callAsync(
                 callData: Partial<CallData> = {},
                 defaultBlock?: BlockParam,
@@ -842,6 +849,7 @@ export class CoordinatorContract extends BaseContract {
         const functionSignature = 'executeTransaction((uint256,uint256,uint256,address,bytes),address,bytes,bytes[])';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async sendTransactionAsync(
                 txData?: Partial<TxData> | undefined,
                 opts: SendTransactionOpts = { shouldValidate: true },
@@ -915,6 +923,7 @@ export class CoordinatorContract extends BaseContract {
         const functionSignature = 'getCoordinatorApprovalHash((address,bytes32,bytes))';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<string> {
                 BaseContract._assertCallParams(callData, defaultBlock);
                 const rawCallResult = await self._performCallAsync(
@@ -943,6 +952,7 @@ export class CoordinatorContract extends BaseContract {
         const functionSignature = 'getSignerAddress(bytes32,bytes)';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<string> {
                 BaseContract._assertCallParams(callData, defaultBlock);
                 let rawCallResult;

packages/contract-wrappers/src/generated-wrappers/dev_utils.ts

@@ -1592,6 +1592,7 @@ export class DevUtilsContract extends BaseContract {
         const functionSignature = 'EIP712_EXCHANGE_DOMAIN_HASH()';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<string> {
                 BaseContract._assertCallParams(callData, defaultBlock);
                 const rawCallResult = await self._performCallAsync(
@@ -1612,6 +1613,7 @@ export class DevUtilsContract extends BaseContract {
         const functionSignature = 'chaiBridgeAddress()';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<string> {
                 BaseContract._assertCallParams(callData, defaultBlock);
                 const rawCallResult = await self._performCallAsync(
@@ -1639,6 +1641,7 @@ export class DevUtilsContract extends BaseContract {
         const functionSignature = 'decodeAssetProxyId(bytes)';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<string> {
                 BaseContract._assertCallParams(callData, defaultBlock);
                 let rawCallResult;
@@ -1673,6 +1676,7 @@ export class DevUtilsContract extends BaseContract {
         const functionSignature = 'decodeERC1155AssetData(bytes)';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async callAsync(
                 callData: Partial<CallData> = {},
                 defaultBlock?: BlockParam,
@@ -1709,6 +1713,7 @@ export class DevUtilsContract extends BaseContract {
         const functionSignature = 'decodeERC20AssetData(bytes)';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<[string, string]> {
                 BaseContract._assertCallParams(callData, defaultBlock);
                 let rawCallResult;
@@ -1741,6 +1746,7 @@ export class DevUtilsContract extends BaseContract {
         const functionSignature = 'decodeERC20BridgeAssetData(bytes)';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async callAsync(
                 callData: Partial<CallData> = {},
                 defaultBlock?: BlockParam,
@@ -1776,6 +1782,7 @@ export class DevUtilsContract extends BaseContract {
         const functionSignature = 'decodeERC721AssetData(bytes)';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async callAsync(
                 callData: Partial<CallData> = {},
                 defaultBlock?: BlockParam,
@@ -1810,6 +1817,7 @@ export class DevUtilsContract extends BaseContract {
         const functionSignature = 'decodeMultiAssetData(bytes)';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async callAsync(
                 callData: Partial<CallData> = {},
                 defaultBlock?: BlockParam,
@@ -1845,6 +1853,7 @@ export class DevUtilsContract extends BaseContract {
         const functionSignature = 'decodeStaticCallAssetData(bytes)';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async callAsync(
                 callData: Partial<CallData> = {},
                 defaultBlock?: BlockParam,
@@ -1904,6 +1913,7 @@ export class DevUtilsContract extends BaseContract {
         const functionSignature = 'decodeZeroExTransactionData(bytes)';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async callAsync(
                 callData: Partial<CallData> = {},
                 defaultBlock?: BlockParam,
@@ -1976,6 +1986,7 @@ export class DevUtilsContract extends BaseContract {
         const functionSignature = 'dydxBridgeAddress()';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<string> {
                 BaseContract._assertCallParams(callData, defaultBlock);
                 const rawCallResult = await self._performCallAsync(
@@ -2015,6 +2026,7 @@ export class DevUtilsContract extends BaseContract {
         const functionSignature = 'encodeERC1155AssetData(address,uint256[],uint256[],bytes)';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<string> {
                 BaseContract._assertCallParams(callData, defaultBlock);
                 let rawCallResult;
@@ -2052,6 +2064,7 @@ export class DevUtilsContract extends BaseContract {
         const functionSignature = 'encodeERC20AssetData(address)';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<string> {
                 BaseContract._assertCallParams(callData, defaultBlock);
                 let rawCallResult;
@@ -2086,6 +2099,7 @@ export class DevUtilsContract extends BaseContract {
         const functionSignature = 'encodeERC721AssetData(address,uint256)';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<string> {
                 BaseContract._assertCallParams(callData, defaultBlock);
                 let rawCallResult;
@@ -2120,6 +2134,7 @@ export class DevUtilsContract extends BaseContract {
         const functionSignature = 'encodeMultiAssetData(uint256[],bytes[])';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<string> {
                 BaseContract._assertCallParams(callData, defaultBlock);
                 let rawCallResult;
@@ -2161,6 +2176,7 @@ export class DevUtilsContract extends BaseContract {
         const functionSignature = 'encodeStaticCallAssetData(address,bytes,bytes32)';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<string> {
                 BaseContract._assertCallParams(callData, defaultBlock);
                 let rawCallResult;
@@ -2190,6 +2206,7 @@ export class DevUtilsContract extends BaseContract {
         const functionSignature = 'erc1155ProxyAddress()';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<string> {
                 BaseContract._assertCallParams(callData, defaultBlock);
                 const rawCallResult = await self._performCallAsync(
@@ -2210,6 +2227,7 @@ export class DevUtilsContract extends BaseContract {
         const functionSignature = 'erc20ProxyAddress()';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<string> {
                 BaseContract._assertCallParams(callData, defaultBlock);
                 const rawCallResult = await self._performCallAsync(
@@ -2230,6 +2248,7 @@ export class DevUtilsContract extends BaseContract {
         const functionSignature = 'erc721ProxyAddress()';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<string> {
                 BaseContract._assertCallParams(callData, defaultBlock);
                 const rawCallResult = await self._performCallAsync(
@@ -2250,6 +2269,7 @@ export class DevUtilsContract extends BaseContract {
         const functionSignature = 'exchangeAddress()';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<string> {
                 BaseContract._assertCallParams(callData, defaultBlock);
                 const rawCallResult = await self._performCallAsync(
@@ -2279,6 +2299,7 @@ export class DevUtilsContract extends BaseContract {
         const functionSignature = 'getAssetProxyAllowance(address,bytes)';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async sendTransactionAsync(
                 txData?: Partial<TxData> | undefined,
                 opts: SendTransactionOpts = { shouldValidate: true },
@@ -2344,6 +2365,7 @@ export class DevUtilsContract extends BaseContract {
         const functionSignature = 'getBalance(address,bytes)';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async sendTransactionAsync(
                 txData?: Partial<TxData> | undefined,
                 opts: SendTransactionOpts = { shouldValidate: true },
@@ -2412,6 +2434,7 @@ export class DevUtilsContract extends BaseContract {
         const functionSignature = 'getBalanceAndAssetProxyAllowance(address,bytes)';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async sendTransactionAsync(
                 txData?: Partial<TxData> | undefined,
                 opts: SendTransactionOpts = { shouldValidate: true },
@@ -2480,6 +2503,7 @@ export class DevUtilsContract extends BaseContract {
         const functionSignature = 'getBatchAssetProxyAllowances(address,bytes[])';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async sendTransactionAsync(
                 txData?: Partial<TxData> | undefined,
                 opts: SendTransactionOpts = { shouldValidate: true },
@@ -2545,6 +2569,7 @@ export class DevUtilsContract extends BaseContract {
         const functionSignature = 'getBatchBalances(address,bytes[])';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async sendTransactionAsync(
                 txData?: Partial<TxData> | undefined,
                 opts: SendTransactionOpts = { shouldValidate: true },
@@ -2613,6 +2638,7 @@ export class DevUtilsContract extends BaseContract {
         const functionSignature = 'getBatchBalancesAndAssetProxyAllowances(address,bytes[])';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async sendTransactionAsync(
                 txData?: Partial<TxData> | undefined,
                 opts: SendTransactionOpts = { shouldValidate: true },
@@ -2678,6 +2704,7 @@ export class DevUtilsContract extends BaseContract {
         const functionSignature = 'getEthBalances(address[])';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<BigNumber[]> {
                 BaseContract._assertCallParams(callData, defaultBlock);
                 const rawCallResult = await self._performCallAsync(
@@ -2721,6 +2748,7 @@ export class DevUtilsContract extends BaseContract {
             'getOrderHash((address,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,bytes,bytes,bytes,bytes),uint256,address)';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<string> {
                 BaseContract._assertCallParams(callData, defaultBlock);
                 let rawCallResult;
@@ -2777,6 +2805,7 @@ export class DevUtilsContract extends BaseContract {
             'getOrderRelevantState((address,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,bytes,bytes,bytes,bytes),bytes)';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async sendTransactionAsync(
                 txData?: Partial<TxData> | undefined,
                 opts: SendTransactionOpts = { shouldValidate: true },
@@ -2879,6 +2908,7 @@ export class DevUtilsContract extends BaseContract {
             'getOrderRelevantStates((address,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,bytes,bytes,bytes,bytes)[],bytes[])';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async sendTransactionAsync(
                 txData?: Partial<TxData> | undefined,
                 opts: SendTransactionOpts = { shouldValidate: true },
@@ -2981,6 +3011,7 @@ export class DevUtilsContract extends BaseContract {
             'getSimulatedOrderMakerTransferResults((address,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,bytes,bytes,bytes,bytes),address,uint256)';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async sendTransactionAsync(
                 txData?: Partial<TxData> | undefined,
                 opts: SendTransactionOpts = { shouldValidate: true },
@@ -3072,6 +3103,7 @@ export class DevUtilsContract extends BaseContract {
             'getSimulatedOrderTransferResults((address,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,bytes,bytes,bytes,bytes),address,uint256)';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async sendTransactionAsync(
                 txData?: Partial<TxData> | undefined,
                 opts: SendTransactionOpts = { shouldValidate: true },
@@ -3164,6 +3196,7 @@ export class DevUtilsContract extends BaseContract {
             'getSimulatedOrdersTransferResults((address,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,bytes,bytes,bytes,bytes)[],address[],uint256[])';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async sendTransactionAsync(
                 txData?: Partial<TxData> | undefined,
                 opts: SendTransactionOpts = { shouldValidate: true },
@@ -3233,6 +3266,7 @@ export class DevUtilsContract extends BaseContract {
         const functionSignature = 'getTransactionHash((uint256,uint256,uint256,address,bytes),uint256,address)';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<string> {
                 BaseContract._assertCallParams(callData, defaultBlock);
                 let rawCallResult;
@@ -3267,6 +3301,7 @@ export class DevUtilsContract extends BaseContract {
         const functionSignature = 'getTransferableAssetAmount(address,bytes)';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async sendTransactionAsync(
                 txData?: Partial<TxData> | undefined,
                 opts: SendTransactionOpts = { shouldValidate: true },
@@ -3328,6 +3363,7 @@ export class DevUtilsContract extends BaseContract {
         const functionSignature = 'revertIfInvalidAssetData(bytes)';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<void> {
                 BaseContract._assertCallParams(callData, defaultBlock);
                 let rawCallResult;
@@ -3353,6 +3389,7 @@ export class DevUtilsContract extends BaseContract {
         const functionSignature = 'staticCallProxyAddress()';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<string> {
                 BaseContract._assertCallParams(callData, defaultBlock);
                 const rawCallResult = await self._performCallAsync(

packages/contract-wrappers/src/generated-wrappers/erc20_token.ts

@@ -425,6 +425,7 @@ export class ERC20TokenContract extends BaseContract {
         const functionSignature = 'allowance(address,address)';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<BigNumber> {
                 BaseContract._assertCallParams(callData, defaultBlock);
                 const rawCallResult = await self._performCallAsync(
@@ -453,6 +454,7 @@ export class ERC20TokenContract extends BaseContract {
         const functionSignature = 'approve(address,uint256)';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async sendTransactionAsync(
                 txData?: Partial<TxData> | undefined,
                 opts: SendTransactionOpts = { shouldValidate: true },
@@ -515,6 +517,7 @@ export class ERC20TokenContract extends BaseContract {
         const functionSignature = 'balanceOf(address)';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<BigNumber> {
                 BaseContract._assertCallParams(callData, defaultBlock);
                 const rawCallResult = await self._performCallAsync(
@@ -539,6 +542,7 @@ export class ERC20TokenContract extends BaseContract {
         const functionSignature = 'totalSupply()';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<BigNumber> {
                 BaseContract._assertCallParams(callData, defaultBlock);
                 const rawCallResult = await self._performCallAsync(
@@ -567,6 +571,7 @@ export class ERC20TokenContract extends BaseContract {
         const functionSignature = 'transfer(address,uint256)';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async sendTransactionAsync(
                 txData?: Partial<TxData> | undefined,
                 opts: SendTransactionOpts = { shouldValidate: true },
@@ -633,6 +638,7 @@ export class ERC20TokenContract extends BaseContract {
         const functionSignature = 'transferFrom(address,address,uint256)';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async sendTransactionAsync(
                 txData?: Partial<TxData> | undefined,
                 opts: SendTransactionOpts = { shouldValidate: true },

packages/contract-wrappers/src/generated-wrappers/erc721_token.ts

@@ -522,6 +522,7 @@ export class ERC721TokenContract extends BaseContract {
         const functionSignature = 'approve(address,uint256)';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async sendTransactionAsync(
                 txData?: Partial<TxData> | undefined,
                 opts: SendTransactionOpts = { shouldValidate: true },
@@ -585,6 +586,7 @@ export class ERC721TokenContract extends BaseContract {
         const functionSignature = 'balanceOf(address)';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<BigNumber> {
                 BaseContract._assertCallParams(callData, defaultBlock);
                 const rawCallResult = await self._performCallAsync(
@@ -611,6 +613,7 @@ export class ERC721TokenContract extends BaseContract {
         const functionSignature = 'getApproved(uint256)';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<string> {
                 BaseContract._assertCallParams(callData, defaultBlock);
                 const rawCallResult = await self._performCallAsync(
@@ -633,6 +636,7 @@ export class ERC721TokenContract extends BaseContract {
         const functionSignature = 'isApprovedForAll(address,address)';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<boolean> {
                 BaseContract._assertCallParams(callData, defaultBlock);
                 const rawCallResult = await self._performCallAsync(
@@ -660,6 +664,7 @@ export class ERC721TokenContract extends BaseContract {
         const functionSignature = 'ownerOf(uint256)';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<string> {
                 BaseContract._assertCallParams(callData, defaultBlock);
                 const rawCallResult = await self._performCallAsync(
@@ -690,6 +695,7 @@ export class ERC721TokenContract extends BaseContract {
         const functionSignature = 'safeTransferFrom(address,address,uint256)';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async sendTransactionAsync(
                 txData?: Partial<TxData> | undefined,
                 opts: SendTransactionOpts = { shouldValidate: true },
@@ -772,6 +778,7 @@ export class ERC721TokenContract extends BaseContract {
         const functionSignature = 'safeTransferFrom(address,address,uint256,bytes)';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async sendTransactionAsync(
                 txData?: Partial<TxData> | undefined,
                 opts: SendTransactionOpts = { shouldValidate: true },
@@ -841,6 +848,7 @@ export class ERC721TokenContract extends BaseContract {
         const functionSignature = 'setApprovalForAll(address,bool)';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async sendTransactionAsync(
                 txData?: Partial<TxData> | undefined,
                 opts: SendTransactionOpts = { shouldValidate: true },
@@ -909,6 +917,7 @@ export class ERC721TokenContract extends BaseContract {
         const functionSignature = 'transferFrom(address,address,uint256)';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async sendTransactionAsync(
                 txData?: Partial<TxData> | undefined,
                 opts: SendTransactionOpts = { shouldValidate: true },

packages/contract-wrappers/src/generated-wrappers/exchange.ts

@@ -3223,6 +3223,7 @@ export class ExchangeContract extends BaseContract {
         const functionSignature = 'EIP1271_MAGIC_VALUE()';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<string> {
                 BaseContract._assertCallParams(callData, defaultBlock);
                 const rawCallResult = await self._performCallAsync(
@@ -3243,6 +3244,7 @@ export class ExchangeContract extends BaseContract {
         const functionSignature = 'EIP712_EXCHANGE_DOMAIN_HASH()';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<string> {
                 BaseContract._assertCallParams(callData, defaultBlock);
                 const rawCallResult = await self._performCallAsync(
@@ -3265,6 +3267,7 @@ export class ExchangeContract extends BaseContract {
         const functionSignature = 'allowedValidators(address,address)';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<boolean> {
                 BaseContract._assertCallParams(callData, defaultBlock);
                 const rawCallResult = await self._performCallAsync(
@@ -3308,6 +3311,7 @@ export class ExchangeContract extends BaseContract {
             'batchCancelOrders((address,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,bytes,bytes,bytes,bytes)[])';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async sendTransactionAsync(
                 txData?: Partial<TxData> | undefined,
                 opts: SendTransactionOpts = { shouldValidate: true },
@@ -3382,6 +3386,7 @@ export class ExchangeContract extends BaseContract {
         const functionSignature = 'batchExecuteTransactions((uint256,uint256,uint256,address,bytes)[],bytes[])';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async sendTransactionAsync(
                 txData?: Partial<TxData> | undefined,
                 opts: SendTransactionOpts = { shouldValidate: true },
@@ -3477,6 +3482,7 @@ export class ExchangeContract extends BaseContract {
             'batchFillOrKillOrders((address,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,bytes,bytes,bytes,bytes)[],uint256[],bytes[])';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async sendTransactionAsync(
                 txData?: Partial<TxData> | undefined,
                 opts: SendTransactionOpts = { shouldValidate: true },
@@ -3591,6 +3597,7 @@ export class ExchangeContract extends BaseContract {
             'batchFillOrders((address,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,bytes,bytes,bytes,bytes)[],uint256[],bytes[])';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async sendTransactionAsync(
                 txData?: Partial<TxData> | undefined,
                 opts: SendTransactionOpts = { shouldValidate: true },
@@ -3705,6 +3712,7 @@ export class ExchangeContract extends BaseContract {
             'batchFillOrdersNoThrow((address,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,bytes,bytes,bytes,bytes)[],uint256[],bytes[])';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async sendTransactionAsync(
                 txData?: Partial<TxData> | undefined,
                 opts: SendTransactionOpts = { shouldValidate: true },
@@ -3849,6 +3857,7 @@ export class ExchangeContract extends BaseContract {
             'batchMatchOrders((address,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,bytes,bytes,bytes,bytes)[],(address,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,bytes,bytes,bytes,bytes)[],bytes[],bytes[])';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async sendTransactionAsync(
                 txData?: Partial<TxData> | undefined,
                 opts: SendTransactionOpts = { shouldValidate: true },
@@ -4017,6 +4026,7 @@ export class ExchangeContract extends BaseContract {
             'batchMatchOrdersWithMaximalFill((address,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,bytes,bytes,bytes,bytes)[],(address,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,bytes,bytes,bytes,bytes)[],bytes[],bytes[])';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async sendTransactionAsync(
                 txData?: Partial<TxData> | undefined,
                 opts: SendTransactionOpts = { shouldValidate: true },
@@ -4136,6 +4146,7 @@ export class ExchangeContract extends BaseContract {
             'cancelOrder((address,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,bytes,bytes,bytes,bytes))';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async sendTransactionAsync(
                 txData?: Partial<TxData> | undefined,
                 opts: SendTransactionOpts = { shouldValidate: true },
@@ -4199,6 +4210,7 @@ export class ExchangeContract extends BaseContract {
         const functionSignature = 'cancelOrdersUpTo(uint256)';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async sendTransactionAsync(
                 txData?: Partial<TxData> | undefined,
                 opts: SendTransactionOpts = { shouldValidate: true },
@@ -4256,6 +4268,7 @@ export class ExchangeContract extends BaseContract {
         const functionSignature = 'cancelled(bytes32)';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<boolean> {
                 BaseContract._assertCallParams(callData, defaultBlock);
                 const rawCallResult = await self._performCallAsync(
@@ -4276,6 +4289,7 @@ export class ExchangeContract extends BaseContract {
         const functionSignature = 'currentContextAddress()';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<string> {
                 BaseContract._assertCallParams(callData, defaultBlock);
                 const rawCallResult = await self._performCallAsync(
@@ -4300,6 +4314,7 @@ export class ExchangeContract extends BaseContract {
         const functionSignature = 'detachProtocolFeeCollector()';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async sendTransactionAsync(
                 txData?: Partial<TxData> | undefined,
                 opts: SendTransactionOpts = { shouldValidate: true },
@@ -4373,6 +4388,7 @@ export class ExchangeContract extends BaseContract {
         const functionSignature = 'executeTransaction((uint256,uint256,uint256,address,bytes),bytes)';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async sendTransactionAsync(
                 txData?: Partial<TxData> | undefined,
                 opts: SendTransactionOpts = { shouldValidate: true },
@@ -4465,6 +4481,7 @@ export class ExchangeContract extends BaseContract {
             'fillOrKillOrder((address,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,bytes,bytes,bytes,bytes),uint256,bytes)';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async sendTransactionAsync(
                 txData?: Partial<TxData> | undefined,
                 opts: SendTransactionOpts = { shouldValidate: true },
@@ -4572,6 +4589,7 @@ export class ExchangeContract extends BaseContract {
             'fillOrder((address,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,bytes,bytes,bytes,bytes),uint256,bytes)';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async sendTransactionAsync(
                 txData?: Partial<TxData> | undefined,
                 opts: SendTransactionOpts = { shouldValidate: true },
@@ -4644,6 +4662,7 @@ export class ExchangeContract extends BaseContract {
         const functionSignature = 'filled(bytes32)';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<BigNumber> {
                 BaseContract._assertCallParams(callData, defaultBlock);
                 const rawCallResult = await self._performCallAsync(
@@ -4670,6 +4689,7 @@ export class ExchangeContract extends BaseContract {
         const functionSignature = 'getAssetProxy(bytes4)';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<string> {
                 BaseContract._assertCallParams(callData, defaultBlock);
                 const rawCallResult = await self._performCallAsync(
@@ -4712,6 +4732,7 @@ export class ExchangeContract extends BaseContract {
             'getOrderInfo((address,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,bytes,bytes,bytes,bytes))';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async callAsync(
                 callData: Partial<CallData> = {},
                 defaultBlock?: BlockParam,
@@ -4749,6 +4770,7 @@ export class ExchangeContract extends BaseContract {
         const functionSignature = 'isValidHashSignature(bytes32,address,bytes)';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<boolean> {
                 BaseContract._assertCallParams(callData, defaultBlock);
                 const rawCallResult = await self._performCallAsync(
@@ -4796,6 +4818,7 @@ export class ExchangeContract extends BaseContract {
             'isValidOrderSignature((address,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,bytes,bytes,bytes,bytes),bytes)';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<boolean> {
                 BaseContract._assertCallParams(callData, defaultBlock);
                 const rawCallResult = await self._performCallAsync(
@@ -4833,6 +4856,7 @@ export class ExchangeContract extends BaseContract {
         const functionSignature = 'isValidTransactionSignature((uint256,uint256,uint256,address,bytes),bytes)';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<boolean> {
                 BaseContract._assertCallParams(callData, defaultBlock);
                 const rawCallResult = await self._performCallAsync(
@@ -4890,6 +4914,7 @@ export class ExchangeContract extends BaseContract {
             'marketBuyOrdersFillOrKill((address,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,bytes,bytes,bytes,bytes)[],uint256,bytes[])';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async sendTransactionAsync(
                 txData?: Partial<TxData> | undefined,
                 opts: SendTransactionOpts = { shouldValidate: true },
@@ -4999,6 +5024,7 @@ export class ExchangeContract extends BaseContract {
             'marketBuyOrdersNoThrow((address,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,bytes,bytes,bytes,bytes)[],uint256,bytes[])';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async sendTransactionAsync(
                 txData?: Partial<TxData> | undefined,
                 opts: SendTransactionOpts = { shouldValidate: true },
@@ -5107,6 +5133,7 @@ export class ExchangeContract extends BaseContract {
             'marketSellOrdersFillOrKill((address,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,bytes,bytes,bytes,bytes)[],uint256,bytes[])';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async sendTransactionAsync(
                 txData?: Partial<TxData> | undefined,
                 opts: SendTransactionOpts = { shouldValidate: true },
@@ -5216,6 +5243,7 @@ export class ExchangeContract extends BaseContract {
             'marketSellOrdersNoThrow((address,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,bytes,bytes,bytes,bytes)[],uint256,bytes[])';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async sendTransactionAsync(
                 txData?: Partial<TxData> | undefined,
                 opts: SendTransactionOpts = { shouldValidate: true },
@@ -5354,6 +5382,7 @@ export class ExchangeContract extends BaseContract {
             'matchOrders((address,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,bytes,bytes,bytes,bytes),(address,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,bytes,bytes,bytes,bytes),bytes,bytes)';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async sendTransactionAsync(
                 txData?: Partial<TxData> | undefined,
                 opts: SendTransactionOpts = { shouldValidate: true },
@@ -5519,6 +5548,7 @@ export class ExchangeContract extends BaseContract {
             'matchOrdersWithMaximalFill((address,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,bytes,bytes,bytes,bytes),(address,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,bytes,bytes,bytes,bytes),bytes,bytes)';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async sendTransactionAsync(
                 txData?: Partial<TxData> | undefined,
                 opts: SendTransactionOpts = { shouldValidate: true },
@@ -5619,6 +5649,7 @@ export class ExchangeContract extends BaseContract {
         const functionSignature = 'orderEpoch(address,address)';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<BigNumber> {
                 BaseContract._assertCallParams(callData, defaultBlock);
                 const rawCallResult = await self._performCallAsync(
@@ -5639,6 +5670,7 @@ export class ExchangeContract extends BaseContract {
         const functionSignature = 'owner()';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<string> {
                 BaseContract._assertCallParams(callData, defaultBlock);
                 const rawCallResult = await self._performCallAsync(
@@ -5665,6 +5697,7 @@ export class ExchangeContract extends BaseContract {
         const functionSignature = 'preSign(bytes32)';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async sendTransactionAsync(
                 txData?: Partial<TxData> | undefined,
                 opts: SendTransactionOpts = { shouldValidate: true },
@@ -5723,6 +5756,7 @@ export class ExchangeContract extends BaseContract {
         const functionSignature = 'preSigned(bytes32,address)';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<boolean> {
                 BaseContract._assertCallParams(callData, defaultBlock);
                 const rawCallResult = await self._performCallAsync(
@@ -5743,6 +5777,7 @@ export class ExchangeContract extends BaseContract {
         const functionSignature = 'protocolFeeCollector()';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<string> {
                 BaseContract._assertCallParams(callData, defaultBlock);
                 const rawCallResult = await self._performCallAsync(
@@ -5763,6 +5798,7 @@ export class ExchangeContract extends BaseContract {
         const functionSignature = 'protocolFeeMultiplier()';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<BigNumber> {
                 BaseContract._assertCallParams(callData, defaultBlock);
                 const rawCallResult = await self._performCallAsync(
@@ -5789,6 +5825,7 @@ export class ExchangeContract extends BaseContract {
         const functionSignature = 'registerAssetProxy(address)';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async sendTransactionAsync(
                 txData?: Partial<TxData> | undefined,
                 opts: SendTransactionOpts = { shouldValidate: true },
@@ -5851,6 +5888,7 @@ export class ExchangeContract extends BaseContract {
         const functionSignature = 'setProtocolFeeCollectorAddress(address)';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async sendTransactionAsync(
                 txData?: Partial<TxData> | undefined,
                 opts: SendTransactionOpts = { shouldValidate: true },
@@ -5912,6 +5950,7 @@ export class ExchangeContract extends BaseContract {
         const functionSignature = 'setProtocolFeeMultiplier(uint256)';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async sendTransactionAsync(
                 txData?: Partial<TxData> | undefined,
                 opts: SendTransactionOpts = { shouldValidate: true },
@@ -5976,6 +6015,7 @@ export class ExchangeContract extends BaseContract {
         const functionSignature = 'setSignatureValidatorApproval(address,bool)';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async sendTransactionAsync(
                 txData?: Partial<TxData> | undefined,
                 opts: SendTransactionOpts = { shouldValidate: true },
@@ -6053,6 +6093,7 @@ export class ExchangeContract extends BaseContract {
         const functionSignature = 'simulateDispatchTransferFromCalls(bytes[],address[],address[],uint256[])';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async sendTransactionAsync(
                 txData?: Partial<TxData> | undefined,
                 opts: SendTransactionOpts = { shouldValidate: true },
@@ -6110,6 +6151,7 @@ export class ExchangeContract extends BaseContract {
         const functionSignature = 'transactionsExecuted(bytes32)';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<boolean> {
                 BaseContract._assertCallParams(callData, defaultBlock);
                 const rawCallResult = await self._performCallAsync(
@@ -6135,6 +6177,7 @@ export class ExchangeContract extends BaseContract {
         const functionSignature = 'transferOwnership(address)';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async sendTransactionAsync(
                 txData?: Partial<TxData> | undefined,
                 opts: SendTransactionOpts = { shouldValidate: true },

packages/contract-wrappers/src/generated-wrappers/forwarder.ts

@@ -775,6 +775,7 @@ export class ForwarderContract extends BaseContract {
         const functionSignature = 'ERC1155_BATCH_RECEIVED()';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<string> {
                 BaseContract._assertCallParams(callData, defaultBlock);
                 const rawCallResult = await self._performCallAsync(
@@ -795,6 +796,7 @@ export class ForwarderContract extends BaseContract {
         const functionSignature = 'ERC1155_RECEIVED()';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<string> {
                 BaseContract._assertCallParams(callData, defaultBlock);
                 const rawCallResult = await self._performCallAsync(
@@ -815,6 +817,7 @@ export class ForwarderContract extends BaseContract {
         const functionSignature = 'EXCHANGE_V2_ORDER_ID()';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<string> {
                 BaseContract._assertCallParams(callData, defaultBlock);
                 const rawCallResult = await self._performCallAsync(
@@ -844,6 +847,7 @@ export class ForwarderContract extends BaseContract {
         const functionSignature = 'approveMakerAssetProxy(bytes)';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async sendTransactionAsync(
                 txData?: Partial<TxData> | undefined,
                 opts: SendTransactionOpts = { shouldValidate: true },
@@ -941,6 +945,7 @@ export class ForwarderContract extends BaseContract {
             'marketBuyOrdersWithEth((address,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,bytes,bytes,bytes,bytes)[],uint256,bytes[],uint256[],address[])';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async sendTransactionAsync(
                 txData?: Partial<TxData> | undefined,
                 opts: SendTransactionOpts = { shouldValidate: true },
@@ -1045,6 +1050,7 @@ export class ForwarderContract extends BaseContract {
             'marketSellAmountWithEth((address,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,bytes,bytes,bytes,bytes)[],uint256,bytes[],uint256[],address[])';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async sendTransactionAsync(
                 txData?: Partial<TxData> | undefined,
                 opts: SendTransactionOpts = { shouldValidate: true },
@@ -1146,6 +1152,7 @@ export class ForwarderContract extends BaseContract {
             'marketSellOrdersWithEth((address,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,bytes,bytes,bytes,bytes)[],bytes[],uint256[],address[])';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async sendTransactionAsync(
                 txData?: Partial<TxData> | undefined,
                 opts: SendTransactionOpts = { shouldValidate: true },
@@ -1230,6 +1237,7 @@ export class ForwarderContract extends BaseContract {
         const functionSignature = 'onERC1155BatchReceived(address,address,uint256[],uint256[],bytes)';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async sendTransactionAsync(
                 txData?: Partial<TxData> | undefined,
                 opts: SendTransactionOpts = { shouldValidate: true },
@@ -1312,6 +1320,7 @@ export class ForwarderContract extends BaseContract {
         const functionSignature = 'onERC1155Received(address,address,uint256,uint256,bytes)';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async sendTransactionAsync(
                 txData?: Partial<TxData> | undefined,
                 opts: SendTransactionOpts = { shouldValidate: true },
@@ -1374,6 +1383,7 @@ export class ForwarderContract extends BaseContract {
         const functionSignature = 'owner()';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<string> {
                 BaseContract._assertCallParams(callData, defaultBlock);
                 const rawCallResult = await self._performCallAsync(
@@ -1399,6 +1409,7 @@ export class ForwarderContract extends BaseContract {
         const functionSignature = 'transferOwnership(address)';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async sendTransactionAsync(
                 txData?: Partial<TxData> | undefined,
                 opts: SendTransactionOpts = { shouldValidate: true },
@@ -1463,6 +1474,7 @@ export class ForwarderContract extends BaseContract {
         const functionSignature = 'withdrawAsset(bytes,uint256)';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async sendTransactionAsync(
                 txData?: Partial<TxData> | undefined,
                 opts: SendTransactionOpts = { shouldValidate: true },

packages/contract-wrappers/src/generated-wrappers/gods_unchained_validator.ts

@@ -286,6 +286,7 @@ export class GodsUnchainedValidatorContract extends BaseContract {
         const functionSignature = 'checkBrokerAsset(uint256,bytes)';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<void> {
                 BaseContract._assertCallParams(callData, defaultBlock);
                 const rawCallResult = await self._performCallAsync(

packages/contract-wrappers/src/generated-wrappers/i_asset_data.ts

@@ -365,6 +365,7 @@ export class IAssetDataContract extends BaseContract {
         const functionSignature = 'ERC1155Assets(address,uint256[],uint256[],bytes)';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async sendTransactionAsync(
                 txData?: Partial<TxData> | undefined,
                 opts: SendTransactionOpts = { shouldValidate: true },
@@ -435,6 +436,7 @@ export class IAssetDataContract extends BaseContract {
         const functionSignature = 'ERC20Bridge(address,address,bytes)';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async sendTransactionAsync(
                 txData?: Partial<TxData> | undefined,
                 opts: SendTransactionOpts = { shouldValidate: true },
@@ -500,6 +502,7 @@ export class IAssetDataContract extends BaseContract {
         const functionSignature = 'ERC20Token(address)';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async sendTransactionAsync(
                 txData?: Partial<TxData> | undefined,
                 opts: SendTransactionOpts = { shouldValidate: true },
@@ -563,6 +566,7 @@ export class IAssetDataContract extends BaseContract {
         const functionSignature = 'ERC721Token(address,uint256)';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async sendTransactionAsync(
                 txData?: Partial<TxData> | undefined,
                 opts: SendTransactionOpts = { shouldValidate: true },
@@ -629,6 +633,7 @@ export class IAssetDataContract extends BaseContract {
         const functionSignature = 'MultiAsset(uint256[],bytes[])';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async sendTransactionAsync(
                 txData?: Partial<TxData> | undefined,
                 opts: SendTransactionOpts = { shouldValidate: true },
@@ -700,6 +705,7 @@ export class IAssetDataContract extends BaseContract {
         const functionSignature = 'StaticCall(address,bytes,bytes32)';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async sendTransactionAsync(
                 txData?: Partial<TxData> | undefined,
                 opts: SendTransactionOpts = { shouldValidate: true },

packages/contract-wrappers/src/generated-wrappers/i_liquidity_provider.ts

@@ -347,6 +347,7 @@ export class ILiquidityProviderContract extends BaseContract {
         const functionSignature = 'bridgeTransferFrom(address,address,address,uint256,bytes)';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async sendTransactionAsync(
                 txData?: Partial<TxData> | undefined,
                 opts: SendTransactionOpts = { shouldValidate: true },
@@ -420,6 +421,7 @@ export class ILiquidityProviderContract extends BaseContract {
         const functionSignature = 'getBuyQuote(address,address,uint256)';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<BigNumber> {
                 BaseContract._assertCallParams(callData, defaultBlock);
                 const rawCallResult = await self._performCallAsync(
@@ -455,6 +457,7 @@ export class ILiquidityProviderContract extends BaseContract {
         const functionSignature = 'getSellQuote(address,address,uint256)';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<BigNumber> {
                 BaseContract._assertCallParams(callData, defaultBlock);
                 const rawCallResult = await self._performCallAsync(

packages/contract-wrappers/src/generated-wrappers/i_transform_erc20.ts

@@ -506,6 +506,7 @@ export class ITransformERC20Contract extends BaseContract {
             '_transformERC20((address,address,address,uint256,uint256,(uint32,bytes)[],bool,address))';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async sendTransactionAsync(
                 txData?: Partial<TxData> | undefined,
                 opts: SendTransactionOpts = { shouldValidate: true },
@@ -567,6 +568,7 @@ export class ITransformERC20Contract extends BaseContract {
         const functionSignature = 'createTransformWallet()';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async sendTransactionAsync(
                 txData?: Partial<TxData> | undefined,
                 opts: SendTransactionOpts = { shouldValidate: true },
@@ -626,6 +628,7 @@ export class ITransformERC20Contract extends BaseContract {
         const functionSignature = 'getQuoteSigner()';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async sendTransactionAsync(
                 txData?: Partial<TxData> | undefined,
                 opts: SendTransactionOpts = { shouldValidate: true },
@@ -686,6 +689,7 @@ export class ITransformERC20Contract extends BaseContract {
         const functionSignature = 'getTransformWallet()';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async sendTransactionAsync(
                 txData?: Partial<TxData> | undefined,
                 opts: SendTransactionOpts = { shouldValidate: true },
@@ -745,6 +749,7 @@ export class ITransformERC20Contract extends BaseContract {
         const functionSignature = 'getTransformerDeployer()';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async sendTransactionAsync(
                 txData?: Partial<TxData> | undefined,
                 opts: SendTransactionOpts = { shouldValidate: true },
@@ -807,6 +812,7 @@ export class ITransformERC20Contract extends BaseContract {
         const functionSignature = 'setQuoteSigner(address)';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async sendTransactionAsync(
                 txData?: Partial<TxData> | undefined,
                 opts: SendTransactionOpts = { shouldValidate: true },
@@ -870,6 +876,7 @@ export class ITransformERC20Contract extends BaseContract {
         const functionSignature = 'setTransformerDeployer(address)';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async sendTransactionAsync(
                 txData?: Partial<TxData> | undefined,
                 opts: SendTransactionOpts = { shouldValidate: true },
@@ -950,6 +957,7 @@ export class ITransformERC20Contract extends BaseContract {
         const functionSignature = 'transformERC20(address,address,uint256,uint256,(uint32,bytes)[])';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async sendTransactionAsync(
                 txData?: Partial<TxData> | undefined,
                 opts: SendTransactionOpts = { shouldValidate: true },

packages/contract-wrappers/src/generated-wrappers/i_zero_ex.ts

@@ -4639,6 +4639,7 @@ export class IZeroExContract extends BaseContract {
             '_fillLimitOrder((address,address,uint128,uint128,uint128,address,address,address,address,bytes32,uint64,uint256),(uint8,uint8,bytes32,bytes32),uint128,address,address)';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async sendTransactionAsync(
                 txData?: Partial<TxData> | undefined,
                 opts: SendTransactionOpts = { shouldValidate: true },
@@ -4738,6 +4739,7 @@ export class IZeroExContract extends BaseContract {
             '_fillOtcOrder((address,address,uint128,uint128,address,address,address,uint256),(uint8,uint8,bytes32,bytes32),uint128,address,bool,address)';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async sendTransactionAsync(
                 txData?: Partial<TxData> | undefined,
                 opts: SendTransactionOpts = { shouldValidate: true },
@@ -4838,6 +4840,7 @@ export class IZeroExContract extends BaseContract {
             '_fillRfqOrder((address,address,uint128,uint128,address,address,address,bytes32,uint64,uint256),(uint8,uint8,bytes32,bytes32),uint128,address,bool,address)';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async sendTransactionAsync(
                 txData?: Partial<TxData> | undefined,
                 opts: SendTransactionOpts = { shouldValidate: true },
@@ -4921,6 +4924,7 @@ export class IZeroExContract extends BaseContract {
         const functionSignature = '_sellHeldTokenForTokenToUniswapV3(bytes,uint256,uint256,address)';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async sendTransactionAsync(
                 txData?: Partial<TxData> | undefined,
                 opts: SendTransactionOpts = { shouldValidate: true },
@@ -4997,6 +5001,7 @@ export class IZeroExContract extends BaseContract {
             '_transformERC20((address,address,address,uint256,uint256,(uint32,bytes)[],bool,address))';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async sendTransactionAsync(
                 txData?: Partial<TxData> | undefined,
                 opts: SendTransactionOpts = { shouldValidate: true },
@@ -5075,6 +5080,7 @@ export class IZeroExContract extends BaseContract {
             'batchCancelLimitOrders((address,address,uint128,uint128,uint128,address,address,address,address,bytes32,uint64,uint256)[])';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async sendTransactionAsync(
                 txData?: Partial<TxData> | undefined,
                 opts: SendTransactionOpts = { shouldValidate: true },
@@ -5147,6 +5153,7 @@ export class IZeroExContract extends BaseContract {
         const functionSignature = 'batchCancelPairLimitOrders(address[],address[],uint256[])';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async sendTransactionAsync(
                 txData?: Partial<TxData> | undefined,
                 opts: SendTransactionOpts = { shouldValidate: true },
@@ -5222,6 +5229,7 @@ export class IZeroExContract extends BaseContract {
         const functionSignature = 'batchCancelPairLimitOrdersWithSigner(address,address[],address[],uint256[])';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async sendTransactionAsync(
                 txData?: Partial<TxData> | undefined,
                 opts: SendTransactionOpts = { shouldValidate: true },
@@ -5299,6 +5307,7 @@ export class IZeroExContract extends BaseContract {
         const functionSignature = 'batchCancelPairRfqOrders(address[],address[],uint256[])';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async sendTransactionAsync(
                 txData?: Partial<TxData> | undefined,
                 opts: SendTransactionOpts = { shouldValidate: true },
@@ -5374,6 +5383,7 @@ export class IZeroExContract extends BaseContract {
         const functionSignature = 'batchCancelPairRfqOrdersWithSigner(address,address[],address[],uint256[])';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async sendTransactionAsync(
                 txData?: Partial<TxData> | undefined,
                 opts: SendTransactionOpts = { shouldValidate: true },
@@ -5455,6 +5465,7 @@ export class IZeroExContract extends BaseContract {
             'batchCancelRfqOrders((address,address,uint128,uint128,address,address,address,bytes32,uint64,uint256)[])';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async sendTransactionAsync(
                 txData?: Partial<TxData> | undefined,
                 opts: SendTransactionOpts = { shouldValidate: true },
@@ -5533,6 +5544,7 @@ export class IZeroExContract extends BaseContract {
             'batchExecuteMetaTransactions((address,address,uint256,uint256,uint256,uint256,bytes,uint256,address,uint256)[],(uint8,uint8,bytes32,bytes32)[])';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async sendTransactionAsync(
                 txData?: Partial<TxData> | undefined,
                 opts: SendTransactionOpts = { shouldValidate: true },
@@ -5620,6 +5632,7 @@ export class IZeroExContract extends BaseContract {
             'batchFillLimitOrders((address,address,uint128,uint128,uint128,address,address,address,address,bytes32,uint64,uint256)[],(uint8,uint8,bytes32,bytes32)[],uint128[],bool)';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async sendTransactionAsync(
                 txData?: Partial<TxData> | undefined,
                 opts: SendTransactionOpts = { shouldValidate: true },
@@ -5713,6 +5726,7 @@ export class IZeroExContract extends BaseContract {
             'batchFillRfqOrders((address,address,uint128,uint128,address,address,address,bytes32,uint64,uint256)[],(uint8,uint8,bytes32,bytes32)[],uint128[],bool)';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async sendTransactionAsync(
                 txData?: Partial<TxData> | undefined,
                 opts: SendTransactionOpts = { shouldValidate: true },
@@ -5805,6 +5819,7 @@ export class IZeroExContract extends BaseContract {
             'batchFillTakerSignedOtcOrders((address,address,uint128,uint128,address,address,address,uint256)[],(uint8,uint8,bytes32,bytes32)[],(uint8,uint8,bytes32,bytes32)[],bool[])';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async sendTransactionAsync(
                 txData?: Partial<TxData> | undefined,
                 opts: SendTransactionOpts = { shouldValidate: true },
@@ -5894,6 +5909,7 @@ export class IZeroExContract extends BaseContract {
             'batchGetLimitOrderRelevantStates((address,address,uint128,uint128,uint128,address,address,address,address,bytes32,uint64,uint256)[],(uint8,uint8,bytes32,bytes32)[])';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async sendTransactionAsync(
                 txData?: Partial<TxData> | undefined,
                 opts: SendTransactionOpts = { shouldValidate: true },
@@ -5991,6 +6007,7 @@ export class IZeroExContract extends BaseContract {
             'batchGetRfqOrderRelevantStates((address,address,uint128,uint128,address,address,address,bytes32,uint64,uint256)[],(uint8,uint8,bytes32,bytes32)[])';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async sendTransactionAsync(
                 txData?: Partial<TxData> | undefined,
                 opts: SendTransactionOpts = { shouldValidate: true },
@@ -6082,6 +6099,7 @@ export class IZeroExContract extends BaseContract {
             'cancelLimitOrder((address,address,uint128,uint128,uint128,address,address,address,address,bytes32,uint64,uint256))';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async sendTransactionAsync(
                 txData?: Partial<TxData> | undefined,
                 opts: SendTransactionOpts = { shouldValidate: true },
@@ -6154,6 +6172,7 @@ export class IZeroExContract extends BaseContract {
         const functionSignature = 'cancelPairLimitOrders(address,address,uint256)';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async sendTransactionAsync(
                 txData?: Partial<TxData> | undefined,
                 opts: SendTransactionOpts = { shouldValidate: true },
@@ -6233,6 +6252,7 @@ export class IZeroExContract extends BaseContract {
         const functionSignature = 'cancelPairLimitOrdersWithSigner(address,address,address,uint256)';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async sendTransactionAsync(
                 txData?: Partial<TxData> | undefined,
                 opts: SendTransactionOpts = { shouldValidate: true },
@@ -6310,6 +6330,7 @@ export class IZeroExContract extends BaseContract {
         const functionSignature = 'cancelPairRfqOrders(address,address,uint256)';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async sendTransactionAsync(
                 txData?: Partial<TxData> | undefined,
                 opts: SendTransactionOpts = { shouldValidate: true },
@@ -6389,6 +6410,7 @@ export class IZeroExContract extends BaseContract {
         const functionSignature = 'cancelPairRfqOrdersWithSigner(address,address,address,uint256)';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async sendTransactionAsync(
                 txData?: Partial<TxData> | undefined,
                 opts: SendTransactionOpts = { shouldValidate: true },
@@ -6468,6 +6490,7 @@ export class IZeroExContract extends BaseContract {
             'cancelRfqOrder((address,address,uint128,uint128,address,address,address,bytes32,uint64,uint256))';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async sendTransactionAsync(
                 txData?: Partial<TxData> | undefined,
                 opts: SendTransactionOpts = { shouldValidate: true },
@@ -6529,6 +6552,7 @@ export class IZeroExContract extends BaseContract {
         const functionSignature = 'createTransformWallet()';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async sendTransactionAsync(
                 txData?: Partial<TxData> | undefined,
                 opts: SendTransactionOpts = { shouldValidate: true },
@@ -6606,6 +6630,7 @@ export class IZeroExContract extends BaseContract {
             'executeMetaTransaction((address,address,uint256,uint256,uint256,uint256,bytes,uint256,address,uint256),(uint8,uint8,bytes32,bytes32))';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async sendTransactionAsync(
                 txData?: Partial<TxData> | undefined,
                 opts: SendTransactionOpts = { shouldValidate: true },
@@ -6669,6 +6694,7 @@ export class IZeroExContract extends BaseContract {
         const functionSignature = 'extend(bytes4,address)';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async sendTransactionAsync(
                 txData?: Partial<TxData> | undefined,
                 opts: SendTransactionOpts = { shouldValidate: true },
@@ -6753,6 +6779,7 @@ export class IZeroExContract extends BaseContract {
             'fillLimitOrder((address,address,uint128,uint128,uint128,address,address,address,address,bytes32,uint64,uint256),(uint8,uint8,bytes32,bytes32),uint128)';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async sendTransactionAsync(
                 txData?: Partial<TxData> | undefined,
                 opts: SendTransactionOpts = { shouldValidate: true },
@@ -6841,6 +6868,7 @@ export class IZeroExContract extends BaseContract {
             'fillOrKillLimitOrder((address,address,uint128,uint128,uint128,address,address,address,address,bytes32,uint64,uint256),(uint8,uint8,bytes32,bytes32),uint128)';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async sendTransactionAsync(
                 txData?: Partial<TxData> | undefined,
                 opts: SendTransactionOpts = { shouldValidate: true },
@@ -6922,6 +6950,7 @@ export class IZeroExContract extends BaseContract {
             'fillOrKillRfqOrder((address,address,uint128,uint128,address,address,address,bytes32,uint64,uint256),(uint8,uint8,bytes32,bytes32),uint128)';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async sendTransactionAsync(
                 txData?: Partial<TxData> | undefined,
                 opts: SendTransactionOpts = { shouldValidate: true },
@@ -7001,6 +7030,7 @@ export class IZeroExContract extends BaseContract {
             'fillOtcOrder((address,address,uint128,uint128,address,address,address,uint256),(uint8,uint8,bytes32,bytes32),uint128)';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async sendTransactionAsync(
                 txData?: Partial<TxData> | undefined,
                 opts: SendTransactionOpts = { shouldValidate: true },
@@ -7085,6 +7115,7 @@ export class IZeroExContract extends BaseContract {
             'fillOtcOrderForEth((address,address,uint128,uint128,address,address,address,uint256),(uint8,uint8,bytes32,bytes32),uint128)';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async sendTransactionAsync(
                 txData?: Partial<TxData> | undefined,
                 opts: SendTransactionOpts = { shouldValidate: true },
@@ -7164,6 +7195,7 @@ export class IZeroExContract extends BaseContract {
             'fillOtcOrderWithEth((address,address,uint128,uint128,address,address,address,uint256),(uint8,uint8,bytes32,bytes32))';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async sendTransactionAsync(
                 txData?: Partial<TxData> | undefined,
                 opts: SendTransactionOpts = { shouldValidate: true },
@@ -7249,6 +7281,7 @@ export class IZeroExContract extends BaseContract {
             'fillRfqOrder((address,address,uint128,uint128,address,address,address,bytes32,uint64,uint256),(uint8,uint8,bytes32,bytes32),uint128)';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async sendTransactionAsync(
                 txData?: Partial<TxData> | undefined,
                 opts: SendTransactionOpts = { shouldValidate: true },
@@ -7330,6 +7363,7 @@ export class IZeroExContract extends BaseContract {
             'fillTakerSignedOtcOrder((address,address,uint128,uint128,address,address,address,uint256),(uint8,uint8,bytes32,bytes32),(uint8,uint8,bytes32,bytes32))';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async sendTransactionAsync(
                 txData?: Partial<TxData> | undefined,
                 opts: SendTransactionOpts = { shouldValidate: true },
@@ -7410,6 +7444,7 @@ export class IZeroExContract extends BaseContract {
             'fillTakerSignedOtcOrderForEth((address,address,uint128,uint128,address,address,address,uint256),(uint8,uint8,bytes32,bytes32),(uint8,uint8,bytes32,bytes32))';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async sendTransactionAsync(
                 txData?: Partial<TxData> | undefined,
                 opts: SendTransactionOpts = { shouldValidate: true },
@@ -7485,6 +7520,7 @@ export class IZeroExContract extends BaseContract {
             'getLimitOrderHash((address,address,uint128,uint128,uint128,address,address,address,address,bytes32,uint64,uint256))';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async sendTransactionAsync(
                 txData?: Partial<TxData> | undefined,
                 opts: SendTransactionOpts = { shouldValidate: true },
@@ -7560,6 +7596,7 @@ export class IZeroExContract extends BaseContract {
             'getLimitOrderInfo((address,address,uint128,uint128,uint128,address,address,address,address,bytes32,uint64,uint256))';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async sendTransactionAsync(
                 txData?: Partial<TxData> | undefined,
                 opts: SendTransactionOpts = { shouldValidate: true },
@@ -7649,6 +7686,7 @@ export class IZeroExContract extends BaseContract {
             'getLimitOrderRelevantState((address,address,uint128,uint128,uint128,address,address,address,address,bytes32,uint64,uint256),(uint8,uint8,bytes32,bytes32))';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async sendTransactionAsync(
                 txData?: Partial<TxData> | undefined,
                 opts: SendTransactionOpts = { shouldValidate: true },
@@ -7727,6 +7765,7 @@ export class IZeroExContract extends BaseContract {
             'getMetaTransactionExecutedBlock((address,address,uint256,uint256,uint256,uint256,bytes,uint256,address,uint256))';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async sendTransactionAsync(
                 txData?: Partial<TxData> | undefined,
                 opts: SendTransactionOpts = { shouldValidate: true },
@@ -7800,6 +7839,7 @@ export class IZeroExContract extends BaseContract {
             'getMetaTransactionHash((address,address,uint256,uint256,uint256,uint256,bytes,uint256,address,uint256))';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async sendTransactionAsync(
                 txData?: Partial<TxData> | undefined,
                 opts: SendTransactionOpts = { shouldValidate: true },
@@ -7861,6 +7901,7 @@ export class IZeroExContract extends BaseContract {
         const functionSignature = 'getMetaTransactionHashExecutedBlock(bytes32)';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async sendTransactionAsync(
                 txData?: Partial<TxData> | undefined,
                 opts: SendTransactionOpts = { shouldValidate: true },
@@ -7931,6 +7972,7 @@ export class IZeroExContract extends BaseContract {
         const functionSignature = 'getOtcOrderHash((address,address,uint128,uint128,address,address,address,uint256))';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async sendTransactionAsync(
                 txData?: Partial<TxData> | undefined,
                 opts: SendTransactionOpts = { shouldValidate: true },
@@ -8001,6 +8043,7 @@ export class IZeroExContract extends BaseContract {
         const functionSignature = 'getOtcOrderInfo((address,address,uint128,uint128,address,address,address,uint256))';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async sendTransactionAsync(
                 txData?: Partial<TxData> | undefined,
                 opts: SendTransactionOpts = { shouldValidate: true },
@@ -8064,6 +8107,7 @@ export class IZeroExContract extends BaseContract {
         const functionSignature = 'getProtocolFeeMultiplier()';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async sendTransactionAsync(
                 txData?: Partial<TxData> | undefined,
                 opts: SendTransactionOpts = { shouldValidate: true },
@@ -8123,6 +8167,7 @@ export class IZeroExContract extends BaseContract {
         const functionSignature = 'getQuoteSigner()';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async sendTransactionAsync(
                 txData?: Partial<TxData> | undefined,
                 opts: SendTransactionOpts = { shouldValidate: true },
@@ -8196,6 +8241,7 @@ export class IZeroExContract extends BaseContract {
             'getRfqOrderHash((address,address,uint128,uint128,address,address,address,bytes32,uint64,uint256))';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async sendTransactionAsync(
                 txData?: Partial<TxData> | undefined,
                 opts: SendTransactionOpts = { shouldValidate: true },
@@ -8269,6 +8315,7 @@ export class IZeroExContract extends BaseContract {
             'getRfqOrderInfo((address,address,uint128,uint128,address,address,address,bytes32,uint64,uint256))';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async sendTransactionAsync(
                 txData?: Partial<TxData> | undefined,
                 opts: SendTransactionOpts = { shouldValidate: true },
@@ -8356,6 +8403,7 @@ export class IZeroExContract extends BaseContract {
             'getRfqOrderRelevantState((address,address,uint128,uint128,address,address,address,bytes32,uint64,uint256),(uint8,uint8,bytes32,bytes32))';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async sendTransactionAsync(
                 txData?: Partial<TxData> | undefined,
                 opts: SendTransactionOpts = { shouldValidate: true },
@@ -8424,6 +8472,7 @@ export class IZeroExContract extends BaseContract {
         const functionSignature = 'getRollbackEntryAtIndex(bytes4,uint256)';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async sendTransactionAsync(
                 txData?: Partial<TxData> | undefined,
                 opts: SendTransactionOpts = { shouldValidate: true },
@@ -8485,6 +8534,7 @@ export class IZeroExContract extends BaseContract {
         const functionSignature = 'getRollbackLength(bytes4)';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async sendTransactionAsync(
                 txData?: Partial<TxData> | undefined,
                 opts: SendTransactionOpts = { shouldValidate: true },
@@ -8545,6 +8595,7 @@ export class IZeroExContract extends BaseContract {
         const functionSignature = 'getTransformWallet()';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async sendTransactionAsync(
                 txData?: Partial<TxData> | undefined,
                 opts: SendTransactionOpts = { shouldValidate: true },
@@ -8604,6 +8655,7 @@ export class IZeroExContract extends BaseContract {
         const functionSignature = 'getTransformerDeployer()';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async sendTransactionAsync(
                 txData?: Partial<TxData> | undefined,
                 opts: SendTransactionOpts = { shouldValidate: true },
@@ -8667,6 +8719,7 @@ export class IZeroExContract extends BaseContract {
         const functionSignature = 'isValidOrderSigner(address,address)';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async sendTransactionAsync(
                 txData?: Partial<TxData> | undefined,
                 opts: SendTransactionOpts = { shouldValidate: true },
@@ -8731,6 +8784,7 @@ export class IZeroExContract extends BaseContract {
         const functionSignature = 'lastOtcTxOriginNonce(address,uint64)';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async sendTransactionAsync(
                 txData?: Partial<TxData> | undefined,
                 opts: SendTransactionOpts = { shouldValidate: true },
@@ -8800,6 +8854,7 @@ export class IZeroExContract extends BaseContract {
         const functionSignature = 'migrate(address,bytes,address)';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async sendTransactionAsync(
                 txData?: Partial<TxData> | undefined,
                 opts: SendTransactionOpts = { shouldValidate: true },
@@ -8875,6 +8930,7 @@ export class IZeroExContract extends BaseContract {
         const functionSignature = 'multiplexBatchSellEthForToken(address,(uint8,uint256,bytes)[],uint256)';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async sendTransactionAsync(
                 txData?: Partial<TxData> | undefined,
                 opts: SendTransactionOpts = { shouldValidate: true },
@@ -8949,6 +9005,7 @@ export class IZeroExContract extends BaseContract {
         const functionSignature = 'multiplexBatchSellTokenForEth(address,(uint8,uint256,bytes)[],uint256,uint256)';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async sendTransactionAsync(
                 txData?: Partial<TxData> | undefined,
                 opts: SendTransactionOpts = { shouldValidate: true },
@@ -9032,6 +9089,7 @@ export class IZeroExContract extends BaseContract {
             'multiplexBatchSellTokenForToken(address,address,(uint8,uint256,bytes)[],uint256,uint256)';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async sendTransactionAsync(
                 txData?: Partial<TxData> | undefined,
                 opts: SendTransactionOpts = { shouldValidate: true },
@@ -9112,6 +9170,7 @@ export class IZeroExContract extends BaseContract {
         const functionSignature = 'multiplexMultiHopSellEthForToken(address[],(uint8,bytes)[],uint256)';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async sendTransactionAsync(
                 txData?: Partial<TxData> | undefined,
                 opts: SendTransactionOpts = { shouldValidate: true },
@@ -9187,6 +9246,7 @@ export class IZeroExContract extends BaseContract {
         const functionSignature = 'multiplexMultiHopSellTokenForEth(address[],(uint8,bytes)[],uint256,uint256)';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async sendTransactionAsync(
                 txData?: Partial<TxData> | undefined,
                 opts: SendTransactionOpts = { shouldValidate: true },
@@ -9263,6 +9323,7 @@ export class IZeroExContract extends BaseContract {
         const functionSignature = 'multiplexMultiHopSellTokenForToken(address[],(uint8,bytes)[],uint256,uint256)';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async sendTransactionAsync(
                 txData?: Partial<TxData> | undefined,
                 opts: SendTransactionOpts = { shouldValidate: true },
@@ -9322,6 +9383,7 @@ export class IZeroExContract extends BaseContract {
         const functionSignature = 'owner()';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async sendTransactionAsync(
                 txData?: Partial<TxData> | undefined,
                 opts: SendTransactionOpts = { shouldValidate: true },
@@ -9386,6 +9448,7 @@ export class IZeroExContract extends BaseContract {
         const functionSignature = 'registerAllowedOrderSigner(address,bool)';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async sendTransactionAsync(
                 txData?: Partial<TxData> | undefined,
                 opts: SendTransactionOpts = { shouldValidate: true },
@@ -9450,6 +9513,7 @@ export class IZeroExContract extends BaseContract {
         const functionSignature = 'registerAllowedRfqOrigins(address[],bool)';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async sendTransactionAsync(
                 txData?: Partial<TxData> | undefined,
                 opts: SendTransactionOpts = { shouldValidate: true },
@@ -9513,6 +9577,7 @@ export class IZeroExContract extends BaseContract {
         const functionSignature = 'rollback(bytes4,address)';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async sendTransactionAsync(
                 txData?: Partial<TxData> | undefined,
                 opts: SendTransactionOpts = { shouldValidate: true },
@@ -9582,6 +9647,7 @@ export class IZeroExContract extends BaseContract {
         const functionSignature = 'sellEthForTokenToUniswapV3(bytes,uint256,address)';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async sendTransactionAsync(
                 txData?: Partial<TxData> | undefined,
                 opts: SendTransactionOpts = { shouldValidate: true },
@@ -9671,6 +9737,7 @@ export class IZeroExContract extends BaseContract {
         const functionSignature = 'sellToLiquidityProvider(address,address,address,address,uint256,uint256,bytes)';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async sendTransactionAsync(
                 txData?: Partial<TxData> | undefined,
                 opts: SendTransactionOpts = { shouldValidate: true },
@@ -9751,6 +9818,7 @@ export class IZeroExContract extends BaseContract {
         const functionSignature = 'sellToPancakeSwap(address[],uint256,uint256,uint8)';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async sendTransactionAsync(
                 txData?: Partial<TxData> | undefined,
                 opts: SendTransactionOpts = { shouldValidate: true },
@@ -9823,6 +9891,7 @@ export class IZeroExContract extends BaseContract {
         const functionSignature = 'sellToUniswap(address[],uint256,uint256,bool)';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async sendTransactionAsync(
                 txData?: Partial<TxData> | undefined,
                 opts: SendTransactionOpts = { shouldValidate: true },
@@ -9895,6 +9964,7 @@ export class IZeroExContract extends BaseContract {
         const functionSignature = 'sellTokenForEthToUniswapV3(bytes,uint256,uint256,address)';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async sendTransactionAsync(
                 txData?: Partial<TxData> | undefined,
                 opts: SendTransactionOpts = { shouldValidate: true },
@@ -9972,6 +10042,7 @@ export class IZeroExContract extends BaseContract {
         const functionSignature = 'sellTokenForTokenToUniswapV3(bytes,uint256,uint256,address)';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async sendTransactionAsync(
                 txData?: Partial<TxData> | undefined,
                 opts: SendTransactionOpts = { shouldValidate: true },
@@ -10039,6 +10110,7 @@ export class IZeroExContract extends BaseContract {
         const functionSignature = 'setQuoteSigner(address)';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async sendTransactionAsync(
                 txData?: Partial<TxData> | undefined,
                 opts: SendTransactionOpts = { shouldValidate: true },
@@ -10102,6 +10174,7 @@ export class IZeroExContract extends BaseContract {
         const functionSignature = 'setTransformerDeployer(address)';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async sendTransactionAsync(
                 txData?: Partial<TxData> | undefined,
                 opts: SendTransactionOpts = { shouldValidate: true },
@@ -10163,6 +10236,7 @@ export class IZeroExContract extends BaseContract {
         const functionSignature = 'transferOwnership(address)';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async sendTransactionAsync(
                 txData?: Partial<TxData> | undefined,
                 opts: SendTransactionOpts = { shouldValidate: true },
@@ -10225,6 +10299,7 @@ export class IZeroExContract extends BaseContract {
         const functionSignature = 'transferProtocolFeesForPools(bytes32[])';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async sendTransactionAsync(
                 txData?: Partial<TxData> | undefined,
                 opts: SendTransactionOpts = { shouldValidate: true },
@@ -10305,6 +10380,7 @@ export class IZeroExContract extends BaseContract {
         const functionSignature = 'transformERC20(address,address,uint256,uint256,(uint32,bytes)[])';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async sendTransactionAsync(
                 txData?: Partial<TxData> | undefined,
                 opts: SendTransactionOpts = { shouldValidate: true },
@@ -10383,6 +10459,7 @@ export class IZeroExContract extends BaseContract {
         const functionSignature = 'uniswapV3SwapCallback(int256,int256,bytes)';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async sendTransactionAsync(
                 txData?: Partial<TxData> | undefined,
                 opts: SendTransactionOpts = { shouldValidate: true },

packages/contract-wrappers/src/generated-wrappers/maximum_gas_price.ts

@@ -253,6 +253,7 @@ export class MaximumGasPriceContract extends BaseContract {
         const functionSignature = 'checkGasPrice()';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<void> {
                 BaseContract._assertCallParams(callData, defaultBlock);
                 const rawCallResult = await self._performCallAsync(
@@ -280,6 +281,7 @@ export class MaximumGasPriceContract extends BaseContract {
         const functionSignature = 'checkGasPrice(uint256)';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<void> {
                 BaseContract._assertCallParams(callData, defaultBlock);
                 const rawCallResult = await self._performCallAsync(

packages/contract-wrappers/src/generated-wrappers/staking.ts

@@ -1697,6 +1697,7 @@ export class StakingContract extends BaseContract {
         const functionSignature = 'addAuthorizedAddress(address)';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async sendTransactionAsync(
                 txData?: Partial<TxData> | undefined,
                 opts: SendTransactionOpts = { shouldValidate: true },
@@ -1758,6 +1759,7 @@ export class StakingContract extends BaseContract {
         const functionSignature = 'addExchangeAddress(address)';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async sendTransactionAsync(
                 txData?: Partial<TxData> | undefined,
                 opts: SendTransactionOpts = { shouldValidate: true },
@@ -1817,6 +1819,7 @@ export class StakingContract extends BaseContract {
         const functionSignature = 'aggregatedStatsByEpoch(uint256)';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async callAsync(
                 callData: Partial<CallData> = {},
                 defaultBlock?: BlockParam,
@@ -1843,6 +1846,7 @@ export class StakingContract extends BaseContract {
         const functionSignature = 'authorities(uint256)';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<string> {
                 BaseContract._assertCallParams(callData, defaultBlock);
                 const rawCallResult = await self._performCallAsync(
@@ -1864,6 +1868,7 @@ export class StakingContract extends BaseContract {
         const functionSignature = 'authorized(address)';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<boolean> {
                 BaseContract._assertCallParams(callData, defaultBlock);
                 const rawCallResult = await self._performCallAsync(
@@ -1884,6 +1889,7 @@ export class StakingContract extends BaseContract {
         const functionSignature = 'cobbDouglasAlphaDenominator()';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<number> {
                 BaseContract._assertCallParams(callData, defaultBlock);
                 const rawCallResult = await self._performCallAsync(
@@ -1904,6 +1910,7 @@ export class StakingContract extends BaseContract {
         const functionSignature = 'cobbDouglasAlphaNumerator()';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<number> {
                 BaseContract._assertCallParams(callData, defaultBlock);
                 const rawCallResult = await self._performCallAsync(
@@ -1932,6 +1939,7 @@ export class StakingContract extends BaseContract {
         const functionSignature = 'computeRewardBalanceOfDelegator(bytes32,address)';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<BigNumber> {
                 BaseContract._assertCallParams(callData, defaultBlock);
                 const rawCallResult = await self._performCallAsync(
@@ -1958,6 +1966,7 @@ export class StakingContract extends BaseContract {
         const functionSignature = 'computeRewardBalanceOfOperator(bytes32)';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<BigNumber> {
                 BaseContract._assertCallParams(callData, defaultBlock);
                 const rawCallResult = await self._performCallAsync(
@@ -1990,6 +1999,7 @@ export class StakingContract extends BaseContract {
         const functionSignature = 'createStakingPool(uint32,bool)';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async sendTransactionAsync(
                 txData?: Partial<TxData> | undefined,
                 opts: SendTransactionOpts = { shouldValidate: true },
@@ -2046,6 +2056,7 @@ export class StakingContract extends BaseContract {
         const functionSignature = 'currentEpoch()';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<BigNumber> {
                 BaseContract._assertCallParams(callData, defaultBlock);
                 const rawCallResult = await self._performCallAsync(
@@ -2066,6 +2077,7 @@ export class StakingContract extends BaseContract {
         const functionSignature = 'currentEpochStartTimeInSeconds()';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<BigNumber> {
                 BaseContract._assertCallParams(callData, defaultBlock);
                 const rawCallResult = await self._performCallAsync(
@@ -2097,6 +2109,7 @@ export class StakingContract extends BaseContract {
         const functionSignature = 'decreaseStakingPoolOperatorShare(bytes32,uint32)';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async sendTransactionAsync(
                 txData?: Partial<TxData> | undefined,
                 opts: SendTransactionOpts = { shouldValidate: true },
@@ -2159,6 +2172,7 @@ export class StakingContract extends BaseContract {
         const functionSignature = 'endEpoch()';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async sendTransactionAsync(
                 txData?: Partial<TxData> | undefined,
                 opts: SendTransactionOpts = { shouldValidate: true },
@@ -2215,6 +2229,7 @@ export class StakingContract extends BaseContract {
         const functionSignature = 'epochDurationInSeconds()';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<BigNumber> {
                 BaseContract._assertCallParams(callData, defaultBlock);
                 const rawCallResult = await self._performCallAsync(
@@ -2244,6 +2259,7 @@ export class StakingContract extends BaseContract {
         const functionSignature = 'finalizePool(bytes32)';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async sendTransactionAsync(
                 txData?: Partial<TxData> | undefined,
                 opts: SendTransactionOpts = { shouldValidate: true },
@@ -2304,6 +2320,7 @@ export class StakingContract extends BaseContract {
         const functionSignature = 'getAuthorizedAddresses()';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<string[]> {
                 BaseContract._assertCallParams(callData, defaultBlock);
                 const rawCallResult = await self._performCallAsync(
@@ -2330,6 +2347,7 @@ export class StakingContract extends BaseContract {
         const functionSignature = 'getCurrentEpochEarliestEndTimeInSeconds()';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<BigNumber> {
                 BaseContract._assertCallParams(callData, defaultBlock);
                 const rawCallResult = await self._performCallAsync(
@@ -2358,6 +2376,7 @@ export class StakingContract extends BaseContract {
         const functionSignature = 'getGlobalStakeByStatus(uint8)';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async callAsync(
                 callData: Partial<CallData> = {},
                 defaultBlock?: BlockParam,
@@ -2396,6 +2415,7 @@ export class StakingContract extends BaseContract {
         const functionSignature = 'getOwnerStakeByStatus(address,uint8)';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async callAsync(
                 callData: Partial<CallData> = {},
                 defaultBlock?: BlockParam,
@@ -2427,6 +2447,7 @@ export class StakingContract extends BaseContract {
         const functionSignature = 'getParams()';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async callAsync(
                 callData: Partial<CallData> = {},
                 defaultBlock?: BlockParam,
@@ -2463,6 +2484,7 @@ export class StakingContract extends BaseContract {
         const functionSignature = 'getStakeDelegatedToPoolByOwner(address,bytes32)';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async callAsync(
                 callData: Partial<CallData> = {},
                 defaultBlock?: BlockParam,
@@ -2495,6 +2517,7 @@ export class StakingContract extends BaseContract {
         const functionSignature = 'getStakingPool(bytes32)';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async callAsync(
                 callData: Partial<CallData> = {},
                 defaultBlock?: BlockParam,
@@ -2526,6 +2549,7 @@ export class StakingContract extends BaseContract {
         const functionSignature = 'getStakingPoolStatsThisEpoch(bytes32)';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async callAsync(
                 callData: Partial<CallData> = {},
                 defaultBlock?: BlockParam,
@@ -2559,6 +2583,7 @@ export class StakingContract extends BaseContract {
         const functionSignature = 'getTotalStake(address)';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<BigNumber> {
                 BaseContract._assertCallParams(callData, defaultBlock);
                 const rawCallResult = await self._performCallAsync(
@@ -2588,6 +2613,7 @@ export class StakingContract extends BaseContract {
         const functionSignature = 'getTotalStakeDelegatedToPool(bytes32)';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async callAsync(
                 callData: Partial<CallData> = {},
                 defaultBlock?: BlockParam,
@@ -2620,6 +2646,7 @@ export class StakingContract extends BaseContract {
         const functionSignature = 'getWethContract()';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<string> {
                 BaseContract._assertCallParams(callData, defaultBlock);
                 const rawCallResult = await self._performCallAsync(
@@ -2645,6 +2672,7 @@ export class StakingContract extends BaseContract {
         const functionSignature = 'getZrxVault()';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<string> {
                 BaseContract._assertCallParams(callData, defaultBlock);
                 const rawCallResult = await self._performCallAsync(
@@ -2670,6 +2698,7 @@ export class StakingContract extends BaseContract {
         const functionSignature = 'init()';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async sendTransactionAsync(
                 txData?: Partial<TxData> | undefined,
                 opts: SendTransactionOpts = { shouldValidate: true },
@@ -2731,6 +2760,7 @@ export class StakingContract extends BaseContract {
         const functionSignature = 'joinStakingPoolAsMaker(bytes32)';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async sendTransactionAsync(
                 txData?: Partial<TxData> | undefined,
                 opts: SendTransactionOpts = { shouldValidate: true },
@@ -2787,6 +2817,7 @@ export class StakingContract extends BaseContract {
         const functionSignature = 'lastPoolId()';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<string> {
                 BaseContract._assertCallParams(callData, defaultBlock);
                 const rawCallResult = await self._performCallAsync(
@@ -2807,6 +2838,7 @@ export class StakingContract extends BaseContract {
         const functionSignature = 'minimumPoolStake()';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<BigNumber> {
                 BaseContract._assertCallParams(callData, defaultBlock);
                 const rawCallResult = await self._performCallAsync(
@@ -2841,6 +2873,7 @@ export class StakingContract extends BaseContract {
         const functionSignature = 'moveStake((uint8,bytes32),(uint8,bytes32),uint256)';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async sendTransactionAsync(
                 txData?: Partial<TxData> | undefined,
                 opts: SendTransactionOpts = { shouldValidate: true },
@@ -2897,6 +2930,7 @@ export class StakingContract extends BaseContract {
         const functionSignature = 'owner()';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<string> {
                 BaseContract._assertCallParams(callData, defaultBlock);
                 const rawCallResult = await self._performCallAsync(
@@ -2933,6 +2967,7 @@ export class StakingContract extends BaseContract {
         const functionSignature = 'payProtocolFee(address,address,uint256)';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async sendTransactionAsync(
                 txData?: Partial<TxData> | undefined,
                 opts: SendTransactionOpts = { shouldValidate: true },
@@ -2994,6 +3029,7 @@ export class StakingContract extends BaseContract {
         const functionSignature = 'poolIdByMaker(address)';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<string> {
                 BaseContract._assertCallParams(callData, defaultBlock);
                 const rawCallResult = await self._performCallAsync(
@@ -3019,6 +3055,7 @@ export class StakingContract extends BaseContract {
         const functionSignature = 'poolStatsByEpoch(bytes32,uint256)';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async callAsync(
                 callData: Partial<CallData> = {},
                 defaultBlock?: BlockParam,
@@ -3047,6 +3084,7 @@ export class StakingContract extends BaseContract {
         const functionSignature = 'removeAuthorizedAddress(address)';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async sendTransactionAsync(
                 txData?: Partial<TxData> | undefined,
                 opts: SendTransactionOpts = { shouldValidate: true },
@@ -3110,6 +3148,7 @@ export class StakingContract extends BaseContract {
         const functionSignature = 'removeAuthorizedAddressAtIndex(address,uint256)';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async sendTransactionAsync(
                 txData?: Partial<TxData> | undefined,
                 opts: SendTransactionOpts = { shouldValidate: true },
@@ -3171,6 +3210,7 @@ export class StakingContract extends BaseContract {
         const functionSignature = 'removeExchangeAddress(address)';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async sendTransactionAsync(
                 txData?: Partial<TxData> | undefined,
                 opts: SendTransactionOpts = { shouldValidate: true },
@@ -3227,6 +3267,7 @@ export class StakingContract extends BaseContract {
         const functionSignature = 'rewardDelegatedStakeWeight()';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<number> {
                 BaseContract._assertCallParams(callData, defaultBlock);
                 const rawCallResult = await self._performCallAsync(
@@ -3248,6 +3289,7 @@ export class StakingContract extends BaseContract {
         const functionSignature = 'rewardsByPoolId(bytes32)';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<BigNumber> {
                 BaseContract._assertCallParams(callData, defaultBlock);
                 const rawCallResult = await self._performCallAsync(
@@ -3290,6 +3332,7 @@ export class StakingContract extends BaseContract {
         const functionSignature = 'setParams(uint256,uint32,uint256,uint32,uint32)';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async sendTransactionAsync(
                 txData?: Partial<TxData> | undefined,
                 opts: SendTransactionOpts = { shouldValidate: true },
@@ -3358,6 +3401,7 @@ export class StakingContract extends BaseContract {
         const functionSignature = 'stake(uint256)';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async sendTransactionAsync(
                 txData?: Partial<TxData> | undefined,
                 opts: SendTransactionOpts = { shouldValidate: true },
@@ -3414,6 +3458,7 @@ export class StakingContract extends BaseContract {
         const functionSignature = 'stakingContract()';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<string> {
                 BaseContract._assertCallParams(callData, defaultBlock);
                 const rawCallResult = await self._performCallAsync(
@@ -3439,6 +3484,7 @@ export class StakingContract extends BaseContract {
         const functionSignature = 'transferOwnership(address)';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async sendTransactionAsync(
                 txData?: Partial<TxData> | undefined,
                 opts: SendTransactionOpts = { shouldValidate: true },
@@ -3502,6 +3548,7 @@ export class StakingContract extends BaseContract {
         const functionSignature = 'unstake(uint256)';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async sendTransactionAsync(
                 txData?: Partial<TxData> | undefined,
                 opts: SendTransactionOpts = { shouldValidate: true },
@@ -3559,6 +3606,7 @@ export class StakingContract extends BaseContract {
         const functionSignature = 'validExchanges(address)';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<boolean> {
                 BaseContract._assertCallParams(callData, defaultBlock);
                 const rawCallResult = await self._performCallAsync(
@@ -3579,6 +3627,7 @@ export class StakingContract extends BaseContract {
         const functionSignature = 'wethReservedForPoolRewards()';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async callAsync(callData: Partial<CallData> = {}, defaultBlock?: BlockParam): Promise<BigNumber> {
                 BaseContract._assertCallParams(callData, defaultBlock);
                 const rawCallResult = await self._performCallAsync(
@@ -3605,6 +3654,7 @@ export class StakingContract extends BaseContract {
         const functionSignature = 'withdrawDelegatorRewards(bytes32)';
 
         return {
+            selector: self._lookupAbiEncoder(functionSignature).getSelector(),
             async sendTransactionAsync(
                 txData?: Partial<TxData> | undefined,
                 opts: SendTransactionOpts = { shouldValidate: true },