Split up BridgeAdapter by chain [TKR-402] (#487)

* Split up BridgeAdapter by chain

* Fix BridgeProtocols enum

* Add isSupportedSource to bridge adapter contracts

* Add bridge adapter tests

* Fix FQT test

contracts/zero-ex/CHANGELOG.json

@@ -1,4 +1,13 @@
 [
+    {
+        "version": "0.34.0",
+        "changes": [
+            {
+                "note": "Splits BridgeAdapter up by chain",
+                "pr": 487
+            }
+        ]
+    },
     {
         "version": "0.33.0",
         "changes": [

contracts/zero-ex/contracts/src/transformers/bridges/AbstractBridgeAdapter.sol

@@ -0,0 +1,88 @@
+// 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;
+pragma experimental ABIEncoderV2;
+
+import "./IBridgeAdapter.sol";
+
+abstract contract AbstractBridgeAdapter is IBridgeAdapter {
+
+    constructor(
+        uint256 expectedChainId, 
+        string memory expectedChainName
+    )
+        public
+    {
+        uint256 chainId;
+        assembly { chainId := chainid() }
+        // Allow testing on Ganache
+        if (chainId != expectedChainId && chainId != 1337) {
+            revert(string(abi.encodePacked(expectedChainName, "BridgeAdapter.constructor: wrong chain ID")));
+        }
+    }
+
+    function isSupportedSource(bytes32 source)
+        external
+        override
+        returns (bool isSupported)
+    {
+        BridgeOrder memory placeholderOrder;
+        placeholderOrder.source = source;
+        IERC20TokenV06 placeholderToken = IERC20TokenV06(address(0));
+        
+        (, isSupported) = _trade(
+            placeholderOrder,
+            placeholderToken,
+            placeholderToken,
+            0,
+            true
+        );
+    }
+
+    function trade(
+        BridgeOrder memory order,
+        IERC20TokenV06 sellToken,
+        IERC20TokenV06 buyToken,
+        uint256 sellAmount
+    )
+        public
+        override
+        returns (uint256 boughtAmount)
+    {
+        (boughtAmount, ) = _trade(
+            order,
+            sellToken,
+            buyToken,
+            sellAmount,
+            false
+        );
+    }
+
+    function _trade(
+        BridgeOrder memory order,
+        IERC20TokenV06 sellToken,
+        IERC20TokenV06 buyToken,
+        uint256 sellAmount,
+        bool dryRun
+    )
+        internal
+        virtual
+        returns (uint256 boughtAmount, bool supportedSource);
+}

contracts/zero-ex/contracts/src/transformers/bridges/AvalancheBridgeAdapter.sol

@@ -0,0 +1,141 @@
+// 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 "./AbstractBridgeAdapter.sol";
+import "./BridgeProtocols.sol";
+import "./mixins/MixinCurve.sol";
+import "./mixins/MixinCurveV2.sol";
+import "./mixins/MixinGMX.sol";
+import "./mixins/MixinKyberDmm.sol";
+import "./mixins/MixinAaveV2.sol";
+import "./mixins/MixinNerve.sol";
+import "./mixins/MixinPlatypus.sol";
+import "./mixins/MixinUniswapV2.sol";
+import "./mixins/MixinZeroExBridge.sol";
+
+contract AvalancheBridgeAdapter is
+    AbstractBridgeAdapter(43114, "Avalanche"),
+    MixinCurve,
+    MixinCurveV2,
+    MixinGMX,
+    MixinKyberDmm,
+    MixinAaveV2,
+    MixinNerve,
+    MixinPlatypus,
+    MixinUniswapV2,
+    MixinZeroExBridge
+{
+    constructor(IEtherTokenV06 weth)
+        public
+        MixinCurve(weth)
+    {}
+
+    function _trade(
+        BridgeOrder memory order,
+        IERC20TokenV06 sellToken,
+        IERC20TokenV06 buyToken,
+        uint256 sellAmount,
+        bool dryRun
+    )
+        internal
+        override
+        returns (uint256 boughtAmount, bool supportedSource)
+    {
+        uint128 protocolId = uint128(uint256(order.source) >> 128);
+        if (protocolId == BridgeProtocols.CURVE) {
+            if (dryRun) { return (0, true); }
+            boughtAmount = _tradeCurve(
+                sellToken,
+                buyToken,
+                sellAmount,
+                order.bridgeData
+            );
+        } else if (protocolId == BridgeProtocols.CURVEV2) {
+            if (dryRun) { return (0, true); }
+            boughtAmount = _tradeCurveV2(
+                sellToken,
+                buyToken,
+                sellAmount,
+                order.bridgeData
+            );
+        } else if (protocolId == BridgeProtocols.UNISWAPV2) {
+            if (dryRun) { return (0, true); }
+            boughtAmount = _tradeUniswapV2(
+                buyToken,
+                sellAmount,
+                order.bridgeData
+            );
+        } else if (protocolId == BridgeProtocols.NERVE) {
+            if (dryRun) { return (0, true); }
+            boughtAmount = _tradeNerve(
+                sellToken,
+                sellAmount,
+                order.bridgeData
+            );
+        } else if (protocolId == BridgeProtocols.KYBERDMM) {
+            if (dryRun) { return (0, true); }
+            boughtAmount = _tradeKyberDmm(
+                buyToken,
+                sellAmount,
+                order.bridgeData
+            );
+        } else if (protocolId == BridgeProtocols.AAVEV2) {
+            if (dryRun) { return (0, true); }
+            boughtAmount = _tradeAaveV2(
+                sellToken,
+                buyToken,
+                sellAmount,
+                order.bridgeData
+            );
+        } else if (protocolId == BridgeProtocols.GMX) {
+            if (dryRun) { return (0, true); }
+            boughtAmount = _tradeGMX(
+                buyToken,
+                sellAmount,
+                order.bridgeData
+            );
+        } else if (protocolId == BridgeProtocols.PLATYPUS) {
+            if (dryRun) { return (0, true); }
+            boughtAmount = _tradePlatypus(
+                buyToken,
+                sellAmount,
+                order.bridgeData
+            );
+        } else if (protocolId == BridgeProtocols.UNKNOWN) {
+            if (dryRun) { return (0, true); }            
+            boughtAmount = _tradeZeroExBridge(
+                sellToken,
+                buyToken,
+                sellAmount,
+                order.bridgeData
+            );
+        }
+
+        emit BridgeFill(
+            order.source,
+            sellToken,
+            buyToken,
+            sellAmount,
+            boughtAmount
+        );
+    }
+}

contracts/zero-ex/contracts/src/transformers/bridges/BSCBridgeAdapter.sol

@@ -0,0 +1,132 @@
+// 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 "./AbstractBridgeAdapter.sol";
+import "./BridgeProtocols.sol";
+import "./mixins/MixinCurve.sol";
+import "./mixins/MixinDodo.sol";
+import "./mixins/MixinDodoV2.sol";
+import "./mixins/MixinKyberDmm.sol";
+import "./mixins/MixinMooniswap.sol";
+import "./mixins/MixinNerve.sol";
+import "./mixins/MixinUniswapV2.sol";
+import "./mixins/MixinZeroExBridge.sol";
+
+contract BSCBridgeAdapter is
+    AbstractBridgeAdapter(56, "BSC"),
+    MixinCurve,
+    MixinDodo,
+    MixinDodoV2,
+    MixinKyberDmm,
+    MixinMooniswap,
+    MixinNerve,
+    MixinUniswapV2,
+    MixinZeroExBridge
+{
+    constructor(IEtherTokenV06 weth)
+        public
+        MixinCurve(weth)
+        MixinMooniswap(weth)
+    {}
+
+    function _trade(
+        BridgeOrder memory order,
+        IERC20TokenV06 sellToken,
+        IERC20TokenV06 buyToken,
+        uint256 sellAmount,
+        bool dryRun
+    )
+        internal
+        override
+        returns (uint256 boughtAmount, bool supportedSource)
+    {
+        uint128 protocolId = uint128(uint256(order.source) >> 128);
+        if (protocolId == BridgeProtocols.CURVE) {
+            if (dryRun) { return (0, true); }
+            boughtAmount = _tradeCurve(
+                sellToken,
+                buyToken,
+                sellAmount,
+                order.bridgeData
+            );
+        } else if (protocolId == BridgeProtocols.UNISWAPV2) {
+            if (dryRun) { return (0, true); }
+            boughtAmount = _tradeUniswapV2(
+                buyToken,
+                sellAmount,
+                order.bridgeData
+            );
+        } else if (protocolId == BridgeProtocols.MOONISWAP) {
+            if (dryRun) { return (0, true); }
+            boughtAmount = _tradeMooniswap(
+                sellToken,
+                buyToken,
+                sellAmount,
+                order.bridgeData
+            );
+        } else if (protocolId == BridgeProtocols.DODO) {
+            if (dryRun) { return (0, true); }
+            boughtAmount = _tradeDodo(
+                sellToken,
+                sellAmount,
+                order.bridgeData
+            );
+        } else if (protocolId == BridgeProtocols.DODOV2) {
+            if (dryRun) { return (0, true); }
+            boughtAmount = _tradeDodoV2(
+                sellToken,
+                sellAmount,
+                order.bridgeData
+            );
+        } else if (protocolId == BridgeProtocols.NERVE) {
+            if (dryRun) { return (0, true); }
+            boughtAmount = _tradeNerve(
+                sellToken,
+                sellAmount,
+                order.bridgeData
+            );
+        } else if (protocolId == BridgeProtocols.KYBERDMM) {
+            if (dryRun) { return (0, true); }
+            boughtAmount = _tradeKyberDmm(
+                buyToken,
+                sellAmount,
+                order.bridgeData
+            );
+        } else if (protocolId == BridgeProtocols.UNKNOWN) {
+            if (dryRun) { return (0, true); }
+            boughtAmount = _tradeZeroExBridge(
+                sellToken,
+                buyToken,
+                sellAmount,
+                order.bridgeData
+            );
+        }
+
+        emit BridgeFill(
+            order.source,
+            sellToken,
+            buyToken,
+            sellAmount,
+            boughtAmount
+        );
+    }
+}

contracts/zero-ex/contracts/src/transformers/bridges/CeloBridgeAdapter.sol

@@ -0,0 +1,84 @@
+
+// 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 "./AbstractBridgeAdapter.sol";
+import "./BridgeProtocols.sol";
+import "./mixins/MixinNerve.sol";
+import "./mixins/MixinUniswapV2.sol";
+import "./mixins/MixinZeroExBridge.sol";
+
+contract CeloBridgeAdapter is
+    AbstractBridgeAdapter(42220, "Celo"),
+    MixinNerve,
+    MixinUniswapV2,
+    MixinZeroExBridge
+{
+    constructor(address _weth)
+        public
+    {}
+
+    function _trade(
+        BridgeOrder memory order,
+        IERC20TokenV06 sellToken,
+        IERC20TokenV06 buyToken,
+        uint256 sellAmount,
+        bool dryRun
+    )
+        internal
+        override
+        returns (uint256 boughtAmount, bool supportedSource)
+    {
+        uint128 protocolId = uint128(uint256(order.source) >> 128);
+        if (protocolId == BridgeProtocols.UNISWAPV2) {
+            if (dryRun) { return (0, true); }
+            boughtAmount = _tradeUniswapV2(
+                buyToken,
+                sellAmount,
+                order.bridgeData
+            );
+        } else if (protocolId == BridgeProtocols.NERVE) {
+            if (dryRun) { return (0, true); }
+            boughtAmount = _tradeNerve(
+                sellToken,
+                sellAmount,
+                order.bridgeData
+            );
+        } else if (protocolId == BridgeProtocols.UNKNOWN) {
+            if (dryRun) { return (0, true); }            
+            boughtAmount = _tradeZeroExBridge(
+                sellToken,
+                buyToken,
+                sellAmount,
+                order.bridgeData
+            );
+        }
+
+        emit BridgeFill(
+            order.source,
+            sellToken,
+            buyToken,
+            sellAmount,
+            boughtAmount
+        );
+    }
+}

contracts/zero-ex/contracts/src/transformers/bridges/EthereumBridgeAdapter.sol

@@ -1,7 +1,7 @@
 // SPDX-License-Identifier: Apache-2.0
 /*
 
-  Copyright 2021 ZeroEx Intl.
+  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.
@@ -20,7 +20,7 @@
 pragma solidity ^0.6.5;
 pragma experimental ABIEncoderV2;
 
-import "./IBridgeAdapter.sol";
+import "./AbstractBridgeAdapter.sol";
 import "./BridgeProtocols.sol";
 import "./mixins/MixinAaveV2.sol";
 import "./mixins/MixinBalancer.sol";
@@ -33,22 +33,20 @@ import "./mixins/MixinCurveV2.sol";
 import "./mixins/MixinCryptoCom.sol";
 import "./mixins/MixinDodo.sol";
 import "./mixins/MixinDodoV2.sol";
-import "./mixins/MixinGMX.sol";
 import "./mixins/MixinKyberDmm.sol";
 import "./mixins/MixinLido.sol";
 import "./mixins/MixinMakerPSM.sol";
 import "./mixins/MixinMooniswap.sol";
 import "./mixins/MixinMStable.sol";
 import "./mixins/MixinNerve.sol";
-import "./mixins/MixinPlatypus.sol";
 import "./mixins/MixinShell.sol";
 import "./mixins/MixinUniswap.sol";
 import "./mixins/MixinUniswapV2.sol";
 import "./mixins/MixinUniswapV3.sol";
 import "./mixins/MixinZeroExBridge.sol";
 
-contract BridgeAdapter is
+contract EthereumBridgeAdapter is
-    IBridgeAdapter,
+    AbstractBridgeAdapter(1, "Ethereum"),
     MixinAaveV2,
     MixinBalancer,
     MixinBalancerV2,
@@ -60,14 +58,12 @@ contract BridgeAdapter is
     MixinCryptoCom,
     MixinDodo,
     MixinDodoV2,
-    MixinGMX,
     MixinKyberDmm,
     MixinLido,
     MixinMakerPSM,
     MixinMooniswap,
     MixinMStable,
     MixinNerve,
-    MixinPlatypus,
     MixinShell,
     MixinUniswap,
     MixinUniswapV2,
@@ -76,42 +72,28 @@ contract BridgeAdapter is
 {
     constructor(IEtherTokenV06 weth)
         public
-        MixinAaveV2()
-        MixinBalancer()
-        MixinBalancerV2()
         MixinBancor(weth)
         MixinCompound(weth)
         MixinCurve(weth)
-        MixinCurveV2()
-        MixinCryptoCom()
-        MixinDodo()
-        MixinDodoV2()
-        MixinGMX()
         MixinLido(weth)
-        MixinMakerPSM()
         MixinMooniswap(weth)
-        MixinMStable()
-        MixinNerve()
-        MixinPlatypus()
-        MixinShell()
         MixinUniswap(weth)
-        MixinUniswapV2()
-        MixinUniswapV3()
-        MixinZeroExBridge()
     {}
 
-    function trade(
+    function _trade(
         BridgeOrder memory order,
         IERC20TokenV06 sellToken,
         IERC20TokenV06 buyToken,
-        uint256 sellAmount
+        uint256 sellAmount,
+        bool dryRun
     )
-        public
+        internal
         override
-        returns (uint256 boughtAmount)
+        returns (uint256 boughtAmount, bool supportedSource)
     {
         uint128 protocolId = uint128(uint256(order.source) >> 128);
         if (protocolId == BridgeProtocols.CURVE) {
+            if (dryRun) { return (0, true); }
             boughtAmount = _tradeCurve(
                 sellToken,
                 buyToken,
@@ -119,6 +101,7 @@ contract BridgeAdapter is
                 order.bridgeData
             );
         } else if (protocolId == BridgeProtocols.CURVEV2) {
+            if (dryRun) { return (0, true); }
             boughtAmount = _tradeCurveV2(
                 sellToken,
                 buyToken,
@@ -126,18 +109,21 @@ contract BridgeAdapter is
                 order.bridgeData
             );
         } else if (protocolId == BridgeProtocols.UNISWAPV3) {
+            if (dryRun) { return (0, true); }
             boughtAmount = _tradeUniswapV3(
                 sellToken,
                 sellAmount,
                 order.bridgeData
             );
         } else if (protocolId == BridgeProtocols.UNISWAPV2) {
+            if (dryRun) { return (0, true); }
             boughtAmount = _tradeUniswapV2(
                 buyToken,
                 sellAmount,
                 order.bridgeData
             );
         } else if (protocolId == BridgeProtocols.UNISWAP) {
+            if (dryRun) { return (0, true); }
             boughtAmount = _tradeUniswap(
                 sellToken,
                 buyToken,
@@ -145,6 +131,7 @@ contract BridgeAdapter is
                 order.bridgeData
             );
         } else if (protocolId == BridgeProtocols.BALANCER) {
+            if (dryRun) { return (0, true); }
             boughtAmount = _tradeBalancer(
                 sellToken,
                 buyToken,
@@ -152,6 +139,7 @@ contract BridgeAdapter is
                 order.bridgeData
             );
         } else if (protocolId == BridgeProtocols.BALANCERV2) {
+            if (dryRun) { return (0, true); }
             boughtAmount = _tradeBalancerV2(
                 sellToken,
                 buyToken,
@@ -159,11 +147,13 @@ contract BridgeAdapter is
                 order.bridgeData
             );
         } else if (protocolId == BridgeProtocols.BALANCERV2BATCH) {
+            if (dryRun) { return (0, true); }
             boughtAmount = _tradeBalancerV2Batch(
                 sellAmount,
                 order.bridgeData
             );
         } else if (protocolId == BridgeProtocols.MAKERPSM) {
+            if (dryRun) { return (0, true); }
             boughtAmount = _tradeMakerPsm(
                 sellToken,
                 buyToken,
@@ -171,6 +161,7 @@ contract BridgeAdapter is
                 order.bridgeData
             );
         } else if (protocolId == BridgeProtocols.MOONISWAP) {
+            if (dryRun) { return (0, true); }
             boughtAmount = _tradeMooniswap(
                 sellToken,
                 buyToken,
@@ -178,6 +169,7 @@ contract BridgeAdapter is
                 order.bridgeData
             );
         } else if (protocolId == BridgeProtocols.MSTABLE) {
+            if (dryRun) { return (0, true); }
             boughtAmount = _tradeMStable(
                 sellToken,
                 buyToken,
@@ -185,6 +177,7 @@ contract BridgeAdapter is
                 order.bridgeData
             );
         } else if (protocolId == BridgeProtocols.SHELL) {
+            if (dryRun) { return (0, true); }
             boughtAmount = _tradeShell(
                 sellToken,
                 buyToken,
@@ -192,42 +185,49 @@ contract BridgeAdapter is
                 order.bridgeData
             );
         } else if (protocolId == BridgeProtocols.DODO) {
+            if (dryRun) { return (0, true); }
             boughtAmount = _tradeDodo(
                 sellToken,
                 sellAmount,
                 order.bridgeData
             );
         } else if (protocolId == BridgeProtocols.DODOV2) {
+            if (dryRun) { return (0, true); }
             boughtAmount = _tradeDodoV2(
                 sellToken,
                 sellAmount,
                 order.bridgeData
             );
         } else if (protocolId == BridgeProtocols.CRYPTOCOM) {
+            if (dryRun) { return (0, true); }
             boughtAmount = _tradeCryptoCom(
                 buyToken,
                 sellAmount,
                 order.bridgeData
             );
         } else if (protocolId == BridgeProtocols.BANCOR) {
+            if (dryRun) { return (0, true); }
             boughtAmount = _tradeBancor(
                 buyToken,
                 sellAmount,
                 order.bridgeData
             );
         } else if (protocolId == BridgeProtocols.NERVE) {
+            if (dryRun) { return (0, true); }
             boughtAmount = _tradeNerve(
                 sellToken,
                 sellAmount,
                 order.bridgeData
             );
         } else if (protocolId == BridgeProtocols.KYBERDMM) {
+            if (dryRun) { return (0, true); }
             boughtAmount = _tradeKyberDmm(
                 buyToken,
                 sellAmount,
                 order.bridgeData
             );
         } else if (protocolId == BridgeProtocols.LIDO) {
+            if (dryRun) { return (0, true); }
             boughtAmount = _tradeLido(
                 sellToken,
                 buyToken,
@@ -235,6 +235,7 @@ contract BridgeAdapter is
                 order.bridgeData
             );
         } else if (protocolId == BridgeProtocols.AAVEV2) {
+            if (dryRun) { return (0, true); }
             boughtAmount = _tradeAaveV2(
                 sellToken,
                 buyToken,
@@ -242,25 +243,15 @@ contract BridgeAdapter is
                 order.bridgeData
             );
         } else if (protocolId == BridgeProtocols.COMPOUND) {
+            if (dryRun) { return (0, true); }
             boughtAmount = _tradeCompound(
                 sellToken,
                 buyToken,
                 sellAmount,
                 order.bridgeData
             );
-        } else if (protocolId == BridgeProtocols.GMX) {
+        } else if (protocolId == BridgeProtocols.UNKNOWN) {
-            boughtAmount = _tradeGMX(
+            if (dryRun) { return (0, true); }            
-                buyToken,
-                sellAmount,
-                order.bridgeData
-            );
-        } else if (protocolId == BridgeProtocols.PLATYPUS) {
-            boughtAmount = _tradePlatypus(
-                buyToken,
-                sellAmount,
-                order.bridgeData
-            );
-        } else {
             boughtAmount = _tradeZeroExBridge(
                 sellToken,
                 buyToken,

contracts/zero-ex/contracts/src/transformers/bridges/FantomBridgeAdapter.sol

@@ -0,0 +1,124 @@
+// 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 "./AbstractBridgeAdapter.sol";
+import "./BridgeProtocols.sol";
+import "./mixins/MixinAaveV2.sol";
+import "./mixins/MixinBalancerV2.sol";
+import "./mixins/MixinCurve.sol";
+import "./mixins/MixinCurveV2.sol";
+import "./mixins/MixinNerve.sol";
+import "./mixins/MixinUniswapV2.sol";
+import "./mixins/MixinZeroExBridge.sol";
+
+contract FantomBridgeAdapter is
+    AbstractBridgeAdapter(250, "Fantom"),
+    MixinAaveV2,
+    MixinBalancerV2,
+    MixinCurve,
+    MixinCurveV2,
+    MixinNerve,
+    MixinUniswapV2,
+    MixinZeroExBridge
+{
+    constructor(IEtherTokenV06 weth)
+        public
+        MixinCurve(weth)
+    {}
+
+    function _trade(
+        BridgeOrder memory order,
+        IERC20TokenV06 sellToken,
+        IERC20TokenV06 buyToken,
+        uint256 sellAmount,
+        bool dryRun
+    )
+        internal
+        override
+        returns (uint256 boughtAmount, bool supportedSource)
+    {
+        uint128 protocolId = uint128(uint256(order.source) >> 128);
+        if (protocolId == BridgeProtocols.CURVE) {
+            if (dryRun) { return (0, true); }
+            boughtAmount = _tradeCurve(
+                sellToken,
+                buyToken,
+                sellAmount,
+                order.bridgeData
+            );
+        } else if (protocolId == BridgeProtocols.CURVEV2) {
+            if (dryRun) { return (0, true); }
+            boughtAmount = _tradeCurveV2(
+                sellToken,
+                buyToken,
+                sellAmount,
+                order.bridgeData
+            );
+        } else if (protocolId == BridgeProtocols.UNISWAPV2) {
+            if (dryRun) { return (0, true); }
+            boughtAmount = _tradeUniswapV2(
+                buyToken,
+                sellAmount,
+                order.bridgeData
+            );
+        } else if (protocolId == BridgeProtocols.BALANCERV2) {
+            if (dryRun) { return (0, true); }
+            boughtAmount = _tradeBalancerV2(
+                sellToken,
+                buyToken,
+                sellAmount,
+                order.bridgeData
+            );
+        } else if (protocolId == BridgeProtocols.NERVE) {
+            if (dryRun) { return (0, true); }
+            boughtAmount = _tradeNerve(
+                sellToken,
+                sellAmount,
+                order.bridgeData
+            );
+        } else if (protocolId == BridgeProtocols.AAVEV2) {
+            if (dryRun) { return (0, true); }
+            boughtAmount = _tradeAaveV2(
+                sellToken,
+                buyToken,
+                sellAmount,
+                order.bridgeData
+            );
+        } else if (protocolId == BridgeProtocols.UNKNOWN) {
+            if (dryRun) { return (0, true); }            
+            boughtAmount = _tradeZeroExBridge(
+                sellToken,
+                buyToken,
+                sellAmount,
+                order.bridgeData
+            );
+        }
+
+        emit BridgeFill(
+            order.source,
+            sellToken,
+            buyToken,
+            sellAmount,
+            boughtAmount
+        );
+    }
+}

contracts/zero-ex/contracts/src/transformers/bridges/IBridgeAdapter.sol

@@ -50,6 +50,10 @@ interface IBridgeAdapter {
         uint256 outputTokenAmount
     );
 
+    function isSupportedSource(bytes32 source)
+        external
+        returns (bool isSupported);
+
     function trade(
         BridgeOrder calldata order,
         IERC20TokenV06 sellToken,

contracts/zero-ex/contracts/src/transformers/bridges/OptimismBridgeAdapter.sol

@@ -0,0 +1,104 @@
+// 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 "./AbstractBridgeAdapter.sol";
+import "./BridgeProtocols.sol";
+import "./mixins/MixinCurve.sol";
+import "./mixins/MixinCurveV2.sol";
+import "./mixins/MixinNerve.sol";
+import "./mixins/MixinUniswapV3.sol";
+import "./mixins/MixinZeroExBridge.sol";
+
+contract OptimismBridgeAdapter is
+    AbstractBridgeAdapter(10, "Optimism"),
+    MixinCurve,
+    MixinCurveV2,
+    MixinNerve,
+    MixinUniswapV3,
+    MixinZeroExBridge
+{
+    constructor(IEtherTokenV06 weth)
+        public
+        MixinCurve(weth)
+    {}
+
+    function _trade(
+        BridgeOrder memory order,
+        IERC20TokenV06 sellToken,
+        IERC20TokenV06 buyToken,
+        uint256 sellAmount,
+        bool dryRun
+    )
+        internal
+        override
+        returns (uint256 boughtAmount, bool supportedSource)
+    {
+        uint128 protocolId = uint128(uint256(order.source) >> 128);
+        if (protocolId == BridgeProtocols.CURVE) {
+            if (dryRun) { return (0, true); }
+            boughtAmount = _tradeCurve(
+                sellToken,
+                buyToken,
+                sellAmount,
+                order.bridgeData
+            );
+        } else if (protocolId == BridgeProtocols.CURVEV2) {
+            if (dryRun) { return (0, true); }
+            boughtAmount = _tradeCurveV2(
+                sellToken,
+                buyToken,
+                sellAmount,
+                order.bridgeData
+            );
+        } else if (protocolId == BridgeProtocols.UNISWAPV3) {
+            if (dryRun) { return (0, true); }
+            boughtAmount = _tradeUniswapV3(
+                sellToken,
+                sellAmount,
+                order.bridgeData
+            );
+        } else if (protocolId == BridgeProtocols.NERVE) {
+            if (dryRun) { return (0, true); }
+            boughtAmount = _tradeNerve(
+                sellToken,
+                sellAmount,
+                order.bridgeData
+            );
+        } else if (protocolId == BridgeProtocols.UNKNOWN) {
+            if (dryRun) { return (0, true); }            
+            boughtAmount = _tradeZeroExBridge(
+                sellToken,
+                buyToken,
+                sellAmount,
+                order.bridgeData
+            );
+        }
+
+        emit BridgeFill(
+            order.source,
+            sellToken,
+            buyToken,
+            sellAmount,
+            boughtAmount
+        );
+    }
+}

contracts/zero-ex/contracts/src/transformers/bridges/PolygonBridgeAdapter.sol

@@ -0,0 +1,178 @@
+// 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 "./AbstractBridgeAdapter.sol";
+import "./BridgeProtocols.sol";
+import "./mixins/MixinAaveV2.sol";
+import "./mixins/MixinBalancerV2.sol";
+import "./mixins/MixinBalancerV2Batch.sol";
+import "./mixins/MixinCurve.sol";
+import "./mixins/MixinCurveV2.sol";
+import "./mixins/MixinDodo.sol";
+import "./mixins/MixinDodoV2.sol";
+import "./mixins/MixinKyberDmm.sol";
+import "./mixins/MixinMStable.sol";
+import "./mixins/MixinNerve.sol";
+import "./mixins/MixinUniswapV2.sol";
+import "./mixins/MixinUniswapV3.sol";
+import "./mixins/MixinZeroExBridge.sol";
+
+contract PolygonBridgeAdapter is
+    AbstractBridgeAdapter(137, "Polygon"),
+    MixinAaveV2,
+    MixinBalancerV2,
+    MixinBalancerV2Batch,
+    MixinCurve,
+    MixinCurveV2,
+    MixinDodo,
+    MixinDodoV2,
+    MixinKyberDmm,
+    MixinMStable,
+    MixinNerve,
+    MixinUniswapV2,
+    MixinUniswapV3,
+    MixinZeroExBridge
+{
+    constructor(IEtherTokenV06 weth)
+        public
+        MixinCurve(weth)
+    {}
+
+    function _trade(
+        BridgeOrder memory order,
+        IERC20TokenV06 sellToken,
+        IERC20TokenV06 buyToken,
+        uint256 sellAmount,
+        bool dryRun
+    )
+        internal
+        override
+        returns (uint256 boughtAmount, bool supportedSource)
+    {
+        uint128 protocolId = uint128(uint256(order.source) >> 128);
+        if (protocolId == BridgeProtocols.CURVE) {
+            if (dryRun) { return (0, true); }
+            boughtAmount = _tradeCurve(
+                sellToken,
+                buyToken,
+                sellAmount,
+                order.bridgeData
+            );
+        } else if (protocolId == BridgeProtocols.CURVEV2) {
+            if (dryRun) { return (0, true); }
+            boughtAmount = _tradeCurveV2(
+                sellToken,
+                buyToken,
+                sellAmount,
+                order.bridgeData
+            );
+        } else if (protocolId == BridgeProtocols.UNISWAPV3) {
+            if (dryRun) { return (0, true); }
+            boughtAmount = _tradeUniswapV3(
+                sellToken,
+                sellAmount,
+                order.bridgeData
+            );
+        } else if (protocolId == BridgeProtocols.UNISWAPV2) {
+            if (dryRun) { return (0, true); }
+            boughtAmount = _tradeUniswapV2(
+                buyToken,
+                sellAmount,
+                order.bridgeData
+            );
+        } else if (protocolId == BridgeProtocols.BALANCERV2) {
+            if (dryRun) { return (0, true); }
+            boughtAmount = _tradeBalancerV2(
+                sellToken,
+                buyToken,
+                sellAmount,
+                order.bridgeData
+            );
+        } else if (protocolId == BridgeProtocols.BALANCERV2BATCH) {
+            if (dryRun) { return (0, true); }
+            boughtAmount = _tradeBalancerV2Batch(
+                sellAmount,
+                order.bridgeData
+            );
+        } else if (protocolId == BridgeProtocols.MSTABLE) {
+            if (dryRun) { return (0, true); }
+            boughtAmount = _tradeMStable(
+                sellToken,
+                buyToken,
+                sellAmount,
+                order.bridgeData
+            );
+        } else if (protocolId == BridgeProtocols.DODO) {
+            if (dryRun) { return (0, true); }
+            boughtAmount = _tradeDodo(
+                sellToken,
+                sellAmount,
+                order.bridgeData
+            );
+        } else if (protocolId == BridgeProtocols.DODOV2) {
+            if (dryRun) { return (0, true); }
+            boughtAmount = _tradeDodoV2(
+                sellToken,
+                sellAmount,
+                order.bridgeData
+            );
+        } else if (protocolId == BridgeProtocols.NERVE) {
+            if (dryRun) { return (0, true); }
+            boughtAmount = _tradeNerve(
+                sellToken,
+                sellAmount,
+                order.bridgeData
+            );
+        } else if (protocolId == BridgeProtocols.KYBERDMM) {
+            if (dryRun) { return (0, true); }
+            boughtAmount = _tradeKyberDmm(
+                buyToken,
+                sellAmount,
+                order.bridgeData
+            );
+        } else if (protocolId == BridgeProtocols.AAVEV2) {
+            if (dryRun) { return (0, true); }
+            boughtAmount = _tradeAaveV2(
+                sellToken,
+                buyToken,
+                sellAmount,
+                order.bridgeData
+            );
+        } else if (protocolId == BridgeProtocols.UNKNOWN) {
+            if (dryRun) { return (0, true); }            
+            boughtAmount = _tradeZeroExBridge(
+                sellToken,
+                buyToken,
+                sellAmount,
+                order.bridgeData
+            );
+        }
+
+        emit BridgeFill(
+            order.source,
+            sellToken,
+            buyToken,
+            sellAmount,
+            boughtAmount
+        );
+    }
+}

contracts/zero-ex/contracts/src/transformers/bridges/mixins/MixinPlatypus.sol

@@ -1,3 +1,22 @@
+// 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;
 
@@ -58,7 +77,7 @@ contract MixinPlatypus {
         //keep track of the previous balance to confirm amount out
         uint256 beforeBalance = buyToken.balanceOf(address(this));
 
-        (uint256 amountOut, uint256 haircut) = router.swapTokensForTokens(
+        router.swapTokensForTokens(
             // Convert to `buyToken` along this path.
             _path,
             // pool to swap on

contracts/zero-ex/package.json

@@ -41,9 +41,9 @@
         "rollback": "node ./lib/scripts/rollback.js"
     },
     "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",
+        "publicInterfaceContracts": "IZeroEx,ZeroEx,FullMigration,InitialMigration,IFlashWallet,IERC20Transformer,IOwnableFeature,ISimpleFunctionRegistryFeature,ITransformERC20Feature,FillQuoteTransformer,PayTakerTransformer,PositiveSlippageFeeTransformer,WethTransformer,OwnableFeature,SimpleFunctionRegistryFeature,TransformERC20Feature,AffiliateFeeTransformer,MetaTransactionsFeature,LogMetadataTransformer,LiquidityProviderFeature,ILiquidityProviderFeature,NativeOrdersFeature,INativeOrdersFeature,FeeCollectorController,FeeCollector,CurveLiquidityProvider,BatchFillNativeOrdersFeature,IBatchFillNativeOrdersFeature,MultiplexFeature,IMultiplexFeature,OtcOrdersFeature,IOtcOrdersFeature,AvalancheBridgeAdapter,BSCBridgeAdapter,CeloBridgeAdapter,EthereumBridgeAdapter,FantomBridgeAdapter,OptimismBridgeAdapter,PolygonBridgeAdapter",
         "abis:comment": "This list is auto-generated by contracts-gen. Don't edit manually.",
-        "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|MixinBalancerV2Batch|MixinBancor|MixinCompound|MixinCryptoCom|MixinCurve|MixinCurveV2|MixinDodo|MixinDodoV2|MixinGMX|MixinKyberDmm|MixinLido|MixinMStable|MixinMakerPSM|MixinMooniswap|MixinNerve|MixinPlatypus|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"
+        "abis": "./test/generated-artifacts/@(AbstractBridgeAdapter|AffiliateFeeTransformer|AvalancheBridgeAdapter|BSCBridgeAdapter|BatchFillNativeOrdersFeature|BootstrapFeature|BridgeProtocols|CeloBridgeAdapter|CurveLiquidityProvider|ERC1155OrdersFeature|ERC165Feature|ERC721OrdersFeature|EthereumBridgeAdapter|FantomBridgeAdapter|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|MixinBalancerV2Batch|MixinBancor|MixinCompound|MixinCryptoCom|MixinCurve|MixinCurveV2|MixinDodo|MixinDodoV2|MixinGMX|MixinKyberDmm|MixinLido|MixinMStable|MixinMakerPSM|MixinMooniswap|MixinNerve|MixinPlatypus|MixinShell|MixinUniswap|MixinUniswapV2|MixinUniswapV3|MixinZeroExBridge|MooniswapLiquidityProvider|MultiplexFeature|MultiplexLiquidityProvider|MultiplexOtc|MultiplexRfq|MultiplexTransformERC20|MultiplexUniswapV2|MultiplexUniswapV3|NFTOrders|NativeOrdersCancellation|NativeOrdersFeature|NativeOrdersInfo|NativeOrdersProtocolFees|NativeOrdersSettlement|OptimismBridgeAdapter|OtcOrdersFeature|OwnableFeature|PancakeSwapFeature|PayTakerTransformer|PermissionlessTransformerDeployer|PolygonBridgeAdapter|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",

contracts/zero-ex/src/artifacts.ts

@@ -6,9 +6,13 @@
 import { ContractArtifact } from 'ethereum-types';
 
 import * as AffiliateFeeTransformer from '../generated-artifacts/AffiliateFeeTransformer.json';
+import * as AvalancheBridgeAdapter from '../generated-artifacts/AvalancheBridgeAdapter.json';
 import * as BatchFillNativeOrdersFeature from '../generated-artifacts/BatchFillNativeOrdersFeature.json';
-import * as BridgeAdapter from '../generated-artifacts/BridgeAdapter.json';
+import * as BSCBridgeAdapter from '../generated-artifacts/BSCBridgeAdapter.json';
+import * as CeloBridgeAdapter from '../generated-artifacts/CeloBridgeAdapter.json';
 import * as CurveLiquidityProvider from '../generated-artifacts/CurveLiquidityProvider.json';
+import * as EthereumBridgeAdapter from '../generated-artifacts/EthereumBridgeAdapter.json';
+import * as FantomBridgeAdapter from '../generated-artifacts/FantomBridgeAdapter.json';
 import * as FeeCollector from '../generated-artifacts/FeeCollector.json';
 import * as FeeCollectorController from '../generated-artifacts/FeeCollectorController.json';
 import * as FillQuoteTransformer from '../generated-artifacts/FillQuoteTransformer.json';
@@ -30,9 +34,11 @@ import * as LogMetadataTransformer from '../generated-artifacts/LogMetadataTrans
 import * as MetaTransactionsFeature from '../generated-artifacts/MetaTransactionsFeature.json';
 import * as MultiplexFeature from '../generated-artifacts/MultiplexFeature.json';
 import * as NativeOrdersFeature from '../generated-artifacts/NativeOrdersFeature.json';
+import * as OptimismBridgeAdapter from '../generated-artifacts/OptimismBridgeAdapter.json';
 import * as OtcOrdersFeature from '../generated-artifacts/OtcOrdersFeature.json';
 import * as OwnableFeature from '../generated-artifacts/OwnableFeature.json';
 import * as PayTakerTransformer from '../generated-artifacts/PayTakerTransformer.json';
+import * as PolygonBridgeAdapter from '../generated-artifacts/PolygonBridgeAdapter.json';
 import * as PositiveSlippageFeeTransformer from '../generated-artifacts/PositiveSlippageFeeTransformer.json';
 import * as SimpleFunctionRegistryFeature from '../generated-artifacts/SimpleFunctionRegistryFeature.json';
 import * as TransformERC20Feature from '../generated-artifacts/TransformERC20Feature.json';
@@ -58,7 +64,6 @@ export const artifacts = {
     AffiliateFeeTransformer: AffiliateFeeTransformer as ContractArtifact,
     MetaTransactionsFeature: MetaTransactionsFeature as ContractArtifact,
     LogMetadataTransformer: LogMetadataTransformer as ContractArtifact,
-    BridgeAdapter: BridgeAdapter as ContractArtifact,
     LiquidityProviderFeature: LiquidityProviderFeature as ContractArtifact,
     ILiquidityProviderFeature: ILiquidityProviderFeature as ContractArtifact,
     NativeOrdersFeature: NativeOrdersFeature as ContractArtifact,
@@ -72,4 +77,11 @@ export const artifacts = {
     IMultiplexFeature: IMultiplexFeature as ContractArtifact,
     OtcOrdersFeature: OtcOrdersFeature as ContractArtifact,
     IOtcOrdersFeature: IOtcOrdersFeature as ContractArtifact,
+    AvalancheBridgeAdapter: AvalancheBridgeAdapter as ContractArtifact,
+    BSCBridgeAdapter: BSCBridgeAdapter as ContractArtifact,
+    CeloBridgeAdapter: CeloBridgeAdapter as ContractArtifact,
+    EthereumBridgeAdapter: EthereumBridgeAdapter as ContractArtifact,
+    FantomBridgeAdapter: FantomBridgeAdapter as ContractArtifact,
+    OptimismBridgeAdapter: OptimismBridgeAdapter as ContractArtifact,
+    PolygonBridgeAdapter: PolygonBridgeAdapter as ContractArtifact,
 };

contracts/zero-ex/src/index.ts

@@ -35,7 +35,11 @@ export * from './bloom_filter_utils';
 export { GREEDY_TOKENS } from './constants';
 export {
     AffiliateFeeTransformerContract,
-    BridgeAdapterContract,
+    AvalancheBridgeAdapterContract,
+    BSCBridgeAdapterContract,
+    CeloBridgeAdapterContract,
+    EthereumBridgeAdapterContract,
+    FantomBridgeAdapterContract,
     FillQuoteTransformerContract,
     IOwnableFeatureContract,
     IOwnableFeatureEvents,
@@ -45,7 +49,9 @@ export {
     IZeroExContract,
     LogMetadataTransformerContract,
     MultiplexFeatureContract,
+    OptimismBridgeAdapterContract,
     PayTakerTransformerContract,
+    PolygonBridgeAdapterContract,
     PositiveSlippageFeeTransformerContract,
     TransformERC20FeatureContract,
     WethTransformerContract,

contracts/zero-ex/src/wrappers.ts

@@ -4,9 +4,13 @@
  * -----------------------------------------------------------------------------
  */
 export * from '../generated-wrappers/affiliate_fee_transformer';
+export * from '../generated-wrappers/avalanche_bridge_adapter';
+export * from '../generated-wrappers/b_s_c_bridge_adapter';
 export * from '../generated-wrappers/batch_fill_native_orders_feature';
-export * from '../generated-wrappers/bridge_adapter';
+export * from '../generated-wrappers/celo_bridge_adapter';
 export * from '../generated-wrappers/curve_liquidity_provider';
+export * from '../generated-wrappers/ethereum_bridge_adapter';
+export * from '../generated-wrappers/fantom_bridge_adapter';
 export * from '../generated-wrappers/fee_collector';
 export * from '../generated-wrappers/fee_collector_controller';
 export * from '../generated-wrappers/fill_quote_transformer';
@@ -28,9 +32,11 @@ export * from '../generated-wrappers/log_metadata_transformer';
 export * from '../generated-wrappers/meta_transactions_feature';
 export * from '../generated-wrappers/multiplex_feature';
 export * from '../generated-wrappers/native_orders_feature';
+export * from '../generated-wrappers/optimism_bridge_adapter';
 export * from '../generated-wrappers/otc_orders_feature';
 export * from '../generated-wrappers/ownable_feature';
 export * from '../generated-wrappers/pay_taker_transformer';
+export * from '../generated-wrappers/polygon_bridge_adapter';
 export * from '../generated-wrappers/positive_slippage_fee_transformer';
 export * from '../generated-wrappers/simple_function_registry_feature';
 export * from '../generated-wrappers/transform_erc20_feature';

contracts/zero-ex/test/artifacts.ts

@@ -5,15 +5,20 @@
  */
 import { ContractArtifact } from 'ethereum-types';
 
+import * as AbstractBridgeAdapter from '../test/generated-artifacts/AbstractBridgeAdapter.json';
 import * as AffiliateFeeTransformer from '../test/generated-artifacts/AffiliateFeeTransformer.json';
+import * as AvalancheBridgeAdapter from '../test/generated-artifacts/AvalancheBridgeAdapter.json';
 import * as BatchFillNativeOrdersFeature from '../test/generated-artifacts/BatchFillNativeOrdersFeature.json';
 import * as BootstrapFeature from '../test/generated-artifacts/BootstrapFeature.json';
-import * as BridgeAdapter from '../test/generated-artifacts/BridgeAdapter.json';
 import * as BridgeProtocols from '../test/generated-artifacts/BridgeProtocols.json';
+import * as BSCBridgeAdapter from '../test/generated-artifacts/BSCBridgeAdapter.json';
+import * as CeloBridgeAdapter from '../test/generated-artifacts/CeloBridgeAdapter.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 EthereumBridgeAdapter from '../test/generated-artifacts/EthereumBridgeAdapter.json';
+import * as FantomBridgeAdapter from '../test/generated-artifacts/FantomBridgeAdapter.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';
@@ -136,11 +141,13 @@ import * as NativeOrdersInfo from '../test/generated-artifacts/NativeOrdersInfo.
 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 OptimismBridgeAdapter from '../test/generated-artifacts/OptimismBridgeAdapter.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';
 import * as PayTakerTransformer from '../test/generated-artifacts/PayTakerTransformer.json';
 import * as PermissionlessTransformerDeployer from '../test/generated-artifacts/PermissionlessTransformerDeployer.json';
+import * as PolygonBridgeAdapter from '../test/generated-artifacts/PolygonBridgeAdapter.json';
 import * as PositiveSlippageFeeTransformer from '../test/generated-artifacts/PositiveSlippageFeeTransformer.json';
 import * as SimpleFunctionRegistryFeature from '../test/generated-artifacts/SimpleFunctionRegistryFeature.json';
 import * as TestBridge from '../test/generated-artifacts/TestBridge.json';
@@ -307,9 +314,16 @@ export const artifacts = {
     PositiveSlippageFeeTransformer: PositiveSlippageFeeTransformer as ContractArtifact,
     Transformer: Transformer as ContractArtifact,
     WethTransformer: WethTransformer as ContractArtifact,
-    BridgeAdapter: BridgeAdapter as ContractArtifact,
+    AbstractBridgeAdapter: AbstractBridgeAdapter as ContractArtifact,
+    AvalancheBridgeAdapter: AvalancheBridgeAdapter as ContractArtifact,
+    BSCBridgeAdapter: BSCBridgeAdapter as ContractArtifact,
     BridgeProtocols: BridgeProtocols as ContractArtifact,
+    CeloBridgeAdapter: CeloBridgeAdapter as ContractArtifact,
+    EthereumBridgeAdapter: EthereumBridgeAdapter as ContractArtifact,
+    FantomBridgeAdapter: FantomBridgeAdapter as ContractArtifact,
     IBridgeAdapter: IBridgeAdapter as ContractArtifact,
+    OptimismBridgeAdapter: OptimismBridgeAdapter as ContractArtifact,
+    PolygonBridgeAdapter: PolygonBridgeAdapter as ContractArtifact,
     MixinAaveV2: MixinAaveV2 as ContractArtifact,
     MixinBalancer: MixinBalancer as ContractArtifact,
     MixinBalancerV2: MixinBalancerV2 as ContractArtifact,

contracts/zero-ex/test/transformers/fill_quote_transformer_test.ts

@@ -28,7 +28,7 @@ import { artifacts } from '../artifacts';
 import { TestFillQuoteTransformerBridgeContract } from '../generated-wrappers/test_fill_quote_transformer_bridge';
 import { getRandomLimitOrder, getRandomRfqOrder } from '../utils/orders';
 import {
-    BridgeAdapterContract,
+    EthereumBridgeAdapterContract,
     FillQuoteTransformerContract,
     TestFillQuoteTransformerExchangeContract,
     TestFillQuoteTransformerHostContract,
@@ -52,7 +52,8 @@ blockchainTests.resets('FillQuoteTransformer', env => {
     let singleProtocolFee: BigNumber;
 
     const GAS_PRICE = 1337;
-    const TEST_BRIDGE_SOURCE = hexUtils.random(32);
+    // Left half is 0, corresponding to BridgeProtocol.Unknown
+    const TEST_BRIDGE_SOURCE = hexUtils.leftPad(hexUtils.random(16), 32);
     const HIGH_BIT = new BigNumber(2).pow(255);
     const REVERT_AMOUNT = new BigNumber('0xdeadbeef');
 
@@ -64,8 +65,8 @@ blockchainTests.resets('FillQuoteTransformer', env => {
             env.txDefaults,
             artifacts,
         );
-        const bridgeAdapter = await BridgeAdapterContract.deployFrom0xArtifactAsync(
+        const bridgeAdapter = await EthereumBridgeAdapterContract.deployFrom0xArtifactAsync(
-            artifacts.BridgeAdapter,
+            artifacts.EthereumBridgeAdapter,
             env.provider,
             env.txDefaults,
             artifacts,

contracts/zero-ex/test/wrappers.ts

@@ -3,15 +3,20 @@
  * Warning: This file is auto-generated by contracts-gen. Don't edit manually.
  * -----------------------------------------------------------------------------
  */
+export * from '../test/generated-wrappers/abstract_bridge_adapter';
 export * from '../test/generated-wrappers/affiliate_fee_transformer';
+export * from '../test/generated-wrappers/avalanche_bridge_adapter';
+export * from '../test/generated-wrappers/b_s_c_bridge_adapter';
 export * from '../test/generated-wrappers/batch_fill_native_orders_feature';
 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/celo_bridge_adapter';
 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/ethereum_bridge_adapter';
+export * from '../test/generated-wrappers/fantom_bridge_adapter';
 export * from '../test/generated-wrappers/fee_collector';
 export * from '../test/generated-wrappers/fee_collector_controller';
 export * from '../test/generated-wrappers/fill_quote_transformer';
@@ -134,11 +139,13 @@ export * from '../test/generated-wrappers/native_orders_feature';
 export * from '../test/generated-wrappers/native_orders_info';
 export * from '../test/generated-wrappers/native_orders_protocol_fees';
 export * from '../test/generated-wrappers/native_orders_settlement';
+export * from '../test/generated-wrappers/optimism_bridge_adapter';
 export * from '../test/generated-wrappers/otc_orders_feature';
 export * from '../test/generated-wrappers/ownable_feature';
 export * from '../test/generated-wrappers/pancake_swap_feature';
 export * from '../test/generated-wrappers/pay_taker_transformer';
 export * from '../test/generated-wrappers/permissionless_transformer_deployer';
+export * from '../test/generated-wrappers/polygon_bridge_adapter';
 export * from '../test/generated-wrappers/positive_slippage_fee_transformer';
 export * from '../test/generated-wrappers/simple_function_registry_feature';
 export * from '../test/generated-wrappers/test_bridge';

contracts/zero-ex/tsconfig.json

@@ -4,9 +4,13 @@
     "include": ["./src/**/*", "./test/**/*", "./generated-wrappers/**/*", "./scripts/**/*"],
     "files": [
         "generated-artifacts/AffiliateFeeTransformer.json",
+        "generated-artifacts/AvalancheBridgeAdapter.json",
+        "generated-artifacts/BSCBridgeAdapter.json",
         "generated-artifacts/BatchFillNativeOrdersFeature.json",
-        "generated-artifacts/BridgeAdapter.json",
+        "generated-artifacts/CeloBridgeAdapter.json",
         "generated-artifacts/CurveLiquidityProvider.json",
+        "generated-artifacts/EthereumBridgeAdapter.json",
+        "generated-artifacts/FantomBridgeAdapter.json",
         "generated-artifacts/FeeCollector.json",
         "generated-artifacts/FeeCollectorController.json",
         "generated-artifacts/FillQuoteTransformer.json",
@@ -28,23 +32,30 @@
         "generated-artifacts/MetaTransactionsFeature.json",
         "generated-artifacts/MultiplexFeature.json",
         "generated-artifacts/NativeOrdersFeature.json",
+        "generated-artifacts/OptimismBridgeAdapter.json",
         "generated-artifacts/OtcOrdersFeature.json",
         "generated-artifacts/OwnableFeature.json",
         "generated-artifacts/PayTakerTransformer.json",
+        "generated-artifacts/PolygonBridgeAdapter.json",
         "generated-artifacts/PositiveSlippageFeeTransformer.json",
         "generated-artifacts/SimpleFunctionRegistryFeature.json",
         "generated-artifacts/TransformERC20Feature.json",
         "generated-artifacts/WethTransformer.json",
         "generated-artifacts/ZeroEx.json",
+        "test/generated-artifacts/AbstractBridgeAdapter.json",
         "test/generated-artifacts/AffiliateFeeTransformer.json",
+        "test/generated-artifacts/AvalancheBridgeAdapter.json",
+        "test/generated-artifacts/BSCBridgeAdapter.json",
         "test/generated-artifacts/BatchFillNativeOrdersFeature.json",
         "test/generated-artifacts/BootstrapFeature.json",
-        "test/generated-artifacts/BridgeAdapter.json",
         "test/generated-artifacts/BridgeProtocols.json",
+        "test/generated-artifacts/CeloBridgeAdapter.json",
         "test/generated-artifacts/CurveLiquidityProvider.json",
         "test/generated-artifacts/ERC1155OrdersFeature.json",
         "test/generated-artifacts/ERC165Feature.json",
         "test/generated-artifacts/ERC721OrdersFeature.json",
+        "test/generated-artifacts/EthereumBridgeAdapter.json",
+        "test/generated-artifacts/FantomBridgeAdapter.json",
         "test/generated-artifacts/FeeCollector.json",
         "test/generated-artifacts/FeeCollectorController.json",
         "test/generated-artifacts/FillQuoteTransformer.json",
@@ -167,11 +178,13 @@
         "test/generated-artifacts/NativeOrdersInfo.json",
         "test/generated-artifacts/NativeOrdersProtocolFees.json",
         "test/generated-artifacts/NativeOrdersSettlement.json",
+        "test/generated-artifacts/OptimismBridgeAdapter.json",
         "test/generated-artifacts/OtcOrdersFeature.json",
         "test/generated-artifacts/OwnableFeature.json",
         "test/generated-artifacts/PancakeSwapFeature.json",
         "test/generated-artifacts/PayTakerTransformer.json",
         "test/generated-artifacts/PermissionlessTransformerDeployer.json",
+        "test/generated-artifacts/PolygonBridgeAdapter.json",
         "test/generated-artifacts/PositiveSlippageFeeTransformer.json",
         "test/generated-artifacts/SimpleFunctionRegistryFeature.json",
         "test/generated-artifacts/TestBridge.json",

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

@@ -288,7 +288,6 @@ export const BUY_SOURCE_FILTER_BY_CHAIN_ID = valueByChainId<SourceFilters>(
             ERC20BridgeSource.JetSwap,
             ERC20BridgeSource.ACryptos,
             ERC20BridgeSource.KyberDmm,
-            ERC20BridgeSource.Synapse,
             ERC20BridgeSource.BiSwap,
         ]),
         [ChainId.Polygon]: new SourceFilters([

packages/asset-swapper/test/contracts/bridge_adapter_test.ts

@@ -0,0 +1,298 @@
+import { ChainId } from '@0x/contract-addresses';
+import { blockchainTests, constants, describe, expect } from '@0x/contracts-test-utils';
+import {
+    artifacts as zeroExArtifacts,
+    AvalancheBridgeAdapterContract,
+    BSCBridgeAdapterContract,
+    CeloBridgeAdapterContract,
+    EthereumBridgeAdapterContract,
+    FantomBridgeAdapterContract,
+    OptimismBridgeAdapterContract,
+    PolygonBridgeAdapterContract,
+} from '@0x/contracts-zero-ex';
+
+import { BUY_SOURCE_FILTER_BY_CHAIN_ID, ERC20BridgeSource, SELL_SOURCE_FILTER_BY_CHAIN_ID } from '../../src';
+import { getErc20BridgeSourceToBridgeSource } from '../../src/utils/market_operation_utils/orders';
+
+blockchainTests('Bridge adapter source compatibility tests', env => {
+    describe('Avalanche', () => {
+        let adapter: AvalancheBridgeAdapterContract;
+        before(async () => {
+            adapter = await AvalancheBridgeAdapterContract.deployFrom0xArtifactAsync(
+                zeroExArtifacts.AvalancheBridgeAdapter,
+                env.provider,
+                env.txDefaults,
+                zeroExArtifacts,
+                constants.NULL_ADDRESS,
+            );
+        });
+        it('sell sources', async () => {
+            const sellSources = SELL_SOURCE_FILTER_BY_CHAIN_ID[ChainId.Avalanche].exclude([
+                ERC20BridgeSource.Native,
+                ERC20BridgeSource.MultiHop,
+            ]).sources;
+            return Promise.all(
+                sellSources.map(async source => {
+                    const isSupported = await adapter
+                        .isSupportedSource(getErc20BridgeSourceToBridgeSource(source))
+                        .callAsync();
+                    expect(isSupported, `${source} is not supported`).to.be.true();
+                }),
+            );
+        });
+        it('buy sources', async () => {
+            const buySources = BUY_SOURCE_FILTER_BY_CHAIN_ID[ChainId.Avalanche].exclude([
+                ERC20BridgeSource.Native,
+                ERC20BridgeSource.MultiHop,
+            ]).sources;
+            return Promise.all(
+                buySources.map(async source => {
+                    const isSupported = await adapter
+                        .isSupportedSource(getErc20BridgeSourceToBridgeSource(source))
+                        .callAsync();
+                    expect(isSupported, `${source} is not supported`).to.be.true();
+                }),
+            );
+        });
+    });
+    describe('BSC', () => {
+        let adapter: BSCBridgeAdapterContract;
+        before(async () => {
+            adapter = await BSCBridgeAdapterContract.deployFrom0xArtifactAsync(
+                zeroExArtifacts.BSCBridgeAdapter,
+                env.provider,
+                env.txDefaults,
+                zeroExArtifacts,
+                constants.NULL_ADDRESS,
+            );
+        });
+        it('sell sources', async () => {
+            const sellSources = SELL_SOURCE_FILTER_BY_CHAIN_ID[ChainId.BSC].exclude([
+                ERC20BridgeSource.Native,
+                ERC20BridgeSource.MultiHop,
+            ]).sources;
+            return Promise.all(
+                sellSources.map(async source => {
+                    const isSupported = await adapter
+                        .isSupportedSource(getErc20BridgeSourceToBridgeSource(source))
+                        .callAsync();
+                    expect(isSupported, `${source} is not supported`).to.be.true();
+                }),
+            );
+        });
+        it('buy sources', async () => {
+            const buySources = BUY_SOURCE_FILTER_BY_CHAIN_ID[ChainId.BSC].exclude([
+                ERC20BridgeSource.Native,
+                ERC20BridgeSource.MultiHop,
+            ]).sources;
+            return Promise.all(
+                buySources.map(async source => {
+                    const isSupported = await adapter
+                        .isSupportedSource(getErc20BridgeSourceToBridgeSource(source))
+                        .callAsync();
+                    expect(isSupported, `${source} is not supported`).to.be.true();
+                }),
+            );
+        });
+    });
+    describe('Celo', () => {
+        let adapter: CeloBridgeAdapterContract;
+        before(async () => {
+            adapter = await CeloBridgeAdapterContract.deployFrom0xArtifactAsync(
+                zeroExArtifacts.CeloBridgeAdapter,
+                env.provider,
+                env.txDefaults,
+                zeroExArtifacts,
+                constants.NULL_ADDRESS,
+            );
+        });
+        it('sell sources', async () => {
+            const sellSources = SELL_SOURCE_FILTER_BY_CHAIN_ID[ChainId.Celo].exclude([
+                ERC20BridgeSource.Native,
+                ERC20BridgeSource.MultiHop,
+            ]).sources;
+            return Promise.all(
+                sellSources.map(async source => {
+                    const isSupported = await adapter
+                        .isSupportedSource(getErc20BridgeSourceToBridgeSource(source))
+                        .callAsync();
+                    expect(isSupported, `${source} is not supported`).to.be.true();
+                }),
+            );
+        });
+        it('buy sources', async () => {
+            const buySources = BUY_SOURCE_FILTER_BY_CHAIN_ID[ChainId.Celo].exclude([
+                ERC20BridgeSource.Native,
+                ERC20BridgeSource.MultiHop,
+            ]).sources;
+            return Promise.all(
+                buySources.map(async source => {
+                    const isSupported = await adapter
+                        .isSupportedSource(getErc20BridgeSourceToBridgeSource(source))
+                        .callAsync();
+                    expect(isSupported, `${source} is not supported`).to.be.true();
+                }),
+            );
+        });
+    });
+    describe('Ethereum', () => {
+        let adapter: EthereumBridgeAdapterContract;
+        before(async () => {
+            adapter = await EthereumBridgeAdapterContract.deployFrom0xArtifactAsync(
+                zeroExArtifacts.EthereumBridgeAdapter,
+                env.provider,
+                env.txDefaults,
+                zeroExArtifacts,
+                constants.NULL_ADDRESS,
+            );
+        });
+        it('sell sources', async () => {
+            const sellSources = SELL_SOURCE_FILTER_BY_CHAIN_ID[ChainId.Mainnet].exclude([
+                ERC20BridgeSource.Native,
+                ERC20BridgeSource.MultiHop,
+            ]).sources;
+            return Promise.all(
+                sellSources.map(async source => {
+                    const isSupported = await adapter
+                        .isSupportedSource(getErc20BridgeSourceToBridgeSource(source))
+                        .callAsync();
+                    expect(isSupported, `${source} is not supported`).to.be.true();
+                }),
+            );
+        });
+        it('buy sources', async () => {
+            const buySources = BUY_SOURCE_FILTER_BY_CHAIN_ID[ChainId.Mainnet].exclude([
+                ERC20BridgeSource.Native,
+                ERC20BridgeSource.MultiHop,
+            ]).sources;
+            return Promise.all(
+                buySources.map(async source => {
+                    const isSupported = await adapter
+                        .isSupportedSource(getErc20BridgeSourceToBridgeSource(source))
+                        .callAsync();
+                    expect(isSupported, `${source} is not supported`).to.be.true();
+                }),
+            );
+        });
+    });
+    describe('Fantom', () => {
+        let adapter: FantomBridgeAdapterContract;
+        before(async () => {
+            adapter = await FantomBridgeAdapterContract.deployFrom0xArtifactAsync(
+                zeroExArtifacts.FantomBridgeAdapter,
+                env.provider,
+                env.txDefaults,
+                zeroExArtifacts,
+                constants.NULL_ADDRESS,
+            );
+        });
+        it('sell sources', async () => {
+            const sellSources = SELL_SOURCE_FILTER_BY_CHAIN_ID[ChainId.Fantom].exclude([
+                ERC20BridgeSource.Native,
+                ERC20BridgeSource.MultiHop,
+            ]).sources;
+            return Promise.all(
+                sellSources.map(async source => {
+                    const isSupported = await adapter
+                        .isSupportedSource(getErc20BridgeSourceToBridgeSource(source))
+                        .callAsync();
+                    expect(isSupported, `${source} is not supported`).to.be.true();
+                }),
+            );
+        });
+        it('buy sources', async () => {
+            const buySources = BUY_SOURCE_FILTER_BY_CHAIN_ID[ChainId.Fantom].exclude([
+                ERC20BridgeSource.Native,
+                ERC20BridgeSource.MultiHop,
+            ]).sources;
+            return Promise.all(
+                buySources.map(async source => {
+                    const isSupported = await adapter
+                        .isSupportedSource(getErc20BridgeSourceToBridgeSource(source))
+                        .callAsync();
+                    expect(isSupported, `${source} is not supported`).to.be.true();
+                }),
+            );
+        });
+    });
+    describe('Optimism', () => {
+        let adapter: OptimismBridgeAdapterContract;
+        before(async () => {
+            adapter = await OptimismBridgeAdapterContract.deployFrom0xArtifactAsync(
+                zeroExArtifacts.OptimismBridgeAdapter,
+                env.provider,
+                env.txDefaults,
+                zeroExArtifacts,
+                constants.NULL_ADDRESS,
+            );
+        });
+        it('sell sources', async () => {
+            const sellSources = SELL_SOURCE_FILTER_BY_CHAIN_ID[ChainId.Optimism].exclude([
+                ERC20BridgeSource.Native,
+                ERC20BridgeSource.MultiHop,
+            ]).sources;
+            return Promise.all(
+                sellSources.map(async source => {
+                    const isSupported = await adapter
+                        .isSupportedSource(getErc20BridgeSourceToBridgeSource(source))
+                        .callAsync();
+                    expect(isSupported, `${source} is not supported`).to.be.true();
+                }),
+            );
+        });
+        it('buy sources', async () => {
+            const buySources = BUY_SOURCE_FILTER_BY_CHAIN_ID[ChainId.Optimism].exclude([
+                ERC20BridgeSource.Native,
+                ERC20BridgeSource.MultiHop,
+            ]).sources;
+            return Promise.all(
+                buySources.map(async source => {
+                    const isSupported = await adapter
+                        .isSupportedSource(getErc20BridgeSourceToBridgeSource(source))
+                        .callAsync();
+                    expect(isSupported, `${source} is not supported`).to.be.true();
+                }),
+            );
+        });
+    });
+    describe('Polygon', () => {
+        let adapter: PolygonBridgeAdapterContract;
+        before(async () => {
+            adapter = await PolygonBridgeAdapterContract.deployFrom0xArtifactAsync(
+                zeroExArtifacts.PolygonBridgeAdapter,
+                env.provider,
+                env.txDefaults,
+                zeroExArtifacts,
+                constants.NULL_ADDRESS,
+            );
+        });
+        it('sell sources', async () => {
+            const sellSources = SELL_SOURCE_FILTER_BY_CHAIN_ID[ChainId.Polygon].exclude([
+                ERC20BridgeSource.Native,
+                ERC20BridgeSource.MultiHop,
+            ]).sources;
+            return Promise.all(
+                sellSources.map(async source => {
+                    const isSupported = await adapter
+                        .isSupportedSource(getErc20BridgeSourceToBridgeSource(source))
+                        .callAsync();
+                    expect(isSupported, `${source} is not supported`).to.be.true();
+                }),
+            );
+        });
+        it('buy sources', async () => {
+            const buySources = BUY_SOURCE_FILTER_BY_CHAIN_ID[ChainId.Polygon].exclude([
+                ERC20BridgeSource.Native,
+                ERC20BridgeSource.MultiHop,
+            ]).sources;
+            return Promise.all(
+                buySources.map(async source => {
+                    const isSupported = await adapter
+                        .isSupportedSource(getErc20BridgeSourceToBridgeSource(source))
+                        .callAsync();
+                    expect(isSupported, `${source} is not supported`).to.be.true();
+                }),
+            );
+        });
+    });
+});

packages/migrations/src/migration.ts

@@ -10,7 +10,7 @@ import {
 import {
     AffiliateFeeTransformerContract,
     artifacts as exchangeProxyArtifacts,
-    BridgeAdapterContract,
+    EthereumBridgeAdapterContract,
     FillQuoteTransformerContract,
     fullMigrateAsync as fullMigrateExchangeProxyAsync,
     PayTakerTransformerContract,
@@ -206,8 +206,8 @@ export async function runMigrationsAsync(
 
     // Exchange Proxy //////////////////////////////////////////////////////////
 
-    const bridgeAdapter = await BridgeAdapterContract.deployFrom0xArtifactAsync(
+    const bridgeAdapter = await EthereumBridgeAdapterContract.deployFrom0xArtifactAsync(
-        exchangeProxyArtifacts.BridgeAdapter,
+        exchangeProxyArtifacts.EthereumBridgeAdapter,
         provider,
         txDefaults,
         allArtifacts,

packages/protocol-utils/src/transformer_utils.ts

@@ -107,6 +107,7 @@ export interface FillQuoteTransformerData {
 // tslint:disable: enum-naming
 /**
  * Identifies the DEX protocol used to fill a bridge order.
+ * Note: These need to correspond exactly with BridgeProtocols.sol!
  */
 export enum BridgeProtocol {
     Unknown,
@@ -114,13 +115,16 @@ export enum BridgeProtocol {
     UniswapV2,
     Uniswap,
     Balancer,
+    Kyber_DEPRECATED,
     Mooniswap,
     MStable,
+    Oasis_DEPRECATED,
     Shell,
     Dodo,
     DodoV2,
     CryptoCom,
     Bancor,
+    CoFiX_DEPRECATED,
     Nerve,
     MakerPsm,
     BalancerV2,