@riftresearch/sdk 0.12.2 → 0.14.0

package/README.md

@@ -67,3 +67,50 @@ console.log(`Swap ID: ${swap.swapId}`)
 const status = await sdk.getSwapStatus(swap.swapId)
 console.log(`Status: ${status.status}`)
 ```
+
+## Limit Orders
+
+You can place limit orders with a fixed price instead of using a market quote:
+
+```ts
+import { RiftSdk, Currencies } from '@riftresearch/sdk'
+import { createPublicClient, createWalletClient, http } from 'viem'
+import { base } from 'viem/chains'
+import { privateKeyToAccount } from 'viem/accounts'
+
+const account = privateKeyToAccount('0x...')
+const publicClient = createPublicClient({ chain: base, transport: http() })
+const walletClient = createWalletClient({ account, chain: base, transport: http() })
+
+const sdk = new RiftSdk({ integratorName: 'my-app' })
+
+const result = await sdk.createLimitOrder({
+  from: Currencies.Base.USDC,
+  to: Currencies.Bitcoin.BTC,
+  pricing: {
+    sellAmount: '1000000',   // 1 USDC (6 decimals)
+    buyAmount: '2500',       // 2500 sats
+  },
+  destinationAddress: 'bc1q...',
+  refundAddress: '0x...',
+  walletClient,
+  publicClient,
+  validUntil: Math.floor(Date.now() / 1000) + 3600, // optional: order expires in 1 hour
+})
+
+console.log(`Order ID: ${result.swapId}`)
+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({
+  swapId: result.swapId,
+  walletClient,
+})
+
+console.log(`Cancel accepted: ${cancel.accepted}`)
+```

package/dist/index.d.ts

@@ -241,6 +241,14 @@ interface SwapResponse {
 	/** Ordered list of steps the client must execute */
 	executionSteps: ExecutionStep[];
 }
+interface CancelOrderResponse {
+	/** The public swap ID from the router API. */
+	swapId: 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;
@@ -383,6 +391,7 @@ interface SwapResult {
 	status: SwapStatus;
 	rift: RiftSwap;
 }
+type CancelOrderResult = CancelOrderResponse;
 /**
 * Function type for sending Bitcoin.
 * Implementers provide this function to handle BTC transactions in their app.
@@ -417,7 +426,8 @@ type CreateLimitOrderOptions<chain extends Chain2 | undefined = Chain2 | undefin
 	destinationAddress: string;
 	refundAddress?: string;
 	approvalMode?: "full" | "partial";
-	validForSeconds?: number;
+	/** Absolute Unix timestamp in UTC seconds when the limit order expires. Defaults to now + 1 year if not provided. */
+	validUntil?: number;
 };
 type ExecuteSwapOnExecuteStepCallback = (type: ExecuteSwapStepType) => void | Promise<void>;
 type ExecuteSwapContext<chain extends Chain2 | undefined = Chain2 | undefined> = {
@@ -439,6 +449,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> = {
+	swapId: 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;
@@ -483,6 +504,10 @@ declare class RiftSdk {
 	getQuote(params: QuoteParameters): Promise<GetQuoteResult>;
 	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.
@@ -517,6 +542,14 @@ declare class RiftSdk {
 	* Get the current status of a swap by its ID.
 	*/
 	getSwapStatus(swapId: string): Promise<SwapStatusResponse>;
+	/**
+	* 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.
+	*/
+	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, 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

@@ -226,6 +226,12 @@ function createClient(baseUrl) {
     const swapId = encodeURIComponent(params.swapId);
     return {
       get: () => get(normalizedBaseUrl, `/order/${swapId}`),
+      cancel: {
+        prepare: {
+          post: (body) => postJson(normalizedBaseUrl, `/order/${swapId}/cancel/prepare`, body)
+        },
+        post: (body) => postJson(normalizedBaseUrl, `/order/${swapId}/cancel`, body)
+      },
       tx: {
         post: (body) => postJson(normalizedBaseUrl, `/order/${swapId}/tx`, body)
       },
@@ -255,6 +261,11 @@ function createClient(baseUrl) {
 var GAS_LIMIT_MULTIPLIER_NUMERATOR = 3n;
 var GAS_LIMIT_MULTIPLIER_DENOMINATOR = 2n;
 var GPV2_SETTLEMENT = "0x9008d19f58aabd9ed0d60971565aa8510560ab41";
+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;
 
 class RiftSdk {
   riftClient;
@@ -369,8 +380,8 @@ class RiftSdk {
     }
     this.assertPositiveIntegerString(options.pricing.buyAmount, "pricing.buyAmount");
     this.assertPositiveIntegerString(options.pricing.sellAmount, "pricing.sellAmount");
-    if (options.validForSeconds !== undefined && (!Number.isInteger(options.validForSeconds) || options.validForSeconds <= 0)) {
-      throw new Error("validForSeconds must be a positive integer when provided");
+    if (options.validUntil !== undefined) {
+      this.assertValidLimitValidUntil(options.validUntil, "validUntil");
     }
     let refundAddress;
     let senderAddress;
@@ -431,7 +442,7 @@ class RiftSdk {
           destinationAddress: options.destinationAddress,
           refundAddress,
           ...options.approvalMode ? { approvalMode: options.approvalMode } : {},
-          ...typeof options.validForSeconds === "number" ? { validForSeconds: options.validForSeconds } : {},
+          ...typeof options.validUntil === "number" ? { validUntil: options.validUntil } : {},
           integratorName: this.integratorName
         };
         this.logDebug("creating limit order", {
@@ -450,6 +461,64 @@ class RiftSdk {
       throw new Error(`${field} must be greater than zero`);
     }
   }
+  assertValidLimitValidUntil(validUntil, field) {
+    if (!Number.isInteger(validUntil)) {
+      throw new Error(`${field} must be an integer when provided`);
+    }
+    if (validUntil > MAX_COW_VALID_TO) {
+      throw new Error(`${field} exceeds the maximum supported Unix timestamp`);
+    }
+    const nowSeconds = Math.floor(Date.now() / 1000);
+    const secondsUntilExpiry = validUntil - nowSeconds;
+    if (secondsUntilExpiry < MIN_LIMIT_VALIDITY_LEAD_TIME_SECONDS || secondsUntilExpiry > MAX_LIMIT_VALIDITY_WINDOW_SECONDS) {
+      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", {
@@ -830,6 +899,27 @@ class RiftSdk {
   async getSwapStatus(swapId) {
     return this.unwrapEdenResult(await this.riftClient.swap({ swapId }).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({ swapId: options.swapId }).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({ swapId: options.swapId }).cancel.post(request2));
+  }
 }
 function createRiftSdk(options) {
   return new RiftSdk(options);

package/package.json

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