@riftresearch/sdk 0.13.0 → 0.15.0

package/README.md

@@ -61,10 +61,10 @@ const swap = await executeSwap({
     // Call your bitcoin wallet's transfer function here
   },
 })
-console.log(`Swap ID: ${swap.swapId}`)
+console.log(`Order ID: ${swap.orderId}`)
 
 // Check status
-const status = await sdk.getSwapStatus(swap.swapId)
+const status = await sdk.getSwapStatus(swap.orderId)
 console.log(`Status: ${status.status}`)
 ```
 
@@ -98,6 +98,19 @@ const result = await sdk.createLimitOrder({
   validUntil: Math.floor(Date.now() / 1000) + 3600, // optional: order expires in 1 hour
 })
 
-console.log(`Order ID: ${result.swapId}`)
+console.log(`Order ID: ${result.orderId}`)
 console.log(`Status: ${result.status}`)
 ```
+
+For supported limit orders, you can later cancel the order. The SDK will fetch the
+correct typed-data payload from the router, sign it with your wallet, and submit the
+cancellation:
+
+```ts
+const cancel = await sdk.cancelOrder({
+  orderId: result.orderId,
+  walletClient,
+})
+
+console.log(`Cancel accepted: ${cancel.accepted}`)
+```

package/dist/index.d.ts

@@ -132,14 +132,57 @@ interface LimitPricing {
 	buyAmount: U256;
 	sellAmount: U256;
 }
-declare const SWAP_STATUSES: readonly ["waiting_for_deposit", "deposit_confirming", "initiating_payout", "confirming_payout", "swap_complete", "refunding_user", "failed"];
-type SwapStatus = (typeof SWAP_STATUSES)[number];
-interface SwapStatusResponse {
-	status: SwapStatus;
-	destinationAddress: Address;
-	payoutTransaction?: TxHash;
-	depositTransaction?: TxHash;
-	quote: QuoteResponse;
+declare const ANALYTICS_ORDER_STATUSES: readonly ["unfilled", "filled", "cancelled", "settled", "refunded", "failed"];
+type AnalyticsOrderStatus = (typeof ANALYTICS_ORDER_STATUSES)[number];
+interface ExternalDexStatus {
+	provider: string | null;
+	status: string | null;
+}
+interface TeeOtcStatus {
+	status: string | null;
+}
+interface TeeSwapperStatus {
+	status: string | null;
+	orderStatus: string | null;
+	refundState: string | null;
+}
+interface AnalyticsOrderResponse {
+	orderId: string;
+	routeType: string;
+	orderType: string | null;
+	provider: string | null;
+	path: string[] | null;
+	status: AnalyticsOrderStatus;
+	senderAddress: Address | null;
+	destinationAddress: Address | null;
+	refundAddress: Address | null;
+	otcSwapId: string | null;
+	swapperSwapId: string | null;
+	cowOrderUid: string | null;
+	sellCurrency: Currency | null;
+	buyCurrency: Currency | null;
+	quoteMode: "exact_input" | "exact_output" | null;
+	quotedSellAmount: U256 | null;
+	quotedBuyAmount: U256 | null;
+	quotedMinimumBuyAmount: U256 | null;
+	quotedMaximumSellAmount: U256 | null;
+	executedSellAmount: U256 | null;
+	executedBuyAmount: U256 | null;
+	executedFeeAmount: U256 | null;
+	depositTxHash: TxHash | null;
+	payoutTxHash: TxHash | null;
+	refundTxHash: TxHash | null;
+	rawRouterJson: Record<string, unknown> | null;
+	rawExternalDEXOrderJson: Record<string, unknown> | null;
+	rawOtcJson: Record<string, unknown> | null;
+	rawSwapperJson: Record<string, unknown> | null;
+	externalDexStatus: ExternalDexStatus | null;
+	teeOtcStatus: TeeOtcStatus | null;
+	teeSwapperStatus: TeeSwapperStatus | null;
+	createdAt: string;
+	updatedAt: string;
+	lastSourceUpdateAt: string | null;
+	terminalAt: string | null;
 }
 interface ErrorResponse {
 	error: string;
@@ -234,13 +277,21 @@ type ExecutionStep = EvmCallStep | Eip712SignStep | BtcTransferStep;
 * Swap response with execution steps that the client must execute.
 */
 interface SwapResponse {
-	/** The Rift swap ID */
-	swapId: string;
+	/** The Rift order ID */
+	orderId: string;
 	/** Normalized quote matching /quote response */
 	quote: QuoteResponse;
 	/** Ordered list of steps the client must execute */
 	executionSteps: ExecutionStep[];
 }
+interface CancelOrderResponse {
+	/** The public order ID from the router API. */
+	orderId: string;
+	/** Whether the downstream cancellation request was accepted. */
+	accepted: boolean;
+	/** Optional downstream CoW order UID for the cancelled order. */
+	cowOrderUid?: string;
+}
 /** Create an ERC-20 currency on an EVM chain */
 declare function createCurrency(params: {
 	chainId: number;
@@ -314,7 +365,7 @@ declare function getSupportedModes(from: Currency, to: Currency): SupportedModes
 import { Chain as Chain3 } from "viem";
 import { Account, PublicClient, Transport, WalletClient } from "viem";
 import { Chain as Chain2 } from "viem/chains";
-type RiftSwap = SwapStatusResponse;
+type RiftSwap = AnalyticsOrderResponse;
 interface QuoteParameters {
 	/** The currency to swap from */
 	from: Currency;
@@ -379,10 +430,11 @@ interface GetQuoteResult {
 	executeSwap: <chain extends Chain2 | undefined = Chain2 | undefined>(context: ExecuteSwapOptions<chain>) => Promise<SwapResult>;
 }
 interface SwapResult {
-	swapId: string;
-	status: SwapStatus;
+	orderId: string;
+	status: AnalyticsOrderStatus;
 	rift: RiftSwap;
 }
+type CancelOrderResult = CancelOrderResponse;
 /**
 * Function type for sending Bitcoin.
 * Implementers provide this function to handle BTC transactions in their app.
@@ -440,6 +492,17 @@ type ExecuteSwapOptions<chain extends Chain2 | undefined = Chain2 | undefined> =
 	/** Address to receive refunds if swap fails. Defaults to source wallet address */
 	refundAddress?: string;
 };
+type CancelOrderOptions<chain extends Chain2 | undefined = Chain2 | undefined> = {
+	orderId: string;
+	/** Viem WalletClient for signing the router-prepared cancellation typed data */
+	walletClient: WalletClient<Transport, chain, Account | undefined>;
+	/**
+	* Optional absolute Unix timestamp in UTC seconds for tee-swapper
+	* cancellation signatures. Defaults to now + 5 minutes and is ignored for
+	* direct CoW-backed cancellations.
+	*/
+	deadline?: number;
+};
 interface RiftSdkOptions {
 	/** Rift API URL. Defaults to production API */
 	apiUrl?: string;
@@ -485,6 +548,9 @@ declare class RiftSdk {
 	createLimitOrder<chain extends Chain3 | undefined = Chain3 | undefined>(options: CreateLimitOrderOptions<chain>): Promise<SwapResult>;
 	private assertPositiveIntegerString;
 	private assertValidLimitValidUntil;
+	private assertValidCancelDeadline;
+	private assertCancelWalletChain;
+	private signPreparedCancellation;
 	private executeOrderFlow;
 	/**
 	* Execute a single step from the server's execution steps.
@@ -506,6 +572,7 @@ declare class RiftSdk {
 	private buildDexSwapRevertMessage;
 	private resolveDexVenueLabel;
 	private shouldReportStepResult;
+	private deriveCowSwapEthFlowOrderId;
 	private getCowSwapApiBase;
 	private assertSufficientBalance;
 	private getAddress;
@@ -516,9 +583,17 @@ declare class RiftSdk {
 	private requireWalletClient;
 	private requireSendBitcoin;
 	/**
-	* Get the current status of a swap by its ID.
+	* Get the current status of an order by its ID.
+	*/
+	getSwapStatus(orderId: string): Promise<AnalyticsOrderResponse>;
+	/**
+	* Cancel a supported limit order through the swap router.
+	*
+	* The SDK first requests the backend-specific typed-data payload from the
+	* router, signs it with the provided wallet, and then submits the signed
+	* cancellation request back to the router.
 	*/
-	getSwapStatus(swapId: string): Promise<SwapStatusResponse>;
+	cancelOrder<chain extends Chain3 | undefined = Chain3 | undefined>(options: CancelOrderOptions<chain>): Promise<CancelOrderResult>;
 }
 declare function createRiftSdk(options: RiftSdkOptions): RiftSdk;
-export { getSupportedModes, detectRoute, createRiftSdk, createCurrency, TokenIdentifier, SwapStatus, SwapRouterApiError, SwapRoute, SwapResult, SwapResponse, SupportedModes, SendBitcoinFn, RiftSwap, RiftSdkOptions, RiftSdk, QuoteResult, QuoteParameters, NativeToken, LimitPricing, GetQuoteResult, ExecutionStep, ExecutionAction, ExecuteSwapStepType, ExecuteSwapOptions, ExecuteSwapOnExecuteStepCallback, EvmChain, EvmCallStep, EvmCallKind, Erc20Token, Currency, Currencies, CreateLimitOrderOptions, Chain, BtcTransferStep, BtcTransferKind, BitcoinChain };
+export { getSupportedModes, detectRoute, createRiftSdk, createCurrency, TokenIdentifier, AnalyticsOrderStatus as SwapStatus, SwapRouterApiError, SwapRoute, SwapResult, SwapResponse, SupportedModes, SendBitcoinFn, RiftSwap, RiftSdkOptions, RiftSdk, QuoteResult, QuoteParameters, NativeToken, LimitPricing, GetQuoteResult, ExecutionStep, ExecutionAction, ExecuteSwapStepType, ExecuteSwapOptions, ExecuteSwapOnExecuteStepCallback, EvmChain, EvmCallStep, EvmCallKind, Erc20Token, Currency, Currencies, CreateLimitOrderOptions, Chain, CancelOrderResult, CancelOrderOptions, BtcTransferStep, BtcTransferKind, BitcoinChain };

package/dist/index.js

@@ -85,6 +85,29 @@ var Currencies = {
     }
   }
 };
+// ../common/src/cowswap.ts
+var COW_SWAP_ORDER_UID_REGEX = /^0x[0-9a-fA-F]{112}$/;
+var COW_SWAP_ORDER_HASH_REGEX = /^0x[0-9a-fA-F]{64}$/;
+var EVM_ADDRESS_REGEX = /^0x[0-9a-fA-F]{40}$/;
+var COW_SWAP_ETH_FLOW_UID_VALID_TO = 4294967295;
+function isCowSwapOrderUid(value) {
+  return COW_SWAP_ORDER_UID_REGEX.test(value);
+}
+function deriveCowSwapOrderUid(orderHash, owner, validTo) {
+  if (!COW_SWAP_ORDER_HASH_REGEX.test(orderHash)) {
+    throw new Error(`Invalid CowSwap order hash: ${orderHash}`);
+  }
+  if (!EVM_ADDRESS_REGEX.test(owner)) {
+    throw new Error(`Invalid CowSwap order owner address: ${owner}`);
+  }
+  if (!Number.isInteger(validTo) || validTo < 0 || validTo > COW_SWAP_ETH_FLOW_UID_VALID_TO) {
+    throw new Error(`Invalid CowSwap order validTo: ${validTo}`);
+  }
+  return `0x${orderHash.slice(2).toLowerCase()}${owner.slice(2).toLowerCase()}${validTo.toString(16).padStart(8, "0")}`;
+}
+function deriveCowSwapEthFlowOrderUid(orderHash, ethFlowContract) {
+  return deriveCowSwapOrderUid(orderHash, ethFlowContract, COW_SWAP_ETH_FLOW_UID_VALID_TO);
+}
 // src/errors.ts
 class SwapRouterApiError extends Error {
   status;
@@ -153,7 +176,11 @@ function getSupportedModes(from, to) {
   return { exactInput: true, exactOutput: false };
 }
 // src/sdk.ts
-import { erc20Abi, isAddress } from "viem";
+import {
+  decodeFunctionResult,
+  erc20Abi,
+  isAddress
+} from "viem";
 
 // src/client.ts
 async function request(baseUrl, path, init) {
@@ -223,18 +250,24 @@ function postJson(baseUrl, path, body) {
 function createClient(baseUrl) {
   const normalizedBaseUrl = baseUrl.replace(/\/$/, "");
   const swap = (params) => {
-    const swapId = encodeURIComponent(params.swapId);
+    const orderId = encodeURIComponent(params.orderId);
     return {
-      get: () => get(normalizedBaseUrl, `/order/${swapId}`),
+      get: () => get(normalizedBaseUrl, `/order/${orderId}`),
+      cancel: {
+        prepare: {
+          post: (body) => postJson(normalizedBaseUrl, `/order/${orderId}/cancel/prepare`, body)
+        },
+        post: (body) => postJson(normalizedBaseUrl, `/order/${orderId}/cancel`, body)
+      },
       tx: {
-        post: (body) => postJson(normalizedBaseUrl, `/order/${swapId}/tx`, body)
+        post: (body) => postJson(normalizedBaseUrl, `/order/${orderId}/tx`, body)
       },
       "refresh-step": {
-        post: (body) => postJson(normalizedBaseUrl, `/order/${swapId}/refresh-step`, body)
+        post: (body) => postJson(normalizedBaseUrl, `/order/${orderId}/refresh-step`, body)
       }
     };
   };
-  swap.post = (body) => postJson(normalizedBaseUrl, "/swap", body);
+  swap.post = (body) => postJson(normalizedBaseUrl, "/order/market", body);
   const market = {
     post: (body) => postJson(normalizedBaseUrl, "/order/market", body)
   };
@@ -259,6 +292,32 @@ var DEFAULT_LIMIT_VALIDITY_WINDOW_SECONDS = 365 * 24 * 60 * 60;
 var MIN_LIMIT_VALIDITY_LEAD_TIME_SECONDS = 60;
 var MAX_LIMIT_VALIDITY_WINDOW_SECONDS = DEFAULT_LIMIT_VALIDITY_WINDOW_SECONDS;
 var MAX_COW_VALID_TO = 4294967295;
+var CANCEL_AUTH_WINDOW_SECONDS = 300;
+var ETHFLOW_ABI = [
+  {
+    name: "createOrder",
+    type: "function",
+    stateMutability: "payable",
+    inputs: [
+      {
+        name: "order",
+        type: "tuple",
+        components: [
+          { name: "buyToken", type: "address" },
+          { name: "receiver", type: "address" },
+          { name: "sellAmount", type: "uint256" },
+          { name: "buyAmount", type: "uint256" },
+          { name: "appData", type: "bytes32" },
+          { name: "feeAmount", type: "uint256" },
+          { name: "validTo", type: "uint32" },
+          { name: "partiallyFillable", type: "bool" },
+          { name: "quoteId", type: "int64" }
+        ]
+      }
+    ],
+    outputs: [{ name: "orderHash", type: "bytes32" }]
+  }
+];
 
 class RiftSdk {
   riftClient;
@@ -467,10 +526,55 @@ class RiftSdk {
       throw new Error(`${field} must be between 60 seconds and 31536000 seconds in the future`);
     }
   }
+  assertValidCancelDeadline(deadline) {
+    if (!Number.isInteger(deadline)) {
+      throw new Error("deadline must be an integer when provided");
+    }
+    const nowSeconds = Math.floor(Date.now() / 1000);
+    if (deadline < nowSeconds) {
+      throw new Error("deadline must be in the future");
+    }
+    if (deadline > nowSeconds + CANCEL_AUTH_WINDOW_SECONDS) {
+      throw new Error(`deadline must be within ${CANCEL_AUTH_WINDOW_SECONDS} seconds`);
+    }
+  }
+  assertCancelWalletChain(walletClient, chainId) {
+    const walletChainId = walletClient.chain?.id;
+    if (!walletChainId) {
+      throw new Error("Wallet client is missing an EVM chain configuration");
+    }
+    if (walletChainId !== chainId) {
+      throw new Error(`Wallet client chain mismatch. Expected ${chainId}, got ${walletChainId}`);
+    }
+  }
+  async signPreparedCancellation(walletClient, account, preparation) {
+    if (preparation.kind === "tee_swapper") {
+      return walletClient.signTypedData({
+        account,
+        domain: preparation.typedData.domain,
+        types: preparation.typedData.types,
+        primaryType: preparation.typedData.primaryType,
+        message: {
+          swapId: preparation.typedData.message.swapId,
+          deadline: BigInt(preparation.typedData.message.deadline)
+        }
+      });
+    }
+    return walletClient.signTypedData({
+      account,
+      domain: {
+        ...preparation.typedData.domain,
+        verifyingContract: preparation.typedData.domain.verifyingContract
+      },
+      types: preparation.typedData.types,
+      primaryType: preparation.typedData.primaryType,
+      message: preparation.typedData.message
+    });
+  }
   async executeOrderFlow(params) {
     const swapResponse = await params.createOrder();
     this.logDebug("order created", {
-      swapId: swapResponse.swapId,
+      orderId: swapResponse.orderId,
       steps: swapResponse.executionSteps.length
     });
     this.assertEvmChainMatchForSteps(swapResponse.executionSteps, params.context);
@@ -481,7 +585,7 @@ class RiftSdk {
         kind: "kind" in step ? step.kind : undefined,
         chainId: "chainId" in step ? step.chainId : undefined
       });
-      const result = await this.executeStep(step, params.context, swapResponse.swapId, params.route);
+      const result = await this.executeStep(step, params.context, swapResponse.orderId, params.route);
       this.logDebug("step completed", {
         stepId: step.id,
         txHash: result.txHash,
@@ -492,36 +596,37 @@ class RiftSdk {
           stepId: step.id,
           kind: "kind" in step ? step.kind : undefined
         });
-        this.unwrapEdenResult(await this.riftClient.swap({ swapId: swapResponse.swapId }).tx.post({
+        this.unwrapEdenResult(await this.riftClient.swap({ orderId: swapResponse.orderId }).tx.post({
           stepId: step.id,
           ...result
         }));
       }
     }
     this.logDebug("fetching swap status", {
-      swapId: swapResponse.swapId
+      orderId: swapResponse.orderId
     });
-    const swap = this.unwrapEdenResult(await this.riftClient.swap({ swapId: swapResponse.swapId }).get());
+    const swap = this.unwrapEdenResult(await this.riftClient.swap({ orderId: swapResponse.orderId }).get());
     this.logDebug("swap fetched", {
-      swapId: swapResponse.swapId,
+      orderId: swapResponse.orderId,
       status: swap.status
     });
     return this.buildSwapResult(swap, {
       chained: params.chained,
-      riftSwapId: swapResponse.swapId
+      riftOrderId: swapResponse.orderId
     });
   }
-  async executeStep(step, context, swapId, route) {
+  async executeStep(step, context, orderId, route) {
     switch (step.action) {
       case "evm_call":
-        return this.executeEvmCallStep(step, context, swapId, route);
+        return this.executeEvmCallStep(step, context, orderId, route);
       case "eip712_sign":
         return this.executeEip712SignStep(step, context);
       case "btc_transfer":
         return this.executeBtcTransferStep(step, context);
     }
+    throw new Error(`Unsupported execution step action: ${String(step)}`);
   }
-  async executeEvmCallStep(step, context, swapId, route) {
+  async executeEvmCallStep(step, context, orderId, route) {
     const walletClient = this.requireWalletClient(context);
     const publicClient = this.requirePublicClient(context);
     const account = walletClient.account;
@@ -554,12 +659,12 @@ class RiftSdk {
         throw estimateError;
       }
       this.logDebug("estimateGas failed; attempting refresh-step", {
-        swapId,
+        orderId,
         stepId: effectiveStep.id,
         error: estimateError instanceof Error ? estimateError.message : String(estimateError)
       });
       try {
-        const refreshed = this.unwrapEdenResult(await this.riftClient.swap({ swapId })["refresh-step"].post({ stepId: effectiveStep.id }));
+        const refreshed = this.unwrapEdenResult(await this.riftClient.swap({ orderId })["refresh-step"].post({ stepId: effectiveStep.id }));
         if (!refreshed?.step) {
           throw new Error("estimateGas failed for dex_swap step and refresh-step returned no step");
         }
@@ -576,7 +681,7 @@ class RiftSdk {
         estimatedGas = await publicClient.estimateGas(txRequest);
       } catch (retrySimulationError) {
         this.logDebug("dex_swap simulation failed after refresh-step attempt", {
-          swapId,
+          orderId,
           stepId: effectiveStep.id,
           error: retrySimulationError instanceof Error ? retrySimulationError.message : String(retrySimulationError)
         });
@@ -589,6 +694,7 @@ class RiftSdk {
       estimatedGas: estimatedGas.toString(),
       gasLimit: gasLimit.toString()
     });
+    const cowswapOrderId = effectiveStep.kind === "cowswap_eth_order" ? await this.deriveCowSwapEthFlowOrderId(effectiveStep, publicClient, account.address) : undefined;
     await context.onExecuteStep?.(effectiveStep.kind === "approval" ? "approval" : "transaction");
     const txHash = await walletClient.sendTransaction({
       ...txRequest,
@@ -603,7 +709,10 @@ class RiftSdk {
       }
       throw new Error(`EVM step transaction reverted (${effectiveStep.kind}) with hash ${txHash}`);
     }
-    return step.kind === "cowswap_eth_order" ? { txHash, cowswapOrderId: txHash } : { txHash };
+    return {
+      txHash,
+      ...cowswapOrderId ? { cowswapOrderId } : {}
+    };
   }
   async executeEip712SignStep(step, context) {
     const walletClient = this.requireWalletClient(context);
@@ -687,6 +796,9 @@ class RiftSdk {
     if (!orderId) {
       throw new Error("CowSwap order submission succeeded but returned no order id");
     }
+    if (!isCowSwapOrderUid(orderId)) {
+      throw new Error(`CowSwap order submission returned a non-UID identifier: ${orderId}`);
+    }
     return { cowswapOrderId: orderId };
   }
   async executeBtcTransferStep(step, context) {
@@ -720,12 +832,12 @@ class RiftSdk {
     }
   }
   buildSwapResult(swap, options) {
-    const riftSwapId = options?.riftSwapId;
-    if (!riftSwapId) {
-      throw new Error("Missing rift swap id for swap result.");
+    const riftOrderId = options?.riftOrderId;
+    if (!riftOrderId) {
+      throw new Error("Missing rift order id for swap result.");
     }
     return {
-      swapId: riftSwapId,
+      orderId: riftOrderId,
       status: swap.status,
       rift: swap
     };
@@ -750,6 +862,45 @@ class RiftSdk {
     }
     return false;
   }
+  async deriveCowSwapEthFlowOrderId(step, publicClient, accountAddress) {
+    this.logDebug("deriving CowSwap EthFlow order uid", {
+      stepId: step.id,
+      chainId: step.chainId,
+      to: step.to
+    });
+    let responseData;
+    try {
+      const response = await publicClient.call({
+        account: accountAddress,
+        to: step.to,
+        data: step.calldata,
+        value: step.value ? BigInt(step.value) : undefined
+      });
+      responseData = response.data;
+    } catch (error) {
+      throw new Error(`Failed to derive CowSwap EthFlow order id before submission: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    if (!responseData) {
+      throw new Error("Failed to derive CowSwap EthFlow order id before submission: empty call result.");
+    }
+    let orderHash;
+    try {
+      orderHash = decodeFunctionResult({
+        abi: ETHFLOW_ABI,
+        functionName: "createOrder",
+        data: responseData
+      });
+    } catch (error) {
+      throw new Error(`Failed to decode CowSwap EthFlow order hash: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    const cowswapOrderId = deriveCowSwapEthFlowOrderUid(orderHash, step.to);
+    this.logDebug("derived CowSwap EthFlow order uid", {
+      stepId: step.id,
+      chainId: step.chainId,
+      cowswapOrderId
+    });
+    return cowswapOrderId;
+  }
   getCowSwapApiBase(chainId) {
     if (chainId === 1)
       return "https://api.cow.fi/mainnet";
@@ -844,8 +995,29 @@ class RiftSdk {
     }
     return context.sendBitcoin;
   }
-  async getSwapStatus(swapId) {
-    return this.unwrapEdenResult(await this.riftClient.swap({ swapId }).get());
+  async getSwapStatus(orderId) {
+    return this.unwrapEdenResult(await this.riftClient.swap({ orderId }).get());
+  }
+  async cancelOrder(options) {
+    const walletClient = options.walletClient;
+    const account = walletClient.account;
+    if (!account) {
+      throw new Error("No account configured on wallet client");
+    }
+    const deadline = options.deadline ?? Math.floor(Date.now() / 1000) + CANCEL_AUTH_WINDOW_SECONDS;
+    this.assertValidCancelDeadline(deadline);
+    const preparation = this.unwrapEdenResult(await this.riftClient.swap({ orderId: options.orderId }).cancel.prepare.post({
+      deadline
+    }));
+    this.assertCancelWalletChain(walletClient, preparation.cancellation.chainId);
+    const signature = await this.signPreparedCancellation(walletClient, account, preparation.cancellation);
+    const request2 = {
+      authorization: {
+        signature,
+        ...preparation.cancellation.kind === "tee_swapper" ? { deadline: preparation.cancellation.deadline } : {}
+      }
+    };
+    return this.unwrapEdenResult(await this.riftClient.swap({ orderId: options.orderId }).cancel.post(request2));
   }
 }
 function createRiftSdk(options) {

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@riftresearch/sdk",
-	"version": "0.13.0",
+	"version": "0.15.0",
 	"description": "SDK for swapping between bitcoin and evm chains",
 	"license": "MIT",
 	"files": [