0xtrails 0.7.0 → 0.8.0

package/src/refund.ts

@@ -0,0 +1,914 @@
+import type { IntentCalls } from "@0xtrails/api"
+import {
+  Config,
+  Constants,
+  Erc6492,
+  Payload,
+  Signature,
+} from "@0xsequence/wallet-primitives"
+import { Address, Bytes, Hex } from "ox"
+import { AbiFunction } from "ox"
+import { SEQUENCE_V3_CONTRACT_ADDRESSES } from "./constants.js"
+import { calculateIntentAddress, createIntentConfiguration } from "./intents.js"
+import { getChainRpcClient, getChainInfo } from "./chains.js"
+import { logger } from "./logger.js"
+import type { WalletClient, Chain } from "viem"
+import { splitSignature } from "./gasless.js"
+import { useMemo, useCallback } from "react"
+import { useGetIntent } from "./widget/hooks/useGetIntent.js"
+import { useTokenBalances } from "./tokenBalances.js"
+import { getERC20TransferData } from "./encoders.js"
+import { zeroAddress } from "viem"
+import type { Payload as WalletPayload } from "@0xsequence/wallet-primitives"
+import { attemptSwitchChain } from "./chainSwitch.js"
+
+// Constants for execute function
+type ChainId = number
+
+/**
+ * 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: ChainId,
+): 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,
+  }
+}
+
+export interface BuildRefundTransactionParams {
+  mainSigner: Address.Address
+  calls: Array<IntentCalls>
+  refundCall: Payload.Call
+  chainId: ChainId
+  intentAddress: Address.Address
+  walletClient: WalletClient
+}
+
+export interface BuildRefundTransactionWithSignatureParams {
+  mainSigner: Address.Address
+  calls: Array<IntentCalls>
+  payload: Payload.Calls // The payload that was signed
+  chainId: ChainId
+  intentAddress: Address.Address
+  signature: string // Hex string signature
+}
+
+/**
+ * Signs the payload hash for a refund transaction
+ */
+export async function signPayload(
+  walletClient: WalletClient,
+  intentAddress: Address.Address,
+  chainId: ChainId,
+  payload: Payload.Calls,
+): Promise<string> {
+  if (!walletClient.account) {
+    throw new Error("Wallet client account is required for signing")
+  }
+
+  const typedData = Payload.toTyped(intentAddress, chainId, payload)
+
+  const signature = await walletClient.signTypedData({
+    account: walletClient.account,
+    ...typedData,
+  })
+
+  logger.console.log("[refund] Signature received:", signature)
+  return signature
+}
+
+/**
+ * Builds a refund transaction using a pre-signed hash
+ */
+export async function buildRefundTransactionWithSignature(
+  params: BuildRefundTransactionWithSignatureParams,
+): Promise<{ to: `0x${string}`; data: Hex.Hex }> {
+  const { mainSigner, calls, payload, chainId, intentAddress, signature } =
+    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(),
+        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(),
+    },
+  )
+
+  // Filter calls to only include origin calls (matching chainId)
+  // The intentAddress is the originIntentAddress, so we should only use origin calls
+  // when calculating the intent configuration and address
+  const originCalls = calls.filter((c) => {
+    const callChainId =
+      typeof c.chainId === "bigint" ? c.chainId : BigInt(String(c.chainId))
+    return callChainId === BigInt(chainId)
+  })
+  logger.console.log("[refund] Filtered origin calls:", {
+    originalCallsCount: calls.length,
+    originCallsCount: originCalls.length,
+    chainId,
+  })
+
+  const intentConfig = createIntentConfiguration(mainSigner, originCalls)
+  logger.console.log("[refund] Intent configuration created:", {
+    threshold: intentConfig.threshold.toString(),
+    checkpoint: intentConfig.checkpoint.toString(),
+    topology: Array.isArray(intentConfig.topology)
+      ? `Node with ${intentConfig.topology.length} items`
+      : "SignerLeaf",
+  })
+
+  const context = SEQUENCE_V3_CONTRACT_ADDRESSES
+  const imageHash = Config.hashConfiguration(intentConfig)
+  logger.console.log("[refund] Image hash:", Hex.fromBytes(imageHash))
+  // See if the derived intent address is correct
+  const derivedConfigurationAddress = calculateIntentAddress(
+    mainSigner,
+    originCalls,
+  )
+  logger.console.log(
+    "[refund] Derived configuration address:",
+    derivedConfigurationAddress,
+  )
+  if (!Address.isEqual(derivedConfigurationAddress, intentAddress)) {
+    throw new Error(
+      "Derived configuration 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,
+    })
+
+    // 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: Hex.fromBytes(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:", encodedDeployPayload)
+
+    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
+  }
+}
+
+/**
+ * Builds a refund transaction for a given intent configuration
+ * @param params - Object containing:
+ *   - mainSigner: The main signer address
+ *   - calls: Array of intent calls used to create the original intent configuration
+ *   - refundCall: The refund call to execute
+ *   - chainId: The chain ID where the refund transaction will be executed
+ *   - intentAddress: The intent address from the API response
+ *   - walletClient: The wallet client to sign the payload hash
+ * @returns Promise resolving to transaction object with `to` address and `data` hex string
+ */
+export async function buildRefundTransaction(
+  params: BuildRefundTransactionParams,
+): Promise<{ to: `0x${string}`; data: Hex.Hex }> {
+  const {
+    mainSigner,
+    calls,
+    refundCall,
+    chainId,
+    intentAddress,
+    walletClient,
+  } = params
+
+  logger.console.log("[refund] buildRefundTransaction called with params:", {
+    mainSigner,
+    callsCount: calls.length,
+    refundCall: {
+      to: refundCall.to,
+      value: refundCall.value.toString(),
+      data: refundCall.data,
+      gasLimit: refundCall.gasLimit.toString(),
+    },
+    chainId,
+    intentAddress,
+  })
+
+  // Create payload with random space and calculate hash for signing
+  const payload = createRefundPayload(refundCall, BigInt(calls[0]?.nonce ?? 0))
+
+  // Sign the payload hash
+  const signature = await signPayload(
+    walletClient,
+    intentAddress,
+    chainId,
+    payload,
+  )
+
+  // Build transaction with signature using the payload that was signed
+  return buildRefundTransactionWithSignature({
+    mainSigner,
+    calls,
+    payload,
+    chainId,
+    intentAddress,
+    signature,
+  })
+}
+
+/**
+ * Determines the refund call based on token balances at the intent address
+ */
+export function determineRefundCall(
+  tokenBalancesData:
+    | {
+        nativeBalances?: Array<{ balance?: string; chainId?: number }>
+        balances?: Array<{
+          balance?: string
+          contractAddress?: string
+          contractInfo?: { decimals?: number; chainId?: number }
+        }>
+      }
+    | 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 native token balances
+  if (tokenBalancesData?.nativeBalances) {
+    for (const nativeBalance of tokenBalancesData.nativeBalances) {
+      const balance = BigInt(nativeBalance.balance || "0")
+      if (balance > 0n) {
+        if (!highestBalanceToken || balance > highestBalanceToken.balance) {
+          highestBalanceToken = {
+            type: "native",
+            balance,
+            chainId: nativeBalance.chainId,
+          }
+        }
+      }
+    }
+  }
+
+  // Check ERC20 token balances
+  if (tokenBalancesData?.balances) {
+    for (const tokenBalance of tokenBalancesData.balances) {
+      const balance = BigInt(tokenBalance.balance || "0")
+      if (balance > 0n) {
+        if (!highestBalanceToken || balance > highestBalanceToken.balance) {
+          highestBalanceToken = {
+            type: "erc20",
+            balance,
+            tokenAddress: tokenBalance.contractAddress,
+            decimals: tokenBalance.contractInfo?.decimals,
+            chainId: tokenBalance.contractInfo?.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
+    const transferData = getERC20TransferData({
+      recipient: refundToAddress,
+      amount: 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",
+    }
+  }
+}
+
+export interface UseTrailsRefundParams {
+  intentId: string | undefined
+  walletClient: WalletClient | undefined
+  refundToAddress?: `0x${string}`
+}
+
+export interface UseTrailsRefundReturn {
+  intent: any | null
+  isLoadingIntent: boolean
+  isLoadingBalances: boolean
+  intentError: Error | null
+  balancesError: Error | null
+  hasIntentBalance: boolean
+  refetchIntent: () => void
+  signPayload: () => Promise<{
+    signature: string
+    payload: Payload.Calls
+    refundCall: Payload.Call
+  }>
+  getRefundTx: (params: {
+    signedHash: string
+    payload: Payload.Calls
+  }) => Promise<{
+    to: `0x${string}`
+    data: `0x${string}`
+    chainId: number
+    chain: Chain
+  }>
+}
+
+/**
+ * Hook for building and signing refund transactions
+ * @example
+ * ```tsx
+ * const { signPayload, getRefundTx } = useTrailsRefund({
+ *   intentId: "0x...",
+ *   walletClient: walletClient,
+ * })
+ *
+ * const signedHash = await signRefund()
+ * const refundTx = await getRefundTx({ signedHash })
+ * await walletClient.sendTransaction(refundTx)
+ * ```
+ */
+export function useTrailsRefund({
+  intentId,
+  walletClient,
+  refundToAddress,
+}: UseTrailsRefundParams): UseTrailsRefundReturn {
+  const {
+    intent: intentData,
+    isLoading: isLoadingIntent,
+    error: intentError,
+    refetch: refetchIntent,
+  } = useGetIntent({
+    intentId,
+    enabled: !!intentId,
+  })
+
+  // Get token balances for the intent address
+  const intentAddressForBalances = useMemo<Address.Address | null>(() => {
+    if (!intentData?.originIntentAddress) return null
+    return Address.from(intentData.originIntentAddress)
+  }, [intentData?.originIntentAddress])
+
+  const {
+    tokenBalancesData,
+    isLoadingBalances,
+    balanceError: balancesError,
+  } = useTokenBalances(intentAddressForBalances)
+
+  // Check if intent address has any balance (native or ERC20)
+  const hasIntentBalance = useMemo<boolean>(() => {
+    if (!tokenBalancesData) return false
+
+    // Check native token balances
+    if (tokenBalancesData.nativeBalances) {
+      for (const nativeBalance of tokenBalancesData.nativeBalances) {
+        const balance = BigInt(nativeBalance.balance || "0")
+        if (balance > 0n) {
+          return true
+        }
+      }
+    }
+
+    // Check ERC20 token balances
+    if (tokenBalancesData.balances) {
+      for (const tokenBalance of tokenBalancesData.balances) {
+        const balance = BigInt(tokenBalance.balance || "0")
+        if (balance > 0n) {
+          return true
+        }
+      }
+    }
+
+    return false
+  }, [tokenBalancesData])
+
+  // Get refund address (use walletClient account or provided address)
+  // Don't throw during render - validate when methods are called
+  const effectiveRefundAddress = useMemo<`0x${string}` | null>(() => {
+    const address =
+      refundToAddress || (walletClient?.account?.address as `0x${string}`)
+    if (!address || Address.isEqual(address, zeroAddress)) {
+      return null // Will be validated when used
+    }
+    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")
+    }
+
+    // Validate refund address
+    if (!effectiveRefundAddress) {
+      throw new Error(
+        "Refund address is required. Provide refundToAddress or connect a wallet with a valid address",
+      )
+    }
+    if (Address.isEqual(effectiveRefundAddress, zeroAddress)) {
+      throw new Error("Refund address cannot be zero address")
+    }
+
+    // Build calls array
+    const calls: IntentCalls[] = []
+    if (intentData.originCalls) {
+      calls.push({
+        chainId: intentData.originCalls.chainId,
+        space: intentData.originCalls.space,
+        nonce: intentData.originCalls.nonce,
+        calls: intentData.originCalls.calls.map((call: any) => ({
+          to: call.to,
+          value: call.value,
+          data: call.data,
+          gasLimit: call.gasLimit,
+          delegateCall: call.delegateCall,
+          onlyFallback: call.onlyFallback,
+          behaviorOnError: call.behaviorOnError,
+        })),
+      })
+    }
+    if (intentData.destinationCalls) {
+      calls.push({
+        chainId: intentData.destinationCalls.chainId,
+        space: intentData.destinationCalls.space,
+        nonce: intentData.destinationCalls.nonce,
+        calls: intentData.destinationCalls.calls.map((call: any) => ({
+          to: call.to,
+          value: call.value,
+          data: call.data,
+          gasLimit: call.gasLimit,
+          delegateCall: call.delegateCall,
+          onlyFallback: call.onlyFallback,
+          behaviorOnError: call.behaviorOnError,
+        })),
+      })
+    }
+
+    // Determine refund call from token balances
+    const refundCall = determineRefundCall(
+      tokenBalancesData,
+      effectiveRefundAddress,
+    )
+
+    // Get chain ID from origin calls (this is the chain where the refund should execute)
+    const chainId = intentData.originCalls?.chainId
+    if (!chainId) {
+      throw new Error("Chain ID not found in origin calls")
+    }
+    logger.console.log("[refund] Using chain ID from origin calls:", chainId)
+
+    // Switch to the correct chain before signing
+    if (walletClient) {
+      try {
+        await attemptSwitchChain({
+          walletClient,
+          desiredChainId: Number(chainId),
+        })
+        logger.console.log("[refund] Successfully switched to chain:", chainId)
+      } catch (error) {
+        logger.console.error(
+          "[refund] Failed to switch chain before signing:",
+          error,
+        )
+        throw new Error(
+          `Failed to switch to chain ${chainId}: ${error instanceof Error ? error.message : "Unknown error"}`,
+        )
+      }
+    }
+
+    // Get intent address (needed for buildRefundTransactionWithSignature)
+    if (!intentData.originIntentAddress) {
+      throw new Error("Intent data missing originIntentAddress")
+    }
+    const intentAddress = Address.from(intentData.originIntentAddress)
+
+    // Create payload with random space and calculate hash for signing
+    const payload = createRefundPayload(
+      refundCall,
+      BigInt(calls[0]?.nonce ?? 0),
+    )
+
+    // Sign the hash - call the function directly to avoid circular import
+    if (!walletClient.account) {
+      throw new Error("Wallet client account is required for signing")
+    }
+    const typedData = Payload.toTyped(intentAddress, chainId, payload)
+    const signature = await walletClient.signTypedData({
+      account: walletClient.account,
+      ...typedData,
+    })
+    logger.console.log("[refund] Signature received:", signature)
+    return {
+      signature,
+      payload,
+      refundCall,
+    }
+  }, [intentData, walletClient, tokenBalancesData, effectiveRefundAddress])
+
+  // Export as signPayload for the hook return
+  const signPayload = signPayloadCallback
+
+  const getRefundTx = 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")
+      }
+
+      // Validate refund address
+      if (!effectiveRefundAddress) {
+        throw new Error(
+          "Refund address is required. Provide refundToAddress or connect a wallet with a valid address",
+        )
+      }
+      if (Address.isEqual(effectiveRefundAddress, zeroAddress)) {
+        throw new Error("Refund address cannot be zero address")
+      }
+
+      // Build calls array (needed for intent configuration)
+      const calls: IntentCalls[] = []
+      if (intentData.originCalls) {
+        calls.push({
+          chainId: intentData.originCalls.chainId,
+          space: intentData.originCalls.space,
+          nonce: intentData.originCalls.nonce,
+          calls: intentData.originCalls.calls.map((call: any) => ({
+            to: call.to,
+            value: call.value,
+            data: call.data,
+            gasLimit: call.gasLimit,
+            delegateCall: call.delegateCall,
+            onlyFallback: call.onlyFallback,
+            behaviorOnError: call.behaviorOnError,
+          })),
+        })
+      }
+      if (intentData.destinationCalls) {
+        calls.push({
+          chainId: intentData.destinationCalls.chainId,
+          space: intentData.destinationCalls.space,
+          nonce: intentData.destinationCalls.nonce,
+          calls: intentData.destinationCalls.calls.map((call: any) => ({
+            to: call.to,
+            value: call.value,
+            data: call.data,
+            gasLimit: call.gasLimit,
+            delegateCall: call.delegateCall,
+            onlyFallback: call.onlyFallback,
+            behaviorOnError: call.behaviorOnError,
+          })),
+        })
+      }
+
+      // Use the refund call from the payload (passed from signPayload)
+      const refundCall = params.payload.calls[0]
+      if (!refundCall) {
+        throw new Error("Refund call not found in payload")
+      }
+
+      // Get chain ID from origin calls (this is the chain where the refund should execute)
+      const chainId = intentData.originCalls?.chainId
+      if (!chainId) {
+        throw new Error("Chain ID not found in origin calls")
+      }
+      logger.console.log("[refund] Using chain ID from origin calls:", chainId)
+
+      // Get intent address
+      if (!intentData.originIntentAddress) {
+        throw new Error("Intent data missing originIntentAddress")
+      }
+      const intentAddress = Address.from(intentData.originIntentAddress)
+
+      // Build transaction with signature using the payload passed from signPayload
+      const mainSigner = walletClient.account.address as Address.Address
+      const result = await buildRefundTransactionWithSignature({
+        mainSigner,
+        calls,
+        payload: params.payload,
+        chainId: Number(chainId),
+        intentAddress,
+        signature: params.signedHash,
+      })
+
+      // Final validation: ensure result "to" address is not zeroAddress
+      if (!result.to || Address.isEqual(result.to, zeroAddress)) {
+        throw new Error(
+          "Refund transaction 'to' address cannot be zero address",
+        )
+      }
+
+      // Get chain info for the transaction
+      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,
+      }
+    },
+    [intentData, walletClient, effectiveRefundAddress],
+  )
+
+  return {
+    intent: intentData,
+    isLoadingIntent,
+    isLoadingBalances,
+    intentError: intentError as Error | null,
+    balancesError: balancesError as Error | null,
+    hasIntentBalance,
+    refetchIntent,
+    signPayload,
+    getRefundTx,
+  }
+}