Types

interface WalletInfo {
  credentialId: string;         // WebAuthn credential ID (base64)
  passkeyPubkey: number[];      // 33-byte compressed secp256r1 pubkey
  expo: string;
  platform: string;             // 'ios' | 'android' | …

  /** Vault PDA (base58) — the address funds live at. Show this to users. */
  smartWallet: string;

  /** Wallet metadata PDA (base58). Needed for raw LazorKitClient calls. */
  walletPda: string;

  /** Authority PDA (base58) tied to this passkey credential. */
  walletDevice: string;
}

interface WalletConfig {
  portalUrl: string;
  configPaymaster: { paymasterUrl: string; apiKey?: string };
  rpcUrl?: string;
  rpId?: string;
}

interface LazorKitProviderProps {
  rpcUrl?: string;
  portalUrl?: string;
  configPaymaster?: { paymasterUrl: string; apiKey?: string };
  rpId?: string;
  isDebug?: boolean;
  children: ReactNode;
}

interface SignOptions {
  redirectUrl: string;                    // your app deep-link scheme
  onSuccess?: (result: any) => void;
  onFail?: (error: Error) => void;
}

interface TxCallbacks {
  onSuccess?: (signature: string) => void;
  onFail?: (error: Error) => void;
}

interface TransactionOptions {
  feeToken?: string;                                       // SPL mint base58
  addressLookupTableAccounts?: AddressLookupTableAccount[];
  computeUnitLimit?: number;
  clusterSimulation?: 'devnet' | 'mainnet';
}

interface SignAndSendTransactionPayload {
  instructions: TransactionInstruction[];
  transactionOptions?: TransactionOptions;
}

interface AuthorizeExecutePayload extends SignAndSendTransactionPayload {
  expiryOffset?: number;                  // slots; default 300 ≈ 2 min
}

// For `authorizeDeferred` — TX1 only, returns payload for later TX2.
interface AuthorizePayload {
  instructions: TransactionInstruction[];
  expiryOffset?: number;                  // slots; default 300 ≈ 2 min
  transactionOptions?: TransactionOptions;
}

// Returned from `authorizeDeferred`.
interface AuthorizeResult {
  signature: string;                      // TX1 signature
  deferredPayload: DeferredPayload;       // feed to executeDeferred later
  deferredExecPda: PublicKey;
  counter: number;
}

// For `executeDeferred` — TX2 only.
interface ExecuteDeferredPayload {
  deferredPayload: DeferredPayload;
  refundDestination?: PublicKey;          // where TX2's DeferredExec rent lands
  transactionOptions?: TransactionOptions;
}

// For `reclaimDeferred` — cleanup path.
interface ReclaimDeferredPayload {
  deferredExecPda: PublicKey;
  refundDestination?: PublicKey;
}

interface SessionSignPayload {
  sessionKeypair: Keypair;                // Ed25519 keypair from createSession
  sessionPda: PublicKey;
  instructions: TransactionInstruction[];
  transactionOptions?: TransactionOptions;
}

// Internal shape produced by authorize*/used by executeDeferred. Re-exported from
// the SDK so you can persist it across sessions / machines via the wire helpers.
interface DeferredPayload {
  walletPda: PublicKey;
  deferredExecPda: PublicKey;
  compactInstructions: {
    programIdIndex: number;
    accountIndexes: number[];
    data: Uint8Array;
  }[];
  remainingAccounts: {
    pubkey: PublicKey;
    isSigner: boolean;
    isWritable: boolean;
  }[];
}

// Wire helpers (JSON-safe strings) for cross-machine deferred flows.
serializeDeferredPayload(p: DeferredPayload): string;
deserializeDeferredPayload(s: string): DeferredPayload;

interface TransferSolPayload {
  recipient: PublicKey;
  lamports: bigint | number;
  transactionOptions?: TransactionOptions;
}

interface CreateSessionPayload {
  sessionKey: PublicKey;                  // fresh Ed25519 public key
  expiresAtSlot: bigint;                  // absolute slot
  actions?: SessionAction[];              // optional on-chain policy
}

interface RevokeSessionPayload {
  sessionPda: PublicKey;
  refundDestination?: PublicKey;          // default: paymaster fee payer
}

interface AddAuthorityPayload {
  newEd25519Pubkey: PublicKey;
  role?: number;                          // ROLE_ADMIN (1) | ROLE_SPENDER (2 — default)
}

interface RemoveAuthorityPayload {
  targetAuthorityPda: PublicKey;
  refundDestination?: PublicKey;
}

interface AuthorityEntry {
  authorityPda: PublicKey;
  authorityType: number;                  // 0 = ed25519, 1 = secp256r1
  role: number;                           // 0 = owner, 1 = admin, 2 = spender
  credential: Uint8Array;                 // 32 bytes
  secp256r1Pubkey?: Uint8Array;           // 33 bytes, secp256r1 only
}

type ListAuthoritiesResult = AuthorityEntry[];

import { Actions } from '@lazorkit/wallet-mobile-adapter';

// SOL
Actions.solLimit(remainingLamports, expiresAt?)
Actions.solRecurringLimit({ limit, window, expiresAt? })
Actions.solMaxPerTx(maxLamports, expiresAt?)

// SPL tokens
Actions.tokenLimit({ mint, remaining, expiresAt? })
Actions.tokenRecurringLimit({ mint, limit, window, expiresAt? })
Actions.tokenMaxPerTx({ mint, max, expiresAt? })

// CPI filters
Actions.programWhitelist(programId, expiresAt?)
Actions.programBlacklist(programId, expiresAt?)

enum SessionActionType {
  SolLimit            = 1,
  SolRecurringLimit   = 2,
  SolMaxPerTx         = 3,
  TokenLimit          = 4,
  TokenRecurringLimit = 5,
  TokenMaxPerTx       = 6,
  ProgramWhitelist    = 10,
  ProgramBlacklist    = 11,
}

type SessionAction =
  | { type: SessionActionType.SolLimit; remaining: bigint; expiresAt?: bigint }
  | { type: SessionActionType.SolRecurringLimit; limit: bigint; window: bigint; expiresAt?: bigint }
  | { type: SessionActionType.SolMaxPerTx; max: bigint; expiresAt?: bigint }
  | { type: SessionActionType.TokenLimit; mint: PublicKey; remaining: bigint; expiresAt?: bigint }
  | { type: SessionActionType.TokenRecurringLimit; mint: PublicKey; limit: bigint; window: bigint; expiresAt?: bigint }
  | { type: SessionActionType.TokenMaxPerTx; mint: PublicKey; max: bigint; expiresAt?: bigint }
  | { type: SessionActionType.ProgramWhitelist; programId: PublicKey; expiresAt?: bigint }
  | { type: SessionActionType.ProgramBlacklist; programId: PublicKey; expiresAt?: bigint };

export const ROLE_OWNER   = 0;   // can transfer ownership
export const ROLE_ADMIN   = 1;   // manage authorities + sessions
export const ROLE_SPENDER = 2;   // execute only

export const AUTH_TYPE_ED25519   = 0;
export const AUTH_TYPE_SECP256R1 = 1;

class LazorKitError extends Error {
  code?: string;                  // e.g. 'WALLET_CONNECTION_ERROR' | 'SIGNING_ERROR'
}
class WalletConnectionError extends LazorKitError { /* code: WALLET_CONNECTION_ERROR */ }
class SigningError          extends LazorKitError { /* code: SIGNING_ERROR */ }