@riftresearch/sdk 0.3.0 → 0.4.0

package/README.md

@@ -28,15 +28,14 @@ const walletClient = createWalletClient({
   transport: http(process.env.ETH_RPC),
 })
 
+// Bitcoin sender implementation
+const sendBitcoin = async ({ recipient, amountSats }) => {
+  // Implement your Bitcoin wallet connection, e.g.:
+  // window.bitcoin.transfer({ recipient, amountSats })
+}
+
 // Initialize SDK
-const sdk = new RiftSdk({
-  publicClient,
-  walletClient,
-  sendBitcoin: async ({ recipient, amountSats }) => {
-    // Implement your Bitcoin wallet connection, e.g.:
-    // window.bitcoin.transfer({ recipient, amountSats })
-  },
-})
+const sdk = new RiftSdk({})
 
 // Optionally create a custom ERC-20
 const ethereumPepe = createCurrency({
@@ -58,10 +57,14 @@ console.log(`Swapping ${quote.from.amount} USDC for ${quote.to.amount} sats`)
 console.log(`Fees: $${quote.fees.totalUsd.toFixed(2)}`)
 
 // Execute the swap
-const swap = await executeSwap()
-console.log(`Swap ID: ${swap.swapId}`) // API order ID
+const swap = await executeSwap({
+  publicClient,
+  walletClient,
+  sendBitcoin,
+})
+console.log(`Swap ID: ${swap.swapId}`)
 
 // Check status
-const status = await sdk.getOrderStatus(swap.swapId)
+const status = await sdk.getSwapStatus(swap.swapId)
 console.log(`Status: ${status.status}`)
 ```

package/dist/index.d.ts

@@ -127,9 +127,10 @@ interface ExactOutputQuoteResponse extends QuoteResponseBase {
 * Use `mode` to determine which fields are specified vs calculated.
 */
 type QuoteResponse = ExactInputQuoteResponse | ExactOutputQuoteResponse;
-type OrderStatus = "waiting_for_deposit" | "deposit_confirming" | "initiating_transfer" | "confirming_transfer" | "swap_complete" | "refunding_user" | "failed";
-interface OrderStatusResponse {
-	status: OrderStatus;
+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;
@@ -192,10 +193,10 @@ interface BtcTransferStep {
 */
 type ExecutionStep = EvmCallStep | BtcTransferStep;
 /**
-* Order response with execution steps that the client must execute.
+* Swap response with execution steps that the client must execute.
 */
-interface OrderResponse {
-	/** The Rift swap/order ID */
+interface SwapResponse {
+	/** The Rift swap ID */
 	swapId: string;
 	/** Normalized quote matching /quote response */
 	quote: QuoteResponse;
@@ -266,19 +267,19 @@ type App = typeof appTyped;
 * console.log('Quote ID:', quote.id)
 * console.log('You will receive:', quote.to.amount)
 *
-* // Create an order from the quote
-* const { data: order, error: orderError } = await api.order.post({
+* // Create a swap from the quote
+* const { data: swap, error: swapError } = await api.swap.post({
 *   id: quote.id,
 *   destinationAddress: '0x...',
 *   refundAddress: 'bc1q...',
 * })
 *
-* if (order) {
-*   console.log('Deposit to:', order.deposit_vault_address)
+* if (swap) {
+*   console.log('Deposit to:', swap.deposit_vault_address)
 * }
 *
-* // Check order status
-* const { data: status } = await api.order({ orderId: order.id }).get()
+* // Check swap status
+* const { data: status } = await api.swap({ swapId: swap.id }).get()
 * ```
 */
 /** Type of the Rift API client */
@@ -323,8 +324,9 @@ interface SupportedModes {
 * - ERC20 → BTC: exact_input only (1inch is exact-input quoting)
 */
 declare function getSupportedModes(from: Currency, to: Currency): SupportedModes;
-import { PublicClient, WalletClient } from "viem";
-type RiftOrder = OrderStatusResponse;
+import { Account, PublicClient, Transport, WalletClient } from "viem";
+import { Chain as Chain2 } from "viem/chains";
+type RiftSwap = SwapStatusResponse;
 interface TradeParameters {
 	/** The currency to swap from */
 	from: Currency;
@@ -344,11 +346,6 @@ interface TradeParameters {
 	* - "partial": approve only the sell amount
 	*/
 	approvalMode?: "full" | "partial";
-	/**
-	* Slippage tolerance for the 1inch swap leg, in basis points.
-	* e.g., 50 = 0.5%, 100 = 1%
-	*/
-	preswapSlippageBps?: number;
 }
 /**
 * Base fields shared by all quote results.
@@ -388,14 +385,14 @@ interface ExactOutputQuoteResult extends QuoteResultBase {
 type QuoteResult = ExactInputQuoteResult | ExactOutputQuoteResult;
 interface GetQuoteResult {
 	quote: QuoteResult;
-	executeSwap: () => Promise<OrderResult>;
+	executeSwap: <chain extends Chain2 | undefined = Chain2 | undefined>(context?: ExecuteSwapContext<chain>) => Promise<SwapResult>;
 }
-interface OrderResult {
+interface SwapResult {
 	swapId: string;
 	status: SwapStatus2;
-	rift: RiftOrder;
+	rift: RiftSwap;
 }
-type SwapStatus2 = OrderStatus;
+type SwapStatus2 = SwapStatus;
 /**
 * Function type for sending Bitcoin.
 * Implementers provide this function to handle BTC transactions in their app.
@@ -422,13 +419,15 @@ type SendBitcoinFn = (params: {
 	/** Amount to send in satoshis */
 	amountSats: string;
 }) => Promise<void>;
-interface RiftSdkOptions {
+type ExecuteSwapContext<chain extends Chain2 | undefined = Chain2 | undefined> = {
 	/** Viem PublicClient for reading chain data */
-	publicClient: PublicClient;
+	publicClient?: PublicClient<Transport, chain>;
 	/** Viem WalletClient for signing and sending transactions */
-	walletClient: WalletClient;
+	walletClient?: WalletClient<Transport, chain, Account | undefined>;
 	/** Function to send Bitcoin (implement using your preferred wallet) */
-	sendBitcoin: SendBitcoinFn;
+	sendBitcoin?: SendBitcoinFn;
+};
+interface RiftSdkOptions {
 	/** Rift API URL. Defaults to production API */
 	apiUrl?: string;
 	/** Optional preflight checks before executing swaps */
@@ -436,13 +435,13 @@ interface RiftSdkOptions {
 		/** Check sender balance before executing EVM steps (default: true) */
 		checkBalances?: boolean;
 	};
+	/** Name of the integrator using the SDK */
+	integratorName: string;
 }
 declare class RiftSdk {
 	private riftClient;
-	private publicClient;
-	private walletClient;
-	private sendBitcoinFn;
 	private preflightCheckBalances;
+	private integratorName;
 	constructor(options: RiftSdkOptions);
 	/**
 	* Get a quote for a swap and return a function to execute it.
@@ -457,7 +456,11 @@ declare class RiftSdk {
 	* })
 	*
 	* console.log(`You'll receive: ${quote.to.amount} sats`)
-	* const swap = await executeSwap()
+	* const swap = await executeSwap({
+	*   publicClient,
+	*   walletClient,
+	*   sendBitcoin,
+	* })
 	*/
 	getQuote(params: TradeParameters): Promise<GetQuoteResult>;
 	/**
@@ -475,15 +478,19 @@ declare class RiftSdk {
 	*/
 	private executeBtcTransferStep;
 	private buildQuoteResult;
-	private buildOrderResult;
+	private buildSwapResult;
 	private assertSufficientBalance;
 	private getAddress;
 	private getRefundAddress;
 	private assertEvmChainMatch;
 	private assertEvmChainMatchForSteps;
+	private requirePublicClient;
+	private requireWalletClient;
+	private requireSendBitcoin;
 	/**
-	* Get the current status of an order by its ID.
+	* Get the current status of a swap by its ID.
 	*/
-	getOrderStatus(orderId: string): Promise<OrderStatusResponse>;
+	getSwapStatus(swapId: string): Promise<SwapStatusResponse>;
 }
-export { getSupportedModes, detectRoute, createCurrency, createClient, TradeParameters, TokenIdentifier, SwapStatus2 as SwapStatus, SwapRoute, SupportedModes, SendBitcoinFn, RiftSdkOptions, RiftSdk, RiftOrder, RiftClient, QuoteResult, OrderResult, OrderResponse, NativeToken, GetQuoteResult, ExecutionStep, ExecutionAction, EvmChain, EvmCallStep, EvmCallKind, Erc20Token, Currency, Currencies, Chain, BtcTransferStep, BtcTransferKind, BitcoinChain, App };
+declare function createRiftSdk(options: RiftSdkOptions): RiftSdk;
+export { getSupportedModes, detectRoute, createRiftSdk, createCurrency, createClient, TradeParameters, TokenIdentifier, SwapStatus2 as SwapStatus, SwapRoute, SwapResult, SwapResponse, SupportedModes, SendBitcoinFn, RiftSwap, RiftSdkOptions, RiftSdk, RiftClient, QuoteResult, NativeToken, GetQuoteResult, ExecutionStep, ExecutionAction, EvmChain, EvmCallStep, EvmCallKind, Erc20Token, Currency, Currencies, Chain, BtcTransferStep, BtcTransferKind, BitcoinChain, App };

package/dist/index.js

@@ -46,7 +46,7 @@ var Currencies = {
     }),
     USDC: createCurrency({
       chainId: 1,
-      address: "0xA0b86991c6218b36c1d19d4a2e9eb0ce3606eb48",
+      address: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
       decimals: 6
     }),
     USDT: createCurrency({
@@ -135,14 +135,14 @@ class SwapRouterClient {
   async quote(request) {
     return this.request("POST", "/quote", request);
   }
-  async createOrder(request) {
-    return this.request("POST", "/order", request);
+  async createSwap(request) {
+    return this.request("POST", "/swap", request);
   }
-  async getOrder(orderId) {
-    return this.request("GET", `/order/${orderId}`);
+  async getSwap(swapId) {
+    return this.request("GET", `/swap/${swapId}`);
   }
-  async reportStepResult(orderId, result) {
-    await this.request("POST", `/order/${orderId}/tx`, result);
+  async reportStepResult(swapId, result) {
+    await this.request("POST", `/swap/${swapId}/tx`, result);
   }
 }
 // src/client.ts
@@ -210,18 +210,14 @@ function getSupportedModes(from, to) {
 import { erc20Abi } from "viem";
 class RiftSdk {
   riftClient;
-  publicClient;
-  walletClient;
-  sendBitcoinFn;
   preflightCheckBalances;
+  integratorName;
   constructor(options) {
     this.riftClient = new SwapRouterClient({
       baseUrl: options.apiUrl ?? "https://router-api-v2-production.up.railway.app"
     });
-    this.publicClient = options.publicClient;
-    this.walletClient = options.walletClient;
-    this.sendBitcoinFn = options.sendBitcoin;
     this.preflightCheckBalances = options.preflight?.checkBalances !== false;
+    this.integratorName = options.integratorName;
   }
   async getQuote(params) {
     const route = detectRoute(params.from, params.to);
@@ -237,50 +233,53 @@ class RiftSdk {
     const isChained = route.type === "direct_rift" && route.direction === "from_btc" && !isCbBtc(params.to);
     return {
       quote,
-      executeSwap: async () => {
-        const refundAddress = params.refundAddress ?? this.getRefundAddress(params);
+      executeSwap: async (context = {}) => {
+        const refundAddress = params.refundAddress ?? this.getRefundAddress(params, context);
         if (this.preflightCheckBalances) {
-          await this.assertSufficientBalance(params.from, quote.from.amount);
+          await this.assertSufficientBalance(params.from, quote.from.amount, context);
         }
-        const orderResponse = await this.riftClient.createOrder({
+        const swapResponse = await this.riftClient.createSwap({
           id: riftQuote.id,
           destinationAddress: params.destinationAddress,
           refundAddress,
+          integratorName: this.integratorName,
           approvalMode: params.approvalMode
         });
-        this.assertEvmChainMatchForSteps(orderResponse.executionSteps);
-        for (const step of orderResponse.executionSteps) {
-          const result = await this.executeStep(step);
+        this.assertEvmChainMatchForSteps(swapResponse.executionSteps, context);
+        for (const step of swapResponse.executionSteps) {
+          const result = await this.executeStep(step, context);
           if (isMonochain && step.action === "evm_call" && step.kind === "oneinch_swap" && result.txHash) {
-            await this.riftClient.reportStepResult(orderResponse.swapId, {
+            await this.riftClient.reportStepResult(swapResponse.swapId, {
               stepId: step.id,
               ...result
             });
           }
         }
-        const swap = await this.riftClient.getOrder(orderResponse.swapId);
-        return this.buildOrderResult(swap, {
+        const swap = await this.riftClient.getSwap(swapResponse.swapId);
+        return this.buildSwapResult(swap, {
           chained: isChained,
-          riftOrderId: orderResponse.swapId
+          riftSwapId: swapResponse.swapId
         });
       }
     };
   }
-  async executeStep(step) {
+  async executeStep(step, context) {
     switch (step.action) {
       case "evm_call":
-        return this.executeEvmCallStep(step);
+        return this.executeEvmCallStep(step, context);
       case "btc_transfer":
-        return this.executeBtcTransferStep(step);
+        return this.executeBtcTransferStep(step, context);
     }
   }
-  async executeEvmCallStep(step) {
-    const account = this.walletClient.account;
+  async executeEvmCallStep(step, context) {
+    const walletClient = this.requireWalletClient(context);
+    const publicClient = this.requirePublicClient(context);
+    const account = walletClient.account;
     if (!account) {
       throw new Error("No account configured on wallet client");
     }
     if (step.kind === "approval" && step.tokenAddress && step.spenderAddress && step.amount) {
-      const allowance = await this.publicClient.readContract({
+      const allowance = await publicClient.readContract({
         address: step.tokenAddress,
         abi: erc20Abi,
         functionName: "allowance",
@@ -290,18 +289,18 @@ class RiftSdk {
         return {};
       }
     }
-    const txHash = await this.walletClient.sendTransaction({
+    const txHash = await walletClient.sendTransaction({
       account,
       to: step.to,
       data: step.calldata,
-      value: step.value ? BigInt(step.value) : undefined,
-      chain: this.walletClient.chain
+      value: step.value ? BigInt(step.value) : undefined
     });
-    await this.publicClient.waitForTransactionReceipt({ hash: txHash });
+    await publicClient.waitForTransactionReceipt({ hash: txHash });
     return { txHash };
   }
-  async executeBtcTransferStep(step) {
-    await this.sendBitcoinFn({
+  async executeBtcTransferStep(step, context) {
+    const sendBitcoin = this.requireSendBitcoin(context);
+    await sendBitcoin({
       recipient: step.toAddress,
       amountSats: step.amountSats
     });
@@ -328,31 +327,32 @@ class RiftSdk {
       };
     }
   }
-  buildOrderResult(swap, options) {
-    const riftOrderId = options?.riftOrderId;
-    if (!riftOrderId) {
-      throw new Error("Missing rift order id for order result.");
+  buildSwapResult(swap, options) {
+    const riftSwapId = options?.riftSwapId;
+    if (!riftSwapId) {
+      throw new Error("Missing rift swap id for swap result.");
     }
     return {
-      swapId: riftOrderId,
+      swapId: riftSwapId,
       status: swap.status,
       rift: swap
     };
   }
-  async assertSufficientBalance(currency, amount) {
+  async assertSufficientBalance(currency, amount, context) {
     if (currency.chain.kind !== "EVM")
       return;
-    this.assertEvmChainMatch(currency.chain.chainId);
+    this.assertEvmChainMatch(currency.chain.chainId, context);
     const required = BigInt(amount);
-    const owner = this.getAddress();
+    const owner = this.getAddress(context);
+    const publicClient = this.requirePublicClient(context);
     if (currency.token.kind === "NATIVE") {
-      const balance2 = await this.publicClient.getBalance({ address: owner });
+      const balance2 = await publicClient.getBalance({ address: owner });
       if (balance2 < required) {
         throw new Error(`Insufficient balance for native token. Need ${required.toString()}, have ${balance2.toString()}`);
       }
       return;
     }
-    const balance = await this.publicClient.readContract({
+    const balance = await publicClient.readContract({
       address: currency.token.address,
       abi: erc20Abi,
       functionName: "balanceOf",
@@ -362,28 +362,31 @@ class RiftSdk {
       throw new Error(`Insufficient balance for token ${currency.token.address}. Need ${required.toString()}, have ${balance.toString()}`);
     }
   }
-  getAddress() {
-    const account = this.walletClient.account;
+  getAddress(context) {
+    const walletClient = this.requireWalletClient(context);
+    const account = walletClient.account;
     if (!account) {
       throw new Error("No account configured on wallet client");
     }
     return account.address;
   }
-  getRefundAddress(params) {
+  getRefundAddress(params, context) {
     if (params.from.chain.kind === "BITCOIN") {
       throw new Error("refundAddress is required for BTC swaps (Bitcoin refund address)");
     }
-    return this.getAddress();
+    return this.getAddress(context);
   }
-  assertEvmChainMatch(expectedChainId) {
-    const walletChainId = this.walletClient.chain?.id;
+  assertEvmChainMatch(expectedChainId, context) {
+    const walletClient = this.requireWalletClient(context);
+    const publicClient = this.requirePublicClient(context);
+    const walletChainId = walletClient.chain?.id;
     if (!walletChainId) {
       throw new Error("Wallet client is missing an EVM chain configuration");
     }
     if (walletChainId !== expectedChainId) {
       throw new Error(`Wallet client chain mismatch. Expected ${expectedChainId}, got ${walletChainId}`);
     }
-    const publicChainId = this.publicClient.chain?.id;
+    const publicChainId = publicClient.chain?.id;
     if (!publicChainId) {
       throw new Error("Public client is missing an EVM chain configuration");
     }
@@ -391,7 +394,7 @@ class RiftSdk {
       throw new Error(`Public client chain mismatch. Expected ${expectedChainId}, got ${publicChainId}`);
     }
   }
-  assertEvmChainMatchForSteps(steps) {
+  assertEvmChainMatchForSteps(steps, context) {
     const evmSteps = steps.filter((step) => step.action === "evm_call");
     const firstStep = evmSteps[0];
     if (!firstStep)
@@ -402,15 +405,37 @@ class RiftSdk {
         throw new Error(`Mixed EVM chain IDs in execution steps. Expected ${expectedChainId}, got ${step.chainId}`);
       }
     }
-    this.assertEvmChainMatch(expectedChainId);
+    this.assertEvmChainMatch(expectedChainId, context);
   }
-  async getOrderStatus(orderId) {
-    return this.riftClient.getOrder(orderId);
+  requirePublicClient(context) {
+    if (!context.publicClient) {
+      throw new Error("publicClient is required to execute EVM steps");
+    }
+    return context.publicClient;
+  }
+  requireWalletClient(context) {
+    if (!context.walletClient) {
+      throw new Error("walletClient is required to execute EVM steps");
+    }
+    return context.walletClient;
   }
+  requireSendBitcoin(context) {
+    if (!context.sendBitcoin) {
+      throw new Error("sendBitcoin is required to execute BTC transfers");
+    }
+    return context.sendBitcoin;
+  }
+  async getSwapStatus(swapId) {
+    return this.riftClient.getSwap(swapId);
+  }
+}
+function createRiftSdk(options) {
+  return new RiftSdk(options);
 }
 export {
   getSupportedModes,
   detectRoute,
+  createRiftSdk,
   createCurrency,
   createClient,
   RiftSdk,

package/package.json

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