0xtrails 0.6.6 → 0.7.0

package/src/decoders.ts

@@ -100,10 +100,7 @@ export type GuestModuleEvent =
   | CallSkippedEvent
 
 // Trails Token Sweeper events: see PR references above for canonical specs.
-export type TrailsTokenSweeperEvent =
-  | RefundEvent
-  | SweepEvent
-  | RefundAndSweepEvent
+export type TokenSweeperEvent = RefundEvent | SweepEvent | RefundAndSweepEvent
 
 // === Decoders ===
 
@@ -285,10 +282,10 @@ export function decodeSweep(log: Log): SweepEvent | null {
 
 // === Main decoder ===
 
-export function decodeTrailsTokenSweeperEvents(
+export function decodeTokenSweeperEvents(
   receipt: TransactionReceipt,
-): TrailsTokenSweeperEvent[] {
-  const events: TrailsTokenSweeperEvent[] = []
+): TokenSweeperEvent[] {
+  const events: TokenSweeperEvent[] = []
 
   for (const log of receipt.logs) {
     const refund = decodeRefund(log)

package/src/error.ts

@@ -33,9 +33,13 @@ export function getIsUserRejectionError(
   }
 
   // Check if the error message indicates a user rejection
-  const isRejected = /rejected|denied|user rejected the request/gi.test(
-    getErrorString(err).toLowerCase(),
-  )
+  // Use getFullErrorMessage to check nested error messages as well
+  // Match patterns like: "rejected", "denied", "user rejected", "denied transaction signature", etc.
+  const errorString = getFullErrorMessage(err).toLowerCase()
+  const isRejected =
+    /rejected|denied|user rejected|denied transaction signature|user denied transaction|user denied the request/gi.test(
+      errorString,
+    )
   return isRejected
 }
 

package/src/fees.ts

@@ -1,4 +1,4 @@
-import type { Intent } from "@0xsequence/trails-api"
+import type { Intent } from "@0xtrails/api"
 import { getTokenInfo } from "./tokens.js"
 import { formatRawAmount, formatUsdAmountDisplay } from "./tokenBalances.js"
 import { zeroAddress } from "viem"
@@ -26,13 +26,14 @@ async function formatTokenAmount(
   amount: string | number | undefined,
   tokenAddress: string,
   chainId: number,
+  config: { trailsApiKey: string; trailsApiUrl: string },
 ): Promise<string> {
   if (!amount) return "0"
   const num = typeof amount === "string" ? parseFloat(amount) : amount
   if (num === 0) return "0"
 
   // Get token info to determine decimals
-  const tokenInfo = await getTokenInfo(chainId, tokenAddress)
+  const tokenInfo = await getTokenInfo(chainId, tokenAddress, config)
   if (!tokenInfo?.decimals) {
     throw new Error(
       `Token decimals not found for token ${tokenAddress} on chain ${chainId}`,
@@ -49,13 +50,73 @@ async function formatTokenAmount(
   return formatted
 }
 
-// Extract fee breakdown from intent data
+/**
+ * Extract fee breakdown and calculate all fee values from intent data
+ * Uses raw USD values from intent to avoid parsing display strings
+ */
 export async function extractTrailsFeeBreakdown(
   intent: Intent,
-): Promise<TrailsFeeBreakdown | null> {
+  config: { trailsApiKey: string; trailsApiUrl: string },
+  options?: {
+    originAmountUsd?: number
+    destinationAmountUsd?: number
+    totalFeesUsd?: number
+  },
+): Promise<{
+  trailsFeeBreakdown: TrailsFeeBreakdown | null
+  // Calculated fee values (using raw USD numbers)
+  originGasUsd: number
+  destGasUsd: number
+  totalGasUsd: number
+  providerUsd: number
+  trailsUsd: number
+  originUsd: number
+  destUsd: number
+  totalFeesUsd: number
+  swapFeesUsd: number
+  totalProviderUsd: number
+  allProviderFeesUsd: number
+  grandTotalUsd: number
+  grandTotalUsdDisplay: string
+  // Display values
+  originGasUsdDisplay: string
+  destGasUsdDisplay: string
+  totalGasUsdDisplay: string
+  providerUsdDisplay: string
+  trailsUsdDisplay: string
+  explicitProviderUsdDisplay: string
+  swapFeesUsdDisplay: string
+  totalProviderUsdDisplay: string
+  allProviderFeesUsdDisplay: string
+}> {
   const fees = intent?.fees
   if (!fees) {
-    return null
+    // Return zero values if no fees
+    return {
+      trailsFeeBreakdown: null,
+      originGasUsd: 0,
+      destGasUsd: 0,
+      totalGasUsd: 0,
+      providerUsd: 0,
+      trailsUsd: 0,
+      originUsd: options?.originAmountUsd ?? 0,
+      destUsd: options?.destinationAmountUsd ?? 0,
+      totalFeesUsd: options?.totalFeesUsd ?? 0,
+      swapFeesUsd: 0,
+      totalProviderUsd: 0,
+      grandTotalUsd: 0,
+      grandTotalUsdDisplay: formatUsdAmountDisplay(0),
+      originGasUsdDisplay: formatUsdAmountDisplay(0),
+      destGasUsdDisplay: formatUsdAmountDisplay(0),
+      totalGasUsdDisplay: formatUsdAmountDisplay(0),
+      providerUsdDisplay: formatUsdAmountDisplay(0),
+      trailsUsdDisplay: formatUsdAmountDisplay(0),
+      explicitProviderUsdDisplay: formatUsdAmountDisplay(0),
+      swapFeesUsdDisplay: formatUsdAmountDisplay(0),
+      totalProviderUsdDisplay: formatUsdAmountDisplay(0),
+      allProviderFeesUsd: 0,
+      allProviderFeesUsdDisplay: formatUsdAmountDisplay(0),
+    }
   }
 
   // Get chain IDs from origin and destination calls
@@ -66,140 +127,193 @@ export async function extractTrailsFeeBreakdown(
   const originChainQuote = fees.originGas
   const destinationChainQuote = fees.destinationGas
 
-  // If we can't find any chain quotes, return null
-  if (!originChainQuote && !destinationChainQuote) {
-    console.warn(
-      "[trails-sdk] Could not find any chain quotes for fee breakdown",
-      {
-        originChainId,
-        destinationChainId,
-      },
-    )
-    return null
-  }
+  // Extract raw USD values (use numbers directly, avoid parsing strings)
+  const originGasUsd =
+    typeof originChainQuote?.totalFeeUsd === "string"
+      ? parseFloat(originChainQuote.totalFeeUsd)
+      : (originChainQuote?.totalFeeUsd ?? 0)
+  const destGasUsd =
+    typeof destinationChainQuote?.totalFeeUsd === "string"
+      ? parseFloat(destinationChainQuote.totalFeeUsd)
+      : (destinationChainQuote?.totalFeeUsd ?? 0)
+  const providerUsd =
+    typeof fees.provider?.quoteProviderFeeUsd === "number"
+      ? fees.provider.quoteProviderFeeUsd
+      : 0
+  const trailsUsd =
+    typeof fees.provider?.trailsFeeUsd === "number"
+      ? fees.provider.trailsFeeUsd
+      : 0
 
-  const breakdown: TrailsFeeBreakdown = {}
+  // Use provided USD amounts or calculate from intent if available
+  const originUsd = options?.originAmountUsd ?? 0
+  const destUsd = options?.destinationAmountUsd ?? 0
+  const totalFeesUsd = options?.totalFeesUsd ?? 0
 
-  // Extract origin relay fee if available
-  if (originChainQuote && originChainId !== undefined) {
-    const originTokenSymbol = originChainQuote.nativeTokenSymbol || "ETH"
-    const originChainIdNum = originChainId
-    const nativeTokenAddress = zeroAddress
+  // Calculate swap fees: (originAmount - destinationAmount) - totalFees
+  const swapFeesUsd = Math.max(0, originUsd - destUsd - totalFeesUsd)
 
-    breakdown.originRelayFee = {
-      amount: await formatTokenAmount(
-        originChainQuote.totalFeeAmount.toString(),
-        nativeTokenAddress,
-        originChainIdNum,
-      ),
-      tokenSymbol: originTokenSymbol,
-      tokenAddress: nativeTokenAddress,
-      chainId: originChainIdNum,
-      usdValue: formatUsdAmountDisplay(originChainQuote.totalFeeUsd),
-    }
-    breakdown.originChainId = originChainIdNum
-  }
+  // Calculate totals
+  const totalGasUsd = originGasUsd + destGasUsd
+  const explicitProviderUsd = providerUsd + trailsUsd
+  const totalProviderUsd = providerUsd + trailsUsd + swapFeesUsd
+  // All provider fees = provider fee + swap fee (excluding trails)
+  const allProviderFeesUsd = providerUsd + swapFeesUsd
+  // Grand total = all gas costs + all provider fees
+  const grandTotalUsd = totalGasUsd + allProviderFeesUsd
 
-  // Extract destination relay fee if available
-  if (destinationChainQuote && destinationChainId !== undefined) {
-    const destinationTokenSymbol =
-      destinationChainQuote.nativeTokenSymbol || "ETH"
-    const destinationChainIdNum = destinationChainId
-    const nativeTokenAddress = zeroAddress
-
-    breakdown.destinationRelayFee = {
-      amount: await formatTokenAmount(
-        destinationChainQuote.totalFeeAmount.toString(),
-        nativeTokenAddress,
-        destinationChainIdNum,
-      ),
-      tokenSymbol: destinationTokenSymbol,
-      tokenAddress: nativeTokenAddress,
-      chainId: destinationChainIdNum,
-      usdValue: formatUsdAmountDisplay(destinationChainQuote.totalFeeUsd),
-    }
-    breakdown.destinationChainId = destinationChainIdNum
-  }
+  // Build breakdown for display (only if we have chain quotes)
+  let breakdown: TrailsFeeBreakdown | null = null
+  if (originChainQuote || destinationChainQuote) {
+    breakdown = {}
 
-  // Extract provider fee from provider fees if available
-  const providerFeeAmount = fees.provider?.quoteProviderFeeUsd
-  const providerFeeRawAmount = fees.provider?.quoteProviderFee
-  if (
-    (providerFeeAmount !== undefined || providerFeeRawAmount !== undefined) &&
-    originChainId !== undefined
-  ) {
-    const feeTokenAddress = fees.feeTokenAddress || zeroAddress
-    const originChainIdNum =
-      typeof originChainId === "bigint" ? Number(originChainId) : originChainId
-
-    // Get token info to determine the actual token symbol
-    const feeTokenInfo = await getTokenInfo(originChainIdNum, feeTokenAddress)
-    if (!feeTokenInfo?.symbol) {
-      throw new Error(
-        `Token symbol not found for provider fee token ${feeTokenAddress} on chain ${originChainIdNum}`,
-      )
+    // Extract origin relay fee if available
+    if (originChainQuote && originChainId !== undefined) {
+      const originTokenSymbol = originChainQuote.nativeTokenSymbol || "ETH"
+      const originChainIdNum = originChainId
+      const nativeTokenAddress = zeroAddress
+
+      breakdown.originRelayFee = {
+        amount: await formatTokenAmount(
+          originChainQuote.totalFeeAmount.toString(),
+          nativeTokenAddress,
+          originChainIdNum,
+          config,
+        ),
+        tokenSymbol: originTokenSymbol,
+        tokenAddress: nativeTokenAddress,
+        chainId: originChainIdNum,
+        usdValue: formatUsdAmountDisplay(originGasUsd),
+      }
+      breakdown.originChainId = originChainIdNum
     }
 
-    breakdown.providerFee = {
-      amount: await formatTokenAmount(
-        providerFeeRawAmount?.toString(),
-        feeTokenAddress,
-        originChainIdNum,
-      ),
-      tokenSymbol: feeTokenInfo.symbol,
-      tokenAddress: feeTokenAddress,
-      chainId: originChainIdNum,
-      usdValue: formatUsdAmountDisplay(providerFeeAmount),
+    // Extract destination relay fee if available
+    if (destinationChainQuote && destinationChainId !== undefined) {
+      const destinationTokenSymbol =
+        destinationChainQuote.nativeTokenSymbol || "ETH"
+      const destinationChainIdNum = destinationChainId
+      const nativeTokenAddress = zeroAddress
+
+      breakdown.destinationRelayFee = {
+        amount: await formatTokenAmount(
+          destinationChainQuote.totalFeeAmount.toString(),
+          nativeTokenAddress,
+          destinationChainIdNum,
+          config,
+        ),
+        tokenSymbol: destinationTokenSymbol,
+        tokenAddress: nativeTokenAddress,
+        chainId: destinationChainIdNum,
+        usdValue: formatUsdAmountDisplay(destGasUsd),
+      }
+      breakdown.destinationChainId = destinationChainIdNum
     }
-  }
 
-  // Extract Trails platform fee from provider fees if available
-  const trailsFeeAmount = fees.provider?.trailsFeeUsd
-  const trailsFeeRawAmount = fees.provider?.trailsFee
-  if (
-    (trailsFeeAmount !== undefined || trailsFeeRawAmount !== undefined) &&
-    originChainId !== undefined
-  ) {
-    const feeTokenAddress = fees.feeTokenAddress || zeroAddress
-    const originChainIdNum =
-      typeof originChainId === "bigint" ? Number(originChainId) : originChainId
-
-    // Get token info to determine the actual token symbol
-    const feeTokenInfo = await getTokenInfo(originChainIdNum, feeTokenAddress)
-    if (!feeTokenInfo?.symbol) {
-      throw new Error(
-        `Token symbol not found for trails fee token ${feeTokenAddress} on chain ${originChainIdNum}`,
+    // Extract provider fee from provider fees if available
+    const providerFeeRawAmount = fees.provider?.quoteProviderFee
+    if (
+      (providerUsd > 0 || providerFeeRawAmount !== undefined) &&
+      originChainId !== undefined
+    ) {
+      const feeTokenAddress = fees.feeTokenAddress || zeroAddress
+      const originChainIdNum =
+        typeof originChainId === "bigint"
+          ? Number(originChainId)
+          : originChainId
+
+      // Get token info to determine the actual token symbol
+      const feeTokenInfo = await getTokenInfo(
+        originChainIdNum,
+        feeTokenAddress,
+        config,
       )
+      if (!feeTokenInfo?.symbol) {
+        throw new Error(
+          `Token symbol not found for provider fee token ${feeTokenAddress} on chain ${originChainIdNum}`,
+        )
+      }
+
+      breakdown.providerFee = {
+        amount: await formatTokenAmount(
+          providerFeeRawAmount?.toString(),
+          feeTokenAddress,
+          originChainIdNum,
+          config,
+        ),
+        tokenSymbol: feeTokenInfo.symbol,
+        tokenAddress: feeTokenAddress,
+        chainId: originChainIdNum,
+        usdValue: formatUsdAmountDisplay(providerUsd),
+      }
     }
 
-    breakdown.trailsFee = {
-      amount: await formatTokenAmount(
-        trailsFeeRawAmount?.toString(),
-        feeTokenAddress,
+    // Extract Trails platform fee from provider fees if available
+    const trailsFeeRawAmount = fees.provider?.trailsFee
+    if (
+      (trailsUsd > 0 || trailsFeeRawAmount !== undefined) &&
+      originChainId !== undefined
+    ) {
+      const feeTokenAddress = fees.feeTokenAddress || zeroAddress
+      const originChainIdNum =
+        typeof originChainId === "bigint"
+          ? Number(originChainId)
+          : originChainId
+
+      // Get token info to determine the actual token symbol
+      const feeTokenInfo = await getTokenInfo(
         originChainIdNum,
-      ),
-      tokenSymbol: feeTokenInfo.symbol,
-      tokenAddress: feeTokenAddress,
-      chainId: originChainIdNum,
-      usdValue: formatUsdAmountDisplay(trailsFeeAmount),
-    }
-  }
+        feeTokenAddress,
+        config,
+      )
+      if (!feeTokenInfo?.symbol) {
+        throw new Error(
+          `Token symbol not found for trails fee token ${feeTokenAddress} on chain ${originChainIdNum}`,
+        )
+      }
 
-  // Calculate total USD value from the actual data
-  const originUsd =
-    typeof originChainQuote?.totalFeeUsd === "string"
-      ? parseFloat(originChainQuote.totalFeeUsd)
-      : originChainQuote?.totalFeeUsd || 0
-  const destinationUsd =
-    typeof destinationChainQuote?.totalFeeUsd === "string"
-      ? parseFloat(destinationChainQuote.totalFeeUsd)
-      : destinationChainQuote?.totalFeeUsd || 0
-  const providerUsd =
-    typeof providerFeeAmount === "number" ? providerFeeAmount : 0
-  const trailsUsd = typeof trailsFeeAmount === "number" ? trailsFeeAmount : 0
-  const totalUsd = originUsd + destinationUsd + providerUsd + trailsUsd
+      breakdown.trailsFee = {
+        amount: await formatTokenAmount(
+          trailsFeeRawAmount?.toString(),
+          feeTokenAddress,
+          originChainIdNum,
+          config,
+        ),
+        tokenSymbol: feeTokenInfo.symbol,
+        tokenAddress: feeTokenAddress,
+        chainId: originChainIdNum,
+        usdValue: formatUsdAmountDisplay(trailsUsd),
+      }
+    }
 
-  breakdown.totalUsdValue = formatUsdAmountDisplay(totalUsd)
+    // Calculate total USD value for breakdown display
+    const totalUsd = originGasUsd + destGasUsd + providerUsd + trailsUsd
+    breakdown.totalUsdValue = formatUsdAmountDisplay(totalUsd)
+  }
 
-  return breakdown
+  return {
+    trailsFeeBreakdown: breakdown,
+    originGasUsd,
+    destGasUsd,
+    totalGasUsd,
+    providerUsd,
+    trailsUsd,
+    originUsd,
+    destUsd,
+    totalFeesUsd,
+    swapFeesUsd,
+    totalProviderUsd,
+    allProviderFeesUsd,
+    grandTotalUsd,
+    grandTotalUsdDisplay: formatUsdAmountDisplay(grandTotalUsd),
+    originGasUsdDisplay: formatUsdAmountDisplay(originGasUsd),
+    destGasUsdDisplay: formatUsdAmountDisplay(destGasUsd),
+    totalGasUsdDisplay: formatUsdAmountDisplay(totalGasUsd),
+    providerUsdDisplay: formatUsdAmountDisplay(providerUsd),
+    trailsUsdDisplay: formatUsdAmountDisplay(trailsUsd),
+    explicitProviderUsdDisplay: formatUsdAmountDisplay(explicitProviderUsd),
+    swapFeesUsdDisplay: formatUsdAmountDisplay(swapFeesUsd),
+    totalProviderUsdDisplay: formatUsdAmountDisplay(totalProviderUsd),
+    allProviderFeesUsdDisplay: formatUsdAmountDisplay(allProviderFeesUsd),
+  }
 }

package/src/gasless.ts

@@ -92,38 +92,6 @@ export function getTransferCalldata({
   return transferCalldata
 }
 
-export function getPermitCalls(
-  connectedAccount: `0x${string}`,
-  delegatorSmartAccountAddress: `0x${string}`,
-  amount: bigint,
-  deadline: bigint,
-  signature: `0x${string}`,
-  recipient: `0x${string}`,
-  tokenAddress: `0x${string}`,
-): { to: `0x${string}`; data: `0x${string}`; value: string }[] {
-  const permitCalldata = getPermitCalldata({
-    signer: connectedAccount,
-    spender: delegatorSmartAccountAddress,
-    amount,
-    deadline,
-    signature,
-  })
-  const transferFromCalldata = getTransferFromCalldata({
-    signer: connectedAccount,
-    spender: delegatorSmartAccountAddress,
-    amount,
-  })
-  const transferCalldata = getTransferCalldata({ recipient, amount })
-
-  return [permitCalldata, transferFromCalldata, transferCalldata].map(
-    (call) => ({
-      to: tokenAddress,
-      data: call,
-      value: "0",
-    }),
-  )
-}
-
 export type GetPermitSignatureParams = {
   publicClient: PublicClient
   walletClient: WalletClient
@@ -318,6 +286,60 @@ export async function getPermitSignature({
   return { signature, deadline, v, r, s }
 }
 
+export type GetNeedsIntentEntrypointApprovalParams = {
+  client: PublicClient
+  token: Address
+  account: Address
+  entrypoint: Address
+  amount: bigint
+}
+
+export async function getNeedsIntentEntrypointApproval({
+  client,
+  token,
+  account,
+  entrypoint,
+  amount,
+}: GetNeedsIntentEntrypointApprovalParams): Promise<boolean> {
+  const allowance = await client.readContract({
+    address: token,
+    abi: erc20Abi,
+    functionName: "allowance",
+    args: [getAddress(account), getAddress(entrypoint)],
+  })
+
+  return allowance < amount
+}
+
+export type GetUserNonceParams = {
+  publicClient: PublicClient
+  userAddress: `0x${string}`
+  intentEntrypoint: `0x${string}`
+}
+
+export async function getUserNonce({
+  publicClient,
+  userAddress,
+  intentEntrypoint,
+}: GetUserNonceParams): Promise<bigint> {
+  const nonce = await publicClient.readContract({
+    address: intentEntrypoint as `0x${string}`,
+    abi: [
+      {
+        name: "nonces",
+        type: "function",
+        stateMutability: "view",
+        inputs: [{ name: "user", type: "address" }],
+        outputs: [{ name: "", type: "uint256" }],
+      },
+    ],
+    functionName: "nonces",
+    args: [userAddress],
+  })
+
+  return nonce as bigint
+}
+
 export type GetDepositToIntentWithPermitCalldataParams = {
   user: `0x${string}`
   token: `0x${string}`
@@ -438,71 +460,6 @@ export function getDepositToIntentWithoutPermitCalldata({
   })
 }
 
-export type GetDepositToIntentCallsParams = {
-  publicClient: PublicClient
-  walletClient: WalletClient
-  account: Account
-  intentEntrypoint: `0x${string}`
-  depositTokenAddress: `0x${string}`
-  depositTokenAmount: bigint
-  depositRecipient: `0x${string}`
-  chain: Chain
-}
-
-export type GetNeedsIntentEntrypointApprovalParams = {
-  client: PublicClient
-  token: Address
-  account: Address
-  entrypoint: Address
-  amount: bigint
-}
-
-export async function getNeedsIntentEntrypointApproval({
-  client,
-  token,
-  account,
-  entrypoint,
-  amount,
-}: GetNeedsIntentEntrypointApprovalParams): Promise<boolean> {
-  const allowance = await client.readContract({
-    address: token,
-    abi: erc20Abi,
-    functionName: "allowance",
-    args: [getAddress(account), getAddress(entrypoint)],
-  })
-
-  return allowance < amount
-}
-
-export type GetUserNonceParams = {
-  publicClient: PublicClient
-  userAddress: `0x${string}`
-  intentEntrypoint: `0x${string}`
-}
-
-export async function getUserNonce({
-  publicClient,
-  userAddress,
-  intentEntrypoint,
-}: GetUserNonceParams): Promise<bigint> {
-  const nonce = await publicClient.readContract({
-    address: intentEntrypoint as `0x${string}`,
-    abi: [
-      {
-        name: "nonces",
-        type: "function",
-        stateMutability: "view",
-        inputs: [{ name: "user", type: "address" }],
-        outputs: [{ name: "", type: "uint256" }],
-      },
-    ],
-    functionName: "nonces",
-    args: [userAddress],
-  })
-
-  return nonce as bigint
-}
-
 export type IntentParams = {
   user: `0x${string}`
   token: `0x${string}`
@@ -609,17 +566,6 @@ function getSignatureBytes(signature: string): number {
     : signature.length / 2
 }
 
-/**
- * Validates that a signature is exactly 65 bytes (standard ECDSA signature length).
- * @param signature - The signature to validate (hex string with or without 0x prefix)
- * @returns true if signature is 65 bytes, false otherwise
- */
-export function isValidGaslessSignature(signature: string): boolean {
-  // Standard ECDSA signatures are 65 bytes (32 bytes r + 32 bytes s + 1 byte v)
-  // Smart contract wallets return longer signatures which are not supported
-  return getSignatureBytes(signature) === 65
-}
-
 /**
  * Validates that a signature is exactly 65 bytes and throws an appropriate error if invalid.
  * @param signature - The signature to validate (hex string with or without 0x prefix)