DepositAuthMethod

import {
  DepositAuthMethod,
  isPermitAuth,
  isApprovalAuth,
  isAlreadyApprovedAuth,
  type DepositAuthorizationResult,
  type PermitAuthorizationResult,
  type ApprovalAuthorizationResult,
  type AlreadyApprovedAuthorizationResult,
} from '@paxoslabs/amplify-sdk'

export const DepositAuthMethod = {
  PERMIT: 'permit', // EIP-2612 off-chain signature (gas efficient)
  APPROVAL: 'approval', // Traditional ERC20 approval (two transactions)
  ALREADY_APPROVED: 'already_approved', // Existing allowance sufficient
} as const

export type DepositAuthMethod =
  (typeof DepositAuthMethod)[keyof typeof DepositAuthMethod]

export type DepositAuthorizationResult =
  | PermitAuthorizationResult
  | ApprovalAuthorizationResult
  | AlreadyApprovedAuthorizationResult

interface PermitAuthorizationResult {
  method: 'permit'
  /** EIP-712 typed data ready for wallet signing */
  permitData: {
    /** User's wallet address (permit signer) */
    account: `0x${string}`
    domain: {
      name: string
      version: string
      chainId: number
      verifyingContract: `0x${string}`
    }
    types: {
      Permit: Array<{ name: string; type: string }>
    }
    primaryType: 'Permit'
    message: {
      owner: `0x${string}`
      spender: `0x${string}`
      value: bigint
      nonce: bigint
      deadline: bigint
    }
  }
}

interface ApprovalAuthorizationResult {
  method: 'approval'
  /** Transaction data for ERC20 approve() call */
  txData: {
    abi: typeof erc20Abi
    address: `0x${string}`
    functionName: 'approve'
    args: [`0x${string}`, bigint] // [spender, amount]
  }
}

interface AlreadyApprovedAuthorizationResult {
  method: 'already_approved'
  /** Current allowance (human-readable) */
  allowance: string
  /** Current allowance as BigInt string */
  allowanceAsBigInt: string
}

import {
  prepareDepositAuthorization,
  isPermitAuth,
  isApprovalAuth,
  isAlreadyApprovedAuth,
} from '@paxoslabs/amplify-sdk'

const auth = await prepareDepositAuthorization(params)

if (isPermitAuth(auth)) {
  // TypeScript knows: auth.method === "permit"
  // auth.permitData is fully typed
  const { domain, types, message } = auth.permitData

  const signature = await walletClient.signTypedData({
    account,
    domain,
    types,
    primaryType: 'Permit',
    message,
  })
}

if (isApprovalAuth(auth)) {
  // TypeScript knows: auth.method === "approval"
  // auth.txData is available with abi, address, functionName, args
  await walletClient.writeContract(auth.txData)
}

if (isAlreadyApprovedAuth(auth)) {
  // TypeScript knows: auth.method === "already_approved"
  // auth.allowance is available
  console.log(`Existing allowance: ${auth.allowance}`)
}

const auth = await prepareDepositAuthorization(params)

switch (auth.method) {
  case 'permit':
    // auth is narrowed to PermitAuthorizationResult
    const signature = await signTypedData(auth.permitData)
    break

  case 'approval':
    // auth is narrowed to ApprovalAuthorizationResult
    await writeContract(auth.txData)
    break

  case 'already_approved':
    // auth is narrowed to AlreadyApprovedAuthorizationResult
    console.log(`Allowance: ${auth.allowance}`)
    break
}