0xtrails 0.1.13 → 0.2.0

package/src/config.ts

@@ -6,10 +6,12 @@ import {
   PROD_SEQUENCE_PROJECT_ACCESS_KEY,
   DEV_SEQUENCE_INDEXER_URL,
   DEV_SEQUENCE_API_URL,
+  DEV_TRAILS_API_URL,
   DEV_SEQUENCE_PROJECT_ACCESS_KEY,
   DEFAULT_SEQUENCE_ENV,
   PROD_SEQUENCE_NODE_GATEWAY_URL,
   DEV_SEQUENCE_NODE_GATEWAY_URL,
+  PROD_TRAILS_API_URL,
 } from "./constants.js"
 import { getQueryParam } from "./queryParams.js"
 
@@ -20,6 +22,7 @@ export const globalConfig: {
   sequenceIndexerUrl: string
   sequenceNodeGatewayUrl: string
   sequenceApiUrl: string
+  trailsApiUrl: string
   sequenceEnv: SequenceEnv
   walletConnectProjectId: string
   slippageTolerance: string
@@ -27,11 +30,12 @@ export const globalConfig: {
   commitHash: string | undefined
 } = {
   commitHash: declareCommitHash(),
+  sequenceEnv: declareSequenceEnv(),
   sequenceProjectAccessKey: declareSequenceProjectAccessKey(),
   sequenceIndexerUrl: declareSequenceIndexerUrl(),
   sequenceNodeGatewayUrl: declareSequenceNodeGatewayUrl(),
   sequenceApiUrl: declareSequenceApiUrl(),
-  sequenceEnv: declareSequenceEnv(),
+  trailsApiUrl: declareTrailsApiUrl(),
   walletConnectProjectId: DEFAULT_WALLETCONNECT_PROJECT_ID,
   slippageTolerance: DEFAULT_SLIPPAGE_TOLERANCE,
   debug: false,
@@ -74,11 +78,21 @@ export function declareSequenceApiUrl() {
     return PROD_SEQUENCE_API_URL
   }
   if (declareSequenceEnv() === "local") {
-    return getEnvVar("TEST_API_URL") || DEV_SEQUENCE_API_URL
+    return getEnvVar("SEQUENCE_API_URL") || DEV_SEQUENCE_API_URL
   }
   return DEV_SEQUENCE_API_URL
 }
 
+export function declareTrailsApiUrl() {
+  if (declareSequenceEnv() === "prod") {
+    return PROD_TRAILS_API_URL
+  }
+  if (declareSequenceEnv() === "local") {
+    return getEnvVar("TRAILS_API_URL") || DEV_TRAILS_API_URL
+  }
+  return DEV_TRAILS_API_URL
+}
+
 export function declareSequenceNodeGatewayUrl() {
   if (declareSequenceEnv() === "prod") {
     return PROD_SEQUENCE_NODE_GATEWAY_URL
@@ -87,6 +101,11 @@ export function declareSequenceNodeGatewayUrl() {
 }
 
 export function declareSequenceProjectAccessKey() {
+  if (typeof process !== "undefined") {
+    if (getEnvVar("SEQUENCE_PROJECT_ACCESS_KEY")) {
+      return getEnvVar("SEQUENCE_PROJECT_ACCESS_KEY")
+    }
+  }
   if (declareSequenceEnv() === "prod") {
     return PROD_SEQUENCE_PROJECT_ACCESS_KEY
   }
@@ -105,6 +124,10 @@ export function declareCommitHash() {
   return cfPagesCommitHash || viteCommitHash
 }
 
+export function getSequenceConfig() {
+  return globalConfig
+}
+
 export function getSequenceProjectAccessKey() {
   return globalConfig.sequenceProjectAccessKey
 }
@@ -137,24 +160,37 @@ export function getSequenceApiUrl() {
   return globalConfig.sequenceApiUrl
 }
 
+export function setTrailsApiUrl(trailsApiUrl: string) {
+  globalConfig.trailsApiUrl = trailsApiUrl
+}
+
+export function getTrailsApiUrl() {
+  return globalConfig.trailsApiUrl
+}
+
 export function setSequenceEnv(sequenceEnv: SequenceEnv) {
   globalConfig.sequenceEnv = sequenceEnv
 
   if (sequenceEnv === "prod") {
     setSequenceIndexerUrl(PROD_SEQUENCE_INDEXER_URL)
     setSequenceApiUrl(PROD_SEQUENCE_API_URL)
+    setTrailsApiUrl(PROD_TRAILS_API_URL)
     setSequenceNodeGatewayUrl(PROD_SEQUENCE_NODE_GATEWAY_URL)
   }
 
   if (sequenceEnv === "local") {
-    if (getEnvVar("API_URL")) {
-      setSequenceApiUrl(getEnvVar("API_URL"))
+    if (getEnvVar("SEQUENCE_API_URL")) {
+      setSequenceApiUrl(getEnvVar("SEQUENCE_API_URL"))
+    }
+    if (getEnvVar("TRAILS_API_URL")) {
+      setTrailsApiUrl(getEnvVar("TRAILS_API_URL"))
     }
   }
 
   if (sequenceEnv === "dev") {
     setSequenceIndexerUrl(DEV_SEQUENCE_INDEXER_URL)
     setSequenceApiUrl(DEV_SEQUENCE_API_URL)
+    setTrailsApiUrl(DEV_TRAILS_API_URL)
     setSequenceNodeGatewayUrl(DEV_SEQUENCE_NODE_GATEWAY_URL)
   }
 }
@@ -208,13 +244,8 @@ export function getAccountIntentTransactionHistory() {
   return FeatureFlags.accountIntentTransactionHistory
 }
 
-export function getSameChainSwapDifferentIntentAddresses() {
-  return FeatureFlags.sameChainSwapDifferentIntentAddresses
-}
-
 export const FeatureFlags = {
   accountIntentTransactionHistory: false,
-  sameChainSwapDifferentIntentAddresses: false,
 }
 
 export function getEnvVar(name: string) {

package/src/constants.ts

@@ -1,3 +1,4 @@
+import type { AddressOverrides } from "@0xsequence/trails-api"
 import type { Context as ContextLike } from "@0xsequence/wallet-primitives"
 
 export const SEQUENCE_V3_CONTRACT_ADDRESSES: ContextLike.Context = {
@@ -8,27 +9,29 @@ export const SEQUENCE_V3_CONTRACT_ADDRESSES: ContextLike.Context = {
     "0x6041600e3d396021805130553df33d3d36153402601f57363d3d373d363d30545af43d82803e903d91601f57fd5bf3" as `0x${string}`,
 }
 
+export const SEQUENCE_V3_CONTRACT_ADDRESSES_OVERRIDES: AddressOverrides = {
+  sequenceWalletFactoryAddress: SEQUENCE_V3_CONTRACT_ADDRESSES.factory,
+  sequenceWalletMainModuleAddress: SEQUENCE_V3_CONTRACT_ADDRESSES.stage1,
+  sequenceWalletMainModuleUpgradableAddress:
+    SEQUENCE_V3_CONTRACT_ADDRESSES.stage2,
+}
+
 export const TRAILS_BALANCE_INJECTOR_ADDRESS =
-  "0x9eCA6CEf73799402a1afe4779f588f03034c5D0f"
+  "0xAca1813C717954c6Dc4Cbf69192b3Ef5781149C0"
 
 export const ATTESATION_SIGNER_ADDRESS =
   "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266"
 
-export const TRAILS_LIFI_SAPIENT_SIGNER_ADDRESS =
-  "0xd7571bd1e3af468c3a49966c9a92a2e907cdfa52"
-export const TRAILS_RELAY_SAPIENT_SIGNER_ADDRESS =
-  "0x9a013e7d186611af36a918ef23d81886e8c256f8"
-export const TRAILS_CCTP_SAPIENT_SIGNER_ADDRESS =
-  "0xc1A9B197eBb31Fc2B613C59dAC3f3E5698A429D0"
-
 export const DEFAULT_SEQUENCE_ENV = "prod"
 
 export const PROD_SEQUENCE_NODE_GATEWAY_URL = "https://nodes.sequence.app"
 export const PROD_SEQUENCE_INDEXER_URL = "https://indexer.sequence.app"
 export const PROD_SEQUENCE_API_URL = "https://api.sequence.app"
+export const PROD_TRAILS_API_URL = "https://trails-api.sequence.app"
 export const DEV_SEQUENCE_NODE_GATEWAY_URL = "https://dev-nodes.sequence.app"
 export const DEV_SEQUENCE_INDEXER_URL = "https://dev-indexer.sequence.app"
 export const DEV_SEQUENCE_API_URL = "https://dev-api.sequence.app"
+export const DEV_TRAILS_API_URL = "https://dev-trails-api.sequence-dev.app"
 
 export const intentEntrypoints: Record<number, `0x${string}`> = {
   8453: "0x2bf4c63199eD7D8A737E8DB2cC19E0C0103F6bE3",

package/src/contractUtils.ts

@@ -1,5 +1,6 @@
 import { createPublicClient, http } from "viem"
 import { getChainInfo } from "./chains.js"
+import { logger } from "./logger.js"
 
 export async function getIsContract(address: `0x${string}`, chainId: number) {
   const client = createPublicClient({
@@ -8,9 +9,39 @@ export async function getIsContract(address: `0x${string}`, chainId: number) {
   })
 
   const code = await client.getCode({ address })
-  return code !== "0x"
+  const isNonZero = isNonZeroHexString(code)
+  const is7702 = is7702ContractCode(code)
+  const isContract = isNonZero && !is7702
+
+  logger.console.log(
+    "[trails-sdk] code:",
+    code?.slice(0, 10),
+    "address:",
+    address,
+    "chainId:",
+    chainId,
+    "isContract:",
+    isContract,
+  )
+
+  return isContract
+}
+
+export function is7702ContractCode(hex: string | undefined): boolean {
+  return hex?.startsWith("0xef0100") || false
+}
+
+export function isNonZeroHexString(hex: string | undefined): boolean {
+  return (
+    hex !== undefined &&
+    hex !== "" &&
+    hex !== "0" &&
+    hex !== "0x" &&
+    hex !== "0x0" &&
+    hex !== "0x00"
+  )
 }
 
 export function getIsCustomCalldata(calldata: string | undefined): boolean {
-  return calldata !== undefined && calldata !== "" && calldata !== "0x"
+  return isNonZeroHexString(calldata)
 }

package/src/customChains.ts

@@ -0,0 +1,24 @@
+// Custom chain definition for Somnia
+export const somnia = {
+  id: 5031,
+  name: "Somnia",
+  nativeCurrency: {
+    decimals: 18,
+    name: "SOMI",
+    symbol: "SOMI",
+  },
+  rpcUrls: {
+    default: {
+      http: ["https://api.infra.mainnet.somnia.network"],
+    },
+    public: {
+      http: ["https://api.infra.mainnet.somnia.network"],
+    },
+  },
+  blockExplorers: {
+    default: {
+      name: "Somnia Explorer",
+      url: "https://explorer.somnia.network/",
+    },
+  },
+} as const

package/src/index.ts

@@ -4,6 +4,8 @@ export { getAPIClient, useAPIClient } from "./apiClient.js"
 export {
   getSupportedChains,
   useSupportedChains,
+  getChainInfo,
+  getAllChains,
 } from "./chains.js"
 export {
   getIndexerGatewayClient,
@@ -71,11 +73,12 @@ export {
   useSupportedTokens,
   useTokenList,
 } from "./tokens.js"
+export type { SupportedToken } from "./tokens.js"
 export { getTxTimeDiff } from "./transactions.js"
 export { useTrails } from "./trails.js"
 export type { WagmiAccount } from "./trails.js"
 export type { Mode } from "./mode.js"
-export { TRAILS_CONTRACT_PLACEHOLDER_AMOUNT } from "./proxyCaller.js"
+export { TRAILS_CONTRACT_PLACEHOLDER_AMOUNT } from "./balanceInjector.js"
 export { getERC20TransferData } from "./encoders.js"
 export { getRelayer, useRelayers } from "./relayer.js"
 export { relayerSendMetaTx, getMetaTxnReceipt } from "./metaTxns.js"
@@ -83,10 +86,12 @@ export {
   declareSequenceEnv,
   getSequenceProjectAccessKey,
   getSequenceApiUrl,
+  getTrailsApiUrl,
   getSequenceIndexerUrl,
   getSequenceEnv,
   setSequenceProjectAccessKey,
   setSequenceApiUrl,
+  setTrailsApiUrl,
   setSequenceIndexerUrl,
   setSequenceNodeGatewayUrl,
   getSequenceNodeGatewayUrl,
@@ -100,3 +105,8 @@ export {
 } from "./config.js"
 export * from "./widget/index.js"
 export { logger, getMinLogLevel } from "./logger.js"
+export {
+  getTrailsClient,
+  useTrailsClient,
+  TrailsClient,
+} from "./trailsClient.js"

package/src/intentEntrypoint.ts

@@ -0,0 +1,253 @@
+import type { Account, WalletClient, Hex, Address } from "viem"
+import { intentEntrypoints } from "./constants.js"
+import type { TrailsAPIClient } from "@0xsequence/trails-api"
+import { signIntent } from "./gasless.js"
+
+// Intent Entrypoint ABI (partial - only the functions we need)
+// TODO: Uncomment and use when implementing calldata injection
+/* const INTENT_ENTRYPOINT_ABI = [
+  {
+    name: "depositToIntent",
+    type: "function",
+    stateMutability: "nonpayable",
+    inputs: [
+      { name: "user", type: "address" },
+      { name: "token", type: "address" },
+      { name: "amount", type: "uint256" },
+      { name: "intentAddress", type: "address" },
+      { name: "deadline", type: "uint256" },
+      { name: "sigV", type: "uint8" },
+      { name: "sigR", type: "bytes32" },
+      { name: "sigS", type: "bytes32" },
+    ],
+    outputs: [],
+  },
+  {
+    name: "depositToIntentWithPermit",
+    type: "function",
+    stateMutability: "nonpayable",
+    inputs: [
+      { name: "user", type: "address" },
+      { name: "token", type: "address" },
+      { name: "amount", type: "uint256" },
+      { name: "permitAmount", type: "uint256" },
+      { name: "intentAddress", type: "address" },
+      { name: "deadline", type: "uint256" },
+      { name: "permitV", type: "uint8" },
+      { name: "permitR", type: "bytes32" },
+      { name: "permitS", type: "bytes32" },
+      { name: "sigV", type: "uint8" },
+      { name: "sigR", type: "bytes32" },
+      { name: "sigS", type: "bytes32" },
+    ],
+    outputs: [],
+  },
+] as const */
+
+// Note: EIP-712 typed data signing has been replaced with raw message signing
+// The backend generates the EIP-712 hash and the client signs it as a raw message
+// This simplifies the flow and avoids wallet compatibility issues
+
+export type IntentEntrypointDepositParams = {
+  userAddress: Address
+  tokenAddress: Address
+  amount: bigint | string
+  intentAddress: Address
+  chainId: number
+  deadline?: number // Unix timestamp, defaults to 1 hour from now
+  usePermit?: boolean
+  permitDeadline?: number
+}
+
+export type IntentEntrypointDepositResult = {
+  depositWalletAddress: Address
+  metaTxn: {
+    id: string
+    chainId: string
+    contract: string
+    input: string
+    walletAddress: string
+  }
+  feeQuote: string
+  entrypointAddress: Address
+}
+
+export type GaslessDepositOptions = {
+  trailsClient: TrailsAPIClient
+  walletClient: WalletClient
+  account: Account
+  tokenAddress: Address
+  amount: bigint | string
+  intentAddress: Address
+  chainId: number
+  deadline?: number
+  usePermit?: boolean
+  onStatusUpdate?: (status: DepositStatus) => void
+}
+
+export enum DepositStatus {
+  PREPARING = "preparing",
+  SIGNING = "signing",
+  SUBMITTING = "submitting",
+  PENDING = "pending",
+  CONFIRMED = "confirmed",
+  FAILED = "failed",
+}
+
+/**
+ * Execute a gasless deposit to an Intent Entrypoint
+ * This function handles the entire flow using the sign-first approach:
+ * 1. Gets message hash from API
+ * 2. User signs the message hash
+ * 3. Calls API with signature to get meta transaction
+ * 4. Submits meta transaction via relayer
+ */
+export async function executeGaslessDeposit({
+  trailsClient,
+  walletClient,
+  account,
+  tokenAddress,
+  amount,
+  intentAddress,
+  chainId,
+  deadline,
+  usePermit = false,
+  onStatusUpdate,
+}: GaslessDepositOptions): Promise<{
+  txHash: string | null
+  receipt: unknown
+  depositWalletAddress: Address
+}> {
+  try {
+    // Update status
+    onStatusUpdate?.(DepositStatus.PREPARING)
+
+    // Default deadline to 1 hour from now
+    const effectiveDeadline = deadline || Math.floor(Date.now() / 1000) + 3600
+
+    // Convert amount to string if it's bigint
+    const amountStr = typeof amount === "bigint" ? amount.toString() : amount
+
+    // 1. Get the entrypoint address for this chain
+    const entrypointAddress = getIntentEntrypointAddress(chainId)
+    if (!entrypointAddress) {
+      throw new Error(`Intent Entrypoint not deployed on chain ${chainId}`)
+    }
+
+    // 2. User signs using EIP-712 typed data
+    onStatusUpdate?.(DepositStatus.SIGNING)
+    const { signature: intentSignature } = await signIntent({
+      client: walletClient,
+      intentParams: {
+        user: account.address,
+        token: tokenAddress,
+        amount: BigInt(amountStr),
+        intentAddress,
+        deadline: BigInt(effectiveDeadline),
+        chainId,
+        contractAddress: entrypointAddress,
+      },
+    })
+
+    // 3. Call the deposit endpoint with the signature
+    onStatusUpdate?.(DepositStatus.SUBMITTING)
+    const depositDataResponse = await trailsClient.getIntentEntrypointDeposit({
+      params: {
+        userAddress: account.address,
+        tokenAddress,
+        amount: amountStr,
+        intentAddress,
+        chainID: chainId,
+        deadline: effectiveDeadline,
+        intentSignature,
+        usePermit,
+        // TODO: Support permit signature
+        // permitSignature: permitSig,
+        // permitDeadline: usePermit ? effectiveDeadline : undefined,
+      },
+    })
+
+    const depositData = depositDataResponse.result
+
+    // 4. Submit meta transaction via relayer
+    // TODO: Implement relayer submission
+    // This would typically be done through the Sequence relayer
+    // const receipt = await relayer.sendMetaTxn({
+    //   ...depositData.metaTxn,
+    //   feeQuote: depositData.feeQuote,
+    // })
+
+    // For now, just return the deposit data
+    console.log("Deposit data ready:", depositData)
+
+    onStatusUpdate?.(DepositStatus.CONFIRMED)
+
+    return {
+      txHash: null, // Would come from relayer response
+      receipt: null, // Would come from relayer response
+      depositWalletAddress: depositData.depositWalletAddress as Address,
+    }
+  } catch (error) {
+    onStatusUpdate?.(DepositStatus.FAILED)
+    throw error
+  }
+}
+
+/**
+ * Inject signatures into the meta transaction calldata
+ * This updates the placeholder signature values in the Intent Entrypoint call
+ *
+ * TODO: Implement this function to properly update nested calldata
+ * This would require:
+ * 1. Decode the guest module execdata
+ * 2. Find the Intent Entrypoint call
+ * 3. Replace its calldata with properly signed version
+ * 4. Re-encode the guest module execdata
+ *
+ * For reference, the signed calldata can be generated using:
+ * ```typescript
+ * const { v, r, s } = splitSignature(signatures.intent)
+ * const depositCalldata = encodeFunctionData({
+ *   abi: INTENT_ENTRYPOINT_ABI,
+ *   functionName: "depositToIntent",
+ *   args: [userAddress, tokenAddress, amount, intentAddress, deadline, v, r, s],
+ * })
+ * ```
+ */
+
+/**
+ * Split a signature into v, r, s components
+ * TODO: Use this when implementing calldata injection
+ */
+export function splitSignature(signature: Hex): {
+  v: number
+  r: Hex
+  s: Hex
+} {
+  // Remove 0x prefix if present
+  const sig = signature.startsWith("0x") ? signature.slice(2) : signature
+
+  if (sig.length !== 130) {
+    throw new Error(`Invalid signature length: ${sig.length}`)
+  }
+
+  const r = `0x${sig.slice(0, 64)}` as Hex
+  const s = `0x${sig.slice(64, 128)}` as Hex
+  const v = parseInt(sig.slice(128, 130), 16)
+
+  return { v, r, s }
+}
+
+/**
+ * Get the Intent Entrypoint address for a given chain
+ */
+export function getIntentEntrypointAddress(chainId: number): Address | null {
+  return (intentEntrypoints[chainId] as Address) || null
+}
+
+/**
+ * Check if Intent Entrypoint is deployed on a chain
+ */
+export function isIntentEntrypointSupported(chainId: number): boolean {
+  return chainId in intentEntrypoints
+}