@imtbl/sdk 1.5.0 → 1.5.1

package/dist/index.cjs

@@ -173,7 +173,7 @@ const flattenProperties$1 = (properties) => {
 };
 
 // WARNING: DO NOT CHANGE THE STRING BELOW. IT GETS REPLACED AT BUILD TIME.
-const SDK_VERSION$1 = '1.5.0';
+const SDK_VERSION$1 = '1.5.1';
 let initialised$1 = false;
 const isInitialised$1 = () => initialised$1;
 const getReferrer$1 = () => {
@@ -11260,7 +11260,7 @@ class MultiRollupApiClients {
 }
 
 // eslint-disable-next-line @typescript-eslint/naming-convention
-const defaultHeaders$1 = { 'x-sdk-version': 'ts-immutable-sdk-1.5.0' };
+const defaultHeaders$1 = { 'x-sdk-version': 'ts-immutable-sdk-1.5.1' };
 const createConfig = ({ basePath, headers, }) => {
     if (!basePath.trim()) {
         throw Error('basePath can not be empty');
@@ -11332,7 +11332,7 @@ class APIError extends Error {
 
 /* eslint-disable implicit-arrow-linebreak */
 const defaultHeaders = {
-    sdkVersion: 'ts-immutable-sdk-multi-rollup-api-client-1.5.0',
+    sdkVersion: 'ts-immutable-sdk-multi-rollup-api-client-1.5.1',
 };
 /**
  * createAPIConfiguration to create a custom Configuration
@@ -11765,7 +11765,7 @@ const createImmutableXConfiguration = ({ basePath, chainID, coreContractAddress,
     chainID,
     coreContractAddress,
     registrationContractAddress,
-    sdkVersion: 'ts-immutable-sdk-1.5.0',
+    sdkVersion: 'ts-immutable-sdk-1.5.1',
 });
 /**
  * Sets `sdkVersion` at the time of build
@@ -16835,12 +16835,14 @@ class GuardianClient {
     messageAPI;
     confirmationScreen;
     crossSdkBridgeEnabled;
-    constructor({ confirmationScreen, config }) {
+    authManager;
+    constructor({ confirmationScreen, config, authManager }) {
         const guardianConfiguration = new Configuration({ basePath: config.imxPublicApiDomain });
         this.confirmationScreen = confirmationScreen;
         this.crossSdkBridgeEnabled = config.crossSdkBridgeEnabled;
         this.messageAPI = new MessagesApi(guardianConfiguration);
         this.transactionAPI = new TransactionsApi(guardianConfiguration);
+        this.authManager = authManager;
     }
     /**
      * Open confirmation screen and close it automatically if the
@@ -16864,10 +16866,11 @@ class GuardianClient {
     withDefaultConfirmationScreenTask(task) {
         return this.withConfirmationScreenTask()(task);
     }
-    async evaluateImxTransaction({ payloadHash, user }) {
+    async evaluateImxTransaction({ payloadHash }) {
         const finallyFn = () => {
             this.confirmationScreen.closeWindow();
         };
+        const user = await this.authManager.getUser();
         const headers = { Authorization: `Bearer ${user.accessToken}` };
         const transactionRes = await retryWithDelay(async () => this.transactionAPI.getTransactionByID({
             transactionID: payloadHash,
@@ -16896,7 +16899,8 @@ class GuardianClient {
             this.confirmationScreen.closeWindow();
         }
     }
-    async evaluateEVMTransaction({ chainId, nonce, user, metaTransactions, }) {
+    async evaluateEVMTransaction({ chainId, nonce, metaTransactions, }) {
+        const user = await this.authManager.getUser();
         const headers = { Authorization: `Bearer ${user.accessToken}` };
         const guardianTransactions = transformGuardianTransactions(metaTransactions);
         try {
@@ -16919,11 +16923,10 @@ class GuardianClient {
             throw new JsonRpcError(RpcErrorCode.INTERNAL_ERROR, `Transaction failed to validate with error: ${errorMessage}`);
         }
     }
-    async validateEVMTransaction({ chainId, nonce, user, metaTransactions, }) {
+    async validateEVMTransaction({ chainId, nonce, metaTransactions, }) {
         const transactionEvaluationResponse = await this.evaluateEVMTransaction({
             chainId,
             nonce,
-            user,
             metaTransactions,
         });
         const { confirmationRequired, transactionId } = transactionEvaluationResponse;
@@ -16931,6 +16934,7 @@ class GuardianClient {
             throw new JsonRpcError(RpcErrorCode.TRANSACTION_REJECTED, transactionRejectedCrossSdkBridgeError);
         }
         if (confirmationRequired && !!transactionId) {
+            const user = await this.authManager.getUser();
             const confirmationResult = await this.confirmationScreen.requestConfirmation(transactionId, user.zkEvm.ethAddress, TransactionApprovalRequestChainTypeEnum.Evm, chainId);
             if (!confirmationResult.confirmed) {
                 throw new JsonRpcError(RpcErrorCode.TRANSACTION_REJECTED, 'Transaction rejected by user');
@@ -16940,8 +16944,12 @@ class GuardianClient {
             this.confirmationScreen.closeWindow();
         }
     }
-    async evaluateMessage({ chainID, payload, user }) {
+    async evaluateMessage({ chainID, payload }) {
         try {
+            const user = await this.authManager.getUser();
+            if (user === null) {
+                throw new PassportError('evaluateMessage requires a valid ID token or refresh token. Please log in first', PassportErrorType.NOT_LOGGED_IN_ERROR);
+            }
             const messageEvalResponse = await this.messageAPI.evaluateMessage({ messageEvaluationRequest: { chainID, payload } }, { headers: { Authorization: `Bearer ${user.accessToken}` } });
             return messageEvalResponse.data;
         }
@@ -16950,12 +16958,13 @@ class GuardianClient {
             throw new JsonRpcError(RpcErrorCode.INTERNAL_ERROR, `Message failed to validate with error: ${errorMessage}`);
         }
     }
-    async validateMessage({ chainID, payload, user }) {
-        const { messageId, confirmationRequired } = await this.evaluateMessage({ chainID, payload, user });
+    async validateMessage({ chainID, payload }) {
+        const { messageId, confirmationRequired } = await this.evaluateMessage({ chainID, payload });
         if (confirmationRequired && this.crossSdkBridgeEnabled) {
             throw new JsonRpcError(RpcErrorCode.TRANSACTION_REJECTED, transactionRejectedCrossSdkBridgeError);
         }
         if (confirmationRequired && !!messageId) {
+            const user = await this.authManager.getUser();
             const confirmationResult = await this.confirmationScreen.requestMessageConfirmation(messageId, user.zkEvm.ethAddress);
             if (!confirmationResult.confirmed) {
                 throw new JsonRpcError(RpcErrorCode.TRANSACTION_REJECTED, 'Signature rejected by user');
@@ -17037,7 +17046,6 @@ async function createOrder$1({ starkSigner, user, request, ordersApi, guardianCl
             getSignableOrderRequestV3,
         }, { headers });
         await guardianClient.evaluateImxTransaction({
-            user,
             payloadHash: getSignableOrderResponse.data.payload_hash,
         });
         const { payload_hash: payloadHash } = getSignableOrderResponse.data;
@@ -17080,7 +17088,6 @@ async function cancelOrder$1({ user, starkSigner, request, ordersApi, guardianCl
             getSignableCancelOrderRequest,
         }, { headers });
         await guardianClient.evaluateImxTransaction({
-            user,
             payloadHash: getSignableCancelOrderResponse.data.payload_hash,
         });
         const { payload_hash: payloadHash } = getSignableCancelOrderResponse.data;
@@ -17142,7 +17149,6 @@ async function createTrade$1({ request, tradesApi, user, starkSigner, guardianCl
             getSignableTradeRequest,
         }, { headers });
         await guardianClient.evaluateImxTransaction({
-            user,
             payloadHash: getSignableTradeResponse.data.payload_hash,
         });
         const { payload_hash: payloadHash } = getSignableTradeResponse.data;
@@ -17190,7 +17196,6 @@ async function transfer$1({ request, transfersApi, starkSigner, user, guardianCl
             getSignableTransferRequest,
         }, { headers });
         await guardianClient.evaluateImxTransaction({
-            user,
             payloadHash: signableResult.data.payload_hash,
         });
         const signableResultData = signableResult.data;
@@ -17241,7 +17246,6 @@ async function batchNftTransfer({ user, starkSigner, request, transfersApi, guar
             },
         }, { headers });
         await guardianClient.evaluateImxTransaction({
-            user,
             payloadHash: signableResult.data.signable_responses[0]?.payload_hash,
         });
         const requests = await Promise.all(signableResult.data.signable_responses.map(async (resp) => {
@@ -17321,6 +17325,7 @@ class PassportImxProvider {
         this.guardianClient = new GuardianClient({
             confirmationScreen,
             config,
+            authManager,
         });
         this.magicAdapter = magicAdapter;
         this.imxApiClients = imxApiClients;
@@ -17952,11 +17957,11 @@ const getEip155ChainId = (chainId) => `eip155:${chainId}`;
 class RelayerClient {
     config;
     jsonRpcProvider;
-    user;
-    constructor({ config, jsonRpcProvider, user }) {
+    authManager;
+    constructor({ config, jsonRpcProvider, authManager }) {
         this.config = config;
         this.jsonRpcProvider = jsonRpcProvider;
-        this.user = user;
+        this.authManager = authManager;
     }
     async postToRelayer(request) {
         const body = {
@@ -17964,10 +17969,11 @@ class RelayerClient {
             jsonrpc: '2.0',
             ...request,
         };
+        const user = await this.authManager.getUser();
         const response = await fetch(`${this.config.relayerUrl}/v1/transactions`, {
             method: 'POST',
             headers: {
-                Authorization: `Bearer ${this.user.accessToken}`,
+                Authorization: `Bearer ${user?.accessToken}`,
                 'Content-Type': 'application/json',
             },
             body: JSON.stringify(body),
@@ -18126,7 +18132,7 @@ const getMetaTransactions = async (metaTransaction, nonce, chainId, walletAddres
     }
     return [metaTransaction, feeMetaTransaction];
 };
-const sendTransaction$1 = ({ params, magicProvider, jsonRpcProvider, relayerClient, guardianClient, user, }) => guardianClient
+const sendTransaction$1 = ({ params, magicProvider, jsonRpcProvider, relayerClient, guardianClient, zkevmAddress, }) => guardianClient
     .withConfirmationScreen({ width: 480, height: 720 })(async () => {
     const transactionRequest = params[0];
     if (!transactionRequest.to) {
@@ -18136,7 +18142,7 @@ const sendTransaction$1 = ({ params, magicProvider, jsonRpcProvider, relayerClie
     const chainIdBigNumber = ethers.BigNumber.from(chainId);
     const magicWeb3Provider = new providers.Web3Provider(magicProvider);
     const signer = magicWeb3Provider.getSigner();
-    const nonce = await getNonce(jsonRpcProvider, user.zkEvm.ethAddress);
+    const nonce = await getNonce(jsonRpcProvider, zkevmAddress);
     const metaTransaction = {
         to: transactionRequest.to,
         data: transactionRequest.data,
@@ -18144,17 +18150,16 @@ const sendTransaction$1 = ({ params, magicProvider, jsonRpcProvider, relayerClie
         value: transactionRequest.value,
         revertOnError: true,
     };
-    const metaTransactions = await getMetaTransactions(metaTransaction, nonce, chainIdBigNumber, user.zkEvm.ethAddress, signer, relayerClient);
+    const metaTransactions = await getMetaTransactions(metaTransaction, nonce, chainIdBigNumber, zkevmAddress, signer, relayerClient);
     await guardianClient.validateEVMTransaction({
         chainId: getEip155ChainId(chainId),
         nonce: convertBigNumberishToString(nonce),
-        user,
         metaTransactions,
     });
     // NOTE: We sign again because we now are adding the fee transaction, so the
     // whole payload is different and needs a new signature.
-    const signedTransactions = await getSignedMetaTransactions(metaTransactions, nonce, chainIdBigNumber, user.zkEvm.ethAddress, signer);
-    const relayerId = await relayerClient.ethSendTransaction(user.zkEvm.ethAddress, signedTransactions);
+    const signedTransactions = await getSignedMetaTransactions(metaTransactions, nonce, chainIdBigNumber, zkevmAddress, signer);
+    const relayerId = await relayerClient.ethSendTransaction(zkevmAddress, signedTransactions);
     const retrieveRelayerTransaction = async () => {
         const tx = await relayerClient.imGetTransactionByHash(relayerId);
         // NOTE: The transaction hash is only available from the Relayer once the
@@ -18222,7 +18227,7 @@ const transformTypedData = (typedData, chainId) => {
     }
     return transformedTypedData;
 };
-const signTypedDataV4 = async ({ params, method, magicProvider, jsonRpcProvider, relayerClient, guardianClient, user, }) => guardianClient
+const signTypedDataV4 = async ({ params, method, magicProvider, jsonRpcProvider, relayerClient, guardianClient, }) => guardianClient
     .withConfirmationScreen({ width: 480, height: 730 })(async () => {
     const fromAddress = params[0];
     const typedDataParam = params[1];
@@ -18231,7 +18236,7 @@ const signTypedDataV4 = async ({ params, method, magicProvider, jsonRpcProvider,
     }
     const { chainId } = await jsonRpcProvider.ready;
     const typedData = transformTypedData(typedDataParam, chainId);
-    await guardianClient.validateMessage({ chainID: String(chainId), payload: typedData, user });
+    await guardianClient.validateMessage({ chainID: String(chainId), payload: typedData });
     const relayerSignature = await relayerClient.imSignTypedData(fromAddress, typedData);
     const magicWeb3Provider = new providers.Web3Provider(magicProvider);
     const signer = magicWeb3Provider.getSigner();
@@ -18249,7 +18254,7 @@ class ZkEvmProvider {
     guardianClient;
     relayerClient;
     magicProvider; // Used for signing
-    user;
+    zkevmAddress;
     isPassport = true;
     constructor({ authManager, magicAdapter, config, confirmationScreen, multiRollupApiClients, passportEventEmitter, }) {
         this.authManager = authManager;
@@ -18274,7 +18279,6 @@ class ZkEvmProvider {
     handleLogout = () => {
         const shouldEmitAccountsChanged = this.isLoggedIn();
         this.magicProvider = undefined;
-        this.user = undefined;
         this.relayerClient = undefined;
         this.guardianClient = undefined;
         if (shouldEmitAccountsChanged) {
@@ -18283,7 +18287,7 @@ class ZkEvmProvider {
     };
     isLoggedIn() {
         return this.magicProvider !== undefined
-            && this.user !== undefined
+            && this.zkevmAddress !== undefined
             && this.relayerClient !== undefined
             && this.guardianClient !== undefined;
     }
@@ -18291,7 +18295,7 @@ class ZkEvmProvider {
         switch (request.method) {
             case 'eth_requestAccounts': {
                 if (this.isLoggedIn()) {
-                    return [this.user.zkEvm.ethAddress];
+                    return [this.zkevmAddress];
                 }
                 const { magicProvider, user } = await loginZkEvmUser({
                     authManager: this.authManager,
@@ -18300,19 +18304,20 @@ class ZkEvmProvider {
                     multiRollupApiClients: this.multiRollupApiClients,
                     jsonRpcProvider: this.jsonRpcProvider,
                 });
-                this.user = user;
                 this.magicProvider = magicProvider;
                 this.relayerClient = new RelayerClient({
                     config: this.config,
                     jsonRpcProvider: this.jsonRpcProvider,
-                    user: this.user,
+                    authManager: this.authManager,
                 });
                 this.guardianClient = new GuardianClient({
                     confirmationScreen: this.confirmationScreen,
                     config: this.config,
+                    authManager: this.authManager,
                 });
-                this.eventEmitter.emit(ProviderEvent.ACCOUNTS_CHANGED, [this.user.zkEvm.ethAddress]);
-                return [this.user.zkEvm.ethAddress];
+                this.zkevmAddress = user.zkEvm.ethAddress;
+                this.eventEmitter.emit(ProviderEvent.ACCOUNTS_CHANGED, [user.zkEvm.ethAddress]);
+                return [user.zkEvm.ethAddress];
             }
             case 'eth_sendTransaction': {
                 if (!this.isLoggedIn()) {
@@ -18324,11 +18329,11 @@ class ZkEvmProvider {
                     guardianClient: this.guardianClient,
                     jsonRpcProvider: this.jsonRpcProvider,
                     relayerClient: this.relayerClient,
-                    user: this.user,
+                    zkevmAddress: this.zkevmAddress,
                 });
             }
             case 'eth_accounts': {
-                return this.isLoggedIn() ? [this.user.zkEvm.ethAddress] : [];
+                return this.zkevmAddress ? [this.zkevmAddress] : [];
             }
             case 'eth_signTypedData':
             case 'eth_signTypedData_v4': {
@@ -18341,7 +18346,6 @@ class ZkEvmProvider {
                     magicProvider: this.magicProvider,
                     jsonRpcProvider: this.jsonRpcProvider,
                     relayerClient: this.relayerClient,
-                    user: this.user,
                     guardianClient: this.guardianClient,
                 });
             }
@@ -37062,7 +37066,7 @@ const flattenProperties = (properties) => {
 };
 
 // WARNING: DO NOT CHANGE THE STRING BELOW. IT GETS REPLACED AT BUILD TIME.
-const SDK_VERSION = '1.5.0';
+const SDK_VERSION = '1.5.1';
 let initialised = false;
 const isInitialised = () => initialised;
 const getReferrer = () => {
@@ -42170,7 +42174,7 @@ const IMMUTABLE_ZKVEM_GAS_OVERRIDES = {
     maxPriorityFeePerGas: ethers.BigNumber.from(10e9),
 };
 
-const SDK_VERSION_MARKER = '1.5.0';
+const SDK_VERSION_MARKER = '1.5.1';
 // This SDK version is replaced by the `yarn build` command ran on the root level
 const globalPackageVersion = () => SDK_VERSION_MARKER;
 
@@ -45432,9 +45436,7 @@ const buy = async (config, provider, orders, overrides = {
     };
 };
 
-const cancel = async (config, provider, orderIds, overrides = {
-    waitFulfillmentSettlements: true,
-}) => {
+const cancelOnChain = async (config, orderbook, provider, orderIds, waitFulfillmentSettlements) => {
     let unsignedCancelOrderTransaction;
     if (orderIds.length === 0) {
         throw new CheckoutError('No orderIds were provided to the orderIds array. Please provide at least one orderId.', CheckoutErrorType.CANCEL_ORDER_LISTING_ERROR);
@@ -45443,7 +45445,6 @@ const cancel = async (config, provider, orderIds, overrides = {
     const orderId = orderIds[0];
     try {
         const offererAddress = await measureAsyncExecution(config, 'Time to get the address from the provider', provider.getSigner().getAddress());
-        const orderbook = createOrderbookInstance(config);
         const cancelOrderResponse = await measureAsyncExecution(config, 'Time to get the cancel order from the orderbook', orderbook.cancelOrdersOnChain([orderId], offererAddress));
         unsignedCancelOrderTransaction = await cancelOrderResponse.cancellationAction.buildTransaction();
     }
@@ -45453,7 +45454,7 @@ const cancel = async (config, provider, orderIds, overrides = {
             error: err,
         });
     }
-    if (overrides.waitFulfillmentSettlements) {
+    if (waitFulfillmentSettlements) {
         const result = await signFulfillmentTransactions(provider, [unsignedCancelOrderTransaction]);
         if (result.type === SignTransactionStatusType.FAILED) {
             return {
@@ -45481,6 +45482,56 @@ const cancel = async (config, provider, orderIds, overrides = {
         transactions,
     };
 };
+const gaslessCancel = async (orderbook, provider, orderIds) => {
+    try {
+        const signer = provider.getSigner();
+        const address = await signer.getAddress();
+        const { signableAction } = await orderbook.prepareOrderCancellations(orderIds);
+        // eslint-disable-next-line no-underscore-dangle
+        const signedMessage = await signer._signTypedData(signableAction.message.domain, signableAction.message.types, signableAction.message.value);
+        const { result } = await orderbook.cancelOrders(orderIds, address, signedMessage);
+        const successfulCancellations = [];
+        const failedCancellations = [];
+        const pendingCancellations = [];
+        for (const success of result.successful_cancellations) {
+            successfulCancellations.push({
+                orderId: success,
+            });
+        }
+        for (const failed of result.failed_cancellations) {
+            failedCancellations.push({
+                orderId: failed.order,
+                reason: failed.reason_code,
+            });
+        }
+        for (const pending of result.pending_cancellations) {
+            pendingCancellations.push({
+                orderId: pending,
+            });
+        }
+        return {
+            successfulCancellations,
+            failedCancellations,
+            pendingCancellations,
+        };
+    }
+    catch (err) {
+        throw new CheckoutError('An error occurred while cancelling the order listing', CheckoutErrorType.CANCEL_ORDER_LISTING_ERROR, {
+            orderIds,
+            error: err,
+        });
+    }
+};
+const cancel = async (config, provider, orderIds, overrides = {
+    waitFulfillmentSettlements: true,
+    useGaslessCancel: false,
+}) => {
+    const orderbook = createOrderbookInstance(config);
+    if (overrides.useGaslessCancel) {
+        return await gaslessCancel(orderbook, provider, orderIds);
+    }
+    return await cancelOnChain(config, orderbook, provider, orderIds, overrides.waitFulfillmentSettlements ?? true);
+};
 
 const getERC721Requirement = (id, contractAddress, spenderAddress) => ({
     type: ItemType.ERC721,

package/dist/index.d.ts

@@ -30092,7 +30092,7 @@ type SellResultInsufficientFunds = {
     /** The insufficient result of smart checkout */
     smartCheckoutResult: SmartCheckoutInsufficient;
 };
-type CancelResult = CancelResultSuccess | CancelResultFailed | CancelResultFulfillmentsUnsettled;
+type CancelResult = CancelResultSuccess | CancelResultFailed | CancelResultFulfillmentsUnsettled | CancelResultGasless;
 /**
  * Represents the result of {@link Checkout.cancel}
  * @property {CheckoutStatus.SUCCESS} status
@@ -30121,18 +30121,58 @@ type CancelResultFailed = {
  * @property {SendTransactionResult[]} transactions
  */
 type CancelResultFulfillmentsUnsettled = {
-    /** The status to indicate success */
+    /** The status to indicate the fulfillments have not yet settled on chain. */
     status: CheckoutStatus.FULFILLMENTS_UNSETTLED;
     /** Array of transaction results */
     transactions: TransactionResponse[];
 };
+/**
+ * Represents the result of {@link Checkout.cancel} when using gasless cancel
+ * @property {SuccessfulGaslessCancellation[]} successfulCancellations
+ * @property {FailedGaslessCancellation[]} failedCancellations
+ * @property {PendingGaslessCancellation[]} pendingCancellations
+ */
+type CancelResultGasless = {
+    successfulCancellations: SuccessfulGaslessCancellation[];
+    failedCancellations: FailedGaslessCancellation[];
+    pendingCancellations: PendingGaslessCancellation[];
+};
+/**
+ * Represents a successful gasless cancellation
+ * @property {string} orderId
+ */
+type SuccessfulGaslessCancellation = {
+    /** The order id of the successful cancellation */
+    orderId: string;
+};
+/**
+ * Represents a failed gasless cancellation
+ * @property {string} orderId
+ * @property {string} reason
+ */
+type FailedGaslessCancellation = {
+    /** The order id of the failed cancellation */
+    orderId: string;
+    /** The reason for failure */
+    reason: string;
+};
+/**
+ * Represents a pending gasless cancellation
+ * @property {string} orderId
+ */
+type PendingGaslessCancellation = {
+    /** The order id of the pending cancellation */
+    orderId: string;
+};
 /**
  * Represents the overrides available for {@link Checkout.cancel}
  * @property {boolean} waitFulfillmentSettlements
  */
 type CancelOverrides = {
-    /** If the buy should wait for the fulfillment transactions to settle */
+    /** If the cancel should wait for the fulfillment transactions to settle */
     waitFulfillmentSettlements?: boolean;
+    /** If the cancel should use the gasless option */
+    useGaslessCancel?: boolean;
 };
 /**
  * An enum representing the checkout status types
@@ -30151,7 +30191,7 @@ declare enum CheckoutStatus {
 /**
  * The type representing the order to buy
  * @property {string} orderId
- * @property {Array<OrderFee>} takerFees
+ * @property {OrderFee[]} takerFees
  */
 type BuyOrder = {
     /** the id of the order to buy */
@@ -32496,6 +32536,7 @@ type checkout_d_CancelParams = CancelParams;
 type checkout_d_CancelResult = CancelResult;
 type checkout_d_CancelResultFailed = CancelResultFailed;
 type checkout_d_CancelResultFulfillmentsUnsettled = CancelResultFulfillmentsUnsettled;
+type checkout_d_CancelResultGasless = CancelResultGasless;
 type checkout_d_CancelResultSuccess = CancelResultSuccess;
 type checkout_d_ChainId = ChainId;
 declare const checkout_d_ChainId: typeof ChainId;
@@ -32537,6 +32578,7 @@ type checkout_d_ERC721ItemRequirement = ERC721ItemRequirement;
 type checkout_d_ErrorType = ErrorType;
 type checkout_d_ExchangeType = ExchangeType;
 declare const checkout_d_ExchangeType: typeof ExchangeType;
+type checkout_d_FailedGaslessCancellation = FailedGaslessCancellation;
 type checkout_d_Fee = Fee;
 type checkout_d_FeePercentage = FeePercentage;
 type checkout_d_FeeToken = FeeToken;
@@ -32599,6 +32641,7 @@ type checkout_d_OrchestrationEventData = OrchestrationEventData;
 type checkout_d_OrchestrationEventType = OrchestrationEventType;
 declare const checkout_d_OrchestrationEventType: typeof OrchestrationEventType;
 type checkout_d_OrderFee = OrderFee;
+type checkout_d_PendingGaslessCancellation = PendingGaslessCancellation;
 type checkout_d_ProviderEvent<KEventName extends keyof ProviderEventMapping> = ProviderEvent<KEventName>;
 type checkout_d_ProviderEventType = ProviderEventType;
 declare const checkout_d_ProviderEventType: typeof ProviderEventType;
@@ -32639,6 +32682,7 @@ type checkout_d_SmartCheckoutParams = SmartCheckoutParams;
 type checkout_d_SmartCheckoutResult = SmartCheckoutResult;
 type checkout_d_SmartCheckoutRouter = SmartCheckoutRouter;
 type checkout_d_SmartCheckoutSufficient = SmartCheckoutSufficient;
+type checkout_d_SuccessfulGaslessCancellation = SuccessfulGaslessCancellation;
 type checkout_d_SwapEventType = SwapEventType;
 declare const checkout_d_SwapEventType: typeof SwapEventType;
 type checkout_d_SwapFailed = SwapFailed;
@@ -32711,6 +32755,7 @@ declare namespace checkout_d {
     checkout_d_CancelResult as CancelResult,
     checkout_d_CancelResultFailed as CancelResultFailed,
     checkout_d_CancelResultFulfillmentsUnsettled as CancelResultFulfillmentsUnsettled,
+    checkout_d_CancelResultGasless as CancelResultGasless,
     checkout_d_CancelResultSuccess as CancelResultSuccess,
     checkout_d_ChainId as ChainId,
     checkout_d_ChainName as ChainName,
@@ -32742,6 +32787,7 @@ declare namespace checkout_d {
     checkout_d_ERC721ItemRequirement as ERC721ItemRequirement,
     checkout_d_ErrorType as ErrorType,
     checkout_d_ExchangeType as ExchangeType,
+    checkout_d_FailedGaslessCancellation as FailedGaslessCancellation,
     checkout_d_Fee as Fee,
     checkout_d_FeePercentage as FeePercentage,
     checkout_d_FeeToken as FeeToken,
@@ -32795,6 +32841,7 @@ declare namespace checkout_d {
     checkout_d_OrchestrationEventData as OrchestrationEventData,
     checkout_d_OrchestrationEventType as OrchestrationEventType,
     checkout_d_OrderFee as OrderFee,
+    checkout_d_PendingGaslessCancellation as PendingGaslessCancellation,
     checkout_d_ProviderEvent as ProviderEvent,
     checkout_d_ProviderEventType as ProviderEventType,
     checkout_d_ProviderUpdated as ProviderUpdated,
@@ -32831,6 +32878,7 @@ declare namespace checkout_d {
     checkout_d_SmartCheckoutResult as SmartCheckoutResult,
     checkout_d_SmartCheckoutRouter as SmartCheckoutRouter,
     checkout_d_SmartCheckoutSufficient as SmartCheckoutSufficient,
+    checkout_d_SuccessfulGaslessCancellation as SuccessfulGaslessCancellation,
     checkout_d_SwapEventType as SwapEventType,
     checkout_d_SwapFailed as SwapFailed,
     checkout_d_SwapFundingStep as SwapFundingStep,