Skip to main content
The deposit authorization system uses discriminated unions to represent the three possible authorization methods. Type guards are provided for TypeScript narrowing.

​
Import

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

​
DepositAuthMethod Enum

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]

​
Result Types

​
DepositAuthorizationResult (Discriminated Union)

export type DepositAuthorizationResult =
  | PermitAuthorizationResult
  | ApprovalAuthorizationResult
  | AlreadyApprovedAuthorizationResult

​
PermitAuthorizationResult

Returned when the token supports EIP-2612 permit signatures. 
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
    }
  }
}

​
ApprovalAuthorizationResult

Returned when an ERC20 approval transaction is needed. 
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]
  }
}

​
AlreadyApprovedAuthorizationResult

Returned when existing allowance is sufficient. 
interface AlreadyApprovedAuthorizationResult {
  method: 'already_approved'
  /** Current allowance (human-readable) */
  allowance: string
  /** Current allowance as BigInt string */
  allowanceAsBigInt: string
}

​
Type Guards

Use type guards for TypeScript narrowing: 
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}`)
}

​
Using Switch Statements

You can also use switch statements with the method discriminant: 
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
}