w3pk 0.10.5 → 0.11.1

package/dist/index.d.mts

@@ -1,4 +1,4 @@
-import { ethers } from 'ethers';
+import { TypedDataDomain, ethers } from 'ethers';
 
 /**
  * ERC-5564 Stealth Address Cryptography
@@ -41,8 +41,6 @@ interface ParseResult {
     isForUser: boolean;
     /** The stealth address (only if isForUser is true) */
     stealthAddress?: string;
-    /** The stealth private key (only if isForUser is true) */
-    stealthPrivateKey?: string;
 }
 /**
  * Derive ERC-5564 compliant stealth keys from w3pk mnemonic using HD paths
@@ -85,7 +83,7 @@ declare function generateStealthAddress(stealthMetaAddress: string): StealthAddr
  * @param ephemeralPubKey - Ephemeral public key from announcement
  * @param stealthAddress - The stealth address to check
  * @param viewTag - View tag from announcement (optional, for optimization)
- * @returns ParseResult with stealth address and private key if it belongs to user
+ * @returns ParseResult with the stealth address if it belongs to the user
  */
 declare function checkStealthAddress(viewingKey: string, spendingPubKey: string, ephemeralPubKey: string, stealthAddress: string, viewTag?: string): ParseResult;
 /**
@@ -124,9 +122,11 @@ declare function canControlStealthAddress(viewingKey: string, spendingKey: strin
  * - Stealth addresses use SEPARATE derivation paths from the main wallet
  * - Viewing key: m/44'/60'/1'/0/0 (for scanning announcements)
  * - Spending key: m/44'/60'/1'/0/1 (for spending stealth funds)
- * - Applications that opt-in to stealth addresses WILL have access to stealth private keys
- * - This is REQUIRED for ERC-5564 compliance (to parse announcements and spend funds)
+ * - Applications that opt-in to stealth addresses get the viewing key, never the
+ *   spending key or the private key of a stealth address; w3pk signs from
+ *   stealth addresses itself
  * - Stealth keys are NOT derived from the main wallet's MAIN tag
+ * - Stealth keys are shared across origins: every app gets the same meta-address
  * - This module is OPT-IN only (must explicitly enable in SDK config)
  *
  * @see https://eips.ethereum.org/EIPS/eip-5564
@@ -164,8 +164,19 @@ interface ParseAnnouncementResult {
     isForUser: boolean;
     /** The stealth address (only if isForUser is true) */
     stealthAddress?: string;
-    /** The stealth private key for spending (only if isForUser is true) */
-    stealthPrivateKey?: string;
+}
+/**
+ * EIP-1559 transaction to sign from a stealth address
+ */
+interface StealthTransaction {
+    to: string;
+    value?: bigint;
+    data?: string;
+    chainId: number;
+    nonce: number;
+    gasLimit: bigint;
+    maxFeePerGas: bigint;
+    maxPriorityFeePerGas: bigint;
 }
 /**
  * ERC-5564 Stealth Address Module
@@ -175,11 +186,18 @@ interface ParseAnnouncementResult {
  * By using this module, applications will have access to:
  * - Stealth meta-address (safe to share publicly)
  * - Viewing private key (required for scanning announcements)
- * - Spending private key (required for spending stealth funds)
- * - Computed stealth private keys (required for accessing received stealth payments)
- *
- * This is INTENTIONAL and REQUIRED for ERC-5564 stealth address functionality.
- * Stealth keys are derived from separate HD paths (not from main wallet).
+ * - Transactions signed from stealth addresses with `signTransaction()`, each
+ *   after a fresh passkey assertion
+ *
+ * The spending key and stealth private keys never leave the SDK: a stealth
+ * private key plus the viewing key would give back the spending key (stealth
+ * key = spending key + hash of the shared secret). The viewing key lets an app
+ * see every stealth payment to the user, and an app with this module enabled
+ * can ask w3pk to sign from a stealth address, which prompts for the passkey
+ * every time. Stealth keys are derived from separate HD paths (not from main wallet)
+ * and are the same for every origin, so any app that enables this module sees
+ * the same viewing key and meta-address; scoping them per origin would change
+ * the meta-address and strand funds already sent to it.
  */
 declare class StealthAddressModule {
     private getMnemonic;
@@ -202,7 +220,7 @@ declare class StealthAddressModule {
      * @param announcement - The announcement to parse (from on-chain event)
      * @param options - Optional configuration
      * @param options.requireAuth - If true, force fresh authentication even if session is active
-     * @returns ParseResult indicating if announcement is for user, plus stealth private key if true
+     * @returns ParseResult indicating if announcement is for user, plus the stealth address if true
      */
     parseAnnouncement(announcement: Announcement, options?: {
         requireAuth?: boolean;
@@ -214,21 +232,35 @@ declare class StealthAddressModule {
      * @param announcements - Array of announcements to scan
      * @param options - Optional configuration
      * @param options.requireAuth - If true, force fresh authentication even if session is active
-     * @returns Array of announcements that belong to the user with their private keys
+     * @returns Array of announcements that belong to the user
      */
     scanAnnouncements(announcements: Announcement[], options?: {
         requireAuth?: boolean;
     }): Promise<ParseAnnouncementResult[]>;
+    /**
+     * Sign an EIP-1559 transaction from a stealth address found for the user
+     * The stealth private key is derived and used inside the SDK, never returned.
+     * Every call runs a fresh passkey assertion, even with an active session.
+     * The transaction is signed, not sent: broadcast it with your own RPC
+     * (`eth_sendRawTransaction`).
+     *
+     * @param announcement - The announcement of the stealth address to sign from
+     * @param tx - Fully populated transaction (nonce, gas limit and fees included)
+     * @returns The serialized signed transaction
+     */
+    signTransaction(announcement: Announcement, tx: StealthTransaction): Promise<string>;
     /**
      * Get ERC-5564 stealth keys
-     * Returns the stealth meta-address and private keys
+     * Returns the stealth meta-address, both public keys and the viewing key;
+     * the spending private key is never returned. The keys are the same for
+     * every origin.
      *
      * @param options - Optional configuration
      * @param options.requireAuth - If true, force fresh authentication even if session is active
      */
     getKeys(options?: {
         requireAuth?: boolean;
-    }): Promise<StealthKeys>;
+    }): Promise<Omit<StealthKeys, "spendingKey">>;
     /**
      * Get the stealth meta-address for receiving funds
      * This is what you share publicly for others to send you stealth payments
@@ -252,6 +284,7 @@ interface PrfExtensionResults {
         enabled?: boolean;
         results?: {
             first?: ArrayBuffer;
+            second?: ArrayBuffer;
         };
     };
 }
@@ -287,17 +320,368 @@ interface PrfSecret {
     credentialId: string;
 }
 
+/**
+ * Semaphore v4 identities bound to a passkey
+ */
+interface SemaphoreIdentity {
+    /** Poseidon(publicKey), the member value apps add to a Semaphore group */
+    commitment: bigint;
+    /** Credential the identity is bound to; a new credential gives a new commitment */
+    credentialId: string;
+}
+
+/**
+ * Zero-Knowledge Proof Types
+ * General-purpose ZK proof system for privacy-preserving assertions
+ */
+interface ZKProofConfig {
+    /**
+     * Enable/disable specific proof types
+     */
+    enabledProofs?: ProofType[];
+    /**
+     * Custom circuit paths (optional)
+     */
+    customCircuits?: Record<string, CircuitArtifacts>;
+}
+type ProofType = "membership" | "threshold" | "range" | "equality" | "ownership" | "signature" | "nft";
+interface CircuitArtifacts {
+    wasmPath: string;
+    zkeyPath: string;
+    verificationKey: unknown;
+}
+interface ZKProof {
+    type: ProofType;
+    proof: {
+        pi_a: string[];
+        pi_b: string[][];
+        pi_c: string[];
+        protocol: string;
+        curve: string;
+    };
+    publicSignals: string[];
+    timestamp: string;
+}
+interface VerificationResult {
+    valid: boolean;
+    type: ProofType;
+    publicSignals: Record<string, string>;
+    timestamp: string;
+}
+/**
+ * Membership Proof - Prove you're in a set without revealing which member
+ */
+interface MembershipProofInput {
+    value: string;
+    pathIndices: number[];
+    pathElements: string[];
+    root: string;
+}
+/**
+ * Threshold Proof - Prove value exceeds threshold without revealing value
+ */
+interface ThresholdProofInput {
+    value: bigint;
+    blinding: bigint;
+    threshold: bigint;
+    commitment: string;
+}
+/**
+ * Range Proof - Prove value is within range without revealing value
+ */
+interface RangeProofInput {
+    value: bigint;
+    blinding: bigint;
+    min: bigint;
+    max: bigint;
+    commitment: string;
+}
+/**
+ * Ownership Proof - Prove you own an address without revealing private key
+ */
+interface OwnershipProofInput {
+    privateKey: string;
+    nonce: bigint;
+    address: string;
+    challenge: string;
+}
+/**
+ * NFT Ownership Proof - Prove you own an NFT from a collection without revealing which one
+ */
+interface NFTOwnershipProofInput {
+    ownerAddress: string;
+    holderIndex: number;
+    pathIndices: number[];
+    pathElements: string[];
+    holdersRoot: string;
+    contractAddress: string;
+    minBalance?: bigint;
+}
+
+/**
+ * Custom error classes for better error handling
+ */
+declare class Web3PasskeyError extends Error {
+    code: string;
+    originalError?: unknown | undefined;
+    constructor(message: string, code: string, originalError?: unknown | undefined);
+}
+declare class AuthenticationError extends Web3PasskeyError {
+    constructor(message: string, originalError?: unknown);
+}
+declare class RegistrationError extends Web3PasskeyError {
+    constructor(message: string, originalError?: unknown);
+}
+declare class WalletError extends Web3PasskeyError {
+    constructor(message: string, originalError?: unknown);
+}
+declare class CryptoError extends Web3PasskeyError {
+    constructor(message: string, originalError?: unknown);
+}
+declare class StorageError extends Web3PasskeyError {
+    constructor(message: string, originalError?: unknown);
+}
+declare class ApiError extends Web3PasskeyError {
+    statusCode?: number | undefined;
+    constructor(message: string, statusCode?: number | undefined, originalError?: unknown);
+}
+/**
+ * The passkey authenticated, but this device has no credential metadata.
+ * The app should start a sync or restore flow.
+ */
+declare class SyncRequiredError extends Web3PasskeyError {
+    credentialId: string;
+    constructor(credentialId: string);
+}
+/**
+ * The credential metadata is on this device, but the wallet record is gone.
+ * The app should offer a restore from backup.
+ */
+declare class WalletMissingError extends Web3PasskeyError {
+    credentialId: string;
+    ethereumAddress: string;
+    constructor(credentialId: string, ethereumAddress: string);
+}
+type SyncBootstrapReason = "NO_CREDENTIAL" | "CREDENTIAL_MISMATCH" | "PUBLIC_KEY_MISMATCH";
+/**
+ * A sync can't set up this device's passkey metadata from the backup.
+ */
+declare class SyncBootstrapError extends Web3PasskeyError {
+    reason: SyncBootstrapReason;
+    credentialId: string;
+    constructor(reason: SyncBootstrapReason, credentialId: string);
+}
+/**
+ * The authenticator returned no WebAuthn PRF output, so no
+ * passkey-bound secret can be derived. There is no fallback.
+ */
+declare class PrfUnsupportedError extends Web3PasskeyError {
+    credentialId: string;
+    constructor(credentialId: string);
+}
+/**
+ * The backup holds another wallet than the one this passkey opens on this
+ * device. Restoring it replaces that wallet, so the app must confirm it
+ * with the user and pass `allowAddressChange: true`.
+ */
+declare class AddressChangeError extends Web3PasskeyError {
+    currentAddress: string;
+    newAddress: string;
+    constructor(currentAddress: string, newAddress: string);
+}
+/**
+ * The backup uses the removed `passkey` or `hybrid` method, whose key came
+ * from public data rather than from the passkey. It can't be restored.
+ */
+declare class RemovedBackupMethodError extends Web3PasskeyError {
+    method: string;
+    constructor(method: string);
+}
+/**
+ * The backup file isn't BackupFile v3. w3pk restores v3 files only: decrypt
+ * an older password backup offline with the v0.10.6 extract-mnemonic tool,
+ * then create a new backup.
+ */
+declare class UnsupportedBackupVersionError extends Web3PasskeyError {
+    version: unknown;
+    /** The rebuilt file, when it came from guardian shares, for the offline tool */
+    backupFileJson?: string;
+    constructor(version: unknown, method?: string);
+}
+/**
+ * The password for a password backup is too weak to resist an offline
+ * guess: `feedback` lists what it's missing
+ */
+declare class WeakPasswordError extends Web3PasskeyError {
+    feedback: string[];
+    constructor(feedback: string[]);
+}
+type ZkArtifactName = "wasm" | "zkey";
+/**
+ * A circuit artifact's IPFS CID doesn't match the CID pinned onchain,
+ * so it isn't the circuit the app chose.
+ */
+declare class ZkArtifactMismatchError extends Web3PasskeyError {
+    artifact: ZkArtifactName;
+    expectedCid: string;
+    actualCid: string;
+    constructor(artifact: ZkArtifactName, expectedCid: string, actualCid: string);
+}
+
+/**
+ * Circuit artifact verification against CIDs pinned onchain
+ */
+
+/** Artifact bytes, or a URL to fetch them from */
+type ZkArtifactSource = ArrayBufferView | ArrayBuffer | string;
+type ZkArtifactSources = Record<ZkArtifactName, ZkArtifactSource>;
+/**
+ * IPFS CIDv1 strings in base32, as `ipfs add --cid-version 1` prints them,
+ * compared as exact strings
+ */
+type ZkArtifactPins = Record<ZkArtifactName, string>;
+
+/**
+ * Zero-Knowledge Proof Module for w3pk SDK
+ * Enables privacy-preserving proofs
+ */
+
+declare class ZKProofModule {
+    private generator;
+    private verifier;
+    private config;
+    constructor(config?: ZKProofConfig);
+    private initializeCircuits;
+    /**
+     * Generate membership proof - prove you're in a set without revealing identity
+     * Use case: Prove you're a verified user without revealing which one
+     */
+    proveMembership(input: MembershipProofInput): Promise<ZKProof>;
+    /**
+     * Generate threshold proof - prove value exceeds threshold
+     * Use case: Prove balance > $1000 without revealing actual balance
+     */
+    proveThreshold(input: ThresholdProofInput): Promise<ZKProof>;
+    /**
+     * Generate range proof - prove value is within range
+     * Use case: Prove age between 18-65 without revealing exact age
+     */
+    proveRange(input: RangeProofInput): Promise<ZKProof>;
+    /**
+     * Generate ownership proof - prove you own an address
+     * Use case: Prove ownership without revealing private key
+     */
+    proveOwnership(input: OwnershipProofInput): Promise<ZKProof>;
+    /**
+     * Generate NFT ownership proof - prove you own an NFT from a collection
+     * Use case: Prove NFT/SBT ownership without revealing which NFT or exact address
+     */
+    proveNFTOwnership(input: NFTOwnershipProofInput): Promise<ZKProof>;
+    /**
+     * Verify any ZK proof
+     */
+    verify(proof: ZKProof): Promise<VerificationResult>;
+    /**
+     * Batch verify multiple proofs
+     */
+    verifyBatch(proofs: ZKProof[]): Promise<VerificationResult[]>;
+    /**
+     * Verify membership proof with expected root
+     */
+    verifyMembership(proof: ZKProof, expectedRoot: string): Promise<boolean>;
+    /**
+     * Verify threshold proof
+     */
+    verifyThreshold(proof: ZKProof, expectedCommitment: string, expectedThreshold: bigint): Promise<boolean>;
+    /**
+     * Verify range proof
+     */
+    verifyRange(proof: ZKProof, expectedCommitment: string, expectedMin: bigint, expectedMax: bigint): Promise<boolean>;
+    /**
+     * Verify ownership proof
+     */
+    verifyOwnership(proof: ZKProof, expectedAddress: string, expectedChallenge: string): Promise<boolean>;
+    /**
+     * Verify NFT ownership proof
+     */
+    verifyNFTOwnership(proof: ZKProof, expectedContract: string, expectedHoldersRoot: string, expectedMinBalance?: bigint): Promise<boolean>;
+    /**
+     * Create a Poseidon commitment for hiding values
+     */
+    createCommitment(value: bigint, blinding: bigint): Promise<string>;
+    /**
+     * Compute merkle root for membership proofs
+     */
+    computeMerkleRoot(leaf: string, pathIndices: number[], pathElements: string[]): Promise<string>;
+    /**
+     * Register a custom circuit
+     */
+    registerCircuit(type: ProofType, artifacts: CircuitArtifacts): void;
+    /**
+     * Check if proof type is enabled
+     */
+    private assertProofEnabled;
+    /**
+     * Check if ZK proofs are available
+     */
+    get isAvailable(): boolean;
+}
+
+/**
+ * Groth16 proofs over a passkey-bound secret the caller never sees
+ */
+
+type ZkSignal = bigint | number | string | ZkSignal[];
+/** Circuit inputs by signal name, as snarkjs takes them */
+type ZkInputs = Record<string, ZkSignal>;
+interface ZkProveArtifacts extends ZkArtifactSources {
+    /** CIDs the artifacts must match, e.g. from `readZkArtifactPins` */
+    pins: ZkArtifactPins;
+}
+/**
+ * - `"zk"`: a Baby Jubjub private key derived from the passkey under the
+ *   `w3pk-zk-v1` label
+ * - `"semaphore"`: the `secretScalar` of `getSemaphoreIdentity(tag)`'s identity
+ */
+type ZkSecretSource = "zk" | "semaphore";
+/**
+ * A Poseidon input: a string names another input (the secret, a caller
+ * input, a random input or an earlier derivation), a bigint is a constant
+ */
+type ZkDerivationTerm = string | bigint;
+interface ZkProveOptions {
+    /** Default `"zk"` */
+    secret?: ZkSecretSource;
+    /** Circuit input that receives the secret. Default `"secret"` */
+    secretInput?: string;
+    /**
+     * Inputs w3pk computes as `Poseidon(terms)`, in order, e.g.
+     * `{ voteSecret: ["secret", "proposalId", 1n] }`. 1 to 16 terms each
+     */
+    derive?: Record<string, ZkDerivationTerm[]>;
+    /** Inputs w3pk fills with fresh random scalars in `[1, l)` and discards */
+    random?: string[];
+}
+interface Groth16Proof {
+    pi_a: string[];
+    pi_b: string[][];
+    pi_c: string[];
+    protocol: string;
+    curve: string;
+}
+interface ZkProveResult {
+    proof: Groth16Proof;
+    publicSignals: string[];
+}
+
 /**
  * Shared types used across the SDK
  */
+
 interface UserInfo {
     username: string;
     ethereumAddress: string;
     credentialId: string;
-    /** @deprecated Use ethereumAddress instead */
-    id?: string;
-    /** @deprecated Use username instead */
-    displayName?: string;
 }
 /**
  * Security modes for origin-centric derivation
@@ -342,6 +726,8 @@ type SecurityMode = 'PRIMARY' | 'STANDARD' | 'STRICT' | 'YOLO';
  * - Sign raw 32-byte hashes without EIP-191 prefix
  * - Useful for pre-computed EIP-712 hashes or Safe transactions
  * - Message must be a 32-byte hex string (with or without 0x prefix)
+ * - Always requires a fresh user-verified passkey assertion: the hash could be
+ *   an EIP-7702 authorization digest
  */
 type SigningMethod = 'EIP191' | 'SIWE' | 'EIP712' | 'rawHash';
 /**
@@ -352,15 +738,23 @@ interface SignMessageOptions {
     mode?: SecurityMode;
     tag?: string;
     requireAuth?: boolean;
-    origin?: string;
     signingMethod?: SigningMethod;
-    eip712Domain?: Record<string, any>;
+    eip712Domain?: TypedDataDomain;
     eip712Types?: Record<string, Array<{
         name: string;
         type: string;
     }>>;
     eip712PrimaryType?: string;
 }
+/**
+ * Result of register()
+ */
+interface RegisterResult {
+    address: string;
+    username: string;
+    hasBackup: boolean;
+    evictionRisk: boolean;
+}
 /**
  * Generated wallet with mnemonic (from generateWallet)
  */
@@ -388,72 +782,6 @@ interface DerivedWallet {
     tag?: string;
     publicKey?: string;
 }
-/**
- * @deprecated Use GeneratedWallet or DerivedWallet instead
- */
-type WalletInfo = GeneratedWallet | DerivedWallet;
-
-/**
- * Custom error classes for better error handling
- */
-declare class Web3PasskeyError extends Error {
-    code: string;
-    originalError?: unknown | undefined;
-    constructor(message: string, code: string, originalError?: unknown | undefined);
-}
-declare class AuthenticationError extends Web3PasskeyError {
-    constructor(message: string, originalError?: unknown);
-}
-declare class RegistrationError extends Web3PasskeyError {
-    constructor(message: string, originalError?: unknown);
-}
-declare class WalletError extends Web3PasskeyError {
-    constructor(message: string, originalError?: unknown);
-}
-declare class CryptoError extends Web3PasskeyError {
-    constructor(message: string, originalError?: unknown);
-}
-declare class StorageError extends Web3PasskeyError {
-    constructor(message: string, originalError?: unknown);
-}
-declare class ApiError extends Web3PasskeyError {
-    statusCode?: number | undefined;
-    constructor(message: string, statusCode?: number | undefined, originalError?: unknown);
-}
-/**
- * The passkey authenticated, but this device has no credential metadata.
- * The app should start a sync or restore flow.
- */
-declare class SyncRequiredError extends Web3PasskeyError {
-    credentialId: string;
-    constructor(credentialId: string);
-}
-/**
- * The credential metadata is on this device, but the wallet record is gone.
- * The app should offer a restore from backup.
- */
-declare class WalletMissingError extends Web3PasskeyError {
-    credentialId: string;
-    ethereumAddress: string;
-    constructor(credentialId: string, ethereumAddress: string);
-}
-type SyncBootstrapReason = "PASSKEY_BACKUP" | "NO_CREDENTIAL" | "CREDENTIAL_MISMATCH" | "PUBLIC_KEY_MISMATCH";
-/**
- * A sync can't set up this device's passkey metadata from the backup.
- */
-declare class SyncBootstrapError extends Web3PasskeyError {
-    reason: SyncBootstrapReason;
-    credentialId: string;
-    constructor(reason: SyncBootstrapReason, credentialId: string);
-}
-/**
- * The authenticator returned no WebAuthn PRF output, so no
- * passkey-bound secret can be derived. There is no fallback.
- */
-declare class PrfUnsupportedError extends Web3PasskeyError {
-    credentialId: string;
-    constructor(credentialId: string);
-}
 
 /**
  * Persistent Session Storage
@@ -493,10 +821,7 @@ interface PersistentSessionConfig {
 
 interface StealthAddressConfig {
 }
-interface ZKProofConfig {
-    enabledProofs?: Array<"membership" | "threshold" | "range" | "equality" | "ownership" | "signature" | "nft">;
-    customCircuits?: Record<string, any>;
-}
+
 interface Web3PasskeyConfig {
     debug?: boolean;
     onError?: (error: Web3PasskeyError) => void;
@@ -544,20 +869,42 @@ interface Web3PasskeyConfig {
      * sign in with one click. PRF-derived secrets always require it.
      */
     userVerification?: 'required' | 'preferred';
+    /**
+     * RPC endpoints per chain ID, used before the chainid.network endpoints
+     * by `sendTransaction()`, `getEndpoints()` and `supportsEIP7702()`.
+     * A per-call `rpcUrl` still takes precedence.
+     *
+     * @example
+     * rpcUrls: { 1: ['https://eth.example.com'], 10: ['https://op.example.com'] }
+     */
+    rpcUrls?: Record<number, string[]>;
 }
 
 /**
  * Backup and Recovery Type Definitions
  */
-type BackupMethod = 'file' | 'qr' | 'phrase';
+
+/**
+ * - `file`: password backup file, restores without a passkey
+ * - `qr`: QR backup, restores without a passkey
+ * - `phrase`: recovery phrase written down
+ * - `prf`: PRF backup from exportForSync(), restores only with the passkey
+ */
+type BackupMethod = 'file' | 'qr' | 'phrase' | 'prf';
 interface BackupStatus {
+    /** A backup that restores without a passkey exists (file, QR or phrase) */
     hasBackup: boolean;
+    /**
+     * Next backup to make: `password` while no backup restores without a
+     * passkey (it's the one that must exist), then `prf` for convenient sync
+     * across devices where the passkey synced. Undefined once both exist.
+     */
+    recommendedMode?: 'password' | 'prf';
     evictionRisk: boolean;
     lastBackupAt?: string;
     methods: BackupMethod[];
     passkeySync: PasskeySyncStatus;
     recoveryPhrase: RecoveryPhraseStatus;
-    socialRecovery?: SocialRecoveryStatus;
     securityScore: SecurityScore;
 }
 interface PasskeySyncStatus {
@@ -574,28 +921,11 @@ interface RecoveryPhraseStatus {
 }
 interface EncryptedBackupInfo {
     id: string;
-    method: 'qr' | 'file';
+    method: 'qr' | 'file' | 'prf';
     location: string;
     createdAt: string;
     deviceFingerprint?: string;
 }
-interface SocialRecoveryStatus {
-    enabled: boolean;
-    guardians: Guardian$1[];
-    threshold: number;
-    sharesDistributed: number;
-    verifiedGuardians: number;
-}
-interface Guardian$1 {
-    id: string;
-    name: string;
-    email?: string;
-    publicKey?: string;
-    shareEncrypted: string;
-    status: 'pending' | 'active' | 'revoked';
-    addedAt: string;
-    lastVerified?: string;
-}
 interface SecurityScore {
     total: number;
     breakdown: {
@@ -603,15 +933,10 @@ interface SecurityScore {
         passkeyMultiDevice: number;
         phraseVerified: number;
         encryptedBackup: number;
-        socialRecovery: number;
     };
     level: 'vulnerable' | 'protected' | 'secured' | 'fort-knox';
     nextMilestone: string;
 }
-interface QRBackupOptions {
-    password?: string;
-    errorCorrection?: 'L' | 'M' | 'Q' | 'H';
-}
 interface RecoveryScenario {
     type: 'lost-device' | 'lost-phrase' | 'lost-both' | 'switch-platform';
     description: string;
@@ -630,6 +955,163 @@ interface RecoveryMethod {
     requirements: string[];
 }
 
+/**
+ * Hybrid KEM keypair: ML-KEM-1024 and X25519, concatenated
+ */
+interface MLKemKeypair {
+    publicKey: Uint8Array;
+    privateKey: Uint8Array;
+}
+interface EncryptedPayload {
+    version: 3;
+    recipients: Array<{
+        publicKey: string;
+        enc: string;
+        ciphertext: string;
+    }>;
+    encryptedData: string;
+    iv: string;
+    authTag: string;
+}
+/** Default context string for hybrid keypair derivation */
+declare const MLKEM_DEFAULT_CONTEXT = "mlkem-v1";
+/**
+ * Derive a deterministic hybrid keypair (ML-KEM-1024 + X25519) from any private key material
+ *
+ * HKDF-SHA256 extracts a PRK from the input (salt `w3pk-kem-keypair-v3`), then expands
+ * a 64-byte ML-KEM-1024 seed (info `ml-kem-1024:<context>`) and a 32-byte X25519 secret
+ * key (info `x25519:<context>`).
+ *
+ * @param privateKey - Private key material (hex string with optional 0x prefix, or Uint8Array)
+ * @param context - Context string for domain separation (default: MLKEM_DEFAULT_CONTEXT)
+ * @returns Hybrid keypair (publicKey: 1600 bytes, privateKey: 3200 bytes)
+ *
+ * @example
+ * ```typescript
+ * const keypair = await deriveMLKemKeypair('0x1234...', 'my-app');
+ * ```
+ */
+declare function deriveMLKemKeypair(privateKey: string | Uint8Array, context?: string): Promise<MLKemKeypair>;
+/**
+ * Encrypt data for one or more recipients (payload v3)
+ *
+ * The plaintext is encrypted once with AES-256-GCM under a random data key, which is
+ * sealed to each recipient with HPKE (RFC 9180, mode_base, HKDF-SHA256, AES-256-GCM)
+ * over a hybrid ML-KEM-1024 + X25519 KEM.
+ *
+ * @param plaintext - The data to encrypt
+ * @param publicKeys - Hybrid public keys (base64 strings or Uint8Arrays, 1600 bytes each)
+ * @returns Encrypted payload with one entry per recipient
+ */
+declare function mlkemEncrypt(plaintext: string, publicKeys: (string | Uint8Array) | Array<string | Uint8Array>): Promise<EncryptedPayload>;
+/**
+ * Decrypt a v3 payload from mlkemEncrypt()
+ *
+ * The recipient entry is found by the public key derived from `privateKey`.
+ * Payloads of any other version are rejected.
+ *
+ * @param payload - The encrypted payload
+ * @param privateKey - Hybrid private key (base64 string or Uint8Array, 3200 bytes)
+ * @returns Decrypted plaintext
+ */
+declare function mlkemDecrypt(payload: EncryptedPayload, privateKey: string | Uint8Array): Promise<string>;
+/**
+ * Encrypt with a hybrid keypair derived from private key material
+ *
+ * Derives the sender's keypair and adds its public key as the first recipient,
+ * so the sender can decrypt later.
+ *
+ * @param plaintext - The data to encrypt
+ * @param senderPrivateKey - Sender's private key (hex string or Uint8Array)
+ * @param recipientPublicKeys - Recipient hybrid public keys (from deriveMLKemKeypair)
+ * @param senderContext - Context for the sender's key derivation (default: MLKEM_DEFAULT_CONTEXT)
+ * @returns Encrypted payload with sender + recipients
+ */
+declare function mlkemEncryptWithKey(plaintext: string, senderPrivateKey: string | Uint8Array, recipientPublicKeys: Array<string | Uint8Array>, senderContext?: string): Promise<EncryptedPayload>;
+/**
+ * Decrypt with a hybrid keypair derived from private key material
+ *
+ * @param payload - The encrypted payload
+ * @param privateKey - Private key material (hex string or Uint8Array)
+ * @param context - Context for key derivation (default: MLKEM_DEFAULT_CONTEXT)
+ * @returns Decrypted plaintext
+ */
+declare function mlkemDecryptWithKey(payload: EncryptedPayload, privateKey: string | Uint8Array, context?: string): Promise<string>;
+
+/**
+ * Cross-Device Sync Manager
+ *
+ * Syncs wallets across devices where passkey is already synced.
+ * Use case: User has passkey on mobile and desktop, but wallet only on desktop.
+ * They can export wallet data from desktop and import on mobile.
+ */
+
+interface DeviceSyncInfo {
+    deviceName: string;
+    platform: 'ios' | 'android' | 'macos' | 'windows' | 'linux' | 'unknown';
+    lastSyncTime: string;
+    walletsSynced: string[];
+}
+
+/**
+ * Cross-Device Sync Type Definitions
+ */
+interface SyncCapabilities {
+    passkeysSync: boolean;
+    platform: 'apple' | 'google' | 'microsoft' | 'none';
+    estimatedDevices: number;
+    syncEnabled: boolean;
+}
+
+/**
+ * Social Recovery Manager
+ *
+ * Splits encrypted wallet data among guardians using Shamir Secret Sharing.
+ * Guardians can combine their shares to help recover the wallet.
+ */
+
+interface GuardianShare {
+    guardianId: string;
+    guardianName: string;
+    shareData: string;
+    shareIndex: number;
+    threshold: number;
+    createdAt: string;
+    walletAddress: string;
+}
+
+/** Payload of the EIP-1193 `connect` event */
+interface ProviderConnectInfo {
+    readonly chainId: string;
+}
+/** Error passed to EIP-1193 `disconnect` listeners */
+interface ProviderRpcError extends Error {
+    code: number;
+    data?: unknown;
+}
+/** Payload of the EIP-1193 `message` event */
+interface ProviderMessage {
+    readonly type: string;
+    readonly data: unknown;
+}
+/** EIP-1193 provider returned by `Web3Passkey.getEIP1193Provider()` */
+interface EIP1193ProviderInterface {
+    request(args: {
+        method: string;
+        params?: unknown[];
+    }): Promise<unknown>;
+    on(event: 'accountsChanged', handler: (accounts: string[]) => void): void;
+    on(event: 'chainChanged', handler: (chainId: string) => void): void;
+    on(event: 'connect', handler: (info: ProviderConnectInfo) => void): void;
+    on(event: 'disconnect', handler: (error: ProviderRpcError) => void): void;
+    on(event: 'message', handler: (message: ProviderMessage) => void): void;
+    removeListener(event: 'accountsChanged', handler: (accounts: string[]) => void): void;
+    removeListener(event: 'chainChanged', handler: (chainId: string) => void): void;
+    removeListener(event: 'connect', handler: (info: ProviderConnectInfo) => void): void;
+    removeListener(event: 'disconnect', handler: (error: ProviderRpcError) => void): void;
+    removeListener(event: 'message', handler: (message: ProviderMessage) => void): void;
+}
+
 /**
  * Main Web3Passkey SDK
  *
@@ -643,21 +1125,20 @@ interface RecoveryMethod {
  * - Each origin receives isolated address derivation
  *
  * STEALTH ADDRESSES (opt-in via config.stealthAddresses):
- * - Applications receive stealth private keys (viewing and spending)
- * - Required for ERC-5564 compliance
+ * - Applications receive the viewing key, never the spending key or a stealth
+ *   private key; w3pk signs from stealth addresses after a fresh assertion
+ * - Stealth keys are shared across origins
  * - Uses separate derivation: m/44'/60'/1'/0/0 and m/44'/60'/1'/0/1
  * - Not derived from origin-specific addresses
  */
 
-/** Minimal EIP-1193 provider interface (matches the existing EIP1193Provider shape) */
-interface EIP1193ProviderInterface {
-    request(args: {
-        method: string;
-        params?: any[];
-    }): Promise<any>;
-    on(event: string, handler: (...args: any[]) => void): void;
-    removeListener(event: string, handler: (...args: any[]) => void): void;
-}
+/**
+ * ZKProofModule members as exposed by `Web3Passkey.zk`: methods return a
+ * Promise, properties become calls resolving to their value
+ */
+type ZKMethods = {
+    [K in keyof ZKProofModule]: ZKProofModule[K] extends (...args: infer A) => infer R ? (...args: A) => Promise<Awaited<R>> : () => Promise<ZKProofModule[K]>;
+};
 declare class Web3Passkey {
     private config;
     private walletStorage;
@@ -667,7 +1148,10 @@ declare class Web3Passkey {
     private sessionManager;
     stealth?: StealthAddressModule;
     private zkModule?;
+    private readonly ctx;
     constructor(config?: Web3PasskeyConfig);
+    /** The internals the feature modules work on, read when they run */
+    private createContext;
     /**
      * Lazy-load ZK module to prevent bundling unless accessed
      */
@@ -678,18 +1162,18 @@ declare class Web3Passkey {
      * @param securityMode - Security mode to use for session persistence (default: STANDARD)
      */
     private getMnemonicFromSession;
+    /**
+     * Store the wallet encrypted under the key derived from `prfOutput`,
+     * the PRF output at `PRF_INPUT` of the wallet's passkey
+     */
+    private storeWallet;
     /**
      * Register new user with WebAuthn
      * Automatically generates wallet if none exists and associates with passkey
      */
     register(options: {
         username: string;
-    }): Promise<{
-        address: string;
-        username: string;
-        hasBackup: boolean;
-        evictionRisk: boolean;
-    }>;
+    }): Promise<RegisterResult>;
     /**
      * Login with WebAuthn using resident credentials
      * Starts session with decrypted mnemonic
@@ -739,16 +1223,6 @@ declare class Web3Passkey {
         createdAt: string;
         lastUsed: string;
     }>>;
-    /**
-     * Check if there are existing credentials on this device
-     * @deprecated Use listExistingCredentials().length > 0 instead
-     */
-    hasExistingCredential(): Promise<boolean>;
-    /**
-     * Get the number of existing credentials on this device
-     * @deprecated Use listExistingCredentials().length instead
-     */
-    getExistingCredentialCount(): Promise<number>;
     /**
      * Generate new BIP39 wallet with 12-word mnemonic
      * @internal - Called automatically by register()
@@ -765,7 +1239,6 @@ declare class Web3Passkey {
      * @param mode - Security mode for derivation (default: "STANDARD")
      * @param tag - Tag for derivation (default: "MAIN")
      * @param options.requireAuth - Force fresh authentication
-     * @param options.origin - Override origin URL (testing only)
      *
      * @example
      * // Default: STANDARD mode with MAIN tag
@@ -779,7 +1252,6 @@ declare class Web3Passkey {
      */
     deriveWallet(mode?: SecurityMode, tag?: string, options?: {
         requireAuth?: boolean;
-        origin?: string;
     }): Promise<DerivedWallet>;
     /**
      * Get public address for a specific security mode and tag
@@ -791,7 +1263,6 @@ declare class Web3Passkey {
      *
      * @param mode - Security mode (default: "STANDARD")
      * @param tag - Derivation tag (default: "MAIN")
-     * @param options.origin - Override origin URL (testing only)
      * @returns The Ethereum address for this mode/tag combination
      *
      * @example
@@ -807,12 +1278,15 @@ declare class Web3Passkey {
      * // Get STRICT address (will require authentication)
      * const strictAddr = await w3pk.getAddress("STRICT")
      */
-    getAddress(mode?: SecurityMode, tag?: string, options?: {
-        origin?: string;
-    }): Promise<string>;
+    getAddress(mode?: SecurityMode, tag?: string): Promise<string>;
     /**
-     * Import mnemonic phrase
-     * Requires authentication and overwrites existing wallet
+     * Import a mnemonic phrase as the logged-in passkey's wallet, replacing
+     * the stored one. The imported wallet is stored under its own address
+     * before the credential points at it, and the previous wallet is deleted
+     * only after.
+     *
+     * @throws WalletError if not logged in, or the phrase isn't a valid BIP39 mnemonic
+     * @throws AuthenticationError if the passkey prompt is cancelled, and PrfUnsupportedError if the authenticator returns no PRF output (nothing stored changes)
      */
     importMnemonic(mnemonic: string): Promise<void>;
     /**
@@ -821,11 +1295,12 @@ declare class Web3Passkey {
      * By default, signs with STANDARD mode + MAIN tag (origin-centric address).
      * You can specify a different mode and tag to sign from a specific derived address.
      *
-     * @param message - Message to sign
+     * @param message - Message to sign; bytes are signed as-is, and only with EIP191
      * @param options.mode - Security mode for derivation (default: "STANDARD")
      * @param options.tag - Tag for derivation (default: "MAIN")
      * @param options.requireAuth - Force fresh authentication
-     * @param options.origin - Override origin URL (testing only)
+     * @param options.signingMethod - EIP191 (default), SIWE, EIP712 or rawHash;
+     *   rawHash always requires a fresh user-verified passkey assertion
      * @returns Signature result with address, mode, and tag information
      *
      * @example
@@ -848,7 +1323,7 @@ declare class Web3Passkey {
      *   mode: 'STRICT'
      * })
      */
-    signMessage(message: string, options?: SignMessageOptions): Promise<{
+    signMessage(message: string | Uint8Array, options?: SignMessageOptions): Promise<{
         signature: string;
         address: string;
         mode: SecurityMode;
@@ -897,8 +1372,9 @@ declare class Web3Passkey {
      * @param options.mode - Security mode (default: STANDARD)
      * @param options.tag - Wallet tag (optional)
      * @param options.requireAuth - Force fresh authentication (optional)
-     * @param options.origin - Origin override (optional)
-     * @param options.rpcUrl - RPC endpoint override (optional, required for PRIMARY mode)
+     * @param options.rpcUrl - RPC endpoint override (optional, required for PRIMARY mode);
+     *   without it, the first `rpcUrls` endpoint set for the chain is used, then the
+     *   first HTTPS chainid.network endpoint
      * @returns Transaction hash and metadata
      *
      * @example
@@ -918,7 +1394,6 @@ declare class Web3Passkey {
         mode?: SecurityMode;
         tag?: string;
         requireAuth?: boolean;
-        origin?: string;
         rpcUrl?: string;
     }): Promise<{
         hash: string;
@@ -935,16 +1410,19 @@ declare class Web3Passkey {
      * @param params.contractAddress - Contract address to authorize
      * @param params.chainId - Chain ID (default: 1)
      * @param params.nonce - Nonce (default: 0)
-     * @param params.privateKey - Private key for derived/stealth addresses
-     * @param options.requireAuth - Force fresh authentication
+     * @param options.mode - Security mode of the signing wallet (default: STANDARD, PRIMARY is refused)
+     * @param options.tag - Wallet tag (default: MAIN)
+     *
+     * Signs with the origin-specific derived key (never the master key) after a
+     * fresh user-verified passkey assertion.
      */
     signAuthorization(params: {
         contractAddress: string;
         chainId?: number;
         nonce?: bigint;
-        privateKey?: string;
     }, options?: {
-        requireAuth?: boolean;
+        mode?: SecurityMode;
+        tag?: string;
     }): Promise<{
         chainId: bigint;
         address: string;
@@ -953,6 +1431,11 @@ declare class Web3Passkey {
         r: string;
         s: string;
     }>;
+    /**
+     * RPC endpoints for a chain: those set in `rpcUrls` first, then the HTTPS
+     * chainid.network endpoints that need no API key (skipped if chainid.network
+     * can't be reached and the app set endpoints for the chain)
+     */
     getEndpoints(chainId: number): Promise<string[]>;
     supportsEIP7702(chainId: number, options?: {
         maxEndpoints?: number;
@@ -996,60 +1479,12 @@ declare class Web3Passkey {
         rpcUrl?: string;
     }): EIP1193ProviderInterface;
     /**
-     * Request EIP-7702 authorization from external wallet (MetaMask, Rabby, etc.)
-     * This allows users to delegate their ENS account to their w3pk STANDARD+MAIN account
-     *
-     * Flow:
-     * 1. User has ENS account in external wallet
-     * 2. User creates/logs into w3pk account
-     * 3. User signs EIP-7702 authorization delegating ENS account → w3pk account
-     * 4. User includes authorization in transaction to activate delegation
-     *
-     * @param params.provider - EIP-1193 provider (window.ethereum) - optional, auto-detected if not provided
-     * @param params.chainId - Chain ID for the authorization
-     * @param params.nonce - Nonce (default: 0n)
-     * @param params.accountIndex - Which account from external wallet to use (default: 0)
-     * @returns EIP-7702 authorization object
-     *
-     * @example
-     * ```typescript
-     * import { createWeb3Passkey } from 'w3pk';
-     *
-     * const w3pk = createWeb3Passkey();
-     * await w3pk.register({ username: 'alice' });
-     *
-     * // Request MetaMask to delegate to w3pk account
-     * const authorization = await w3pk.requestExternalWalletDelegation({
-     *   chainId: 1,
-     *   nonce: 0n
-     * });
-     *
-     * // Now user's ENS account delegates to w3pk account
-     * // Include in first transaction to activate
-     * await provider.request({
-     *   method: 'eth_sendTransaction',
-     *   params: [{
-     *     to: someContract,
-     *     data: txData,
-     *     authorizationList: [authorization]
-     *   }]
-     * });
-     * ```
+     * Lazily loaded ZKProofModule (from `w3pk/zk`): each member loads the
+     * module on first call and returns a Promise; a property such as
+     * `isAvailable` resolves to its value, and `isAvailable()` resolves to
+     * false when the module can't load
      */
-    requestExternalWalletDelegation(params?: {
-        provider?: any;
-        chainId?: number;
-        nonce?: bigint;
-        accountIndex?: number;
-    }): Promise<{
-        chainId: bigint;
-        address: string;
-        nonce: bigint;
-        yParity: number;
-        r: string;
-        s: string;
-    }>;
-    get zk(): any;
+    get zk(): ZKMethods;
     /**
      * Get backup status
      */
@@ -1067,27 +1502,30 @@ declare class Web3Passkey {
      * - Sync wallet across devices
      * - Split among guardians for social recovery
      *
-     * @param encryptionType - 'password' (default), 'passkey', or 'hybrid'
-     * @param password - Required for 'password' and 'hybrid' encryption
+     * Creates a password backup (BackupFile v3, Argon2id): the backup that
+     * restores without a passkey. A PRF backup comes from exportForSync().
+     *
+     * @param password - Encrypts the backup
+     * @throws WeakPasswordError when isStrongPassword() refuses the password, with its feedback
      */
-    createBackupFile(encryptionType?: 'password' | 'passkey' | 'hybrid', password?: string): Promise<{
+    createBackupFile(password: string): Promise<{
         blob: Blob;
         filename: string;
     }>;
-    private backupCredential;
     /**
      * Set up social recovery by splitting backup file among guardians
      * Uses Shamir Secret Sharing to split the backup - requires M-of-N guardians to recover
      *
      * @param guardians - List of guardian names/emails
      * @param threshold - Number of guardians required to recover (M-of-N)
-     * @param password - Optional password for additional encryption layer
+     * @param password - Encrypts the backup that the guardians' shares rebuild
+     * @throws WeakPasswordError when isStrongPassword() refuses the password, with its feedback
      */
     setupSocialRecovery(guardians: {
         name: string;
         email?: string;
-    }[], threshold: number, password?: string): Promise<{
-        guardianShares: any[];
+    }[], threshold: number, password: string): Promise<{
+        guardianShares: GuardianShare[];
         setupComplete: boolean;
     }>;
     /**
@@ -1096,7 +1534,7 @@ declare class Web3Passkey {
      * @param guardianShare - The guardian's share data
      * @param message - Optional custom message for the guardian
      */
-    generateGuardianInvite(guardianShare: any, message?: string): Promise<{
+    generateGuardianInvite(guardianShare: GuardianShare, message?: string): Promise<{
         qrCodeDataURL?: string;
         shareDocument: string;
         downloadBlob: Blob;
@@ -1104,25 +1542,45 @@ declare class Web3Passkey {
     }>;
     /**
      * Recover wallet from guardian shares
-     * Combines M-of-N guardian shares to reconstruct the backup file
+     * Combines M-of-N guardian shares to reconstruct the backup file, then
+     * restores it as restoreFromBackupFile() restores a password backup:
+     * logged out, the wallet stays in memory for register(); logged in, it
+     * replaces the stored wallet after a passkey assertion. The mnemonic is
+     * never returned.
      *
      * @param shares - Array of guardian share objects (JSON strings or parsed objects)
-     * @param password - Password to decrypt the backup (if password-protected)
+     * @param password - Password of the backup the shares rebuild
+     * @throws AddressChangeError when logged in with another address, without `allowAddressChange`
      */
-    recoverFromGuardians(shares: Array<string | any>, password?: string): Promise<{
-        mnemonic: string;
+    recoverFromGuardians(shares: Array<string | GuardianShare>, password: string, options?: {
+        allowAddressChange?: boolean;
+    }): Promise<{
         ethereumAddress: string;
     }>;
     /**
      * Restore wallet from backup file with existing passkey
      * Use case: User has passkey synced to this device
      *
-     * After restoration, you can either:
-     * - Use importMnemonic() to associate with current logged-in user
-     * - Use registerWithBackupFile() to create new passkey for this wallet
+     * When logged out, a restored password backup stays in memory: call
+     * register() to create a passkey for it, or log in and restore the file
+     * again to store it under that passkey. The mnemonic is never returned.
+     *
+     * A PRF backup takes one assertion with its passkey, no password, and sets
+     * this device up for that passkey (as importFromSync() does).
+     *
+     * When logged in, the restored wallet replaces the stored one only after
+     * the passkey assertion succeeds. A backup of another address than the
+     * logged-in one needs `allowAddressChange: true`, which the app sets once
+     * the user confirms the replacement.
+     *
+     * @throws UnsupportedBackupVersionError for a file that isn't BackupFile v3
+     * @throws SyncBootstrapError ('CREDENTIAL_MISMATCH') for a PRF backup of another passkey than the logged-in one
+     * @throws AddressChangeError for a backup of another address without `allowAddressChange`
+     * @throws AuthenticationError if the passkey prompt is cancelled, and PrfUnsupportedError if the authenticator returns no PRF output, when logged in (nothing stored changes)
      */
-    restoreFromBackupFile(backupData: string | Blob, password?: string): Promise<{
-        mnemonic: string;
+    restoreFromBackupFile(backupData: string | Blob, password?: string, options?: {
+        allowAddressChange?: boolean;
+    }): Promise<{
         ethereumAddress: string;
     }>;
     /**
@@ -1137,26 +1595,20 @@ declare class Web3Passkey {
      * A PRF backup (from exportForSync()) takes a single assertion restricted
      * to its passkey and no password.
      *
+     * A backup of another address than the one this device stores for the
+     * passkey needs `allowAddressChange: true`, which the app sets once the
+     * user confirms the replacement.
+     *
      * @param backupData - Backup file (JSON string or Blob) - can be pasted by user
      * @param password - Password to decrypt backup (if password-encrypted)
-     * @returns Restored wallet info
+     * @returns The restored wallet's address (the mnemonic is never returned)
+     * @throws AddressChangeError for a backup of another address than the passkey's, without `allowAddressChange` (nothing stored changes)
      */
-    syncWalletWithPasskey(backupData: string | Blob, password?: string): Promise<{
-        mnemonic: string;
+    syncWalletWithPasskey(backupData: string | Blob, password?: string, options?: {
+        allowAddressChange?: boolean;
+    }): Promise<{
         ethereumAddress: string;
     }>;
-    /**
-     * Restore a PRF backup with its passkey and set this device up for it.
-     * The public key is this device's when it has the passkey's metadata,
-     * else the backup's, checked against the assertion's signature.
-     */
-    private restorePrfBackup;
-    /**
-     * Set this device up for a passkey and a synced wallet: saves the
-     * passkey's metadata (or points it at the wallet), stores the wallet
-     * under the passkey-derived key and starts a session
-     */
-    private bootstrapCredential;
     /**
      * Register new passkey with wallet from backup file
      * Use case: Fresh device, user has backup file but no passkey yet
@@ -1174,7 +1626,7 @@ declare class Web3Passkey {
     /**
      * Get cross-device sync status
      */
-    getSyncStatus(): Promise<any>;
+    getSyncStatus(): Promise<DeviceSyncInfo | null>;
     /**
      * Export wallet for syncing to another device
      *
@@ -1185,6 +1637,7 @@ declare class Web3Passkey {
      *
      * @param password - Fallback password when PRF is unavailable
      * @throws PrfUnsupportedError when PRF is unavailable and no password is given
+     * @throws WeakPasswordError when isStrongPassword() refuses the password, with its feedback
      */
     exportForSync(password?: string): Promise<{
         blob: Blob;
@@ -1200,35 +1653,23 @@ declare class Web3Passkey {
      * login. For a password backup (exportForSync()'s fallback), use
      * syncWalletWithPasskey().
      *
+     * A backup of another address than the one this device stores for the
+     * passkey needs `allowAddressChange: true`, which the app sets once the
+     * user confirms the replacement.
+     *
      * @throws SyncBootstrapError ('CREDENTIAL_MISMATCH') when logged in with another passkey
+     * @throws AddressChangeError for a backup of another address than the passkey's, without `allowAddressChange` (nothing stored changes)
      */
-    importFromSync(syncData: string | Blob): Promise<{
+    importFromSync(syncData: string | Blob, options?: {
+        allowAddressChange?: boolean;
+    }): Promise<{
         ethereumAddress: string;
         success: boolean;
     }>;
     /**
      * Detect platform sync capabilities
      */
-    detectSyncCapabilities(): Promise<any>;
-    /**
-     * Simulate recovery scenario
-     */
-    simulateRecoveryScenario(scenario: {
-        type: "lost-device" | "lost-phrase" | "lost-both" | "switch-platform";
-        description: string;
-    }): Promise<any>;
-    /**
-     * Run interactive recovery test
-     */
-    runRecoveryTest(): Promise<{
-        scenarios: any[];
-        overallScore: number;
-        feedback: string;
-    }>;
-    /**
-     * Get educational content by topic
-     */
-    getEducation(topic: string): Promise<any>;
+    detectSyncCapabilities(): Promise<SyncCapabilities>;
     hasActiveSession(): boolean;
     getSessionRemainingTime(): number;
     /**
@@ -1273,18 +1714,84 @@ declare class Web3Passkey {
      */
     derivePrfSecret(tag: string): Promise<PrfSecret>;
     /**
-     * Derive ML-KEM-1024 public key from the current wallet
+     * Get the commitment of a Semaphore v4 identity bound to the passkey
+     *
+     * The identity's private key is a PRF secret for the current origin and
+     * `tag`, derived under its own label so `derivePrfSecret(tag)` can't
+     * return it. The private key is never returned or stored. A new
+     * credential gives a new commitment: keep `credentialId` with the
+     * commitment you add to a group, and replace the member when it changes.
+     *
+     * Requires the optional dependency `@semaphore-protocol/identity`.
+     *
+     * @param tag - Non-empty label without ':', e.g. "voting"
+     * @returns The identity commitment and the credential it is bound to
+     * @throws PrfUnsupportedError when the authenticator doesn't support PRF
+     * @throws CryptoError when `@semaphore-protocol/identity` isn't installed
+     *   (before any prompt) or the tag is invalid
+     *
+     * @example
+     * const { commitment, credentialId } = await w3pk.getSemaphoreIdentity("voting")
+     * group.addMember(commitment)
+     */
+    getSemaphoreIdentity(tag: string): Promise<SemaphoreIdentity>;
+    /**
+     * Prove with a secret bound to the passkey that the app never sees
+     *
+     * w3pk derives the secret for the current origin and `tag` (by default
+     * under its own `w3pk-zk-v1` label, or the Semaphore identity's
+     * `secretScalar`), places it in the witness with any inputs `options`
+     * declares as derived (Poseidon over the secret and other inputs) or
+     * random (fresh, discarded after the call), checks the artifacts against
+     * their pins, and runs snarkjs in a Web Worker (in-thread where `Worker`
+     * doesn't exist, as in Node, or the worker can't start). Only the proof
+     * and public signals come back;
+     * a proof whose public signals contain the secret or a random input is
+     * refused. Everything checkable without the passkey is checked before
+     * the prompt.
+     *
+     * Only public signals equal to the secret or a random input are refused:
+     * the circuit chooses its public signals and can output any function of
+     * the secret, the Semaphore secret included. Only prove with circuits
+     * you trust; the artifact pins say which circuit runs, not what it reveals.
+     *
+     * w3pk runs in the app's JavaScript context: this keeps the secret out
+     * of the API, not out of reach of malicious code on the same page.
+     *
+     * Requires the optional dependencies `snarkjs`, `poseidon-lite` (for
+     * derivations) and `@semaphore-protocol/identity` (for `"semaphore"`).
+     *
+     * @param tag - Non-empty label without ':', e.g. "voting"
+     * @param artifacts - The circuit's `.wasm` and `.zkey` (bytes or URLs) and their pinned CIDs
+     * @param publicInputs - The circuit's public inputs
+     * @param extraWitness - Other private inputs the app provides
+     * @param options - Secret source, its input name, derived and random inputs
+     * @throws ZkArtifactMismatchError when an artifact doesn't match its pin
+     * @throws PrfUnsupportedError when the authenticator doesn't support PRF
+     * @throws CryptoError on invalid inputs, missing dependencies or a failed proof
+     *
+     * @example
+     * const { proof, publicSignals } = await w3pk.zkProve(
+     *   "voting",
+     *   { wasm: wasmUrl, zkey: zkeyUrl, pins },
+     *   { proposalId, root },
+     *   { vote: 1 },
+     *   { secret: "semaphore", derive: { voteSecret: ["secret", "proposalId", 1n] }, random: ["r"] }
+     * )
+     */
+    zkProve(tag: string, artifacts: ZkProveArtifacts, publicInputs: ZkInputs, extraWitness?: ZkInputs, options?: ZkProveOptions): Promise<ZkProveResult>;
+    /**
+     * Derive the hybrid ML-KEM-1024 + X25519 public key from the current wallet
      *
      * Returns the public key that can be shared with others for encryption.
-     * The keypair is derived deterministically from the wallet's private key.
+     * The hybrid keypair is derived deterministically from the wallet's private key.
      *
      * @param options - Optional configuration
-     * @param options.context - Context string for domain separation (default: 'mlkem-v1')
+     * @param options.context - Context string for domain separation (default: MLKEM_DEFAULT_CONTEXT)
      * @param options.mode - Security mode (default: 'YOLO' to access private key)
      * @param options.tag - Tag for address derivation (default: 'MAIN')
-     * @param options.origin - Origin for derivation (default: current origin)
      * @param options.requireAuth - Force WebAuthn re-authentication
-     * @returns Base64-encoded ML-KEM public key (1568 bytes)
+     * @returns Base64-encoded hybrid public key (1600 bytes: ML-KEM-1024 || X25519)
      *
      * @example
      * ```typescript
@@ -1299,22 +1806,20 @@ declare class Web3Passkey {
         context?: string;
         mode?: SecurityMode;
         tag?: string;
-        origin?: string;
         requireAuth?: boolean;
     }): Promise<string>;
     /**
-     * Encrypt data using ML-KEM-1024 for self + additional recipients
+     * Encrypt data with the hybrid ML-KEM-1024 + X25519 KEM (payload v3) for self + additional recipients
      *
      * Encrypts data such that you (the sender) and specified recipients can decrypt.
-     * Your ML-KEM keypair is derived from your wallet, so you can always decrypt later.
+     * Your hybrid keypair is derived from your wallet, so you can always decrypt later.
      *
      * @param plaintext - The data to encrypt
-     * @param recipientPublicKeys - Array of recipient ML-KEM public keys (base64 strings or Uint8Arrays)
+     * @param recipientPublicKeys - Array of recipient hybrid public keys (base64 strings or Uint8Arrays, 1600 bytes)
      * @param options - Optional configuration
-     * @param options.context - Context string for key derivation (default: 'mlkem-v1')
+     * @param options.context - Context string for key derivation (default: MLKEM_DEFAULT_CONTEXT)
      * @param options.mode - Security mode (default: 'YOLO' to access private key)
      * @param options.tag - Tag for address derivation (default: 'MAIN')
-     * @param options.origin - Origin for derivation (default: current origin)
      * @param options.requireAuth - Force WebAuthn re-authentication
      * @returns Encrypted payload that can be decrypted by sender or recipients
      *
@@ -1340,21 +1845,19 @@ declare class Web3Passkey {
         context?: string;
         mode?: SecurityMode;
         tag?: string;
-        origin?: string;
         requireAuth?: boolean;
-    }): Promise<any>;
+    }): Promise<EncryptedPayload>;
     /**
      * Decrypt ML-KEM encrypted data using current wallet
      *
      * Decrypts data that was encrypted for this wallet.
-     * The ML-KEM keypair is derived from your wallet's private key.
+     * The hybrid keypair is derived from your wallet's private key. Only v3 payloads are read.
      *
      * @param payload - The encrypted payload (from mlkemEncrypt)
      * @param options - Optional configuration
-     * @param options.context - Context string for key derivation (default: 'mlkem-v1', must match encryption)
+     * @param options.context - Context string for key derivation (default: MLKEM_DEFAULT_CONTEXT, must match encryption)
      * @param options.mode - Security mode (default: 'YOLO' to access private key)
      * @param options.tag - Tag for address derivation (default: 'MAIN')
-     * @param options.origin - Origin for derivation (default: current origin)
      * @param options.requireAuth - Force WebAuthn re-authentication
      * @returns Decrypted plaintext
      *
@@ -1368,194 +1871,43 @@ declare class Web3Passkey {
      *
      * // Decrypt locally (server never sees plaintext!)
      * const plaintext = await w3pk.mlkemDecrypt(encrypted);
-     * ```
-     */
-    mlkemDecrypt(payload: any, options?: {
-        context?: string;
-        mode?: SecurityMode;
-        tag?: string;
-        origin?: string;
-        requireAuth?: boolean;
-    }): Promise<string>;
-}
-
-/**
- * Wallet-related types
- */
-interface WalletData {
-    address: string;
-    mnemonic: string;
-}
-/**
- * EIP-7702 Authorization signature components
- */
-interface EIP7702Authorization {
-    chainId: bigint;
-    address: string;
-    nonce: bigint;
-    yParity: number;
-    r: string;
-    s: string;
-}
-/**
- * Parameters for signing EIP-7702 authorization
- */
-interface SignAuthorizationParams {
-    contractAddress: string;
-    chainId?: number;
-    nonce?: bigint;
-    privateKey?: string;
-}
-
-/**
- * External Wallet EIP-7702 Authorization Utilities
- *
- * This module provides utilities for users to sign EIP-7702 authorizations
- * using external wallets (MetaMask, Rabby, hardware wallets, etc.) to delegate
- * their external wallet accounts to W3PK accounts.
- *
- * Use cases:
- * - Delegate ENS-linked addresses to W3PK for gasless transactions
- * - Integrate hardware wallets for enhanced security
- * - Enable multi-signature setups combining external and W3PK accounts
- * - Migrate existing wallet users to W3PK while maintaining their addresses
- *
- * Flow:
- * 1. User has an external wallet account (MetaMask, Ledger, etc.)
- * 2. User creates or has a W3PK account
- * 3. User signs EIP-7702 authorization delegating external account to W3PK account
- * 4. User includes authorization in transaction to activate delegation
- */
-
-/**
- * EIP-1193 Provider interface (MetaMask, Rabby, etc.)
- */
-interface EIP1193Provider {
-    request(args: {
-        method: string;
-        params?: any[];
-    }): Promise<any>;
-    on?(event: string, handler: (...args: any[]) => void): void;
-    removeListener?(event: string, handler: (...args: any[]) => void): void;
-}
-/**
- * Request user to sign EIP-7702 authorization with external wallet
- *
- * @param provider - EIP-1193 provider (window.ethereum)
- * @param params - Authorization parameters
- * @param params.delegateToAddress - The w3pk account address to delegate to
- * @param params.chainId - Chain ID for the authorization
- * @param params.nonce - Nonce (default: 0n)
- * @param params.accountIndex - Optional: request specific account from wallet (default: 0)
- * @returns EIP-7702 authorization object
- *
- * @example
- * ```typescript
- * import { requestExternalWalletAuthorization } from 'w3pk';
- *
- * // Get user's w3pk account
- * const w3pkAddress = w3pk.getAddress();
- *
- * // Request MetaMask to sign authorization
- * const authorization = await requestExternalWalletAuthorization(
- *   window.ethereum,
- *   {
- *     delegateToAddress: w3pkAddress,
- *     chainId: 1,
- *     nonce: 0n
- *   }
- * );
- *
- * // Use in transaction
- * await provider.request({
- *   method: 'eth_sendTransaction',
- *   params: [{
- *     to: someContract,
- *     data: txData,
- *     authorizationList: [authorization]
- *   }]
- * });
- * ```
- */
-declare function requestExternalWalletAuthorization(provider: EIP1193Provider, params: {
-    delegateToAddress: string;
-    chainId?: number;
-    nonce?: bigint;
-    accountIndex?: number;
-}): Promise<EIP7702Authorization>;
-/**
- * Get the default Ethereum provider (window.ethereum)
- * Handles multiple injected wallets and provider detection
- *
- * @returns EIP-1193 provider or null if not found
- */
-declare function getDefaultProvider(): EIP1193Provider | null;
-/**
- * Detect which wallet provider is being used
- *
- * @param provider - EIP-1193 provider
- * @returns Wallet name or 'Unknown'
- */
-declare function detectWalletProvider(provider: EIP1193Provider): string;
-/**
- * Check if a provider supports EIP-7702
- * Note: This is a best-effort check as EIP-7702 support is still rolling out
- *
- * @param provider - EIP-1193 provider
- * @returns true if provider likely supports EIP-7702
- */
-declare function supportsEIP7702Authorization(provider: EIP1193Provider): Promise<boolean>;
+     * ```
+     */
+    mlkemDecrypt(payload: EncryptedPayload, options?: {
+        context?: string;
+        mode?: SecurityMode;
+        tag?: string;
+        requireAuth?: boolean;
+    }): Promise<string>;
+}
 
 /**
- * EIP-7702 Utility Functions
- * Shared encoding logic to ensure consistency across all implementations
- */
-/**
- * Encode EIP-7702 authorization message
- *
- * @param chainId - Chain ID for the authorization
- * @param contractAddress - Contract address to delegate to
- * @param nonce - Nonce for the authorization
- * @returns Encoded authorization message bytes
- *
- * @spec EIP-7702: 0x05 || rlp([chain_id, address, nonce])
- */
-declare function encodeEIP7702AuthorizationMessage(chainId: bigint, contractAddress: string, nonce: bigint): string;
-/**
- * Hash EIP-7702 authorization message
- *
- * @param chainId - Chain ID for the authorization
- * @param contractAddress - Contract address to delegate to
- * @param nonce - Nonce for the authorization
- * @returns Keccak256 hash of the authorization message
+ * Wallet-related types
  */
-declare function hashEIP7702AuthorizationMessage(chainId: bigint, contractAddress: string, nonce: bigint): string;
+interface WalletData {
+    address: string;
+    mnemonic: string;
+}
 /**
- * Verify EIP-7702 authorization signature
- *
- * @param chainId - Chain ID for the authorization
- * @param contractAddress - Contract address being delegated to
- * @param nonce - Nonce for the authorization
- * @param signature - The signature components (yParity, r, s) or hex string
- * @param expectedSigner - The expected signer address
- * @returns true if signature is valid and from expected signer
- *
- * @example
- * ```typescript
- * const isValid = verifyEIP7702Authorization(
- *   1n,
- *   "0x742d35Cc6634C0532925a3b844Bc9e7595f0bEb1",
- *   0n,
- *   { yParity: 1, r: "0x...", s: "0x..." },
- *   "0x1234567890123456789012345678901234567890"
- * );
- * ```
+ * EIP-7702 Authorization signature components
  */
-declare function verifyEIP7702Authorization(chainId: bigint, contractAddress: string, nonce: bigint, signature: {
+interface EIP7702Authorization {
+    chainId: bigint;
+    address: string;
+    nonce: bigint;
     yParity: number;
     r: string;
     s: string;
-} | string, expectedSigner: string): boolean;
+}
+/**
+ * Parameters for signing EIP-7702 authorization
+ */
+interface SignAuthorizationParams {
+    contractAddress: string;
+    chainId?: number;
+    nonce?: bigint;
+    privateKey?: string;
+}
 
 /**
  * Sync Authentication Helper
@@ -1569,6 +1921,10 @@ interface PasskeySelectionResult {
     username?: string;
     /** The selection assertion, to verify against a public key from a backup */
     assertion: AuthenticationCredential;
+    /** Base64url challenge the assertion answers */
+    challenge: string;
+    /** PRF output at `PRF_INPUT`, the source of the wallet key; absent without PRF */
+    prfOutput?: ArrayBuffer;
 }
 /**
  * Prompts the user to select a passkey/webauthn credential
@@ -1603,6 +1959,14 @@ declare function deriveIndexFromOriginModeAndTag(origin: string, mode?: Security
  * - STANDARD mode: Private key NOT exposed, persistent sessions allowed
  * - STRICT mode: Private key NOT exposed, persistent sessions NOT allowed
  * - YOLO mode: Private key exposed, persistent sessions allowed
+ *
+ * The key is derived at `m/44'/60'/0'/0/{index}`, a non-hardened BIP-32 child.
+ * Under BIP-32, a leaked non-hardened child private key together with the
+ * parent extended public key (`m/44'/60'/0'/0`) reveals the parent private key
+ * and every sibling, so every origin's key. w3pk never exposes that extended
+ * public key, but a YOLO-mode private key must be treated as sensitive for the
+ * whole wallet, not only for its origin. The path is kept as is because
+ * changing it would move every origin address.
  */
 declare function getOriginSpecificAddress(mnemonic: string, origin: string, mode?: SecurityMode, tag?: string): Promise<{
     address: string;
@@ -1692,17 +2056,7 @@ declare function assertEthereumAddress(address: string): void;
 declare function assertUsername(username: string): void;
 declare function assertMnemonic(mnemonic: string): void;
 /**
- * Validates password strength based on security best practices
- * @param password - The password to validate
- * @returns true if password meets strength requirements, false otherwise
- *
- * Requirements:
- * - At least 12 characters long
- * - Contains at least one uppercase letter
- * - Contains at least one lowercase letter
- * - Contains at least one number
- * - Contains at least one special character
- * - Not a common password
+ * The password rules of backups: see validatePasswordStrength()
  */
 declare function isStrongPassword(password: string): boolean;
 
@@ -1732,6 +2086,7 @@ declare function getW3pkBuildHash(distUrl: string): Promise<string>;
 declare function getPackageVersion(): string;
 /**
  * Computes build hash for the current w3pk version from unpkg CDN
+ * (the published package, not the running code)
  * @returns IPFS CIDv1 hash of the build
  *
  * @example
@@ -1742,7 +2097,14 @@ declare function getPackageVersion(): string;
  */
 declare function getCurrentBuildHash(): Promise<string>;
 /**
- * Verifies if a given hash matches the current build
+ * Verifies if a given hash matches the build published on unpkg for the
+ * installed version
+ *
+ * This hashes the files fetched from unpkg, not the code actually running:
+ * a bundled, modified or injected copy is not checked, and compromised
+ * running code can return any result. Hash the files you ship at build time
+ * to check those.
+ *
  * @param expectedHash The hash to verify against
  * @returns true if hashes match, false otherwise
  *
@@ -1802,9 +2164,6 @@ declare function safeBtoa(input: string): string;
  */
 declare function base64UrlDecode(base64url: string): ArrayBuffer;
 
-/**
- * Cryptographic utility functions for WebAuthn and P-256 signatures
- */
 /**
  * Extracts r and s values from a DER-encoded ECDSA signature
  * Applies low-s normalization for Ethereum compatibility
@@ -1922,6 +2281,9 @@ declare function parseSiweMessage(message: string): SiweMessage;
 /**
  * Validate a SIWE message for correctness and expiration
  *
+ * `Issued At`, `Expiration Time` and `Not Before` must be valid dates, and
+ * the message fails once expired or before its not-before time.
+ *
  * @param message - SIWE message string or parsed object
  * @param options - Validation options
  * @returns Validation result with details
@@ -1929,7 +2291,7 @@ declare function parseSiweMessage(message: string): SiweMessage;
  * @example
  * const validation = validateSiweMessage(message, {
  *   domain: 'example.com',
- *   checkExpiration: true
+ *   chainId: 1
  * })
  *
  * if (validation.valid) {
@@ -1941,10 +2303,6 @@ declare function parseSiweMessage(message: string): SiweMessage;
 declare function validateSiweMessage(message: string | SiweMessage, options?: {
     /** Expected domain (validates domain matches) */
     domain?: string;
-    /** Check expiration time */
-    checkExpiration?: boolean;
-    /** Check not-before time */
-    checkNotBefore?: boolean;
     /** Expected chain ID */
     chainId?: number;
 }): {
@@ -1980,167 +2338,55 @@ declare function verifySiweSignature(message: string, signature: string, expecte
 }>;
 
 /**
- * Social Recovery Type Definitions
+ * EIP-7702 Utility Functions
+ * Shared encoding logic to ensure consistency across all implementations
  */
-interface Guardian {
-    id: string;
-    name: string;
-    email?: string;
-    phone?: string;
-    publicKey?: string;
-    shareEncrypted: string;
-    status: 'pending' | 'active' | 'revoked';
-    addedAt: string;
-    lastVerified?: string;
-}
-interface GuardianInvite {
-    guardianId: string;
-    qrCode: string;
-    shareCode: string;
-    explainer: string;
-    link?: string;
-}
-interface SocialRecoveryConfig {
-    threshold: number;
-    totalGuardians: number;
-    guardians: Guardian[];
-    createdAt: string;
-    ethereumAddress: string;
-}
-interface RecoveryShare {
-    guardianId: string;
-    share: string;
-    index: number;
-}
-interface RecoveryProgress {
-    collected: number;
-    required: number;
-    guardians: {
-        id: string;
-        name: string;
-        hasProvided: boolean;
-    }[];
-    canRecover: boolean;
-}
-
 /**
- * Social Recovery Manager
- * Manages guardian-based wallet recovery using Shamir Secret Sharing
+ * Encode EIP-7702 authorization message
+ *
+ * @param chainId - Chain ID for the authorization
+ * @param contractAddress - Contract address to delegate to
+ * @param nonce - Nonce for the authorization
+ * @returns Encoded authorization message bytes
+ *
+ * @spec EIP-7702: 0x05 || rlp([chain_id, address, nonce])
  */
-
-declare class SocialRecoveryManager {
-    private storageKey;
-    /**
-     * Get storage (localStorage or in-memory fallback)
-     */
-    private getItem;
-    /**
-     * Set storage (localStorage or in-memory fallback)
-     */
-    private setItem;
-    /**
-     * Set up social recovery
-     * Splits encrypted backup file into M-of-N shares and distributes to guardians
-     *
-     * @param backupFileJson - The complete backup file JSON string (password-encrypted)
-     * @param ethereumAddress - The Ethereum address for verification
-     * @param guardians - Array of guardian information
-     * @param threshold - Minimum number of guardians needed for recovery
-     */
-    setupSocialRecovery(backupFileJson: string, ethereumAddress: string, guardians: {
-        name: string;
-        email?: string;
-        phone?: string;
-    }[], threshold: number): Promise<Guardian[]>;
-    /**
-     * Get current social recovery configuration
-     */
-    getSocialRecoveryConfig(): SocialRecoveryConfig | null;
-    /**
-     * Generate guardian invitation
-     * Creates QR code and educational materials for guardian
-     */
-    generateGuardianInvite(guardian: Guardian): Promise<GuardianInvite>;
-    /**
-     * Generate QR code from share data
-     * Uses 'qrcode' library if available, falls back to canvas text
-     */
-    private generateQRCode;
-    /**
-     * Create fallback QR representation
-     */
-    private createPlaceholderQR;
-    /**
-     * Wrap text for display
-     */
-    private wrapText;
-    /**
-     * Get guardian explainer text
-     */
-    private getGuardianExplainer;
-    /**
-     * Recover backup file from guardian shares
-     * Returns the reconstructed backup file JSON that can be used with restoreFromBackupFile()
-     */
-    recoverFromGuardians(shareData: string[]): Promise<{
-        backupFileJson: string;
-        ethereumAddress: string;
-    }>;
-    /**
-     * Get recovery progress
-     */
-    getRecoveryProgress(collectedShares: string[]): RecoveryProgress;
-    /**
-     * Mark guardian as verified
-     * Note: This updates guardian status but does NOT automatically refresh security score.
-     * The security score will be updated on the next call to BackupManager.getBackupStatus()
-     */
-    markGuardianVerified(guardianId: string): void;
-    /**
-     * Revoke a guardian
-     */
-    revokeGuardian(guardianId: string): void;
-    /**
-     * Add new guardian (requires re-sharing with new backup file)
-     */
-    addGuardian(backupFileJson: string, newGuardian: {
-        name: string;
-        email?: string;
-        phone?: string;
-    }): Promise<Guardian>;
-}
-
+declare function encodeEIP7702AuthorizationMessage(chainId: bigint, contractAddress: string, nonce: bigint): string;
 /**
- * Cross-Device Sync Type Definitions
+ * Hash EIP-7702 authorization message
+ *
+ * @param chainId - Chain ID for the authorization
+ * @param contractAddress - Contract address to delegate to
+ * @param nonce - Nonce for the authorization
+ * @returns Keccak256 hash of the authorization message
  */
-interface SyncVault {
-    id: string;
-    encryptedData: string;
-    deviceFingerprints: string[];
-    syncMethod: 'icloud' | 'google' | 'microsoft' | 'custom';
-    version: number;
-    updatedAt: string;
-}
-interface DeviceInfo {
-    id: string;
-    name: string;
-    platform: 'ios' | 'android' | 'macos' | 'windows' | 'linux' | 'unknown';
-    lastActive: string;
-    trusted: boolean;
-    canRevoke: boolean;
-}
-interface SyncCapabilities {
-    passkeysSync: boolean;
-    platform: 'apple' | 'google' | 'microsoft' | 'none';
-    estimatedDevices: number;
-    syncEnabled: boolean;
-}
-interface SyncStatus {
-    enabled: boolean;
-    devices: DeviceInfo[];
-    lastSyncTime?: string;
-    platform: string;
-}
+declare function hashEIP7702AuthorizationMessage(chainId: bigint, contractAddress: string, nonce: bigint): string;
+/**
+ * Verify EIP-7702 authorization signature
+ *
+ * @param chainId - Chain ID for the authorization
+ * @param contractAddress - Contract address being delegated to
+ * @param nonce - Nonce for the authorization
+ * @param signature - The signature components (yParity, r, s) or hex string
+ * @param expectedSigner - The expected signer address
+ * @returns true if signature is valid and from expected signer
+ *
+ * @example
+ * ```typescript
+ * const isValid = verifyEIP7702Authorization(
+ *   1n,
+ *   "0x742d35Cc6634C0532925a3b844Bc9e7595f0bEb1",
+ *   0n,
+ *   { yParity: 1, r: "0x...", s: "0x..." },
+ *   "0x1234567890123456789012345678901234567890"
+ * );
+ * ```
+ */
+declare function verifyEIP7702Authorization(chainId: bigint, contractAddress: string, nonce: bigint, signature: {
+    yParity: number;
+    r: string;
+    s: string;
+} | string, expectedSigner: string): boolean;
 
 /**
  * Chainlist types
@@ -2195,11 +2441,11 @@ interface ChainlistOptions {
  */
 
 /**
- * Get RPC endpoints for a specific chain ID, excluding those that require API keys
+ * Get the HTTPS RPC endpoints for a specific chain ID, excluding those that require API keys
  *
  * @param chainId - The chain ID to get endpoints for
  * @param options - Optional configuration
- * @returns Array of RPC URLs that don't require API keys
+ * @returns Array of HTTPS RPC URLs that don't require API keys
  *
  * @example
  * ```typescript
@@ -2237,106 +2483,6 @@ declare function getChainById(chainId: number, options?: ChainlistOptions): Prom
  */
 declare function clearCache(): void;
 
-interface MLKemKeypair {
-    publicKey: Uint8Array;
-    privateKey: Uint8Array;
-}
-interface EncryptedPayload {
-    version?: 2;
-    recipients: Array<{
-        publicKey: string;
-        ciphertext: string;
-    }>;
-    encryptedData: string;
-    iv: string;
-    authTag: string;
-}
-/**
- * Derive deterministic ML-KEM-1024 keypair from any private key material
- *
- * Uses HKDF-SHA256 to derive a 64-byte seed from the input key material,
- * then generates a reproducible ML-KEM-1024 keypair.
- *
- * @param privateKey - Private key material (hex string with optional 0x prefix, or Uint8Array)
- * @param context - Context string for domain separation (default: 'mlkem-v1')
- * @returns ML-KEM-1024 keypair (publicKey: 1568 bytes, privateKey: 3168 bytes)
- *
- * @example
- * ```typescript
- * // Derive from Ethereum private key
- * const ethPrivateKey = '0x1234...';
- * const keypair = await deriveMLKemKeypair(ethPrivateKey, 'my-app');
- *
- * // Derive from any 32-byte key
- * const randomKey = crypto.getRandomValues(new Uint8Array(32));
- * const keypair2 = await deriveMLKemKeypair(randomKey);
- * ```
- */
-declare function deriveMLKemKeypair(privateKey: string | Uint8Array, context?: string): Promise<MLKemKeypair>;
-/**
- * Encrypt data using ML-KEM-1024 + AES-256-GCM for multiple recipients
- *
- * @param plaintext - The data to encrypt
- * @param publicKeys - Array of ML-KEM-1024 public keys (base64 strings or Uint8Arrays, 1568 bytes each)
- * @returns Encrypted payload with per-recipient ciphertexts and shared encrypted data
- */
-declare function mlkemEncrypt(plaintext: string, publicKeys: (string | Uint8Array) | Array<string | Uint8Array>): Promise<EncryptedPayload>;
-/**
- * Decrypt data encrypted with mlkemEncrypt()
- *
- * @param payload - The encrypted payload
- * @param privateKey - ML-KEM-1024 private key (base64 string or Uint8Array, 3168 bytes)
- * @param publicKey - Optional: Your public key to find the correct recipient entry (base64 string or Uint8Array, 1568 bytes)
- * @returns Decrypted plaintext
- */
-declare function mlkemDecrypt(payload: EncryptedPayload, privateKey: string | Uint8Array, publicKey?: string | Uint8Array): Promise<string>;
-/**
- * Encrypt data with ML-KEM using derived keypairs from private keys
- *
- * This is a convenience function that derives ML-KEM keypairs from private key material,
- * then encrypts the data for all recipients. The sender's keypair is derived and used
- * as one of the recipients.
- *
- * @param plaintext - The data to encrypt
- * @param senderPrivateKey - Sender's private key (hex string or Uint8Array)
- * @param recipientPublicKeys - Array of recipient ML-KEM public keys (from deriveMLKemKeypair)
- * @param senderContext - Context for sender's key derivation (default: 'mlkem-v1')
- * @returns Encrypted payload with sender + recipients
- *
- * @example
- * ```typescript
- * // Encrypt for yourself + server
- * const serverKeypair = await deriveMLKemKeypair(serverPrivateKey, 'server');
- * const encrypted = await mlkemEncryptWithKey(
- *   'secret data',
- *   myEthPrivateKey,
- *   [serverKeypair.publicKey]
- * );
- * ```
- */
-declare function mlkemEncryptWithKey(plaintext: string, senderPrivateKey: string | Uint8Array, recipientPublicKeys: Array<string | Uint8Array>, senderContext?: string): Promise<EncryptedPayload>;
-/**
- * Decrypt data with ML-KEM using a derived keypair from private key
- *
- * This is a convenience function that derives an ML-KEM keypair from private key material,
- * then decrypts the payload.
- *
- * @param payload - The encrypted payload
- * @param privateKey - Private key material (hex string or Uint8Array)
- * @param context - Context for key derivation (default: 'mlkem-v1')
- * @returns Decrypted plaintext
- *
- * @example
- * ```typescript
- * // Decrypt with your Ethereum private key
- * const plaintext = await mlkemDecryptWithKey(
- *   encryptedPayload,
- *   myEthPrivateKey
- * );
- * ```
- */
-declare function mlkemDecryptWithKey(payload: EncryptedPayload, privateKey: string | Uint8Array, context?: string): Promise<string>;
-
 declare function createWeb3Passkey(config?: Web3PasskeyConfig): Web3Passkey;
 
-export { ApiError, AuthenticationError, type BackupMethod, type BackupStatus, CryptoError, DEFAULT_MODE, DEFAULT_TAG, type DeviceInfo, type EIP1193Provider, type EIP7702Authorization, type EncryptedBackupInfo, type EncryptedPayload, type Guardian, type GuardianInvite, type MLKemKeypair, type PasskeySelectionResult, type PrfSecret, PrfUnsupportedError, type QRBackupOptions, type RecoveryProgress, type RecoveryScenario, type RecoveryShare, RecoverySimulator, RegistrationError, type SecurityScore, type SignAuthorizationParams, type SimulationResult, type SiweMessage, type SocialRecoveryConfig, SocialRecoveryManager, type StealthAddressConfig, StealthAddressModule, type StealthAddressResult, type StealthKeys, StorageError, SyncBootstrapError, type SyncBootstrapReason, type SyncCapabilities, SyncRequiredError, type SyncStatus, type SyncVault, type UserInfo, WalletError, type WalletInfo, WalletMissingError, Web3Passkey, type Web3PasskeyConfig, Web3PasskeyError, arrayBufferToBase64Url, assertEthereumAddress, assertMnemonic, assertUsername, authenticateWithPasskey, base64ToArrayBuffer, base64UrlDecode, base64UrlToArrayBuffer, canControlStealthAddress, checkStealthAddress, clearCache, computeStealthPrivateKey, createSiweMessage, createWalletFromMnemonic, createWeb3Passkey, createWeb3Passkey as default, deriveAddressFromP256PublicKey, deriveIndexFromOriginModeAndTag, deriveMLKemKeypair, deriveStealthKeys, deriveWalletFromMnemonic, detectWalletProvider, encodeEIP7702AuthorizationMessage, extractRS, generateBIP39Wallet, generateSiweNonce, generateStealthAddress, getAllChains, getAllTopics, getChainById, getCurrentBuildHash, getCurrentOrigin, getDefaultProvider, getEndpoints, getExplainer, getOriginSpecificAddress, getPackageVersion, getW3pkBuildHash, hashEIP7702AuthorizationMessage, isStrongPassword, mlkemDecrypt, mlkemDecryptWithKey, mlkemEncrypt, mlkemEncryptWithKey, normalizeOrigin, parseSiweMessage, promptPasskeySelection, requestExternalWalletAuthorization, safeAtob, safeBtoa, searchExplainers, supportsEIP7702Authorization, validateEthereumAddress, validateMnemonic, validateSiweMessage, validateUsername, verifyBuildHash, verifyEIP7702Authorization, verifySiweSignature };
+export { AddressChangeError, type Announcement, ApiError, AuthenticationError, type BackupMethod, type BackupStatus, type Chain, type ChainlistOptions, type CircuitArtifacts, CryptoError, DEFAULT_MODE, DEFAULT_TAG, type DerivedWallet, type DeviceSyncInfo, type EIP1193ProviderInterface, type EIP7702Authorization, type EncryptedBackupInfo, type EncryptedPayload, type GeneratedWallet, type Groth16Proof, type GuardianShare, MLKEM_DEFAULT_CONTEXT, type MLKemKeypair, type MembershipProofInput, type NFTOwnershipProofInput, type OwnershipProofInput, type ParseAnnouncementResult, type PasskeySelectionResult, type PersistentSessionConfig, type PrfSecret, PrfUnsupportedError, type ProofType, type ProviderConnectInfo, type ProviderMessage, type ProviderRpcError, type RangeProofInput, type RecoveryScenario, RecoverySimulator, type RegisterResult, RegistrationError, RemovedBackupMethodError, type SecurityMode, type SecurityScore, type SemaphoreIdentity, type SignAuthorizationParams, type SignMessageOptions, type SigningMethod, type SimulationResult, type SiweMessage, type StealthAddressConfig, StealthAddressModule, type StealthAddressResult, type StealthKeys, type StealthTransaction, StorageError, SyncBootstrapError, type SyncBootstrapReason, type SyncCapabilities, SyncRequiredError, type ThresholdProofInput, UnsupportedBackupVersionError, type UserInfo, type VerificationResult, WalletError, WalletMissingError, WeakPasswordError, Web3Passkey, type Web3PasskeyConfig, Web3PasskeyError, type ZKMethods, type ZKProof, type ZKProofConfig, ZkArtifactMismatchError, type ZkArtifactName, type ZkDerivationTerm, type ZkInputs, type ZkProveArtifacts, type ZkProveOptions, type ZkProveResult, type ZkSecretSource, type ZkSignal, arrayBufferToBase64Url, assertEthereumAddress, assertMnemonic, assertUsername, authenticateWithPasskey, base64ToArrayBuffer, base64UrlDecode, base64UrlToArrayBuffer, canControlStealthAddress, checkStealthAddress, clearCache, computeStealthPrivateKey, createSiweMessage, createWalletFromMnemonic, createWeb3Passkey, createWeb3Passkey as default, deriveAddressFromP256PublicKey, deriveIndexFromOriginModeAndTag, deriveMLKemKeypair, deriveStealthKeys, deriveWalletFromMnemonic, encodeEIP7702AuthorizationMessage, extractRS, generateBIP39Wallet, generateSiweNonce, generateStealthAddress, getAllChains, getAllTopics, getChainById, getCurrentBuildHash, getCurrentOrigin, getEndpoints, getExplainer, getOriginSpecificAddress, getPackageVersion, getW3pkBuildHash, hashEIP7702AuthorizationMessage, isStrongPassword, mlkemDecrypt, mlkemDecryptWithKey, mlkemEncrypt, mlkemEncryptWithKey, normalizeOrigin, parseSiweMessage, promptPasskeySelection, safeAtob, safeBtoa, searchExplainers, validateEthereumAddress, validateMnemonic, validateSiweMessage, validateUsername, verifyBuildHash, verifyEIP7702Authorization, verifySiweSignature };