0xtrails 0.4.2 → 0.5.0

package/src/prepareSend.ts

@@ -1,7 +1,7 @@
 import { abortControllerRegistry } from "./abortController.js"
 import { createPublicClient, http, zeroAddress } from "viem"
 import { trackPaymentError, trackPaymentStarted } from "./analytics.js"
-import { getSlippageTolerance } from "./config.js"
+import { getSlippageToleranceValue } from "./widget/components/SlippageToleranceSettings.js"
 import { getERC20TransferData } from "./encoders.js"
 import { getTokenPrice } from "./prices.js"
 import {
@@ -73,7 +73,7 @@ export async function prepareSend(
     sourceTokenDecimals,
     destinationTokenDecimals,
     paymasterUrl,
-    slippageTolerance = getSlippageTolerance(),
+    slippageTolerance: slippageToleranceFromOptions,
     originNativeTokenPriceUsd,
     quoteProvider,
     fundMethod,
@@ -84,9 +84,17 @@ export async function prepareSend(
     abortSignal,
     commitIntentFn,
     executeIntentFn,
+    sequenceProjectAccessKey,
+    sequenceIndexerUrl,
   } = options
   let { sourceTokenPriceUsd, destinationTokenPriceUsd } = options
 
+  // Use slippage from options, or get from localStorage with config default fallback
+  // The config default (slippageToleranceFromOptions) comes from React component context
+  const slippageTolerance = getSlippageToleranceValue(
+    slippageToleranceFromOptions || "0.01",
+  )
+
   if (!sourceTokenDecimals) {
     throw new Error("Source token decimals not provided")
   }
@@ -312,6 +320,10 @@ export async function prepareSend(
   }
 
   onTransactionStateChange(transactionStates)
+  // Also trigger checkout status update if handler is provided
+  if (checkoutOnHandlers?.triggerCheckoutStatusUpdate) {
+    checkoutOnHandlers.triggerCheckoutStatusUpdate(transactionStates)
+  }
 
   // Call onCheckoutStart callback if provided
   if (checkoutOnHandlers?.triggerCheckoutStart) {
@@ -413,6 +425,8 @@ export async function prepareSend(
     abortSignal,
     commitIntentFn,
     executeIntentFn,
+    sequenceProjectAccessKey,
+    sequenceIndexerUrl,
   })
 }
 

package/src/sequenceWallet.ts

@@ -12,7 +12,6 @@ import {
   toHex,
   type WalletClient,
 } from "viem"
-import { getSequenceProjectAccessKey } from "./config.js"
 import { logger } from "./logger.js"
 
 export type FlatTransaction = {
@@ -221,7 +220,7 @@ export async function sequenceSendTransaction(
   publicClient: PublicClient,
   calls: any[],
   chain: Chain,
-  sequenceProjectAccessKey: string = getSequenceProjectAccessKey(),
+  sequenceProjectAccessKey: string,
 ): Promise<string | null> {
   const chainId = chain.id
   if (!accountClient?.account?.address || !sequenceWalletAddress) {

package/src/trailsClient.ts

@@ -1,10 +1,9 @@
-import { useConfig } from "@0xsequence/hooks"
 import { TrailsApi } from "@0xsequence/trails-api"
 import { useMemo } from "react"
-import { getTrailsApiUrl, getSequenceProjectAccessKey } from "./config.js"
+import { useTrails } from "./widget/providers/TrailsProvider.js"
 
 export type TrailsClientConfig = {
-  apiKey?: string
+  apiKey: string
   jwt?: string
   hostname?: string
 }
@@ -12,24 +11,30 @@ export type TrailsClientConfig = {
 export class TrailsClient extends TrailsApi {}
 
 export function getTrailsClient({
-  apiKey = getSequenceProjectAccessKey(),
+  apiKey,
   jwt,
   hostname,
-}: TrailsClientConfig = {}): TrailsClient {
+}: TrailsClientConfig): TrailsClient {
   return new TrailsApi(apiKey, { jwt, hostname })
 }
 
-export const useTrailsClient = (config?: TrailsClientConfig) => {
-  const { projectAccessKey, jwt } = useConfig()
+export const useTrailsClient = (
+  configOverride?: Partial<TrailsClientConfig>,
+) => {
+  const trailsConfig = useTrails()
 
   const trailsClient = useMemo(() => {
     return getTrailsClient({
-      hostname: config?.hostname || getTrailsApiUrl(),
-      apiKey:
-        config?.apiKey || getSequenceProjectAccessKey() || projectAccessKey,
-      jwt: config?.jwt || jwt,
+      apiKey: configOverride?.apiKey || trailsConfig.trailsApiKey,
+      hostname: configOverride?.hostname || trailsConfig.trailsApiUrl,
+      jwt: configOverride?.jwt,
     })
-  }, [config?.hostname, config?.apiKey, config?.jwt, projectAccessKey, jwt])
+  }, [
+    configOverride?.hostname,
+    configOverride?.apiKey,
+    configOverride?.jwt,
+    trailsConfig,
+  ])
 
   return trailsClient
 }

package/src/transactionIntent/deposits/gaslessDeposit.ts

@@ -31,6 +31,7 @@ import {
   signIntent,
   getPermitSignature,
 } from "../../gasless.js"
+import { getIsUserRejectionError } from "../../error.js"
 
 export async function attemptGaslessDeposit({
   paymasterUrl,
@@ -154,18 +155,29 @@ export async function attemptGaslessDeposit({
         checkoutOnHandlers.triggerCheckoutSignatureRequest()
       }
 
-      const txHash = await sendPaymasterGaslessTransaction({
-        walletClient,
-        publicClient,
-        chain,
-        paymasterUrl,
-        delegatorSmartAccount,
-        calls,
-      })
-
-      // Trigger signature confirmed callback after successful signing
-      if (checkoutOnHandlers?.triggerCheckoutSignatureConfirmed) {
-        checkoutOnHandlers.triggerCheckoutSignatureConfirmed()
+      let txHash: any
+      try {
+        txHash = await sendPaymasterGaslessTransaction({
+          walletClient,
+          publicClient,
+          chain,
+          paymasterUrl,
+          delegatorSmartAccount,
+          calls,
+        })
+
+        // Trigger signature confirmed callback after successful signing
+        if (checkoutOnHandlers?.triggerCheckoutSignatureConfirmed) {
+          checkoutOnHandlers.triggerCheckoutSignatureConfirmed()
+        }
+      } catch (error) {
+        // Check if this is a user rejection error
+        if (getIsUserRejectionError(error)) {
+          if (checkoutOnHandlers?.triggerCheckoutSignatureRejected) {
+            checkoutOnHandlers.triggerCheckoutSignatureRejected(error)
+          }
+        }
+        throw error
       }
 
       if (onOriginSend) {
@@ -324,18 +336,39 @@ export async function attemptGaslessDeposit({
         },
       )
 
-      const permitSig = await getPermitSignature({
-        publicClient,
-        walletClient,
-        signer: account.address,
-        spender: TRAILS_INTENT_ENTRYPOINT_ADDRESS,
-        tokenAddress: depositTokenAddress as `0x${string}`,
-        amount: permitAmount, // Infinite approval
-        chain,
-        deadline: BigInt(deadline),
-      })
-      permitSignature = permitSig.signature
-      permitDeadline = Number(permitSig.deadline)
+      // Trigger signature request callback before prompting wallet for permit
+      if (checkoutOnHandlers?.triggerCheckoutSignatureRequest) {
+        checkoutOnHandlers.triggerCheckoutSignatureRequest()
+      }
+
+      let permitSig
+      try {
+        permitSig = await getPermitSignature({
+          publicClient,
+          walletClient,
+          signer: account.address,
+          spender: TRAILS_INTENT_ENTRYPOINT_ADDRESS,
+          tokenAddress: depositTokenAddress as `0x${string}`,
+          amount: permitAmount, // Infinite approval
+          chain,
+          deadline: BigInt(deadline),
+        })
+        permitSignature = permitSig.signature
+        permitDeadline = Number(permitSig.deadline)
+
+        // Trigger signature confirmed callback after successful signing
+        if (checkoutOnHandlers?.triggerCheckoutSignatureConfirmed) {
+          checkoutOnHandlers.triggerCheckoutSignatureConfirmed()
+        }
+      } catch (error) {
+        // Check if this is a user rejection error
+        if (getIsUserRejectionError(error)) {
+          if (checkoutOnHandlers?.triggerCheckoutSignatureRejected) {
+            checkoutOnHandlers.triggerCheckoutSignatureRejected(error)
+          }
+        }
+        throw error
+      }
       logger.console.log(
         "[trails-sdk] Deposit token permit signature obtained for infinite approval",
       )
@@ -375,26 +408,38 @@ export async function attemptGaslessDeposit({
       checkoutOnHandlers.triggerCheckoutSignatureRequest()
     }
 
-    const { signature: intentSignature } = await signIntent({
-      client: walletClient,
-      intentParams: {
-        user: account.address,
-        token: depositTokenAddress as `0x${string}`,
-        amount: BigInt(depositTokenAmount),
-        intentAddress: depositRecipient as `0x${string}`,
-        deadline: BigInt(deadline),
-        chainId: originChainId,
-        contractAddress: TRAILS_INTENT_ENTRYPOINT_ADDRESS,
-        nonce,
-        feeAmount: BigInt(selectedFeeOption?.amount || "0"),
-        feeCollector: feeCollectorAddress,
-      },
-    })
-    logger.console.log("[trails-sdk] Intent signature received")
+    let intentSignature: string
+    try {
+      const result = await signIntent({
+        client: walletClient,
+        intentParams: {
+          user: account.address,
+          token: depositTokenAddress as `0x${string}`,
+          amount: BigInt(depositTokenAmount),
+          intentAddress: depositRecipient as `0x${string}`,
+          deadline: BigInt(deadline),
+          chainId: originChainId,
+          contractAddress: TRAILS_INTENT_ENTRYPOINT_ADDRESS,
+          nonce,
+          feeAmount: BigInt(selectedFeeOption?.amount || "0"),
+          feeCollector: feeCollectorAddress,
+        },
+      })
+      intentSignature = result.signature
+      logger.console.log("[trails-sdk] Intent signature received")
 
-    // Trigger signature confirmed callback after successful signing
-    if (checkoutOnHandlers?.triggerCheckoutSignatureConfirmed) {
-      checkoutOnHandlers.triggerCheckoutSignatureConfirmed()
+      // Trigger signature confirmed callback after successful signing
+      if (checkoutOnHandlers?.triggerCheckoutSignatureConfirmed) {
+        checkoutOnHandlers.triggerCheckoutSignatureConfirmed()
+      }
+    } catch (error) {
+      // Check if this is a user rejection error
+      if (getIsUserRejectionError(error)) {
+        if (checkoutOnHandlers?.triggerCheckoutSignatureRejected) {
+          checkoutOnHandlers.triggerCheckoutSignatureRejected(error)
+        }
+      }
+      throw error
     }
 
     // 5. Call the deposit endpoint with permit support and optional fee

package/src/transactionIntent/deposits/standardDeposit.ts

@@ -23,6 +23,7 @@ import { updatePersistentToast } from "../../toast.js"
 import { getChainInfo } from "../../chains.js"
 import { trackTransactionConfirmed } from "../../analytics.js"
 import { zeroAddress } from "viem"
+import { getIsUserRejectionError } from "../../error.js"
 
 export async function attemptStandardDeposit({
   originTokenAddress,
@@ -77,6 +78,7 @@ export async function attemptStandardDeposit({
   recipient?: string
   destinationCalldata?: string
 }): Promise<TransactionReceipt | null> {
+  console.log("IN ATTEMPT STANDARD DEPOSIT!")
   let depositUserTxnReceipt: TransactionReceipt | null = null
   const usingLIfi = false
   let needsNativeFee = false
@@ -176,24 +178,36 @@ export async function attemptStandardDeposit({
         args: [recipient as `0x${string}`, requiredAmount],
       }) as `0x${string}`
 
-      const approveHash = await sendOriginTransaction(
-        account,
-        walletClient,
-        {
-          to: originTokenAddress as `0x${string}`,
-          data: approveData,
-          value: 0n,
-          chain,
-        },
-        {
-          transactionType: "token_approve",
-          depositTokenAmountUsd: depositAmountUsd?.toString(),
-        },
-      )
+      let approveHash: `0x${string}`
+      let approveReceipt: TransactionReceipt
+      try {
+        approveHash = await sendOriginTransaction(
+          account,
+          walletClient,
+          {
+            to: originTokenAddress as `0x${string}`,
+            data: approveData,
+            value: 0n,
+            chain,
+          },
+          {
+            transactionType: "token_approve",
+            depositTokenAmountUsd: depositAmountUsd?.toString(),
+          },
+        )
 
-      const approveReceipt = await publicClient.waitForTransactionReceipt({
-        hash: approveHash,
-      })
+        approveReceipt = await publicClient.waitForTransactionReceipt({
+          hash: approveHash,
+        })
+      } catch (error) {
+        // Check if this is a user rejection error
+        if (getIsUserRejectionError(error)) {
+          if (checkoutOnHandlers?.triggerCheckoutSignatureRejected) {
+            checkoutOnHandlers.triggerCheckoutSignatureRejected(error)
+          }
+        }
+        throw error
+      }
 
       logger.console.log(
         "[trails-sdk] Approve transaction confirmed:",
@@ -397,31 +411,44 @@ export async function attemptStandardDeposit({
           checkoutOnHandlers.triggerCheckoutSignatureRequest()
         }
 
-        const txHashNativeFee = await sendOriginTransaction(
-          account,
-          walletClient,
-          {
-            to: originIntentAddress,
-            data: "0x00",
-            value: nativeFee,
-            chainId: originChainId,
-            chain,
-          } as any,
-          {
-            depositTokenAmountUsd: depositAmountUsd?.toString(),
-          },
-        ) // TODO: Add proper type
-        logger.console.log("[trails-sdk] origin tx native fee", txHashNativeFee)
+        try {
+          const txHashNativeFee = await sendOriginTransaction(
+            account,
+            walletClient,
+            {
+              to: originIntentAddress,
+              data: "0x00",
+              value: nativeFee,
+              chainId: originChainId,
+              chain,
+            } as any,
+            {
+              depositTokenAmountUsd: depositAmountUsd?.toString(),
+            },
+          ) // TODO: Add proper type
+          logger.console.log(
+            "[trails-sdk] origin tx native fee",
+            txHashNativeFee,
+          )
 
-        // Trigger signature confirmed callback after successful signing
-        if (checkoutOnHandlers?.triggerCheckoutSignatureConfirmed) {
-          checkoutOnHandlers.triggerCheckoutSignatureConfirmed()
+          // Trigger signature confirmed callback after successful signing
+          if (checkoutOnHandlers?.triggerCheckoutSignatureConfirmed) {
+            checkoutOnHandlers.triggerCheckoutSignatureConfirmed()
+          }
+          // Wait for transaction receipt
+          const feeReceipt = await publicClient.waitForTransactionReceipt({
+            hash: txHashNativeFee,
+          })
+          logger.console.log("[trails-sdk] nativeFeeReceipt", feeReceipt)
+        } catch (error) {
+          // Check if this is a user rejection error
+          if (getIsUserRejectionError(error)) {
+            if (checkoutOnHandlers?.triggerCheckoutSignatureRejected) {
+              checkoutOnHandlers.triggerCheckoutSignatureRejected(error)
+            }
+          }
+          throw error
         }
-        // Wait for transaction receipt
-        const feeReceipt = await publicClient.waitForTransactionReceipt({
-          hash: txHashNativeFee,
-        })
-        logger.console.log("[trails-sdk] nativeFeeReceipt", feeReceipt)
       }
 
       // Show persistent toast for checkout flow
@@ -436,19 +463,30 @@ export async function attemptStandardDeposit({
         checkoutOnHandlers.triggerCheckoutSignatureRequest()
       }
 
-      const txHash = await sendOriginTransaction(
-        account,
-        walletClient,
-        originCallParams as any,
-        {
-          depositTokenAmountUsd: depositAmountUsd?.toString(),
-        },
-      ) // TODO: Add proper type
-      logger.console.log("[trails-sdk] origin tx", txHash)
-
-      // Trigger signature confirmed callback after successful signing
-      if (checkoutOnHandlers?.triggerCheckoutSignatureConfirmed) {
-        checkoutOnHandlers.triggerCheckoutSignatureConfirmed()
+      let txHash: `0x${string}`
+      try {
+        txHash = await sendOriginTransaction(
+          account,
+          walletClient,
+          originCallParams as any,
+          {
+            depositTokenAmountUsd: depositAmountUsd?.toString(),
+          },
+        ) // TODO: Add proper type
+        logger.console.log("[trails-sdk] origin tx", txHash)
+
+        // Trigger signature confirmed callback after successful signing
+        if (checkoutOnHandlers?.triggerCheckoutSignatureConfirmed) {
+          checkoutOnHandlers.triggerCheckoutSignatureConfirmed()
+        }
+      } catch (error) {
+        // Check if this is a user rejection error
+        if (getIsUserRejectionError(error)) {
+          if (checkoutOnHandlers?.triggerCheckoutSignatureRejected) {
+            checkoutOnHandlers.triggerCheckoutSignatureRejected(error)
+          }
+        }
+        throw error
       }
 
       if (onOriginSend) {