@riftresearch/sdk 0.8.0 → 0.10.0

package/dist/index.d.ts

@@ -148,7 +148,7 @@ type ExecutionAction = "evm_call" | "btc_transfer";
 /**
 * Step kinds grouped by action type.
 */
-type EvmCallKind = "approval" | "transfer_erc20" | "oneinch_swap" | "dex_swap";
+type EvmCallKind = "approval" | "transfer_erc20" | "dex_swap";
 type BtcTransferKind = "transfer_btc";
 /**
 * EVM Call step - execute calldata on an EVM chain.
@@ -376,6 +376,8 @@ type SendBitcoinFn = (params: {
 	/** Amount to send in satoshis */
 	amountSats: string;
 }) => Promise<void>;
+type ExecuteSwapStepType = "approval" | "transaction";
+type ExecuteSwapOnExecuteStepCallback = (type: ExecuteSwapStepType) => void | Promise<void>;
 type ExecuteSwapContext<chain extends Chain2 | undefined = Chain2 | undefined> = {
 	/** Viem PublicClient for reading chain data */
 	publicClient?: PublicClient<Transport, chain>;
@@ -383,6 +385,11 @@ type ExecuteSwapContext<chain extends Chain2 | undefined = Chain2 | undefined> =
 	walletClient?: WalletClient<Transport, chain, Account | undefined>;
 	/** Function to send Bitcoin (implement using your preferred wallet) */
 	sendBitcoin?: SendBitcoinFn;
+	/**
+	* Optional callback invoked immediately before prompting the user's wallet to
+	* sign/send a transaction (after estimateGas/simulation has succeeded).
+	*/
+	onExecuteStep?: ExecuteSwapOnExecuteStepCallback;
 };
 type ExecuteSwapOptions<chain extends Chain2 | undefined = Chain2 | undefined> = ExecuteSwapContext<chain> & {
 	/** Address to receive the output tokens */
@@ -395,6 +402,12 @@ 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) */
@@ -408,6 +421,7 @@ declare class RiftSdk {
 	private preflightCheckBalances;
 	private integratorName;
 	private debug;
+	private evmBroadcastMode;
 	constructor(options: RiftSdkOptions);
 	private logDebug;
 	private unwrapEdenResult;
@@ -462,4 +476,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, ExecuteSwapOptions, 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, QuoteQuality, QuoteParameters, NativeToken, GetQuoteResult, ExecutionStep, ExecutionAction, ExecuteSwapStepType, ExecuteSwapOptions, ExecuteSwapOnExecuteStepCallback, EvmChain, EvmCallStep, EvmCallKind, Erc20Token, Currency, Currencies, Chain, BtcTransferStep, BtcTransferKind, BitcoinChain };

package/dist/index.js

@@ -164,18 +164,42 @@ function createClient(baseUrl) {
 // 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)
@@ -268,15 +292,16 @@ class RiftSdk {
             kind: "kind" in step ? step.kind : undefined,
             chainId: "chainId" in step ? step.chainId : undefined
           });
-          const result = await this.executeStep(step, context);
+          const result = await this.executeStep(step, context, swapResponse.swapId);
           this.logDebug("step completed", {
             stepId: step.id,
             txHash: result.txHash
           });
-          if (isMonochain && step.action === "evm_call" && (step.kind === "dex_swap" || step.kind === "oneinch_swap") && result.txHash) {
+          if (step.action === "evm_call" && step.kind === "dex_swap" && result.txHash) {
             this.logDebug("reporting step result", {
               stepId: step.id,
-              dexSwap: true
+              dexSwap: true,
+              monochain: isMonochain
             });
             this.unwrapEdenResult(await this.riftClient.swap({ swapId: swapResponse.swapId }).tx.post({
               stepId: step.id,
@@ -299,15 +324,15 @@ class RiftSdk {
       }
     };
   }
-  async executeStep(step, context) {
+  async executeStep(step, context, swapId) {
     switch (step.action) {
       case "evm_call":
-        return this.executeEvmCallStep(step, context);
+        return this.executeEvmCallStep(step, context, swapId);
       case "btc_transfer":
         return this.executeBtcTransferStep(step, context);
     }
   }
-  async executeEvmCallStep(step, context) {
+  async executeEvmCallStep(step, context, swapId) {
     const walletClient = this.requireWalletClient(context);
     const publicClient = this.requirePublicClient(context);
     const account = walletClient.account;
@@ -325,33 +350,133 @@ class RiftSdk {
         return {};
       }
     }
-    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()
-    });
-    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}`);
+    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;
+      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)}`);
+        }
+        if (!refreshed?.step) {
+          throw new Error("estimateGas failed for dex_swap step and refresh-step returned no step");
+        }
+        if (refreshed.step.kind !== "dex_swap") {
+          throw new Error(`refresh-step returned unexpected step kind: ${refreshed.step.kind}`);
+        }
+        effectiveStep = refreshed.step;
+        txRequest = {
+          account,
+          to: effectiveStep.to,
+          data: effectiveStep.calldata,
+          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
+        });
+      }
+      const receipt = await publicClient.waitForTransactionReceipt({
+        hash: txHash
+      });
+      if (receipt.status !== "success") {
+        throw new Error(`EVM step transaction reverted (${effectiveStep.kind}) with hash ${txHash}`);
+      }
+      return { txHash };
     }
-    return { txHash };
   }
   async executeBtcTransferStep(step, context) {
     const sendBitcoin = this.requireSendBitcoin(context);
+    await context.onExecuteStep?.("transaction");
     await sendBitcoin({
       recipient: step.toAddress,
       amountSats: step.amountSats

package/package.json

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