Types

import {
  YieldType,
  LogLevel,
  DepositAuthMethod,
  WithdrawAuthMethod,
} from '@paxoslabs/amplify-sdk'

// Yield types (used as filters in vault discovery)
YieldType.CORE // Standard yield strategy
YieldType.TREASURY // Treasury-backed strategy
YieldType.FRONTIER // Higher-risk/reward strategy

// Deposit authorization methods
DepositAuthMethod.PERMIT // "permit" — EIP-2612 gasless signature
DepositAuthMethod.APPROVAL // "approval" — ERC-20 approve tx
DepositAuthMethod.ALREADY_APPROVED // "already_approved" — sufficient allowance

// Withdrawal authorization methods
WithdrawAuthMethod.APPROVAL // "approval" — vault share approve tx
WithdrawAuthMethod.ALREADY_APPROVED // "already_approved" — sufficient allowance

// Log levels
LogLevel.DEBUG // 0 - Verbose debugging
LogLevel.INFO // 1 - General information
LogLevel.WARN // 2 - Warnings
LogLevel.ERROR // 3 - Errors only (default)
LogLevel.NONE // 4 - Disable logging

import type {
  AmplifyVault,
  VaultContracts,
  VaultSLA,
  VaultSupportedAsset,
  VaultFilterOptions,
  GetVaultsByConfigParams,
} from '@paxoslabs/amplify-sdk'

interface AmplifyVault {
  id: string
  name: string
  chainId: number
  yieldType: YieldType
  inDeprecation: boolean
  vault: VaultContracts
  enterpriseConfig?: EnterpriseConfig
  sla?: VaultSLA
  supportedAssets: VaultSupportedAsset[]
}

interface EnterpriseConfig {
  predicatePolicyId: string | null
}

interface VaultSupportedAsset {
  address: Address
  symbol: string
  name: string
  decimals: number
  coinGeckoTokenId?: string
  depositable?: boolean
  withdrawable?: boolean
}

interface VaultContracts {
  boringVaultAddress: Address
  tellerAddress: Address
  accountantAddress: Address
  managerAddress: Address
  rolesAuthorityAddress: Address
  baseTokenAddress: Address
  baseTokenStandIn?: Address
  communityCodeDepositorAddress?: Address
  withdrawQueueAddress?: Address
}

interface VaultSLA {
  externalWithdrawalQueueDelaySLA: number
  externalAccountantRateUpdateSLA: number
}

interface VaultFilterOptions {
  chainId?: number
  yieldType?: YieldType
  depositTokenAddress?: Address
  withdrawAssetAddress?: Address
  settlementAssetAddress?: Address
}

interface GetVaultsByConfigParams {
  yieldType?: YieldType
  chainId?: number
  depositAssetAddress?: Address
  withdrawAssetAddress?: Address
  settlementAssetAddress?: Address
}

import type {
  SupportedAsset,
  WithdrawSupportedAsset,
  AssetFilterOptions,
} from '@paxoslabs/amplify-sdk'

interface SupportedAsset {
  address: Address
  symbol: string
  name: string
  decimals: number
  coinGeckoTokenId?: string
  chains: number[]
}

interface AssetFilterOptions {
  chains?: number[]
  yieldType?: YieldType
  address?: string
  symbol?: string
}

interface WithdrawSupportedAsset {
  address: Address
  symbol: string
  decimals: number
  vaults: Array<{
    id: string
    yieldType: YieldType
    chainId: number
    vaultId: string
  }>
}

import {
  isPermitAuth,
  isApprovalAuth,
  isAlreadyApprovedAuth,
  isWithdrawApprovalAuth,
  isWithdrawAlreadyApprovedAuth,
  isVaultNotFoundByAddressError,
  isVaultNotFoundByNameError,
} from '@paxoslabs/amplify-sdk'

const auth = await prepareDepositAuthorization(params)

if (isPermitAuth(auth)) {
  // TypeScript knows: auth.method === "permit"
  // auth.permitData is available
}

if (isApprovalAuth(auth)) {
  // TypeScript knows: auth.method === "approval"
  // auth.txData is available
}

if (isAlreadyApprovedAuth(auth)) {
  // TypeScript knows: auth.method === "already_approved"
  // auth.allowance is available
}

const withdrawAuth = await prepareWithdrawalAuthorization(params)

if (isWithdrawApprovalAuth(withdrawAuth)) {
  // withdrawAuth.txData is available
}

if (isWithdrawAlreadyApprovedAuth(withdrawAuth)) {
  // withdrawAuth.allowance is available
}

import type { SDKInitOptions, Logger } from '@paxoslabs/amplify-sdk'
import { LogLevel } from '@paxoslabs/amplify-sdk'

interface SDKInitOptions {
  /** Custom RPC URLs keyed by chain ID */
  rpcUrls?: Record<number, string>
  /** Enable/disable PostHog telemetry (default: true) */
  telemetry?: boolean
  /** Minimum log level (default: LogLevel.ERROR) */
  logLevel?: LogLevel
  /** Custom logger implementation */
  logger?: Logger
}

import type {
  PermitSignatureData,
  EIP712Domain,
  ParsedPermitSignature,
} from '@paxoslabs/amplify-sdk'

interface PermitSignatureData {
  /** User's wallet address (permit signer) */
  account: Address
  domain: EIP712Domain
  types: typeof PERMIT_TYPES
  message: {
    owner: Address
    spender: Address
    value: bigint
    nonce: bigint
    deadline: bigint
  }
  primaryType: 'Permit'
}

interface EIP712Domain {
  name: string
  version: string
  chainId: number
  verifyingContract: Address
  salt?: Hex
}

interface ParsedPermitSignature {
  v: number
  r: Hex
  s: Hex
}

// Address type (from viem)
type Address = `0x${string}`

// Flexible chain ID — accepts number or numeric string
type ChainId = number | `${number}`

import type { Logger } from '@paxoslabs/amplify-sdk'
import {
  setLogger,
  setLogLevel,
  getLogger,
  LogLevel,
} from '@paxoslabs/amplify-sdk'

// Implement for custom logging
interface Logger {
  debug(message: string, context?: Record<string, unknown>): void
  info(message: string, context?: Record<string, unknown>): void
  warn(message: string, context?: Record<string, unknown>): void
  error(message: string, context?: Record<string, unknown>): void
}

// Usage
setLogger({
  debug: (msg, ctx) => myLogger.debug(msg, ctx),
  info: (msg, ctx) => myLogger.info(msg, ctx),
  warn: (msg, ctx) => myLogger.warn(msg, ctx),
  error: (msg, ctx) => myLogger.error(msg, ctx),
})

setLogLevel(LogLevel.DEBUG) // Set minimum log level
const logger = getLogger() // Get current logger instance