0xtrails 0.13.1 → 0.14.0

package/src/recover.ts

@@ -1,1665 +0,0 @@
-import type { Payload as WalletPayload } from "@0xsequence/wallet-primitives"
-import {
-  Constants,
-  Erc6492,
-  Payload,
-  Signature,
-} from "@0xsequence/wallet-primitives"
-import { isPositiveBigInt } from "./utils/validation.js"
-import {
-  IntentProtocolVersion,
-  type Intent,
-  type IntentCalls,
-  type TransactionCall,
-} from "@0xtrails/api"
-import { AbiFunction, Address, Bytes, type Hex } from "ox"
-import { useCallback, useMemo } from "react"
-import type { Chain, TransactionReceipt, WalletClient } from "viem"
-import { zeroAddress } from "viem"
-import { getChainInfo, getChainRpcClient } from "./chains.js"
-import { attemptSwitchChain } from "./chainSwitch.js"
-import { SEQUENCE_V3_CONTRACT_ADDRESSES } from "./constants.js"
-import { decodeGuestModuleEvents } from "./decoders.js"
-import { splitSignature } from "./gasless.js"
-import { abortIntent, getIntentConfigurationFromCalls } from "./intents.js"
-import { logger } from "./logger.js"
-import { type TrailsClient, useTrailsClient } from "./trailsClient.js"
-import {
-  useTokenBalancesForMultipleAccounts,
-  WIDGET_REFRESH_INTERVAL,
-} from "./query/balance.hooks.js"
-import type { FlatTokenBalancesData } from "./query/balance.fetchers.js"
-import type { Token } from "./tokens.js"
-import {
-  checkProviderHealth,
-  sendWalletTransaction,
-  signWithTimeout,
-} from "./walletUtils.js"
-import { getERC20TransferData } from "./utils.js"
-import { useGetIntent } from "./widget/hooks/useGetIntent.js"
-
-import { normalizeAddress } from "./utils/address.js"
-/**
- * Checks if an address is deployed by checking for bytecode
- * @param address - The address to check
- * @param chainId - The chain ID where the address exists
- * @returns Promise resolving to true if the address has bytecode, false otherwise
- */
-export async function isAddressDeployed(
-  address: Address.Address,
-  chainId: number,
-): Promise<boolean> {
-  const publicClient = getChainRpcClient(chainId)
-  const code = await publicClient.getCode({ address })
-  const isDeployed = code !== undefined && code !== "0x"
-  logger.console.log("[refund] Address deployment check:", {
-    address,
-    chainId,
-    codeLength: code?.length ?? 0,
-    isDeployed,
-  })
-  return isDeployed
-}
-
-/**
- * Generates a random space value for Sequence wallet payloads.
- * Space must be in the range [0, 2^160) (20 bytes).
- */
-function generateRandomSpace(): bigint {
-  const bytes = new Uint8Array(20) // 20 bytes = 160 bits
-  crypto.getRandomValues(bytes)
-  // Convert bytes to BigInt, ensuring it's within [0, 2^160)
-  return BigInt(
-    `0x${Array.from(bytes)
-      .map((b) => b.toString(16).padStart(2, "0"))
-      .join("")}`,
-  )
-}
-
-/**
- * Creates a refund payload with random space
- * @param refundCall - The refund call to include in the payload
- * @param nonce - The nonce value to use
- * @returns The created payload
- */
-function createRefundPayload(
-  refundCall: Payload.Call,
-  nonce: bigint,
-): Payload.Calls {
-  const refundSpace = generateRandomSpace()
-  return {
-    type: "call",
-    calls: [refundCall],
-    space: refundSpace,
-    nonce,
-  }
-}
-
-/**
- * Signs the payload hash for a refund transaction
- */
-export async function signPayload(
-  walletClient: WalletClient,
-  intentAddress: Address.Address,
-  chainId: number,
-  payload: Payload.Calls,
-): Promise<string> {
-  if (!walletClient.account) {
-    throw new Error("Wallet client account is required for signing")
-  }
-
-  // Check provider health before signing
-  await checkProviderHealth(walletClient)
-
-  const typedData = Payload.toTyped(
-    Address.from(intentAddress),
-    chainId,
-    payload,
-  )
-
-  // Sign with timeout to prevent hanging
-  const signature = await signWithTimeout(
-    walletClient.signTypedData({
-      account: walletClient.account,
-      ...typedData,
-    }),
-    "Payload signature",
-  )
-
-  logger.console.log("[refund] Signature received:", signature)
-  return signature
-}
-
-export interface BuildRefundTransactionWithSignatureParams {
-  trailsClient: TrailsClient
-  intentId: string
-  intentProtocolVersion: IntentProtocolVersion
-  mainSigner: Address.Address
-  checkpoint: number
-  calls: Array<IntentCalls>
-  payload: Payload.Calls // The payload that was signed
-  chainId: number
-  intentAddress: Address.Address
-  signature: string // Hex string signature
-  isOriginIntent: boolean // Whether this is the origin intent address (vs destination)
-}
-
-/**
- * Builds a refund transaction using a pre-signed hash
- */
-export async function buildRefundTransactionWithSignature(
-  params: BuildRefundTransactionWithSignatureParams,
-): Promise<{ to: `0x${string}`; data: Hex.Hex }> {
-  const {
-    trailsClient,
-    intentId,
-    intentProtocolVersion,
-    mainSigner,
-    checkpoint,
-    calls,
-    payload,
-    chainId,
-    intentAddress,
-    signature,
-    isOriginIntent,
-  } = params
-
-  // Validate refund call "to" address is not zeroAddress
-  const refundCall = payload.calls[0]
-  if (!refundCall) {
-    throw new Error("Refund call not found in payload")
-  }
-  if (!refundCall.to || Address.isEqual(refundCall.to, zeroAddress)) {
-    throw new Error("Refund call 'to' address cannot be zero address")
-  }
-
-  logger.console.log(
-    "[refund] buildRefundTransactionWithSignature called with params:",
-    {
-      mainSigner,
-      callsCount: calls.length,
-      calls: calls.map((c) => ({
-        chainId: c.chainId,
-        space: c.space?.toString(),
-        nonce: c.nonce?.toString(),
-        callsCount: c.calls?.length,
-        calls: c.calls.map((c) => ({
-          to: c.to,
-          value: c.value?.toString(),
-          data: c.data,
-          gasLimit: c.gasLimit?.toString(),
-          delegateCall: c.delegateCall,
-          onlyFallback: c.onlyFallback,
-          behaviorOnError: c.behaviorOnError,
-        })),
-      })),
-      refundCall: {
-        to: refundCall.to,
-        value: refundCall.value.toString(),
-        data: refundCall.data,
-        gasLimit: refundCall.gasLimit.toString(),
-      },
-      chainId,
-      intentAddress,
-      signatureLength: signature.length,
-      space: payload.space.toString(),
-      nonce: payload.nonce.toString(),
-    },
-  )
-
-  // In the current version, calls are already pre-filtered in the hook
-  // to contain only the calls for the selected intent address (origin or destination)
-  logger.console.log("[refund] Using pre-filtered calls for configuration:", {
-    intentProtocolVersion,
-    callsCount: calls.length,
-    chainId,
-    intentAddress,
-    isOriginIntent,
-    callChainIds: calls.map((c) => c.chainId),
-  })
-
-  if (calls.length !== 1) {
-    throw new Error("Invalid calls provided for intent configuration")
-  }
-
-  const context = SEQUENCE_V3_CONTRACT_ADDRESSES
-  const {
-    config: intentConfig,
-    imageHash,
-    address: apiAddress,
-  } = await getIntentConfigurationFromCalls(
-    trailsClient,
-    intentId,
-    intentProtocolVersion,
-    mainSigner,
-    checkpoint,
-    calls[0]!,
-    isOriginIntent,
-    context,
-  )
-
-  logger.console.log("[refund] Image hash:", imageHash)
-
-  if (!Address.isEqual(apiAddress, intentAddress)) {
-    throw new Error(
-      "API address does not match intent address. Probably config is wrong",
-    )
-  }
-
-  // Use the payload that was passed in (already contains space, nonce, and refundCall)
-  logger.console.log("[refund] Payload created:", {
-    type: payload.type,
-    callsCount: payload.calls.length,
-    space: payload.space.toString(),
-    nonce: payload.nonce.toString(),
-    calls: payload.calls.map((c) => ({
-      to: c.to,
-      value: c.value.toString(),
-      data: c.data,
-      gasLimit: c.gasLimit.toString(),
-    })),
-  })
-
-  const encodedPayload = Bytes.toHex(Payload.encode(payload))
-  logger.console.log("[refund] Encoded payload:", encodedPayload)
-
-  const toSignatureLeaf = async (
-    signer: Address.Address,
-    signature: `0x${string}`,
-  ): Promise<
-    Signature.SignatureOfSignerLeaf | Signature.SignatureOfSapientSignerLeaf
-  > => {
-    const signerIsContract = await isAddressDeployed(signer, chainId)
-    if (signerIsContract) {
-      return {
-        address: signer,
-        type: "erc1271",
-        data: signature as `0x${string}`,
-      }
-    } else {
-      const { r, s, v } = splitSignature(signature)
-      const yParity = v - 27 // Convert v to yParity (0 or 1)
-      logger.console.log("[refund] Signature parsed:", { r, s, v, yParity })
-      const rBigInt = BigInt(r)
-      const sBigInt = BigInt(s)
-      return {
-        type: "hash",
-        r: rBigInt,
-        s: sBigInt,
-        yParity,
-      }
-    }
-  }
-  const signerSignatureLeaf = await toSignatureLeaf(
-    mainSigner,
-    signature as `0x${string}`,
-  )
-  const topology = Signature.fillLeaves(intentConfig.topology, (leaf) =>
-    Address.isEqual(leaf.address, mainSigner) ? signerSignatureLeaf : undefined,
-  )
-  logger.console.log("[refund] Topology filled with signature leaves")
-
-  const filledConfig = {
-    noChainId: false,
-    configuration: { ...intentConfig, topology },
-  }
-  const encodedSignature = Signature.encodeSignature(filledConfig, true, true)
-  logger.console.log(
-    "[refund] Signature encoded:",
-    Bytes.toHex(encodedSignature),
-  )
-
-  // Check if intent address has bytecode deployed
-  const intentAddressDeployed = await isAddressDeployed(intentAddress, chainId)
-
-  const executeData = AbiFunction.encodeData(Constants.EXECUTE, [
-    encodedPayload,
-    Bytes.toHex(encodedSignature),
-  ])
-  logger.console.log("[refund] Execute data encoded:", executeData)
-
-  // Validate intent address is not zeroAddress
-  if (!intentAddress || Address.isEqual(intentAddress, zeroAddress)) {
-    throw new Error("Intent address cannot be zero address")
-  }
-
-  if (intentAddressDeployed) {
-    logger.console.log(
-      "[refund] Intent address is deployed, returning direct transaction:",
-      {
-        to: intentAddress,
-        data: executeData,
-      },
-    )
-    return { to: intentAddress, data: executeData }
-  } else {
-    logger.console.log(
-      "[refund] Intent address not deployed, using ERC-6492 deploy",
-    )
-    const deploy = Erc6492.deploy(imageHash, context)
-    logger.console.log("[refund] ERC-6492 deploy created:", {
-      to: deploy.to,
-      dataLength: deploy.data.length,
-      deployToHex: deploy.to,
-      imageHashUsed: imageHash,
-      factoryAddress: context.factory,
-      guestModuleAddress: context.guestModule,
-    })
-
-    // Validate deploy.to and intentAddress are not zeroAddress
-    if (!deploy.to || Address.isEqual(deploy.to, zeroAddress)) {
-      throw new Error("Deploy 'to' address cannot be zero address")
-    }
-
-    const deployPayload = {
-      type: "call" as const,
-      space: 0n,
-      nonce: 0n,
-      calls: [
-        {
-          to: deploy.to,
-          value: 0n,
-          data: deploy.data,
-          gasLimit: 0n,
-          delegateCall: false,
-          onlyFallback: false,
-          behaviorOnError: "revert" as const,
-        },
-        {
-          to: intentAddress,
-          value: 0n,
-          data: executeData,
-          gasLimit: 0n,
-          delegateCall: false,
-          onlyFallback: false,
-          behaviorOnError: "revert" as const,
-        },
-      ],
-    }
-    logger.console.log("[refund] Deploy payload created:", {
-      callsCount: deployPayload.calls.length,
-      calls: deployPayload.calls.map((c) => ({
-        to: c.to,
-        value: c.value.toString(),
-        dataLength: c.data.length,
-        gasLimit: c.gasLimit.toString(),
-      })),
-    })
-
-    const encodedDeployPayload = Bytes.toHex(Payload.encode(deployPayload))
-    logger.console.log("[refund] Encoded deploy payload:", {
-      fullPayload: encodedDeployPayload,
-      payloadLength: encodedDeployPayload.length,
-      payloadPreview: `${encodedDeployPayload.slice(0, 100)}...`,
-      executeDataLength: executeData.length,
-      executeDataPreview: `${executeData.slice(0, 100)}...`,
-    })
-
-    const result = {
-      to: context.guestModule as `0x${string}`,
-      data: encodedDeployPayload,
-    }
-
-    // Validate final transaction "to" address is not zeroAddress
-    if (!result.to || Address.isEqual(result.to, zeroAddress)) {
-      throw new Error("Transaction 'to' address cannot be zero address")
-    }
-
-    logger.console.log("[refund] Returning ERC-6492 transaction:", {
-      to: result.to,
-      dataLength: result.data.length,
-    })
-
-    return result
-  }
-}
-
-/**
- * Determines the refund call based on token balances at the intent address
- * Uses Token type which has symbol, name, decimals, chainId directly (no contractInfo)
- */
-export function determineRefundCall(
-  tokenBalancesData:
-    | {
-        tokens?: Array<{
-          balance?: string
-          contractAddress?: string
-          decimals?: number
-          chainId?: number
-          isNativeToken?: boolean
-        }>
-      }
-    | undefined,
-  refundToAddress: `0x${string}`,
-): WalletPayload.Call {
-  // Validate refund address is not zeroAddress
-  if (!refundToAddress || Address.isEqual(refundToAddress, zeroAddress)) {
-    throw new Error("Refund address cannot be zero address")
-  }
-  // Find the token with the highest balance
-  let highestBalanceToken: {
-    type: "native" | "erc20"
-    balance: bigint
-    tokenAddress?: string
-    decimals?: number
-    chainId?: number
-  } | null = null
-
-  // Check all tokens (both native and ERC20)
-  if (tokenBalancesData?.tokens) {
-    for (const token of tokenBalancesData.tokens) {
-      const balance = BigInt(token.balance || "0")
-      if (balance > 0n) {
-        if (!highestBalanceToken || balance > highestBalanceToken.balance) {
-          highestBalanceToken = {
-            type: token.isNativeToken ? "native" : "erc20",
-            balance,
-            tokenAddress: token.contractAddress,
-            decimals: token.decimals,
-            chainId: token.chainId,
-          }
-        }
-      }
-    }
-  }
-
-  if (!highestBalanceToken) {
-    logger.console.log(
-      "[refund] No tokens found at intent address, creating empty refund call",
-    )
-    return {
-      to: refundToAddress,
-      value: 0n,
-      data: "0x" as `0x${string}`,
-      gasLimit: 0n,
-      delegateCall: false,
-      onlyFallback: false,
-      behaviorOnError: "revert",
-    }
-  } else if (highestBalanceToken.type === "native") {
-    logger.console.log("[refund] Creating native token refund call:", {
-      to: refundToAddress,
-      value: highestBalanceToken.balance.toString(),
-      balance: highestBalanceToken.balance.toString(),
-      chainId: highestBalanceToken.chainId,
-    })
-    return {
-      to: refundToAddress,
-      value: highestBalanceToken.balance,
-      data: "0x" as `0x${string}`,
-      gasLimit: 0n,
-      delegateCall: false,
-      onlyFallback: false,
-      behaviorOnError: "revert",
-    }
-  } else {
-    // ERC20 token refund
-    // For recovery operations, we still encode client-side
-    const transferData = getERC20TransferData(
-      refundToAddress,
-      highestBalanceToken.balance,
-    )
-    logger.console.log("[refund] Creating ERC20 token refund call:", {
-      to: highestBalanceToken.tokenAddress,
-      value: "0",
-      data: transferData,
-      balance: highestBalanceToken.balance.toString(),
-      decimals: highestBalanceToken.decimals,
-      chainId: highestBalanceToken.chainId,
-      recipient: refundToAddress,
-    })
-    // Validate token address is not zeroAddress
-    if (
-      !highestBalanceToken.tokenAddress ||
-      Address.isEqual(
-        Address.from(highestBalanceToken.tokenAddress),
-        zeroAddress,
-      )
-    ) {
-      throw new Error("ERC20 token address cannot be zero address")
-    }
-
-    return {
-      to: Address.from(highestBalanceToken.tokenAddress),
-      value: 0n,
-      data: transferData as `0x${string}`,
-      gasLimit: 0n,
-      delegateCall: false,
-      onlyFallback: false,
-      behaviorOnError: "revert",
-    }
-  }
-}
-
-// ─── Shared helper types and functions (used by multiple hooks) ───
-
-interface SelectedIntentAddress {
-  address: Address.Address
-  chainId: number
-  intentAddress: Address.Address
-  tokenBalancesData: FlatTokenBalancesData | undefined
-  isOrigin: boolean
-}
-
-function findHighestTokenUsdBalance(
-  tokenBalancesData: FlatTokenBalancesData | undefined,
-): number {
-  if (!tokenBalancesData?.tokens) return 0
-  let highest = 0
-  for (const token of tokenBalancesData.tokens) {
-    const balanceUsd = token.balanceUsd || 0
-    if (balanceUsd > highest) highest = balanceUsd
-  }
-  return highest
-}
-
-function findHighestRawTokenBalance(
-  tokenBalancesData: FlatTokenBalancesData | undefined,
-): bigint {
-  if (!tokenBalancesData?.tokens) return 0n
-  let highest = 0n
-  for (const token of tokenBalancesData.tokens) {
-    const balance = BigInt(token.balance || "0")
-    if (balance > highest) highest = balance
-  }
-  return highest
-}
-
-function selectIntentAddress(
-  intentData: Intent,
-  originBalances: FlatTokenBalancesData | undefined,
-  destBalances: FlatTokenBalancesData | undefined,
-  originAddr: Address.Address | null,
-  destAddr: Address.Address | null,
-): SelectedIntentAddress | null {
-  const originHighestTokenUsd = findHighestTokenUsdBalance(originBalances)
-  const destinationHighestTokenUsd = findHighestTokenUsdBalance(destBalances)
-  const originHighestRawBalance = findHighestRawTokenBalance(originBalances)
-  const destinationHighestRawBalance = findHighestRawTokenBalance(destBalances)
-
-  let useDestination = false
-  if (destAddr) {
-    if (originHighestTokenUsd > 0 && destinationHighestTokenUsd > 0) {
-      useDestination = destinationHighestTokenUsd > originHighestTokenUsd
-    } else if (destinationHighestTokenUsd > 0 && originHighestTokenUsd === 0) {
-      useDestination = true
-    } else if (originHighestTokenUsd > 0 && destinationHighestTokenUsd === 0) {
-      useDestination = false
-    } else {
-      useDestination = destinationHighestRawBalance > originHighestRawBalance
-    }
-  }
-
-  const makeOriginResult = (): SelectedIntentAddress | null => {
-    if (!intentData.originIntentAddress || !originAddr) return null
-    return {
-      address: originAddr,
-      chainId: Number(intentData.originChainId || 0),
-      intentAddress: Address.from(intentData.originIntentAddress),
-      tokenBalancesData: originBalances,
-      isOrigin: true,
-    }
-  }
-
-  if (useDestination) {
-    const chainId = intentData.destinationChainId
-    if (!chainId || !intentData.destinationIntentAddress || !destAddr) {
-      return makeOriginResult()
-    }
-    return {
-      address: destAddr,
-      chainId: Number(chainId),
-      intentAddress: Address.from(intentData.destinationIntentAddress),
-      tokenBalancesData: destBalances,
-      isOrigin: false,
-    }
-  }
-
-  return makeOriginResult()
-}
-
-function checkAnyIntentBalance(
-  originBalances: FlatTokenBalancesData | undefined,
-  destBalances: FlatTokenBalancesData | undefined,
-): boolean {
-  const hasBalance = (data: { tokens?: Token[] } | undefined): boolean => {
-    if (!data?.tokens) return false
-    for (const token of data.tokens) {
-      if (isPositiveBigInt(token.balance || "0")) return true
-    }
-    return false
-  }
-  return hasBalance(originBalances) || hasBalance(destBalances)
-}
-
-function findRecoverToken(
-  selected: SelectedIntentAddress | null,
-): Token | null {
-  if (!selected?.tokenBalancesData?.tokens) return null
-  let highestBalanceToken: Token | null = null
-  let highestBalance = 0n
-  for (const token of selected.tokenBalancesData.tokens) {
-    const balance = BigInt(token.balance || "0")
-    if (balance > 0n && balance > highestBalance) {
-      highestBalance = balance
-      highestBalanceToken = token
-    }
-  }
-  return highestBalanceToken
-}
-
-function mapTransactionCalls(intentData: Intent): IntentCalls[] {
-  const allCalls: IntentCalls[] = []
-  if (intentData.originCalls) {
-    allCalls.push({
-      chainId: intentData.originCalls.chainId,
-      space: intentData.originCalls.space,
-      nonce: intentData.originCalls.nonce,
-      calls: intentData.originCalls.calls.map((call: TransactionCall) => ({
-        to: call.to,
-        value: call.value,
-        data: call.data,
-        gasLimit: call.gasLimit,
-        delegateCall: call.delegateCall,
-        onlyFallback: call.onlyFallback,
-        behaviorOnError: call.behaviorOnError,
-      })),
-    })
-  }
-  if (
-    intentData.destinationCalls &&
-    intentData.destinationCalls.chainId !== intentData.originCalls?.chainId
-  ) {
-    allCalls.push({
-      chainId: intentData.destinationCalls.chainId,
-      space: intentData.destinationCalls.space,
-      nonce: intentData.destinationCalls.nonce,
-      calls: intentData.destinationCalls.calls.map((call: TransactionCall) => ({
-        to: call.to,
-        value: call.value,
-        data: call.data,
-        gasLimit: call.gasLimit,
-        delegateCall: call.delegateCall,
-        onlyFallback: call.onlyFallback,
-        behaviorOnError: call.behaviorOnError,
-      })),
-    })
-  }
-  return allCalls
-}
-
-function filterCallsByChainId(
-  allCalls: IntentCalls[],
-  targetChainId: number,
-): IntentCalls[] {
-  return allCalls.filter((call) => {
-    const callChainId =
-      typeof call.chainId === "bigint"
-        ? call.chainId
-        : BigInt(String(call.chainId))
-    return callChainId === BigInt(targetChainId)
-  })
-}
-
-function validateRefundAddress(
-  address: `0x${string}` | null,
-): asserts address is `0x${string}` {
-  if (!address) {
-    throw new Error(
-      "Refund address is required. Provide refundToAddress or connect a wallet with a valid address",
-    )
-  }
-  if (Address.isEqual(address, zeroAddress)) {
-    throw new Error("Refund address cannot be zero address")
-  }
-}
-
-async function getRecoverStatusFromChain(params: {
-  txHash: `0x${string}`
-  chainId: number
-}): Promise<{ status: "success" | "fail" | "pending" }> {
-  const { txHash, chainId } = params
-  const publicClient = getChainRpcClient(chainId)
-  try {
-    const transaction = await publicClient.getTransaction({ hash: txHash })
-    if (transaction) {
-      try {
-        const receipt = await publicClient.getTransactionReceipt({
-          hash: txHash,
-        })
-        if (receipt.status === "reverted") return { status: "fail" }
-        const guestModuleEvents = decodeGuestModuleEvents(receipt)
-        if (guestModuleEvents.some((e) => e.type === "CallFailed"))
-          return { status: "fail" }
-        return { status: "success" }
-      } catch {
-        return { status: "pending" }
-      }
-    }
-  } catch {
-    try {
-      const receipt = await publicClient.getTransactionReceipt({
-        hash: txHash,
-      })
-      if (receipt.status === "reverted") return { status: "fail" }
-      const guestModuleEvents = decodeGuestModuleEvents(receipt)
-      if (guestModuleEvents.some((e) => e.type === "CallFailed"))
-        return { status: "fail" }
-      return { status: "success" }
-    } catch {
-      return { status: "pending" }
-    }
-  }
-  return { status: "pending" }
-}
-
-function buildSelectedRecoveryTarget(selected: SelectedIntentAddress | null) {
-  if (!selected) return null
-  const chainInfo = getChainInfo(selected.chainId)
-  return {
-    address: selected.address,
-    chainId: selected.chainId,
-    chainName: chainInfo?.name || `Chain ${selected.chainId}`,
-    isOrigin: selected.isOrigin,
-    tokenBalancesData: selected.tokenBalancesData,
-  }
-}
-
-/**
- * Builds the calls array for a specific intent address (origin or destination).
- * Used by getRecoverTx in multiple hooks.
- */
-function buildCallsForSelectedAddress(
-  intentData: Intent,
-  selected: SelectedIntentAddress,
-): IntentCalls[] {
-  const calls: IntentCalls[] = []
-  if (selected.isOrigin && intentData.originCalls) {
-    calls.push({
-      chainId: intentData.originCalls.chainId,
-      space: intentData.originCalls.space,
-      nonce: intentData.originCalls.nonce,
-      calls: intentData.originCalls.calls.map((call: TransactionCall) => ({
-        to: call.to,
-        value: call.value,
-        data: call.data,
-        gasLimit: call.gasLimit,
-        delegateCall: call.delegateCall,
-        onlyFallback: call.onlyFallback,
-        behaviorOnError: call.behaviorOnError,
-      })),
-    })
-  } else if (!selected.isOrigin && intentData.destinationCalls) {
-    calls.push({
-      chainId: intentData.destinationCalls.chainId,
-      space: intentData.destinationCalls.space,
-      nonce: intentData.destinationCalls.nonce,
-      calls: intentData.destinationCalls.calls.map((call: TransactionCall) => ({
-        to: call.to,
-        value: call.value,
-        data: call.data,
-        gasLimit: call.gasLimit,
-        delegateCall: call.delegateCall,
-        onlyFallback: call.onlyFallback,
-        behaviorOnError: call.behaviorOnError,
-      })),
-    })
-  }
-  return calls
-}
-
-/**
- * Builds a recover transaction from signature + payload using shared logic.
- */
-async function buildRecoverTxFromSignature(params: {
-  trailsClient: TrailsClient
-  intentData: Intent
-  mainSigner: Address.Address
-  selected: SelectedIntentAddress
-  effectiveRefundAddress: `0x${string}`
-  signature: string
-  payload: Payload.Calls
-}): Promise<{
-  to: `0x${string}`
-  data: `0x${string}`
-  chainId: number
-  chain: Chain
-}> {
-  const {
-    trailsClient,
-    intentData,
-    mainSigner,
-    selected,
-    effectiveRefundAddress,
-    signature,
-    payload,
-  } = params
-  validateRefundAddress(effectiveRefundAddress)
-
-  const calls = buildCallsForSelectedAddress(intentData, selected)
-  if (calls.length === 0) {
-    throw new Error("No calls found for the selected intent address")
-  }
-
-  const chainId = selected.chainId
-  if (!chainId) {
-    throw new Error("Chain ID not found for selected intent address")
-  }
-
-  const intentProtocolVersion =
-    intentData.intentProtocolVersion ?? IntentProtocolVersion.v1
-  const checkpoint = Number(intentData.salt)
-
-  const result = await buildRefundTransactionWithSignature({
-    trailsClient,
-    intentId: intentData.intentId,
-    intentProtocolVersion,
-    checkpoint,
-    mainSigner,
-    calls,
-    payload,
-    chainId: Number(chainId),
-    intentAddress: selected.intentAddress,
-    signature,
-    isOriginIntent: selected.isOrigin,
-  })
-
-  if (!result.to || Address.isEqual(result.to, zeroAddress)) {
-    throw new Error("Refund transaction 'to' address cannot be zero address")
-  }
-
-  const chainInfo = getChainInfo(Number(chainId))
-  if (!chainInfo) {
-    throw new Error(`Chain info not found for chain ID: ${chainId}`)
-  }
-
-  return {
-    to: result.to,
-    data: result.data,
-    chainId: Number(chainId),
-    chain: chainInfo as Chain,
-  }
-}
-
-// ─── End shared helpers ───
-
-export interface UseIntentRecoverParams {
-  intentId: string | undefined
-  walletClient: WalletClient | undefined
-  refundToAddress?: `0x${string}`
-}
-
-export interface UseIntentRecoverWithBalancesParams {
-  intent: Intent | null
-  balancesByIntentAddress: {
-    [account: string]: {
-      tokenBalancesData: FlatTokenBalancesData | undefined
-      isLoading: boolean
-      error: Error | null
-    }
-  }
-  walletClient: WalletClient | undefined
-  refundToAddress?: `0x${string}`
-}
-
-/**
- * Optimized return type for useIntentRecoverWithBalances
- */
-export interface UseIntentRecoverWithBalancesReturn {
-  intent: Intent | null
-  hasIntentBalance: boolean
-  recoverToken: Token | null
-  selectedRecoveryTarget: {
-    address: Address.Address
-    chainId: number
-    chainName: string
-    isOrigin: boolean
-    tokenBalancesData: FlatTokenBalancesData | undefined
-  } | null
-  refetchIntent: () => void
-  signPayload: () => Promise<{
-    signature: string
-    payload: Payload.Calls
-    refundCall: Payload.Call
-  }>
-  getRecoverTx: (params: {
-    signedHash: string
-    payload: Payload.Calls
-  }) => Promise<{
-    to: `0x${string}`
-    data: `0x${string}`
-    chainId: number
-    chain: Chain
-  }>
-  recover: () => Promise<{
-    txHash: `0x${string}`
-  }>
-  getRecoverStatus: (params: {
-    txHash: `0x${string}`
-    chainId: number
-  }) => Promise<{
-    status: "success" | "fail" | "pending"
-  }>
-}
-
-export interface UseIntentRecoverReturn {
-  intent: Intent | null
-  isLoadingIntent: boolean
-  isLoadingBalances: boolean
-  intentError: Error | null
-  balancesError: Error | null
-  hasIntentBalance: boolean
-  /** Token that will be recovered (the one with highest balance) */
-  recoverToken: Token | null
-  /** Information about which intent address will be recovered from */
-  selectedRecoveryTarget: {
-    address: Address.Address
-    chainId: number
-    chainName: string
-    isOrigin: boolean
-    tokenBalancesData: FlatTokenBalancesData | undefined
-  } | null
-  refetchIntent: () => void
-  signPayload: () => Promise<{
-    signature: string
-    payload: Payload.Calls
-    refundCall: Payload.Call
-  }>
-  getRecoverTx: (params: {
-    signedHash: string
-    payload: Payload.Calls
-  }) => Promise<{
-    to: `0x${string}`
-    data: `0x${string}`
-    chainId: number
-    chain: Chain
-  }>
-  recover: () => Promise<{
-    txHash: `0x${string}`
-    receipt: TransactionReceipt
-    chainId: number
-  }>
-  getRecoverStatus: (params: {
-    txHash: `0x${string}`
-    chainId: number
-  }) => Promise<{
-    status: "success" | "fail" | "pending"
-  }>
-}
-
-export interface UseIntentRecoverWithAddressParams {
-  intentId: string | undefined
-  /** Signer for the recovery tx and default refund receiver */
-  walletAddress: `0x${string}` | undefined
-  /** Optional. If set, refund is sent here instead of walletAddress (signer stays walletAddress). */
-  refundToAddress?: `0x${string}`
-}
-
-export interface UseIntentRecoverWithAddressReturn {
-  intent: Intent | null
-  isLoadingIntent: boolean
-  isLoadingBalances: boolean
-  intentError: Error | null
-  balancesError: Error | null
-  hasIntentBalance: boolean
-  recoverToken: Token | null
-  selectedRecoveryTarget: {
-    address: Address.Address
-    chainId: number
-    chainName: string
-    isOrigin: boolean
-    tokenBalancesData: FlatTokenBalancesData | undefined
-  } | null
-  refetchIntent: () => void
-  /** Returns payload and EIP-712 typed data for the app to sign (e.g. with embedded wallet). */
-  getDataToSign: () => Promise<{
-    payload: Payload.Calls
-    refundCall: Payload.Call
-    chainId: number
-    typedData: ReturnType<typeof Payload.toTyped>
-  }>
-  getRecoverTx: (params: {
-    signature: string
-    payload: Payload.Calls
-  }) => Promise<{
-    to: `0x${string}`
-    data: `0x${string}`
-    chainId: number
-    chain: Chain
-  }>
-  getRecoverStatus: (params: {
-    txHash: `0x${string}`
-    chainId: number
-  }) => Promise<{
-    status: "success" | "fail" | "pending"
-  }>
-}
-
-/**
- * Hook for building and signing recover transactions.
- * Wraps useIntentRecoverWithAddress and adds walletClient-based signing + sending.
- * @example
- * ```tsx
- * const { signPayload, getRecoverTx, recover } = useIntentRecover({
- *   intentId: "0x...",
- *   walletClient: walletClient,
- * })
- *
- * // Option 1: Manual flow
- * const signedHash = await signPayload()
- * const recoverTx = await getRecoverTx({ signedHash })
- * await walletClient.sendTransaction(recoverTx)
- *
- * // Option 2: Automatic flow (recommended)
- * const { txHash, receipt, chainId } = await recover()
- * const status = await getRecoverStatus({ txHash, chainId })
- * ```
- */
-export function useIntentRecover({
-  intentId,
-  walletClient,
-  refundToAddress,
-}: UseIntentRecoverParams): UseIntentRecoverReturn {
-  const trailsClient = useTrailsClient()
-  const walletAddress = walletClient?.account?.address as
-    | `0x${string}`
-    | undefined
-
-  const inner = useIntentRecoverWithAddress({
-    intentId,
-    walletAddress,
-    refundToAddress: refundToAddress || walletAddress,
-  })
-
-  const signPayload = useCallback(async (): Promise<{
-    signature: string
-    payload: Payload.Calls
-    refundCall: Payload.Call
-  }> => {
-    if (!walletClient || !walletClient.account) {
-      throw new Error("Intent data and wallet client with account required")
-    }
-
-    await checkProviderHealth(walletClient)
-
-    const { payload, refundCall, chainId, typedData } =
-      await inner.getDataToSign()
-
-    await attemptSwitchChain({
-      walletClient,
-      desiredChainId: Number(chainId),
-    })
-
-    await checkProviderHealth(walletClient)
-
-    const signature = await signWithTimeout(
-      walletClient.signTypedData({
-        account: walletClient.account,
-        ...typedData,
-      }),
-      "Recovery signature",
-    )
-
-    return { signature, payload, refundCall }
-  }, [walletClient, inner])
-
-  const getRecoverTx = useCallback(
-    async (params: {
-      signedHash: string
-      payload: Payload.Calls
-    }): Promise<{
-      to: `0x${string}`
-      data: `0x${string}`
-      chainId: number
-      chain: Chain
-    }> =>
-      inner.getRecoverTx({
-        signature: params.signedHash,
-        payload: params.payload,
-      }),
-    [inner],
-  )
-
-  const recover = useCallback(async (): Promise<{
-    txHash: `0x${string}`
-    receipt: TransactionReceipt
-    chainId: number
-  }> => {
-    if (!walletClient || !walletClient.account) {
-      throw new Error("Intent data and wallet client with account required")
-    }
-
-    const { signature, payload } = await signPayload()
-
-    const recoverTx = await getRecoverTx({
-      signedHash: signature,
-      payload,
-    })
-
-    await attemptSwitchChain({
-      walletClient,
-      desiredChainId: recoverTx.chainId,
-    })
-
-    const txHash = await sendWalletTransaction(walletClient, {
-      account: walletClient.account,
-      to: recoverTx.to,
-      data: recoverTx.data,
-      chain: recoverTx.chain,
-    })
-
-    const publicClient = getChainRpcClient(recoverTx.chainId)
-    const receipt = await publicClient.waitForTransactionReceipt({
-      hash: txHash as `0x${string}`,
-    })
-
-    if (intentId && trailsClient) {
-      try {
-        await abortIntent(trailsClient, intentId, recoverTx.chainId, txHash)
-      } catch (error) {
-        logger.console.error(
-          "[recover] Failed to abort intent after recovery:",
-          {
-            error: error instanceof Error ? error.message : String(error),
-            intentId,
-            chainId: recoverTx.chainId,
-            txHash,
-          },
-        )
-      }
-    }
-
-    return {
-      txHash: txHash as `0x${string}`,
-      receipt,
-      chainId: recoverTx.chainId,
-    }
-  }, [signPayload, getRecoverTx, walletClient, intentId, trailsClient])
-
-  return {
-    ...inner,
-    signPayload,
-    getRecoverTx,
-    recover,
-  }
-}
-
-/**
- * Recovery hook for apps that handle signing externally (e.g. embedded wallets)
- * Use getDataToSign to get EIP-712 data, sign with walletAddress, then getRecoverTx(signature, payload).
- * Refund goes to refundToAddress if provided, otherwise to walletAddress.
- * @example
- * ```tsx
- * const { getDataToSign, getRecoverTx } = useIntentRecoverWithAddress({
- *   intentId: "0x...",
- *   walletAddress: "0x...",
- *   refundToAddress: "0x...", // optional, allows for different refund address than signer
- * })
- * const { payload, typedData, chainId } = await getDataToSign()
- * const signature = await myCustomWallet.signTypedData({ account: walletAddress, ...typedData })
- * const recoverTx = await getRecoverTx({ signature, payload })
- * const hash = await myCustomWallet.sendTransaction({ to: recoverTx.to, data: recoverTx.data, chain: recoverTx.chain })
- * ```
- */
-export function useIntentRecoverWithAddress({
-  intentId,
-  walletAddress,
-  refundToAddress,
-}: UseIntentRecoverWithAddressParams): UseIntentRecoverWithAddressReturn {
-  const {
-    intent: intentData,
-    isLoading: isLoadingIntent,
-    error: intentError,
-    refetch: refetchIntent,
-  } = useGetIntent({
-    intentId,
-    enabled: !!intentId,
-  })
-
-  const trailsClient = useTrailsClient()
-
-  const originIntentAddressForBalances = intentData?.originIntentAddress
-    ? Address.from(intentData.originIntentAddress)
-    : null
-  const destinationIntentAddressForBalances =
-    intentData?.destinationIntentAddress
-      ? Address.from(intentData.destinationIntentAddress)
-      : null
-
-  const {
-    balancesByAccount: balancesByIntentAddress,
-    isLoading: isLoadingBalances,
-    error: balanceError,
-  } = useTokenBalancesForMultipleAccounts(
-    [originIntentAddressForBalances, destinationIntentAddressForBalances],
-    {
-      refetchInterval: WIDGET_REFRESH_INTERVAL,
-    },
-  )
-
-  const originTokenBalancesData = originIntentAddressForBalances
-    ? balancesByIntentAddress[normalizeAddress(originIntentAddressForBalances)]
-        ?.tokenBalancesData
-    : undefined
-  const destinationTokenBalancesData = destinationIntentAddressForBalances
-    ? balancesByIntentAddress[
-        normalizeAddress(destinationIntentAddressForBalances)
-      ]?.tokenBalancesData
-    : undefined
-  const balancesError = balanceError
-
-  const selectedIntentAddress = useMemo<SelectedIntentAddress | null>(
-    () =>
-      intentData
-        ? selectIntentAddress(
-            intentData,
-            originTokenBalancesData,
-            destinationTokenBalancesData,
-            originIntentAddressForBalances,
-            destinationIntentAddressForBalances,
-          )
-        : null,
-    [
-      intentData,
-      originTokenBalancesData,
-      destinationTokenBalancesData,
-      originIntentAddressForBalances,
-      destinationIntentAddressForBalances,
-    ],
-  )
-
-  const hasIntentBalance = useMemo<boolean>(
-    () =>
-      checkAnyIntentBalance(
-        originTokenBalancesData,
-        destinationTokenBalancesData,
-      ),
-    [originTokenBalancesData, destinationTokenBalancesData],
-  )
-
-  const recoverToken = useMemo<Token | null>(
-    () => findRecoverToken(selectedIntentAddress),
-    [selectedIntentAddress],
-  )
-
-  const effectiveRefundAddress = useMemo<`0x${string}` | null>(() => {
-    const address = refundToAddress ?? walletAddress
-    if (!address || Address.isEqual(address, zeroAddress)) return null
-    return address
-  }, [refundToAddress, walletAddress])
-
-  const getDataToSign = useCallback(async (): Promise<{
-    payload: Payload.Calls
-    refundCall: Payload.Call
-    chainId: number
-    typedData: ReturnType<typeof Payload.toTyped>
-  }> => {
-    if (!intentData) {
-      throw new Error("Intent data required")
-    }
-    if (!effectiveRefundAddress) {
-      throw new Error(
-        "Refund address required. Provide refundToAddress or walletAddress",
-      )
-    }
-    if (Address.isEqual(effectiveRefundAddress, zeroAddress)) {
-      throw new Error("Refund address cannot be zero address")
-    }
-    if (!selectedIntentAddress) {
-      throw new Error("No intent address selected for recovery")
-    }
-    const allCalls = mapTransactionCalls(intentData)
-    const calls = filterCallsByChainId(allCalls, selectedIntentAddress.chainId)
-    if (calls.length === 0) {
-      throw new Error("No calls found for the selected intent address")
-    }
-    const refundCall = determineRefundCall(
-      selectedIntentAddress.tokenBalancesData,
-      effectiveRefundAddress,
-    )
-    const chainId = selectedIntentAddress.chainId
-    if (!chainId) {
-      throw new Error("Chain ID not found for selected intent address")
-    }
-    const payload = createRefundPayload(
-      refundCall,
-      BigInt(calls[0]?.nonce ?? 0),
-    )
-    const typedData = Payload.toTyped(
-      selectedIntentAddress.intentAddress,
-      chainId,
-      payload,
-    )
-    return { payload, refundCall, chainId, typedData }
-  }, [intentData, selectedIntentAddress, effectiveRefundAddress])
-
-  const getRecoverTx = useCallback(
-    async (params: {
-      signature: string
-      payload: Payload.Calls
-    }): Promise<{
-      to: `0x${string}`
-      data: `0x${string}`
-      chainId: number
-      chain: Chain
-    }> => {
-      if (!intentData) {
-        throw new Error("Intent data required")
-      }
-      if (!walletAddress) {
-        throw new Error("walletAddress is required")
-      }
-      if (!selectedIntentAddress) {
-        throw new Error("No intent address selected for recovery")
-      }
-      return buildRecoverTxFromSignature({
-        trailsClient,
-        intentData,
-        mainSigner: Address.from(walletAddress),
-        selected: selectedIntentAddress,
-        effectiveRefundAddress: effectiveRefundAddress!,
-        signature: params.signature,
-        payload: params.payload,
-      })
-    },
-    [
-      intentData,
-      walletAddress,
-      selectedIntentAddress,
-      effectiveRefundAddress,
-      trailsClient,
-    ],
-  )
-
-  const getRecoverStatus = useCallback(
-    (params: { txHash: `0x${string}`; chainId: number }) =>
-      getRecoverStatusFromChain(params),
-    [],
-  )
-
-  const selectedRecoveryTarget = useMemo(
-    () => buildSelectedRecoveryTarget(selectedIntentAddress),
-    [selectedIntentAddress],
-  )
-
-  return {
-    intent: intentData,
-    isLoadingIntent,
-    isLoadingBalances,
-    intentError: intentError as Error | null,
-    balancesError: balancesError as Error | null,
-    hasIntentBalance,
-    recoverToken,
-    selectedRecoveryTarget,
-    refetchIntent,
-    getDataToSign,
-    getRecoverTx,
-    getRecoverStatus,
-  }
-}
-
-/**
- * Optimized hook for building and signing recover transactions with pre-fetched data
- * @example
- * ```tsx
- * const { hasIntentBalance, recoverToken, recover } = useIntentRecoverWithBalances({
- *   intent: intentData,
- *   balancesByIntentAddress: balancesMap,
- *   walletClient: walletClient,
- * })
- * ```
- */
-export function useIntentRecoverWithBalances({
-  intent: intentData,
-  balancesByIntentAddress,
-  walletClient,
-  refundToAddress,
-}: UseIntentRecoverWithBalancesParams): UseIntentRecoverWithBalancesReturn {
-  const trailsClient = useTrailsClient()
-
-  const originTokenBalancesData = intentData?.originIntentAddress
-    ? balancesByIntentAddress[normalizeAddress(intentData.originIntentAddress)]
-        ?.tokenBalancesData
-    : undefined
-
-  const destinationTokenBalancesData = intentData?.destinationIntentAddress
-    ? balancesByIntentAddress[
-        normalizeAddress(intentData.destinationIntentAddress)
-      ]?.tokenBalancesData
-    : undefined
-
-  const originIntentAddressForBalances = intentData?.originIntentAddress
-    ? Address.from(intentData.originIntentAddress)
-    : null
-
-  const destinationIntentAddressForBalances =
-    intentData?.destinationIntentAddress
-      ? Address.from(intentData.destinationIntentAddress)
-      : null
-
-  const selectedIntentAddress = useMemo<SelectedIntentAddress | null>(
-    () =>
-      intentData
-        ? selectIntentAddress(
-            intentData,
-            originTokenBalancesData,
-            destinationTokenBalancesData,
-            originIntentAddressForBalances,
-            destinationIntentAddressForBalances,
-          )
-        : null,
-    [
-      intentData,
-      originTokenBalancesData,
-      destinationTokenBalancesData,
-      originIntentAddressForBalances,
-      destinationIntentAddressForBalances,
-    ],
-  )
-
-  const hasIntentBalance = useMemo<boolean>(
-    () =>
-      checkAnyIntentBalance(
-        originTokenBalancesData,
-        destinationTokenBalancesData,
-      ),
-    [originTokenBalancesData, destinationTokenBalancesData],
-  )
-
-  const recoverToken = useMemo<Token | null>(
-    () => findRecoverToken(selectedIntentAddress),
-    [selectedIntentAddress],
-  )
-
-  // Get refund address
-  const effectiveRefundAddress = useMemo<`0x${string}` | null>(() => {
-    const address =
-      refundToAddress || (walletClient?.account?.address as `0x${string}`)
-    if (!address || Address.isEqual(address, zeroAddress)) {
-      return null
-    }
-    return address
-  }, [refundToAddress, walletClient?.account?.address])
-
-  const signPayloadCallback = useCallback(async (): Promise<{
-    signature: string
-    payload: Payload.Calls
-    refundCall: Payload.Call
-  }> => {
-    if (!intentData || !walletClient || !walletClient.account) {
-      throw new Error("Intent data and wallet client with account required")
-    }
-
-    await checkProviderHealth(walletClient)
-    validateRefundAddress(effectiveRefundAddress)
-
-    if (!selectedIntentAddress) {
-      throw new Error("No intent address selected for recovery")
-    }
-
-    const allCalls = mapTransactionCalls(intentData)
-    const calls = filterCallsByChainId(allCalls, selectedIntentAddress.chainId)
-
-    if (calls.length === 0) {
-      throw new Error("No calls found for the selected intent address")
-    }
-
-    const refundCall = determineRefundCall(
-      selectedIntentAddress.tokenBalancesData,
-      effectiveRefundAddress,
-    )
-
-    const chainId = selectedIntentAddress.chainId
-    if (!chainId) {
-      throw new Error("Chain ID not found for selected intent address")
-    }
-
-    await attemptSwitchChain({
-      walletClient,
-      desiredChainId: Number(chainId),
-    })
-
-    const intentAddress = selectedIntentAddress.intentAddress
-    const payload = createRefundPayload(
-      refundCall,
-      BigInt(calls[0]?.nonce ?? 0),
-    )
-
-    await checkProviderHealth(walletClient)
-
-    const typedData = Payload.toTyped(intentAddress, chainId, payload)
-
-    const signature = await signWithTimeout(
-      walletClient.signTypedData({
-        account: walletClient.account,
-        ...typedData,
-      }),
-      "Recovery signature",
-    )
-
-    return {
-      signature,
-      payload,
-      refundCall,
-    }
-  }, [intentData, walletClient, selectedIntentAddress, effectiveRefundAddress])
-
-  const signPayload = signPayloadCallback
-
-  const getRecoverTx = useCallback(
-    async (params: {
-      signedHash: string
-      payload: Payload.Calls
-    }): Promise<{
-      to: `0x${string}`
-      data: `0x${string}`
-      chainId: number
-      chain: Chain
-    }> => {
-      if (!intentData || !walletClient?.account) {
-        throw new Error("Intent data and wallet client with account required")
-      }
-      if (!selectedIntentAddress) {
-        throw new Error("No intent address selected for recovery")
-      }
-
-      if (!intentData.intentProtocolVersion) {
-        logger.console.log(
-          "[recover] Intent configuration version not found, using V1",
-        )
-      }
-
-      return buildRecoverTxFromSignature({
-        trailsClient,
-        intentData,
-        mainSigner: Address.from(walletClient.account.address),
-        selected: selectedIntentAddress,
-        effectiveRefundAddress: effectiveRefundAddress!,
-        signature: params.signedHash,
-        payload: params.payload,
-      })
-    },
-    [
-      intentData,
-      walletClient,
-      selectedIntentAddress,
-      effectiveRefundAddress,
-      trailsClient,
-    ],
-  )
-
-  const recover = useCallback(async (): Promise<{
-    txHash: `0x${string}`
-  }> => {
-    if (!walletClient || !walletClient.account) {
-      throw new Error("Wallet client with account is required for recovery")
-    }
-    if (!intentData) {
-      throw new Error("Intent data is required for recovery")
-    }
-
-    const { signature, payload } = await signPayload()
-    const recoverTx = await getRecoverTx({
-      signedHash: signature,
-      payload,
-    })
-
-    await attemptSwitchChain({
-      walletClient,
-      desiredChainId: Number(recoverTx.chainId),
-    })
-
-    const txHash = await sendWalletTransaction(walletClient, {
-      account: walletClient.account,
-      to: recoverTx.to,
-      data: recoverTx.data,
-      chain: recoverTx.chain,
-    })
-
-    const publicClient = getChainRpcClient(recoverTx.chainId)
-    await publicClient.waitForTransactionReceipt({
-      hash: txHash,
-    })
-
-    if (intentData.intentId && trailsClient) {
-      try {
-        await abortIntent(
-          trailsClient,
-          intentData.intentId,
-          recoverTx.chainId,
-          txHash,
-        )
-      } catch (error) {
-        logger.console.warn(
-          "[recover] Failed to abort intent after recovery (non-fatal):",
-          error,
-        )
-      }
-    }
-
-    return { txHash }
-  }, [walletClient, intentData, signPayload, getRecoverTx, trailsClient])
-
-  const getRecoverStatus = useCallback(
-    (params: { txHash: `0x${string}`; chainId: number }) =>
-      getRecoverStatusFromChain(params),
-    [],
-  )
-
-  const selectedRecoveryTarget = useMemo(
-    () => buildSelectedRecoveryTarget(selectedIntentAddress),
-    [selectedIntentAddress],
-  )
-
-  return {
-    intent: intentData,
-    hasIntentBalance,
-    recoverToken,
-    selectedRecoveryTarget,
-    refetchIntent: () => {}, // No-op since intent is passed in
-    signPayload,
-    getRecoverTx,
-    recover,
-    getRecoverStatus,
-  }
-}