@riftresearch/sdk 0.12.1 → 0.13.0

package/README.md

@@ -16,15 +16,15 @@ Then use it:
 import { RiftSdk, Currencies, createCurrency } from '@riftresearch/sdk'
 import { createPublicClient, createWalletClient, http } from 'viem'
 import { privateKeyToAccount } from 'viem/accounts'
-import { ethereum } from 'viem/chains'
+import { mainnet } from 'viem/chains'
 
 
 // Setup viem clients
 const account = privateKeyToAccount('0x...')
-const publicClient = createPublicClient({ chain: ethereum, transport: http(process.env.ETH_RPC) })
+const publicClient = createPublicClient({ chain: mainnet, transport: http(process.env.ETH_RPC) })
 const walletClient = createWalletClient({
   account,
-  chain: ethereum,
+  chain: mainnet,
   transport: http(process.env.ETH_RPC),
 })
 
@@ -67,3 +67,37 @@ 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}`)
+```

package/dist/index.d.ts

@@ -128,6 +128,10 @@ interface ExactOutputQuoteResponse extends QuoteResponseBase {
 * Use `mode` to determine which fields are specified vs calculated.
 */
 type QuoteResponse = ExactInputQuoteResponse | ExactOutputQuoteResponse;
+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 {
@@ -307,6 +311,7 @@ interface SupportedModes {
 * - EVM → EVM (same chain): both modes supported
 */
 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;
@@ -405,6 +410,16 @@ type SendBitcoinFn = (params: {
 	amountSats: string;
 }) => Promise<void>;
 type ExecuteSwapStepType = "approval" | "transaction" | "signature";
+type CreateLimitOrderOptions<chain extends Chain2 | undefined = Chain2 | undefined> = ExecuteSwapContext<chain> & {
+	from: Currency;
+	to: Currency;
+	pricing: LimitPricing;
+	destinationAddress: string;
+	refundAddress?: string;
+	approvalMode?: "full" | "partial";
+	/** 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> = {
 	/** Viem PublicClient for reading chain data */
@@ -467,6 +482,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 executeOrderFlow;
 	/**
 	* Execute a single step from the server's execution steps.
 	* Dispatch based on `action` (the execution mechanism).
@@ -502,4 +521,4 @@ declare class RiftSdk {
 	getSwapStatus(swapId: string): Promise<SwapStatusResponse>;
 }
 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, GetQuoteResult, ExecutionStep, ExecutionAction, ExecuteSwapStepType, ExecuteSwapOptions, ExecuteSwapOnExecuteStepCallback, EvmChain, EvmCallStep, EvmCallKind, Erc20Token, Currency, Currencies, 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, BtcTransferStep, BtcTransferKind, BitcoinChain };

package/dist/index.js

@@ -153,7 +153,7 @@ function getSupportedModes(from, to) {
   return { exactInput: true, exactOutput: false };
 }
 // src/sdk.ts
-import { erc20Abi } from "viem";
+import { erc20Abi, isAddress } from "viem";
 
 // src/client.ts
 async function request(baseUrl, path, init) {
@@ -225,20 +225,28 @@ function createClient(baseUrl) {
   const swap = (params) => {
     const swapId = encodeURIComponent(params.swapId);
     return {
-      get: () => get(normalizedBaseUrl, `/swap/${swapId}`),
+      get: () => get(normalizedBaseUrl, `/order/${swapId}`),
       tx: {
-        post: (body) => postJson(normalizedBaseUrl, `/swap/${swapId}/tx`, body)
+        post: (body) => postJson(normalizedBaseUrl, `/order/${swapId}/tx`, body)
       },
       "refresh-step": {
-        post: (body) => postJson(normalizedBaseUrl, `/swap/${swapId}/refresh-step`, body)
+        post: (body) => postJson(normalizedBaseUrl, `/order/${swapId}/refresh-step`, body)
       }
     };
   };
   swap.post = (body) => postJson(normalizedBaseUrl, "/swap", body);
+  const market = {
+    post: (body) => postJson(normalizedBaseUrl, "/order/market", body)
+  };
+  const limit = {
+    post: (body) => postJson(normalizedBaseUrl, "/order/limit", body)
+  };
   return {
     quote: {
       post: (body) => postJson(normalizedBaseUrl, "/quote", body)
     },
+    market,
+    limit,
     swap
   };
 }
@@ -247,6 +255,10 @@ 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;
 
 class RiftSdk {
   riftClient;
@@ -295,7 +307,6 @@ class RiftSdk {
       throw new Error("slippageBps must be between 0 and 10000");
     }
     const route = detectRoute(params.from, params.to);
-    const isMonochain = route.type === "dex_monochain";
     const quoteRequest = {
       type: params.mode === "exact_input" ? "EXACT_INPUT" : "EXACT_OUTPUT",
       from: params.from,
@@ -328,60 +339,177 @@ class RiftSdk {
           this.logDebug("running preflight balance check");
           await this.assertSufficientBalance(params.from, quote.from.expected, context);
         }
-        this.logDebug("creating swap", { quoteId: riftQuote.id });
-        const senderAddress = params.from.chain.kind === "EVM" ? this.getAddress(context) : undefined;
-        const swapResponse = this.unwrapEdenResult(await this.riftClient.swap.post({
-          id: riftQuote.id,
-          ...senderAddress ? { senderAddress } : {},
-          destinationAddress: context.destinationAddress,
-          refundAddress,
-          integratorName: this.integratorName,
-          approvalMode: params.approvalMode
-        }));
-        this.logDebug("swap created", {
-          swapId: swapResponse.swapId,
-          steps: swapResponse.executionSteps.length
-        });
-        this.assertEvmChainMatchForSteps(swapResponse.executionSteps, context);
-        for (const step of swapResponse.executionSteps) {
-          this.logDebug("executing step", {
-            stepId: step.id,
-            action: step.action,
-            kind: "kind" in step ? step.kind : undefined,
-            chainId: "chainId" in step ? step.chainId : undefined
-          });
-          const result = await this.executeStep(step, context, swapResponse.swapId, route);
-          this.logDebug("step completed", {
-            stepId: step.id,
-            txHash: result.txHash,
-            cowswapOrderId: result.cowswapOrderId
-          });
-          if (this.shouldReportStepResult(step, result)) {
-            this.logDebug("reporting step result", {
-              stepId: step.id,
-              kind: "kind" in step ? step.kind : undefined,
-              monochain: isMonochain
-            });
-            this.unwrapEdenResult(await this.riftClient.swap({ swapId: swapResponse.swapId }).tx.post({
-              stepId: step.id,
-              ...result
+        return this.executeOrderFlow({
+          context,
+          route,
+          chained: isChained,
+          createOrder: async () => {
+            this.logDebug("creating market order", { quoteId: riftQuote.id });
+            const senderAddress = params.from.chain.kind === "EVM" ? this.getAddress(context) : undefined;
+            return this.unwrapEdenResult(await this.riftClient.market.post({
+              id: riftQuote.id,
+              ...senderAddress ? { senderAddress } : {},
+              destinationAddress: context.destinationAddress,
+              refundAddress,
+              integratorName: this.integratorName,
+              approvalMode: params.approvalMode
             }));
           }
-        }
-        this.logDebug("fetching swap status", {
-          swapId: swapResponse.swapId
         });
-        const swap = this.unwrapEdenResult(await this.riftClient.swap({ swapId: swapResponse.swapId }).get());
-        this.logDebug("swap fetched", {
-          swapId: swapResponse.swapId,
-          status: swap.status
+      }
+    };
+  }
+  async createLimitOrder(options) {
+    if (!options?.destinationAddress) {
+      throw new Error("destinationAddress is required to create a limit order");
+    }
+    if (options.from.token.kind === "TOKEN") {
+      if (!isAddress(options.from.token.address)) {
+        throw new Error("from.token.address must be a valid EVM token address");
+      }
+    }
+    if (options.to.token.kind === "TOKEN" && !isAddress(options.to.token.address)) {
+      throw new Error("to.token.address must be a valid EVM token address");
+    }
+    this.assertPositiveIntegerString(options.pricing.buyAmount, "pricing.buyAmount");
+    this.assertPositiveIntegerString(options.pricing.sellAmount, "pricing.sellAmount");
+    if (options.validUntil !== undefined) {
+      this.assertValidLimitValidUntil(options.validUntil, "validUntil");
+    }
+    let refundAddress;
+    let senderAddress;
+    if (options.from.chain.kind === "BITCOIN") {
+      if (options.from.token.kind !== "NATIVE") {
+        throw new Error("BTC-start limit orders must use native BTC as the input");
+      }
+      if (!options.refundAddress) {
+        throw new Error("refundAddress is required for BTC-start limit orders (Bitcoin refund address).");
+      }
+      if (isCbBtc(options.to)) {
+        throw new Error("BTC -> cbBTC limit orders are not supported");
+      }
+      refundAddress = options.refundAddress;
+    } else {
+      senderAddress = this.getAddress(options);
+      refundAddress = options.refundAddress ?? senderAddress;
+      if (!isAddress(refundAddress)) {
+        throw new Error("refundAddress must be a valid EVM address for EVM-start limit orders");
+      }
+    }
+    if (options.to.chain.kind === "BITCOIN") {
+      if (options.from.chain.kind !== "EVM") {
+        throw new Error("Bitcoin-payout limit orders require an EVM source currency.");
+      }
+      if (isCbBtc(options.from)) {
+        throw new Error("cbBTC -> BTC limit orders are not supported");
+      }
+    } else {
+      if (!isAddress(options.destinationAddress)) {
+        throw new Error("destinationAddress must be a valid EVM address for EVM-destination limit orders");
+      }
+      if (options.to.chain.chainId !== 1 && options.to.chain.chainId !== 8453) {
+        throw new Error(`Unsupported limit order chainId: ${options.to.chain.chainId}. Expected 1 or 8453.`);
+      }
+      if (options.from.chain.kind === "EVM") {
+        if (options.from.chain.chainId !== options.to.chain.chainId) {
+          throw new Error("EVM-start limit orders currently require from/to on the same EVM chain.");
+        }
+      }
+    }
+    this.logDebug("resolved limit order refund address", { refundAddress });
+    const route = detectRoute(options.from, options.to);
+    if (this.preflightCheckBalances && options.from.chain.kind === "EVM") {
+      this.logDebug("running limit-order preflight balance check");
+      await this.assertSufficientBalance(options.from, options.pricing.sellAmount, options);
+    }
+    return this.executeOrderFlow({
+      context: options,
+      route,
+      chained: false,
+      createOrder: async () => {
+        const request2 = {
+          from: options.from,
+          to: options.to,
+          ...senderAddress ? { senderAddress } : {},
+          pricing: options.pricing,
+          destinationAddress: options.destinationAddress,
+          refundAddress,
+          ...options.approvalMode ? { approvalMode: options.approvalMode } : {},
+          ...typeof options.validUntil === "number" ? { validUntil: options.validUntil } : {},
+          integratorName: this.integratorName
+        };
+        this.logDebug("creating limit order", {
+          to: request2.to,
+          pricing: request2.pricing
         });
-        return this.buildSwapResult(swap, {
-          chained: isChained,
-          riftSwapId: swapResponse.swapId
+        return this.unwrapEdenResult(await this.riftClient.limit.post(request2));
+      }
+    });
+  }
+  assertPositiveIntegerString(value, field) {
+    if (!/^\d+$/.test(value)) {
+      throw new Error(`${field} must be a positive integer string`);
+    }
+    if (BigInt(value) <= 0n) {
+      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`);
+    }
+  }
+  async executeOrderFlow(params) {
+    const swapResponse = await params.createOrder();
+    this.logDebug("order created", {
+      swapId: swapResponse.swapId,
+      steps: swapResponse.executionSteps.length
+    });
+    this.assertEvmChainMatchForSteps(swapResponse.executionSteps, params.context);
+    for (const step of swapResponse.executionSteps) {
+      this.logDebug("executing step", {
+        stepId: step.id,
+        action: step.action,
+        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);
+      this.logDebug("step completed", {
+        stepId: step.id,
+        txHash: result.txHash,
+        cowswapOrderId: result.cowswapOrderId
+      });
+      if (this.shouldReportStepResult(step, result)) {
+        this.logDebug("reporting step result", {
+          stepId: step.id,
+          kind: "kind" in step ? step.kind : undefined
         });
+        this.unwrapEdenResult(await this.riftClient.swap({ swapId: swapResponse.swapId }).tx.post({
+          stepId: step.id,
+          ...result
+        }));
       }
-    };
+    }
+    this.logDebug("fetching swap status", {
+      swapId: swapResponse.swapId
+    });
+    const swap = this.unwrapEdenResult(await this.riftClient.swap({ swapId: swapResponse.swapId }).get());
+    this.logDebug("swap fetched", {
+      swapId: swapResponse.swapId,
+      status: swap.status
+    });
+    return this.buildSwapResult(swap, {
+      chained: params.chained,
+      riftSwapId: swapResponse.swapId
+    });
   }
   async executeStep(step, context, swapId, route) {
     switch (step.action) {

package/package.json

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