aboutsummaryrefslogtreecommitdiffstats
path: root/packages/asset-buyer/src
diff options
context:
space:
mode:
Diffstat (limited to 'packages/asset-buyer/src')
-rw-r--r--packages/asset-buyer/src/asset_buyers/asset_buyer.ts129
-rw-r--r--packages/asset-buyer/src/constants.ts1
-rw-r--r--packages/asset-buyer/src/forwarder_helper_factory.ts510
-rw-r--r--packages/asset-buyer/src/forwarder_helper_impl.ts64
-rw-r--r--packages/asset-buyer/src/index.ts4
-rw-r--r--packages/asset-buyer/src/types.ts63
-rw-r--r--packages/asset-buyer/src/utils/forwarder_helper_impl_config_utils.ts170
7 files changed, 500 insertions, 441 deletions
diff --git a/packages/asset-buyer/src/asset_buyers/asset_buyer.ts b/packages/asset-buyer/src/asset_buyers/asset_buyer.ts
new file mode 100644
index 000000000..eb7f85e2b
--- /dev/null
+++ b/packages/asset-buyer/src/asset_buyers/asset_buyer.ts
@@ -0,0 +1,129 @@
+import { ContractWrappers } from '@0xproject/contract-wrappers';
+import { marketUtils } from '@0xproject/order-utils';
+import { SignedOrder } from '@0xproject/types';
+import { BigNumber } from '@0xproject/utils';
+import { Web3Wrapper } from '@0xproject/web3-wrapper';
+import * as _ from 'lodash';
+import { Provider } from 'ethereum-types';
+
+import { constants } from '../constants';
+import { AssetBuyerError, BuyQuote, BuyQuoteRequest } from '../types';
+
+const SLIPPAGE_PERCENTAGE = new BigNumber(0.2); // 20% slippage protection, possibly move this into request interface
+
+export interface AssetBuyerConfig {
+ orders: SignedOrder[];
+ feeOrders: SignedOrder[];
+ remainingFillableMakerAssetAmounts?: BigNumber[];
+ remainingFillableFeeAmounts?: BigNumber[];
+ networkId?: number;
+}
+
+export class AssetBuyer {
+ public readonly provider: Provider;
+ public readonly config: AssetBuyerConfig;
+ private _contractWrappers: ContractWrappers;
+ constructor(provider: Provider, config: AssetBuyerConfig) {
+ this.provider = provider;
+ this.config = config;
+ const networkId = this.config.networkId || constants.MAINNET_NETWORK_ID;
+ this._contractWrappers = new ContractWrappers(this.provider, {
+ networkId,
+ });
+ }
+ /**
+ * Given a BuyQuoteRequest, returns a BuyQuote containing all information relevant to fulfilling the buy. Pass the BuyQuote
+ * to executeBuyQuoteAsync to execute the buy.
+ * @param buyQuoteRequest An object that conforms to BuyQuoteRequest. See type definition for more information.
+ * @return An object that conforms to BuyQuote that satisfies the request. See type definition for more information.
+ */
+ public getBuyQuote(buyQuoteRequest: BuyQuoteRequest): BuyQuote {
+ const { assetBuyAmount, feePercentage } = buyQuoteRequest;
+ const { orders, feeOrders, remainingFillableMakerAssetAmounts, remainingFillableFeeAmounts } = this.config;
+ // TODO: optimization
+ // make the slippage percentage customizable
+ const slippageBufferAmount = assetBuyAmount.mul(SLIPPAGE_PERCENTAGE).round();
+ const { resultOrders, remainingFillAmount } = marketUtils.findOrdersThatCoverMakerAssetFillAmount(
+ orders,
+ assetBuyAmount,
+ {
+ remainingFillableMakerAssetAmounts,
+ slippageBufferAmount,
+ },
+ );
+ if (remainingFillAmount.gt(constants.ZERO_AMOUNT)) {
+ throw new Error(AssetBuyerError.InsufficientAssetLiquidity);
+ }
+ // TODO: optimization
+ // update this logic to find the minimum amount of feeOrders to cover the worst case as opposed to
+ // finding order that cover all fees, this will help with estimating ETH and minimizing gas usage
+ const { resultFeeOrders, remainingFeeAmount } = marketUtils.findFeeOrdersThatCoverFeesForTargetOrders(
+ resultOrders,
+ feeOrders,
+ {
+ remainingFillableMakerAssetAmounts,
+ remainingFillableFeeAmounts,
+ },
+ );
+ if (remainingFeeAmount.gt(constants.ZERO_AMOUNT)) {
+ throw new Error(AssetBuyerError.InsufficientZrxLiquidity);
+ }
+ const assetData = orders[0].makerAssetData;
+ // TODO: critical
+ // calculate minRate and maxRate by calculating min and max eth usage and then dividing into
+ // assetBuyAmount to get assetData / WETH
+ return {
+ assetData,
+ orders: resultOrders,
+ feeOrders: resultFeeOrders,
+ minRate: constants.ZERO_AMOUNT,
+ maxRate: constants.ZERO_AMOUNT,
+ assetBuyAmount,
+ feePercentage,
+ };
+ }
+ /**
+ * Given a BuyQuote and desired rate, attempt to execute the buy.
+ * @param buyQuote An object that conforms to BuyQuote. See type definition for more information.
+ * @param rate The desired rate to execute the buy at. Affects the amount of ETH sent with the transaction, defaults to buyQuote.maxRate.
+ * @param takerAddress The address to perform the buy. Defaults to the first available address from the provider.
+ * @param feeRecipient The address where affiliate fees are sent. Defaults to null address (0x000...000).
+ * @return A promise of the txHash.
+ */
+ public async executeBuyQuoteAsync(
+ buyQuote: BuyQuote,
+ rate?: BigNumber,
+ takerAddress?: string,
+ feeRecipient: string = constants.NULL_ADDRESS,
+ ): Promise<string> {
+ const { orders, feeOrders, feePercentage, assetBuyAmount, maxRate } = buyQuote;
+ // if no takerAddress is provided, try to get one from the provider
+ let finalTakerAddress;
+ if (!_.isUndefined(takerAddress)) {
+ finalTakerAddress = takerAddress;
+ } else {
+ const web3Wrapper = new Web3Wrapper(this.provider);
+ const availableAddresses = await web3Wrapper.getAvailableAddressesAsync();
+ const firstAvailableAddress = _.head(availableAddresses);
+ if (!_.isUndefined(firstAvailableAddress)) {
+ finalTakerAddress = firstAvailableAddress;
+ } else {
+ throw new Error(AssetBuyerError.NoAddressAvailable);
+ }
+ }
+ // if no rate is provided, default to the maxRate from buyQuote
+ const desiredRate = rate || maxRate;
+ // calculate how much eth is required to buy assetBuyAmount at the desired rate
+ const ethAmount = assetBuyAmount.dividedToIntegerBy(desiredRate);
+ const txHash = await this._contractWrappers.forwarder.marketBuyOrdersWithEthAsync(
+ orders,
+ assetBuyAmount,
+ finalTakerAddress,
+ ethAmount,
+ feeOrders,
+ feePercentage,
+ feeRecipient,
+ );
+ return txHash;
+ }
+}
diff --git a/packages/asset-buyer/src/constants.ts b/packages/asset-buyer/src/constants.ts
index c0a1b090e..5785e705b 100644
--- a/packages/asset-buyer/src/constants.ts
+++ b/packages/asset-buyer/src/constants.ts
@@ -3,4 +3,5 @@ import { BigNumber } from '@0xproject/utils';
export const constants = {
ZERO_AMOUNT: new BigNumber(0),
NULL_ADDRESS: '0x0000000000000000000000000000000000000000',
+ MAINNET_NETWORK_ID: 1,
};
diff --git a/packages/asset-buyer/src/forwarder_helper_factory.ts b/packages/asset-buyer/src/forwarder_helper_factory.ts
index 2b37ac98f..9a3832e81 100644
--- a/packages/asset-buyer/src/forwarder_helper_factory.ts
+++ b/packages/asset-buyer/src/forwarder_helper_factory.ts
@@ -1,261 +1,261 @@
-import { assert } from '@0xproject/assert';
-import { APIOrder, HttpClient, OrderbookResponse } from '@0xproject/connect';
-import { ContractWrappers, OrderAndTraderInfo, OrderStatus } from '@0xproject/contract-wrappers';
-import { schemas } from '@0xproject/json-schemas';
-import { assetDataUtils } from '@0xproject/order-utils';
-import { RemainingFillableCalculator } from '@0xproject/order-utils/lib/src/remaining_fillable_calculator';
-import { RPCSubprovider, Web3ProviderEngine } from '@0xproject/subproviders';
-import { SignedOrder } from '@0xproject/types';
-import { BigNumber } from '@0xproject/utils';
-import * as _ from 'lodash';
+// import { assert } from '@0xproject/assert';
+// import { APIOrder, HttpClient, OrderbookResponse } from '@0xproject/connect';
+// import { ContractWrappers, OrderAndTraderInfo, OrderStatus } from '@0xproject/contract-wrappers';
+// import { schemas } from '@0xproject/json-schemas';
+// import { assetDataUtils } from '@0xproject/order-utils';
+// import { RemainingFillableCalculator } from '@0xproject/order-utils/lib/src/remaining_fillable_calculator';
+// import { RPCSubprovider, Web3ProviderEngine } from '@0xproject/subproviders';
+// import { SignedOrder } from '@0xproject/types';
+// import { BigNumber } from '@0xproject/utils';
+// import * as _ from 'lodash';
-import { constants } from './constants';
-import { ForwarderHelperImpl, ForwarderHelperImplConfig } from './forwarder_helper_impl';
-import { ForwarderHelper, ForwarderHelperFactoryError } from './types';
-import { orderUtils } from './utils/order_utils';
+// import { constants } from './constants';
+// import { ForwarderHelperImpl, ForwarderHelperImplConfig } from '@0xproject/asset-buyer/src/asset_buyer';
+// import { ForwarderHelper, ForwarderHelperFactoryError } from './types';
+// import { orderUtils } from './utils/order_utils';
-export const forwarderHelperFactory = {
- /**
- * Given an array of orders and an array of feeOrders, get a ForwarderHelper
- * @param orders An array of objects conforming to SignedOrder. Each order should specify the same makerAssetData and takerAssetData
- * @param feeOrders An array of objects conforming to SignedOrder. Each order should specify ZRX as makerAssetData WETH as takerAssetData
- * @return A ForwarderHelper, see type for definition
- */
- getForwarderHelperForOrders(orders: SignedOrder[], feeOrders: SignedOrder[] = []): ForwarderHelper {
- assert.doesConformToSchema('orders', orders, schemas.signedOrdersSchema);
- assert.doesConformToSchema('feeOrders', orders, schemas.signedOrdersSchema);
- // TODO: Add assertion here for orders all having the same makerAsset and takerAsset
- const config: ForwarderHelperImplConfig = {
- orders,
- feeOrders,
- };
- const helper = new ForwarderHelperImpl(config);
- return helper;
- },
- /**
- * Given a desired makerAsset and SRA url, get a ForwarderHelper
- * @param makerAssetData An array of objects conforming to SignedOrder. Each order should specify the same makerAssetData and takerAssetData
- * @param sraUrl A url pointing to an SRA v2 compliant endpoint.
- * @param rpcUrl A url pointing to an ethereum node.
- * @param networkId The ethereum networkId, defaults to 1 (mainnet).
- * @return A ForwarderHelper, see type for definition
- */
- async getForwarderHelperForMakerAssetDataAsync(
- makerAssetData: string,
- sraUrl: string,
- rpcUrl?: string,
- networkId: number = 1,
- ): Promise<ForwarderHelper> {
- assert.isHexString('makerAssetData', makerAssetData);
- assert.isWebUri('sraUrl', sraUrl);
- if (!_.isUndefined(rpcUrl)) {
- assert.isWebUri('rpcUrl', rpcUrl);
- }
- assert.isNumber('networkId', networkId);
- // create provider
- const providerEngine = new Web3ProviderEngine();
- if (!_.isUndefined(rpcUrl)) {
- providerEngine.addProvider(new RPCSubprovider(rpcUrl));
- }
- providerEngine.start();
- // create contract wrappers given provider and networkId
- const contractWrappers = new ContractWrappers(providerEngine, { networkId });
- // find ether token asset data
- const etherTokenAddressIfExists = contractWrappers.etherToken.getContractAddressIfExists();
- if (_.isUndefined(etherTokenAddressIfExists)) {
- throw new Error(ForwarderHelperFactoryError.NoEtherTokenContractFound);
- }
- const etherTokenAssetData = assetDataUtils.encodeERC20AssetData(etherTokenAddressIfExists);
- // find zrx token asset data
- let zrxTokenAssetData: string;
- try {
- zrxTokenAssetData = contractWrappers.exchange.getZRXAssetData();
- } catch (err) {
- throw new Error(ForwarderHelperFactoryError.NoZrxTokenContractFound);
- }
- // get orderbooks for makerAsset/WETH and ZRX/WETH
- const sraClient = new HttpClient(sraUrl);
- const orderbookRequests = [
- { baseAssetData: makerAssetData, quoteAssetData: etherTokenAssetData },
- { baseAssetData: zrxTokenAssetData, quoteAssetData: etherTokenAssetData },
- ];
- const requestOpts = { networkId };
- let makerAssetOrderbook: OrderbookResponse;
- let zrxOrderbook: OrderbookResponse;
- try {
- [makerAssetOrderbook, zrxOrderbook] = await Promise.all(
- _.map(orderbookRequests, request => sraClient.getOrderbookAsync(request, requestOpts)),
- );
- } catch (err) {
- throw new Error(ForwarderHelperFactoryError.StandardRelayerApiError);
- }
- // validate orders and find remaining fillable from on chain state or sra api
- let ordersAndRemainingFillableMakerAssetAmounts: OrdersAndRemainingFillableMakerAssetAmounts;
- let feeOrdersAndRemainingFillableMakerAssetAmounts: OrdersAndRemainingFillableMakerAssetAmounts;
- if (!_.isUndefined(rpcUrl)) {
- // if we do have an rpc url, get on-chain orders and traders info via the OrderValidatorWrapper
- const ordersFromSra = getOpenAsksFromOrderbook(makerAssetOrderbook);
- const feeOrdersFromSra = getOpenAsksFromOrderbook(zrxOrderbook);
- // TODO: try catch these requests and throw a more domain specific error
- // TODO: optimization, reduce this to once RPC call buy combining orders into one array and then splitting up the response
- const [makerAssetOrdersAndTradersInfo, feeOrdersAndTradersInfo] = await Promise.all(
- _.map([ordersFromSra, feeOrdersFromSra], ordersToBeValidated => {
- const takerAddresses = _.map(ordersToBeValidated, () => constants.NULL_ADDRESS);
- return contractWrappers.orderValidator.getOrdersAndTradersInfoAsync(
- ordersToBeValidated,
- takerAddresses,
- );
- }),
- );
- // take maker asset orders from SRA + on chain information and find the valid orders and remaining fillable maker asset amounts
- ordersAndRemainingFillableMakerAssetAmounts = getValidOrdersAndRemainingFillableMakerAssetAmountsFromOnChain(
- ordersFromSra,
- makerAssetOrdersAndTradersInfo,
- zrxTokenAssetData,
- );
- // take fee orders from SRA + on chain information and find the valid orders and remaining fillable maker asset amounts
- feeOrdersAndRemainingFillableMakerAssetAmounts = getValidOrdersAndRemainingFillableMakerAssetAmountsFromOnChain(
- feeOrdersFromSra,
- feeOrdersAndTradersInfo,
- zrxTokenAssetData,
- );
- } else {
- // if we don't have an rpc url, assume all orders are valid and fallback to optional fill amounts from SRA
- // if fill amounts are not available from the SRA, assume all orders are completely fillable
- const apiOrdersFromSra = makerAssetOrderbook.asks.records;
- const feeApiOrdersFromSra = zrxOrderbook.asks.records;
- // take maker asset orders from SRA and the valid orders and remaining fillable maker asset amounts
- ordersAndRemainingFillableMakerAssetAmounts = getValidOrdersAndRemainingFillableMakerAssetAmountsFromApi(
- apiOrdersFromSra,
- );
- // take fee orders from SRA and find the valid orders and remaining fillable maker asset amounts
- feeOrdersAndRemainingFillableMakerAssetAmounts = getValidOrdersAndRemainingFillableMakerAssetAmountsFromApi(
- feeApiOrdersFromSra,
- );
- }
- // compile final config
- const config: ForwarderHelperImplConfig = {
- orders: ordersAndRemainingFillableMakerAssetAmounts.orders,
- feeOrders: feeOrdersAndRemainingFillableMakerAssetAmounts.orders,
- remainingFillableMakerAssetAmounts:
- ordersAndRemainingFillableMakerAssetAmounts.remainingFillableMakerAssetAmounts,
- remainingFillableFeeAmounts:
- feeOrdersAndRemainingFillableMakerAssetAmounts.remainingFillableMakerAssetAmounts,
- };
- const helper = new ForwarderHelperImpl(config);
- return helper;
- },
-};
+// export const forwarderHelperFactory = {
+// /**
+// * Given an array of orders and an array of feeOrders, get a ForwarderHelper
+// * @param orders An array of objects conforming to SignedOrder. Each order should specify the same makerAssetData and takerAssetData
+// * @param feeOrders An array of objects conforming to SignedOrder. Each order should specify ZRX as makerAssetData WETH as takerAssetData
+// * @return A ForwarderHelper, see type for definition
+// */
+// getForwarderHelperForOrders(orders: SignedOrder[], feeOrders: SignedOrder[] = []): ForwarderHelper {
+// assert.doesConformToSchema('orders', orders, schemas.signedOrdersSchema);
+// assert.doesConformToSchema('feeOrders', orders, schemas.signedOrdersSchema);
+// // TODO: Add assertion here for orders all having the same makerAsset and takerAsset
+// const config: ForwarderHelperImplConfig = {
+// orders,
+// feeOrders,
+// };
+// const helper = new ForwarderHelperImpl(config);
+// return helper;
+// },
+// /**
+// * Given a desired makerAsset and SRA url, get a ForwarderHelper
+// * @param makerAssetData An array of objects conforming to SignedOrder. Each order should specify the same makerAssetData and takerAssetData
+// * @param sraUrl A url pointing to an SRA v2 compliant endpoint.
+// * @param rpcUrl A url pointing to an ethereum node.
+// * @param networkId The ethereum networkId, defaults to 1 (mainnet).
+// * @return A ForwarderHelper, see type for definition
+// */
+// async getForwarderHelperForMakerAssetDataAsync(
+// makerAssetData: string,
+// sraUrl: string,
+// rpcUrl?: string,
+// networkId: number = 1,
+// ): Promise<ForwarderHelper> {
+// assert.isHexString('makerAssetData', makerAssetData);
+// assert.isWebUri('sraUrl', sraUrl);
+// if (!_.isUndefined(rpcUrl)) {
+// assert.isWebUri('rpcUrl', rpcUrl);
+// }
+// assert.isNumber('networkId', networkId);
+// // create provider
+// const providerEngine = new Web3ProviderEngine();
+// if (!_.isUndefined(rpcUrl)) {
+// providerEngine.addProvider(new RPCSubprovider(rpcUrl));
+// }
+// providerEngine.start();
+// // create contract wrappers given provider and networkId
+// const contractWrappers = new ContractWrappers(providerEngine, { networkId });
+// // find ether token asset data
+// const etherTokenAddressIfExists = contractWrappers.etherToken.getContractAddressIfExists();
+// if (_.isUndefined(etherTokenAddressIfExists)) {
+// throw new Error(ForwarderHelperFactoryError.NoEtherTokenContractFound);
+// }
+// const etherTokenAssetData = assetDataUtils.encodeERC20AssetData(etherTokenAddressIfExists);
+// // find zrx token asset data
+// let zrxTokenAssetData: string;
+// try {
+// zrxTokenAssetData = contractWrappers.exchange.getZRXAssetData();
+// } catch (err) {
+// throw new Error(ForwarderHelperFactoryError.NoZrxTokenContractFound);
+// }
+// // get orderbooks for makerAsset/WETH and ZRX/WETH
+// const sraClient = new HttpClient(sraUrl);
+// const orderbookRequests = [
+// { baseAssetData: makerAssetData, quoteAssetData: etherTokenAssetData },
+// { baseAssetData: zrxTokenAssetData, quoteAssetData: etherTokenAssetData },
+// ];
+// const requestOpts = { networkId };
+// let makerAssetOrderbook: OrderbookResponse;
+// let zrxOrderbook: OrderbookResponse;
+// try {
+// [makerAssetOrderbook, zrxOrderbook] = await Promise.all(
+// _.map(orderbookRequests, request => sraClient.getOrderbookAsync(request, requestOpts)),
+// );
+// } catch (err) {
+// throw new Error(ForwarderHelperFactoryError.StandardRelayerApiError);
+// }
+// // validate orders and find remaining fillable from on chain state or sra api
+// let ordersAndRemainingFillableMakerAssetAmounts: OrdersAndRemainingFillableMakerAssetAmounts;
+// let feeOrdersAndRemainingFillableMakerAssetAmounts: OrdersAndRemainingFillableMakerAssetAmounts;
+// if (!_.isUndefined(rpcUrl)) {
+// // if we do have an rpc url, get on-chain orders and traders info via the OrderValidatorWrapper
+// const ordersFromSra = getOpenAsksFromOrderbook(makerAssetOrderbook);
+// const feeOrdersFromSra = getOpenAsksFromOrderbook(zrxOrderbook);
+// // TODO: try catch these requests and throw a more domain specific error
+// // TODO: optimization, reduce this to once RPC call buy combining orders into one array and then splitting up the response
+// const [makerAssetOrdersAndTradersInfo, feeOrdersAndTradersInfo] = await Promise.all(
+// _.map([ordersFromSra, feeOrdersFromSra], ordersToBeValidated => {
+// const takerAddresses = _.map(ordersToBeValidated, () => constants.NULL_ADDRESS);
+// return contractWrappers.orderValidator.getOrdersAndTradersInfoAsync(
+// ordersToBeValidated,
+// takerAddresses,
+// );
+// }),
+// );
+// // take maker asset orders from SRA + on chain information and find the valid orders and remaining fillable maker asset amounts
+// ordersAndRemainingFillableMakerAssetAmounts = getValidOrdersAndRemainingFillableMakerAssetAmountsFromOnChain(
+// ordersFromSra,
+// makerAssetOrdersAndTradersInfo,
+// zrxTokenAssetData,
+// );
+// // take fee orders from SRA + on chain information and find the valid orders and remaining fillable maker asset amounts
+// feeOrdersAndRemainingFillableMakerAssetAmounts = getValidOrdersAndRemainingFillableMakerAssetAmountsFromOnChain(
+// feeOrdersFromSra,
+// feeOrdersAndTradersInfo,
+// zrxTokenAssetData,
+// );
+// } else {
+// // if we don't have an rpc url, assume all orders are valid and fallback to optional fill amounts from SRA
+// // if fill amounts are not available from the SRA, assume all orders are completely fillable
+// const apiOrdersFromSra = makerAssetOrderbook.asks.records;
+// const feeApiOrdersFromSra = zrxOrderbook.asks.records;
+// // take maker asset orders from SRA and the valid orders and remaining fillable maker asset amounts
+// ordersAndRemainingFillableMakerAssetAmounts = getValidOrdersAndRemainingFillableMakerAssetAmountsFromApi(
+// apiOrdersFromSra,
+// );
+// // take fee orders from SRA and find the valid orders and remaining fillable maker asset amounts
+// feeOrdersAndRemainingFillableMakerAssetAmounts = getValidOrdersAndRemainingFillableMakerAssetAmountsFromApi(
+// feeApiOrdersFromSra,
+// );
+// }
+// // compile final config
+// const config: ForwarderHelperImplConfig = {
+// orders: ordersAndRemainingFillableMakerAssetAmounts.orders,
+// feeOrders: feeOrdersAndRemainingFillableMakerAssetAmounts.orders,
+// remainingFillableMakerAssetAmounts:
+// ordersAndRemainingFillableMakerAssetAmounts.remainingFillableMakerAssetAmounts,
+// remainingFillableFeeAmounts:
+// feeOrdersAndRemainingFillableMakerAssetAmounts.remainingFillableMakerAssetAmounts,
+// };
+// const helper = new ForwarderHelperImpl(config);
+// return helper;
+// },
+// };
-interface OrdersAndRemainingFillableMakerAssetAmounts {
- orders: SignedOrder[];
- remainingFillableMakerAssetAmounts: BigNumber[];
-}
+// interface OrdersAndRemainingFillableMakerAssetAmounts {
+// orders: SignedOrder[];
+// remainingFillableMakerAssetAmounts: BigNumber[];
+// }
-/**
- * Given an array of APIOrder objects from a standard relayer api, return an array
- * of fillable orders with their corresponding remainingFillableMakerAssetAmounts
- */
-function getValidOrdersAndRemainingFillableMakerAssetAmountsFromApi(
- apiOrders: APIOrder[],
-): OrdersAndRemainingFillableMakerAssetAmounts {
- const result = _.reduce(
- apiOrders,
- (acc, apiOrder) => {
- // get current accumulations
- const { orders, remainingFillableMakerAssetAmounts } = acc;
- // get order and metadata
- const { order, metaData } = apiOrder;
- // if the order is expired or not open, move on
- if (orderUtils.isOrderExpired(order) || !orderUtils.isOpenOrder(order)) {
- return acc;
- }
- // calculate remainingFillableMakerAssetAmount from api metadata, else assume order is completely fillable
- const remainingFillableTakerAssetAmount = _.get(
- metaData,
- 'remainingTakerAssetAmount',
- order.takerAssetAmount,
- );
- const remainingFillableMakerAssetAmount = orderUtils.calculateRemainingMakerAssetAmount(
- order,
- remainingFillableTakerAssetAmount,
- );
- // if there is some amount of maker asset left to fill and add the order and remaining amount to the accumulations
- // if there is not any maker asset left to fill, do not add
- if (remainingFillableMakerAssetAmount.gt(constants.ZERO_AMOUNT)) {
- return {
- orders: _.concat(orders, order),
- remainingFillableMakerAssetAmounts: _.concat(
- remainingFillableMakerAssetAmounts,
- remainingFillableMakerAssetAmount,
- ),
- };
- } else {
- return acc;
- }
- },
- { orders: [] as SignedOrder[], remainingFillableMakerAssetAmounts: [] as BigNumber[] },
- );
- return result;
-}
+// /**
+// * Given an array of APIOrder objects from a standard relayer api, return an array
+// * of fillable orders with their corresponding remainingFillableMakerAssetAmounts
+// */
+// function getValidOrdersAndRemainingFillableMakerAssetAmountsFromApi(
+// apiOrders: APIOrder[],
+// ): OrdersAndRemainingFillableMakerAssetAmounts {
+// const result = _.reduce(
+// apiOrders,
+// (acc, apiOrder) => {
+// // get current accumulations
+// const { orders, remainingFillableMakerAssetAmounts } = acc;
+// // get order and metadata
+// const { order, metaData } = apiOrder;
+// // if the order is expired or not open, move on
+// if (orderUtils.isOrderExpired(order) || !orderUtils.isOpenOrder(order)) {
+// return acc;
+// }
+// // calculate remainingFillableMakerAssetAmount from api metadata, else assume order is completely fillable
+// const remainingFillableTakerAssetAmount = _.get(
+// metaData,
+// 'remainingTakerAssetAmount',
+// order.takerAssetAmount,
+// );
+// const remainingFillableMakerAssetAmount = orderUtils.calculateRemainingMakerAssetAmount(
+// order,
+// remainingFillableTakerAssetAmount,
+// );
+// // if there is some amount of maker asset left to fill and add the order and remaining amount to the accumulations
+// // if there is not any maker asset left to fill, do not add
+// if (remainingFillableMakerAssetAmount.gt(constants.ZERO_AMOUNT)) {
+// return {
+// orders: _.concat(orders, order),
+// remainingFillableMakerAssetAmounts: _.concat(
+// remainingFillableMakerAssetAmounts,
+// remainingFillableMakerAssetAmount,
+// ),
+// };
+// } else {
+// return acc;
+// }
+// },
+// { orders: [] as SignedOrder[], remainingFillableMakerAssetAmounts: [] as BigNumber[] },
+// );
+// return result;
+// }
-/**
- * Given an array of orders and corresponding on-chain infos, return a subset of the orders
- * that are still fillable orders with their corresponding remainingFillableMakerAssetAmounts
- */
-function getValidOrdersAndRemainingFillableMakerAssetAmountsFromOnChain(
- inputOrders: SignedOrder[],
- ordersAndTradersInfo: OrderAndTraderInfo[],
- zrxAssetData: string,
-): OrdersAndRemainingFillableMakerAssetAmounts {
- // iterate through the input orders and find the ones that are still fillable
- // for the orders that are still fillable, calculate the remaining fillable maker asset amount
- const result = _.reduce(
- inputOrders,
- (acc, order, index) => {
- // get current accumulations
- const { orders, remainingFillableMakerAssetAmounts } = acc;
- // get corresponding on-chain state for the order
- const { orderInfo, traderInfo } = ordersAndTradersInfo[index];
- // if the order IS NOT fillable, do not add anything to the accumulations and continue iterating
- if (orderInfo.orderStatus !== OrderStatus.FILLABLE) {
- return acc;
- }
- // if the order IS fillable, add the order and calculate the remaining fillable amount
- const transferrableAssetAmount = BigNumber.min([traderInfo.makerAllowance, traderInfo.makerBalance]);
- const transferrableFeeAssetAmount = BigNumber.min([
- traderInfo.makerZrxAllowance,
- traderInfo.makerZrxBalance,
- ]);
- const remainingTakerAssetAmount = order.takerAssetAmount.minus(orderInfo.orderTakerAssetFilledAmount);
- const remainingMakerAssetAmount = orderUtils.calculateRemainingMakerAssetAmount(
- order,
- remainingTakerAssetAmount,
- );
- const remainingFillableCalculator = new RemainingFillableCalculator(
- order.makerFee,
- order.makerAssetAmount,
- order.makerAssetData === zrxAssetData,
- transferrableAssetAmount,
- transferrableFeeAssetAmount,
- remainingMakerAssetAmount,
- );
- const remainingFillableAmount = remainingFillableCalculator.computeRemainingFillable();
- return {
- orders: _.concat(orders, order),
- remainingFillableMakerAssetAmounts: _.concat(
- remainingFillableMakerAssetAmounts,
- remainingFillableAmount,
- ),
- };
- },
- { orders: [] as SignedOrder[], remainingFillableMakerAssetAmounts: [] as BigNumber[] },
- );
- return result;
-}
+// /**
+// * Given an array of orders and corresponding on-chain infos, return a subset of the orders
+// * that are still fillable orders with their corresponding remainingFillableMakerAssetAmounts
+// */
+// function getValidOrdersAndRemainingFillableMakerAssetAmountsFromOnChain(
+// inputOrders: SignedOrder[],
+// ordersAndTradersInfo: OrderAndTraderInfo[],
+// zrxAssetData: string,
+// ): OrdersAndRemainingFillableMakerAssetAmounts {
+// // iterate through the input orders and find the ones that are still fillable
+// // for the orders that are still fillable, calculate the remaining fillable maker asset amount
+// const result = _.reduce(
+// inputOrders,
+// (acc, order, index) => {
+// // get current accumulations
+// const { orders, remainingFillableMakerAssetAmounts } = acc;
+// // get corresponding on-chain state for the order
+// const { orderInfo, traderInfo } = ordersAndTradersInfo[index];
+// // if the order IS NOT fillable, do not add anything to the accumulations and continue iterating
+// if (orderInfo.orderStatus !== OrderStatus.FILLABLE) {
+// return acc;
+// }
+// // if the order IS fillable, add the order and calculate the remaining fillable amount
+// const transferrableAssetAmount = BigNumber.min([traderInfo.makerAllowance, traderInfo.makerBalance]);
+// const transferrableFeeAssetAmount = BigNumber.min([
+// traderInfo.makerZrxAllowance,
+// traderInfo.makerZrxBalance,
+// ]);
+// const remainingTakerAssetAmount = order.takerAssetAmount.minus(orderInfo.orderTakerAssetFilledAmount);
+// const remainingMakerAssetAmount = orderUtils.calculateRemainingMakerAssetAmount(
+// order,
+// remainingTakerAssetAmount,
+// );
+// const remainingFillableCalculator = new RemainingFillableCalculator(
+// order.makerFee,
+// order.makerAssetAmount,
+// order.makerAssetData === zrxAssetData,
+// transferrableAssetAmount,
+// transferrableFeeAssetAmount,
+// remainingMakerAssetAmount,
+// );
+// const remainingFillableAmount = remainingFillableCalculator.computeRemainingFillable();
+// return {
+// orders: _.concat(orders, order),
+// remainingFillableMakerAssetAmounts: _.concat(
+// remainingFillableMakerAssetAmounts,
+// remainingFillableAmount,
+// ),
+// };
+// },
+// { orders: [] as SignedOrder[], remainingFillableMakerAssetAmounts: [] as BigNumber[] },
+// );
+// return result;
+// }
-function getOpenAsksFromOrderbook(orderbookResponse: OrderbookResponse): SignedOrder[] {
- const asks = _.map(orderbookResponse.asks.records, apiOrder => apiOrder.order);
- const result = _.filter(asks, ask => orderUtils.isOpenOrder(ask));
- return result;
-}
+// function getOpenAsksFromOrderbook(orderbookResponse: OrderbookResponse): SignedOrder[] {
+// const asks = _.map(orderbookResponse.asks.records, apiOrder => apiOrder.order);
+// const result = _.filter(asks, ask => orderUtils.isOpenOrder(ask));
+// return result;
+// }
diff --git a/packages/asset-buyer/src/forwarder_helper_impl.ts b/packages/asset-buyer/src/forwarder_helper_impl.ts
deleted file mode 100644
index a90edb0bb..000000000
--- a/packages/asset-buyer/src/forwarder_helper_impl.ts
+++ /dev/null
@@ -1,64 +0,0 @@
-import { marketUtils } from '@0xproject/order-utils';
-import { SignedOrder } from '@0xproject/types';
-import { BigNumber } from '@0xproject/utils';
-import * as _ from 'lodash';
-
-import { constants } from './constants';
-import { ForwarderHelper, ForwarderHelperError, MarketBuyOrdersInfo, MarketBuyOrdersInfoRequest } from './types';
-import { forwarderHelperImplConfigUtils } from './utils/forwarder_helper_impl_config_utils';
-
-const SLIPPAGE_PERCENTAGE = new BigNumber(0.2); // 20% slippage protection, possibly move this into request interface
-
-export interface ForwarderHelperImplConfig {
- orders: SignedOrder[];
- feeOrders: SignedOrder[];
- remainingFillableMakerAssetAmounts?: BigNumber[];
- remainingFillableFeeAmounts?: BigNumber[];
-}
-
-export class ForwarderHelperImpl implements ForwarderHelper {
- public readonly config: ForwarderHelperImplConfig;
- constructor(config: ForwarderHelperImplConfig) {
- this.config = forwarderHelperImplConfigUtils.sortedConfig(config);
- }
- public getMarketBuyOrdersInfo(request: MarketBuyOrdersInfoRequest): MarketBuyOrdersInfo {
- const { makerAssetFillAmount, feePercentage } = request;
- const { orders, feeOrders, remainingFillableMakerAssetAmounts, remainingFillableFeeAmounts } = this.config;
- // TODO: make the slippage percentage customizable
- const slippageBufferAmount = makerAssetFillAmount.mul(SLIPPAGE_PERCENTAGE).round();
- const { resultOrders, remainingFillAmount } = marketUtils.findOrdersThatCoverMakerAssetFillAmount(
- orders,
- makerAssetFillAmount,
- {
- remainingFillableMakerAssetAmounts,
- slippageBufferAmount,
- },
- );
- if (remainingFillAmount.gt(constants.ZERO_AMOUNT)) {
- throw new Error(ForwarderHelperError.InsufficientMakerAssetLiquidity);
- }
- // TODO: update this logic to find the minimum amount of feeOrders to cover the worst case as opposed to
- // finding order that cover all fees, this will help with estimating ETH and minimizing gas usage
- const { resultFeeOrders, remainingFeeAmount } = marketUtils.findFeeOrdersThatCoverFeesForTargetOrders(
- resultOrders,
- feeOrders,
- {
- remainingFillableMakerAssetAmounts,
- remainingFillableFeeAmounts,
- },
- );
- if (remainingFeeAmount.gt(constants.ZERO_AMOUNT)) {
- throw new Error(ForwarderHelperError.InsufficientZrxLiquidity);
- }
- // TODO: calculate min and max eth usage
- // TODO: optimize orders call data
- return {
- makerAssetFillAmount,
- orders: resultOrders,
- feeOrders: resultFeeOrders,
- minEthAmount: constants.ZERO_AMOUNT,
- maxEthAmount: constants.ZERO_AMOUNT,
- feePercentage,
- };
- }
-}
diff --git a/packages/asset-buyer/src/index.ts b/packages/asset-buyer/src/index.ts
index eb3a34bd5..299b32edd 100644
--- a/packages/asset-buyer/src/index.ts
+++ b/packages/asset-buyer/src/index.ts
@@ -1,2 +1,2 @@
-export { forwarderHelperFactory } from './forwarder_helper_factory';
-export { ForwarderHelper, ForwarderHelperError, MarketBuyOrdersInfoRequest, MarketBuyOrdersInfo } from './types';
+export { AssetBuyerError, BuyQuote, BuyQuoteRequest } from './types';
+export { AssetBuyer } from './asset_buyers/asset_buyer';
diff --git a/packages/asset-buyer/src/types.ts b/packages/asset-buyer/src/types.ts
index a7f02ff8d..8a12d0cf8 100644
--- a/packages/asset-buyer/src/types.ts
+++ b/packages/asset-buyer/src/types.ts
@@ -1,49 +1,42 @@
import { SignedOrder } from '@0xproject/types';
import { BigNumber } from '@0xproject/utils';
-export enum ForwarderHelperFactoryError {
- NoEtherTokenContractFound = 'NO_ETHER_TOKEN_CONTRACT_FOUND',
- NoZrxTokenContractFound = 'NO_ZRX_TOKEN_CONTRACT_FOUND',
- StandardRelayerApiError = 'STANDARD_RELAYER_API_ERROR',
-}
-
-export interface ForwarderHelper {
- /**
- * Given a MarketBuyOrdersInfoRequest, returns a MarketBuyOrdersInfo containing all information relevant to fulfilling the request
- * using the ForwarderContract marketBuyOrdersWithEth function.
- * @param request An object that conforms to MarketBuyOrdersInfoRequest. See type definition for more information.
- * @return An object that conforms to MarketBuyOrdersInfo that satisfies the request. See type definition for more information.
- */
- getMarketBuyOrdersInfo: (request: MarketBuyOrdersInfoRequest) => MarketBuyOrdersInfo;
-}
-
-export enum ForwarderHelperError {
- InsufficientMakerAssetLiquidity = 'INSUFFICIENT_MAKER_ASSET_LIQUIDITY',
- InsufficientZrxLiquidity = 'INSUFFICIENT_ZRX_LIQUIDITY',
-}
-
/**
- * makerAssetFillAmount: The amount of makerAsset requesting to be filled
- * feePercentage: Optional affiliate percentage amount factoring into eth amount calculations
+ * assetBuyAmount: The amount of asset to buy.
+ * feePercentage: Optional affiliate percentage amount factoring into eth amount calculations.
*/
-export interface MarketBuyOrdersInfoRequest {
- makerAssetFillAmount: BigNumber;
+export interface BuyQuoteRequest {
+ assetBuyAmount: BigNumber;
feePercentage?: BigNumber;
}
/**
- * makerAssetFillAmount: The amount of makerAsset requesting to be filled
- * orders: An array of objects conforming to SignedOrder. These orders can be used to cover the requested makerAssetFillAmount plus slippage
- * feeOrders: An array of objects conforming to SignedOrder. These orders can be used to cover the fees for the orders param above
- * minEthAmount: Amount of eth in wei to send with the tx for the most optimistic case
- * maxEthAmount: Amount of eth in wei to send with the tx for the worst case
- * feePercentage: Affiliate fee percentage used to calculate the eth amounts above. Passed thru directly from the request
+ * assetData: The asset information.
+ * orders: An array of objects conforming to SignedOrder. These orders can be used to cover the requested assetBuyAmount plus slippage.
+ * feeOrders: An array of objects conforming to SignedOrder. These orders can be used to cover the fees for the orders param above.
+ * minRate: Min rate that needs to be paid in order to execute the buy.
+ * maxRate: Max rate that can be paid in order to execute the buy.
+ * assetBuyAmount: The amount of asset to buy. Passed through directly from the request.
+ * feePercentage: Affiliate fee percentage used to calculate the eth amounts above. Passed through directly from the request.
*/
-export interface MarketBuyOrdersInfo {
- makerAssetFillAmount: BigNumber;
+export interface BuyQuote {
+ assetData: string;
orders: SignedOrder[];
feeOrders: SignedOrder[];
- minEthAmount: BigNumber;
- maxEthAmount: BigNumber;
+ minRate: BigNumber;
+ maxRate: BigNumber;
+ assetBuyAmount: BigNumber;
feePercentage?: BigNumber;
}
+
+/**
+ * Possible errors thrown by an AssetBuyer instance or associated static methods
+ */
+export enum AssetBuyerError {
+ NoEtherTokenContractFound = 'NO_ETHER_TOKEN_CONTRACT_FOUND',
+ NoZrxTokenContractFound = 'NO_ZRX_TOKEN_CONTRACT_FOUND',
+ StandardRelayerApiError = 'STANDARD_RELAYER_API_ERROR',
+ InsufficientAssetLiquidity = 'INSUFFICIENT_ASSET_LIQUIDITY',
+ InsufficientZrxLiquidity = 'INSUFFICIENT_ZRX_LIQUIDITY',
+ NoAddressAvailable = 'NO_ADDRESS_AVAILABLE',
+}
diff --git a/packages/asset-buyer/src/utils/forwarder_helper_impl_config_utils.ts b/packages/asset-buyer/src/utils/forwarder_helper_impl_config_utils.ts
index 253384f65..d3cbb651a 100644
--- a/packages/asset-buyer/src/utils/forwarder_helper_impl_config_utils.ts
+++ b/packages/asset-buyer/src/utils/forwarder_helper_impl_config_utils.ts
@@ -1,92 +1,92 @@
-import { sortingUtils } from '@0xproject/order-utils';
-import { SignedOrder } from '@0xproject/types';
-import { BigNumber } from '@0xproject/utils';
-import * as _ from 'lodash';
+// import { sortingUtils } from '@0xproject/order-utils';
+// import { SignedOrder } from '@0xproject/types';
+// import { BigNumber } from '@0xproject/utils';
+// import * as _ from 'lodash';
-import { ForwarderHelperImplConfig } from '../forwarder_helper_impl';
+// import { ForwarderHelperImplConfig } from '@0xproject/asset-buyer/src/asset_buyer';
-interface SignedOrderWithAmount extends SignedOrder {
- remainingFillAmount: BigNumber;
-}
+// interface SignedOrderWithAmount extends SignedOrder {
+// remainingFillAmount: BigNumber;
+// }
-export const forwarderHelperImplConfigUtils = {
- sortedConfig(config: ForwarderHelperImplConfig): ForwarderHelperImplConfig {
- const { orders, feeOrders, remainingFillableMakerAssetAmounts, remainingFillableFeeAmounts } = config;
- // TODO: provide a feeRate to the sorting function to more accurately sort based on the current market for ZRX tokens
- const orderSorter = (ordersToSort: SignedOrder[]) => {
- return sortingUtils.sortOrdersByFeeAdjustedRate(ordersToSort);
- };
- const sortOrdersResult = sortOrdersAndRemainingFillAmounts(
- orderSorter,
- orders,
- remainingFillableMakerAssetAmounts,
- );
- const feeOrderSorter = (ordersToSort: SignedOrder[]) => {
- return sortingUtils.sortFeeOrdersByFeeAdjustedRate(ordersToSort);
- };
- const sortFeeOrdersResult = sortOrdersAndRemainingFillAmounts(
- feeOrderSorter,
- feeOrders,
- remainingFillableFeeAmounts,
- );
- return {
- orders: sortOrdersResult.orders,
- feeOrders: sortFeeOrdersResult.orders,
- remainingFillableMakerAssetAmounts: sortOrdersResult.remainingFillAmounts,
- remainingFillableFeeAmounts: sortFeeOrdersResult.remainingFillAmounts,
- };
- },
-};
+// export const forwarderHelperImplConfigUtils = {
+// sortedConfig(config: ForwarderHelperImplConfig): ForwarderHelperImplConfig {
+// const { orders, feeOrders, remainingFillableMakerAssetAmounts, remainingFillableFeeAmounts } = config;
+// // TODO: provide a feeRate to the sorting function to more accurately sort based on the current market for ZRX tokens
+// const orderSorter = (ordersToSort: SignedOrder[]) => {
+// return sortingUtils.sortOrdersByFeeAdjustedRate(ordersToSort);
+// };
+// const sortOrdersResult = sortOrdersAndRemainingFillAmounts(
+// orderSorter,
+// orders,
+// remainingFillableMakerAssetAmounts,
+// );
+// const feeOrderSorter = (ordersToSort: SignedOrder[]) => {
+// return sortingUtils.sortFeeOrdersByFeeAdjustedRate(ordersToSort);
+// };
+// const sortFeeOrdersResult = sortOrdersAndRemainingFillAmounts(
+// feeOrderSorter,
+// feeOrders,
+// remainingFillableFeeAmounts,
+// );
+// return {
+// orders: sortOrdersResult.orders,
+// feeOrders: sortFeeOrdersResult.orders,
+// remainingFillableMakerAssetAmounts: sortOrdersResult.remainingFillAmounts,
+// remainingFillableFeeAmounts: sortFeeOrdersResult.remainingFillAmounts,
+// };
+// },
+// };
-type OrderSorter = (orders: SignedOrder[]) => SignedOrder[];
+// type OrderSorter = (orders: SignedOrder[]) => SignedOrder[];
-function sortOrdersAndRemainingFillAmounts(
- orderSorter: OrderSorter,
- orders: SignedOrder[],
- remainingFillAmounts?: BigNumber[],
-): { orders: SignedOrder[]; remainingFillAmounts?: BigNumber[] } {
- if (!_.isUndefined(remainingFillAmounts)) {
- // Bundle orders together with their remainingFillAmounts so that we can sort them together
- const orderWithAmounts = bundleSignedOrderWithAmounts(orders, remainingFillAmounts);
- // Sort
- const sortedOrderWithAmounts = orderSorter(orderWithAmounts) as SignedOrderWithAmount[];
- // Unbundle after sorting
- const unbundledSortedOrderWithAmounts = unbundleSignedOrderWithAmounts(sortedOrderWithAmounts);
- return {
- orders: unbundledSortedOrderWithAmounts.orders,
- remainingFillAmounts: unbundledSortedOrderWithAmounts.amounts,
- };
- } else {
- const sortedOrders = orderSorter(orders);
- return {
- orders: sortedOrders,
- };
- }
-}
+// function sortOrdersAndRemainingFillAmounts(
+// orderSorter: OrderSorter,
+// orders: SignedOrder[],
+// remainingFillAmounts?: BigNumber[],
+// ): { orders: SignedOrder[]; remainingFillAmounts?: BigNumber[] } {
+// if (!_.isUndefined(remainingFillAmounts)) {
+// // Bundle orders together with their remainingFillAmounts so that we can sort them together
+// const orderWithAmounts = bundleSignedOrderWithAmounts(orders, remainingFillAmounts);
+// // Sort
+// const sortedOrderWithAmounts = orderSorter(orderWithAmounts) as SignedOrderWithAmount[];
+// // Unbundle after sorting
+// const unbundledSortedOrderWithAmounts = unbundleSignedOrderWithAmounts(sortedOrderWithAmounts);
+// return {
+// orders: unbundledSortedOrderWithAmounts.orders,
+// remainingFillAmounts: unbundledSortedOrderWithAmounts.amounts,
+// };
+// } else {
+// const sortedOrders = orderSorter(orders);
+// return {
+// orders: sortedOrders,
+// };
+// }
+// }
-function bundleSignedOrderWithAmounts(orders: SignedOrder[], amounts: BigNumber[]): SignedOrderWithAmount[] {
- const ordersAndAmounts = _.map(orders, (order, index) => {
- return {
- ...order,
- remainingFillAmount: amounts[index],
- };
- });
- return ordersAndAmounts;
-}
+// function bundleSignedOrderWithAmounts(orders: SignedOrder[], amounts: BigNumber[]): SignedOrderWithAmount[] {
+// const ordersAndAmounts = _.map(orders, (order, index) => {
+// return {
+// ...order,
+// remainingFillAmount: amounts[index],
+// };
+// });
+// return ordersAndAmounts;
+// }
-function unbundleSignedOrderWithAmounts(
- signedOrderWithAmounts: SignedOrderWithAmount[],
-): { orders: SignedOrder[]; amounts: BigNumber[] } {
- const orders = _.map(signedOrderWithAmounts, order => {
- const { remainingFillAmount, ...rest } = order;
- return rest;
- });
- const amounts = _.map(signedOrderWithAmounts, order => {
- const { remainingFillAmount } = order;
- return remainingFillAmount;
- });
- return {
- orders,
- amounts,
- };
-}
+// function unbundleSignedOrderWithAmounts(
+// signedOrderWithAmounts: SignedOrderWithAmount[],
+// ): { orders: SignedOrder[]; amounts: BigNumber[] } {
+// const orders = _.map(signedOrderWithAmounts, order => {
+// const { remainingFillAmount, ...rest } = order;
+// return rest;
+// });
+// const amounts = _.map(signedOrderWithAmounts, order => {
+// const { remainingFillAmount } = order;
+// return remainingFillAmount;
+// });
+// return {
+// orders,
+// amounts,
+// };
+// }
generated by cgit v1.2.3 (git 2.25.1) at 2024-11-10 09:13:51 +0800