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;

  /** 1 = made before LazorKit v2, 2 = since. Absent on records saved before 2.0.0 (= v1). */
  protocolVersion?: 1 | 2;
}

interface WalletConfig {
  portalUrl: string;
  configPaymaster: { paymasterUrl: string; apiKey?: string };   // v2 wallets
  v1ConfigPaymaster?: { paymasterUrl: string; apiKey?: string }; // v1 wallets (2.0.0+)
  rpcUrl?: string;
  cluster?: 'mainnet' | 'devnet';                                // when rpcUrl does not say (2.0.0+)
  rpId?: string;
}

interface LazorKitProviderProps {
  rpcUrl?: string;
  portalUrl?: string;
  configPaymaster?: { paymasterUrl: string; apiKey?: string };
  v1ConfigPaymaster?: { paymasterUrl: string; apiKey?: string };
  cluster?: 'mainnet' | 'devnet';
  rpId?: string;
  isDebug?: boolean;
  children: ReactNode;
}

interface LazorKitProviderProps {
  // ...the props above, plus:
  onConfirmWallet?: OnConfirmWallet;      // default 'builtin'
  trustedAuthorities?: readonly string[]; // your own Ed25519 keys, base58
  watchMints?: readonly string[];         // SPL Token mints your app receives, base58
}

interface ConnectOptions {
  redirectUrl: string;
  confirmWallet?: string;                 // vault (or wallet PDA) the user chose
  onConfirmWallet?: OnConfirmWallet;      // overrides the provider's for this call
  onSuccess?: (wallet: WalletInfo) => void;
  onFail?: (error: Error) => void;
}

interface WalletChoice {
  wallet: string;                         // wallet PDA
  vault: string;                          // vault PDA — where the funds are. Show this one.
  version: 1 | 2;                         // 1 = made before LazorKit v2, not migrated yet
  lamports: number;                       // vault balance
  signatureCount: number;                 // 0 = not used with this passkey yet
  vaultIsSystemAccount: boolean;          // false: vault handed to another program
  otherAuthorities: {                     // every authority except this passkey's
    address: string;                      // the authority account
    type: 'passkey' | 'key';              // passkey = secp256r1, key = Ed25519
    role: 'owner' | 'admin' | 'spender' | 'unknown'; // 'spender' = Delegate
    key?: string;                         // 'key' only: the Ed25519 key
    sameRelyingParty?: boolean;           // 'passkey' only: same relying party
    trusted: boolean;                     // in trustedAuthorities; a passkey never is
  }[];
  liveSessions: {                         // sessions that can still sign
    address: string;
    sessionKey: string | null;            // null when unreadable
    approxExpiresAt: number | null;       // ms since the epoch (slots × 400 ms)
    trusted: boolean;
  }[];
  pendingDeferred: {                      // authorized, not yet run or expired. Never trusted.
    address: string;
    approxExpiresAt: number | null;
  }[];
  tokenGrants: {                          // rights over the vault's token accounts
    tokenAccount: string;
    tokenProgram: string;
    mint: string | null;
    kind: 'delegate' | 'closeAuthority' | 'owner' | 'unreadable';
    grantee: string | null;
    trusted: boolean;
  }[];
}

interface ConfirmWalletRequest {
  credentialId: string;
  candidates: WalletChoice[];
}

type ConfirmWalletHandler = (
  request: ConfirmWalletRequest,
) => Promise<{ wallet: string } | null> | { wallet: string } | null;

type OnConfirmWallet = ConfirmWalletHandler | 'builtin' | 'throw';

class WalletNeedsConfirmationError extends Error {      // onConfirmWallet: 'throw'
  readonly credentialId: string;
  readonly candidates: WalletChoice[];
}
class WalletConfirmationDeclinedError extends Error {}  // the user chose none; nothing saved
class PortalCancelledError extends LazorKitError {}     // code 'PORTAL_CANCELLED'
class WalletChooserNotShownError extends LazorKitError {} // code 'WALLET_CHOOSER_NOT_SHOWN' (iOS)

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

interface DisconnectOptions {
  onSuccess?: () => 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 after TX1, 10–9000; default 1500
}

// For `authorizeDeferred` — TX1 only, returns payload for later TX2.
interface AuthorizePayload {
  instructions: TransactionInstruction[];
  expiryOffset?: number;                  // slots after TX1, 10–9000; default 1500
  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;          // leave unset: the program accepts only the Authorize payer
  transactionOptions?: TransactionOptions;
}

// For `reclaimDeferred` — cleanup path, after the window.
interface ReclaimDeferredPayload {
  deferredExecPda: PublicKey;
  refundDestination?: PublicKey;          // leave unset: the program accepts only the Authorize payer
}

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.
// Serialized, it carries `version: 2` and is refused across the v1/v2 boundary.
interface DeferredPayload {
  walletPda: PublicKey;
  deferredExecPda: PublicKey;
  compactInstructions: {
    programIdIndex: number;
    accountIndexes: number[];
    data: Uint8Array;
  }[];
  remainingAccounts: {
    pubkey: PublicKey;
    isSigner: boolean;
    isWritable: boolean;
  }[];
  executor?: PublicKey;                   // who the accounts hash expects to send TX2
  refundDestination?: PublicKey;          // the Authorize payer
}

// 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; you keep the secret key
  expiresAtSlot: bigint;                  // absolute slot, at most 6,480,000 slots ahead
  actions?: SessionAction[];              // required unless unrestricted. Name every asset it
                                          // may spend; at most 16, within 244 bytes (not checked)
  unrestricted?: boolean;                 // a session with no limits, explicitly (2.0.0+)
}

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

interface AddAuthorityPayload {
  newEd25519Pubkey: PublicKey;
  role: number;                           // required, no default: ROLE_SPENDER (2, a Delegate) | ROLE_ADMIN (1) | ROLE_OWNER (0, v1 only)
  policy?: Uint8Array;                    // required for ROLE_SPENDER on v2: serializeActions([...]).
                                          // Names every asset the key may spend; within 244 bytes
  unrestricted?: boolean;                 // required to add a key to a v1 wallet
}

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

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

type ListAuthoritiesResult = AuthorityEntry[];

const SIGNED_MESSAGE_DOMAIN = 'LazorKit signed message v1';  // the challenge's tag
const OWNERSHIP_PROOF_DOMAIN = 'LazorKit ownership proof v1'; // connect's proofs

type SignedMessageInput = string | Uint8Array;  // a string is signed as its UTF-8 bytes

// What signMessage resolves with: the passkey's assertion over signedMessageChallenge(message).
interface SignMessageResult {
  readonly signature: string;               // P-256, 64 bytes (r || s, low-S), base64
  readonly signedPayload: string;           // authenticatorData || SHA-256(clientDataJSON), base64
  readonly clientDataJsonBase64: string;    // its challenge is base64url(signedMessageChallenge(message))
  readonly authenticatorDataBase64: string;
}

interface VerifySignedMessageParams {
  readonly message: SignedMessageInput;
  readonly signature: string | Uint8Array;  // 64 bytes, or their base64
  readonly clientDataJsonBase64: string;
  readonly authenticatorDataBase64: string;
  readonly signedPayload?: string;          // checked when given
  readonly publicKey: string | Uint8Array | ArrayLike<number>; // P-256: 33, 65 or 64 bytes, or base64. Read it from chain.
  readonly rpId?: string;
  readonly origin?: string;
}

interface VerifyWalletMessageParams extends Omit<VerifySignedMessageParams, 'publicKey' | 'rpId'> {
  readonly connection: Connection;
  readonly wallet: string | PublicKey;      // the claimed wallet: vault or wallet PDA
  readonly credentialId: string;            // base64
  readonly rpId: string;                    // the passkey's relying party (the provider's rpId)
  readonly cluster?: 'mainnet' | 'devnet';
}

function signedMessageChallenge(message: SignedMessageInput): Uint8Array; // 58 bytes
function verifySignedMessage(params: VerifySignedMessageParams): boolean;  // offline; never throws
function verifyWalletMessage(params: VerifyWalletMessageParams): Promise<boolean>; // key read from chain
function createOwnershipChallenge(): Uint8Array; // OWNERSHIP_PROOF_DOMAIN || 32 random bytes, 59 bytes

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;   // manages every authority, including other Owners
export const ROLE_ADMIN   = 1;   // manages Delegates and sessions
export const ROLE_SPENDER = 2;   // a Delegate: manages nothing, spends within its policy

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

class LazorKitError extends Error { code?: string }
class WalletConnectionError extends LazorKitError {}   // "Already connecting", bad redirect
class SigningError          extends LazorKitError {}   // another sign action is running; no wallet
class PortalCancelledError  extends LazorKitError {}   // the portal was closed
class WalletChooserNotShownError extends LazorKitError {} // iOS: chooser under another modal

// Sending (2.1.0+)
class TransactionFailedError extends Error {           // landed and failed
  readonly signature: string;
  readonly transactionError: TransactionError;
  readonly slot: number;
  readonly logs?: string[];
}
class TransactionExpiredError extends Error { readonly signature: string }
class TransactionOutcomeUnknownError extends Error { readonly signature: string | undefined }
class ConfirmationTimeoutError extends TransactionOutcomeUnknownError { readonly waitedMs: number }
class PreviousTransactionPendingError extends Error { readonly pendingSignature: string | undefined }
class SignatureReusedError extends Error { readonly code: 3006 }
class PaymasterError extends Error {
  readonly code?: number; readonly data?: unknown; readonly httpStatus?: number;
  readonly signature?: string; maybeSent: boolean;
}

// Deferred execution (2.2.0+)
class DeferredExpiredError extends Error {
  readonly code: 3014;
  readonly deferredExecPda: PublicKey;             // holds the rent: pass it to reclaimDeferred
  readonly authorizeSignature: string | undefined; // TX1, when the same call sent it
  readonly expiresAtSlot: bigint | undefined;
}
interface DeferredFailureContext { deferredExecPda?: PublicKey; authorizeSignature?: string; expiresAtSlot?: bigint } // 2.2.1+

// v1 wallets (2.0.0+)
class V1WalletRetiredError extends Error { readonly code: 4018 }
class V1WalletMigratedError extends Error {}

// A session send moving an asset its actions do not name (2.4.0+), from the v2 program
// release that adds errors 3037 and 3038. Nothing in it ran.
type PolicySigner = 'session' | 'authority';  // always 'session' from this adapter
class UnlistedSolOutflowError extends Error {   // "This session is not allowed to spend SOL"
  readonly code: 3037;
  readonly signer: PolicySigner;
  readonly cause?: unknown;                     // the failure as it came
}
class UnlistedTokenOutflowError extends Error { // "This session is not allowed to spend this token"
  readonly code: 3038;
  readonly signer: PolicySigner;
  readonly cause?: unknown;
}

// Re-exported from @lazorkit/sdk-legacy
class MinContextSlotNotReachedError extends Error {}