0xtrails 0.2.5 → 0.3.0

package/src/prices.ts

@@ -1,7 +1,8 @@
-import type { SequenceAPIClient, Token, TokenPrice } from "@0xsequence/api"
+import type { Token, TokenPrice } from "@0xsequence/trails-api"
 import { QueryClient, useQuery } from "@tanstack/react-query"
 import { zeroAddress } from "viem"
 import { logger } from "./logger.js"
+import type { TrailsClient } from "./trailsClient.js"
 
 // Global caching configuration
 const CACHE_CONFIG = {
@@ -53,7 +54,7 @@ const tokenPricesQueryClient = new QueryClient({
 
 // Cache key generation methods
 const createTokenCacheKey = (token: Token): string => {
-  return `${token.contractAddress}-${token.chainId}-${token.tokenId}`
+  return `${token.tokenAddress}-${token.chainId}-${token.tokenSymbol || ""}`
 }
 
 const createBatchCacheKey = (
@@ -73,11 +74,11 @@ const createSingleCacheKey = (token?: Token | null): (string | null)[] => {
 
 // Separate fetch function for token prices
 export const fetchGetTokenPrices = async (
-  apiClient: SequenceAPIClient,
+  trailsClient: TrailsClient,
   tokens: Token[],
 ): Promise<TokenPrice[]> => {
-  if (!apiClient) {
-    throw new Error("API client is required")
+  if (!trailsClient) {
+    throw new Error("Trails client is required")
   }
 
   if (tokens.length === 0) {
@@ -85,7 +86,7 @@ export const fetchGetTokenPrices = async (
   }
 
   try {
-    const res = await apiClient.getCoinPrices({ tokens })
+    const res = await trailsClient.getTokenPrices({ tokens })
     return res?.tokenPrices || []
   } catch (error) {
     logger.console.error("[trails-sdk] Failed to fetch token prices:", error)
@@ -94,52 +95,55 @@ export const fetchGetTokenPrices = async (
 }
 
 export function normalizeToken(
-  token: Token & { tokenID?: string; symbol?: string },
+  token: Token & {
+    tokenID?: string
+    symbol?: string
+    contractAddress?: string
+    tokenId?: string
+  },
 ): Token {
   return {
     chainId: token.chainId,
-    contractAddress: token.contractAddress || zeroAddress,
-    tokenId: token.tokenId || token.tokenID || token.symbol,
+    tokenAddress: token.tokenAddress || token.contractAddress || zeroAddress,
+    tokenSymbol:
+      token.tokenSymbol || token.tokenId || token.tokenID || token.symbol,
   }
 }
 
 export const getTokenPrices = async (
-  apiClient: SequenceAPIClient,
+  trailsClient: TrailsClient,
   tokens: Token[],
 ): Promise<TokenPrice[]> => {
   tokens = tokens.map(normalizeToken)
 
   return tokenPricesQueryClient.fetchQuery({
     queryKey: createBatchCacheKey(tokens),
-    queryFn: () => fetchGetTokenPrices(apiClient, tokens),
+    queryFn: () => fetchGetTokenPrices(trailsClient, tokens),
     ...COMMON_QUERY_OPTIONS,
   })
 }
 
 export const getTokenPrice = async (
-  apiClient: SequenceAPIClient,
+  trailsClient: TrailsClient,
   token: Token,
 ): Promise<TokenPrice | null> => {
   return tokenPricesQueryClient.fetchQuery({
     queryKey: createSingleCacheKey(token),
     queryFn: async () => {
-      const prices = await getTokenPrices(apiClient, [token])
+      const prices = await getTokenPrices(trailsClient, [token])
       return prices?.length ? prices[0] : null
     },
     ...COMMON_QUERY_OPTIONS,
   })
 }
 
-export const useTokenPrices = (
-  tokens: Token[],
-  apiClient: SequenceAPIClient,
-) => {
+export const useTokenPrices = (tokens: Token[], trailsClient: TrailsClient) => {
   tokens = tokens.map(normalizeToken)
 
   const { data: tokenPrices, isLoading: isLoadingTokenPrices } = useQuery({
     queryKey: createBatchCacheKey(tokens),
-    queryFn: () => getTokenPrices(apiClient, tokens),
-    enabled: tokens.length > 0 && !!apiClient,
+    queryFn: () => getTokenPrices(trailsClient, tokens),
+    enabled: tokens.length > 0 && !!trailsClient,
     ...COMMON_QUERY_OPTIONS,
   })
 
@@ -151,13 +155,13 @@ export const useTokenPrices = (
 
 export const useTokenPrice = (
   token?: Token | null,
-  apiClient?: SequenceAPIClient,
+  trailsClient?: TrailsClient,
 ) => {
   const { data: tokenPrice, isLoading: isLoadingTokenPrice } = useQuery({
     queryKey: createSingleCacheKey(token),
     queryFn: () =>
-      token && apiClient ? getTokenPrice(apiClient, token) : null,
-    enabled: !!token && !!apiClient,
+      token && trailsClient ? getTokenPrice(trailsClient, token) : null,
+    enabled: !!token && !!trailsClient,
     ...COMMON_QUERY_OPTIONS,
   })
 

package/src/relaySdk.ts

@@ -304,12 +304,12 @@ export async function executeSimpleRelayTransaction(
 
 export function getTxHashFromRelayResult(result: RelayExecuteResult): string {
   let txHash =
-    result?.data?.steps?.[result?.data?.steps!.length - 1]?.items?.[0]
+    result?.data?.steps?.[result?.data?.steps?.length - 1]?.items?.[0]
       ?.txHashes?.[0]?.txHash
 
   if (!txHash) {
     txHash =
-      result?.data?.steps?.[result?.data?.steps!.length - 1]?.items?.[0]
+      result?.data?.steps?.[result?.data?.steps?.length - 1]?.items?.[0]
         ?.internalTxHashes?.[0]?.txHash
   }
 

package/src/sequenceWallet.ts

@@ -3,8 +3,6 @@ import { commons } from "@0xsequence/core"
 import { allNetworks } from "@0xsequence/network"
 import { trackers } from "@0xsequence/sessions"
 import { Orchestrator, type signers } from "@0xsequence/signhub"
-import type { Payload } from "@0xsequence/wallet-primitives"
-import { ethers } from "ethers"
 import { Abi, AbiFunction } from "ox"
 import {
   bytesToHex,
@@ -14,11 +12,8 @@ import {
   toHex,
   type WalletClient,
 } from "viem"
-import type { RelayerEnvConfig, RelayerEnv } from "./relayer.js"
-import { getRelayerUrl } from "./relayer.js"
-import { getSequenceProjectAccessKey, getSequenceEnv } from "./config.js"
+import { getSequenceProjectAccessKey } from "./config.js"
 import { logger } from "./logger.js"
-import type { Relayer } from "@0xsequence/relayer"
 
 export type FlatTransaction = {
   to: string
@@ -42,38 +37,9 @@ export const TRACKER = new trackers.remote.RemoteConfigTracker(
   "https://sessions.sequence.app",
 )
 
-type GetAccountNetworksInput = {
-  relayerConfig: RelayerEnvConfig
-  sequenceProjectAccessKey: string
-}
-
-export function getAccountNetworks(input: GetAccountNetworksInput): any[] {
-  return allNetworks.map((network) => {
-    try {
-      const relayerUrl = getRelayerUrl(input.relayerConfig, network.chainId)
-      if (relayerUrl) {
-        const relayer: any = {
-          provider: new ethers.JsonRpcProvider(network.rpcUrl),
-          url: relayerUrl,
-          projectAccessKey: input.sequenceProjectAccessKey,
-        }
-        return {
-          ...network,
-          relayer,
-        }
-      }
-    } catch (_err: unknown) {
-      // noop
-    }
-    return network
-  })
-}
-
 export async function createSequenceWallet(
   threshold: number,
   signers: { address: string; weight: number }[],
-  relayerConfig: RelayerEnvConfig,
-  sequenceProjectAccessKey: string,
 ): Promise<Account> {
   const account = await Account.new({
     config: {
@@ -85,7 +51,7 @@ export async function createSequenceWallet(
     tracker: TRACKER,
     contexts: commons.context.defaultContexts,
     orchestrator: new Orchestrator([]),
-    networks: getAccountNetworks({ relayerConfig, sequenceProjectAccessKey }),
+    networks: allNetworks,
   })
 
   // Try to fetch the config from the tracker
@@ -129,7 +95,6 @@ export function toSequenceTransaction(
 export function accountFor(args: {
   address: string
   signatures?: { signer: string; signature: string }[]
-  relayerConfig: RelayerEnvConfig
   sequenceProjectAccessKey: string
 }): Account {
   const signers: signers.SapientSigner[] = []
@@ -158,10 +123,7 @@ export function accountFor(args: {
     tracker: TRACKER,
     contexts: commons.context.defaultContexts,
     orchestrator: new Orchestrator(signers),
-    networks: getAccountNetworks({
-      relayerConfig: args.relayerConfig,
-      sequenceProjectAccessKey: args.sequenceProjectAccessKey,
-    }),
+    networks: allNetworks,
   })
 }
 
@@ -217,20 +179,13 @@ export function recoverSigner(
 
 export async function simpleCreateSequenceWallet(
   account: Account,
-  relayerConfig: RelayerEnvConfig = {
-    env: getSequenceEnv() as RelayerEnv,
-  },
-  sequenceProjectAccessKey: string = getSequenceProjectAccessKey(),
 ): Promise<`0x${string}`> {
   const signer = account.address
   const threshold = 1
   const weight = 1
-  const wallet = await createSequenceWallet(
-    threshold,
-    [{ address: signer, weight: weight }],
-    relayerConfig,
-    sequenceProjectAccessKey,
-  )
+  const wallet = await createSequenceWallet(threshold, [
+    { address: signer, weight: weight },
+  ])
 
   return wallet.address as `0x${string}`
 }
@@ -266,9 +221,6 @@ export async function sequenceSendTransaction(
   publicClient: PublicClient,
   calls: any[],
   chain: Chain,
-  relayerConfig: RelayerEnvConfig = {
-    env: getSequenceEnv() as RelayerEnv,
-  },
   sequenceProjectAccessKey: string = getSequenceProjectAccessKey(),
 ): Promise<string | null> {
   const chainId = chain.id
@@ -309,7 +261,6 @@ export async function sequenceSendTransaction(
         signature: suffixed,
       },
     ],
-    relayerConfig,
     sequenceProjectAccessKey,
   })
   const sequenceTxs = toSequenceTransactions(txsToExecute)
@@ -527,24 +478,6 @@ export class StaticSigner implements signers.SapientSigner {
   }
 }
 
-export async function getFeeOptions(
-  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,
-    calls,
-  )
-
-  return feeOptions
-}
-
 // Import the encodeGasRefundTransaction function
 function encodeGasRefundTransaction(option?: any): FlatTransaction[] {
   if (!option) return []