@riftresearch/sdk 0.5.0 → 0.6.0

package/dist/index.d.ts

@@ -1,10 +1,241 @@
-import { BtcTransferKind, BtcTransferStep, Currencies, createCurrency, EvmCallKind, EvmCallStep, ExecutionAction, ExecutionStep, SwapResponse as SwapResponse2 } from "@riftresearch/common";
+/**
+* Core domain types for Rift Swap Router.
+* Shared between SDK and server packages.
+*/
+type Address = string;
+type TxHash = string;
+type U256 = string;
+type BitcoinChain = {
+	kind: "BITCOIN";
+};
+type EvmChain = {
+	kind: "EVM";
+	chainId: number;
+};
+type Chain = BitcoinChain | EvmChain;
+type NativeToken = {
+	kind: "NATIVE";
+	decimals: number;
+};
+type Erc20Token = {
+	kind: "TOKEN";
+	address: string;
+	decimals: number;
+};
+type TokenIdentifier = NativeToken | Erc20Token;
+interface Currency {
+	chain: Chain;
+	token: TokenIdentifier;
+}
+/**
+* A currency amount that was specified by the user (exact).
+*/
+interface SpecifiedAmount {
+	currency: Currency;
+	amount: U256;
+}
+/**
+* A calculated output amount for exact_input mode.
+* The user specifies exact input, and this represents the expected output.
+*/
+interface CalculatedOutputAmount {
+	currency: Currency;
+	/** Expected output based on current market conditions */
+	amount: U256;
+	/** Minimum guaranteed output after slippage (optional - not all routes provide this) */
+	minimum?: U256;
+}
+/**
+* A calculated input amount for exact_output mode.
+* The user specifies exact output, and this represents the expected input.
+*/
+interface CalculatedInputAmount {
+	currency: Currency;
+	/** Expected input based on current market conditions */
+	amount: U256;
+	/** 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.
+*/
+interface FeeComponent {
+	/** Amount in the smallest unit of the currency */
+	amount: U256;
+	/** The currency this fee is denominated in */
+	currency: Currency;
+	/** USD equivalent of the fee */
+	usd: number;
+}
+/**
+* Rift protocol fees broken down by type.
+*/
+interface RiftFees {
+	/** Bitcoin network transaction fee */
+	network: FeeComponent;
+	/** Fee paid to liquidity providers */
+	liquidity: FeeComponent;
+	/** Rift protocol fee */
+	protocol: FeeComponent;
+}
+/**
+* Complete fee breakdown for a swap quote.
+* Shows fees from each leg of the swap in their native currencies.
+*/
+interface FeeBreakdown {
+	/** Fees from DEX swap BEFORE Rift (e.g., 1inch USDC → cbBTC) */
+	preswap?: FeeComponent;
+	/** Fees from the Rift protocol (optional for mono-chain swaps) */
+	rift?: RiftFees;
+	/** Fees from DEX swap AFTER Rift (e.g., Swapper cbBTC → USDC) */
+	postswap?: FeeComponent;
+	/** Total fees in USD across all legs */
+	totalUsd: number;
+}
+/**
+* Base fields shared by all quote responses.
+*/
+interface QuoteResponseBase {
+	id: string;
+	fees: FeeBreakdown;
+	expiresAt: string;
+}
+/**
+* Quote response for exact_input mode.
+* User specifies exact input amount, output is calculated with slippage bound.
+*/
+interface ExactInputQuoteResponse extends QuoteResponseBase {
+	mode: "exact_input";
+	/** The exact input amount specified by the user */
+	from: SpecifiedAmount;
+	/** The calculated output amount with slippage bound */
+	to: CalculatedOutputAmount;
+}
+/**
+* Quote response for exact_output mode.
+* User specifies exact output amount, input is calculated with slippage bound.
+*/
+interface ExactOutputQuoteResponse extends QuoteResponseBase {
+	mode: "exact_output";
+	/** The calculated input amount with slippage bound */
+	from: CalculatedInputAmount;
+	/** The exact output amount specified by the user */
+	to: SpecifiedAmount;
+}
+/**
+* Discriminated union of quote responses.
+* Use `mode` to determine which fields are specified vs calculated.
+*/
+type QuoteResponse = ExactInputQuoteResponse | ExactOutputQuoteResponse;
+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;
+}
+interface ErrorResponse {
+	error: string;
+}
+/**
+* Execution actions - the mechanism by which a step is executed.
+*/
+type ExecutionAction = "evm_call" | "btc_transfer";
+/**
+* Step kinds grouped by action type.
+*/
+type EvmCallKind = "approval" | "transfer_erc20" | "oneinch_swap" | "dex_swap";
+type BtcTransferKind = "transfer_btc";
+/**
+* EVM Call step - execute calldata on an EVM chain.
+* Used for: token approvals, ERC20 transfers, and DEX swaps.
+*/
+interface EvmCallStep {
+	/** Step ID for tracking */
+	id: string;
+	/** Execution mechanism */
+	action: "evm_call";
+	/** Specific step type */
+	kind: EvmCallKind;
+	/** Chain ID for the transaction */
+	chainId: number;
+	/** Contract address to call */
+	to: string;
+	/** Encoded calldata */
+	calldata: string;
+	/** Native ETH value to send (for swap steps) */
+	value?: U256;
+	/** Token address (for approval, transfer_evm) */
+	tokenAddress?: string;
+	/** Spender address (for approval) */
+	spenderAddress?: string;
+	/** Amount for display/verification (for approval, transfer_evm) */
+	amount?: U256;
+}
+/**
+* BTC Transfer step - send Bitcoin to an address.
+* Used for: depositing BTC to Rift vault.
+*/
+interface BtcTransferStep {
+	/** Step ID for tracking */
+	id: string;
+	/** Execution mechanism */
+	action: "btc_transfer";
+	/** Specific step type */
+	kind: BtcTransferKind;
+	/** Bitcoin address to send to */
+	toAddress: string;
+	/** Amount in satoshis */
+	amountSats: U256;
+}
+/**
+* Discriminated union of all execution step types.
+* Discriminate on `action` for execution logic, or `kind` for specific handling.
+*/
+type ExecutionStep = EvmCallStep | BtcTransferStep;
+/**
+* Swap response with execution steps that the client must execute.
+*/
+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[];
+}
+/** 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 { ErrorResponse } from "@riftresearch/common";
 import { Elysia } from "elysia";
 import { RiftOtcApi } from "../lib";
-import { SwapResponse, SwapStatusResponse } from "@riftresearch/common";
-import { SwapRequest } from "../../../common/types";
+import { SwapRequest as SwapRequest2 } from "../../../common/types";
 import { CachedQuote, ISwapMappingStore } from "../../../lib/cache";
 import { OtcClient as OtcClient2 } from "../../../lib/rift-otc-api";
 import { SwapperClient } from "../../../lib/rift-swapper-api";
@@ -22,7 +253,7 @@ declare class OrderService {
 	* Create a swap using the cached quote with raw JSON.
 	* Returns SwapResponse with execution steps the client must execute.
 	*/
-	createSwap(request: SwapRequest, cachedQuote: CachedQuote): Promise<SwapResponse>;
+	createSwap(request: SwapRequest2, cachedQuote: CachedQuote): Promise<SwapResponse>;
 	/**
 	* Create a direct cbBTC ↔ BTC swap order.
 	* Returns execution steps: either DepositBtc (for BTC → cbBTC) or Approval + DepositEvm (for cbBTC → BTC)
@@ -83,7 +314,7 @@ declare class OrderService {
 	private normalizeTxHash;
 	private isEvmChain;
 }
-import { QuoteRequest, QuoteResponse } from "../../../common/types";
+import { QuoteRequest as QuoteRequest2, QuoteResponse as QuoteResponse2 } from "../../../common/types";
 import { CachedQuote as CachedQuote2, IQuoteCache } from "../../../lib/cache";
 import { RfqClient as RfqClient2 } from "../../../lib/rift-otc-api";
 import { SwapperClient as SwapperClient2 } from "../../../lib/rift-swapper-api";
@@ -98,7 +329,7 @@ declare class QuoteService {
 	private readonly priceOracle;
 	private readonly oneinchProvider;
 	constructor(quoteCache: IQuoteCache, rfqClient: RfqClient2, swapperClient: SwapperClient2 | null);
-	getQuote(request: QuoteRequest): Promise<QuoteResponse>;
+	getQuote(request: QuoteRequest2): Promise<QuoteResponse2>;
 	/** Get the cached quote with raw JSON for order creation */
 	getCachedQuoteById(id: string): Promise<CachedQuote2 | null>;
 	/** Atomically consume a cached quote to prevent reuse */
@@ -1335,14 +1566,14 @@ declare class SwapRouterApiError extends Error {
 /**
 * Create a type-safe API client for the Rift Swap Router.
 *
-* @param baseUrl - The base URL of the swap router API (e.g., 'https://router-api-v2-production.up.railway.app')
+* @param baseUrl - The base URL of the swap router API (e.g., 'https://api.rift.trade')
 * @returns A fully typed Eden Treaty client
 *
 * @example
 * ```typescript
 * import { createClient } from '@riftresearch/sdk'
 *
-* const api = createClient('https://router-api-v2-production.up.railway.app')
+* const api = createClient('https://api.rift.trade')
 *
 * // Get a quote - fully typed request and response
 * const { data: quote, error } = await api.quote.post({
@@ -1384,31 +1615,30 @@ declare class SwapRouterApiError extends Error {
 /** Type of the Rift API client */
 type RiftClient = Treaty.Create<App>;
 declare function createClient(baseUrl: string): RiftClient;
-import { Currency } from "@riftresearch/common";
 /**
 * Discriminated union of all possible swap routes.
 *
 * - direct_rift: BTC <-> EVM token (Rift handles directly)
-* - oneinch_then_rift: ERC20 (non-cbBTC) -> BTC (1inch to cbBTC, then Rift to BTC)
-* - oneinch_monochain: EVM token -> EVM token (single-chain 1inch swap)
+* - dex_then_rift: ERC20 (non-cbBTC) -> BTC (DEX to cbBTC, then Rift to BTC)
+* - dex_monochain: EVM token -> EVM token (single-chain DEX swap)
 */
 type SwapRoute = {
 	type: "direct_rift";
 	direction: "to_btc" | "from_btc";
 } | {
-	type: "oneinch_then_rift";
+	type: "dex_then_rift";
 	evmChainId: number;
 } | {
-	type: "oneinch_monochain";
+	type: "dex_monochain";
 	evmChainId: number;
 };
 /**
 * Detect the appropriate swap route based on currency pair.
 *
 * Routes:
-* - EVM token → BTC: direct_rift (to_btc) for cbBTC, oneinch_then_rift for other ERC20s
+* - EVM token → BTC: direct_rift (to_btc) for cbBTC, dex_then_rift for other ERC20s
 * - BTC → EVM token: direct_rift (from_btc) - Rift handles all BTC -> EVM swaps directly
-* - EVM token → EVM token (same chain): oneinch_monochain
+* - EVM token → EVM token (same chain): dex_monochain
 */
 declare function detectRoute(from: Currency, to: Currency): SwapRoute;
 interface SupportedModes {
@@ -1421,24 +1651,23 @@ interface SupportedModes {
 * - cbBTC ↔ BTC: both modes supported
 * - BTC → cbBTC: both modes supported
 * - BTC → ERC20 (non-cbBTC): only exact_input (Rift doesn't support exact_output for chained swaps)
-* - ERC20 → BTC: exact_input only (1inch is exact-input quoting)
+* - ERC20 → BTC: both modes supported
 */
 declare function getSupportedModes(from: Currency, to: Currency): SupportedModes;
-import { SwapStatusResponse as SwapStatusResponse3 } from "@riftresearch/common";
-import { SwapStatus as ApiSwapStatus, CalculatedInputAmount, CalculatedOutputAmount, Currency as Currency2, FeeBreakdown, SpecifiedAmount, SwapStatusResponse as SwapStatusResponse2 } from "@riftresearch/common";
 import { Account, PublicClient, Transport, WalletClient } from "viem";
-import { Chain } from "viem/chains";
-import { BitcoinChain, Chain as Chain2, Currency as Currency3, Erc20Token, EvmChain, NativeToken, TokenIdentifier } from "@riftresearch/common";
-type RiftSwap = SwapStatusResponse2;
+import { Chain as Chain2 } from "viem/chains";
+type RiftSwap = SwapStatusResponse;
 interface QuoteParameters {
 	/** The currency to swap from */
-	from: Currency2;
+	from: Currency;
 	/** The currency to swap to */
-	to: Currency2;
+	to: Currency;
 	/** Amount in smallest unit (sats for BTC, wei for ETH, etc.) */
 	amount: string;
 	/** Whether amount refers to input or output */
 	mode: "exact_input" | "exact_output";
+	/** Optional DEX quote quality target for DEX-backed routes. */
+	quoteQuality?: QuoteQuality;
 	/**
 	* Approval amount strategy for ERC20 swaps.
 	* - "full" (default): approve max uint256
@@ -1484,14 +1713,14 @@ interface ExactOutputQuoteResult extends QuoteResultBase {
 type QuoteResult = ExactInputQuoteResult | ExactOutputQuoteResult;
 interface GetQuoteResult {
 	quote: QuoteResult;
-	executeSwap: <chain extends Chain | undefined = Chain | undefined>(context: ExecuteSwapOptions<chain>) => Promise<SwapResult>;
+	executeSwap: <chain extends Chain2 | undefined = Chain2 | undefined>(context: ExecuteSwapOptions<chain>) => Promise<SwapResult>;
 }
 interface SwapResult {
 	swapId: string;
-	status: SwapStatus;
+	status: SwapStatus2;
 	rift: RiftSwap;
 }
-type SwapStatus = ApiSwapStatus;
+type SwapStatus2 = SwapStatus;
 /**
 * Function type for sending Bitcoin.
 * Implementers provide this function to handle BTC transactions in their app.
@@ -1518,7 +1747,7 @@ type SendBitcoinFn = (params: {
 	/** Amount to send in satoshis */
 	amountSats: string;
 }) => Promise<void>;
-type ExecuteSwapContext<chain extends Chain | undefined = Chain | undefined> = {
+type ExecuteSwapContext<chain extends Chain2 | undefined = Chain2 | undefined> = {
 	/** Viem PublicClient for reading chain data */
 	publicClient?: PublicClient<Transport, chain>;
 	/** Viem WalletClient for signing and sending transactions */
@@ -1526,7 +1755,7 @@ type ExecuteSwapContext<chain extends Chain | undefined = Chain | undefined> = {
 	/** Function to send Bitcoin (implement using your preferred wallet) */
 	sendBitcoin?: SendBitcoinFn;
 };
-type ExecuteSwapOptions<chain extends Chain | undefined = Chain | undefined> = ExecuteSwapContext<chain> & {
+type ExecuteSwapOptions<chain extends Chain2 | undefined = Chain2 | undefined> = ExecuteSwapContext<chain> & {
 	/** Address to receive the output tokens */
 	destinationAddress: string;
 	/** Address to receive refunds if swap fails. Defaults to source wallet address */
@@ -1580,7 +1809,7 @@ declare class RiftSdk {
 	private executeStep;
 	/**
 	* Execute an EVM call step - send a transaction with calldata.
-	* Handles: approval, transfer_evm, oneinch_swap
+	* Handles: approval, transfer_evm, dex_swap
 	*/
 	private executeEvmCallStep;
 	/**
@@ -1600,7 +1829,7 @@ declare class RiftSdk {
 	/**
 	* Get the current status of a swap by its ID.
 	*/
-	getSwapStatus(swapId: string): Promise<SwapStatusResponse3>;
+	getSwapStatus(swapId: string): Promise<SwapStatusResponse>;
 }
 declare function createRiftSdk(options: RiftSdkOptions): RiftSdk;
-export { getSupportedModes, detectRoute, createRiftSdk, createCurrency, createClient, TokenIdentifier, SwapStatus, SwapRouterApiError, SwapRoute, SwapResult, SwapResponse2 as SwapResponse, SupportedModes, SendBitcoinFn, RiftSwap, RiftSdkOptions, RiftSdk, RiftClient, QuoteResult, QuoteParameters, NativeToken, GetQuoteResult, ExecutionStep, ExecutionAction, ExecuteSwapOptions, EvmChain, EvmCallStep, EvmCallKind, Erc20Token, Currency3 as Currency, Currencies, Chain2 as Chain, BtcTransferStep, BtcTransferKind, BitcoinChain, App };
+export { getSupportedModes, detectRoute, createRiftSdk, createCurrency, createClient, TokenIdentifier, SwapStatus2 as SwapStatus, SwapRouterApiError, SwapRoute, SwapResult, SwapResponse, SupportedModes, SendBitcoinFn, RiftSwap, RiftSdkOptions, RiftSdk, RiftClient, QuoteResult, QuoteQuality, QuoteParameters, NativeToken, GetQuoteResult, ExecutionStep, ExecutionAction, ExecuteSwapOptions, EvmChain, EvmCallStep, EvmCallKind, Erc20Token, Currency, Currencies, Chain, BtcTransferStep, BtcTransferKind, BitcoinChain, App };

package/dist/index.js

@@ -1,4 +1,4 @@
-// ../common/dist/index.js
+// ../common/src/constants.ts
 var CBBTC_ADDRESS = "0xcbB7C0000aB88B473b1f5aFd9ef808440eed33Bf";
 var CBBTC_ADDRESS_LOWER = CBBTC_ADDRESS.toLowerCase();
 var BTC_CHAIN = {
@@ -106,35 +106,35 @@ import { match, P } from "ts-pattern";
 var CBBTC_ADDRESS2 = "0xcbb7c0000ab88b473b1f5afd9ef808440eed33bf";
 var isBitcoin = (currency) => currency.chain.kind === "BITCOIN";
 var isCbBtc = (currency) => currency.chain.kind === "EVM" && currency.token.kind === "TOKEN" && currency.token.address.toLowerCase() === CBBTC_ADDRESS2;
-var isEvmToken = (currency) => currency.chain.kind === "EVM";
-var isSameEvmChain = (a, b) => a.chain.kind === "EVM" && b.chain.kind === "EVM" && a.chain.chainId === b.chain.chainId;
+var isEvmToken2 = (currency) => currency.chain.kind === "EVM";
+var isSameEvmChain2 = (a, b) => a.chain.kind === "EVM" && b.chain.kind === "EVM" && a.chain.chainId === b.chain.chainId;
 function detectRoute(from, to) {
   return match({ from, to }).with({ from: P.when(isCbBtc), to: P.when(isBitcoin) }, () => ({
     type: "direct_rift",
     direction: "to_btc"
-  })).with({ from: P.when(isBitcoin), to: P.when(isEvmToken) }, () => ({
+  })).with({ from: P.when(isBitcoin), to: P.when(isEvmToken2) }, () => ({
     type: "direct_rift",
     direction: "from_btc"
   })).with({
-    from: P.when((c) => isEvmToken(c) && !isCbBtc(c)),
+    from: P.when((c) => isEvmToken2(c) && !isCbBtc(c)),
     to: P.when(isBitcoin)
   }, ({ from: from2 }) => {
     if (from2.chain.kind !== "EVM") {
       throw new Error("Expected EVM chain");
     }
     return {
-      type: "oneinch_then_rift",
+      type: "dex_then_rift",
       evmChainId: from2.chain.chainId
     };
   }).with({
-    from: P.when(isEvmToken),
-    to: P.when((c) => isEvmToken(c) && isSameEvmChain(from, to))
+    from: P.when(isEvmToken2),
+    to: P.when((c) => isEvmToken2(c) && isSameEvmChain2(from, to))
   }, ({ from: from2 }) => {
     if (from2.chain.kind !== "EVM") {
       throw new Error("Expected EVM chain");
     }
     return {
-      type: "oneinch_monochain",
+      type: "dex_monochain",
       evmChainId: from2.chain.chainId
     };
   }).otherwise(() => {
@@ -143,10 +143,10 @@ function detectRoute(from, to) {
 }
 function getSupportedModes(from, to) {
   const route = detectRoute(from, to);
-  if (route.type === "oneinch_then_rift") {
-    return { exactInput: true, exactOutput: false };
+  if (route.type === "dex_then_rift") {
+    return { exactInput: true, exactOutput: true };
   }
-  if (route.type === "oneinch_monochain") {
+  if (route.type === "dex_monochain") {
     return { exactInput: true, exactOutput: false };
   }
   if (route.direction === "to_btc") {
@@ -159,13 +159,16 @@ function getSupportedModes(from, to) {
 }
 // src/sdk.ts
 import { erc20Abi } from "viem";
+var GAS_LIMIT_MULTIPLIER_NUMERATOR = 3n;
+var GAS_LIMIT_MULTIPLIER_DENOMINATOR = 2n;
+
 class RiftSdk {
   riftClient;
   preflightCheckBalances;
   integratorName;
   debug;
   constructor(options) {
-    const baseUrl = (options.apiUrl ?? "https://router-api-v2-production.up.railway.app").replace(/\/$/, "");
+    const baseUrl = (options.apiUrl ?? "https://api.rift.trade").replace(/\/$/, "");
     this.riftClient = createClient(baseUrl);
     this.preflightCheckBalances = options.preflight?.checkBalances !== false;
     this.integratorName = options.integratorName;
@@ -200,12 +203,13 @@ class RiftSdk {
   }
   async getQuote(params) {
     const route = detectRoute(params.from, params.to);
-    const isMonochain = route.type === "oneinch_monochain";
+    const isMonochain = route.type === "dex_monochain";
     const quoteRequest = {
       type: params.mode === "exact_input" ? "EXACT_INPUT" : "EXACT_OUTPUT",
       from: params.from,
       to: params.to,
-      amount: params.amount
+      amount: params.amount,
+      quoteQuality: params.quoteQuality
     };
     const riftQuote = this.unwrapEdenResult(await this.riftClient.quote.post(quoteRequest));
     const quote = this.buildQuoteResult(riftQuote, params);
@@ -257,10 +261,10 @@ class RiftSdk {
             stepId: step.id,
             txHash: result.txHash
           });
-          if (isMonochain && step.action === "evm_call" && step.kind === "oneinch_swap" && result.txHash) {
+          if (isMonochain && step.action === "evm_call" && (step.kind === "dex_swap" || step.kind === "oneinch_swap") && result.txHash) {
             this.logDebug("reporting step result", {
               stepId: step.id,
-              oneinchSwap: true
+              dexSwap: true
             });
             this.unwrapEdenResult(await this.riftClient.swap({ swapId: swapResponse.swapId }).tx.post({
               stepId: step.id,
@@ -309,13 +313,29 @@ class RiftSdk {
         return {};
       }
     }
-    const txHash = await walletClient.sendTransaction({
+    const txRequest = {
       account,
       to: step.to,
       data: step.calldata,
       value: step.value ? BigInt(step.value) : undefined
+    };
+    const 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()
     });
-    await publicClient.waitForTransactionReceipt({ hash: txHash });
+    const txHash = await walletClient.sendTransaction({
+      ...txRequest,
+      gas: gasLimit
+    });
+    const receipt = await publicClient.waitForTransactionReceipt({
+      hash: txHash
+    });
+    if (receipt.status !== "success") {
+      throw new Error(`EVM step transaction reverted (${step.kind}) with hash ${txHash}`);
+    }
     return { txHash };
   }
   async executeBtcTransferStep(step, context) {

package/package.json

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