@riftresearch/sdk 0.14.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,7 +98,7 @@ 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}`)
 ```
 
@@ -108,7 +108,7 @@ cancellation:
 
 ```ts
 const cancel = await sdk.cancelOrder({
-  swapId: result.swapId,
+  orderId: result.orderId,
   walletClient,
 })
 

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,16 +277,16 @@ 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 swap ID from the router API. */
-	swapId: string;
+	/** 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. */
@@ -322,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;
@@ -387,8 +430,8 @@ 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;
@@ -450,7 +493,7 @@ type ExecuteSwapOptions<chain extends Chain2 | undefined = Chain2 | undefined> =
 	refundAddress?: string;
 };
 type CancelOrderOptions<chain extends Chain2 | undefined = Chain2 | undefined> = {
-	swapId: string;
+	orderId: string;
 	/** Viem WalletClient for signing the router-prepared cancellation typed data */
 	walletClient: WalletClient<Transport, chain, Account | undefined>;
 	/**
@@ -529,6 +572,7 @@ declare class RiftSdk {
 	private buildDexSwapRevertMessage;
 	private resolveDexVenueLabel;
 	private shouldReportStepResult;
+	private deriveCowSwapEthFlowOrderId;
 	private getCowSwapApiBase;
 	private assertSufficientBalance;
 	private getAddress;
@@ -539,9 +583,9 @@ 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(swapId: string): Promise<SwapStatusResponse>;
+	getSwapStatus(orderId: string): Promise<AnalyticsOrderResponse>;
 	/**
 	* Cancel a supported limit order through the swap router.
 	*
@@ -552,4 +596,4 @@ declare class RiftSdk {
 	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, CancelOrderResult, CancelOrderOptions, 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,24 +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/${swapId}/cancel/prepare`, body)
+          post: (body) => postJson(normalizedBaseUrl, `/order/${orderId}/cancel/prepare`, body)
         },
-        post: (body) => postJson(normalizedBaseUrl, `/order/${swapId}/cancel`, 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)
   };
@@ -266,6 +293,31 @@ 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;
@@ -522,7 +574,7 @@ class RiftSdk {
   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);
@@ -533,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,
@@ -544,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;
@@ -606,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");
         }
@@ -628,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)
         });
@@ -641,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,
@@ -655,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);
@@ -739,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) {
@@ -772,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
     };
@@ -802,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";
@@ -896,8 +995,8 @@ 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;
@@ -907,7 +1006,7 @@ class RiftSdk {
     }
     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({
+    const preparation = this.unwrapEdenResult(await this.riftClient.swap({ orderId: options.orderId }).cancel.prepare.post({
       deadline
     }));
     this.assertCancelWalletChain(walletClient, preparation.cancellation.chainId);
@@ -918,7 +1017,7 @@ class RiftSdk {
         ...preparation.cancellation.kind === "tee_swapper" ? { deadline: preparation.cancellation.deadline } : {}
       }
     };
-    return this.unwrapEdenResult(await this.riftClient.swap({ swapId: options.swapId }).cancel.post(request2));
+    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.14.0",
+	"version": "0.15.0",
 	"description": "SDK for swapping between bitcoin and evm chains",
 	"license": "MIT",
 	"files": [