0xtrails 0.1.2 → 0.1.4

package/src/chains.ts

@@ -2,7 +2,9 @@ import { useQuery } from "@tanstack/react-query"
 import type { Chain } from "viem"
 import * as chains from "viem/chains"
 import { getRelaySupportedChains } from "./relaySdk.js"
+import { getLifiSupportedChains } from "./lifi.js"
 import { getRpcSequenceProjectAccessKey } from "./config.js"
+import type { QuoteProvider } from "./intents.js"
 
 export const sequenceRpcUrls: Record<number, string> = {
   [chains.arbitrum.id]: "https://nodes.sequence.app/arbitrum",
@@ -19,6 +21,8 @@ export const sequenceRpcUrls: Record<number, string> = {
   [chains.b3.id]: "https://nodes.sequence.app/b3",
   [chains.blast.id]: "https://nodes.sequence.app/blast",
   [chains.bsc.id]: "https://nodes.sequence.app/bsc",
+  [chains.katana.id]: "https://nodes.sequence.app/katana",
+  [chains.etherlink.id]: "https://nodes.sequence.app/etherlink",
 }
 
 export const getRpcUrl = (
@@ -46,6 +50,8 @@ export const supportedSequenceChains: Record<number, Chain> = {
   [chains.polygon.id]: getChainInfo(chains.polygon.id)!,
   [chains.soneium.id]: getChainInfo(chains.soneium.id)!,
   [chains.xai.id]: getChainInfo(chains.xai.id)!,
+  [chains.katana.id]: getChainInfo(chains.katana.id)!,
+  [chains.etherlink.id]: getChainInfo(chains.etherlink.id)!,
 }
 
 export const supportedSequenceTestnetChains: Record<number, Chain> = {
@@ -61,6 +67,7 @@ export const supportedSequenceTestnetChains: Record<number, Chain> = {
   [chains.optimismSepolia.id]: getChainInfo(chains.optimismSepolia.id)!,
   [chains.soneiumMinato.id]: getChainInfo(chains.soneiumMinato.id)!,
   [chains.xaiTestnet.id]: getChainInfo(chains.xaiTestnet.id)!,
+  [chains.etherlinkTestnet.id]: getChainInfo(chains.etherlinkTestnet.id)!,
 }
 
 export const mainnetChainsToTestnetChains: Record<number, Chain> = {
@@ -78,13 +85,15 @@ export const mainnetChainsToTestnetChains: Record<number, Chain> = {
   [chains.bsc.id]: chains.bscTestnet,
   [chains.arbitrumNova.id]: chains.arbitrumSepolia,
   [chains.apeChain.id]: chains.sepolia,
+  [chains.etherlink.id]: chains.etherlinkTestnet,
 }
 
 // Helper to get chain info
 export function getChainInfo(
-  chainId: number,
+  chainId?: number,
   options?: { usePublicRpc?: boolean },
 ): Chain | null {
+  if (!chainId) return null
   const chainInfo =
     (Object.values(chains) as Array<Chain>).find(
       (chain: Chain) => chain.id === chainId,
@@ -155,13 +164,36 @@ function sortChains(chainList: Chain[]): Chain[] {
   })
 }
 
-export async function getSupportedChains(): Promise<Chain[]> {
-  const sequenceChains = await getSupportedSequenceChains()
+export async function getAllQuoteProviderChains(): Promise<Chain[]> {
   const relayChains = await getRelaySupportedChains()
+  const lifiChains = await getLifiSupportedChains()
+  const allChains = [...relayChains, ...lifiChains]
+  return allChains.filter(
+    (chain, index, self) => index === self.findIndex((c) => c.id === chain.id),
+  )
+}
+
+export async function getSupportedChains({
+  quoteProvider,
+}: {
+  quoteProvider?: QuoteProvider | string
+} = {}): Promise<Chain[]> {
+  let quoteProviderChains: Chain[] = []
+  if (quoteProvider === "relay") {
+    quoteProviderChains = await getRelaySupportedChains()
+  } else if (quoteProvider === "lifi") {
+    quoteProviderChains = await getLifiSupportedChains()
+  } else {
+    quoteProviderChains = await getAllQuoteProviderChains()
+  }
+
+  const sequenceChains = await getSupportedSequenceChains()
 
   // Find intersection of sequence chains and relay chains
   const supportedChains = sequenceChains.filter((sequenceChain) =>
-    relayChains.some((relayChain) => relayChain.id === sequenceChain.id),
+    quoteProviderChains.some(
+      (quoteProviderChain) => quoteProviderChain.id === sequenceChain.id,
+    ),
   )
 
   // Ensure unique chain IDs by filtering duplicates
@@ -169,17 +201,23 @@ export async function getSupportedChains(): Promise<Chain[]> {
     (chain, index, self) => index === self.findIndex((c) => c.id === chain.id),
   )
 
+  const sortedChains = sortChains(uniqueChains)
+
   // Sort chains by priority and then by name
-  return sortChains(uniqueChains)
+  return sortedChains
 }
 
-export function useSupportedChains(): {
+export function useSupportedChains({
+  quoteProvider,
+}: {
+  quoteProvider?: QuoteProvider | string
+} = {}): {
   supportedChains: Chain[]
   isLoadingChains: boolean
 } {
   const { data: supportedChains = [], isLoading: isLoadingChains } = useQuery({
     queryKey: ["supportedChains"],
-    queryFn: getSupportedChains,
+    queryFn: () => getSupportedChains({ quoteProvider }),
     staleTime: 60 * 60 * 1000, // 1 hour - chains rarely change
     gcTime: 24 * 60 * 60 * 1000, // 24 hours - keep in cache for a full day
     refetchOnWindowFocus: false, // Don't refetch when window regains focus

package/src/constants.ts

@@ -1,13 +1,16 @@
 import type { Context as ContextLike } from "@0xsequence/wallet-primitives"
 
 export const SEQUENCE_V3_CONTRACT_ADDRESSES: ContextLike.Context = {
-  factory: "0xBd0F8abD58B4449B39C57Ac9D5C67433239aC447" as `0x${string}`,
-  stage1: "0x53bA242E7C2501839DF2972c75075dc693176Cd0" as `0x${string}`,
-  stage2: "0xa29874c88b8Fd557e42219B04b0CeC693e1712f5" as `0x${string}`,
+  factory: "0x7aaaD48b90Ea2c1DaE03cb68ea1Ed8E1DD26dB38" as `0x${string}`,
+  stage1: "0x4d7c112790F03caFc7287b1a29Aa03da1Bb00C10" as `0x${string}`,
+  stage2: "0x7C96ff440BCE51EEF0C9f748D69246B4b3F28173" as `0x${string}`,
   creationCode:
-    "0x603e600e3d39601e805130553df33d3d34601c57363d3d373d363d30545af43d82803e903d91601c57fd5bf3" as `0x${string}`,
+    "0x6041600e3d396021805130553df33d3d36153402601f57363d3d373d363d30545af43d82803e903d91601f57fd5bf3" as `0x${string}`,
 }
 
+export const TRAILS_BALANCE_INJECTOR_ADDRESS =
+  "0x9eCA6CEf73799402a1afe4779f588f03034c5D0f"
+
 export const ATTESATION_SIGNER_ADDRESS =
   "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266"
 

package/src/decoders.ts

@@ -0,0 +1,310 @@
+import type { TransactionReceipt, Log } from "viem"
+import { decodeEventLog, parseAbiItem } from "viem"
+
+// Corrected ABI items
+const CALL_SUCCEEDED_ABI = parseAbiItem(
+  "event CallSucceeded(bytes32 _opHash, uint256 _index)",
+)
+
+const CALL_FAILED_ABI = parseAbiItem(
+  "event CallFailed(bytes32 _opHash, uint256 _index, bytes _returnData)",
+)
+
+const CALL_ABORTED_ABI = parseAbiItem(
+  "event CallAborted(bytes32 _opHash, uint256 _index, bytes _returnData)",
+)
+
+// only `deploymentId` is indexed
+const CALL_SKIPPED_ABI = parseAbiItem(
+  "event CallSkipped(bytes32 indexed deploymentId, uint256 actionIndex)",
+)
+
+// Refund / Sweep events come from the Trails Token Sweeper contract.
+// Contract source and event definitions:
+// - https://github.com/0xsequence/trails-contracts/pull/28
+// - https://github.com/0xsequence/stack/pull/1249
+const REFUND_ABI = parseAbiItem(
+  "event Refund(address indexed token, address indexed recipient, uint256 amount)",
+)
+
+const SWEEP_ABI = parseAbiItem(
+  "event Sweep(address indexed token, address indexed recipient, uint256 amount)",
+)
+
+// Event types
+export interface CallSucceededEvent {
+  type: "CallSucceeded"
+  opHash: string
+  index: bigint
+  log: Log
+}
+
+export interface CallFailedEvent {
+  type: "CallFailed"
+  opHash: string
+  index: bigint
+  returnData: string
+  log: Log
+}
+
+export interface CallAbortedEvent {
+  type: "CallAborted"
+  opHash: string
+  index: bigint
+  returnData: string
+  log: Log
+}
+
+export interface CallSkippedEvent {
+  type: "CallSkipped"
+  deploymentId: string
+  actionIndex: bigint
+  log: Log
+}
+
+export interface RefundEvent {
+  type: "Refund"
+  token: string
+  recipient: string
+  amount: bigint
+  log: Log
+}
+
+export interface SweepEvent {
+  type: "Sweep"
+  token: string
+  recipient: string
+  amount: bigint
+  log: Log
+}
+
+export type GuestModuleEvent =
+  | CallSucceededEvent
+  | CallFailedEvent
+  | CallAbortedEvent
+  | CallSkippedEvent
+
+// Trails Token Sweeper events: see PR references above for canonical specs.
+export type TrailsTokenSweeperEvent = RefundEvent | SweepEvent
+
+// === Decoders ===
+
+export function decodeCallSucceeded(log: Log): CallSucceededEvent | null {
+  try {
+    const decoded = decodeEventLog({
+      abi: [CALL_SUCCEEDED_ABI],
+      data: log.data,
+      topics: log.topics,
+      strict: false,
+    }) as {
+      eventName: "CallSucceeded"
+      args: { _opHash: string; _index: bigint }
+    }
+
+    return {
+      type: "CallSucceeded",
+      opHash: decoded.args._opHash,
+      index: decoded.args._index,
+      log,
+    }
+  } catch {
+    return null
+  }
+}
+
+export function decodeCallFailed(log: Log): CallFailedEvent | null {
+  try {
+    const decoded = decodeEventLog({
+      abi: [CALL_FAILED_ABI],
+      data: log.data,
+      topics: log.topics,
+      strict: false,
+    }) as {
+      eventName: "CallFailed"
+      args: { _opHash: string; _index: bigint; _returnData: string }
+    }
+
+    return {
+      type: "CallFailed",
+      opHash: decoded.args._opHash,
+      index: decoded.args._index,
+      returnData: decoded.args._returnData,
+      log,
+    }
+  } catch {
+    return null
+  }
+}
+
+export function decodeCallAborted(log: Log): CallAbortedEvent | null {
+  try {
+    const decoded = decodeEventLog({
+      abi: [CALL_ABORTED_ABI],
+      data: log.data,
+      topics: log.topics,
+      strict: false,
+    }) as {
+      eventName: "CallAborted"
+      args: { _opHash: string; _index: bigint; _returnData: string }
+    }
+
+    return {
+      type: "CallAborted",
+      opHash: decoded.args._opHash,
+      index: decoded.args._index,
+      returnData: decoded.args._returnData,
+      log,
+    }
+  } catch {
+    return null
+  }
+}
+
+export function decodeCallSkipped(log: Log): CallSkippedEvent | null {
+  try {
+    const decoded = decodeEventLog({
+      abi: [CALL_SKIPPED_ABI],
+      data: log.data,
+      topics: log.topics,
+      strict: false,
+    }) as {
+      eventName: "CallSkipped"
+      args: { deploymentId: string; actionIndex: bigint }
+    }
+
+    return {
+      type: "CallSkipped",
+      deploymentId: decoded.args.deploymentId,
+      actionIndex: decoded.args.actionIndex,
+      log,
+    }
+  } catch {
+    return null
+  }
+}
+
+export function decodeRefund(log: Log): RefundEvent | null {
+  try {
+    const decoded = decodeEventLog({
+      abi: [REFUND_ABI],
+      data: log.data,
+      topics: log.topics,
+      strict: false,
+    }) as {
+      eventName: "Refund"
+      args: { token: string; recipient: string; amount: bigint }
+    }
+
+    return {
+      type: "Refund",
+      token: decoded.args.token,
+      recipient: decoded.args.recipient,
+      amount: decoded.args.amount,
+      log,
+    }
+  } catch {
+    return null
+  }
+}
+
+export function decodeSweep(log: Log): SweepEvent | null {
+  try {
+    const decoded = decodeEventLog({
+      abi: [SWEEP_ABI],
+      data: log.data,
+      topics: log.topics,
+      strict: false,
+    }) as {
+      eventName: "Sweep"
+      args: { token: string; recipient: string; amount: bigint }
+    }
+
+    return {
+      type: "Sweep",
+      token: decoded.args.token,
+      recipient: decoded.args.recipient,
+      amount: decoded.args.amount,
+      log,
+    }
+  } catch {
+    return null
+  }
+}
+
+// === Main decoder ===
+
+export function decodeTrailsTokenSweeperEvents(
+  receipt: TransactionReceipt,
+): TrailsTokenSweeperEvent[] {
+  const events: TrailsTokenSweeperEvent[] = []
+
+  for (const log of receipt.logs) {
+    const refund = decodeRefund(log)
+    if (refund) {
+      events.push(refund)
+      continue
+    }
+
+    const sweep = decodeSweep(log)
+    if (sweep) {
+      events.push(sweep)
+    }
+  }
+
+  return events
+}
+
+export function decodeGuestModuleEvents(
+  receipt: TransactionReceipt,
+): GuestModuleEvent[] {
+  const events: GuestModuleEvent[] = []
+
+  for (const log of receipt.logs) {
+    const succeeded = decodeCallSucceeded(log)
+    if (succeeded) {
+      events.push(succeeded)
+      continue
+    }
+
+    const failed = decodeCallFailed(log)
+    if (failed) {
+      events.push(failed)
+      continue
+    }
+
+    const aborted = decodeCallAborted(log)
+    if (aborted) {
+      events.push(aborted)
+      continue
+    }
+
+    const skipped = decodeCallSkipped(log)
+    if (skipped) {
+      events.push(skipped)
+    }
+  }
+
+  return events
+}
+
+// === Utilities ===
+
+export function getEventsByType<T extends GuestModuleEvent["type"]>(
+  events: GuestModuleEvent[],
+  type: T,
+): Extract<GuestModuleEvent, { type: T }>[] {
+  return events.filter(
+    (event): event is Extract<GuestModuleEvent, { type: T }> =>
+      event.type === type,
+  )
+}
+
+export function getFirstEventByType<T extends GuestModuleEvent["type"]>(
+  events: GuestModuleEvent[],
+  type: T,
+): Extract<GuestModuleEvent, { type: T }> | undefined {
+  return events.find(
+    (event): event is Extract<GuestModuleEvent, { type: T }> =>
+      event.type === type,
+  )
+}

package/src/ens.ts

@@ -0,0 +1,32 @@
+import { mainnet } from "viem/chains"
+import { useEnsAddress, useEnsName } from "wagmi"
+
+export function useResolveEnsAddress({ textInput }: { textInput: string }) {
+  const { data: ensAddress, isLoading } = useEnsAddress({
+    name: textInput?.endsWith(".eth") ? textInput : undefined,
+    chainId: mainnet.id,
+    query: {
+      enabled: !!textInput && textInput.endsWith(".eth"),
+    },
+  })
+
+  return {
+    ensAddress,
+    isLoading,
+  }
+}
+
+export function useResolveEnsName({ address }: { address: string }) {
+  const { data: ensName, isLoading } = useEnsName({
+    address: address?.startsWith("0x") ? (address as `0x${string}`) : undefined,
+    chainId: mainnet.id,
+    query: {
+      enabled: !!address && address.startsWith("0x"),
+    },
+  })
+
+  return {
+    ensName,
+    isLoading,
+  }
+}

package/src/error.ts

@@ -3,7 +3,10 @@ export function getFullErrorMessage(err: any) {
 
   let current = err
   while (current) {
-    if (current.message) {
+    if (typeof current === "string") {
+      messages.push(current)
+    }
+    if (typeof current.message === "string") {
       messages.push(current.message)
     }
 
@@ -37,3 +40,100 @@ export class InsufficientBalanceError extends Error {
     this.name = "InsufficientBalanceError"
   }
 }
+
+export function getIsApiError(err: unknown) {
+  const isApiError = /request aborted|not deployed/gi.test(
+    getErrorString(err).toLowerCase(),
+  )
+  return isApiError
+}
+
+export function getIsRateLimitedError(err: unknown) {
+  const isRateLimited = /slow down|request rate|rate limit/gi.test(
+    getErrorString(err).toLowerCase(),
+  )
+  return isRateLimited
+}
+
+export function getIsRequiredAmountNotMetError(err: unknown) {
+  // Example error:
+  // GetIntentsQuote failed: total required amount (196159816026182793237) exceeds user-specified maximum (21960919303474978846)
+  const isRequiredAmountNotMet = /exceeds user-specified maximum/gi.test(
+    getErrorString(err).toLowerCase(),
+  )
+  return isRequiredAmountNotMet
+}
+
+export function getIsNoAvailableQuoteError(err: unknown) {
+  const isNoAvailableQuote =
+    /no available quotes|failed to get quote from any provider/gi.test(
+      getErrorString(err).toLowerCase(),
+    )
+  return isNoAvailableQuote
+}
+
+export function getIsQuoteFailedError(err: unknown) {
+  const isQuoteFailed = /GetIntentsQuote failed/gi.test(
+    getErrorString(err).toLowerCase(),
+  )
+  return isQuoteFailed
+}
+
+export function getIsQuoteTokenError(err: unknown) {
+  const isQuoteTokenError =
+    /requires destination token to be USDC|Token or chain not found/gi.test(
+      getErrorString(err).toLowerCase(),
+    )
+  return isQuoteTokenError
+}
+
+export function getIsQuoteInputError(err: unknown) {
+  const isQuoteInputError =
+    /Invalid input or output currency|originTokenAmount must be greater than zero|trails fee is greater than the origin token amount/gi.test(
+      getErrorString(err).toLowerCase(),
+    )
+  return isQuoteInputError
+}
+
+export function getIsInsufficientLiquidityError(err: unknown) {
+  const isInsufficientLiquidity =
+    /insufficient liquidity|higher than the available liquidity/gi.test(
+      getErrorString(err).toLowerCase(),
+    )
+  return isInsufficientLiquidity
+}
+
+export function getPrettifiedErrorMessage(
+  err: unknown,
+  defaultMessage: string = "",
+) {
+  const isRequiredAmountNotMet = getIsRequiredAmountNotMetError(err)
+  if (isRequiredAmountNotMet) {
+    return "The requested amount is too low to retrieve a quote or the account has insufficient funds to meet the required amount. Try again with a higher amount or make sure you have enough funds."
+  }
+  const isInsufficientLiquidity = getIsInsufficientLiquidityError(err)
+  if (isInsufficientLiquidity) {
+    return "The requested amount is too high to retrieve a quote. Try again with a lower amount."
+  }
+  const isNoAvailableQuote = getIsNoAvailableQuoteError(err)
+  if (isNoAvailableQuote) {
+    return "No quote found for the selected pair and/or amount. Try again with a different pair and/or amount."
+  }
+  const isQuoteTokenError = getIsQuoteTokenError(err)
+  if (isQuoteTokenError) {
+    return "The selected token is not supported. Please try again with a different token."
+  }
+  const isQuoteInputError = getIsQuoteInputError(err)
+  if (isQuoteInputError) {
+    return "No quote found for the input amount. Try again with a higher amount."
+  }
+  const isQuoteFailed = getIsQuoteFailedError(err)
+  if (isQuoteFailed) {
+    return "No quote found for the selected pair and amount."
+  }
+  const isApiError = getIsApiError(err)
+  if (isApiError) {
+    return "An API error occurred. Please try again later."
+  }
+  return defaultMessage
+}

package/src/intents.ts

@@ -6,12 +6,12 @@ import type {
   IntentCallsPayload,
   IntentPrecondition,
   SequenceAPIClient,
-} from "@0xsequence/api"
+} from "@0xsequence/trails-api"
 
 export type {
   IntentCallsPayload,
   IntentPrecondition,
-} from "@0xsequence/api"
+} from "@0xsequence/trails-api"
 
 import { Config, type Context, Payload } from "@0xsequence/wallet-primitives"
 import {
@@ -116,6 +116,7 @@ export type SendOriginCallTxArgs = {
 export async function getIntentCallsPayloads(
   apiClient: SequenceAPIClient,
   args: GetIntentCallsPayloadsArgs,
+  additionalTrackingProps: Record<string, string> = {},
 ): Promise<GetIntentCallsPayloadsReturn> {
   const localApiIntent = getQueryParam("localapiintent") === "true"
   if (localApiIntent) {
@@ -133,6 +134,7 @@ export async function getIntentCallsPayloads(
     originTokenAddress: args.originTokenAddress,
     destinationTokenAddress: args.destinationTokenAddress,
     userAddress: args.userAddress,
+    ...additionalTrackingProps,
   })
 
   try {
@@ -162,6 +164,7 @@ export async function getIntentCallsPayloads(
       feeToken: result.trailsFee?.feeToken,
       userAddress: args.userAddress,
       intentAddress: result.originIntentAddress,
+      ...additionalTrackingProps,
     })
 
     return result
@@ -174,6 +177,7 @@ export async function getIntentCallsPayloads(
       destinationChainId: args.destinationChainId || 0,
       originTokenAddress: args.originTokenAddress,
       destinationTokenAddress: args.destinationTokenAddress,
+      ...additionalTrackingProps,
     })
     throw error
   }
@@ -259,6 +263,7 @@ export async function commitIntentConfig(
   mainSignerAddress: string,
   calls: Array<IntentCallsPayload>,
   preconditions: Array<IntentPrecondition>,
+  additionalTrackingProps: Record<string, string> = {},
 ): Promise<CommitIntentConfigReturn> {
   console.log("[trails-sdk] commitIntentConfig inputs:", {
     mainSignerAddress,
@@ -323,6 +328,7 @@ export async function commitIntentConfig(
       destinationChainId: destinationChainIdStr
         ? Number(destinationChainIdStr)
         : undefined,
+      ...additionalTrackingProps,
     })
 
     const result = await apiClient.commitIntentConfig({
@@ -338,6 +344,7 @@ export async function commitIntentConfig(
       destinationChainId: destinationChainIdStr
         ? Number(destinationChainIdStr)
         : undefined,
+      ...additionalTrackingProps,
     })
 
     return result
@@ -351,6 +358,7 @@ export async function commitIntentConfig(
       destinationChainId: destinationChainIdStr
         ? Number(destinationChainIdStr)
         : undefined,
+      ...additionalTrackingProps,
     })
     throw error
   }