@riftresearch/sdk 0.2.4 → 0.4.0

package/README.md

@@ -13,44 +13,41 @@ npm install @riftresearch/sdk
 Then use it:
 
 ```ts
-import { RiftSdk, BTC, type Currency } from '@riftresearch/sdk'
+import { RiftSdk, Currencies, createCurrency } from '@riftresearch/sdk'
 import { createPublicClient, createWalletClient, http } from 'viem'
 import { privateKeyToAccount } from 'viem/accounts'
-import { base } from 'viem/chains'
+import { ethereum } from 'viem/chains'
 
-// Define USDC on Base
-const USDC_BASE: Currency = {
-  chain: { kind: 'EVM', chainId: 8453 },
-  token: {
-    kind: 'TOKEN',
-    address: '0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913',
-    decimals: 6,
-  },
-}
 
 // Setup viem clients
 const account = privateKeyToAccount('0x...')
-const publicClient = createPublicClient({ chain: base, transport: http() })
+const publicClient = createPublicClient({ chain: ethereum, transport: http(process.env.ETH_RPC) })
 const walletClient = createWalletClient({
   account,
-  chain: base,
-  transport: http(),
+  chain: ethereum,
+  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({
+  chainId: 1,
+  address: '0x6982508145454Ce325dDbE47a25d4ec3d2311933',
+  decimals: 18,
 })
 
 // Get a quote
 const { quote, executeSwap } = await sdk.getQuote({
-  from: USDC_BASE,
-  to: BTC,
+  from: Currencies.Ethereum.USDC,
+  to: Currencies.Bitcoin.BTC,
   amount: '100000000', // 100 USDC (6 decimals)
   mode: 'exact_input',
   destinationAddress: 'bc1q...',
@@ -60,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,22 +193,41 @@ 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;
 	/** Ordered list of steps the client must execute */
 	executionSteps: ExecutionStep[];
 }
-/** Native BTC on Bitcoin */
-declare const BTC: Currency;
-/** cbBTC on Ethereum mainnet */
-declare const CBBTC_ETHEREUM: Currency;
-/** cbBTC on Base */
-declare const CBBTC_BASE: Currency;
+/** Create an ERC-20 currency on an EVM chain */
+declare function createCurrency(params: {
+	chainId: number;
+	address: string;
+	decimals: number;
+}): Currency;
+declare const Currencies: {
+	Bitcoin: {
+		BTC: Currency;
+	};
+	Ethereum: {
+		ETH: Currency;
+		WETH: Currency;
+		USDC: Currency;
+		USDT: Currency;
+		CBBTC: Currency;
+		WBTC: Currency;
+	};
+	Base: {
+		ETH: Currency;
+		WETH: Currency;
+		USDC: Currency;
+		CBBTC: Currency;
+	};
+};
 import { treaty } from "@elysiajs/eden";
 import { Elysia } from "elysia";
 declare const app: Elysia;
@@ -247,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 */
@@ -304,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;
@@ -325,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.
@@ -369,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.
@@ -403,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 */
@@ -417,28 +435,32 @@ 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.
 	*
 	* @example
 	* const { quote, executeSwap } = await sdk.getQuote({
-	*   from: CBBTC_BASE,
-	*   to: BTC,
+	*   from: Currencies.Base.CBBTC,
+	*   to: Currencies.Bitcoin.BTC,
 	*   amount: '100000000', // 1 cbBTC
 	*   mode: 'exact_input',
 	*   destinationAddress: 'bc1q...',
 	* })
 	*
 	* 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>;
 	/**
@@ -456,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, 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, Chain, CBBTC_ETHEREUM, CBBTC_BASE, BtcTransferStep, BtcTransferKind, BitcoinChain, BTC, 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

@@ -17,17 +17,73 @@ var CBBTC_TOKEN = {
   address: CBBTC_ADDRESS,
   decimals: 8
 };
-var BTC = {
-  chain: BTC_CHAIN,
-  token: { kind: "NATIVE", decimals: 8 }
-};
-var CBBTC_ETHEREUM = {
-  chain: ETH_CHAIN,
-  token: CBBTC_TOKEN
-};
-var CBBTC_BASE = {
-  chain: BASE_CHAIN,
-  token: CBBTC_TOKEN
+function createCurrency(params) {
+  return {
+    chain: { kind: "EVM", chainId: params.chainId },
+    token: {
+      kind: "TOKEN",
+      address: params.address,
+      decimals: params.decimals
+    }
+  };
+}
+var Currencies = {
+  Bitcoin: {
+    BTC: {
+      chain: BTC_CHAIN,
+      token: { kind: "NATIVE", decimals: 8 }
+    }
+  },
+  Ethereum: {
+    ETH: {
+      chain: ETH_CHAIN,
+      token: { kind: "NATIVE", decimals: 18 }
+    },
+    WETH: createCurrency({
+      chainId: 1,
+      address: "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2",
+      decimals: 18
+    }),
+    USDC: createCurrency({
+      chainId: 1,
+      address: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
+      decimals: 6
+    }),
+    USDT: createCurrency({
+      chainId: 1,
+      address: "0xdAC17F958D2ee523a2206206994597C13D831ec7",
+      decimals: 6
+    }),
+    CBBTC: {
+      chain: ETH_CHAIN,
+      token: CBBTC_TOKEN
+    },
+    WBTC: createCurrency({
+      chainId: 1,
+      address: "0x2260FAC5E5542a773Aa44fBCfeDf7C193bc2C599",
+      decimals: 8
+    })
+  },
+  Base: {
+    ETH: {
+      chain: BASE_CHAIN,
+      token: { kind: "NATIVE", decimals: 18 }
+    },
+    WETH: createCurrency({
+      chainId: 8453,
+      address: "0x4200000000000000000000000000000000000006",
+      decimals: 18
+    }),
+    USDC: createCurrency({
+      chainId: 8453,
+      address: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
+      decimals: 6
+    }),
+    CBBTC: {
+      chain: BASE_CHAIN,
+      token: CBBTC_TOKEN
+    }
+  }
 };
 // src/apiClient.ts
 class SwapRouterApiError extends Error {
@@ -79,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
@@ -154,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);
@@ -181,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",
@@ -234,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
     });
@@ -272,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",
@@ -306,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");
     }
@@ -335,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)
@@ -346,18 +405,39 @@ 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,
-  CBBTC_ETHEREUM,
-  CBBTC_BASE,
-  BTC
+  Currencies
 };

package/package.json

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