0xtrails 0.2.2 → 0.2.5

package/src/queryParams.ts

@@ -1,11 +1,12 @@
 import { useEffect, useState } from "react"
+import { logger } from "./logger.js"
 
 export function getQueryParam(key: string): string | null {
   try {
     if (typeof window === "undefined") return null
     return new URLSearchParams(window.location.search).get(key)
   } catch (error) {
-    console.error("Error getting query param", error)
+    logger.console.error("Error getting query param", error)
     return null
   }
 }

package/src/relayer.ts

@@ -1,4 +1,4 @@
-import { Relayer } from "@0xsequence/wallet-core"
+import { Relayer } from "@0xsequence/relayer"
 import { useMemo } from "react"
 import { getChainInfo, getRpcUrl } from "./chains.js"
 import { Hex } from "ox"
@@ -45,7 +45,10 @@ export interface MetaTxnReceipt {
 }
 
 export type RelayerOperationStatus = Relayer.OperationStatus
-export type RpcRelayer = Relayer.Standard.Rpc.RpcRelayer
+export type RelayerOperationFailedStatus = Relayer.OperationFailedStatus
+export type RelayerOperationPendingStatus = Relayer.OperationPendingStatus
+export type RelayerOperationConfirmedStatus = Relayer.OperationConfirmedStatus
+export type RelayerOperationUnknownStatus = Relayer.OperationUnknownStatus
 
 export type RelayerConfig = {
   hostname: string
@@ -120,15 +123,15 @@ function wrappedFetch(
 
 export function getBackupRelayer(
   chainId: number,
-): Relayer.Standard.Rpc.RpcRelayer | undefined {
+): Relayer.RpcRelayer | undefined {
   if (chainId === 42161) {
-    return new Relayer.Standard.Rpc.RpcRelayer(
+    return new Relayer.RpcRelayer(
       "https://a1b4a8c5d856.ngrok.app/",
       chainId,
       getRpcUrl(chainId)!,
     )
   } else if (chainId === 8453) {
-    return new Relayer.Standard.Rpc.RpcRelayer(
+    return new Relayer.RpcRelayer(
       "https://644a6aeb891e.ngrok.app/",
       chainId,
       getRpcUrl(chainId)!,
@@ -187,7 +190,7 @@ export function getRelayer(
     env: getSequenceEnv() as RelayerEnv,
   },
   chainId: number,
-): Relayer.Standard.Rpc.RpcRelayer {
+): Relayer.RpcRelayer {
   const chain = getChainInfo(chainId)
 
   if (!chain) {
@@ -201,7 +204,7 @@ export function getRelayer(
 
   const relayerUrl = getRelayerUrl(config, chainId)
 
-  const relayer = new Relayer.Standard.Rpc.RpcRelayer(
+  const relayer = new Relayer.RpcRelayer(
     relayerUrl,
     chainId,
     rpcUrl,
@@ -258,20 +261,16 @@ export function useRelayers(
     env: getSequenceEnv() as RelayerEnv,
   },
 ): {
-  relayers: Map<number, Relayer.Standard.Rpc.RpcRelayer>
-  getRelayer: (chainId: number) => Relayer.Standard.Rpc.RpcRelayer
-  getBackupRelayer: (
-    chainId: number,
-  ) => Relayer.Standard.Rpc.RpcRelayer | undefined
+  relayers: Map<number, Relayer.RpcRelayer>
+  getRelayer: (chainId: number) => Relayer.RpcRelayer
+  getBackupRelayer: (chainId: number) => Relayer.RpcRelayer | undefined
 } {
   const relayers = useMemo(() => {
-    const relayerMap = new Map<number, Relayer.Standard.Rpc.RpcRelayer>()
+    const relayerMap = new Map<number, Relayer.RpcRelayer>()
     return relayerMap
   }, [])
 
-  const getCachedRelayer = (
-    chainId: number,
-  ): Relayer.Standard.Rpc.RpcRelayer => {
+  const getCachedRelayer = (chainId: number): Relayer.RpcRelayer => {
     let relayer = relayers.get(chainId)
 
     if (!relayer) {

package/src/sequenceWallet.ts

@@ -14,10 +14,11 @@ import {
   toHex,
   type WalletClient,
 } from "viem"
-import type { Relayer, RelayerEnvConfig, RelayerEnv } from "./relayer.js"
+import type { RelayerEnvConfig, RelayerEnv } from "./relayer.js"
 import { getRelayerUrl } from "./relayer.js"
 import { getSequenceProjectAccessKey, getSequenceEnv } from "./config.js"
 import { logger } from "./logger.js"
+import type { Relayer } from "@0xsequence/relayer"
 
 export type FlatTransaction = {
   to: string
@@ -527,11 +528,14 @@ export class StaticSigner implements signers.SapientSigner {
 }
 
 export async function getFeeOptions(
-  relayer: Relayer.Standard.Rpc.RpcRelayer,
+  relayer: Relayer.RpcRelayer,
   wallet: string,
   chainId: number,
   calls: Payload.Call[],
-) {
+): Promise<{
+  options: Relayer.FeeOption[]
+  quote?: Relayer.FeeQuote
+}> {
   const feeOptions = await relayer.feeOptions(
     wallet as `0x${string}`,
     chainId,

package/src/tokenBalances.ts

@@ -17,6 +17,7 @@ import { useIndexerGatewayClient } from "./indexerClient.js"
 import { getTokenPrices, useTokenPrices } from "./prices.js"
 import { logger } from "./logger.js"
 import { getChainInfo } from "./chains.js"
+import { getTokenImageUrl } from "./tokens.js"
 
 export type { NativeTokenBalance, TokenBalance }
 
@@ -58,6 +59,10 @@ export interface TokenBalanceWithPrice extends TokenBalance {
   balanceUsd?: number
   balanceUsdFormatted?: string
   chainName?: string
+  imageUrl?: string
+  symbol?: string
+  name?: string
+  decimals?: number
 }
 
 export interface NativeTokenBalanceWithPrice extends NativeTokenBalance {
@@ -66,6 +71,9 @@ export interface NativeTokenBalanceWithPrice extends NativeTokenBalance {
   balanceUsdFormatted?: string
   symbol?: string
   chainName?: string
+  imageUrl?: string
+  name?: string
+  decimals?: number
 }
 
 export type TokenBalanceExtended =
@@ -268,11 +276,32 @@ export function useTokenBalances(
             ...token,
             contractAddress: zeroAddress, // Native tokens always use zero address
             chainName: getChainInfo(token.chainId)?.name || "",
+            symbol: token.symbol ?? (token as any).contractInfo?.symbol,
+            name: (token as any).name ?? (token as any).contractInfo?.name,
+            decimals:
+              (token as any).decimals ??
+              (token as any).contractInfo?.decimals ??
+              18, // Use token decimals or default to 18
+            imageUrl: getTokenImageUrl({
+              chainId: token.chainId,
+              contractAddress: zeroAddress,
+              symbol: token.symbol ?? (token as any).contractInfo?.symbol,
+              fallbackImageUrl: (token as any).contractInfo?.logoURI,
+            }),
           })),
           ...tokenBalancesData.balances.map((token) => ({
             ...token,
             contractAddress: token.contractAddress,
             chainName: getChainInfo(token.contractInfo?.chainId)?.name || "",
+            symbol: token.contractInfo?.symbol,
+            name: token.contractInfo?.name,
+            decimals: token.contractInfo?.decimals,
+            imageUrl: getTokenImageUrl({
+              chainId: token.contractInfo?.chainId || 0,
+              contractAddress: token.contractAddress,
+              symbol: token.contractInfo?.symbol,
+              fallbackImageUrl: token.contractInfo?.logoURI,
+            }),
           })),
         ].filter((token) => {
           try {
@@ -614,6 +643,15 @@ export async function getTokenBalancesFlatArray({
           ...b,
           contractAddress: b.contractAddress ?? zeroAddress,
           tokenId: b.contractInfo?.symbol,
+          symbol: b.contractInfo?.symbol,
+          name: b.contractInfo?.name,
+          decimals: b.contractInfo?.decimals,
+          imageUrl: getTokenImageUrl({
+            chainId: b.contractInfo?.chainId || 0,
+            contractAddress: b.contractAddress ?? zeroAddress,
+            symbol: b.contractInfo?.symbol,
+            fallbackImageUrl: b.contractInfo?.logoURI,
+          }),
         },
       )
     })
@@ -625,6 +663,15 @@ export async function getTokenBalancesFlatArray({
         ...b,
         contractAddress: b.contractAddress ?? zeroAddress,
         tokenId: b.symbol,
+        symbol: b.symbol,
+        name: b.name,
+        decimals: b.decimals ?? b.contractInfo?.decimals ?? 18, // Use token decimals or default to 18
+        imageUrl: getTokenImageUrl({
+          chainId: b.chainId,
+          contractAddress: zeroAddress,
+          symbol: b.symbol,
+          fallbackImageUrl: b.contractInfo?.logoURI,
+        }),
       })
     })
   }

package/src/tokens.ts

@@ -44,6 +44,10 @@ export const commonTokenImages: Record<string, string> = {
   XTZ: "https://assets.sequence.info/images/tokens/large/42793/0x0000000000000000000000000000000000000000.webp",
   WXTZ: "https://assets.coingecko.com/coins/images/976/standard/Tezos-logo.png?1696502091",
   SOMI: "https://assets.sequence.info/images/tokens/large/5031/0x0000000000000000000000000000000000000000.webp",
+  XAI: "https://assets.coingecko.com/coins/images/34258/large/round_icon_2048_px.png?1719523838",
+  APE: "https://assets.sequence.info/images/tokens/large/33139/0x0000000000000000000000000000000000000000.webp",
+  ANIME:
+    "https://assets.coingecko.com/coins/images/53575/large/anime.jpg?1736748703",
 }
 
 const cacheVersion = "01"
@@ -697,10 +701,11 @@ export function getCommonTokenImageUrl({
   contractAddress?: string | null
   chainId?: number | null
 }) {
-  if (!symbol || !contractAddress || !chainId) {
+  if (!contractAddress || !chainId) {
     return ""
   }
 
+  // If no symbol provided, try to look it up from contract address
   if (!symbol) {
     const token = commonTokens.find(
       (t) =>
@@ -717,6 +722,7 @@ export function getCommonTokenImageUrl({
   }
 
   const symbolKey = tokenImageSymbolMap[symbol] ?? symbol
+
   if (commonTokenImages[symbolKey]) {
     return commonTokenImages[symbolKey]
   }
@@ -728,10 +734,12 @@ export function getTokenImageUrl({
   chainId,
   contractAddress,
   symbol,
+  fallbackImageUrl,
 }: {
   chainId?: number
   contractAddress?: string
   symbol?: string
+  fallbackImageUrl?: string
 }) {
   if (!chainId || !contractAddress || !symbol) {
     return ""
@@ -757,6 +765,10 @@ export function getTokenImageUrl({
     }
   }
 
+  if (fallbackImageUrl) {
+    return fallbackImageUrl
+  }
+
   const imageUrl = `https://assets.sequence.info/images/tokens/large/${chainId}/${contractAddress.toLowerCase()}.webp`
   return imageUrl
 }
@@ -960,6 +972,10 @@ export const tokenImageSymbolMap: Record<string, string> = {
   BAT: "BAT",
   ARB: "ARB",
   LINK: "LINK",
+
+  // vault tokens
+  aBasUSDC: "USDC",
+  steakUSDC: "USDC",
 }
 
 export const commonTokens: SupportedToken[] = [

package/src/trails.ts

@@ -6,7 +6,7 @@ import type {
   IntentPrecondition,
 } from "@0xsequence/trails-api"
 import type { TrailsClient } from "./trailsClient.js"
-import type { Relayer } from "@0xsequence/wallet-core"
+import type { RelayerOperationStatus } from "./relayer.js"
 import { useMutation, useQuery } from "@tanstack/react-query"
 import { Address } from "ox"
 import { useCallback, useEffect, useMemo, useRef, useState } from "react"
@@ -154,7 +154,7 @@ export type UseTrailsReturn = {
   sendMetaTxnError: Error | null
   sendMetaTxnArgs: { selectedId: string | null } | undefined
   clearIntent: () => void
-  metaTxnMonitorStatuses: { [key: string]: Relayer.OperationStatus }
+  metaTxnMonitorStatuses: { [key: string]: RelayerOperationStatus }
   createIntent: (args: GetIntentCallsPayloadsArgs) => void
   createIntentPending: boolean
   createIntentSuccess: boolean

package/src/wallets.ts

@@ -172,6 +172,7 @@ export const connectors = [
   zerionConnector,
   ambireConnector,
   rabbyConnector,
+  sequenceConnector,
 ]
 
 export const WALLET_CONFIGS: Record<string, WalletConfig> = {
@@ -282,6 +283,12 @@ export const WALLET_CONFIGS: Record<string, WalletConfig> = {
     connector: sequenceConnector,
     icon: SequenceLogo as string,
   },
+  "sequence-waas": {
+    id: "sequence-waas",
+    name: "Sequence WaaS",
+    connector: sequenceConnector,
+    icon: SequenceLogo as string,
+  },
 }
 
 export const topShownWallets = [
@@ -320,6 +327,7 @@ export const wagmiConnectorToWalletId = (wagmiConnector: any): string => {
   if (wagmiConnectorName.includes("okx")) return "okxwallet"
   if (wagmiConnectorName.includes("privy")) return "privy"
   if (wagmiConnectorName.includes("gemini")) return "gemini"
+  if (wagmiConnectorName.includes("waas")) return "sequence-waas"
   if (wagmiConnectorName.includes("sequence")) return "sequence"
   return wagmiConnector.id || "injected"
 }