0xtrails 0.8.2 → 0.8.4

package/src/gasless.ts

@@ -147,51 +147,81 @@ export async function getPermitSignature({
     args: [signer],
   })
 
-  const name = (await publicClient.readContract({
-    address: tokenAddress as `0x${string}`,
-    abi: [
-      {
-        name: "name",
-        type: "function",
-        stateMutability: "view",
-        inputs: [],
-        outputs: [{ name: "", type: "string" }],
-      },
-    ],
-    functionName: "name",
-  })) as string
+  // Fetch EIP-5267 eip712Domain() first - this returns the exact domain parameters used by the contract
+  let name: string
+  let version: string
 
-  let version = "1" // fallback default
   try {
-    version = (await publicClient.readContract({
+    const eip712Domain = (await publicClient.readContract({
       address: tokenAddress as `0x${string}`,
       abi: [
         {
-          name: "version",
+          name: "eip712Domain",
           type: "function",
           stateMutability: "view",
           inputs: [],
-          outputs: [{ name: "", type: "string" }],
+          outputs: [
+            { name: "fields", type: "bytes1" },
+            { name: "name", type: "string" },
+            { name: "version", type: "string" },
+            { name: "chainId", type: "uint256" },
+            { name: "verifyingContract", type: "address" },
+            { name: "salt", type: "bytes32" },
+            { name: "extensions", type: "uint256[]" },
+          ],
         },
       ],
-      functionName: "version",
-    })) as string
-    logger.console.log("[trails-sdk] Token version from contract:", version)
-  } catch (error) {
-    logger.console.warn(
-      "[trails-sdk] Token does not implement version(), defaulting to '1'",
-      error,
-    )
-  }
+      functionName: "eip712Domain",
+    })) as [string, string, string, bigint, string, string, bigint[]]
 
-  // Special handling for Katana chain (747474)
-  // Katana USDC contract returns "0.5.0" from version() but uses "1" for EIP-712 domain
-  // The contract's version() is the implementation version, not the EIP-712 domain version
-  if (chain.id === 747474) {
+    name = eip712Domain[1]
+    version = eip712Domain[2]
+    logger.console.log(
+      "[trails-sdk] EIP-5267 eip712Domain() supported, using domain:",
+      { name, version },
+    )
+  } catch {
+    // EIP-5267 not supported, fall back to reading name() and version()
     logger.console.log(
-      "[trails-sdk] Katana chain detected, overriding version to '1' for EIP-712 domain compatibility",
+      "[trails-sdk] EIP-5267 not supported, falling back to name()/version()",
     )
-    version = "1"
+
+    name = (await publicClient.readContract({
+      address: tokenAddress as `0x${string}`,
+      abi: [
+        {
+          name: "name",
+          type: "function",
+          stateMutability: "view",
+          inputs: [],
+          outputs: [{ name: "", type: "string" }],
+        },
+      ],
+      functionName: "name",
+    })) as string
+
+    version = "1" // fallback default EIP-712 version
+    try {
+      version = (await publicClient.readContract({
+        address: tokenAddress as `0x${string}`,
+        abi: [
+          {
+            name: "version",
+            type: "function",
+            stateMutability: "view",
+            inputs: [],
+            outputs: [{ name: "", type: "string" }],
+          },
+        ],
+        functionName: "version",
+      })) as string
+      logger.console.log("[trails-sdk] Token version from contract:", version)
+    } catch (error) {
+      logger.console.warn(
+        "[trails-sdk] Token does not implement version(), defaulting to '1'",
+        error,
+      )
+    }
   }
 
   // Log domain parameters for debugging

package/src/intents.ts

@@ -822,18 +822,16 @@ export function buildCrossChainDepositParams({
   originTokenAddress,
   originIntentAddress,
   depositAmount,
-  fee,
   originChainId,
   chain,
 }: {
   originTokenAddress: string
   originIntentAddress: string
   depositAmount: string
-  fee: string
   originChainId: number
   chain: Chain
 }) {
-  const totalAmount = BigInt(depositAmount) + BigInt(fee)
+  const totalAmount = BigInt(depositAmount)
 
   return {
     to: isNativeToken(originTokenAddress)

package/src/morpho.ts

@@ -63,7 +63,7 @@ async function fetchAllVaults(): Promise<any[]> {
         vaults(
           first: 1000, 
           where: { 
-            chainId_in: [1, 8453, 42161, 137, 10, 100]
+            chainId_in: [1, 8453, 42161, 42170, 137, 10, 100, 81457, 56, 660279, 33139, 747474]
           },
           orderBy: TotalAssetsUsd,
           orderDirection: Desc

package/src/prepareSend.ts

@@ -7,6 +7,8 @@ import { getTokenPrice } from "./prices.js"
 import {
   TRAILS_ROUTER_PLACEHOLDER_AMOUNT,
   wrapCalldataWithTrailsRouterIfNeeded,
+  calldataHasPlaceholder,
+  replacePlaceholderInCalldata,
 } from "./trailsRouter.js"
 import type { TransactionState } from "./transactions.js"
 import { logger } from "./logger.js"
@@ -62,9 +64,7 @@ export async function prepareSend(
     tradeType = TradeType.EXACT_OUTPUT,
     originTokenSymbol,
     destinationTokenSymbol,
-    fee,
     client: walletClient,
-    dryMode = false,
     trailsClient,
     destinationCalldata,
     onTransactionStateChange,
@@ -149,6 +149,44 @@ export async function prepareSend(
   const isToSameToken = isSameToken(originTokenAddress, destinationTokenAddress)
   const isSameChainSameToken = isToSameChain && isToSameToken
 
+  // For same-chain same-token with custom calldata:
+  // 1. Replace any placeholder in the calldata with the actual swapAmount
+  // 2. Use EXACT_OUTPUT trade type to ensure consistent amount handling
+  // This handles vault deposits where calldata may have been generated with a placeholder
+  const originalHadPlaceholder = calldataHasPlaceholder(destinationCalldata)
+  let placeholderWasReplaced = false
+
+  if (isSameChainSameToken && hasCustomCalldata && originalHadPlaceholder) {
+    const calldataBefore = effectiveDestinationCalldata
+    // Replace placeholder with actual amount in calldata
+    effectiveDestinationCalldata = replacePlaceholderInCalldata(
+      effectiveDestinationCalldata || "",
+      swapAmount,
+    )
+    // Verify the placeholder was actually replaced
+    placeholderWasReplaced = !calldataHasPlaceholder(
+      effectiveDestinationCalldata,
+    )
+
+    logger.console.log(
+      "[trails-sdk] Same-chain same-token: Replaced placeholder with actual amount in calldata",
+      {
+        swapAmount,
+        placeholderWasReplaced,
+        calldataBefore,
+        calldataAfter: effectiveDestinationCalldata,
+      },
+    )
+  }
+
+  logger.console.log("[trails-sdk] Trade type and calldata info:", {
+    tradeType,
+    isSameChainSameToken,
+    hasCustomCalldata,
+    originalHadPlaceholder,
+    placeholderWasReplaced,
+  })
+
   if (
     !hasCustomCalldata &&
     tradeType === TradeType.EXACT_INPUT &&
@@ -414,7 +452,6 @@ export async function prepareSend(
       originChainId,
       walletClient,
       onTransactionStateChange,
-      dryMode,
       account,
       chain,
       transactionStates,
@@ -437,6 +474,7 @@ export async function prepareSend(
       isSmartWallet,
       trailsApiKey,
       trailsApiUrl,
+      tradeType: tradeType,
     })
   }
 
@@ -462,12 +500,10 @@ export async function prepareSend(
     publicClient,
     chain,
     account,
-    fee,
-    dryMode,
     onTransactionStateChange,
     transactionStates,
     slippageTolerance,
-    tradeType,
+    tradeType: tradeType,
     originNativeTokenPriceUsd,
     swapProvider,
     bridgeProvider,

package/src/recover.ts

@@ -17,13 +17,14 @@ import { splitSignature } from "./gasless.js"
 import { useMemo, useCallback } from "react"
 import { useGetIntent } from "./widget/hooks/useGetIntent.js"
 import {
-  useTokenBalances,
+  useTokenBalancesForMultipleAccounts,
   getTokenBalanceUsd,
   type Price,
 } from "./tokenBalances.js"
 import { getERC20TransferData } from "./encoders.js"
 import { zeroAddress } from "viem"
 import { useTokenPrices } from "./prices.js"
+import type { Token } from "./tokens.js"
 import type { Payload as WalletPayload } from "@0xsequence/wallet-primitives"
 import { attemptSwitchChain } from "./chainSwitch.js"
 import { decodeGuestModuleEvents } from "./decoders.js"
@@ -440,15 +441,17 @@ export async function buildRefundTransaction(
 
 /**
  * Determines the refund call based on token balances at the intent address
+ * Uses Token type which has symbol, name, decimals, chainId directly (no contractInfo)
  */
 export function determineRefundCall(
   tokenBalancesData:
     | {
-        nativeBalances?: Array<{ balance?: string; chainId?: number }>
-        balances?: Array<{
+        tokens?: Array<{
           balance?: string
           contractAddress?: string
-          contractInfo?: { decimals?: number; chainId?: number }
+          decimals?: number
+          chainId?: number
+          isNativeToken?: boolean
         }>
       }
     | undefined,
@@ -467,34 +470,18 @@ export function determineRefundCall(
     chainId?: number
   } | null = null
 
-  // Check native token balances
-  if (tokenBalancesData?.nativeBalances) {
-    for (const nativeBalance of tokenBalancesData.nativeBalances) {
-      const balance = BigInt(nativeBalance.balance || "0")
+  // Check all tokens (both native and ERC20)
+  if (tokenBalancesData?.tokens) {
+    for (const token of tokenBalancesData.tokens) {
+      const balance = BigInt(token.balance || "0")
       if (balance > 0n) {
         if (!highestBalanceToken || balance > highestBalanceToken.balance) {
           highestBalanceToken = {
-            type: "native",
+            type: token.isNativeToken ? "native" : "erc20",
             balance,
-            chainId: nativeBalance.chainId,
-          }
-        }
-      }
-    }
-  }
-
-  // Check ERC20 token balances
-  if (tokenBalancesData?.balances) {
-    for (const tokenBalance of tokenBalancesData.balances) {
-      const balance = BigInt(tokenBalance.balance || "0")
-      if (balance > 0n) {
-        if (!highestBalanceToken || balance > highestBalanceToken.balance) {
-          highestBalanceToken = {
-            type: "erc20",
-            balance,
-            tokenAddress: tokenBalance.contractAddress,
-            decimals: tokenBalance.contractInfo?.decimals,
-            chainId: tokenBalance.contractInfo?.chainId,
+            tokenAddress: token.contractAddress,
+            decimals: token.decimals,
+            chainId: token.chainId,
           }
         }
       }
@@ -581,6 +568,8 @@ export interface UseIntentRecoverReturn {
   intentError: Error | null
   balancesError: Error | null
   hasIntentBalance: boolean
+  /** Token that will be recovered (the one with highest balance) */
+  recoverToken: Token | null
   refetchIntent: () => void
   signPayload: () => Promise<{
     signature: string
@@ -655,49 +644,41 @@ export function useIntentRecover({
       return Address.from(intentData.destinationIntentAddress)
     }, [intentData?.destinationIntentAddress])
 
+  // Fetch balances for both origin and destination in a single API call
   const {
-    tokenBalancesData: originTokenBalancesData,
-    isLoadingBalances: isLoadingOriginBalances,
-    balanceError: originBalanceError,
-  } = useTokenBalances(originIntentAddressForBalances)
+    balancesByAccount,
+    isLoading: isLoadingBalances,
+    error: balanceError,
+  } = useTokenBalancesForMultipleAccounts([
+    originIntentAddressForBalances,
+    destinationIntentAddressForBalances,
+  ])
 
-  const {
-    tokenBalancesData: destinationTokenBalancesData,
-    isLoadingBalances: isLoadingDestinationBalances,
-    balanceError: destinationBalanceError,
-  } = useTokenBalances(destinationIntentAddressForBalances)
+  // Extract individual account balances
+  const originTokenBalancesData = originIntentAddressForBalances
+    ? balancesByAccount[originIntentAddressForBalances.toLowerCase()]
+        ?.tokenBalancesData
+    : undefined
+  const destinationTokenBalancesData = destinationIntentAddressForBalances
+    ? balancesByAccount[destinationIntentAddressForBalances.toLowerCase()]
+        ?.tokenBalancesData
+    : undefined
+
+  // balancesError alias for backward compatibility in component return
+  const balancesError = balanceError
 
   // Get token prices for origin balances
+  // Note: Token type already has balance/price fields populated, but we fetch prices
+  // separately for more accurate/up-to-date pricing
   const originTokensForPricing = useMemo(() => {
-    if (!originTokenBalancesData) return []
-    const tokens: Array<{
-      tokenSymbol: string
-      tokenAddress: string
-      chainId: number
-    }> = []
-    if (originTokenBalancesData.nativeBalances) {
-      for (const nativeBalance of originTokenBalancesData.nativeBalances) {
-        if (nativeBalance.chainId) {
-          tokens.push({
-            tokenSymbol: (nativeBalance as any).symbol || "ETH",
-            tokenAddress: zeroAddress,
-            chainId: nativeBalance.chainId,
-          })
-        }
-      }
-    }
-    if (originTokenBalancesData.balances) {
-      for (const tokenBalance of originTokenBalancesData.balances) {
-        if (tokenBalance.contractInfo?.chainId) {
-          tokens.push({
-            tokenSymbol: tokenBalance.contractInfo?.symbol || "",
-            tokenAddress: tokenBalance.contractAddress || zeroAddress,
-            chainId: tokenBalance.contractInfo.chainId,
-          })
-        }
-      }
-    }
-    return tokens
+    if (!originTokenBalancesData?.tokens) return []
+    return originTokenBalancesData.tokens
+      .filter((token) => token.chainId !== undefined)
+      .map((token) => ({
+        tokenSymbol: token.symbol,
+        tokenAddress: token.contractAddress || zeroAddress,
+        chainId: token.chainId!,
+      }))
   }, [originTokenBalancesData])
 
   const { tokenPrices: originTokenPrices } = useTokenPrices(
@@ -706,35 +687,14 @@ export function useIntentRecover({
 
   // Get token prices for destination balances
   const destinationTokensForPricing = useMemo(() => {
-    if (!destinationTokenBalancesData) return []
-    const tokens: Array<{
-      tokenSymbol: string
-      tokenAddress: string
-      chainId: number
-    }> = []
-    if (destinationTokenBalancesData.nativeBalances) {
-      for (const nativeBalance of destinationTokenBalancesData.nativeBalances) {
-        if (nativeBalance.chainId) {
-          tokens.push({
-            tokenSymbol: (nativeBalance as any).symbol || "ETH",
-            tokenAddress: zeroAddress,
-            chainId: nativeBalance.chainId,
-          })
-        }
-      }
-    }
-    if (destinationTokenBalancesData.balances) {
-      for (const tokenBalance of destinationTokenBalancesData.balances) {
-        if (tokenBalance.contractInfo?.chainId) {
-          tokens.push({
-            tokenSymbol: tokenBalance.contractInfo?.symbol || "",
-            tokenAddress: tokenBalance.contractAddress || zeroAddress,
-            chainId: tokenBalance.contractInfo.chainId,
-          })
-        }
-      }
-    }
-    return tokens
+    if (!destinationTokenBalancesData?.tokens) return []
+    return destinationTokenBalancesData.tokens
+      .filter((token) => token.chainId !== undefined)
+      .map((token) => ({
+        tokenSymbol: token.symbol,
+        tokenAddress: token.contractAddress || zeroAddress,
+        chainId: token.chainId!,
+      }))
   }, [destinationTokenBalancesData])
 
   const { tokenPrices: destinationTokenPrices } = useTokenPrices(
@@ -746,19 +706,13 @@ export function useIntentRecover({
     (
       balancesData:
         | {
-            nativeBalances?: Array<{
+            tokens?: Array<{
               balance?: string
               chainId?: number
-              symbol?: string
-            }>
-            balances?: Array<{
-              balance?: string
               contractAddress?: string
-              contractInfo?: {
-                decimals?: number
-                chainId?: number
-                symbol?: string
-              }
+              decimals?: number
+              isNativeToken?: boolean
+              balanceUsd?: number
             }>
           }
         | undefined,
@@ -773,56 +727,44 @@ export function useIntentRecover({
 
       let totalUsd = 0
 
-      // Sum native token USD values
-      if (balancesData.nativeBalances) {
-        for (const nativeBalance of balancesData.nativeBalances) {
-          const priceData = tokenPrices.find(
-            (p) =>
-              p.token.tokenAddress === zeroAddress &&
-              p.token.chainId === nativeBalance.chainId &&
-              p.priceUsd !== undefined,
-          )
-          if (priceData?.priceUsd && nativeBalance.balance) {
-            const price: Price = {
-              value: priceData.priceUsd,
-              currency: "USD",
-            }
-            const usdValue = getTokenBalanceUsd(
-              {
-                balance: nativeBalance.balance,
-                chainId: nativeBalance.chainId,
-              } as any,
-              price,
-            )
-            totalUsd += usdValue
-          }
-        }
-      }
+      // Sum all token USD values (both native and ERC20)
+      if (balancesData.tokens) {
+        for (const token of balancesData.tokens) {
+          const tokenAddress = token.isNativeToken
+            ? zeroAddress
+            : token.contractAddress || zeroAddress
 
-      // Sum ERC20 token USD values
-      if (balancesData.balances) {
-        for (const tokenBalance of balancesData.balances) {
           const priceData = tokenPrices.find(
             (p) =>
               p.token.tokenAddress?.toLowerCase() ===
-                (tokenBalance.contractAddress || zeroAddress).toLowerCase() &&
-              p.token.chainId === tokenBalance.contractInfo?.chainId &&
+                tokenAddress.toLowerCase() &&
+              p.token.chainId === token.chainId &&
               p.priceUsd !== undefined,
           )
-          if (priceData?.priceUsd && tokenBalance.balance) {
+
+          if (priceData?.priceUsd && token.balance) {
             const price: Price = {
               value: priceData.priceUsd,
               currency: "USD",
             }
-            const usdValue = getTokenBalanceUsd(
-              {
-                balance: tokenBalance.balance,
-                contractAddress: tokenBalance.contractAddress,
-                contractInfo: tokenBalance.contractInfo,
-              } as any,
-              price,
-            )
-            totalUsd += usdValue
+
+            // Use balanceUsd if already calculated, otherwise calculate
+            if (token.balanceUsd !== undefined) {
+              totalUsd += token.balanceUsd
+            } else {
+              // Create a compatible object for getTokenBalanceUsd
+              const balanceObj = token.isNativeToken
+                ? { balance: token.balance, chainId: token.chainId }
+                : {
+                    balance: token.balance,
+                    contractInfo: {
+                      decimals: token.decimals,
+                      chainId: token.chainId,
+                    },
+                  }
+              const usdValue = getTokenBalanceUsd(balanceObj as any, price)
+              totalUsd += usdValue
+            }
           }
         }
       }
@@ -919,9 +861,7 @@ export function useIntentRecover({
     calculateTotalUsdBalance,
   ])
 
-  const isLoadingBalances =
-    isLoadingOriginBalances || isLoadingDestinationBalances
-  const balancesError = originBalanceError || destinationBalanceError
+  // isLoadingBalances and balancesError are already defined above from useTokenBalancesForMultipleAccounts
 
   // Check if ANY intent address (origin or destination) has any balance (native or ERC20)
   // This ensures we show the recover button if there are balances in either address
@@ -930,34 +870,17 @@ export function useIntentRecover({
     const checkBalances = (
       balancesData:
         | {
-            nativeBalances?: Array<{ balance?: string; chainId?: number }>
-            balances?: Array<{
-              balance?: string
-              contractAddress?: string
-              contractInfo?: { decimals?: number; chainId?: number }
-            }>
+            tokens?: Array<{ balance?: string }>
           }
         | undefined,
     ): boolean => {
-      if (!balancesData) return false
-
-      // Check native token balances
-      if (balancesData.nativeBalances) {
-        for (const nativeBalance of balancesData.nativeBalances) {
-          const balance = BigInt(nativeBalance.balance || "0")
-          if (balance > 0n) {
-            return true
-          }
-        }
-      }
+      if (!balancesData?.tokens) return false
 
-      // Check ERC20 token balances
-      if (balancesData.balances) {
-        for (const tokenBalance of balancesData.balances) {
-          const balance = BigInt(tokenBalance.balance || "0")
-          if (balance > 0n) {
-            return true
-          }
+      // Check all tokens (both native and ERC20)
+      for (const token of balancesData.tokens) {
+        const balance = BigInt(token.balance || "0")
+        if (balance > 0n) {
+          return true
         }
       }
 
@@ -971,6 +894,26 @@ export function useIntentRecover({
     return originHasBalance || destinationHasBalance
   }, [originTokenBalancesData, destinationTokenBalancesData])
 
+  // Get the token that will be recovered (highest balance from selected intent address)
+  // Get the token that will be recovered (highest balance from selected intent address)
+  const recoverToken = useMemo<Token | null>(() => {
+    if (!selectedIntentAddress?.tokenBalancesData?.tokens) return null
+
+    // Find the token with the highest balance
+    let highestBalanceToken: Token | null = null
+    let highestBalance = 0n
+
+    for (const token of selectedIntentAddress.tokenBalancesData.tokens) {
+      const balance = BigInt(token.balance || "0")
+      if (balance > 0n && balance > highestBalance) {
+        highestBalance = balance
+        highestBalanceToken = token
+      }
+    }
+
+    return highestBalanceToken
+  }, [selectedIntentAddress?.tokenBalancesData?.tokens])
+
   // Get refund address (use walletClient account or provided address)
   // Don't throw during render - validate when methods are called
   const effectiveRefundAddress = useMemo<`0x${string}` | null>(() => {
@@ -1411,6 +1354,7 @@ export function useIntentRecover({
     intentError: intentError as Error | null,
     balancesError: balancesError as Error | null,
     hasIntentBalance,
+    recoverToken,
     refetchIntent,
     signPayload,
     getRecoverTx,