3. Sign Payload(s)

import {
  Address,
  createWalletClient,
  Hex,
  http,
  OneOf,
  publicActions,
  SignTypedDataParameters,
} from "viem";
import { privateKeyToAccount } from "viem/accounts";
import { base } from "viem/chains";

/**
 * Types for different signable payloads.
 */

// Payload for EIP-712 typed data signature (smart-account v2.2.1, permits)
type SignableTypedDataPayload = Omit<SignTypedDataParameters, "account">;

// Payload for personal message signing (legacy v2.1.0, eoa-7702)
type SignablePersonalMessagePayload = {
  message: {
    raw: Hex;
  };
};

// Union type for "simple" quote type payloads (can be either format)
type SignableSimplePayload = SignableTypedDataPayload | SignablePersonalMessagePayload;

// Payload for on-chain transaction signing
type SignableOnChainPayload =
  | {
      data: Hex;
      to: Address;
      chainId: number;
      value: string;
    }
  | {
      data: Hex;
      to: Address;
      chainId: number;
      value?: string | undefined;
    };

/**
 * Type guard to detect EIP-712 typed data payload.
 * v2.2.1 smart accounts use typed data, v2.1.0 uses personal message.
 */
function isTypedDataPayload(
  payload: SignableSimplePayload
): payload is SignableTypedDataPayload {
  return 'domain' in payload && 'primaryType' in payload;
}

/**
 * Example EOA account and wallet client setup.
 * Replace the private key with a real one for production use.
 */
const eoaAccount = privateKeyToAccount("0x"); // ⚠️ Replace with your private key

const walletClient = createWalletClient({
  account: eoaAccount,
  chain: base,
  transport: http(), // ⚠️ Use private paid RPC for production
}).extend(publicActions);

/**
 * Signs a "simple" quote payload. Handles both formats:
 * - EIP-712 typed data (v2.2.1 smart accounts)
 * - Personal message (v2.1.0 legacy accounts, eoa-7702)
 *
 * @param signablePayload - The payload to sign (auto-detected format).
 * @returns The signature as a Hex string.
 *
 * @example
 * // EIP-712 typed data (v2.2.1 smart account)
 * const signature = await signSimpleQuoteSignablePayload({
 *   domain: { name: "Nexus" },
 *   types: { MeeUserOp: [...], SuperTx: [{ name: "meeUserOps", type: "MeeUserOp[]" }] },
 *   primaryType: "SuperTx",
 *   message: { meeUserOps: [{ userOpHash: "0x...", lowerBoundTimestamp: 0, upperBoundTimestamp: 1765465749 }] }
 * });
 *
 * @example
 * // Personal message (v2.1.0 or eoa-7702)
 * const signature = await signSimpleQuoteSignablePayload({
 *   message: { raw: "0x68656c6c6f" }
 * });
 */
const signSimpleQuoteSignablePayload = async (
  signablePayload: SignableSimplePayload
): Promise<Hex> => {
  if (isTypedDataPayload(signablePayload)) {
    // EIP-712 typed data for v2.2.1 smart accounts
    return await walletClient.signTypedData({
      ...signablePayload,
      account: eoaAccount,
    });
  } else {
    // Personal message for v2.1.0 accounts or eoa-7702 mode
    return await eoaAccount.signMessage(signablePayload);
  }
};

/**
 * Signs a permit quote payload (EIP-712 typed data for ERC20 permits).
 *
 * @param signablePayload - The EIP-712 payload to sign.
 * @returns The signature as a Hex string.
 *
 * @example
 * const signature = await signPermitQuoteSignablePayload({
 *   domain: { ... },
 *   types: { ... },
 *   primaryType: "Permit",
 *   message: { ... }
 * });
 */
const signPermitQuoteSignablePayload = async (
  signablePayload: SignableTypedDataPayload
): Promise<Hex> => {
  const signature = await walletClient.signTypedData({
    ...signablePayload,
    account: eoaAccount,
  });
  return signature;
};

/**
 * Signs an on-chain quote payload (transaction).
 *
 * @param signablePayload - The transaction payload to send.
 * @returns The transaction hash as a Hex string.
 *
 * @example
 * const txHash = await signOnChainQuoteSignablePayload({
 *   to: "0x...",
 *   data: "0x...",
 *   value: "0",
 *   chainId: 1
 * });
 */
const signOnChainQuoteSignablePayload = async (
  signablePayload: SignableOnChainPayload
): Promise<Hex> => {
  const hash = await walletClient.sendTransaction({
    to: signablePayload.to,
    data: signablePayload.data,
    value: BigInt(signablePayload.value || "0")
  });
  // Wait for 5 confirmations before returning the hash
  await walletClient.waitForTransactionReceipt({ hash, confirmations: 5 });
  return hash;
};

/**
 * Union type for all supported payloads to sign.
 */
type PayloadToSign = OneOf<
  | {
      signablePayload: SignableSimplePayload;
      metadata?: any;
    }
  | {
      signablePayload: SignableTypedDataPayload;
      metadata: {
        nonce: string;
        name: string;
        version: string;
        domainSeparator: string;
        owner: string;
        spender: string;
        amount: string;
      };
    }
  | SignableOnChainPayload
>;

/**
 * Signs a quote payload based on its type.
 * Automatically handles both EIP-712 and personal message formats for "simple" type.
 *
 * @param quoteType - The type of quote from the API response.
 * @param payloadToSign - The payload to sign.
 * @returns The signature or transaction hash as a Hex string.
 *
 * @example
 * // Simple - EIP-712 (v2.2.1 smart account)
 * const sig = await signQuoteSignablePayload("simple", {
 *   signablePayload: { domain: { name: "Nexus" }, types: {...}, primaryType: "SuperTx", message: { meeUserOps: [...] } }
 * });
 *
 * @example
 * // Simple - Personal message (v2.1.0 or eoa-7702)
 * const sig = await signQuoteSignablePayload("simple", {
 *   signablePayload: { message: { raw: "0x68656c6c6f" } }
 * });
 *
 * @example
 * // Permit (EIP-712 for ERC20)
 * const sig = await signQuoteSignablePayload("permit", {
 *   signablePayload: { domain: {...}, types: {...}, primaryType: "Permit", message: {...} },
 *   metadata: { ... }
 * });
 *
 * @example
 * // On-chain transaction
 * const txHash = await signQuoteSignablePayload("onchain", {
 *   to: "0x...",
 *   data: "0x...",
 *   value: "0",
 *   chainId: 1
 * });
 */
const signQuoteSignablePayload = async (
  quoteType: string,
  payloadToSign: PayloadToSign
): Promise<Hex> => {
  let signature: Hex = "0x";

  switch (quoteType) {
    case "simple":
      // Auto-detects EIP-712 vs personal message format
      signature = await signSimpleQuoteSignablePayload(payloadToSign.signablePayload || payloadToSign);
      break;
    case "permit":
      signature = await signPermitQuoteSignablePayload(payloadToSign.signablePayload);
      break;
    case "onchain":
      signature = await signOnChainQuoteSignablePayload(payloadToSign);
      break;
    default:
      throw new Error("Unsupported quote type, can't sign the payload");
  }

  return signature;
};