0xtrails 0.1.3 → 0.1.4

package/src/prices.ts

@@ -1,4 +1,8 @@
-import type { SequenceAPIClient, Token, TokenPrice } from "@0xsequence/api"
+import type {
+  SequenceAPIClient,
+  Token,
+  TokenPrice,
+} from "@0xsequence/trails-api"
 import { QueryClient, useQuery } from "@tanstack/react-query"
 import { zeroAddress } from "viem"
 

package/src/proxyCaller.ts

@@ -1,18 +1,9 @@
 import { encodeFunctionData } from "viem"
-import * as chains from "viem/chains"
+import { TRAILS_BALANCE_INJECTOR_ADDRESS } from "./constants.js"
 
 export const TRAILS_CONTRACT_PLACEHOLDER_AMOUNT =
   0xdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefn
 
-const proxyCallers: Record<string, string> = {
-  [chains.base.id]: "0x4F54Dc2C6bCa2D01e066fa36f4CFdA96B544DD20",
-  [chains.arbitrum.id]: "0x8c070e800D0e0c33A0A4ceef7A91677410ed9444",
-}
-
-export function getProxyCallerAddress(chainId: number) {
-  return proxyCallers[chainId]
-}
-
 function getAmountOffset(calldata: `0x${string}`, placeholder: bigint): number {
   const hex = placeholder.toString(16).padStart(64, "0")
   const search = hex.toLowerCase()
@@ -99,10 +90,7 @@ export function wrapCalldataWithProxyCallerIfNeeded({
     }
   }
 
-  const proxyCallerAddress = getProxyCallerAddress(destinationChainId)
-  if (!proxyCallerAddress) {
-    return null
-  }
+  const proxyCallerAddress = TRAILS_BALANCE_INJECTOR_ADDRESS
 
   const amountOffset = getAmountOffset(
     calldata,

package/src/tokenBalances.ts

@@ -7,7 +7,7 @@ import type {
   TokenBalance,
 } from "@0xsequence/indexer"
 import { ContractVerificationStatus } from "@0xsequence/indexer"
-import type { Page, Price, SequenceAPIClient } from "@0xsequence/api"
+import type { Page, Price, SequenceAPIClient } from "@0xsequence/trails-api"
 import { QueryClient, useQuery } from "@tanstack/react-query"
 import type { Address } from "ox"
 import { useEffect, useState } from "react"
@@ -18,12 +18,14 @@ import { getTokenPrices, useTokenPrices } from "./prices.js"
 
 export type { NativeTokenBalance, TokenBalance }
 
+const REFRESH_INTERVAL = 10000 // 10 seconds
+
 // Initialize query client for token balances
 const tokenBalancesQueryClient = new QueryClient({
   defaultOptions: {
     queries: {
-      staleTime: 60000, // 1 minute
-      gcTime: 300000, // 5 minutes
+      staleTime: REFRESH_INTERVAL, // 10 seconds - faster updates for balance changes
+      gcTime: REFRESH_INTERVAL, // 10 seconds
       retry: 2,
       retryDelay: (attemptIndex) => Math.min(1000 * 2 ** attemptIndex, 30000),
       refetchOnWindowFocus: false,
@@ -167,8 +169,8 @@ export function useTokenBalances(
       }
     },
     enabled: !!address && !!indexerClient,
-    staleTime: 60000, // 1 minute
-    gcTime: 300000, // 5 minutes cache time
+    staleTime: 10000, // 10 seconds - faster updates for balance changes
+    gcTime: 10000, // 10 seconds cache time
     retry: (failureCount, error) => {
       // Don't retry 404s or network errors after 3 attempts
       if (error && "status" in error && error.status === 404) return false
@@ -176,10 +178,11 @@ export function useTokenBalances(
       return false
     },
     retryDelay: (attemptIndex) => Math.min(1000 * 2 ** attemptIndex, 30000), // Exponential backoff
-    refetchOnWindowFocus: false, // Prevent refetch on window focus
+    refetchOnWindowFocus: true, // Prevent refetch on window focus
     refetchOnReconnect: true, // Refetch on reconnect
-    refetchInterval: 300000, // Background refetch every 5 minutes
+    refetchInterval: REFRESH_INTERVAL, // Background refetch every 10 seconds
     refetchIntervalInBackground: true,
+    refetchOnMount: true,
   })
 
   const { tokenPrices, isLoadingTokenPrices } = useTokenPrices(
@@ -262,9 +265,9 @@ export function useTokenBalances(
         !isLoadingTokenPrices &&
         !!tokenBalancesData &&
         !!tokenPrices,
-      staleTime: 30000, // 30 seconds for sorted tokens
-      gcTime: 120000, // 2 minutes cache time
-      refetchOnWindowFocus: false,
+      staleTime: REFRESH_INTERVAL, // 10 seconds for sorted tokens
+      gcTime: REFRESH_INTERVAL, // 10 seconds cache time
+      refetchOnWindowFocus: true,
     })
 
   return {
@@ -432,8 +435,8 @@ export async function getTokenBalances({
     queryKey: ["tokenBalances", "summary", account],
     queryFn: () =>
       fetchGetTokenBalancesSummary({ account, indexerGatewayClient }),
-    staleTime: 60000, // 1 minute
-    gcTime: 300000, // 5 minutes
+    staleTime: REFRESH_INTERVAL, // 10 seconds - faster updates for balance changes
+    gcTime: REFRESH_INTERVAL, // 10 seconds
   })
 }
 
@@ -727,8 +730,8 @@ export function useHasSufficientBalanceUsd(
           })
         : false,
     enabled: !!account && !!targetAmountUsd,
-    staleTime: 45000, // 45 seconds
-    gcTime: 180000, // 3 minutes cache time
+    staleTime: REFRESH_INTERVAL, // 10 seconds
+    gcTime: REFRESH_INTERVAL, // 10 seconds cache time
     retry: (failureCount, error) => {
       if (error && "status" in error && error.status === 404) return false
       if (failureCount < 2) return true
@@ -786,8 +789,8 @@ export function useAccountTotalBalanceUsd(account: string): {
             })
           : null,
       enabled: !!account,
-      staleTime: 60000, // 1 minute
-      gcTime: 300000, // 5 minutes cache time
+      staleTime: REFRESH_INTERVAL, // 10 seconds - faster updates for balance changes
+      gcTime: REFRESH_INTERVAL, // 10 seconds cache time
       retry: (failureCount, error) => {
         if (error && "status" in error && error.status === 404) return false
         if (failureCount < 2) return true
@@ -796,8 +799,9 @@ export function useAccountTotalBalanceUsd(account: string): {
       retryDelay: (attemptIndex) => Math.min(1000 * 2 ** attemptIndex, 30000),
       refetchOnWindowFocus: false,
       refetchOnReconnect: true,
-      refetchInterval: 300000, // Background refetch every 5 minutes
+      refetchInterval: REFRESH_INTERVAL, // Background refetch every 10 seconds
       refetchIntervalInBackground: true,
+      refetchOnMount: true,
     })
 
   return {

package/src/tokens.ts

@@ -1,5 +1,5 @@
 import { QueryClient, useQuery } from "@tanstack/react-query"
-import { zeroAddress, erc20Abi } from "viem"
+import { zeroAddress, erc20Abi, createPublicClient, http } from "viem"
 import { getChainInfo, getSupportedChains } from "./chains.js"
 import * as chains from "viem/chains"
 import { getRelaySupportedTokens } from "./relaySdk.js"
@@ -535,6 +535,9 @@ export async function getTokenInfo(
       t.contractAddress.toLowerCase() === normalizedAddress,
   )
 
+  console.log("tokens", tokens)
+  console.log("token", token)
+
   if (token) {
     // Cache the token info
     setTokenInfoCache(`${chainId}:${normalizedAddress}`, token)
@@ -542,8 +545,64 @@ export async function getTokenInfo(
     return token
   }
 
-  // If not found in supported tokens, return null
-  return null
+  // If not found in supported tokens, try to fetch on-chain data
+  try {
+    const chainInfo = getChainInfo(chainId)
+    if (!chainInfo) {
+      console.warn(`[trails-sdk] Chain info not found for chainId: ${chainId}`)
+      return null
+    }
+
+    // Create a public client for the specific chain
+    const publicClient = createPublicClient({
+      chain: chainInfo,
+      transport: http(),
+    })
+
+    // Read token data on-chain
+    const [name, symbol, decimals] = await Promise.all([
+      publicClient.readContract({
+        address: normalizedAddress as `0x${string}`,
+        abi: erc20Abi,
+        functionName: "name",
+      }),
+      publicClient.readContract({
+        address: normalizedAddress as `0x${string}`,
+        abi: erc20Abi,
+        functionName: "symbol",
+      }),
+      publicClient.readContract({
+        address: normalizedAddress as `0x${string}`,
+        abi: erc20Abi,
+        functionName: "decimals",
+      }),
+    ])
+
+    // Create token info from on-chain data
+    const onChainTokenInfo: SupportedToken = {
+      id: `${symbol}-${chainInfo.name}`,
+      name: name,
+      symbol: symbol,
+      decimals: decimals,
+      chainId: chainId,
+      contractAddress: normalizedAddress,
+      chainName: chainInfo.name,
+      imageUrl: getTokenImageUrl({
+        chainId,
+        contractAddress: normalizedAddress,
+        symbol: symbol,
+      }),
+    }
+
+    // Cache the on-chain token info
+    setTokenInfoCache(`${chainId}:${normalizedAddress}`, onChainTokenInfo)
+
+    console.log("[trails-sdk] Fetched token info on-chain:", onChainTokenInfo)
+    return onChainTokenInfo
+  } catch (error) {
+    console.error("[trails-sdk] Error fetching on-chain token info:", error)
+    return null
+  }
 }
 
 export async function getTokenAddress(chainId: number, tokenSymbol: string) {

package/src/trails.ts

@@ -4,8 +4,8 @@ import type {
   GetIntentConfigReturn,
   IntentCallsPayload,
   IntentPrecondition,
-} from "@0xsequence/api"
-import type { SequenceAPIClient } from "@0xsequence/api"
+} from "@0xsequence/trails-api"
+import type { SequenceAPIClient } from "@0xsequence/trails-api"
 import type { Relayer } from "@0xsequence/wallet-core"
 import { useMutation, useQuery } from "@tanstack/react-query"
 import { Address } from "ox"

package/src/transactions.ts

@@ -1,6 +1,8 @@
 import { createPublicClient, http } from "viem"
 import { getChainInfo } from "./chains.js"
-import { getRpcSequenceProjectAccessKey } from "./config.js"
+import { getRpcSequenceProjectAccessKey, getSequenceEnv } from "./config.js"
+import type { GuestModuleEvent, TrailsTokenSweeperEvent } from "./decoders.js"
+import * as chains from "viem/chains"
 
 export type TransactionStateStatus = "pending" | "failed" | "confirmed"
 
@@ -11,6 +13,8 @@ export type TransactionState = {
   chainId: number
   state: TransactionStateStatus
   label: string
+  decodedTrailsTokenSweeperEvents?: TrailsTokenSweeperEvent[]
+  decodedGuestModuleEvents?: GuestModuleEvent[]
 }
 
 export type TransferType = "SEND" | "RECEIVE"
@@ -163,24 +167,37 @@ export async function getTxTimeDiff(
   }
 }
 
+export function getIndexerUrlChainSlug(chainSlug: string) {
+  const env = getSequenceEnv()
+  let envPrefix = ""
+
+  // Only use dev prefix for katana in dev environment, since it's not deployed to prod yet
+  if (env === "dev" && chainSlug === "katana") {
+    envPrefix = "dev-"
+  }
+
+  return `https://${envPrefix}${chainSlug}-indexer.sequence.app`
+}
+
 const chainIdToIndexerUrl = {
-  42161: "https://arbitrum-indexer.sequence.app",
-  8453: "https://base-indexer.sequence.app",
-  84532: "https://base-sepolia-indexer.sequence.app",
-  10: "https://optimism-indexer.sequence.app",
-  137: "https://polygon-indexer.sequence.app",
-  1: "https://mainnet-indexer.sequence.app",
-  33139: "https://apechain-indexer.sequence.app",
-  42170: "https://arbitrum-nova-indexer.sequence.app",
-  43114: "https://avalanche-indexer.sequence.app",
-  8333: "https://b3-indexer.sequence.app",
-  81457: "https://blast-indexer.sequence.app",
-  100: "https://gnosis-indexer.sequence.app",
-  1868: "https://soneium-indexer.sequence.app",
-  660279: "https://xai-indexer.sequence.app",
-  56: "https://bsc-indexer.sequence.app",
-  421613: "https://arbitrum-nova-sepolia-indexer.sequence.app",
-  42793: "https://etherlink-indexer.sequence.app",
+  [chains.arbitrum.id]: getIndexerUrlChainSlug("arbitrum"),
+  [chains.base.id]: getIndexerUrlChainSlug("base"),
+  [chains.baseSepolia.id]: getIndexerUrlChainSlug("base-sepolia"),
+  [chains.optimism.id]: getIndexerUrlChainSlug("optimism"),
+  [chains.polygon.id]: getIndexerUrlChainSlug("polygon"),
+  [chains.mainnet.id]: getIndexerUrlChainSlug("mainnet"),
+  [chains.apeChain.id]: getIndexerUrlChainSlug("apechain"),
+  [chains.arbitrumNova.id]: getIndexerUrlChainSlug("arbitrum-nova"),
+  [chains.avalanche.id]: getIndexerUrlChainSlug("avalanche"),
+  [chains.b3.id]: getIndexerUrlChainSlug("b3"),
+  [chains.blast.id]: getIndexerUrlChainSlug("blast"),
+  [chains.gnosis.id]: getIndexerUrlChainSlug("gnosis"),
+  [chains.soneium.id]: getIndexerUrlChainSlug("soneium"),
+  [chains.xai.id]: getIndexerUrlChainSlug("xai"),
+  [chains.bsc.id]: getIndexerUrlChainSlug("bsc"),
+  421613: getIndexerUrlChainSlug("arbitrum-nova-sepolia"),
+  [chains.etherlink.id]: getIndexerUrlChainSlug("etherlink"),
+  [chains.katana.id]: getIndexerUrlChainSlug("katana"),
 }
 
 export async function getAccountTransactionHistory({

package/src/utils.ts

@@ -40,3 +40,31 @@ export function formatElapsed(seconds: number): string {
     }
   }
 }
+
+/**
+ * Calculates and formats time ago from a timestamp
+ * @param timestamp - Timestamp in milliseconds
+ * @returns Formatted time ago string (e.g., "Sent just now", "Sent 5 minutes ago")
+ */
+export function getTimeAgo(timestamp?: number): string {
+  if (!timestamp) return "Sent just now"
+
+  const now = Date.now()
+  const diffInSeconds = Math.floor((now - timestamp) / 1000)
+
+  if (diffInSeconds < 1) return "Sent just now"
+  if (diffInSeconds === 1) return "Sent 1 second ago"
+  if (diffInSeconds < 60) return `Sent ${diffInSeconds} seconds ago`
+
+  const diffInMinutes = Math.floor(diffInSeconds / 60)
+  if (diffInMinutes === 1) return "Sent 1 minute ago"
+  if (diffInMinutes < 60) return `Sent ${diffInMinutes} minutes ago`
+
+  const diffInHours = Math.floor(diffInMinutes / 60)
+  if (diffInHours === 1) return "Sent 1 hour ago"
+  if (diffInHours < 24) return `Sent ${diffInHours} hours ago`
+
+  const diffInDays = Math.floor(diffInHours / 24)
+  if (diffInDays === 1) return "Sent 1 day ago"
+  return `Sent ${diffInDays} days ago`
+}