@riftresearch/sdk 0.10.0 → 0.11.1

package/dist/index.d.ts

@@ -57,7 +57,6 @@ interface CalculatedInputAmount {
 	/** Maximum input required after slippage (optional - not all routes provide this) */
 	maximum?: U256;
 }
-type QuoteQuality = "fast" | "optimal";
 /**
 * A single fee component with amount in native currency and USD equivalent.
 */
@@ -175,6 +174,8 @@ interface EvmCallStep {
 	spenderAddress?: string;
 	/** Amount for display/verification (for approval, transfer_evm) */
 	amount?: U256;
+	/** DEX execution venue label (for dex_swap, e.g. "spandex.paraswap") */
+	venue?: string;
 }
 /**
 * BTC Transfer step - send Bitcoin to an address.
@@ -296,8 +297,6 @@ interface QuoteParameters {
 	* `minimum`/`maximum` bounds; direct OTC routes may ignore it.
 	*/
 	slippageBps: number;
-	/** Optional DEX quote quality target for DEX-backed routes. */
-	quoteQuality?: QuoteQuality;
 	/**
 	* Approval amount strategy for ERC20 swaps.
 	* - "full" (default): approve max uint256
@@ -402,12 +401,6 @@ interface RiftSdkOptions {
 	apiUrl?: string;
 	/** Enable verbose debug logging for swap execution */
 	debug?: boolean;
-	/**
-	* Controls how EVM transactions are broadcast:
-	* - "sdk" (default): wallet signs via `walletClient.signTransaction`, SDK simulates and broadcasts
-	* - "wallet": wallet signs + broadcasts via `walletClient.sendTransaction`
-	*/
-	evmBroadcastMode?: "wallet" | "sdk";
 	/** Optional preflight checks before executing swaps */
 	preflight?: {
 		/** Check sender balance before executing EVM steps (default: true) */
@@ -421,7 +414,6 @@ declare class RiftSdk {
 	private preflightCheckBalances;
 	private integratorName;
 	private debug;
-	private evmBroadcastMode;
 	constructor(options: RiftSdkOptions);
 	private logDebug;
 	private unwrapEdenResult;
@@ -462,6 +454,8 @@ declare class RiftSdk {
 	private executeBtcTransferStep;
 	private buildQuoteResult;
 	private buildSwapResult;
+	private buildDexSwapRevertMessage;
+	private resolveDexVenueLabel;
 	private assertSufficientBalance;
 	private getAddress;
 	private getRefundAddress;
@@ -476,4 +470,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, QuoteQuality, 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, GetQuoteResult, ExecutionStep, ExecutionAction, ExecuteSwapStepType, ExecuteSwapOptions, ExecuteSwapOnExecuteStepCallback, EvmChain, EvmCallStep, EvmCallKind, Erc20Token, Currency, Currencies, Chain, BtcTransferStep, BtcTransferKind, BitcoinChain };

package/dist/index.js

@@ -156,50 +156,108 @@ function getSupportedModes(from, to) {
 import { erc20Abi } from "viem";
 
 // src/client.ts
-import { treaty } from "@elysiajs/eden";
+async function request(baseUrl, path, init) {
+  try {
+    const response = await fetch(`${baseUrl}${path}`, init);
+    const status = response.status;
+    const contentType = response.headers.get("content-type") ?? "";
+    let value = null;
+    if (status !== 204) {
+      if (contentType.includes("application/json")) {
+        try {
+          value = await response.json();
+        } catch {
+          value = null;
+        }
+      } else {
+        const text = await response.text();
+        value = text.length > 0 ? text : null;
+      }
+    }
+    if (response.ok) {
+      return {
+        data: value,
+        error: null,
+        status
+      };
+    }
+    const message = value && typeof value === "object" && "error" in value && typeof value.error === "string" ? value.error : typeof value === "string" && value.length > 0 ? value : `Request failed with status ${status}`;
+    return {
+      data: null,
+      error: {
+        status,
+        value,
+        message
+      },
+      status
+    };
+  } catch (error) {
+    return {
+      data: null,
+      error: {
+        status: 0,
+        message: error instanceof Error ? error.message : String(error)
+      },
+      status: 0
+    };
+  }
+}
+function get(baseUrl, path) {
+  return request(baseUrl, path, {
+    method: "GET",
+    headers: {
+      accept: "application/json"
+    }
+  });
+}
+function postJson(baseUrl, path, body) {
+  return request(baseUrl, path, {
+    method: "POST",
+    headers: {
+      accept: "application/json",
+      "content-type": "application/json"
+    },
+    body: JSON.stringify(body)
+  });
+}
 function createClient(baseUrl) {
-  return treaty(baseUrl);
+  const normalizedBaseUrl = baseUrl.replace(/\/$/, "");
+  const swap = (params) => {
+    const swapId = encodeURIComponent(params.swapId);
+    return {
+      get: () => get(normalizedBaseUrl, `/swap/${swapId}`),
+      tx: {
+        post: (body) => postJson(normalizedBaseUrl, `/swap/${swapId}/tx`, body)
+      },
+      "refresh-step": {
+        post: (body) => postJson(normalizedBaseUrl, `/swap/${swapId}/refresh-step`, body)
+      }
+    };
+  };
+  swap.post = (body) => postJson(normalizedBaseUrl, "/swap", body);
+  return {
+    quote: {
+      post: (body) => postJson(normalizedBaseUrl, "/quote", body)
+    },
+    swap
+  };
 }
 
 // src/sdk.ts
 var GAS_LIMIT_MULTIPLIER_NUMERATOR = 3n;
 var GAS_LIMIT_MULTIPLIER_DENOMINATOR = 2n;
-var FLASHBOTS_PROTECT_RPC_URL = "https://rpc.flashbots.net";
-async function sendFlashbotsRawTransaction(serializedTransaction) {
-  const response = await fetch(FLASHBOTS_PROTECT_RPC_URL, {
-    method: "POST",
-    headers: { "content-type": "application/json" },
-    body: JSON.stringify({
-      jsonrpc: "2.0",
-      id: 1,
-      method: "eth_sendRawTransaction",
-      params: [serializedTransaction]
-    })
-  });
-  const json = await response.json().catch(() => null);
-  const errorMessage = typeof json?.error?.message === "string" ? json.error.message : undefined;
-  if (!response.ok || errorMessage) {
-    throw new Error(`Flashbots submission failed: ${errorMessage ?? `HTTP ${response.status}`}`);
-  }
-  if (!json || typeof json.result !== "string") {
-    throw new Error("Flashbots submission failed: invalid response");
-  }
-  return json.result;
-}
 
 class RiftSdk {
   riftClient;
   preflightCheckBalances;
   integratorName;
   debug;
-  evmBroadcastMode;
   constructor(options) {
     const baseUrl = (options.apiUrl ?? "https://api.rift.trade").replace(/\/$/, "");
     this.riftClient = createClient(baseUrl);
     this.preflightCheckBalances = options.preflight?.checkBalances !== false;
     this.integratorName = options.integratorName;
     this.debug = options.debug ?? false;
-    this.evmBroadcastMode = options.evmBroadcastMode ?? "sdk";
   }
   logDebug(message, data) {
     if (!this.debug)
@@ -242,8 +300,7 @@ class RiftSdk {
       from: params.from,
       to: params.to,
       amount: params.amount,
-      slippageBps: params.slippageBps,
-      quoteQuality: params.quoteQuality
+      slippageBps: params.slippageBps
     };
     const riftQuote = this.unwrapEdenResult(await this.riftClient.quote.post(quoteRequest));
     const quote = this.buildQuoteResult(riftQuote, params);
@@ -292,7 +349,7 @@ class RiftSdk {
             kind: "kind" in step ? step.kind : undefined,
             chainId: "chainId" in step ? step.chainId : undefined
           });
-          const result = await this.executeStep(step, context, swapResponse.swapId);
+          const result = await this.executeStep(step, context, swapResponse.swapId, route);
           this.logDebug("step completed", {
             stepId: step.id,
             txHash: result.txHash
@@ -324,15 +381,15 @@ class RiftSdk {
       }
     };
   }
-  async executeStep(step, context, swapId) {
+  async executeStep(step, context, swapId, route) {
     switch (step.action) {
       case "evm_call":
-        return this.executeEvmCallStep(step, context, swapId);
+        return this.executeEvmCallStep(step, context, swapId, route);
       case "btc_transfer":
         return this.executeBtcTransferStep(step, context);
     }
   }
-  async executeEvmCallStep(step, context, swapId) {
+  async executeEvmCallStep(step, context, swapId, route) {
     const walletClient = this.requireWalletClient(context);
     const publicClient = this.requirePublicClient(context);
     const account = walletClient.account;
@@ -351,32 +408,26 @@ class RiftSdk {
       }
     }
     let effectiveStep = step;
-    let refreshedForFinalSimulation = false;
-    while (true) {
-      let txRequest = {
-        account,
-        to: effectiveStep.to,
-        data: effectiveStep.calldata,
-        value: effectiveStep.value ? BigInt(effectiveStep.value) : undefined
-      };
-      let estimatedGas;
+    let txRequest = {
+      account,
+      to: effectiveStep.to,
+      data: effectiveStep.calldata,
+      value: effectiveStep.value ? BigInt(effectiveStep.value) : undefined
+    };
+    let estimatedGas;
+    try {
+      estimatedGas = await publicClient.estimateGas(txRequest);
+    } catch (estimateError) {
+      if (effectiveStep.kind !== "dex_swap") {
+        throw estimateError;
+      }
+      this.logDebug("estimateGas failed; attempting refresh-step", {
+        swapId,
+        stepId: effectiveStep.id,
+        error: estimateError instanceof Error ? estimateError.message : String(estimateError)
+      });
       try {
-        estimatedGas = await publicClient.estimateGas(txRequest);
-      } catch (estimateError) {
-        if (effectiveStep.kind !== "dex_swap") {
-          throw estimateError;
-        }
-        this.logDebug("estimateGas failed; attempting refresh-step", {
-          swapId,
-          stepId: effectiveStep.id,
-          error: estimateError instanceof Error ? estimateError.message : String(estimateError)
-        });
-        let refreshed;
-        try {
-          refreshed = this.unwrapEdenResult(await this.riftClient.swap({ swapId })["refresh-step"].post({ stepId: effectiveStep.id }));
-        } catch (refreshError) {
-          throw new Error(`estimateGas failed for dex_swap step and refresh-step failed: ${refreshError instanceof Error ? refreshError.message : String(refreshError)}`);
-        }
+        const refreshed = this.unwrapEdenResult(await this.riftClient.swap({ swapId })["refresh-step"].post({ stepId: effectiveStep.id }));
         if (!refreshed?.step) {
           throw new Error("estimateGas failed for dex_swap step and refresh-step returned no step");
         }
@@ -391,88 +442,36 @@ class RiftSdk {
           value: effectiveStep.value ? BigInt(effectiveStep.value) : undefined
         };
         estimatedGas = await publicClient.estimateGas(txRequest);
-      }
-      const gasLimit = (estimatedGas * GAS_LIMIT_MULTIPLIER_NUMERATOR + GAS_LIMIT_MULTIPLIER_DENOMINATOR - 1n) / GAS_LIMIT_MULTIPLIER_DENOMINATOR;
-      this.logDebug("using buffered gas limit", {
-        stepId: step.id,
-        estimatedGas: estimatedGas.toString(),
-        gasLimit: gasLimit.toString()
-      });
-      if (this.evmBroadcastMode === "wallet") {
-        await context.onExecuteStep?.(effectiveStep.kind === "approval" ? "approval" : "transaction");
-        const txHash2 = await walletClient.sendTransaction({
-          ...txRequest,
-          gas: gasLimit
-        });
-        const receipt2 = await publicClient.waitForTransactionReceipt({
-          hash: txHash2
-        });
-        if (receipt2.status !== "success") {
-          throw new Error(`EVM step transaction reverted (${effectiveStep.kind}) with hash ${txHash2}`);
-        }
-        return { txHash: txHash2 };
-      }
-      const nonce = await publicClient.getTransactionCount({
-        address: account.address,
-        blockTag: "pending"
-      });
-      const feeEstimate = await publicClient.estimateFeesPerGas().catch(() => {
-        return;
-      });
-      const feeParams = {};
-      if (feeEstimate?.maxFeePerGas !== undefined && feeEstimate?.maxPriorityFeePerGas !== undefined) {
-        feeParams.maxFeePerGas = feeEstimate.maxFeePerGas;
-        feeParams.maxPriorityFeePerGas = feeEstimate.maxPriorityFeePerGas;
-      } else if (feeEstimate?.gasPrice !== undefined) {
-        feeParams.gasPrice = feeEstimate.gasPrice;
-      }
-      const txToSign = {
-        ...txRequest,
-        gas: gasLimit,
-        nonce,
-        ...feeParams
-      };
-      await context.onExecuteStep?.(effectiveStep.kind === "approval" ? "approval" : "transaction");
-      const serializedTransaction = await walletClient.signTransaction(txToSign);
-      try {
-        const { nonce: _nonce, ...callRequest } = txToSign;
-        await publicClient.call({
-          ...callRequest,
-          blockTag: "pending"
-        });
-      } catch (callError) {
-        if (effectiveStep.kind === "dex_swap" && !refreshedForFinalSimulation) {
-          refreshedForFinalSimulation = true;
-          this.logDebug("final simulation failed for dex_swap; attempting refresh-step before broadcast", {
-            swapId,
-            stepId: effectiveStep.id,
-            error: callError instanceof Error ? callError.message : String(callError)
-          });
-          const refreshed = this.unwrapEdenResult(await this.riftClient.swap({ swapId })["refresh-step"].post({ stepId: effectiveStep.id }));
-          if (!refreshed?.step || refreshed.step.kind !== "dex_swap") {
-            throw new Error("refresh-step returned invalid step");
-          }
-          effectiveStep = refreshed.step;
-          continue;
-        }
-        throw callError;
-      }
-      let txHash;
-      if (effectiveStep.kind === "dex_swap" && effectiveStep.chainId === 1) {
-        txHash = await sendFlashbotsRawTransaction(serializedTransaction);
-      } else {
-        txHash = await publicClient.sendRawTransaction({
-          serializedTransaction
+      } catch (retrySimulationError) {
+        this.logDebug("dex_swap simulation failed after refresh-step attempt", {
+          swapId,
+          stepId: effectiveStep.id,
+          error: retrySimulationError instanceof Error ? retrySimulationError.message : String(retrySimulationError)
         });
+        throw new Error(this.buildDexSwapRevertMessage(route, effectiveStep.venue));
       }
-      const receipt = await publicClient.waitForTransactionReceipt({
-        hash: txHash
-      });
-      if (receipt.status !== "success") {
-        throw new Error(`EVM step transaction reverted (${effectiveStep.kind}) with hash ${txHash}`);
+    }
+    const gasLimit = (estimatedGas * GAS_LIMIT_MULTIPLIER_NUMERATOR + GAS_LIMIT_MULTIPLIER_DENOMINATOR - 1n) / GAS_LIMIT_MULTIPLIER_DENOMINATOR;
+    this.logDebug("using buffered gas limit", {
+      stepId: step.id,
+      estimatedGas: estimatedGas.toString(),
+      gasLimit: gasLimit.toString()
+    });
+    await context.onExecuteStep?.(effectiveStep.kind === "approval" ? "approval" : "transaction");
+    const txHash = await walletClient.sendTransaction({
+      ...txRequest,
+      gas: gasLimit
+    });
+    const receipt = await publicClient.waitForTransactionReceipt({
+      hash: txHash
+    });
+    if (receipt.status !== "success") {
+      if (effectiveStep.kind === "dex_swap") {
+        throw new Error(this.buildDexSwapRevertMessage(route, effectiveStep.venue, txHash));
       }
-      return { txHash };
+      throw new Error(`EVM step transaction reverted (${effectiveStep.kind}) with hash ${txHash}`);
     }
+    return { txHash };
   }
   async executeBtcTransferStep(step, context) {
     const sendBitcoin = this.requireSendBitcoin(context);
@@ -515,6 +514,17 @@ class RiftSdk {
       rift: swap
     };
   }
+  buildDexSwapRevertMessage(route, venue, txHash) {
+    const venueLabel = this.resolveDexVenueLabel(venue);
+    const baseMessage = route?.type === "dex_then_rift" ? `The pre-swap into cbBTC failed on ${venueLabel}; consider increasing slippage tolerance.` : `The DEX swap failed on ${venueLabel}; consider increasing slippage tolerance.`;
+    return txHash ? `${baseMessage} Transaction hash: ${txHash}` : baseMessage;
+  }
+  resolveDexVenueLabel(venue) {
+    if (typeof venue !== "string")
+      return "the selected venue";
+    const trimmed = venue.trim();
+    return trimmed.length > 0 ? trimmed : "the selected venue";
+  }
   async assertSufficientBalance(currency, amount, context) {
     if (currency.chain.kind !== "EVM")
       return;

package/package.json

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