Types

interface CavosConfig {
  appId: string;                        // Required: App ID from https://cavos.xyz/dashboard
  network?: 'sepolia' | 'mainnet';      // Default: 'sepolia'
  paymasterApiKey?: string;             // Cavos Paymaster API key
  paymasterUrl?: string;                // Custom paymaster endpoint URL
  starknetRpcUrl?: string;              // Custom Starknet RPC URL
  backendUrl?: string;                  // Default: 'https://cavos.xyz'
  enableLogging?: boolean;              // Default: false
  session?: SessionConfig;
  oauthWallet?: Partial<OAuthWalletConfig>;
}

interface SessionConfig {
  sessionDuration?: number;         // Seconds (default: 86400 = 24h)
  renewalGracePeriod?: number;      // Seconds (default: 172800 = 48h)
  defaultPolicy?: SessionKeyPolicy;
}

interface OAuthWalletConfig {
  jwksRegistryAddress: string;      // JWKS Registry contract address
  cavosAccountClassHash: string;    // Account contract class hash
  salt?: string;                    // Address derivation salt (default: '0x0')
}

interface CavosModalConfig {
  appName?: string;
  appLogo?: string;
  providers?: ('google' | 'apple' | 'email')[];
  primaryColor?: string;
  theme?: 'light' | 'dark';        // Default: 'light'
  onSuccess?: (address: string) => void;
}

type LoginProvider = 'google' | 'apple';

interface UserInfo {
  id: string;       // Composite: '{iss}:{sub}'
  email: string;
  name: string;
  picture: string;
}

interface SessionKeyPolicy {
  allowedContracts: string[];   // Contract addresses the session key may call
  spendingLimits: Array<{
    token: string;              // ERC-20 contract address
    limit: bigint;              // Max transferable amount in token base units (MUST be bigint)
  }>;
  maxCallsPerTx: number;        // Max calls per multicall transaction
}

interface WalletStatus {
  isDeploying: boolean;           // Account contract is currently being deployed
  isDeployed: boolean;            // Account contract exists on-chain
  isRegistering: boolean;         // Session key is currently being registered on-chain
  isSessionActive: boolean;       // Session key is registered and not expired
  isReady: boolean;               // Fully set up — deployed + session active
  pendingDeployTxHash?: string;   // Deploy tx hash when confirmation timed out
}

interface Call {
  contractAddress: string;  // Contract to call
  entrypoint: string;       // Function name
  calldata?: string[];      // Function arguments (as hex strings or decimal strings)
}

// Transfer 1 STRK (1 × 10^18)
const calldata = [
  recipientAddress,
  '1000000000000000000', // low  (fits in felt252)
  '0',                    // high
];

interface TypedData {
  types: {
    StarknetDomain?: TypeElement[];
    [key: string]: TypeElement[] | undefined;
  };
  primaryType: string;
  domain: Record<string, unknown>;
  message: Record<string, unknown>;
}

interface TypeElement {
  name: string;
  type: string;
}

class JwtExpiredError extends Error {
  readonly code = 'JWT_EXPIRED';
}

import { JwtExpiredError } from '@cavos/react';

try {
  await execute(calls);
} catch (err) {
  if (err instanceof JwtExpiredError) {
    await login('google');
  }
}

interface CavosContextValue {
  // --- SDK instance ---
  cavos: CavosSDK;

  // --- State ---
  isAuthenticated: boolean;
  user: UserInfo | null;
  address: string | null;
  hasActiveSession: boolean;
  isLoading: boolean;
  walletStatus: WalletStatus;
  sessionPublicKey: string | null;

  // --- Auth ---
  login: (provider: LoginProvider) => Promise<void>;
  sendMagicLink: (email: string) => Promise<void>;
  logout: () => Promise<void>;

  // --- Transactions ---
  execute: (calls: Call | Call[], options?: { gasless?: boolean }) => Promise<string>;
  signMessage: (typedData: TypedData) => Promise<string[]>;

  // --- Session ---
  registerCurrentSession: () => Promise<string>;
  updateSessionPolicy: (policy: SessionKeyPolicy) => void;
  renewSession: () => Promise<string>;
  revokeSession: (sessionKey: string) => Promise<string>;
  emergencyRevokeAllSessions: () => Promise<string>;
  exportSession: () => string;

  // --- Account ---
  isAccountDeployed: () => Promise<boolean>;
  deployAccount: () => Promise<string>;
  getBalance: () => Promise<string>;
  getAssociatedWallets: () => Promise<{ address: string; name?: string }[]>;
  switchWallet: (name?: string) => Promise<void>;

  // --- Modal ---
  openModal: () => void;
  closeModal: () => void;

  // --- Utilities ---
  getOnramp: (provider: OnrampProvider) => string;
  resendVerificationEmail: (email: string) => Promise<void>;
}