fix rfq/otc encoding logic

contracts/zero-ex/contracts/src/transformers/FillQuoteTransformer.sol

@@ -31,6 +31,7 @@ import "../features/libs/LibNativeOrder.sol";
 import "./bridges/IBridgeAdapter.sol";
 import "./Transformer.sol";
 import "./LibERC20Transformer.sol";
+import "../IZeroEx.sol";
 
 /// @dev A transformer that fills an ERC20 market sell/buy quote.
 ///      This transformer shortcuts bridge orders and fills them directly
@@ -52,7 +53,8 @@ contract FillQuoteTransformer is
     enum OrderType {
         Bridge,
         Limit,
-        Rfq
+        Rfq,
+        Otc
     }
 
     struct LimitOrderInfo {
@@ -69,6 +71,13 @@ contract FillQuoteTransformer is
         uint256 maxTakerTokenFillAmount;
     }
 
+    struct OtcOrderInfo {
+        LibNativeOrder.OtcOrder order;
+        LibSignature.Signature signature;
+        // Maximum taker token amount of this limit order to fill.
+        uint256 maxTakerTokenFillAmount;
+    }
+
     /// @dev Transform data to ABI-encode and pass into `transform()`.
     struct TransformData {
         // Whether we are performing a market sell or buy.
@@ -86,6 +95,8 @@ contract FillQuoteTransformer is
         LimitOrderInfo[] limitOrders;
         // Native RFQ orders. Sorted by fill sequence.
         RfqOrderInfo[] rfqOrders;
+        // Otc orders. Sorted by fill sequence.
+        OtcOrderInfo[] otcOrders;
 
         // The sequence to fill the orders in. Each item will fill the next
         // order of that type in either `bridgeOrders`, `limitOrders`,
@@ -123,7 +134,7 @@ contract FillQuoteTransformer is
         uint256 soldAmount;
         uint256 protocolFee;
         uint256 takerTokenBalanceRemaining;
-        uint256[3] currentIndices;
+        uint256[4] currentIndices;
         OrderType currentOrderType;
     }
 
@@ -147,12 +158,12 @@ contract FillQuoteTransformer is
     IBridgeAdapter public immutable bridgeAdapter;
 
     /// @dev The exchange proxy contract.
-    INativeOrdersFeature public immutable zeroEx;
+    IZeroEx public immutable zeroEx;
 
     /// @dev Create this contract.
     /// @param bridgeAdapter_ The bridge adapter contract.
     /// @param zeroEx_ The Exchange Proxy contract.
-    constructor(IBridgeAdapter bridgeAdapter_, INativeOrdersFeature zeroEx_)
+    constructor(IBridgeAdapter bridgeAdapter_, IZeroEx zeroEx_)
         public
         Transformer()
     {
@@ -183,7 +194,8 @@ contract FillQuoteTransformer is
 
         if (data.bridgeOrders.length
                 + data.limitOrders.length
-                + data.rfqOrders.length != data.fillSequence.length
+                + data.rfqOrders.length
+                + data.otcOrders.length != data.fillSequence.length
         ) {
             LibTransformERC20RichErrors.InvalidTransformDataError(
                 LibTransformERC20RichErrors.InvalidTransformDataErrorCode.INVALID_ARRAY_LENGTH,
@@ -198,15 +210,16 @@ contract FillQuoteTransformer is
 
         // Approve the exchange proxy to spend our sell tokens if native orders
         // are present.
-        if (data.limitOrders.length + data.rfqOrders.length != 0) {
+        if (data.limitOrders.length + data.rfqOrders.length + data.otcOrders.length != 0) {
             data.sellToken.approveIfBelow(address(zeroEx), data.fillAmount);
             // Compute the protocol fee if a limit order is present.
+            
             if (data.limitOrders.length != 0) {
                 state.protocolFee = uint256(zeroEx.getProtocolFeeMultiplier())
                     .safeMul(tx.gasprice);
             }
         }
-
+        
         state.ethRemaining = address(this).balance;
 
         // Fill the orders.
@@ -222,6 +235,7 @@ contract FillQuoteTransformer is
 
             state.currentOrderType = OrderType(data.fillSequence[i]);
             uint256 orderIndex = state.currentIndices[uint256(state.currentOrderType)];
+
             // Fill the order.
             FillOrderResults memory results;
             if (state.currentOrderType == OrderType.Bridge) {
@@ -230,6 +244,8 @@ contract FillQuoteTransformer is
                 results = _fillLimitOrder(data.limitOrders[orderIndex], data, state);
             } else if (state.currentOrderType == OrderType.Rfq) {
                 results = _fillRfqOrder(data.rfqOrders[orderIndex], data, state);
+            } else if (state.currentOrderType == OrderType.Otc) {
+                results = _fillOtcOrder(data.otcOrders[orderIndex], data, state);
             } else {
                 revert("INVALID_ORDER_TYPE");
             }
@@ -402,6 +418,41 @@ contract FillQuoteTransformer is
         } catch {}
     }
 
+    // Fill a single RFQ order.
+    function _fillOtcOrder(
+        OtcOrderInfo memory orderInfo,
+        TransformData memory data,
+        FillState memory state
+    )
+        private
+        returns (FillOrderResults memory results)
+    {
+        uint256 takerTokenFillAmount = LibSafeMathV06.min256(
+            _computeTakerTokenFillAmount(
+                data,
+                state,
+                orderInfo.order.takerAmount,
+                orderInfo.order.makerAmount,
+                0
+            ),
+            orderInfo.maxTakerTokenFillAmount
+        );
+        try
+            zeroEx.fillOtcOrder
+                (
+                    orderInfo.order,
+                    orderInfo.signature,
+                    takerTokenFillAmount.safeDowncastToUint128()
+                )
+            returns (uint128 takerTokenFilledAmount, uint128 makerTokenFilledAmount)
+        {
+            results.takerTokenSoldAmount = takerTokenFilledAmount;
+            results.makerTokenBoughtAmount = makerTokenFilledAmount;
+        } catch {
+            revert("FillQuoteTransformer/OTC_ORDER_FILL_FAILED");
+        }
+    }
+
     // Compute the next taker token fill amount of a generic order.
     function _computeTakerTokenFillAmount(
         TransformData memory data,

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

@@ -12,10 +12,13 @@ import {
     FillQuoteTransformerData,
     FillQuoteTransformerLimitOrderInfo,
     FillQuoteTransformerOrderType as OrderType,
+    FillQuoteTransformerOtcOrderInfo,
     FillQuoteTransformerRfqOrderInfo,
     FillQuoteTransformerSide as Side,
     LimitOrder,
     LimitOrderFields,
+    OtcOrder,
+    OtcOrderFields,
     RfqOrder,
     RfqOrderFields,
     Signature,
@@ -26,7 +29,7 @@ import * as _ from 'lodash';
 
 import { artifacts } from '../artifacts';
 import { TestFillQuoteTransformerBridgeContract } from '../generated-wrappers/test_fill_quote_transformer_bridge';
-import { getRandomLimitOrder, getRandomRfqOrder } from '../utils/orders';
+import { getRandomLimitOrder, getRandomOtcOrder, getRandomRfqOrder } from '../utils/orders';
 import {
     EthereumBridgeAdapterContract,
     FillQuoteTransformerContract,
@@ -142,6 +145,18 @@ blockchainTests.resets('FillQuoteTransformer', env => {
         };
     }
 
+    function createOtcOrder(fields: Partial<OtcOrderFields> = {}): OtcOrder {
+        return getRandomOtcOrder({
+            makerToken: makerToken.address,
+            takerToken: takerToken.address,
+            makerAmount: getRandomInteger('0.1e18', '1e18'),
+            takerAmount: getRandomInteger('0.1e18', '1e18'),
+            maker,
+            taker,
+            ...fields,
+        });
+    }
+
     function createOrderSignature(preFilledTakerAmount: Numberish = 0): Signature {
         return {
             // The r field of the signature is the pre-filled amount.
@@ -254,6 +269,24 @@ blockchainTests.resets('FillQuoteTransformer', env => {
             };
         }
 
+        function fillOtcOrder(oi: FillQuoteTransformerOtcOrderInfo): FillOrderResults {
+            const preFilledTakerAmount = orderSignatureToPreFilledTakerAmount(oi.signature);
+            if (preFilledTakerAmount.gte(oi.order.takerAmount) || preFilledTakerAmount.eq(REVERT_AMOUNT)) {
+                return EMPTY_FILL_ORDER_RESULTS;
+            }
+            const takerTokenFillAmount = BigNumber.min(
+                computeTakerTokenFillAmount(oi.order.takerAmount, oi.order.makerAmount),
+                oi.order.takerAmount.minus(preFilledTakerAmount),
+                oi.maxTakerTokenFillAmount,
+            );
+            const fillRatio = takerTokenFillAmount.div(oi.order.takerAmount);
+            return {
+                ...EMPTY_FILL_ORDER_RESULTS,
+                takerTokenSoldAmount: takerTokenFillAmount,
+                makerTokenBoughtAmount: fillRatio.times(oi.order.makerAmount).integerValue(BigNumber.ROUND_DOWN),
+            };
+        }
+
         function fillRfqOrder(oi: FillQuoteTransformerRfqOrderInfo): FillOrderResults {
             const preFilledTakerAmount = orderSignatureToPreFilledTakerAmount(oi.signature);
             if (preFilledTakerAmount.gte(oi.order.takerAmount) || preFilledTakerAmount.eq(REVERT_AMOUNT)) {
@@ -296,6 +329,11 @@ blockchainTests.resets('FillQuoteTransformer', env => {
                         results = fillLimitOrder(data.limitOrders[orderIndices[orderType]]);
                     }
                     break;
+                case OrderType.Otc:
+                    {
+                        results = fillOtcOrder(data.otcOrders[orderIndices[orderType]]);
+                    }
+                    break;
                 case OrderType.Rfq:
                     {
                         results = fillRfqOrder(data.rfqOrders[orderIndices[orderType]]);
@@ -393,6 +431,7 @@ blockchainTests.resets('FillQuoteTransformer', env => {
             buyToken: makerToken.address,
             bridgeOrders: [],
             limitOrders: [],
+            otcOrders: [],
             rfqOrders: [],
             fillSequence: [],
             fillAmount: MAX_UINT256,
@@ -447,7 +486,7 @@ blockchainTests.resets('FillQuoteTransformer', env => {
     }
 
     describe('sell quotes', () => {
-        it('can fully sell to a single bridge order with -1 fillAmount', async () => {
+        it.only('can fully sell to a single bridge order with -1 fillAmount', async () => {
             const bridgeOrders = [createBridgeOrder()];
             const data = createTransformData({
                 bridgeOrders,
@@ -624,6 +663,24 @@ blockchainTests.resets('FillQuoteTransformer', env => {
             return assertFinalBalancesAsync(qfr);
         });
 
+        it('can fully sell to a single OTC order', async () => {
+            const otcOrders = [createOtcOrder()];
+            const data = createTransformData({
+                otcOrders: otcOrders.map(o => ({
+                    order: o,
+                    maxTakerTokenFillAmount: MAX_UINT256,
+                    signature: createOrderSignature(),
+                })),
+                fillAmount: BigNumber.sum(...otcOrders.map(o => o.takerAmount)),
+                fillSequence: otcOrders.map(() => OrderType.Rfq),
+            });
+            const qfr = getExpectedQuoteFillResults(data, createSimulationState());
+            await executeTransformAsync({
+                data,
+                takerTokenBalance: qfr.takerTokensSpent,
+            });
+            return assertFinalBalancesAsync(qfr);
+        });
         it('can fully sell to a single RFQ order', async () => {
             const rfqOrders = [createRfqOrder()];
             const data = createTransformData({
@@ -1117,6 +1174,30 @@ blockchainTests.resets('FillQuoteTransformer', env => {
             return assertFinalBalancesAsync(qfr);
         });
 
+        it('can fully buy to a single OTC order', async () => {
+            const otcOrders = [createOtcOrder()];
+            const totalTakerTokens = BigNumber.sum(...otcOrders.map(o => o.takerAmount));
+            const data = createTransformData({
+                side: Side.Buy,
+                otcOrders: otcOrders.map(o => ({
+                    order: o,
+                    maxTakerTokenFillAmount: MAX_UINT256,
+                    signature: createOrderSignature(),
+                })),
+                fillAmount: BigNumber.sum(...otcOrders.map(o => o.makerAmount)),
+                fillSequence: otcOrders.map(() => OrderType.Rfq),
+            });
+            const qfr = getExpectedQuoteFillResults(
+                data,
+                createSimulationState({ takerTokenBalance: totalTakerTokens }),
+            );
+            await executeTransformAsync({
+                data,
+                takerTokenBalance: qfr.takerTokensSpent,
+            });
+            return assertFinalBalancesAsync(qfr);
+        });
+
         it('can fully buy to a single RFQ order', async () => {
             const rfqOrders = [createRfqOrder()];
             const totalTakerTokens = BigNumber.sum(...rfqOrders.map(o => o.takerAmount));

packages/asset-swapper/CHANGELOG.json

@@ -1,4 +1,13 @@
 [
+    {
+        "version": "16.64.0",
+        "changes": [
+            {
+                "note": "Add support for OTC orders in the fillQuoteTransformer",
+                "pr": 516
+            }
+        ]
+    },
     {
         "version": "16.63.1",
         "changes": [

packages/asset-swapper/src/quote_consumers/exchange_proxy_swap_quote_consumer.ts

@@ -42,6 +42,7 @@ import {
     FinalUniswapV3FillData,
     LiquidityProviderFillData,
     MooniswapFillData,
+    NativeOtcOrderFillData,
     NativeRfqOrderFillData,
     OptimizedMarketBridgeOrder,
     OptimizedMarketOrder,
@@ -49,6 +50,7 @@ import {
 } from '../utils/market_operation_utils/types';
 
 import {
+    multiplexOtcOrder,
     multiplexPlpEncoder,
     multiplexRfqEncoder,
     MultiplexSubcall,
@@ -340,18 +342,7 @@ export class ExchangeProxySwapQuoteConsumer implements SwapQuoteConsumerBase {
             !requiresTransformERC20(optsWithDefaults)
         ) {
             const rfqOrdersData = quote.orders.map(o => o.fillData as NativeRfqOrderFillData);
-            const fillAmountPerOrder = (() => {
-                // Don't think order taker amounts are clipped to actual sell amount
-                // (the last one might be too large) so figure them out manually.
-                let remaining = sellAmount;
-                const fillAmounts = [];
-                for (const o of quote.orders) {
-                    const fillAmount = BigNumber.min(o.takerAmount, remaining);
-                    fillAmounts.push(fillAmount);
-                    remaining = remaining.minus(fillAmount);
-                }
-                return fillAmounts;
-            })();
+            const fillAmountPerOrder = generateFillAmounts(sellAmount, quote);
             const callData =
                 quote.orders.length === 1
                     ? this._exchangeProxy
@@ -374,6 +365,46 @@ export class ExchangeProxySwapQuoteConsumer implements SwapQuoteConsumerBase {
             };
         }
 
+        // OTC orders
+        if (
+            [ChainId.Mainnet, ChainId.Ropsten].includes(this.chainId) && // @todo goerli and polygon?
+            quote.orders.every(o => o.type === FillQuoteTransformerOrderType.Otc) &&
+            !requiresTransformERC20(optsWithDefaults)
+        ) {
+            const otcOrdersData = quote.orders.map(o => o.fillData as NativeOtcOrderFillData);
+            const fillAmountPerOrder = generateFillAmounts(sellAmount, quote);
+            // grab the amount to fill on each OtcOrder (if more than 1, fallback to multiplexBatchFill)
+
+            let callData;
+            // if we have more than one otc order we want to batch fill them,
+            if (quote.orders.length === 1) {
+                // if the otc orders takerToken is the native asset
+                if (isFromETH) {
+                    callData = this._exchangeProxy
+                        .fillOtcOrderWithEth(otcOrdersData[0].order, otcOrdersData[0].signature)
+                        .getABIEncodedTransactionData();
+                }
+                // if the otc orders makerToken is the native asset
+                if (isToETH) {
+                    callData = this._exchangeProxy
+                        .fillOtcOrderForEth(otcOrdersData[0].order, otcOrdersData[0].signature, fillAmountPerOrder[0])
+                        .getABIEncodedTransactionData();
+                } else {
+                    // if the otc order contains 2 erc20 tokens
+                    callData = this._exchangeProxy
+                        .fillOtcOrder(otcOrdersData[0].order, otcOrdersData[0].signature, fillAmountPerOrder[0])
+                        .getABIEncodedTransactionData();
+                }
+                return {
+                    calldataHexString: callData,
+                    ethAmount: isFromETH ? sellAmount : ZERO_AMOUNT,
+                    toAddress: this._exchangeProxy.address,
+                    allowanceTarget: this._exchangeProxy.address,
+                    gasOverhead: ZERO_AMOUNT,
+                };
+            }
+        }
+
         if (this.chainId === ChainId.Mainnet && isMultiplexBatchFillCompatible(quote, optsWithDefaults)) {
             return {
                 calldataHexString: this._encodeMultiplexBatchFillCalldata(
@@ -567,19 +598,30 @@ export class ExchangeProxySwapQuoteConsumer implements SwapQuoteConsumerBase {
         for_loop: for (const [i, order] of quote.orders.entries()) {
             switch_statement: switch (order.source) {
                 case ERC20BridgeSource.Native:
-                    if (order.type !== FillQuoteTransformerOrderType.Rfq) {
+                    if (order.type !== FillQuoteTransformerOrderType.Rfq && order.type !== FillQuoteTransformerOrderType.Otc) {
                         // Should never happen because we check `isMultiplexBatchFillCompatible`
                         // before calling this function.
-                        throw new Error('Multiplex batch fill only supported for RFQ native orders');
+                        throw new Error('Multiplex batch fill only supported for RFQ native orders and OTC Orders');
+                    }
+                    if (order.type !== FillQuoteTransformerOrderType.Otc) {
+                        subcalls.push({
+                            id: MultiplexSubcall.Rfq,
+                            sellAmount: order.takerAmount,
+                            data: multiplexRfqEncoder.encode({
+                                order: order.fillData.order,
+                                signature: order.fillData.signature,
+                            }),
+                        });
+                    } else {
+                        subcalls.push({
+                            id: MultiplexSubcall.Otc,
+                            sellAmount: order.takerAmount,
+                            data: multiplexOtcOrder.encode({
+                                order: order.fillData.order,
+                                signature: order.fillData.signature,
+                            }),
+                        });
                     }
-                    subcalls.push({
-                        id: MultiplexSubcall.Rfq,
-                        sellAmount: order.takerAmount,
-                        data: multiplexRfqEncoder.encode({
-                            order: order.fillData.order,
-                            signature: order.fillData.signature,
-                        }),
-                    });
                     break switch_statement;
                 case ERC20BridgeSource.UniswapV2:
                 case ERC20BridgeSource.SushiSwap:
@@ -730,6 +772,17 @@ export class ExchangeProxySwapQuoteConsumer implements SwapQuoteConsumerBase {
     }
 }
 
+function generateFillAmounts(sellAmount: BigNumber, quote: MarketBuySwapQuote | MarketSellSwapQuote): BigNumber[] {
+    let remaining = sellAmount;
+    const fillAmounts = [];
+    for (const o of quote.orders) {
+        const fillAmount = BigNumber.min(o.takerAmount, remaining);
+        fillAmounts.push(fillAmount);
+        remaining = remaining.minus(fillAmount);
+    }
+    return fillAmounts;
+}
+
 function slipNonNativeOrders(quote: MarketSellSwapQuote | MarketBuySwapQuote): OptimizedMarketOrder[] {
     const slippage = getMaxQuoteSlippageRate(quote);
     if (slippage === 0) {

packages/asset-swapper/src/quote_consumers/multiplex_encoders.ts

@@ -1,4 +1,4 @@
-import { RfqOrder, SIGNATURE_ABI } from '@0x/protocol-utils';
+import { OtcOrder, RfqOrder, SIGNATURE_ABI } from '@0x/protocol-utils';
 import { AbiEncoder } from '@0x/utils';
 
 export enum MultiplexSubcall {
@@ -26,6 +26,10 @@ export const multiplexRfqEncoder = AbiEncoder.create([
     { name: 'order', type: 'tuple', components: RfqOrder.STRUCT_ABI },
     { name: 'signature', type: 'tuple', components: SIGNATURE_ABI },
 ]);
+export const multiplexOtcOrder = AbiEncoder.create([
+    { name: 'order', type: 'tuple', components: OtcOrder.STRUCT_ABI },
+    { name: 'signature', type: 'tuple', components: SIGNATURE_ABI },
+]);
 export const multiplexUniswapEncoder = AbiEncoder.create([
     { name: 'tokens', type: 'address[]' },
     { name: 'isSushi', type: 'bool' },

packages/asset-swapper/src/quote_consumers/quote_consumer_utils.ts

@@ -113,11 +113,15 @@ function isOptimizedRfqOrder(x: OptimizedMarketOrder): x is OptimizedMarketOrder
  */
 export function getFQTTransformerDataFromOptimizedOrders(
     orders: OptimizedMarketOrder[],
-): Pick<FillQuoteTransformerData, 'bridgeOrders' | 'limitOrders' | 'rfqOrders' | 'fillSequence'> {
-    const fqtData: Pick<FillQuoteTransformerData, 'bridgeOrders' | 'limitOrders' | 'rfqOrders' | 'fillSequence'> = {
+): Pick<FillQuoteTransformerData, 'bridgeOrders' | 'limitOrders' | 'rfqOrders' | 'otcOrders' | 'fillSequence'> {
+    const fqtData: Pick<
+        FillQuoteTransformerData,
+        'bridgeOrders' | 'limitOrders' | 'rfqOrders' | 'otcOrders' | 'fillSequence'
+    > = {
         bridgeOrders: [],
         limitOrders: [],
         rfqOrders: [],
+        otcOrders: [],
         fillSequence: [],
     };
 

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

@@ -1,6 +1,7 @@
 import {
     FillQuoteTransformerLimitOrderInfo,
     FillQuoteTransformerOrderType,
+    FillQuoteTransformerOtcOrderInfo,
     FillQuoteTransformerRfqOrderInfo,
 } from '@0x/protocol-utils';
 import { MarketOperation } from '@0x/types';
@@ -196,7 +197,8 @@ export interface FillData {}
 // `FillData` for native fills. Represents a single native order
 export type NativeRfqOrderFillData = FillQuoteTransformerRfqOrderInfo;
 export type NativeLimitOrderFillData = FillQuoteTransformerLimitOrderInfo;
-export type NativeFillData = NativeRfqOrderFillData | NativeLimitOrderFillData;
+export type NativeOtcOrderFillData = FillQuoteTransformerOtcOrderInfo;
+export type NativeFillData = NativeRfqOrderFillData | NativeLimitOrderFillData | NativeOtcOrderFillData;
 
 // Represents an individual DEX sample from the sampler contract
 export interface DexSample<TFillData extends FillData = FillData> {
@@ -436,7 +438,8 @@ export interface OptimizedRfqOrder extends OptimizedMarketOrderBase<NativeRfqOrd
 export type OptimizedMarketOrder =
     | OptimizedMarketBridgeOrder<FillData>
     | OptimizedMarketOrderBase<NativeLimitOrderFillData>
-    | OptimizedMarketOrderBase<NativeRfqOrderFillData>;
+    | OptimizedMarketOrderBase<NativeRfqOrderFillData>
+    | OptimizedMarketOrderBase<NativeOtcOrderFillData>;
 
 export interface GetMarketOrdersRfqOpts extends RfqRequestOpts {
     rfqClient?: IRfqClient;

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

@@ -11,8 +11,6 @@ import {
     FillData,
     MultiHopFillData,
     NativeFillData,
-    NativeLimitOrderFillData,
-    NativeRfqOrderFillData,
     RawQuotes,
 } from './market_operation_utils/types';
 import { QuoteRequestor, V4RFQIndicativeQuoteMM } from './quote_requestor';
@@ -353,7 +351,7 @@ function _isNativeOrderFromCollapsedFill(cf: Fill): cf is Fill<NativeFillData> {
  */
 export function nativeOrderToReportEntry(
     type: FillQuoteTransformerOrderType,
-    fillData: NativeLimitOrderFillData | NativeRfqOrderFillData,
+    fillData: NativeFillData,
     fillableAmount: BigNumber,
     comparisonPrice?: BigNumber | undefined,
     quoteRequestor?: QuoteRequestor,

packages/protocol-utils/CHANGELOG.json

@@ -1,4 +1,13 @@
 [
+    {
+        "version": "11.16.0",
+        "changes": [
+            {
+                "note": "Add Otc order support to the fillQuoteTransformer",
+                "pr": 516
+            }
+        ]
+    },
     {
         "version": "11.15.0",
         "changes": [

packages/protocol-utils/src/transformer_utils.ts

@@ -1,7 +1,7 @@
 import { AbiEncoder, BigNumber, hexUtils, NULL_ADDRESS } from '@0x/utils';
 import * as ethjs from 'ethereumjs-util';
 
-import { LimitOrder, LimitOrderFields, RfqOrder, RfqOrderFields } from './orders';
+import { LimitOrder, LimitOrderFields, OtcOrder, OtcOrderFields, RfqOrder, RfqOrderFields } from './orders';
 import { Signature, SIGNATURE_ABI } from './signature_utils';
 
 const BRIDGE_ORDER_ABI_COMPONENTS = [
@@ -39,6 +39,20 @@ const RFQ_ORDER_INFO_ABI_COMPONENTS = [
     { name: 'maxTakerTokenFillAmount', type: 'uint256' },
 ];
 
+const OTC_ORDER_INFO_ABI_COMPONENTS = [
+    {
+        name: 'order',
+        type: 'tuple',
+        components: OtcOrder.STRUCT_ABI,
+    },
+    {
+        name: 'signature',
+        type: 'tuple',
+        components: SIGNATURE_ABI,
+    },
+    { name: 'maxTakerTokenFillAmount', type: 'uint256' },
+];
+
 /**
  * ABI encoder for `FillQuoteTransformer.TransformData`
  */
@@ -60,6 +74,11 @@ export const fillQuoteTransformerDataEncoder = AbiEncoder.create([
                 type: 'tuple[]',
                 components: LIMIT_ORDER_INFO_ABI_COMPONENTS,
             },
+            {
+                name: 'otcOrders',
+                type: 'tuple[]',
+                components: OTC_ORDER_INFO_ABI_COMPONENTS,
+            },
             {
                 name: 'rfqOrders',
                 type: 'tuple[]',
@@ -87,6 +106,7 @@ export enum FillQuoteTransformerOrderType {
     Bridge,
     Limit,
     Rfq,
+    Otc,
 }
 
 /**
@@ -99,6 +119,7 @@ export interface FillQuoteTransformerData {
     bridgeOrders: FillQuoteTransformerBridgeOrder[];
     limitOrders: FillQuoteTransformerLimitOrderInfo[];
     rfqOrders: FillQuoteTransformerRfqOrderInfo[];
+    otcOrders: FillQuoteTransformerOtcOrderInfo[];
     fillSequence: FillQuoteTransformerOrderType[];
     fillAmount: BigNumber;
     refundReceiver: string;
@@ -176,6 +197,11 @@ export type FillQuoteTransformerLimitOrderInfo = FillQuoteTransformerNativeOrder
  */
 export type FillQuoteTransformerRfqOrderInfo = FillQuoteTransformerNativeOrderInfo<RfqOrderFields>;
 
+/**
+ * `FillQuoteTransformer.OtcOrderInfo`
+ */
+export type FillQuoteTransformerOtcOrderInfo = FillQuoteTransformerNativeOrderInfo<OtcOrderFields>;
+
 /**
  * ABI-encode a `FillQuoteTransformer.TransformData` type.
  */