@clober/v2-sdk 0.0.3 → 0.0.5

package/dist/esm/call.js

@@ -1,4 +1,4 @@
-import { encodeAbiParameters, isAddressEqual, parseUnits, zeroAddress, zeroHash, } from 'viem';
+import { formatUnits, isAddressEqual, parseUnits, zeroAddress, zeroHash, } from 'viem';
 import { CHAIN_MAP } from './constants/chain';
 import { calculateUnit } from './utils/unit';
 import { CONTROLLER_ABI } from './abis/core/controller-abi';
@@ -11,9 +11,8 @@ import { parsePrice } from './utils/prices';
 import { fromPrice, invertPrice } from './utils/tick';
 import { getExpectedOutput, getOpenOrders } from './view';
 import { toBookId } from './utils/book-id';
-import { MAKE_ORDER_PARAMS_ABI, TAKE_ORDER_PARAMS_ABI, } from './abis/core/params-abi';
-import { Action } from './constants/action';
 import { fetchIsApprovedForAll } from './utils/approval';
+import { decorator } from './utils/decorator';
 /**
  * Build a transaction to open a market.
  *
@@ -32,11 +31,11 @@ import { fetchIsApprovedForAll } from './utils/approval';
  *  '0x0000000000000000000000000000000000000000'
  * )
  */
-export const openMarket = async (chainId, inputToken, outputToken, options) => {
-    const market = await fetchMarket(chainId, [inputToken, outputToken], options?.rpcUrl);
+export const openMarket = decorator(async ({ chainId, inputToken, outputToken, }) => {
+    const market = await fetchMarket(chainId, [inputToken, outputToken]);
     const isBid = isAddressEqual(market.quote.address, inputToken);
     if ((isBid && !market.bidBookOpen) || (!isBid && !market.askBookOpen)) {
-        const unit = await calculateUnit(chainId, isBid ? market.quote : market.base, options?.rpcUrl);
+        const unit = await calculateUnit(chainId, isBid ? market.quote : market.base);
         return buildTransaction(chainId, {
             address: CONTRACT_ADDRESSES[chainId].Controller,
             abi: CONTROLLER_ABI,
@@ -57,10 +56,10 @@ export const openMarket = async (chainId, inputToken, outputToken, options) => {
                 ],
                 getDeadlineTimestampInSeconds(),
             ],
-        }, options?.rpcUrl);
+        });
     }
     return undefined;
-};
+});
 /**
  * Places a limit order on the specified chain for trading tokens.
  *
@@ -74,7 +73,8 @@ export const openMarket = async (chainId, inputToken, outputToken, options) => {
  * @param {PermitSignature} [options.signature] The permit signature for token approval.
  * @param {boolean} [options.postOnly] A boolean indicating whether the order is only to be made not taken.
  * @param {string} [options.rpcUrl] The RPC URL of the blockchain.
- * @returns {Promise<Transaction>} Promise resolving to the transaction object representing the limit order.
+ * @returns {Promise<{ transaction: Transaction, result: { make: CurrencyFlow, take: CurrencyFlow } }>}
+ * Promise resolving to the transaction object representing the limit order with the result of the order.
  * @example
  * import { signERC20Permit, limitOrder } from '@clober/v2-sdk'
  * import { privateKeyToAccount } from 'viem/accounts'
@@ -86,7 +86,7 @@ export const openMarket = async (chainId, inputToken, outputToken, options) => {
  *   '100.123'
  * )
  *
- * const transaction = await limitOrder(
+ * const { transaction } = await limitOrder(
  *   421614,
  *  '0xF8c1869Ecd4df136693C45EcE1b67f85B6bDaE69
  *  '0x00bfd44e79fb7f6dd5887a9426c8ef85a0cd23e0',
@@ -99,7 +99,7 @@ export const openMarket = async (chainId, inputToken, outputToken, options) => {
  * @example
  * import { limitOrder } from '@clober/v2-sdk'
  *
- * const transaction = await limitOrder(
+ * const { transaction } = await limitOrder(
  *   421614,
  *  '0xF8c1869Ecd4df136693C45EcE1b67f85B6bDaE69
  *  '0x0000000000000000000000000000000000000000',
@@ -108,16 +108,12 @@ export const openMarket = async (chainId, inputToken, outputToken, options) => {
  *  '4000.01', // price at 4000.01 (ETH/USDC)
  * )
  */
-export const limitOrder = async (chainId, userAddress, inputToken, outputToken, amount, price, options) => {
-    const { signature, postOnly, rpcUrl } = options || {
-        signature: undefined,
-        postOnly: false,
-        rpcUrl: undefined,
-    };
-    const market = await fetchMarket(chainId, [inputToken, outputToken], rpcUrl);
+export const limitOrder = decorator(async ({ chainId, userAddress, inputToken, outputToken, amount, price, options, }) => {
+    const market = await fetchMarket(chainId, [inputToken, outputToken]);
     const isBid = isAddressEqual(market.quote.address, inputToken);
     if ((isBid && !market.bidBookOpen) || (!isBid && !market.askBookOpen)) {
         throw new Error(`
+       Open the market before placing a limit order.
        import { openMarket } from '@clober/v2-sdk'
 
        const transaction = await openMarket(
@@ -131,24 +127,25 @@ export const limitOrder = async (chainId, userAddress, inputToken, outputToken,
     const tick = isBid ? fromPrice(rawPrice) : fromPrice(invertPrice(rawPrice));
     const tokensToSettle = [inputToken, outputToken].filter((address) => !isAddressEqual(address, zeroAddress));
     const quoteAmount = parseUnits(amount, isBid ? market.quote.decimals : market.base.decimals);
-    const [unit, { result }] = await Promise.all([
-        calculateUnit(chainId, isBid ? market.quote : market.base, rpcUrl),
-        getExpectedOutput(chainId, inputToken, outputToken, amount, rpcUrl
-            ? {
-                limitPrice: price,
-                rpcUrl,
-            }
-            : {
-                limitPrice: price,
-            }),
+    const [unit, { spendAmount, bookId }] = await Promise.all([
+        calculateUnit(chainId, isBid ? market.quote : market.base),
+        getExpectedOutput({
+            chainId,
+            inputToken,
+            outputToken,
+            amountIn: amount,
+            options: {
+                ...options,
+            },
+        }),
     ]);
     const isETH = isAddressEqual(inputToken, zeroAddress);
-    const permitParamsList = signature && !isETH
+    const permitParamsList = options?.signature && !isETH
         ? [
             {
                 token: inputToken,
                 permitAmount: quoteAmount,
-                signature,
+                signature: options.signature,
             },
         ]
         : [];
@@ -158,93 +155,78 @@ export const limitOrder = async (chainId, userAddress, inputToken, outputToken,
         quoteAmount,
         hookData: zeroHash,
     };
-    if (postOnly === true || result.length === 0) {
-        return buildTransaction(chainId, {
-            chain: CHAIN_MAP[chainId],
-            account: userAddress,
-            address: CONTRACT_ADDRESSES[chainId].Controller,
-            abi: CONTROLLER_ABI,
-            functionName: 'make',
-            args: [
-                [makeParam],
-                tokensToSettle,
-                permitParamsList,
-                getDeadlineTimestampInSeconds(),
-            ],
-            value: isETH ? quoteAmount : 0n,
-        }, options?.rpcUrl);
-    }
-    else if (result.length === 1) {
-        // take and make
-        return buildTransaction(chainId, {
-            chain: CHAIN_MAP[chainId],
-            account: userAddress,
-            address: CONTRACT_ADDRESSES[chainId].Controller,
-            abi: CONTROLLER_ABI,
-            functionName: 'limit',
-            args: [
-                [
-                    {
-                        takeBookId: result[0].bookId,
-                        makeBookId: makeParam.id,
-                        limitPrice: rawPrice,
-                        tick: makeParam.tick,
-                        quoteAmount,
-                        takeHookData: zeroHash,
-                        makeHookData: makeParam.hookData,
-                    },
+    if (options?.postOnly === true || spendAmount === '0') {
+        return {
+            transaction: await buildTransaction(chainId, {
+                chain: CHAIN_MAP[chainId],
+                account: userAddress,
+                address: CONTRACT_ADDRESSES[chainId].Controller,
+                abi: CONTROLLER_ABI,
+                functionName: 'make',
+                args: [
+                    [makeParam],
+                    tokensToSettle,
+                    permitParamsList,
+                    getDeadlineTimestampInSeconds(),
                 ],
-                tokensToSettle,
-                permitParamsList,
-                getDeadlineTimestampInSeconds(),
-            ],
-            value: isETH ? quoteAmount : 0n,
-        }, options?.rpcUrl);
+                value: isETH ? quoteAmount : 0n,
+            }),
+            result: {
+                make: {
+                    amount: formatUnits(quoteAmount, isBid ? market.quote.decimals : market.base.decimals),
+                    currency: isBid ? market.quote : market.base,
+                    direction: 'in',
+                },
+                take: {
+                    amount: '0',
+                    currency: isBid ? market.base : market.quote,
+                    direction: 'out',
+                },
+            },
+        };
     }
     else {
-        // take x n and make
-        const makeAmount = quoteAmount -
-            result.reduce((acc, { spendAmount }) => acc + spendAmount, 0n);
-        return buildTransaction(chainId, {
-            chain: CHAIN_MAP[chainId],
-            account: userAddress,
-            address: CONTRACT_ADDRESSES[chainId].Controller,
-            abi: CONTROLLER_ABI,
-            functionName: 'execute',
-            args: [
-                [
-                    ...result.map(() => Action.TAKE),
-                    ...(makeAmount > 0n ? [Action.MAKE] : []),
-                ],
-                [
-                    ...result.map(({ bookId, takenAmount }) => encodeAbiParameters(TAKE_ORDER_PARAMS_ABI, [
+        // take and make
+        return {
+            transaction: await buildTransaction(chainId, {
+                chain: CHAIN_MAP[chainId],
+                account: userAddress,
+                address: CONTRACT_ADDRESSES[chainId].Controller,
+                abi: CONTROLLER_ABI,
+                functionName: 'limit',
+                args: [
+                    [
                         {
-                            id: bookId,
+                            takeBookId: bookId,
+                            makeBookId: makeParam.id,
                             limitPrice: rawPrice,
-                            quoteAmount: takenAmount,
-                            hookData: zeroHash,
+                            tick: makeParam.tick,
+                            quoteAmount,
+                            takeHookData: zeroHash,
+                            makeHookData: makeParam.hookData,
                         },
-                    ])),
-                    ...(makeAmount > 0n
-                        ? [
-                            encodeAbiParameters(MAKE_ORDER_PARAMS_ABI, [
-                                {
-                                    ...makeParam,
-                                    quoteAmount: makeAmount,
-                                },
-                            ]),
-                        ]
-                        : []),
+                    ],
+                    tokensToSettle,
+                    permitParamsList,
+                    getDeadlineTimestampInSeconds(),
                 ],
-                tokensToSettle,
-                permitParamsList,
-                [],
-                getDeadlineTimestampInSeconds(),
-            ],
-            value: isETH ? quoteAmount : 0n,
-        }, options?.rpcUrl);
+                value: isETH ? quoteAmount : 0n,
+            }),
+            result: {
+                make: {
+                    amount: formatUnits(quoteAmount, isBid ? market.quote.decimals : market.base.decimals),
+                    currency: isBid ? market.quote : market.base,
+                    direction: 'in',
+                },
+                take: {
+                    amount: spendAmount,
+                    currency: isBid ? market.base : market.quote,
+                    direction: 'out',
+                },
+            },
+        };
     }
-};
+});
 /**
  * Executes a market order on the specified chain for trading tokens.
  *
@@ -290,16 +272,12 @@ export const limitOrder = async (chainId, userAddress, inputToken, outputToken,
  *  '0.13', // 0.13 ETH
  * )
  */
-export const marketOrder = async (chainId, userAddress, inputToken, outputToken, amount, options) => {
-    const { signature, rpcUrl, limitPrice } = options || {
-        signature: undefined,
-        rpcUrl: undefined,
-        limitPrice: undefined,
-    };
-    const market = await fetchMarket(chainId, [inputToken, outputToken], rpcUrl);
+export const marketOrder = decorator(async ({ chainId, userAddress, inputToken, outputToken, amount, options, }) => {
+    const market = await fetchMarket(chainId, [inputToken, outputToken]);
     const isBid = isAddressEqual(market.quote.address, inputToken);
     if ((isBid && !market.bidBookOpen) || (!isBid && !market.askBookOpen)) {
         throw new Error(`
+       Open the market before placing a market order.
        import { openMarket } from '@clober/v2-sdk'
 
        const transaction = await openMarket(
@@ -309,21 +287,25 @@ export const marketOrder = async (chainId, userAddress, inputToken, outputToken,
        )
     `);
     }
-    const rawLimitPrice = parsePrice(Number(limitPrice ?? '0'), market.quote.decimals, market.base.decimals);
+    const rawLimitPrice = parsePrice(Number(options?.limitPrice ?? '0'), market.quote.decimals, market.base.decimals);
     const tokensToSettle = [inputToken, outputToken].filter((address) => !isAddressEqual(address, zeroAddress));
     const quoteAmount = parseUnits(amount, isBid ? market.quote.decimals : market.base.decimals);
-    const { result } = await getExpectedOutput(chainId, inputToken, outputToken, amount, rpcUrl
-        ? {
-            rpcUrl,
-        }
-        : {});
+    const { bookId, takenAmount } = await getExpectedOutput({
+        chainId,
+        inputToken,
+        outputToken,
+        amountIn: amount,
+        options: {
+            ...options,
+        },
+    });
     const isETH = isAddressEqual(inputToken, zeroAddress);
-    const permitParamsList = signature && !isETH
+    const permitParamsList = options?.signature && !isETH
         ? [
             {
                 token: inputToken,
                 permitAmount: quoteAmount,
-                signature,
+                signature: options.signature,
             },
         ]
         : [];
@@ -334,19 +316,21 @@ export const marketOrder = async (chainId, userAddress, inputToken, outputToken,
         abi: CONTROLLER_ABI,
         functionName: 'take',
         args: [
-            result.map(({ bookId, takenAmount }) => ({
-                id: bookId,
-                limitPrice: isBid ? invertPrice(rawLimitPrice) : rawLimitPrice,
-                quoteAmount: takenAmount,
-                hookData: zeroHash,
-            })),
+            [
+                {
+                    id: bookId,
+                    limitPrice: isBid ? invertPrice(rawLimitPrice) : rawLimitPrice,
+                    quoteAmount: takenAmount,
+                    hookData: zeroHash,
+                },
+            ],
             tokensToSettle,
             permitParamsList,
             getDeadlineTimestampInSeconds(),
         ],
         value: isETH ? quoteAmount : 0n,
-    }, options?.rpcUrl);
-};
+    });
+});
 /**
  * Claims specified open order for settlement.
  * [IMPORTANT] Set ApprovalForAll before calling this function.
@@ -356,7 +340,8 @@ export const marketOrder = async (chainId, userAddress, inputToken, outputToken,
  * @param {string} id An ID representing the open order to be claimed.
  * @param {Object} [options] Optional parameters for claiming orders.
  * @param {string} [options.rpcUrl] The RPC URL to use for executing the transaction.
- * @returns {Promise<Transaction>} Promise resolving to the transaction object representing the claim action.
+ * @returns {Promise<{ transaction: Transaction, result: CurrencyFlow }>}
+ * Promise resolving to the transaction object representing the claim action with the result of the order.
  * @throws {Error} Throws an error if no open orders are found for the specified user.
  * @example
  * import { getOpenOrders, claimOrders } from '@clober/v2-sdk'
@@ -371,9 +356,18 @@ export const marketOrder = async (chainId, userAddress, inputToken, outputToken,
  *    openOrders.map((order) => order.id)
  * )
  */
-export const claimOrder = async (chainId, userAddress, id, options) => {
-    return claimOrders(chainId, userAddress, [id], options);
-};
+export const claimOrder = decorator(async ({ chainId, userAddress, id, options, }) => {
+    const { transaction, result } = await claimOrders({
+        chainId,
+        userAddress,
+        ids: [id],
+        options: { ...options },
+    });
+    return {
+        transaction,
+        result: result[0],
+    };
+});
 /**
  * Claims specified open orders for settlement.
  * [IMPORTANT] Set ApprovalForAll before calling this function.
@@ -383,7 +377,8 @@ export const claimOrder = async (chainId, userAddress, id, options) => {
  * @param {string[]} ids An array of IDs representing the open orders to be claimed.
  * @param {Object} [options] Optional parameters for claiming orders.
  * @param {string} [options.rpcUrl] The RPC URL to use for executing the transaction.
- * @returns {Promise<Transaction>} Promise resolving to the transaction object representing the claim action.
+ * @returns {Promise<{ transaction: Transaction, result: CurrencyFlow[] }>}
+ * Promise resolving to the transaction object representing the claim action with the result of the orders.
  * @throws {Error} Throws an error if no open orders are found for the specified user.
  * @example
  * import { getOpenOrders, claimOrders } from '@clober/v2-sdk'
@@ -398,13 +393,11 @@ export const claimOrder = async (chainId, userAddress, id, options) => {
  *    openOrders.map((order) => order.id)
  * )
  */
-export const claimOrders = async (chainId, userAddress, ids, options) => {
-    const { rpcUrl } = options || {
-        rpcUrl: undefined,
-    };
-    const isApprovedForAll = await fetchIsApprovedForAll(chainId, userAddress, options?.rpcUrl);
+export const claimOrders = decorator(async ({ chainId, userAddress, ids, options, }) => {
+    const isApprovedForAll = await fetchIsApprovedForAll(chainId, userAddress);
     if (!isApprovedForAll) {
         throw new Error(`
+       Set ApprovalForAll before calling this function.
        import { setApprovalOfOpenOrdersForAll } from '@clober/v2-sdk'
 
        const hash = await setApprovalOfOpenOrdersForAll(
@@ -413,32 +406,42 @@ export const claimOrders = async (chainId, userAddress, ids, options) => {
        )
     `);
     }
-    const openOrders = (await getOpenOrders(chainId, userAddress, rpcUrl ? { rpcUrl } : {})).filter((order) => ids.includes(order.id));
+    const openOrders = (await getOpenOrders({ chainId, userAddress, options: { ...options } })).filter((order) => ids.includes(order.id));
     if (openOrders.length === 0) {
         throw new Error(`No claimable open orders found for ${userAddress}`);
     }
     const tokensToSettle = openOrders
-        .map((order) => [order.outputCurrency.address, order.inputCurrency.address])
+        .map((order) => [
+        order.outputCurrency.address,
+        order.inputCurrency.address,
+    ])
         .flat()
         .filter((address, index, self) => self.findIndex((c) => isAddressEqual(c, address)) === index)
         .filter((address) => !isAddressEqual(address, zeroAddress));
-    return buildTransaction(chainId, {
-        chain: CHAIN_MAP[chainId],
-        account: userAddress,
-        address: CONTRACT_ADDRESSES[chainId].Controller,
-        abi: CONTROLLER_ABI,
-        functionName: 'claim',
-        args: [
-            openOrders.map((order) => ({
-                id: BigInt(order.id),
-                hookData: zeroHash,
-            })),
-            tokensToSettle,
-            [],
-            getDeadlineTimestampInSeconds(),
-        ],
-    }, options?.rpcUrl);
-};
+    return {
+        transaction: await buildTransaction(chainId, {
+            chain: CHAIN_MAP[chainId],
+            account: userAddress,
+            address: CONTRACT_ADDRESSES[chainId].Controller,
+            abi: CONTROLLER_ABI,
+            functionName: 'claim',
+            args: [
+                openOrders.map((order) => ({
+                    id: BigInt(order.id),
+                    hookData: zeroHash,
+                })),
+                tokensToSettle,
+                [],
+                getDeadlineTimestampInSeconds(),
+            ],
+        }),
+        result: openOrders.map((order) => ({
+            currency: order.claimable.currency,
+            amount: order.claimable.value,
+            direction: 'out',
+        })),
+    };
+});
 /**
  * Cancels specified open order if the order is not fully filled.
  * [IMPORTANT] Set ApprovalForAll before calling this function.
@@ -448,7 +451,8 @@ export const claimOrders = async (chainId, userAddress, ids, options) => {
  * @param {string} id An ID representing the open order to be canceled
  * @param {Object} [options] Optional parameters for canceling orders.
  * @param {string} [options.rpcUrl] The RPC URL to use for executing the transaction.
- * @returns {Promise<Transaction>} Promise resolving to the transaction object representing the cancel action.
+ * @returns {Promise<{ transaction: Transaction, result: CurrencyFlow }>}
+ * Promise resolving to the transaction object representing the cancel action with the result of the order.
  * @throws {Error} Throws an error if no open orders are found for the specified user.
  * @example
  * import { getOpenOrders, cancelOrders } from '@clober/v2-sdk'
@@ -463,9 +467,18 @@ export const claimOrders = async (chainId, userAddress, ids, options) => {
  *    openOrders.map((order) => order.id)
  * )
  */
-export const cancelOrder = async (chainId, userAddress, id, options) => {
-    return cancelOrders(chainId, userAddress, [id], options);
-};
+export const cancelOrder = decorator(async ({ chainId, userAddress, id, options, }) => {
+    const { transaction, result } = await cancelOrders({
+        chainId,
+        userAddress,
+        ids: [id],
+        options: { ...options },
+    });
+    return {
+        transaction,
+        result: result[0],
+    };
+});
 /**
  * Cancels specified open orders if orders are not fully filled.
  * [IMPORTANT] Set ApprovalForAll before calling this function.
@@ -475,7 +488,8 @@ export const cancelOrder = async (chainId, userAddress, id, options) => {
  * @param {string[]} ids An array of IDs representing the open orders to be canceled.
  * @param {Object} [options] Optional parameters for canceling orders.
  * @param {string} [options.rpcUrl] The RPC URL to use for executing the transaction.
- * @returns {Promise<Transaction>} Promise resolving to the transaction object representing the cancel action.
+ * @returns {Promise<{ transaction: Transaction, result: CurrencyFlow[] }>
+ * Promise resolving to the transaction object representing the cancel action with the result of the orders.
  * @throws {Error} Throws an error if no open orders are found for the specified user.
  * @example
  * import { getOpenOrders, cancelOrders } from '@clober/v2-sdk'
@@ -490,13 +504,11 @@ export const cancelOrder = async (chainId, userAddress, id, options) => {
  *    openOrders.map((order) => order.id)
  * )
  */
-export const cancelOrders = async (chainId, userAddress, ids, options) => {
-    const { rpcUrl } = options || {
-        rpcUrl: undefined,
-    };
-    const isApprovedForAll = await fetchIsApprovedForAll(chainId, userAddress, options?.rpcUrl);
+export const cancelOrders = decorator(async ({ chainId, userAddress, ids, options, }) => {
+    const isApprovedForAll = await fetchIsApprovedForAll(chainId, userAddress);
     if (!isApprovedForAll) {
         throw new Error(`
+       Set ApprovalForAll before calling this function.
        import { setApprovalOfOpenOrdersForAll } from '@clober/v2-sdk'
 
        const hash = await setApprovalOfOpenOrdersForAll(
@@ -505,31 +517,41 @@ export const cancelOrders = async (chainId, userAddress, ids, options) => {
        )
     `);
     }
-    const openOrders = (await getOpenOrders(chainId, userAddress, rpcUrl ? { rpcUrl } : {})).filter((order) => ids.includes(order.id) && order.cancelable);
+    const openOrders = (await getOpenOrders({ chainId, userAddress, options: { ...options } })).filter((order) => ids.includes(order.id) && order.claimable.value !== '0');
     if (openOrders.length === 0) {
         throw new Error(`No cancelable open orders found for ${userAddress}`);
     }
     const tokensToSettle = openOrders
-        .map((order) => [order.outputCurrency.address, order.inputCurrency.address])
+        .map((order) => [
+        order.outputCurrency.address,
+        order.inputCurrency.address,
+    ])
         .flat()
         .filter((address, index, self) => self.findIndex((c) => isAddressEqual(c, address)) === index)
         .filter((address) => !isAddressEqual(address, zeroAddress));
-    return buildTransaction(chainId, {
-        chain: CHAIN_MAP[chainId],
-        account: userAddress,
-        address: CONTRACT_ADDRESSES[chainId].Controller,
-        abi: CONTROLLER_ABI,
-        functionName: 'cancel',
-        args: [
-            openOrders.map((order) => ({
-                id: BigInt(order.id),
-                leftQuoteAmount: 0n,
-                hookData: zeroHash,
-            })),
-            tokensToSettle,
-            [],
-            getDeadlineTimestampInSeconds(),
-        ],
-    }, options?.rpcUrl);
-};
+    return {
+        transaction: await buildTransaction(chainId, {
+            chain: CHAIN_MAP[chainId],
+            account: userAddress,
+            address: CONTRACT_ADDRESSES[chainId].Controller,
+            abi: CONTROLLER_ABI,
+            functionName: 'cancel',
+            args: [
+                openOrders.map((order) => ({
+                    id: BigInt(order.id),
+                    leftQuoteAmount: 0n,
+                    hookData: zeroHash,
+                })),
+                tokensToSettle,
+                [],
+                getDeadlineTimestampInSeconds(),
+            ],
+        }),
+        result: openOrders.map((order) => ({
+            currency: order.cancelable.currency,
+            amount: order.cancelable.value,
+            direction: 'out',
+        })),
+    };
+});
 //# sourceMappingURL=call.js.map