@imtbl/sdk 0.27.15 → 0.28.0

package/dist/checkout_sdk.js

@@ -7,7 +7,7 @@ import { TradeType, Percent } from '@uniswap/sdk-core';
 import assert from 'assert';
 import { FeeAmount, Route, SwapQuoter, Pool, Trade, toHex as toHex$1, encodeRouteToPath } from '@uniswap/v3-sdk';
 import { keccak256 as keccak256$1 } from '@ethersproject/solidity';
-import { SwapRouter } from '@uniswap/router-sdk';
+import { SwapRouter, PaymentsExtended } from '@uniswap/router-sdk';
 import FormData from 'form-data';
 import { Seaport as Seaport$1 } from '@opensea/seaport-js';
 
@@ -14739,6 +14739,7 @@ const newAmount = (amount, token) => ({
 });
 const isERC20Amount = (amount) => amount.token.type === 'erc20';
 const isNativeAmount = (amount) => amount.token.type === 'native';
+const isNative = (token) => token.type === 'native';
 const addERC20Amount = (a, b) => {
     // Make sure the ERC20s have the same address
     if (a.token.address !== b.token.address)
@@ -15392,92 +15393,193 @@ const IMMUTABLE_TESTNET_COMMON_ROUTING_TOKENS = [
 
 const zeroNativeCurrencyValue = '0x00';
 const multicallWithDeadlineFunctionSignature = 'multicall(uint256,bytes[])';
-function buildSwapParametersForSinglePoolSwap(fromAddress, trade, route, amountIn, amountOut, secondaryFees, secondaryFeeContract) {
+function buildSinglePoolSwap(tokenIn, tokenOut, recipient, trade, route, amountIn, amountOut, routerContract, paymentsContract) {
+    const calldatas = [];
+    if (trade.tradeType === Uniswap.TradeType.EXACT_INPUT) {
+        calldatas.push(routerContract.encodeFunctionData('exactInputSingle', [
+            {
+                tokenIn: route.tokenPath[0].address,
+                tokenOut: route.tokenPath[1].address,
+                fee: route.pools[0].fee,
+                recipient,
+                amountIn,
+                amountOutMinimum: amountOut,
+                sqrtPriceLimitX96: 0,
+            },
+        ]));
+    }
+    if (trade.tradeType === Uniswap.TradeType.EXACT_OUTPUT) {
+        calldatas.push(routerContract.encodeFunctionData('exactOutputSingle', [
+            {
+                tokenIn: route.tokenPath[0].address,
+                tokenOut: route.tokenPath[1].address,
+                fee: route.pools[0].fee,
+                recipient,
+                amountInMaximum: amountIn,
+                amountOut,
+                sqrtPriceLimitX96: 0,
+            },
+        ]));
+    }
+    const shouldRefundNativeTokens = trade.tradeType === Uniswap.TradeType.EXACT_OUTPUT && isNative(tokenIn);
+    if (shouldRefundNativeTokens) {
+        // Refund ETH if the input token is native and the swap is exact output
+        calldatas.push(paymentsContract.encodeFunctionData('refundETH'));
+    }
+    const shouldUnwrapTokens = isNative(tokenOut);
+    if (shouldUnwrapTokens) {
+        // Unwrap the output token if the user specified a native token as the output
+        calldatas.push(paymentsContract.encodeFunctionData('unwrapWETH9(uint256)', [amountOut]));
+    }
+    return calldatas;
+}
+function buildSinglePoolSwapWithFees(recipient, trade, route, amountIn, amountOut, secondaryFees, secondaryFeeContract) {
     const secondaryFeeValues = secondaryFees.map((fee) => ({
         feeBasisPoints: fee.basisPoints,
         recipient: fee.recipient,
     }));
-    if (trade.tradeType === TradeType.EXACT_INPUT) {
-        return secondaryFeeContract.encodeFunctionData('exactInputSingleWithSecondaryFee', [
+    const calldatas = [];
+    if (trade.tradeType === Uniswap.TradeType.EXACT_INPUT) {
+        calldatas.push(secondaryFeeContract.encodeFunctionData('exactInputSingleWithSecondaryFee', [
             secondaryFeeValues,
             {
                 tokenIn: route.tokenPath[0].address,
                 tokenOut: route.tokenPath[1].address,
                 fee: route.pools[0].fee,
-                recipient: fromAddress,
+                recipient,
                 amountIn,
                 amountOutMinimum: amountOut,
                 sqrtPriceLimitX96: 0,
             },
-        ]);
+        ]));
     }
-    return secondaryFeeContract.encodeFunctionData('exactOutputSingleWithSecondaryFee', [
-        secondaryFeeValues,
-        {
-            tokenIn: route.tokenPath[0].address,
-            tokenOut: route.tokenPath[1].address,
-            fee: route.pools[0].fee,
-            recipient: fromAddress,
-            amountInMaximum: amountIn,
-            amountOut,
-            sqrtPriceLimitX96: 0,
-        },
-    ]);
+    if (trade.tradeType === Uniswap.TradeType.EXACT_OUTPUT) {
+        calldatas.push(secondaryFeeContract.encodeFunctionData('exactOutputSingleWithSecondaryFee', [
+            secondaryFeeValues,
+            {
+                tokenIn: route.tokenPath[0].address,
+                tokenOut: route.tokenPath[1].address,
+                fee: route.pools[0].fee,
+                recipient,
+                amountInMaximum: amountIn,
+                amountOut,
+                sqrtPriceLimitX96: 0,
+            },
+        ]));
+    }
+    // TODO: Add refundETH method when support is added in SecondaryFee contract
+    return calldatas;
+}
+function buildMultiPoolSwap(tokenIn, tokenOut, recipient, trade, route, amountIn, amountOut, routerContract, paymentsContract) {
+    const path = encodeRouteToPath(route, trade.tradeType === Uniswap.TradeType.EXACT_OUTPUT);
+    const calldatas = [];
+    if (trade.tradeType === Uniswap.TradeType.EXACT_INPUT) {
+        calldatas.push(routerContract.encodeFunctionData('exactInput', [
+            {
+                path,
+                recipient,
+                amountIn,
+                amountOutMinimum: amountOut,
+            },
+        ]));
+    }
+    if (trade.tradeType === Uniswap.TradeType.EXACT_OUTPUT) {
+        calldatas.push(routerContract.encodeFunctionData('exactOutput', [
+            {
+                path,
+                recipient,
+                amountInMaximum: amountIn,
+                amountOut,
+            },
+        ]));
+    }
+    const shouldRefundNativeTokens = trade.tradeType === Uniswap.TradeType.EXACT_OUTPUT && isNative(tokenIn);
+    if (shouldRefundNativeTokens) {
+        // Refund ETH if the input token is native and the swap is exact output
+        calldatas.push(paymentsContract.encodeFunctionData('refundETH'));
+    }
+    const shouldUnwrapTokens = isNative(tokenOut);
+    if (shouldUnwrapTokens) {
+        // Unwrap the output token if the user specified a native token as the output
+        calldatas.push(paymentsContract.encodeFunctionData('unwrapWETH9(uint256)', [amountOut]));
+    }
+    return calldatas;
 }
-function buildSwapParametersForMultiPoolSwap(fromAddress, trade, route, amountIn, amountOut, secondaryFees, secondaryFeeContract) {
-    const path = encodeRouteToPath(route, trade.tradeType === TradeType.EXACT_OUTPUT);
+function buildMultiPoolSwapWithFees(recipient, trade, route, amountIn, amountOut, secondaryFees, secondaryFeeContract) {
+    const path = encodeRouteToPath(route, trade.tradeType === Uniswap.TradeType.EXACT_OUTPUT);
     const secondaryFeeValues = secondaryFees.map((fee) => ({
         feeBasisPoints: fee.basisPoints,
         recipient: fee.recipient,
     }));
-    if (trade.tradeType === TradeType.EXACT_INPUT) {
-        return secondaryFeeContract.encodeFunctionData('exactInputWithSecondaryFee', [
+    const calldatas = [];
+    if (trade.tradeType === Uniswap.TradeType.EXACT_INPUT) {
+        calldatas.push(secondaryFeeContract.encodeFunctionData('exactInputWithSecondaryFee', [
             secondaryFeeValues,
             {
                 path,
-                recipient: fromAddress,
+                recipient,
                 amountIn,
                 amountOutMinimum: amountOut,
             },
-        ]);
+        ]));
     }
-    return secondaryFeeContract.encodeFunctionData('exactOutputWithSecondaryFee', [
-        secondaryFeeValues,
-        {
-            path,
-            recipient: fromAddress,
-            amountInMaximum: amountIn,
-            amountOut,
-        },
-    ]);
+    if (trade.tradeType === Uniswap.TradeType.EXACT_OUTPUT) {
+        calldatas.push(secondaryFeeContract.encodeFunctionData('exactOutputWithSecondaryFee', [
+            secondaryFeeValues,
+            {
+                path,
+                recipient,
+                amountInMaximum: amountIn,
+                amountOut,
+            },
+        ]));
+    }
+    // TODO: Add refundETH method when support is added in SecondaryFee contract
+    return calldatas;
 }
 /**
- * Builds swap parameters
- * @param fromAddress the msg.sender of the transaction
- * @param secondaryFeeAddress the secondary fee contract address
- * @param trade details of the swap, including the route, input/output tokens and amounts
- * @param options additional swap options
- * @returns calldata for the swap
+ * Builds and array of calldatas for the swap to be executed in the multicall method
+ * @param tokenIn The token to be swapped
+ * @param tokenOut The token to be received
+ * @param fromAddress The address of the user
+ * @param trade The trade to be executed
+ * @param secondaryFees Secondary fees to be applied to the swap
+ * @param secondaryFeeContract The SecondaryFee contract interface
+ * @param routerContract The SwapRouter02 contract interface
+ * @param paymentsContract The PaymentsExtended contract interface
+ * @param maximumAmountIn The maximum amount of tokenIn to be swapped
+ * @param minimumAmountOut The minimum amount of tokenOut to be received
+ * @returns calldatas that make up the swap transaction
  */
-function buildSwapParameters(fromAddress, trade, options, secondaryFees, secondaryFeeContract, maximumAmountIn, minimumAmountOut) {
+function buildSwapParameters(tokenIn, tokenOut, recipient, trade, secondaryFees, secondaryFeeContract, routerContract, paymentsContract, maximumAmountIn, minimumAmountOut) {
     // @dev we don't support multiple swaps in a single transaction
     // there will always be only one swap in the trade regardless of the trade type
     const { route } = trade.swaps[0];
     const isSinglePoolSwap = route.pools.length === 1;
+    const hasSecondaryFees = secondaryFees.length > 0;
     if (isSinglePoolSwap) {
-        return buildSwapParametersForSinglePoolSwap(fromAddress, trade, route, maximumAmountIn, minimumAmountOut, secondaryFees, secondaryFeeContract);
+        if (hasSecondaryFees) {
+            return buildSinglePoolSwapWithFees(recipient, trade, route, maximumAmountIn, minimumAmountOut, secondaryFees, secondaryFeeContract);
+        }
+        return buildSinglePoolSwap(tokenIn, tokenOut, recipient, trade, route, maximumAmountIn, minimumAmountOut, routerContract, paymentsContract);
+    }
+    if (hasSecondaryFees) {
+        return buildMultiPoolSwapWithFees(recipient, trade, route, maximumAmountIn, minimumAmountOut, secondaryFees, secondaryFeeContract);
     }
-    return buildSwapParametersForMultiPoolSwap(fromAddress, trade, route, maximumAmountIn, minimumAmountOut, secondaryFees, secondaryFeeContract);
+    return buildMultiPoolSwap(tokenIn, tokenOut, recipient, trade, route, maximumAmountIn, minimumAmountOut, routerContract, paymentsContract);
 }
-function createSwapCallParametersWithFees(trade, fromAddress, swapOptions, secondaryFees, maximumAmountIn, minimumAmountOut) {
+function createSwapCallParameters(tokenIn, tokenOut, trade, recipient, swapOptions, secondaryFees, maximumAmountIn, minimumAmountOut) {
     const secondaryFeeContract = SecondaryFee__factory.createInterface();
-    const swapWithFeesCalldata = buildSwapParameters(fromAddress, trade, swapOptions, secondaryFees, secondaryFeeContract, maximumAmountIn, minimumAmountOut);
+    const routerContract = SwapRouter.INTERFACE;
+    const paymentsContract = PaymentsExtended.INTERFACE;
+    const calldatas = buildSwapParameters(tokenIn, tokenOut, recipient, trade, secondaryFees, secondaryFeeContract, routerContract, paymentsContract, maximumAmountIn, minimumAmountOut);
+    // Create the multicall transaction using the calldatas generated above
     return secondaryFeeContract.encodeFunctionData(multicallWithDeadlineFunctionSignature, [
         swapOptions.deadlineOrPreviousBlockhash,
-        [swapWithFeesCalldata],
+        calldatas,
     ]);
 }
-function createSwapParameters(adjustedQuote, fromAddress, slippage, deadline, secondaryFees) {
+function createSwapParameters(tokenIn, tokenOut, adjustedQuote, fromAddress, slippage, deadline, secondaryFees) {
     // Create an unchecked trade to be used in generating swap parameters.
     const uncheckedTrade = Trade.createUncheckedTrade({
         route: adjustedQuote.route,
@@ -15492,29 +15594,26 @@ function createSwapParameters(adjustedQuote, fromAddress, slippage, deadline, se
         deadlineOrPreviousBlockhash: deadline,
     };
     // If the trade type is EXACT_INPUT, then the maximum amount-in is the user-specified amount (no slippage applied)
+    // For EXACT_OUTPUT, the maximum amount-in is the amount-in with slippage applied
     // https://github.com/Uniswap/v3-sdk/blob/81d66099f07d1ec350767f497ef73222575fe032/src/entities/trade.ts#L456
     const maximumAmountIn = toHex$1(uncheckedTrade.maximumAmountIn(options.slippageTolerance).quotient);
     const minimumAmountOut = toHex$1(uncheckedTrade.minimumAmountOut(options.slippageTolerance).quotient);
-    if (secondaryFees.length === 0) {
-        // Generate swap parameters without secondary fee contract details
-        return { calldata: SwapRouter.swapCallParameters([uncheckedTrade], options).calldata, maximumAmountIn };
-    }
     return {
-        calldata: createSwapCallParametersWithFees(uncheckedTrade, fromAddress, options, secondaryFees, maximumAmountIn, minimumAmountOut),
+        calldata: createSwapCallParameters(tokenIn, tokenOut, uncheckedTrade, fromAddress, options, secondaryFees, maximumAmountIn, minimumAmountOut),
         maximumAmountIn,
     };
 }
 const getTransactionValue = (tokenIn, maximumAmountIn) => tokenIn.type === 'native' ? maximumAmountIn : zeroNativeCurrencyValue;
-function getSwap(tokenIn, adjustedQuote, fromAddress, slippage, deadline, peripheryRouterAddress, secondaryFeesAddress, gasPrice, secondaryFees) {
-    // TODO: TP-1651: Include `refundETH` transaction as final step for native Exact Output swaps
-    const { calldata, maximumAmountIn } = createSwapParameters(adjustedQuote, fromAddress, slippage, deadline, secondaryFees);
+function getSwap(tokenIn, tokenOut, adjustedQuote, fromAddress, slippage, deadline, routerContractAddress, secondaryFeesContractAddress, gasPrice, secondaryFees) {
+    const swapRecipient = isNative(tokenOut) ? routerContractAddress : fromAddress;
+    const { calldata, maximumAmountIn } = createSwapParameters(tokenIn, tokenOut, adjustedQuote, swapRecipient, slippage, deadline, secondaryFees);
     // TODO: Add additional gas fee estimates for secondary fees
     const gasFeeEstimate = gasPrice ? calculateGasFee(gasPrice, adjustedQuote.gasEstimate) : null;
     const transactionValue = getTransactionValue(tokenIn, maximumAmountIn);
     return {
         transaction: {
             data: calldata,
-            to: secondaryFees.length > 0 ? secondaryFeesAddress : peripheryRouterAddress,
+            to: secondaryFees.length > 0 ? secondaryFeesContractAddress : routerContractAddress,
             value: transactionValue,
             from: fromAddress,
         },
@@ -15522,7 +15621,7 @@ function getSwap(tokenIn, adjustedQuote, fromAddress, slippage, deadline, periph
     };
 }
 const adjustAmountIn = (ourQuote, amountSpecified, fees, nativeTokenService) => {
-    if (ourQuote.tradeType === TradeType.EXACT_OUTPUT) {
+    if (ourQuote.tradeType === Uniswap.TradeType.EXACT_OUTPUT) {
         // when doing exact output, calculate the fees based on the amountIn
         const amountToAdd = canUnwrapToken(fees.token)
             ? nativeTokenService.unwrapAmount(ourQuote.amountIn)
@@ -15728,7 +15827,7 @@ class Exchange {
             fetchGasPrice(this.provider, this.nativeToken),
         ]);
         const adjustedQuote = adjustQuoteWithFees(ourQuote, amountSpecified, fees, this.nativeTokenService);
-        const swap = getSwap(tokenIn, adjustedQuote, fromAddress, slippagePercent, deadline, this.routerContractAddress, this.secondaryFeeContractAddress, gasPrice, secondaryFees);
+        const swap = getSwap(tokenIn, tokenOut, adjustedQuote, fromAddress, slippagePercent, deadline, this.routerContractAddress, this.secondaryFeeContractAddress, gasPrice, secondaryFees);
         const { quotedAmount, quotedAmountWithMaxSlippage } = prepareUserQuote(this.nativeTokenService, adjustedQuote, slippagePercent, otherToken);
         const preparedApproval = prepareApproval(tradeType, amountSpecified, quotedAmountWithMaxSlippage, {
             routerAddress: this.routerContractAddress,
@@ -16372,7 +16471,7 @@ var CancelledOrderStatus;
 var FailedOrderCancellation;
 (function (FailedOrderCancellation) {
     (function (reason_code) {
-        reason_code["ALREADY_FILLED"] = "ALREADY_FILLED";
+        reason_code["FILLED"] = "FILLED";
     })(FailedOrderCancellation.reason_code || (FailedOrderCancellation.reason_code = {}));
 })(FailedOrderCancellation || (FailedOrderCancellation = {}));
 
@@ -16426,10 +16525,12 @@ var TransactionPurpose;
 (function (TransactionPurpose) {
     TransactionPurpose["APPROVAL"] = "APPROVAL";
     TransactionPurpose["FULFILL_ORDER"] = "FULFILL_ORDER";
+    TransactionPurpose["CANCEL"] = "CANCEL";
 })(TransactionPurpose || (TransactionPurpose = {}));
 var SignablePurpose;
 (function (SignablePurpose) {
     SignablePurpose["CREATE_LISTING"] = "CREATE_LISTING";
+    SignablePurpose["OFF_CHAIN_CANCELLATION"] = "OFF_CHAIN_CANCELLATION";
 })(SignablePurpose || (SignablePurpose = {}));
 var ActionType;
 (function (ActionType) {
@@ -16826,11 +16927,15 @@ class Seaport {
                 .reduce((p, c) => (new Date(p) < new Date(c) ? p : c)),
         };
     }
-    async cancelOrder(order, account) {
-        const { orderComponents } = this.mapImmutableOrderToSeaportOrderComponents(order);
-        const seaportLib = this.getSeaportLib(order);
-        const cancellationTransaction = await seaportLib.cancelOrders([orderComponents], account);
-        return prepareTransaction(cancellationTransaction)();
+    async cancelOrders(orders, account) {
+        const orderComponents = orders.map((order) => this.mapImmutableOrderToSeaportOrderComponents(order).orderComponents);
+        const seaportLib = this.getSeaportLib(orders[0]);
+        const cancellationTransaction = await seaportLib.cancelOrders(orderComponents, account);
+        return {
+            type: ActionType.TRANSACTION,
+            buildTransaction: prepareTransaction(cancellationTransaction),
+            purpose: TransactionPurpose.CANCEL,
+        };
     }
     mapImmutableOrderToSeaportOrderComponents(order) {
         const orderCounter = order.protocol_data.counter;
@@ -16932,6 +17037,16 @@ class ImmutableApiClient {
             ...listTradesParams,
         });
     }
+    async cancelOrders(orderIds, accountAddress, signature) {
+        return this.orderbookService.cancelOrders({
+            chainName: this.chainName,
+            requestBody: {
+                account_address: accountAddress,
+                orders: orderIds,
+                signature,
+            },
+        });
+    }
     async createListing({ orderHash, orderComponents, orderSignature, makerFees, }) {
         if (orderComponents.offer.length !== 1) {
             throw new Error('Only one item can be listed at a time');
@@ -17233,24 +17348,89 @@ class Orderbook {
         }
     }
     /**
-     * Get an unsigned cancel order transaction. Orders can only be cancelled by
-     * the account that created them.
-     * @param {string} listingId - The listingId to cancel.
+     * Cancelling orders is a gasless alternative to on-chain cancellation exposed with
+     * `cancelOrdersOnChain`. For the orderbook to authenticate the cancellation, the creator
+     * of the orders must sign an EIP712 message containing the orderIds
+     * @param {string} orderIds - The orderIds to attempt to cancel.
+     * @return {PrepareCancelOrdersResponse} The signable action to cancel the orders.
+     */
+    async prepareOrderCancellations(orderIds) {
+        const network = await this.orderbookConfig.provider.getNetwork();
+        const domain = {
+            name: 'imtbl-order-book',
+            chainId: network.chainId,
+            verifyingContract: this.orderbookConfig.seaportContractAddress,
+        };
+        const types = {
+            // eslint-disable-next-line @typescript-eslint/naming-convention
+            CancelPayload: [
+                { name: 'orders', type: 'Order[]' },
+            ],
+            // eslint-disable-next-line @typescript-eslint/naming-convention
+            Order: [
+                { name: 'id', type: 'string' },
+            ],
+        };
+        const cancelMessage = {
+            orders: orderIds.map((id) => ({ id })),
+        };
+        return {
+            signableAction: {
+                purpose: SignablePurpose.OFF_CHAIN_CANCELLATION,
+                type: ActionType.SIGNABLE,
+                message: {
+                    domain,
+                    types,
+                    value: cancelMessage,
+                },
+            },
+        };
+    }
+    /**
+     * Cancelling orders is a gasless alternative to on-chain cancellation exposed with
+     * `cancelOrdersOnChain`. Orders cancelled this way cannot be fulfilled and will be removed
+     * from the orderbook. If there is pending fulfillment data outstanding for the order, its
+     * cancellation will be pending until the fulfillment window has passed.
+     * `prepareOffchainOrderCancellations` can be used to get the signable action that is signed
+     * to get the signature required for this call.
+     * @param {string[]} orderIds - The orderIds to attempt to cancel.
+     * @param {string} accountAddress - The address of the account cancelling the orders.
+     * @param {string} accountAddress - The address of the account cancelling the orders.
+     * @return {CancelOrdersResult} The result of the off-chain cancellation request
+     */
+    async cancelOrders(orderIds, accountAddress, signature) {
+        return this.apiClient.cancelOrders(orderIds, accountAddress, signature);
+    }
+    /**
+     * Get an unsigned order cancellation transaction. Orders can only be cancelled by
+     * the account that created them. All of the orders must be from the same seaport contract.
+     * If trying to cancel orders from multiple seaport contracts, group the orderIds by seaport
+     * contract and call this method for each group.
+     * @param {string[]} orderIds - The orderIds to cancel.
      * @param {string} accountAddress - The address of the account cancelling the order.
-     * @return {CancelOrderResponse} The unsigned cancel order transaction
+     * @return {CancelOrdersOnChainResponse} The unsigned cancel order action
      */
-    async cancelOrder(listingId, accountAddress) {
-        const orderResult = await this.apiClient.getListing(listingId);
-        if (orderResult.result.status.name !== OrderStatusName$1.ACTIVE
-            && orderResult.result.status.name !== OrderStatusName$1.INACTIVE
-            && orderResult.result.status.name !== OrderStatusName$1.PENDING) {
-            throw new Error(`Cannot cancel order with status ${orderResult.result.status}`);
+    async cancelOrdersOnChain(orderIds, accountAddress) {
+        const orderResults = await Promise.all(orderIds.map((id) => this.apiClient.getListing(id)));
+        // eslint-disable-next-line no-restricted-syntax
+        for (const orderResult of orderResults) {
+            if (orderResult.result.status.name !== OrderStatusName$1.ACTIVE
+                && orderResult.result.status.name !== OrderStatusName$1.INACTIVE
+                && orderResult.result.status.name !== OrderStatusName$1.PENDING) {
+                throw new Error(`Cannot cancel order with status ${orderResult.result.status}`);
+            }
+            if (orderResult.result.account_address !== accountAddress.toLowerCase()) {
+                throw new Error(`Only account ${orderResult.result.account_address} can cancel order ${orderResult.result.id}`);
+            }
         }
-        if (orderResult.result.account_address !== accountAddress.toLowerCase()) {
-            throw new Error(`Only account ${orderResult.result.account_address} can cancel order ${listingId}`);
+        const orders = orderResults.map((orderResult) => orderResult.result);
+        const seaportAddresses = orders.map((o) => o.protocol_data.seaport_address);
+        const distinctSeaportAddresses = new Set(...[seaportAddresses]);
+        if (distinctSeaportAddresses.size !== 1) {
+            throw new Error('Cannot cancel multiple orders from different seaport contracts. Please group your orderIds accordingly');
         }
-        const cancelOrderTransaction = await this.seaport.cancelOrder(orderResult.result, accountAddress);
-        return { unsignedCancelOrderTransaction: cancelOrderTransaction };
+        const cancellationAction = await this.seaport.cancelOrders(orders, accountAddress);
+        return { cancellationAction };
     }
 }
 
@@ -20607,7 +20787,7 @@ class APIError extends Error {
 
 /* eslint-disable implicit-arrow-linebreak */
 const defaultHeaders = {
-    sdkVersion: 'ts-immutable-sdk-multi-rollup-api-client-0.27.15',
+    sdkVersion: 'ts-immutable-sdk-multi-rollup-api-client-0.28.0',
 };
 /**
  * createAPIConfiguration to create a custom Configuration
@@ -24717,8 +24897,10 @@ const $9c3db1bb9c8b69d3$export$70b61ad426ddbe54 = async (config, provider, order
     try {
         const offererAddress = await (0, $458d407830d66110$export$5280dbcb91c8b391)(config, "Time to get the address from the provider", provider.getSigner().getAddress());
         const orderbook = $67fc622a2b913d5f$export$c60ce6c6a92bc2ff(config);
-        const cancelOrderResponse = await (0, $458d407830d66110$export$5280dbcb91c8b391)(config, "Time to get the cancel order from the orderbook", orderbook.cancelOrder(orderId, offererAddress));
-        unsignedCancelOrderTransaction = cancelOrderResponse.unsignedCancelOrderTransaction;
+        const cancelOrderResponse = await (0, $458d407830d66110$export$5280dbcb91c8b391)(config, "Time to get the cancel order from the orderbook", orderbook.cancelOrdersOnChain([
+            orderId
+        ], offererAddress));
+        unsignedCancelOrderTransaction = await cancelOrderResponse.cancellationAction.buildTransaction();
     } catch (err) {
         throw new ($a8bc256d81a5e2c1$export$b722478a3cbfa3bc)("An error occurred while cancelling the order listing", ($a8bc256d81a5e2c1$export$e3dc0620abde7f5a).CANCEL_ORDER_LISTING_ERROR, {
             orderId: orderId,

package/dist/checkout_widgets.js

@@ -25,7 +25,7 @@ var $045213b18e9f1f94$export$75be0f6af9650f2c;
 })($045213b18e9f1f94$export$75be0f6af9650f2c || ($045213b18e9f1f94$export$75be0f6af9650f2c = {}));
 
 
-const $d663162fd5a0853f$export$38a083d9fb5551ca = "0.27.15";
+const $d663162fd5a0853f$export$38a083d9fb5551ca = "0.28.0";
 const $d663162fd5a0853f$export$83bf90b30cdfd29f = ()=>false;
 const $d663162fd5a0853f$export$1169f5475725171b = ()=>$d663162fd5a0853f$export$38a083d9fb5551ca;
 

package/dist/immutablex_client.js

@@ -16,7 +16,7 @@ const createImmutableXConfiguration = ({ basePath, chainID, coreContractAddress,
     chainID,
     coreContractAddress,
     registrationContractAddress,
-    sdkVersion: 'ts-immutable-sdk-0.27.15',
+    sdkVersion: 'ts-immutable-sdk-0.28.0',
 });
 /**
  * Sets `sdkVersion` at the time of build