Move generated contract wrappers and artifacts into contracts package

7 files changed, 0 insertions, 872 deletions

diff --git a/packages/contracts/src/2.0.0/protocol/Exchange/libs/LibAbiEncoder.sol b/packages/contracts/src/2.0.0/protocol/Exchange/libs/LibAbiEncoder.sol
deleted file mode 100644
index 4aad37709..000000000
--- a/packages/contracts/src/2.0.0/protocol/Exchange/libs/LibAbiEncoder.sol
+++ /dev/null
@@ -1,215 +0,0 @@
-/*
-
-  Copyright 2018 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.4.24;
-pragma experimental ABIEncoderV2;
-
-import "./LibOrder.sol";
-
-
-contract LibAbiEncoder {
-
-    /// @dev ABI encodes calldata for `fillOrder`.
-    /// @param order Order struct containing order specifications.
-    /// @param takerAssetFillAmount Desired amount of takerAsset to sell.
-    /// @param signature Proof that order has been created by maker.
-    /// @return ABI encoded calldata for `fillOrder`.
-    function abiEncodeFillOrder(
-        LibOrder.Order memory order,
-        uint256 takerAssetFillAmount,
-        bytes memory signature
-    )
-        internal
-        pure
-        returns (bytes memory fillOrderCalldata)
-    {
-        // We need to call MExchangeCore.fillOrder using a delegatecall in
-        // assembly so that we can intercept a call that throws. For this, we
-        // need the input encoded in memory in the Ethereum ABIv2 format [1].
-
-        // | Area     | Offset | Length  | Contents                                    |
-        // | -------- |--------|---------|-------------------------------------------- |
-        // | Header   | 0x00   | 4       | function selector                           |
-        // | Params   |        | 3 * 32  | function parameters:                        |
-        // |          | 0x00   |         |   1. offset to order (*)                    |
-        // |          | 0x20   |         |   2. takerAssetFillAmount                   |
-        // |          | 0x40   |         |   3. offset to signature (*)                |
-        // | Data     |        | 12 * 32 | order:                                      |
-        // |          | 0x000  |         |   1.  senderAddress                         |
-        // |          | 0x020  |         |   2.  makerAddress                          |
-        // |          | 0x040  |         |   3.  takerAddress                          |
-        // |          | 0x060  |         |   4.  feeRecipientAddress                   |
-        // |          | 0x080  |         |   5.  makerAssetAmount                      |
-        // |          | 0x0A0  |         |   6.  takerAssetAmount                      |
-        // |          | 0x0C0  |         |   7.  makerFeeAmount                        |
-        // |          | 0x0E0  |         |   8.  takerFeeAmount                        |
-        // |          | 0x100  |         |   9.  expirationTimeSeconds                 |
-        // |          | 0x120  |         |   10. salt                                  |
-        // |          | 0x140  |         |   11. Offset to makerAssetData (*)          |
-        // |          | 0x160  |         |   12. Offset to takerAssetData (*)          |
-        // |          | 0x180  | 32      | makerAssetData Length                       |
-        // |          | 0x1A0  | **      | makerAssetData Contents                     |
-        // |          | 0x1C0  | 32      | takerAssetData Length                       |
-        // |          | 0x1E0  | **      | takerAssetData Contents                     |
-        // |          | 0x200  | 32      | signature Length                            |
-        // |          | 0x220  | **      | signature Contents                          |
-
-        // * Offsets are calculated from the beginning of the current area: Header, Params, Data:
-        //     An offset stored in the Params area is calculated from the beginning of the Params section.
-        //     An offset stored in the Data area is calculated from the beginning of the Data section.
-
-        // ** The length of dynamic array contents are stored in the field immediately preceeding the contents.
-
-        // [1]: https://solidity.readthedocs.io/en/develop/abi-spec.html
-
-        assembly {
-
-            // Areas below may use the following variables:
-            //   1. <area>Start   -- Start of this area in memory
-            //   2. <area>End     -- End of this area in memory. This value may
-            //                       be precomputed (before writing contents),
-            //                       or it may be computed as contents are written.
-            //   3. <area>Offset  -- Current offset into area. If an area's End
-            //                       is precomputed, this variable tracks the
-            //                       offsets of contents as they are written.
-
-            /////// Setup Header Area ///////
-            // Load free memory pointer
-            fillOrderCalldata := mload(0x40)
-            // bytes4(keccak256("fillOrder((address,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,bytes,bytes),uint256,bytes)"))
-            // = 0xb4be83d5
-            // Leave 0x20 bytes to store the length
-            mstore(add(fillOrderCalldata, 0x20), 0xb4be83d500000000000000000000000000000000000000000000000000000000)
-            let headerAreaEnd := add(fillOrderCalldata, 0x24)
-
-            /////// Setup Params Area ///////
-            // This area is preallocated and written to later.
-            // This is because we need to fill in offsets that have not yet been calculated.
-            let paramsAreaStart := headerAreaEnd
-            let paramsAreaEnd := add(paramsAreaStart, 0x60)
-            let paramsAreaOffset := paramsAreaStart
-
-            /////// Setup Data Area ///////
-            let dataAreaStart := paramsAreaEnd
-            let dataAreaEnd := dataAreaStart
-
-            // Offset from the source data we're reading from
-            let sourceOffset := order
-            // arrayLenBytes and arrayLenWords track the length of a dynamically-allocated bytes array.
-            let arrayLenBytes := 0
-            let arrayLenWords := 0
-
-            /////// Write order Struct ///////
-            // Write memory location of Order, relative to the start of the
-            // parameter list, then increment the paramsAreaOffset respectively.
-            mstore(paramsAreaOffset, sub(dataAreaEnd, paramsAreaStart))
-            paramsAreaOffset := add(paramsAreaOffset, 0x20)
-
-            // Write values for each field in the order
-            // It would be nice to use a loop, but we save on gas by writing
-            // the stores sequentially.
-            mstore(dataAreaEnd, mload(sourceOffset))                            // makerAddress
-            mstore(add(dataAreaEnd, 0x20), mload(add(sourceOffset, 0x20)))      // takerAddress
-            mstore(add(dataAreaEnd, 0x40), mload(add(sourceOffset, 0x40)))      // feeRecipientAddress
-            mstore(add(dataAreaEnd, 0x60), mload(add(sourceOffset, 0x60)))      // senderAddress
-            mstore(add(dataAreaEnd, 0x80), mload(add(sourceOffset, 0x80)))      // makerAssetAmount
-            mstore(add(dataAreaEnd, 0xA0), mload(add(sourceOffset, 0xA0)))      // takerAssetAmount
-            mstore(add(dataAreaEnd, 0xC0), mload(add(sourceOffset, 0xC0)))      // makerFeeAmount
-            mstore(add(dataAreaEnd, 0xE0), mload(add(sourceOffset, 0xE0)))      // takerFeeAmount
-            mstore(add(dataAreaEnd, 0x100), mload(add(sourceOffset, 0x100)))    // expirationTimeSeconds
-            mstore(add(dataAreaEnd, 0x120), mload(add(sourceOffset, 0x120)))    // salt
-            mstore(add(dataAreaEnd, 0x140), mload(add(sourceOffset, 0x140)))    // Offset to makerAssetData
-            mstore(add(dataAreaEnd, 0x160), mload(add(sourceOffset, 0x160)))    // Offset to takerAssetData
-            dataAreaEnd := add(dataAreaEnd, 0x180)
-            sourceOffset := add(sourceOffset, 0x180)
-
-            // Write offset to <order.makerAssetData>
-            mstore(add(dataAreaStart, mul(10, 0x20)), sub(dataAreaEnd, dataAreaStart))
-
-            // Calculate length of <order.makerAssetData>
-            sourceOffset := mload(add(order, 0x140)) // makerAssetData
-            arrayLenBytes := mload(sourceOffset)
-            sourceOffset := add(sourceOffset, 0x20)
-            arrayLenWords := div(add(arrayLenBytes, 0x1F), 0x20)
-
-            // Write length of <order.makerAssetData>
-            mstore(dataAreaEnd, arrayLenBytes)
-            dataAreaEnd := add(dataAreaEnd, 0x20)
-
-            // Write contents of <order.makerAssetData>
-            for {let i := 0} lt(i, arrayLenWords) {i := add(i, 1)} {
-                mstore(dataAreaEnd, mload(sourceOffset))
-                dataAreaEnd := add(dataAreaEnd, 0x20)
-                sourceOffset := add(sourceOffset, 0x20)
-            }
-
-            // Write offset to <order.takerAssetData>
-            mstore(add(dataAreaStart, mul(11, 0x20)), sub(dataAreaEnd, dataAreaStart))
-
-            // Calculate length of <order.takerAssetData>
-            sourceOffset := mload(add(order, 0x160)) // takerAssetData
-            arrayLenBytes := mload(sourceOffset)
-            sourceOffset := add(sourceOffset, 0x20)
-            arrayLenWords := div(add(arrayLenBytes, 0x1F), 0x20)
-
-            // Write length of <order.takerAssetData>
-            mstore(dataAreaEnd, arrayLenBytes)
-            dataAreaEnd := add(dataAreaEnd, 0x20)
-
-            // Write contents of  <order.takerAssetData>
-            for {let i := 0} lt(i, arrayLenWords) {i := add(i, 1)} {
-                mstore(dataAreaEnd, mload(sourceOffset))
-                dataAreaEnd := add(dataAreaEnd, 0x20)
-                sourceOffset := add(sourceOffset, 0x20)
-            }
-
-            /////// Write takerAssetFillAmount ///////
-            mstore(paramsAreaOffset, takerAssetFillAmount)
-            paramsAreaOffset := add(paramsAreaOffset, 0x20)
-
-            /////// Write signature ///////
-            // Write offset to paramsArea
-            mstore(paramsAreaOffset, sub(dataAreaEnd, paramsAreaStart))
-
-            // Calculate length of signature
-            sourceOffset := signature
-            arrayLenBytes := mload(sourceOffset)
-            sourceOffset := add(sourceOffset, 0x20)
-            arrayLenWords := div(add(arrayLenBytes, 0x1F), 0x20)
-
-            // Write length of signature
-            mstore(dataAreaEnd, arrayLenBytes)
-            dataAreaEnd := add(dataAreaEnd, 0x20)
-
-            // Write contents of signature
-            for {let i := 0} lt(i, arrayLenWords) {i := add(i, 1)} {
-                mstore(dataAreaEnd, mload(sourceOffset))
-                dataAreaEnd := add(dataAreaEnd, 0x20)
-                sourceOffset := add(sourceOffset, 0x20)
-            }
-
-            // Set length of calldata
-            mstore(fillOrderCalldata, sub(dataAreaEnd, add(fillOrderCalldata, 0x20)))
-
-            // Increment free memory pointer
-            mstore(0x40, dataAreaEnd)
-        }
-
-        return fillOrderCalldata;
-    }
-}
diff --git a/packages/contracts/src/2.0.0/protocol/Exchange/libs/LibConstants.sol b/packages/contracts/src/2.0.0/protocol/Exchange/libs/LibConstants.sol
deleted file mode 100644
index 8d2732cd3..000000000
--- a/packages/contracts/src/2.0.0/protocol/Exchange/libs/LibConstants.sol
+++ /dev/null
@@ -1,49 +0,0 @@
-/*
-
-  Copyright 2018 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.4.24;
-
-
-// solhint-disable max-line-length
-contract LibConstants {
-   
-    // Asset data for ZRX token. Used for fee transfers.
-    // @TODO: Hardcode constant when we deploy. Currently 
-    //        not constant to make testing easier.
-
-    // The proxyId for ZRX_ASSET_DATA is bytes4(keccak256("ERC20Token(address)")) = 0xf47261b0
-    
-    // Kovan ZRX address is 0x6ff6c0ff1d68b964901f986d4c9fa3ac68346570.
-    // The ABI encoded proxyId and address is 0xf47261b00000000000000000000000006ff6c0ff1d68b964901f986d4c9fa3ac68346570
-    // bytes constant public ZRX_ASSET_DATA = "\xf4\x72\x61\xb0\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6f\xf6\xc0\xff\x1d\x68\xb9\x64\x90\x1f\x98\x6d\x4c\x9f\xa3\xac\x68\x34\x65\x70";
-    
-    // Mainnet ZRX address is 0xe41d2489571d322189246dafa5ebde1f4699f498.
-    // The ABI encoded proxyId and address is 0xf47261b0000000000000000000000000e41d2489571d322189246dafa5ebde1f4699f498
-    // bytes constant public ZRX_ASSET_DATA = "\xf4\x72\x61\xb0\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe4\x1d\x24\x89\x57\x1d\x32\x21\x89\x24\x6d\xaf\xa5\xeb\xde\x1f\x46\x99\xf4\x98";
-    
-    // solhint-disable-next-line var-name-mixedcase
-    bytes public ZRX_ASSET_DATA;
-
-    // @TODO: Remove when we deploy.
-    constructor (bytes memory zrxAssetData)
-        public
-    {
-        ZRX_ASSET_DATA = zrxAssetData;
-    }
-}
-// solhint-enable max-line-length
diff --git a/packages/contracts/src/2.0.0/protocol/Exchange/libs/LibEIP712.sol b/packages/contracts/src/2.0.0/protocol/Exchange/libs/LibEIP712.sol
deleted file mode 100644
index 203edc1fd..000000000
--- a/packages/contracts/src/2.0.0/protocol/Exchange/libs/LibEIP712.sol
+++ /dev/null
@@ -1,87 +0,0 @@
-/*
-
-  Copyright 2018 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.4.24;
-
-
-contract LibEIP712 {
-
-    // EIP191 header for EIP712 prefix
-    string constant internal EIP191_HEADER = "\x19\x01";
-
-    // EIP712 Domain Name value
-    string constant internal EIP712_DOMAIN_NAME = "0x Protocol";
-
-    // EIP712 Domain Version value
-    string constant internal EIP712_DOMAIN_VERSION = "2";
-
-    // Hash of the EIP712 Domain Separator Schema
-    bytes32 constant internal EIP712_DOMAIN_SEPARATOR_SCHEMA_HASH = keccak256(abi.encodePacked(
-        "EIP712Domain(",
-        "string name,",
-        "string version,",
-        "address verifyingContract",
-        ")"
-    ));
-
-    // Hash of the EIP712 Domain Separator data
-    // solhint-disable-next-line var-name-mixedcase
-    bytes32 public EIP712_DOMAIN_HASH;
-
-    constructor ()
-        public
-    {
-        EIP712_DOMAIN_HASH = keccak256(abi.encodePacked(
-            EIP712_DOMAIN_SEPARATOR_SCHEMA_HASH,
-            keccak256(bytes(EIP712_DOMAIN_NAME)),
-            keccak256(bytes(EIP712_DOMAIN_VERSION)),
-            bytes32(address(this))
-        ));
-    }
-
-    /// @dev Calculates EIP712 encoding for a hash struct in this EIP712 Domain.
-    /// @param hashStruct The EIP712 hash struct.
-    /// @return EIP712 hash applied to this EIP712 Domain.
-    function hashEIP712Message(bytes32 hashStruct)
-        internal
-        view
-        returns (bytes32 result)
-    {
-        bytes32 eip712DomainHash = EIP712_DOMAIN_HASH;
-
-        // Assembly for more efficient computing:
-        // keccak256(abi.encodePacked(
-        //     EIP191_HEADER,
-        //     EIP712_DOMAIN_HASH,
-        //     hashStruct    
-        // ));
-
-        assembly {
-            // Load free memory pointer
-            let memPtr := mload(64)
-
-            mstore(memPtr, 0x1901000000000000000000000000000000000000000000000000000000000000)  // EIP191 header
-            mstore(add(memPtr, 2), eip712DomainHash)                                            // EIP712 domain hash
-            mstore(add(memPtr, 34), hashStruct)                                                 // Hash of struct
-
-            // Compute hash
-            result := keccak256(memPtr, 66)
-        }
-        return result;
-    }
-}
diff --git a/packages/contracts/src/2.0.0/protocol/Exchange/libs/LibExchangeErrors.sol b/packages/contracts/src/2.0.0/protocol/Exchange/libs/LibExchangeErrors.sol
deleted file mode 100644
index a0f75bc06..000000000
--- a/packages/contracts/src/2.0.0/protocol/Exchange/libs/LibExchangeErrors.sol
+++ /dev/null
@@ -1,70 +0,0 @@
-/*
-
-  Copyright 2018 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.
-
-*/
-
-// solhint-disable
-pragma solidity 0.4.24;
-
-
-/// @dev This contract documents the revert reasons used in the Exchange contract.
-/// This contract is intended to serve as a reference, but is not actually used for efficiency reasons.
-contract LibExchangeErrors {
-
-    /// Order validation errors ///
-    string constant ORDER_UNFILLABLE = "ORDER_UNFILLABLE";                              // Order cannot be filled.
-    string constant INVALID_MAKER = "INVALID_MAKER";                                    // Invalid makerAddress.
-    string constant INVALID_TAKER = "INVALID_TAKER";                                    // Invalid takerAddress.
-    string constant INVALID_SENDER = "INVALID_SENDER";                                  // Invalid `msg.sender`.
-    string constant INVALID_ORDER_SIGNATURE = "INVALID_ORDER_SIGNATURE";                // Signature validation failed. 
-    
-    /// fillOrder validation errors ///
-    string constant INVALID_TAKER_AMOUNT = "INVALID_TAKER_AMOUNT";                      // takerAssetFillAmount cannot equal 0.
-    string constant ROUNDING_ERROR = "ROUNDING_ERROR";                                  // Rounding error greater than 0.1% of takerAssetFillAmount. 
-    
-    /// Signature validation errors ///
-    string constant INVALID_SIGNATURE = "INVALID_SIGNATURE";                            // Signature validation failed. 
-    string constant SIGNATURE_ILLEGAL = "SIGNATURE_ILLEGAL";                            // Signature type is illegal.
-    string constant SIGNATURE_UNSUPPORTED = "SIGNATURE_UNSUPPORTED";                    // Signature type unsupported.
-    
-    /// cancelOrdersUptTo errors ///
-    string constant INVALID_NEW_ORDER_EPOCH = "INVALID_NEW_ORDER_EPOCH";                // Specified salt must be greater than or equal to existing orderEpoch.
-
-    /// fillOrKillOrder errors ///
-    string constant COMPLETE_FILL_FAILED = "COMPLETE_FILL_FAILED";                      // Desired takerAssetFillAmount could not be completely filled. 
-
-    /// matchOrders errors ///
-    string constant NEGATIVE_SPREAD_REQUIRED = "NEGATIVE_SPREAD_REQUIRED";              // Matched orders must have a negative spread.
-
-    /// Transaction errors ///
-    string constant REENTRANCY_ILLEGAL = "REENTRANCY_ILLEGAL";                          // Recursive reentrancy is not allowed. 
-    string constant INVALID_TX_HASH = "INVALID_TX_HASH";                                // Transaction has already been executed. 
-    string constant INVALID_TX_SIGNATURE = "INVALID_TX_SIGNATURE";                      // Signature validation failed. 
-    string constant FAILED_EXECUTION = "FAILED_EXECUTION";                              // Transaction execution failed. 
-    
-    /// registerAssetProxy errors ///
-    string constant ASSET_PROXY_ALREADY_EXISTS = "ASSET_PROXY_ALREADY_EXISTS";          // AssetProxy with same id already exists.
-
-    /// dispatchTransferFrom errors ///
-    string constant ASSET_PROXY_DOES_NOT_EXIST = "ASSET_PROXY_DOES_NOT_EXIST";          // No assetProxy registered at given id.
-    string constant TRANSFER_FAILED = "TRANSFER_FAILED";                                // Asset transfer unsuccesful.
-
-    /// Length validation errors ///
-    string constant LENGTH_GREATER_THAN_0_REQUIRED = "LENGTH_GREATER_THAN_0_REQUIRED";  // Byte array must have a length greater than 0.
-    string constant LENGTH_GREATER_THAN_3_REQUIRED = "LENGTH_GREATER_THAN_3_REQUIRED";  // Byte array must have a length greater than 3.
-    string constant LENGTH_0_REQUIRED = "LENGTH_0_REQUIRED";                            // Byte array must have a length of 0.
-    string constant LENGTH_65_REQUIRED = "LENGTH_65_REQUIRED";                          // Byte array must have a length of 65.
-}
diff --git a/packages/contracts/src/2.0.0/protocol/Exchange/libs/LibFillResults.sol b/packages/contracts/src/2.0.0/protocol/Exchange/libs/LibFillResults.sol
deleted file mode 100644
index 659ae9a69..000000000
--- a/packages/contracts/src/2.0.0/protocol/Exchange/libs/LibFillResults.sol
+++ /dev/null
@@ -1,53 +0,0 @@
-/*
-
-  Copyright 2018 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.4.24;
-
-import "../../../utils/SafeMath/SafeMath.sol";
-
-
-contract LibFillResults is
-    SafeMath
-{
-    struct FillResults {
-        uint256 makerAssetFilledAmount;  // Total amount of makerAsset(s) filled.
-        uint256 takerAssetFilledAmount;  // Total amount of takerAsset(s) filled.
-        uint256 makerFeePaid;            // Total amount of ZRX paid by maker(s) to feeRecipient(s).
-        uint256 takerFeePaid;            // Total amount of ZRX paid by taker to feeRecipients(s).
-    }
-
-    struct MatchedFillResults {
-        FillResults left;                    // Amounts filled and fees paid of left order.
-        FillResults right;                   // Amounts filled and fees paid of right order.
-        uint256 leftMakerAssetSpreadAmount;  // Spread between price of left and right order, denominated in the left order's makerAsset, paid to taker.
-    }
-
-    /// @dev Adds properties of both FillResults instances.
-    ///      Modifies the first FillResults instance specified.
-    /// @param totalFillResults Fill results instance that will be added onto.
-    /// @param singleFillResults Fill results instance that will be added to totalFillResults.
-    function addFillResults(FillResults memory totalFillResults, FillResults memory singleFillResults)
-        internal
-        pure
-    {
-        totalFillResults.makerAssetFilledAmount = safeAdd(totalFillResults.makerAssetFilledAmount, singleFillResults.makerAssetFilledAmount);
-        totalFillResults.takerAssetFilledAmount = safeAdd(totalFillResults.takerAssetFilledAmount, singleFillResults.takerAssetFilledAmount);
-        totalFillResults.makerFeePaid = safeAdd(totalFillResults.makerFeePaid, singleFillResults.makerFeePaid);
-        totalFillResults.takerFeePaid = safeAdd(totalFillResults.takerFeePaid, singleFillResults.takerFeePaid);
-    }
-}
diff --git a/packages/contracts/src/2.0.0/protocol/Exchange/libs/LibMath.sol b/packages/contracts/src/2.0.0/protocol/Exchange/libs/LibMath.sol
deleted file mode 100644
index c0b85ea10..000000000
--- a/packages/contracts/src/2.0.0/protocol/Exchange/libs/LibMath.sol
+++ /dev/null
@@ -1,253 +0,0 @@
-/*
-
-  Copyright 2018 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.4.24;
-
-import "../../../utils/SafeMath/SafeMath.sol";
-
-
-contract LibMath is
-    SafeMath
-{
-    /// @dev Calculates partial value given a numerator and denominator rounded down.
-    ///      Reverts if rounding error is >= 0.1%
-    /// @param numerator Numerator.
-    /// @param denominator Denominator.
-    /// @param target Value to calculate partial of.
-    /// @return Partial value of target rounded down.
-    function safeGetPartialAmountFloor(
-        uint256 numerator,
-        uint256 denominator,
-        uint256 target
-    )
-        internal
-        pure
-        returns (uint256 partialAmount)
-    {
-        require(
-            denominator > 0,
-            "DIVISION_BY_ZERO"
-        );
-
-        require(
-            !isRoundingErrorFloor(
-                numerator,
-                denominator,
-                target
-            ),
-            "ROUNDING_ERROR"
-        );
-        
-        partialAmount = safeDiv(
-            safeMul(numerator, target),
-            denominator
-        );
-        return partialAmount;
-    }
-
-    /// @dev Calculates partial value given a numerator and denominator rounded down.
-    ///      Reverts if rounding error is >= 0.1%
-    /// @param numerator Numerator.
-    /// @param denominator Denominator.
-    /// @param target Value to calculate partial of.
-    /// @return Partial value of target rounded up.
-    function safeGetPartialAmountCeil(
-        uint256 numerator,
-        uint256 denominator,
-        uint256 target
-    )
-        internal
-        pure
-        returns (uint256 partialAmount)
-    {
-        require(
-            denominator > 0,
-            "DIVISION_BY_ZERO"
-        );
-
-        require(
-            !isRoundingErrorCeil(
-                numerator,
-                denominator,
-                target
-            ),
-            "ROUNDING_ERROR"
-        );
-        
-        // safeDiv computes `floor(a / b)`. We use the identity (a, b integer):
-        //       ceil(a / b) = floor((a + b - 1) / b)
-        // To implement `ceil(a / b)` using safeDiv.
-        partialAmount = safeDiv(
-            safeAdd(
-                safeMul(numerator, target),
-                safeSub(denominator, 1)
-            ),
-            denominator
-        );
-        return partialAmount;
-    }
-
-    /// @dev Calculates partial value given a numerator and denominator rounded down.
-    /// @param numerator Numerator.
-    /// @param denominator Denominator.
-    /// @param target Value to calculate partial of.
-    /// @return Partial value of target rounded down.
-    function getPartialAmountFloor(
-        uint256 numerator,
-        uint256 denominator,
-        uint256 target
-    )
-        internal
-        pure
-        returns (uint256 partialAmount)
-    {
-        require(
-            denominator > 0,
-            "DIVISION_BY_ZERO"
-        );
-
-        partialAmount = safeDiv(
-            safeMul(numerator, target),
-            denominator
-        );
-        return partialAmount;
-    }
-    
-    /// @dev Calculates partial value given a numerator and denominator rounded down.
-    /// @param numerator Numerator.
-    /// @param denominator Denominator.
-    /// @param target Value to calculate partial of.
-    /// @return Partial value of target rounded up.
-    function getPartialAmountCeil(
-        uint256 numerator,
-        uint256 denominator,
-        uint256 target
-    )
-        internal
-        pure
-        returns (uint256 partialAmount)
-    {
-        require(
-            denominator > 0,
-            "DIVISION_BY_ZERO"
-        );
-
-        // safeDiv computes `floor(a / b)`. We use the identity (a, b integer):
-        //       ceil(a / b) = floor((a + b - 1) / b)
-        // To implement `ceil(a / b)` using safeDiv.
-        partialAmount = safeDiv(
-            safeAdd(
-                safeMul(numerator, target),
-                safeSub(denominator, 1)
-            ),
-            denominator
-        );
-        return partialAmount;
-    }
-    
-    /// @dev Checks if rounding error >= 0.1% when rounding down.
-    /// @param numerator Numerator.
-    /// @param denominator Denominator.
-    /// @param target Value to multiply with numerator/denominator.
-    /// @return Rounding error is present.
-    function isRoundingErrorFloor(
-        uint256 numerator,
-        uint256 denominator,
-        uint256 target
-    )
-        internal
-        pure
-        returns (bool isError)
-    {
-        require(
-            denominator > 0,
-            "DIVISION_BY_ZERO"
-        );
-        
-        // The absolute rounding error is the difference between the rounded
-        // value and the ideal value. The relative rounding error is the
-        // absolute rounding error divided by the absolute value of the
-        // ideal value. This is undefined when the ideal value is zero.
-        //
-        // The ideal value is `numerator * target / denominator`.
-        // Let's call `numerator * target % denominator` the remainder.
-        // The absolute error is `remainder / denominator`.
-        //
-        // When the ideal value is zero, we require the absolute error to
-        // be zero. Fortunately, this is always the case. The ideal value is
-        // zero iff `numerator == 0` and/or `target == 0`. In this case the
-        // remainder and absolute error are also zero. 
-        if (target == 0 || numerator == 0) {
-            return false;
-        }
-        
-        // Otherwise, we want the relative rounding error to be strictly
-        // less than 0.1%.
-        // The relative error is `remainder / (numerator * target)`.
-        // We want the relative error less than 1 / 1000:
-        //        remainder / (numerator * denominator)  <  1 / 1000
-        // or equivalently:
-        //        1000 * remainder  <  numerator * target
-        // so we have a rounding error iff:
-        //        1000 * remainder  >=  numerator * target
-        uint256 remainder = mulmod(
-            target,
-            numerator,
-            denominator
-        );
-        isError = safeMul(1000, remainder) >= safeMul(numerator, target);
-        return isError;
-    }
-    
-    /// @dev Checks if rounding error >= 0.1% when rounding up.
-    /// @param numerator Numerator.
-    /// @param denominator Denominator.
-    /// @param target Value to multiply with numerator/denominator.
-    /// @return Rounding error is present.
-    function isRoundingErrorCeil(
-        uint256 numerator,
-        uint256 denominator,
-        uint256 target
-    )
-        internal
-        pure
-        returns (bool isError)
-    {
-        require(
-            denominator > 0,
-            "DIVISION_BY_ZERO"
-        );
-        
-        // See the comments in `isRoundingError`.
-        if (target == 0 || numerator == 0) {
-            // When either is zero, the ideal value and rounded value are zero
-            // and there is no rounding error. (Although the relative error
-            // is undefined.)
-            return false;
-        }
-        // Compute remainder as before
-        uint256 remainder = mulmod(
-            target,
-            numerator,
-            denominator
-        );
-        remainder = safeSub(denominator, remainder) % denominator;
-        isError = safeMul(1000, remainder) >= safeMul(numerator, target);
-        return isError;
-    }
-}
diff --git a/packages/contracts/src/2.0.0/protocol/Exchange/libs/LibOrder.sol b/packages/contracts/src/2.0.0/protocol/Exchange/libs/LibOrder.sol
deleted file mode 100644
index 0fe7c2161..000000000
--- a/packages/contracts/src/2.0.0/protocol/Exchange/libs/LibOrder.sol
+++ /dev/null
@@ -1,145 +0,0 @@
-/*
-
-  Copyright 2018 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.4.24;
-
-import "./LibEIP712.sol";
-
-
-contract LibOrder is
-    LibEIP712
-{
-    // Hash for the EIP712 Order Schema
-    bytes32 constant internal EIP712_ORDER_SCHEMA_HASH = keccak256(abi.encodePacked(
-        "Order(",
-        "address makerAddress,",
-        "address takerAddress,",
-        "address feeRecipientAddress,",
-        "address senderAddress,",
-        "uint256 makerAssetAmount,",
-        "uint256 takerAssetAmount,",
-        "uint256 makerFee,",
-        "uint256 takerFee,",
-        "uint256 expirationTimeSeconds,",
-        "uint256 salt,",
-        "bytes makerAssetData,",
-        "bytes takerAssetData",
-        ")"
-    ));
-
-    // A valid order remains fillable until it is expired, fully filled, or cancelled.
-    // An order's state is unaffected by external factors, like account balances.
-    enum OrderStatus {
-        INVALID,                     // Default value
-        INVALID_MAKER_ASSET_AMOUNT,  // Order does not have a valid maker asset amount
-        INVALID_TAKER_ASSET_AMOUNT,  // Order does not have a valid taker asset amount
-        FILLABLE,                    // Order is fillable
-        EXPIRED,                     // Order has already expired
-        FULLY_FILLED,                // Order is fully filled
-        CANCELLED                    // Order has been cancelled
-    }
-
-    // solhint-disable max-line-length
-    struct Order {
-        address makerAddress;           // Address that created the order.      
-        address takerAddress;           // Address that is allowed to fill the order. If set to 0, any address is allowed to fill the order.          
-        address feeRecipientAddress;    // Address that will recieve fees when order is filled.      
-        address senderAddress;          // Address that is allowed to call Exchange contract methods that affect this order. If set to 0, any address is allowed to call these methods.
-        uint256 makerAssetAmount;       // Amount of makerAsset being offered by maker. Must be greater than 0.        
-        uint256 takerAssetAmount;       // Amount of takerAsset being bid on by maker. Must be greater than 0.        
-        uint256 makerFee;               // Amount of ZRX paid to feeRecipient by maker when order is filled. If set to 0, no transfer of ZRX from maker to feeRecipient will be attempted.
-        uint256 takerFee;               // Amount of ZRX paid to feeRecipient by taker when order is filled. If set to 0, no transfer of ZRX from taker to feeRecipient will be attempted.
-        uint256 expirationTimeSeconds;  // Timestamp in seconds at which order expires.          
-        uint256 salt;                   // Arbitrary number to facilitate uniqueness of the order's hash.     
-        bytes makerAssetData;           // Encoded data that can be decoded by a specified proxy contract when transferring makerAsset. The last byte references the id of this proxy.
-        bytes takerAssetData;           // Encoded data that can be decoded by a specified proxy contract when transferring takerAsset. The last byte references the id of this proxy.
-    }
-    // solhint-enable max-line-length
-
-    struct OrderInfo {
-        uint8 orderStatus;                    // Status that describes order's validity and fillability.
-        bytes32 orderHash;                    // EIP712 hash of the order (see LibOrder.getOrderHash).
-        uint256 orderTakerAssetFilledAmount;  // Amount of order that has already been filled.
-    }
-
-    /// @dev Calculates Keccak-256 hash of the order.
-    /// @param order The order structure.
-    /// @return Keccak-256 EIP712 hash of the order.
-    function getOrderHash(Order memory order)
-        internal
-        view
-        returns (bytes32 orderHash)
-    {
-        orderHash = hashEIP712Message(hashOrder(order));
-        return orderHash;
-    }
-
-    /// @dev Calculates EIP712 hash of the order.
-    /// @param order The order structure.
-    /// @return EIP712 hash of the order.
-    function hashOrder(Order memory order)
-        internal
-        pure
-        returns (bytes32 result)
-    {
-        bytes32 schemaHash = EIP712_ORDER_SCHEMA_HASH;
-        bytes32 makerAssetDataHash = keccak256(order.makerAssetData);
-        bytes32 takerAssetDataHash = keccak256(order.takerAssetData);
-
-        // Assembly for more efficiently computing:
-        // keccak256(abi.encodePacked(
-        //     EIP712_ORDER_SCHEMA_HASH,
-        //     bytes32(order.makerAddress),
-        //     bytes32(order.takerAddress),
-        //     bytes32(order.feeRecipientAddress),
-        //     bytes32(order.senderAddress),
-        //     order.makerAssetAmount,
-        //     order.takerAssetAmount,
-        //     order.makerFee,
-        //     order.takerFee,
-        //     order.expirationTimeSeconds,
-        //     order.salt,
-        //     keccak256(order.makerAssetData),
-        //     keccak256(order.takerAssetData)
-        // ));
-
-        assembly {
-            // Calculate memory addresses that will be swapped out before hashing
-            let pos1 := sub(order, 32)
-            let pos2 := add(order, 320)
-            let pos3 := add(order, 352)
-
-            // Backup
-            let temp1 := mload(pos1)
-            let temp2 := mload(pos2)
-            let temp3 := mload(pos3)
-            
-            // Hash in place
-            mstore(pos1, schemaHash)
-            mstore(pos2, makerAssetDataHash)
-            mstore(pos3, takerAssetDataHash)
-            result := keccak256(pos1, 416)
-            
-            // Restore
-            mstore(pos1, temp1)
-            mstore(pos2, temp2)
-            mstore(pos3, temp3)
-        }
-        return result;
-    }
-}