0xtrails 0.13.0 → 0.13.2

package/src/chains.ts

@@ -47,12 +47,17 @@ import {
 } from "viem/chains"
 import { somnia } from "./customChains.js"
 
-export function getShouldFetchVersions(): boolean {
-  const trailsApiUrl = getConfig("trailsApiUrl")
+export function getShouldFetchVersions(overrideTrailsApiUrl?: string): boolean {
+  const trailsApiUrl = overrideTrailsApiUrl || getConfig("trailsApiUrl") || ""
+  const normalized = trailsApiUrl.toLowerCase()
+
   const isDev =
-    trailsApiUrl?.includes("dev2-trails-api.sequence-dev.app") === true
+    normalized.includes("dev-trails-api.sequence-dev.app") ||
+    normalized.includes("dev2-trails-api.sequence-dev.app")
+  const isLocal =
+    normalized.includes("localhost") || normalized.includes("127.0.0.1")
 
-  return isDev
+  return isDev || isLocal
 }
 
 // Extended Chain type with imageUrl
@@ -214,15 +219,21 @@ function createHttpTransport(
   chainId: number,
   trailsApiKey?: string,
   sequenceNodeGatewayUrl?: string,
+  retryCount?: number,
 ) {
+  const transportOptions =
+    retryCount === undefined
+      ? TRANSPORT_OPTIONS
+      : { ...TRANSPORT_OPTIONS, retryCount }
+
   if (trailsApiKey && sequenceNodeGatewayUrl) {
     const rpcUrl = getRpcUrl(chainId, trailsApiKey, sequenceNodeGatewayUrl)
     if (rpcUrl) {
-      return http(rpcUrl, TRANSPORT_OPTIONS)
+      return http(rpcUrl, transportOptions)
     }
   }
 
-  return http(undefined, TRANSPORT_OPTIONS)
+  return http(undefined, transportOptions)
 }
 
 export function getChainTransport(
@@ -231,12 +242,14 @@ export function getChainTransport(
     trailsApiKey?: string
     sequenceNodeGatewayUrl?: string
   },
+  retryCount?: number,
 ) {
   const resolvedConfig = config ?? getConfig()
   return createHttpTransport(
     chainId,
     resolvedConfig.trailsApiKey,
     resolvedConfig.sequenceNodeGatewayUrl,
+    retryCount,
   )
 }
 
@@ -244,21 +257,25 @@ export function getChainTransport(
  * Create a public RPC client for a chain using Sequence RPC URLs
  * This is a temporary solution to use global config for RPC URLs
  * @param chainId - The chain ID to create the public client for
+ * @param retryCount - The number of retry attempts for the RPC client
  * @returns Viem PublicClient configured with Sequence RPC URL if available
  */
-export function getChainRpcClient(chainId: number): PublicClient {
+export function getChainRpcClient(
+  chainId: number,
+  retryCount?: number,
+): PublicClient {
   const chainInfo = getChainInfo(chainId)
   if (!chainInfo) {
     logger.console.warn(
       `[trails-sdk] Chain ${chainId} not found. Falling back to a generic public client.`,
     )
     return createPublicClient({
-      transport: getChainTransport(chainId),
+      transport: getChainTransport(chainId, undefined, retryCount),
     })
   }
   return createPublicClient({
     chain: chainInfo,
-    transport: getChainTransport(chainId),
+    transport: getChainTransport(chainId, undefined, retryCount),
   })
 }
 

package/src/constants.ts

@@ -50,6 +50,8 @@ export const PROD_TRAILS_APP_URL = "https://app.trails.build"
 // when trails is used inside of the sequence wallet app.
 export const PROD_SEQUENCE_API_URL = "https://api.sequence.app"
 
+export const PROD_KEYMACHINE_URL = "https://keymachine.sequence.app"
+
 export const DATABEAT_SERVER = "https://databeat.sequence.app"
 export const DATABEAT_KEY =
   "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJhcHAiOiJzZXEtdHJhaWxzIiwiZXhwIjoyMDI4MTIwOTg4fQ.KZIjEziul_nZ4kjEXudvfqeWmVekc5ftXKx_EqDrmZU"

package/src/customTokens.ts

@@ -1,4 +1,4 @@
-import { useState, useCallback, useEffect } from "react"
+import { useState, useCallback } from "react"
 import type { Token } from "./tokens.js"
 import { logger } from "./logger.js"
 
@@ -90,12 +90,6 @@ export function useCustomTokens(): {
     return getCustomTokensFromStorage()
   })
 
-  // Sync with localStorage on mount
-  useEffect(() => {
-    const stored = getCustomTokensFromStorage()
-    setCustomTokens(stored)
-  }, [])
-
   const addCustomToken = useCallback((token: Token) => {
     setCustomTokens((prev) => {
       // Check if token already exists (same chainId + contractAddress)
@@ -111,6 +105,27 @@ export function useCustomTokens(): {
 
       let updated: Token[]
       if (existingIndex >= 0) {
+        const existingToken = prev[existingIndex]
+        if (!existingToken) {
+          return prev
+        }
+
+        // Avoid unnecessary state updates when token payload is unchanged.
+        const isSameTokenData =
+          existingToken.symbol === tokenWithFlag.symbol &&
+          existingToken.name === tokenWithFlag.name &&
+          existingToken.decimals === tokenWithFlag.decimals &&
+          (existingToken.chainId || 0) === (tokenWithFlag.chainId || 0) &&
+          normalizeAddress(existingToken.contractAddress) ===
+            normalizeAddress(tokenWithFlag.contractAddress) &&
+          existingToken.chainName === tokenWithFlag.chainName &&
+          existingToken.imageUrl === tokenWithFlag.imageUrl &&
+          existingToken.isCustomToken === true
+
+        if (isSameTokenData) {
+          return prev
+        }
+
         // Update existing token
         updated = [...prev]
         updated[existingIndex] = tokenWithFlag

package/src/error.ts

@@ -138,6 +138,10 @@ export function getIsQuoteInputError(err: unknown) {
   return isQuoteInputError
 }
 
+export function getIsHighPriceImpactError(err: unknown) {
+  return /HighPriceImpact|high price impact/gi.test(getFullErrorMessage(err))
+}
+
 export function getIsInsufficientLiquidityError(err: unknown) {
   const isInsufficientLiquidity =
     /insufficient liquidity|higher than the available liquidity/gi.test(
@@ -243,6 +247,9 @@ export function getPrettifiedErrorMessage(
   if (fullErrorMessage.toLowerCase().includes("transaction aborted")) {
     return "The transaction was aborted. Please try again."
   }
+  if (getIsHighPriceImpactError(err)) {
+    return "This quote is unavailable due to high price impact (>30%) on a large transfer. Try a smaller amount."
+  }
   const isOnrampAmountTooLow = getIsOnrampAmountTooLowError(err)
   if (isOnrampAmountTooLow) {
     // Try to extract minimum amount from error message

package/src/gasless.ts

@@ -9,6 +9,7 @@ import type {
 import { encodeFunctionData, erc20Abi, getAddress, parseAbi } from "viem"
 import { PERMIT_ABI, TRANSFER_ABI, TRANSFER_FROM_ABI } from "./abi.js"
 import { attemptSwitchChain } from "./chainSwitch.js"
+import { getChainRpcClient } from "./chains.js"
 import { logger } from "./logger.js"
 import { checkProviderHealth, signWithTimeout } from "./walletUtils.js"
 import { toSeconds, now, HOUR_S } from "./utils/time.js"
@@ -96,7 +97,6 @@ export function getTransferCalldata({
 }
 
 export type GetPermitSignatureParams = {
-  publicClient: PublicClient
   walletClient: WalletClient
   signer: `0x${string}`
   spender: `0x${string}`
@@ -107,7 +107,6 @@ export type GetPermitSignatureParams = {
 }
 
 export async function getPermitSignature({
-  publicClient,
   walletClient,
   signer,
   spender,
@@ -126,6 +125,10 @@ export async function getPermitSignature({
     throw new Error("No account found")
   }
 
+  // Use a dedicated read client with no retries for permit domain probing.
+  // This avoids waiting on repeated deterministic failures (e.g. missing eip712Domain()).
+  const publicClient = getChainRpcClient(chain.id, 0)
+
   // Validate that the connected wallet matches the token owner
   if (!addressEqual(walletClient.account.address, signer)) {
     throw new Error(

package/src/index.ts

@@ -140,15 +140,17 @@ export { getCurrencyInfo } from "./utils/fiat.js"
 export {
   getTokenPrice,
   getTokenPrices,
-  useTokenPrice,
-  useTokenPrices,
   invalidateTokenPricesCache,
+  priceQueries,
+} from "./query/price.queries.js"
+export { useTokenPrice, useTokenPrices } from "./query/price.hooks.js"
+export {
   calcAmountUsdPrice,
   normalizeNumber,
   formatTvl,
   isValidNumeric,
   isValidInteger,
-} from "./prices.js"
+} from "./utils/format.js"
 export { getTxTimeDiff } from "./transactions.js"
 export { useCommitIntent, useExecuteIntent } from "./mutations.js"
 export type { Mode } from "./widget/hooks/useViewManager.js"
@@ -160,6 +162,7 @@ export type {
   SequenceEnv,
 } from "./widget/providers/TrailsProvider.js"
 export { logger, getMinLogLevel } from "./logger.js"
+export * from "./onramp/index.js"
 export {
   getTrailsClient,
   useTrailsClient,
@@ -182,8 +185,8 @@ export type {
   BuildRefundTransactionWithSignatureParams,
   UseIntentRecoverParams,
   UseIntentRecoverReturn,
-  UseIntentRecoverWithSignatureParams,
-  UseIntentRecoverWithSignatureReturn,
+  UseIntentRecoverWithAddressParams,
+  UseIntentRecoverWithAddressReturn,
 } from "./recover.js"
 export type {
   IntentReceipt,

package/src/intents.ts

@@ -18,8 +18,9 @@ import type {
   TransactionStateInfo,
 } from "@0xtrails/api"
 import { logger } from "./logger.js"
-import { IntentProtocolVersion, IntentSource, JsonEncode } from "@0xtrails/api"
+import { IntentProtocolVersion, JsonEncode } from "@0xtrails/api"
 import type { TrailsClient } from "./trailsClient.js"
+import type { KeyMachineClient } from "./keyMachineClient.js"
 import { getIntentStatusFromError } from "./error.js"
 
 import { Config, type Context, Payload } from "@0xsequence/wallet-primitives"
@@ -46,7 +47,7 @@ import { getChainInfo, getChainRpcClient } from "./chains.js"
 import { attemptSwitchChain } from "./chainSwitch.js"
 import { SEQUENCE_V3_CONTRACT_ADDRESSES } from "./constants.js"
 import { getFullErrorMessage } from "./error.js"
-import { GAS_BUFFER, getFeeData } from "./estimate.js"
+import { getFeeData } from "./estimate.js"
 import { zeroAddress } from "viem"
 import { addressEqual, isNativeToken } from "./utils/address.js"
 import { sendWalletTransaction } from "./walletUtils.js"
@@ -251,10 +252,43 @@ export async function quoteIntent(
   }
 }
 
+export async function getIntentConfigurationFromAddress(
+  keyMachineClient: KeyMachineClient,
+  intentAddress: Address.Address,
+): Promise<{
+  address: Address.Address
+  imageHash: Hex.Hex
+  config: Config.Config
+}> {
+  const deployConfig = await keyMachineClient.getDeploy(intentAddress)
+  if (!deployConfig) {
+    throw new Error("Deploy config not found")
+  }
+  const { imageHash, context } = deployConfig
+  const config = await keyMachineClient.getConfiguration(imageHash)
+  if (!config) {
+    throw new Error("Configuration not found")
+  }
+  // Construct the address from the configuration as a double check
+  const derivedImageHash = Config.hashConfiguration(config)
+  const derivedAddress = calculateIntentAddressFromImageHash(
+    context,
+    derivedImageHash,
+  )
+  if (!Address.isEqual(derivedAddress, intentAddress)) {
+    throw new Error("Derived address does not match intent address")
+  }
+  return {
+    address: derivedAddress,
+    imageHash: Bytes.toHex(derivedImageHash),
+    config,
+  }
+}
+
 export async function getIntentConfigurationFromCalls(
-  trailsClient: TrailsClient,
-  intentId: string,
-  intentProtocolVersion: IntentProtocolVersion,
+  _trailsClient: TrailsClient,
+  _intentId: string,
+  intentProtocol: IntentProtocolVersion,
   mainSigner: string,
   checkpoint: number,
   calls: IntentCalls,
@@ -268,57 +302,31 @@ export async function getIntentConfigurationFromCalls(
   logger.console.log(
     "[trails-sdk] [intent-protocol] === Intent Configuration Calculation ===",
     {
-      intentProtocolVersion,
+      intentProtocol,
       mainSigner,
       checkpoint,
       callsCount: calls?.calls?.length ?? 0,
       isOrigin,
       calculationMethod:
-        intentProtocolVersion === IntentProtocolVersion.v1
+        intentProtocol === IntentProtocolVersion.v1
           ? "client-side (Merkle tree)"
-          : "server-side (API call)",
+          : "(NOT IMPLEMENTED)",
     },
   )
-  if (intentProtocolVersion === IntentProtocolVersion.v1) {
+  if (intentProtocol === IntentProtocolVersion.v1) {
     logger.console.log(
       "[trails-sdk] [intent-protocol] v1: Calculating intent config client-side (deprecated)",
       {
-        intentProtocolVersion,
+        intentProtocol,
         method: "buildMerkleTreeFromMembers + counterfactual address",
       },
     )
     return getIntentConfigurationFromCallsV1(mainSigner, calls, context)
   }
 
-  logger.console.log(
-    "[trails-sdk] [intent-protocol] v1.5: Fetching intent config from API",
-    {
-      intentProtocolVersion,
-      intentId,
-      isOrigin,
-    },
+  throw new Error(
+    "Intent protocol v1.5 configuration derivation is not implemented",
   )
-
-  const response = await trailsClient.getIntentConfig({
-    intentId,
-    intentSource: isOrigin ? IntentSource.ORIGIN : IntentSource.DESTINATION,
-  })
-
-  const config = fromServiceConfig(response.walletConfiguration)
-
-  logger.console.log(
-    "[trails-sdk] [intent-protocol] v1.5: Received config from API",
-    {
-      address: response.address.toString(),
-      imageHash: response.imageHash.toString(),
-      hasConfig: !!config,
-    },
-  )
-  return {
-    address: response.address.toString() as `0x${string}`,
-    imageHash: response.imageHash.toString() as `0x${string}`,
-    config,
-  }
 }
 
 // @deprecated - v1 only
@@ -398,7 +406,7 @@ function calculateIntentAddressFromImageHash(
 export async function calculateOriginAndDestinationIntentAddresses(
   trailsClient: TrailsClient,
   intentId: string,
-  intentProtocolVersion: IntentProtocolVersion,
+  intentProtocol: IntentProtocolVersion,
   mainSigner: string,
   checkpoint: number,
   calls: Array<IntentCalls>,
@@ -429,7 +437,7 @@ export async function calculateOriginAndDestinationIntentAddresses(
     await getIntentConfigurationFromCalls(
       trailsClient,
       intentId,
-      intentProtocolVersion,
+      intentProtocol,
       mainSigner,
       checkpoint,
       originCalls[0]!,
@@ -449,7 +457,7 @@ export async function calculateOriginAndDestinationIntentAddresses(
     const { address } = await getIntentConfigurationFromCalls(
       trailsClient,
       intentId,
-      intentProtocolVersion,
+      intentProtocol,
       mainSigner,
       checkpoint,
       originCalls[0]!,
@@ -650,8 +658,8 @@ export async function sendOriginTransaction(
   }
   const publicClient = getChainRpcClient(chainInfo.id)
 
-  // Use provided gasLimit if available, otherwise estimate
-  let gasLimit: bigint
+  // Use provided gasLimit if available, otherwise let the wallet estimate
+  let gasLimit: bigint | undefined
   if (originParams.gasLimit) {
     gasLimit = originParams.gasLimit
     logger.console.log(
@@ -659,22 +667,8 @@ export async function sendOriginTransaction(
       gasLimit,
     )
   } else {
-    const estimatedGasLimit = await publicClient.estimateGas({
-      account: account,
-      to: originParams.to as `0x${string}`,
-      data: originParams.data as `0x${string}`,
-      value: BigInt(originParams.value),
-    })
-
-    gasLimit = estimatedGasLimit + GAS_BUFFER
     logger.console.log(
-      "[trails-sdk][gas-estimation] estimated gasLimit in sendOriginTransaction:",
-      gasLimit,
-      "(estimated:",
-      estimatedGasLimit,
-      "buffer:",
-      GAS_BUFFER,
-      ")",
+      "[trails-sdk][gas-estimation] no gasLimit provided, let wallet estimate",
     )
   }
 
@@ -726,7 +720,9 @@ export async function sendOriginTransaction(
       data: originParams.data as `0x${string}`,
       value: BigInt(originParams.value),
       chain: originParams.chain,
-      gas: gasLimit,
+    }
+    if (gasLimit) {
+      txParams.gas = gasLimit
     }
 
     // Add fee parameters based on transaction type
@@ -909,7 +905,7 @@ function buildMerkleTreeFromMembers(
   return currentLevel[0]!
 }
 
-function fromServiceConfig(config: any): Config.Config {
+function _fromServiceConfig(config: any): Config.Config {
   if (config.checkpointer !== undefined) {
     Address.assert(config.checkpointer)
   }

package/src/keyMachineClient.ts

@@ -0,0 +1,29 @@
+import { useMemo } from "react"
+import { KeyMachine } from "./keymachine/index.js"
+import { useTrails } from "./widget/providers/TrailsProvider.js"
+
+export type KeyMachineClientConfig = {
+  hostname?: string
+}
+
+export class KeyMachineClient extends KeyMachine {}
+
+export function getKeyMachineClient({
+  hostname,
+}: KeyMachineClientConfig): KeyMachine {
+  return new KeyMachine(hostname)
+}
+
+export const useKeyMachineClient = (
+  configOverride?: Partial<KeyMachineClientConfig>,
+) => {
+  const trailsConfig = useTrails()
+
+  const keyMachineClient = useMemo(() => {
+    return getKeyMachineClient({
+      hostname: configOverride?.hostname || trailsConfig.keyMachineUrl,
+    })
+  }, [configOverride?.hostname, trailsConfig.keyMachineUrl])
+
+  return keyMachineClient
+}

package/src/keymachine/index.ts

@@ -0,0 +1,175 @@
+import type {
+  Config,
+  Context,
+  GenericTree,
+} from "@0xsequence/wallet-primitives"
+import { Address, Hex } from "ox"
+import {
+  KeyMachine as KeyMachineService,
+  type Fetch,
+} from "./key-machine.gen.js"
+
+export class KeyMachine {
+  private readonly service: KeyMachineService
+
+  constructor(host = "https://keymachine.sequence.app", fetcher?: Fetch) {
+    const resolvedFetch = fetcher ?? (globalThis as any).fetch
+    if (!resolvedFetch) {
+      throw new Error("fetch is not available")
+    }
+    this.service = new KeyMachineService(host, resolvedFetch)
+  }
+
+  async getConfiguration(
+    imageHash: Hex.Hex,
+  ): Promise<Config.Config | undefined> {
+    const { version, config } = await this.service.config({ imageHash })
+
+    if (version !== 3) {
+      throw new Error(
+        `invalid configuration version ${version}, expected version 3`,
+      )
+    }
+
+    return fromServiceConfig(config)
+  }
+
+  async getDeploy(
+    wallet: Address.Address,
+  ): Promise<{ imageHash: Hex.Hex; context: Context.Context } | undefined> {
+    const { deployHash, context } = await this.service.deployHash({ wallet })
+
+    Hex.assert(deployHash)
+    Address.assert(context.factory)
+    Address.assert(context.mainModule)
+    Address.assert(context.mainModuleUpgradable)
+    Hex.assert(context.walletCreationCode)
+
+    return {
+      imageHash: deployHash,
+      context: {
+        factory: context.factory,
+        stage1: context.mainModule,
+        stage2: context.mainModuleUpgradable,
+        creationCode: context.walletCreationCode,
+      },
+    }
+  }
+
+  async getTree(rootHash: Hex.Hex): Promise<GenericTree.Tree | undefined> {
+    const { version, tree } = await this.service.tree({ imageHash: rootHash })
+
+    if (version !== 3) {
+      throw new Error(`invalid tree version ${version}, expected version 3`)
+    }
+
+    return fromServiceTree(tree)
+  }
+}
+
+type ServiceConfig = {
+  threshold: number | string
+  checkpoint: number | string
+  checkpointer?: string
+  tree: ServiceConfigTree
+}
+
+type ServiceConfigTree =
+  | [ServiceConfigTree, ServiceConfigTree]
+  | string
+  | { weight: number | string; address: string; imageHash?: string }
+  | {
+      weight: number | string
+      threshold: number | string
+      tree: ServiceConfigTree
+    }
+  | { subdigest: string; isAnyAddress?: boolean }
+
+type ServiceTree = string | { data: string } | ServiceTree[]
+
+function fromServiceConfig(config: ServiceConfig): Config.Config {
+  if (config.checkpointer !== undefined) {
+    Address.assert(config.checkpointer)
+  }
+
+  return {
+    threshold: BigInt(config.threshold),
+    checkpoint: BigInt(config.checkpoint),
+    checkpointer: config.checkpointer,
+    topology: fromServiceConfigTree(config.tree),
+  }
+}
+
+function fromServiceConfigTree(tree: ServiceConfigTree): Config.Topology {
+  switch (typeof tree) {
+    case "string":
+      Hex.assert(tree)
+      return tree
+
+    case "object":
+      if (Array.isArray(tree)) {
+        return [fromServiceConfigTree(tree[0]), fromServiceConfigTree(tree[1])]
+      }
+
+      if ("weight" in tree) {
+        if ("address" in tree) {
+          Address.assert(tree.address)
+
+          if (tree.imageHash) {
+            Hex.assert(tree.imageHash)
+            return {
+              type: "sapient-signer",
+              address: tree.address,
+              weight: BigInt(tree.weight),
+              imageHash: tree.imageHash,
+            }
+          } else {
+            return {
+              type: "signer",
+              address: tree.address,
+              weight: BigInt(tree.weight),
+            }
+          }
+        }
+
+        if ("tree" in tree) {
+          return {
+            type: "nested",
+            weight: BigInt(tree.weight),
+            threshold: BigInt(tree.threshold),
+            tree: fromServiceConfigTree(tree.tree),
+          }
+        }
+      }
+
+      if ("subdigest" in tree) {
+        Hex.assert(tree.subdigest)
+        return {
+          type: tree.isAnyAddress ? "any-address-subdigest" : "subdigest",
+          digest: tree.subdigest,
+        }
+      }
+  }
+
+  throw new Error(`unknown config tree '${JSON.stringify(tree)}'`)
+}
+
+function fromServiceTree(tree: ServiceTree): GenericTree.Tree {
+  switch (typeof tree) {
+    case "string":
+      Hex.assert(tree)
+      return tree
+
+    case "object":
+      if (Array.isArray(tree)) {
+        return tree.map(fromServiceTree) as GenericTree.Branch
+      }
+
+      if ("data" in tree) {
+        Hex.assert(tree.data)
+        return { type: "leaf", value: Hex.toBytes(tree.data) }
+      }
+  }
+
+  throw new Error(`unknown tree '${JSON.stringify(tree)}'`)
+}