0xtrails 0.1.2 → 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"
 
@@ -204,3 +208,24 @@ export function formatTvl(tvl: number): string {
   if (tvl >= 1e3) return `$${(tvl / 1e3).toFixed(1)}K`
   return `$${tvl.toFixed(0)}`
 }
+
+// Helper function to validate numeric values
+export const isValidNumeric = (
+  value: number | string | null | undefined,
+): boolean => {
+  if (value === null || value === undefined || value === "") {
+    return true // Empty values are considered valid
+  }
+  const strValue = String(value).trim()
+  return /^\d+(\.\d+)?$/.test(strValue)
+}
+
+export const isValidInteger = (
+  value: number | string | null | undefined,
+): boolean => {
+  if (value === null || value === undefined || value === "") {
+    return true // Empty values are considered valid
+  }
+  const strValue = String(value).trim()
+  return /^\d+$/.test(strValue)
+}

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/relaySdk.ts

@@ -242,6 +242,7 @@ export const relaySupportedChains: Record<number, Chain> = {
   [chains.zircuit.id]: chains.zircuit,
   [chains.zksync.id]: chains.zksync,
   [chains.zora.id]: chains.zora,
+  [chains.katana.id]: chains.katana,
 }
 
 export async function getRelaySupportedChains(): Promise<Chain[]> {

package/src/relayer.ts

@@ -162,6 +162,10 @@ export function getRelayerUrl(
       relayerUrl = "https://v3-xai-relayer.sequence.app"
     } else if (chainId === 56) {
       relayerUrl = "https://v3-bsc-relayer.sequence.app"
+    } else if (chainId === 747474) {
+      relayerUrl = "https://v3-katana-relayer.sequence.app"
+    } else if (chainId === 42793) {
+      relayerUrl = "https://v3-etherlink-relayer.sequence.app"
     } else {
       // Fallback to general dev relayer for other chains if V3 is specified but chain not V3-supported
       relayerUrl = `${baseUrl}${getChainInfo(chainId)!.name?.replace(" ", "-")}-relayer.sequence.app`
@@ -207,6 +211,10 @@ export function getRelayerUrl(
       relayerUrl = "https://dev-xai-relayer.sequence.app"
     } else if (chainId === 56) {
       relayerUrl = "https://dev-bsc-relayer.sequence.app"
+    } else if (chainId === 747474) {
+      relayerUrl = "https://dev-katana-relayer.sequence.app"
+    } else if (chainId === 42793) {
+      relayerUrl = "https://dev-etherlink-relayer.sequence.app"
     } else {
       // Fallback to general dev relayer for other chains if V3 is specified but chain not V3-supported
       relayerUrl = `${baseUrl}${getChainInfo(chainId)!.name?.replace(" ", "-")}-relayer.sequence.app`

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 {
@@ -283,6 +286,9 @@ export function formatRawAmount(
   balance: string | bigint,
   decimals: number = 18,
 ): string {
+  if (!balance) {
+    return "0"
+  }
   try {
     const formatted = formatUnits(BigInt(balance), decimals)
     return formatAmount(formatted)
@@ -429,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
   })
 }
 
@@ -724,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
@@ -783,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
@@ -793,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,7 +1,7 @@
 import { QueryClient, useQuery } from "@tanstack/react-query"
-import { zeroAddress, erc20Abi } from "viem"
-import * as chains from "viem/chains"
+import { zeroAddress, erc20Abi, createPublicClient, http } from "viem"
 import { getChainInfo, getSupportedChains } from "./chains.js"
+import * as chains from "viem/chains"
 import { getRelaySupportedTokens } from "./relaySdk.js"
 import { useReadContracts } from "wagmi"
 import { useMemo } from "react"
@@ -17,6 +17,21 @@ export type SupportedToken = {
   imageUrl: string
 }
 
+export const commonTokenImages: Record<string, string> = {
+  ETH: "https://assets.sequence.info/images/tokens/large/1/0x0000000000000000000000000000000000000000.webp",
+  WETH: "https://assets.coingecko.com/coins/images/39723/small/WETH.PNG?1723733967",
+  POL: "https://assets.sequence.info/images/tokens/large/137/0x0000000000000000000000000000000000000000.webp",
+  USDC: "https://assets.sequence.info/images/tokens/large/1/0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48.webp",
+  USDT: "https://assets.sequence.info/images/tokens/large/1/0xdac17f958d2ee523a2206206994597c13d831ec7.webp",
+  DAI: "https://assets.sequence.info/images/tokens/large/1/0x6b175474e89094c44da98b954eedeac495271d0f.webp",
+  WBTC: "https://assets.sequence.info/images/tokens/large/1/0x2260fac5e5542a773aa44fbcfedf7c193bc2c599.webp",
+  BAT: "https://assets.sequence.info/images/tokens/large/1/0x0d8775f648430679a709e98d2b0cb6250d2887ef.webp",
+  ARB: "https://assets.sequence.info/images/tokens/large/42161/0x912ce59144191c1204e64559fe8253a0e49e6548.webp",
+  LINK: "https://assets.sequence.info/images/tokens/large/1/0x514910771af9ca656af840dff83e8264ecf986ca.webp",
+  XTZ: "https://assets.sequence.info/images/tokens/large/42793/0x0000000000000000000000000000000000000000.webp",
+  WXTZ: "https://assets.coingecko.com/coins/images/976/standard/Tezos-logo.png?1696502091",
+}
+
 const cacheVersion = "01"
 
 // LocalStorage cache utilities for token images
@@ -303,8 +318,13 @@ export async function getTokenImageUrlOrFallback({
   }
 }
 
+export async function getAllTokens(): Promise<SupportedToken[]> {
+  const relayTokens = (await getRelaySupportedTokens()) as SupportedToken[]
+  return relayTokens
+}
+
 export async function getSupportedTokens(): Promise<SupportedToken[]> {
-  const tokens = await getRelaySupportedTokens()
+  const tokens = await getAllTokens()
   for (const token of tokens) {
     if (!token.imageUrl) {
       token.imageUrl = getTokenImageUrl({
@@ -342,9 +362,13 @@ export async function getSupportedTokens(): Promise<SupportedToken[]> {
 
   const supportedChains = await getSupportedChains()
   const allTokens = [...tokens, ...additionalTokens]
-  const supportedChainTokens = allTokens.filter((token) =>
-    supportedChains.some((chain) => chain.id === token.chainId),
-  )
+  const supportedChainTokens = allTokens.filter((token) => {
+    // Always include Etherlink tokens
+    if (token.chainId === chains.etherlink.id) {
+      return true
+    }
+    return supportedChains.some((chain) => chain.id === token.chainId)
+  })
   const uniqueTokens = supportedChainTokens.filter(
     (token, index, self) =>
       index ===
@@ -357,7 +381,9 @@ export async function getSupportedTokens(): Promise<SupportedToken[]> {
   )
 
   // Sort tokens according to priority order
-  return sortTokens(uniqueTokens as SupportedToken[])
+  const sortedTokens = sortTokens(uniqueTokens as SupportedToken[])
+
+  return sortedTokens
 }
 
 export function useSupportedTokens({ chainId }: { chainId?: number } = {}): {
@@ -426,6 +452,7 @@ export const tokenNamePrefixes: Record<string, string> = {
   [chains.optimism.id]: "Optimistic",
   [chains.arbitrum.id]: "Arbitrum",
   [chains.polygon.id]: "Polygon",
+  [chains.etherlink.id]: "Etherlink",
 }
 
 export function getFormatttedTokenName(
@@ -508,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)
@@ -515,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) {
@@ -788,21 +874,8 @@ export function useTokenInfo({
   }
 }
 
-export const commonTokenImages: Record<string, string> = {
-  ETH: "https://assets.sequence.info/images/tokens/large/1/0x0000000000000000000000000000000000000000.webp",
-  POL: "https://assets.sequence.info/images/tokens/large/137/0x0000000000000000000000000000000000000000.webp",
-  USDC: "https://assets.sequence.info/images/tokens/large/1/0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48.webp",
-  USDT: "https://assets.sequence.info/images/tokens/large/1/0xdac17f958d2ee523a2206206994597c13d831ec7.webp",
-  DAI: "https://assets.sequence.info/images/tokens/large/1/0x6b175474e89094c44da98b954eedeac495271d0f.webp",
-  WBTC: "https://assets.sequence.info/images/tokens/large/1/0x2260fac5e5542a773aa44fbcfedf7c193bc2c599.webp",
-  BAT: "https://assets.sequence.info/images/tokens/large/1/0x0d8775f648430679a709e98d2b0cb6250d2887ef.webp",
-  ARB: "https://assets.sequence.info/images/tokens/large/42161/0x912ce59144191c1204e64559fe8253a0e49e6548.webp",
-  LINK: "https://assets.sequence.info/images/tokens/large/1/0x514910771af9ca656af840dff83e8264ecf986ca.webp",
-}
-
 export const tokenImageSymbolMap: Record<string, string> = {
   ETH: "ETH",
-  WETH: "ETH",
   cbETH: "ETH",
   POL: "POL",
   WPOL: "POL",
@@ -1018,6 +1091,58 @@ export const commonTokens: SupportedToken[] = [
     chainName: chains.mainnet.name,
     imageUrl: commonTokenImages.LINK!,
   },
+
+  // Etherlink tokens
+  {
+    id: "XTZ-etherlink",
+    symbol: "XTZ",
+    name: "Tezos",
+    contractAddress: "0x0000000000000000000000000000000000000000",
+    decimals: 18,
+    chainId: chains.etherlink.id,
+    chainName: chains.etherlink.name,
+    imageUrl: commonTokenImages.XTZ as string,
+  },
+  {
+    id: "WXTZ-etherlink",
+    symbol: "WXTZ",
+    name: "Wrapped XTZ",
+    contractAddress: "0xc9B53AB2679f573e480d01e0f49e2B5CFB7a3EAb",
+    decimals: 18,
+    chainId: chains.etherlink.id,
+    chainName: chains.etherlink.name,
+    imageUrl: commonTokenImages.WXTZ as string,
+  },
+  {
+    id: "USDC-etherlink",
+    symbol: "USDC",
+    name: "USD Coin",
+    contractAddress: "0x796Ea11Fa2dD751eD01b53C372fFDB4AAa8f00F9",
+    decimals: 6,
+    chainId: chains.etherlink.id,
+    chainName: chains.etherlink.name,
+    imageUrl: commonTokenImages.USDC as string,
+  },
+  {
+    id: "WETH-etherlink",
+    symbol: "WETH",
+    name: "Wrapped ETH",
+    contractAddress: "0xfc24f770F94edBca6D6f885E12d4317320BcB401",
+    decimals: 18,
+    chainId: chains.etherlink.id,
+    chainName: chains.etherlink.name,
+    imageUrl: commonTokenImages.WETH as string,
+  },
+  {
+    id: "USDT-etherlink",
+    symbol: "USDT",
+    name: "Bridged USDT",
+    contractAddress: "0x2C03058C8AFC06713be23e58D2febC8337dbfE6A",
+    decimals: 6,
+    chainId: chains.etherlink.id,
+    chainName: chains.etherlink.name,
+    imageUrl: commonTokenImages.USDT as string,
+  },
 ]
 
 export const wethAddresses: Record<string, 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"
@@ -98,7 +98,7 @@ export type UseTrailsReturn = {
     mainSignerAddress: string
     calls: IntentCallsPayload[]
     preconditions: IntentPrecondition[]
-    quoteProvider: "lifi" | "relay" | "cctp"
+    quoteProvider: QuoteProvider
     addressOverrides?: AddressOverrides
   }) => void
   commitIntentConfigPending: boolean
@@ -109,7 +109,7 @@ export type UseTrailsReturn = {
         mainSignerAddress: string
         calls: IntentCallsPayload[]
         preconditions: IntentPrecondition[]
-        quoteProvider: "lifi" | "relay" | "cctp"
+        quoteProvider: QuoteProvider
         addressOverrides?: AddressOverrides
       }
     | undefined

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,23 +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",
+  [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`
+}