0xtrails 0.13.2 → 0.14.0

package/src/gasless.ts

@@ -1,638 +0,0 @@
-import type {
-  Account,
-  Address,
-  Chain,
-  Hex,
-  PublicClient,
-  WalletClient,
-} from "viem"
-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"
-
-import { addressEqual } from "./utils/address.js"
-const intentEntrypointDomainName = "TrailsIntentEntrypoint"
-
-export function splitSignature(signature: `0x${string}`): {
-  r: `0x${string}`
-  s: `0x${string}`
-  v: number
-} {
-  const sig = signature.slice(2)
-  const r = `0x${sig.slice(0, 64)}` as `0x${string}`
-  const s = `0x${sig.slice(64, 128)}` as `0x${string}`
-  const v = parseInt(sig.slice(128, 130), 16)
-  return { r, s, v }
-}
-
-export type PermitCalldataParams = {
-  signer: `0x${string}`
-  spender: `0x${string}`
-  amount: bigint
-  deadline: bigint
-  signature: `0x${string}`
-}
-
-export function getPermitCalldata({
-  signer,
-  spender,
-  amount,
-  deadline,
-  signature,
-}: PermitCalldataParams): Hex {
-  const { r, s, v } = splitSignature(signature)
-
-  // Encode permit call
-  const permitCalldata = encodeFunctionData({
-    abi: [PERMIT_ABI],
-    functionName: "permit",
-    args: [signer, spender, amount, deadline, v, r, s],
-  })
-
-  return permitCalldata
-}
-
-export type TransferFromCalldataParams = {
-  signer: `0x${string}`
-  spender: `0x${string}`
-  amount: bigint
-}
-
-export function getTransferFromCalldata({
-  signer,
-  spender,
-  amount,
-}: TransferFromCalldataParams): Hex {
-  // Encode transferFrom call
-  const transferFromCalldata = encodeFunctionData({
-    abi: [TRANSFER_FROM_ABI],
-    functionName: "transferFrom",
-    args: [signer, spender, amount],
-  })
-
-  return transferFromCalldata
-}
-
-export type TransferCalldataParams = {
-  recipient: `0x${string}`
-  amount: bigint
-}
-
-export function getTransferCalldata({
-  recipient,
-  amount,
-}: TransferCalldataParams): Hex {
-  // Encode transfer call to recipient
-  const transferCalldata = encodeFunctionData({
-    abi: [TRANSFER_ABI],
-    functionName: "transfer",
-    args: [recipient, amount],
-  })
-
-  return transferCalldata
-}
-
-export type GetPermitSignatureParams = {
-  walletClient: WalletClient
-  signer: `0x${string}`
-  spender: `0x${string}`
-  tokenAddress: `0x${string}`
-  amount: bigint
-  chain: Chain
-  deadline?: bigint
-}
-
-export async function getPermitSignature({
-  walletClient,
-  signer,
-  spender,
-  tokenAddress,
-  amount,
-  chain,
-  deadline = BigInt(toSeconds(now()) + HOUR_S), // 1 hour from now
-}: GetPermitSignatureParams): Promise<{
-  signature: `0x${string}`
-  deadline: bigint
-  v: number
-  r: `0x${string}`
-  s: `0x${string}`
-}> {
-  if (!walletClient.account) {
-    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(
-      `Connected wallet (${walletClient.account.address}) does not match token owner (${signer}). ` +
-        `Please connect the wallet that owns the tokens.`,
-    )
-  }
-
-  // Get permit signature from connected account
-  const nonce = await publicClient.readContract({
-    address: tokenAddress as `0x${string}`,
-    abi: [
-      {
-        name: "nonces",
-        type: "function",
-        stateMutability: "view",
-        inputs: [{ name: "owner", type: "address" }],
-        outputs: [{ name: "", type: "uint256" }],
-      },
-    ],
-    functionName: "nonces",
-    args: [signer],
-  })
-
-  // Fetch EIP-5267 eip712Domain() first - this returns the exact domain parameters used by the contract
-  let name: string
-  let version: string
-
-  try {
-    const eip712Domain = (await publicClient.readContract({
-      address: tokenAddress as `0x${string}`,
-      abi: [
-        {
-          name: "eip712Domain",
-          type: "function",
-          stateMutability: "view",
-          inputs: [],
-          outputs: [
-            { name: "fields", type: "bytes1" },
-            { name: "name", type: "string" },
-            { name: "version", type: "string" },
-            { name: "chainId", type: "uint256" },
-            { name: "verifyingContract", type: "address" },
-            { name: "salt", type: "bytes32" },
-            { name: "extensions", type: "uint256[]" },
-          ],
-        },
-      ],
-      functionName: "eip712Domain",
-    })) as [string, string, string, bigint, string, string, bigint[]]
-
-    name = eip712Domain[1]
-    version = eip712Domain[2]
-    logger.console.log(
-      "[trails-sdk] EIP-5267 eip712Domain() supported, using domain:",
-      { name, version },
-    )
-  } catch {
-    // EIP-5267 not supported, fall back to reading name() and version()
-    logger.console.log(
-      "[trails-sdk] EIP-5267 not supported, falling back to name()/version()",
-    )
-
-    name = (await publicClient.readContract({
-      address: tokenAddress as `0x${string}`,
-      abi: [
-        {
-          name: "name",
-          type: "function",
-          stateMutability: "view",
-          inputs: [],
-          outputs: [{ name: "", type: "string" }],
-        },
-      ],
-      functionName: "name",
-    })) as string
-
-    version = "1" // fallback default EIP-712 version
-    try {
-      version = (await publicClient.readContract({
-        address: tokenAddress as `0x${string}`,
-        abi: [
-          {
-            name: "version",
-            type: "function",
-            stateMutability: "view",
-            inputs: [],
-            outputs: [{ name: "", type: "string" }],
-          },
-        ],
-        functionName: "version",
-      })) as string
-      logger.console.log("[trails-sdk] Token version from contract:", version)
-    } catch (error) {
-      logger.console.warn(
-        "[trails-sdk] Token does not implement version(), defaulting to '1'",
-        error,
-      )
-    }
-  }
-
-  // Log domain parameters for debugging
-  logger.console.log("[trails-sdk] Permit domain parameters:", {
-    name,
-    version,
-    chainId: chain.id,
-    verifyingContract: tokenAddress,
-    signer,
-    spender,
-    amount: amount.toString(),
-    nonce: nonce.toString(),
-    deadline: deadline.toString(),
-  })
-
-  // Try to read the domain separator from the contract for comparison
-  let contractDomainSeparator: string | null = null
-  try {
-    contractDomainSeparator = (await publicClient.readContract({
-      address: tokenAddress as `0x${string}`,
-      abi: [
-        {
-          name: "DOMAIN_SEPARATOR",
-          type: "function",
-          stateMutability: "view",
-          inputs: [],
-          outputs: [{ name: "", type: "bytes32" }],
-        },
-      ],
-      functionName: "DOMAIN_SEPARATOR",
-    })) as string
-    logger.console.log(
-      "[trails-sdk] Contract domain separator:",
-      contractDomainSeparator,
-    )
-  } catch (error) {
-    logger.console.warn(
-      "[trails-sdk] Could not read DOMAIN_SEPARATOR from contract:",
-      error,
-    )
-  }
-
-  // Special handling for Katana chain ID
-  const chainId = chain.id
-
-  const domain = {
-    name,
-    version,
-    chainId,
-    verifyingContract: tokenAddress as `0x${string}`,
-  }
-
-  const types = {
-    Permit: [
-      { name: "owner", type: "address" },
-      { name: "spender", type: "address" },
-      { name: "value", type: "uint256" },
-      { name: "nonce", type: "uint256" },
-      { name: "deadline", type: "uint256" },
-    ],
-  }
-
-  // Create permit data
-  const permitData = {
-    owner: signer,
-    spender: spender,
-    value: amount,
-    nonce: nonce,
-    deadline: deadline,
-  }
-
-  await attemptSwitchChain({
-    walletClient,
-    desiredChainId: chain.id,
-  })
-
-  logger.console.log("[trails-sdk] Requesting permit signature...")
-  logger.console.log("[trails-sdk] Permit data:", permitData)
-
-  // Check provider health before attempting signature
-  await checkProviderHealth(walletClient)
-
-  // Wrap the signature request with a timeout to prevent hanging
-  const signature = await signWithTimeout(
-    walletClient.signTypedData({
-      account: walletClient.account,
-      domain,
-      types,
-      primaryType: "Permit",
-      message: permitData,
-    }),
-    "Permit signature",
-  )
-
-  logger.console.log("[trails-sdk] Permit signature created:", signature)
-
-  const { v, r, s } = splitSignature(signature)
-
-  return { signature, deadline, v, r, s }
-}
-
-export type GetNeedsIntentEntrypointApprovalParams = {
-  client: PublicClient
-  token: Address
-  account: Address
-  entrypoint: Address
-  amount: bigint
-}
-
-// @deprecated - v1 only
-export async function getNeedsIntentEntrypointApproval({
-  client,
-  token,
-  account,
-  entrypoint,
-  amount,
-}: GetNeedsIntentEntrypointApprovalParams): Promise<boolean> {
-  const allowance = await client.readContract({
-    address: token,
-    abi: erc20Abi,
-    functionName: "allowance",
-    args: [getAddress(account), getAddress(entrypoint)],
-  })
-
-  return allowance < amount
-}
-
-export type GetUserNonceParams = {
-  publicClient: PublicClient
-  userAddress: `0x${string}`
-  intentEntrypoint: `0x${string}`
-}
-
-// @deprecated - v1 only
-export async function getUserNonce({
-  publicClient,
-  userAddress,
-  intentEntrypoint,
-}: GetUserNonceParams): Promise<bigint> {
-  const nonce = await publicClient.readContract({
-    address: intentEntrypoint as `0x${string}`,
-    abi: [
-      {
-        name: "nonces",
-        type: "function",
-        stateMutability: "view",
-        inputs: [{ name: "user", type: "address" }],
-        outputs: [{ name: "", type: "uint256" }],
-      },
-    ],
-    functionName: "nonces",
-    args: [userAddress],
-  })
-
-  return nonce as bigint
-}
-
-// @deprecated - v1 only
-export type GetDepositToIntentWithPermitCalldataParams = {
-  user: `0x${string}`
-  token: `0x${string}`
-  amount: bigint
-  intentAddress: `0x${string}`
-  deadline: bigint
-  nonce: bigint
-  feeToken: `0x${string}`
-  feeAmount: bigint
-  feeCollector: `0x${string}`
-  permitAmount: bigint
-  // permit signature
-  v: number
-  r: `0x${string}`
-  s: `0x${string}`
-  // intent signature
-  sigV: number
-  sigR: `0x${string}`
-  sigS: `0x${string}`
-}
-
-export function getDepositToIntentWithPermitCalldata({
-  user,
-  token,
-  amount,
-  intentAddress,
-  deadline,
-  nonce,
-  feeToken,
-  feeAmount,
-  feeCollector,
-  permitAmount,
-  v,
-  r,
-  s,
-  sigV,
-  sigR,
-  sigS,
-}: GetDepositToIntentWithPermitCalldataParams): Hex {
-  const abi = parseAbi([
-    "function depositToIntentWithPermit(address user, address token, uint256 amount, uint256 permitAmount, address intentAddress, uint256 deadline, uint256 nonce, address feeToken, uint256 feeAmount, address feeCollector, uint8 v, bytes32 r, bytes32 s, uint8 sigV, bytes32 sigR, bytes32 sigS)",
-  ])
-
-  return encodeFunctionData({
-    abi,
-    functionName: "depositToIntentWithPermit",
-    args: [
-      user,
-      token,
-      amount,
-      permitAmount,
-      intentAddress,
-      deadline,
-      nonce,
-      feeToken,
-      feeAmount,
-      feeCollector,
-      v,
-      r,
-      s,
-      sigV,
-      sigR,
-      sigS,
-    ],
-  })
-}
-
-export type GetDepositToIntentWithoutPermitCalldataParams = {
-  user: `0x${string}`
-  token: `0x${string}`
-  amount: bigint
-  intentAddress: `0x${string}`
-  deadline: bigint
-  nonce: bigint
-  feeToken: `0x${string}`
-  feeAmount: bigint
-  feeCollector: `0x${string}`
-  sigV: number
-  sigR: `0x${string}`
-  sigS: `0x${string}`
-}
-
-// @deprecated - v1 only
-export function getDepositToIntentWithoutPermitCalldata({
-  user,
-  token,
-  amount,
-  intentAddress,
-  deadline,
-  nonce,
-  feeToken,
-  feeAmount,
-  feeCollector,
-  sigV,
-  sigR,
-  sigS,
-}: GetDepositToIntentWithoutPermitCalldataParams): Hex {
-  const abi = parseAbi([
-    "function depositToIntent(address user, address token, uint256 amount, address intentAddress, uint256 deadline, uint256 nonce, address feeToken, uint256 feeAmount, address feeCollector, uint8 sigV, bytes32 sigR, bytes32 sigS)",
-  ])
-
-  return encodeFunctionData({
-    abi,
-    functionName: "depositToIntent",
-    args: [
-      user,
-      token,
-      amount,
-      intentAddress,
-      deadline,
-      nonce,
-      feeToken,
-      feeAmount,
-      feeCollector,
-      sigV,
-      sigR,
-      sigS,
-    ],
-  })
-}
-
-export type IntentParams = {
-  user: `0x${string}`
-  token: `0x${string}`
-  amount: bigint
-  intentAddress: `0x${string}`
-  deadline: bigint
-  chainId: number
-  contractAddress: `0x${string}`
-  nonce: bigint
-  feeAmount: bigint
-  feeCollector: `0x${string}`
-}
-
-export type SignIntentParams = {
-  client: WalletClient
-  intentParams: IntentParams
-}
-
-// @deprecated - v1 only
-export async function signIntent({
-  client,
-  intentParams,
-}: SignIntentParams): Promise<{
-  signature: `0x${string}`
-  v: number
-  r: `0x${string}`
-  s: `0x${string}`
-}> {
-  const {
-    user,
-    token,
-    amount,
-    intentAddress,
-    deadline,
-    chainId,
-    contractAddress,
-  } = intentParams
-
-  // Validate that the connected wallet matches the user
-  if (!client.account) {
-    throw new Error("No account found")
-  }
-
-  if (!addressEqual(client.account.address, user)) {
-    throw new Error(
-      `Connected wallet (${client.account.address}) does not match intent user (${user}). ` +
-        `Please connect the wallet that owns the tokens.`,
-    )
-  }
-
-  const domain = {
-    name: intentEntrypointDomainName,
-    version: "1",
-    chainId,
-    verifyingContract: contractAddress, // ✅ This fixes the signature mismatch
-  }
-
-  const types = {
-    TrailsIntent: [
-      { name: "user", type: "address" },
-      { name: "token", type: "address" },
-      { name: "amount", type: "uint256" },
-      { name: "intentAddress", type: "address" },
-      { name: "deadline", type: "uint256" },
-      { name: "chainId", type: "uint256" },
-      { name: "nonce", type: "uint256" },
-      { name: "feeAmount", type: "uint256" },
-      { name: "feeCollector", type: "address" },
-    ],
-  }
-
-  const message = {
-    user: getAddress(user),
-    token: getAddress(token),
-    amount: BigInt(amount),
-    intentAddress: getAddress(intentAddress),
-    deadline: BigInt(deadline),
-    chainId: BigInt(chainId),
-    nonce: BigInt(intentParams.nonce),
-    feeAmount: BigInt(intentParams.feeAmount),
-    feeCollector: getAddress(intentParams.feeCollector),
-  }
-
-  const signature = await client.signTypedData({
-    account: client.account as Account,
-    domain,
-    types,
-    primaryType: "TrailsIntent",
-    message,
-  })
-
-  const { v, r, s } = splitSignature(signature)
-
-  return { signature, v, r, s }
-}
-
-/**
- * Calculates the byte length of a hex signature string.
- * @param signature - The signature (hex string with or without 0x prefix)
- * @returns The number of bytes in the signature
- */
-function getSignatureBytes(signature: string): number {
-  return signature.startsWith("0x")
-    ? (signature.length - 2) / 2
-    : signature.length / 2
-}
-
-/**
- * Validates that a signature is exactly 65 bytes and throws an appropriate error if invalid.
- * @param signature - The signature to validate (hex string with or without 0x prefix)
- * @throws Error if signature is not 65 bytes
- */
-export function validateGaslessSignature(signature: string): void {
-  const signatureBytes = getSignatureBytes(signature)
-
-  if (signatureBytes !== 65) {
-    if (signatureBytes > 65) {
-      throw new Error(
-        "Smart contract wallets are not supported for gasless transfers at the moment. " +
-          "Please use an EOA (Externally Owned Account) wallet for gasless transactions.",
-      )
-    } else {
-      throw new Error(
-        `Invalid signature length: expected 65 bytes, got ${signatureBytes} bytes. ` +
-          "The signature may be malformed.",
-      )
-    }
-  }
-}