@btc-vision/wallet-sdk 1.0.7 → 2.0.0

package/dist/index.d.ts

@@ -0,0 +1,841 @@
+import { AddressTypes } from '@btc-vision/transaction';
+import * as bitcoin from '@btc-vision/bitcoin';
+import { ECPairInterface } from 'ecpair';
+import { MLDSASecurityLevel } from '@btc-vision/transaction';
+import { MnemonicStrength } from '@btc-vision/transaction';
+import { Network } from '@btc-vision/bitcoin';
+import { OPNetNetwork } from '@btc-vision/transaction';
+import { Psbt } from '@btc-vision/bitcoin';
+import { QuantumBIP32Factory } from '@btc-vision/transaction';
+import { QuantumBIP32Interface } from '@btc-vision/transaction';
+import { Wallet } from '@btc-vision/transaction';
+
+/**
+ * Abstract wallet interface
+ */
+export declare interface AbstractWallet {
+    signPsbt(psbt: Psbt, opts?: SignPsbtOptions): Promise<Psbt> | Psbt;
+    signMessage(message: string | Buffer, method: MessageSigningMethod): Promise<string>;
+}
+
+/**
+ * All address types for an account
+ */
+export declare interface AccountAddresses {
+    readonly p2pkh?: string;
+    readonly p2wpkh?: string;
+    readonly p2tr?: string;
+    readonly p2shP2wpkh?: string;
+}
+
+/**
+ * Wallet account information
+ */
+export declare interface AccountInfo {
+    readonly index: number;
+    readonly publicKey: string;
+    readonly quantumPublicKey: string;
+    readonly addresses: AccountAddresses;
+}
+
+/**
+ * Sign input with address specification
+ */
+export declare interface AddressSignInput extends BaseSignInput {
+    readonly address: string;
+}
+
+/**
+ * Convert an address to its scriptPubKey
+ */
+export declare function addressToScriptPubKey(address: string, network: Network): Buffer;
+
+/**
+ * Base interface for inputs to sign in a PSBT
+ */
+export declare interface BaseSignInput {
+    readonly index: number;
+    readonly sighashTypes?: readonly number[];
+    readonly disableTweakSigner?: boolean;
+}
+
+/**
+ * BIP322 signature result
+ */
+export declare interface Bip322Signature {
+    readonly address: string;
+    readonly message: string | Buffer;
+    readonly signature: string;
+    readonly networkType: OPNetNetwork;
+}
+
+/**
+ * Classical key pair information
+ */
+export declare interface ClassicalKeyInfo {
+    readonly publicKey: Buffer;
+    readonly privateKey?: Buffer;
+}
+
+/**
+ * Decode an address to get its network type, address type, and scriptPubKey
+ */
+export declare function decodeAddress(address: string): DecodedAddress | null;
+
+/**
+ * Result of an address decode operation
+ */
+export declare interface DecodedAddress {
+    readonly networkType: OPNetNetwork;
+    readonly addressType: AddressTypes;
+    readonly scriptPubKey: Buffer;
+}
+
+/**
+ * HD derivation options
+ */
+export declare interface DerivationOptions {
+    readonly addressType?: AddressTypes;
+    readonly account?: number;
+    readonly change?: boolean;
+    readonly index?: number;
+}
+
+/**
+ * Deserialize string to unified export
+ */
+export declare function deserializeExport(serialized: string): UnifiedWalletExport;
+
+/**
+ * Detect the address type from an address string
+ */
+export declare function detectAddressType(address: string, network: Network): AddressTypes | null;
+
+/**
+ * Detect network type from an address
+ */
+export declare function detectNetworkFromAddress(address: string): OPNetNetwork | null;
+
+/**
+ * Exported wallet format for unified key export
+ */
+export declare interface ExportedWallet {
+    readonly version: number;
+    readonly classicalPrivateKey: string;
+    readonly quantumPrivateKey: string;
+    readonly quantumPublicKey: string;
+    readonly securityLevel: MLDSASecurityLevel;
+    readonly chainCode: string;
+}
+
+/**
+ * Export wallet keys to unified format
+ */
+export declare function exportWallet(classicalPrivateKey: Buffer, classicalPublicKey: Buffer, quantumPrivateKey: Uint8Array, quantumPublicKey: Uint8Array, chainCode: Buffer, securityLevel: MLDSASecurityLevel, network: Network): UnifiedWalletExport;
+
+/**
+ * Export wallet to portable string format
+ */
+export declare function exportWalletToString(classicalPrivateKey: Buffer, classicalPublicKey: Buffer, quantumPrivateKey: Uint8Array, quantumPublicKey: Uint8Array, chainCode: Buffer, securityLevel: MLDSASecurityLevel, network: Network): string;
+
+/**
+ * Extract signature from a signed BIP322 PSBT
+ */
+export declare function extractBip322Signature(psbt: Psbt): string;
+
+/**
+ * Convert legacy ExportedWallet format to unified format
+ */
+export declare function fromLegacyExport(legacy: ExportedWallet, network: Network): UnifiedWalletExport;
+
+/**
+ * Generate a PSBT for BIP322 simple message signing
+ */
+export declare function generateBip322Psbt(message: string | Buffer, address: string, network: Network): Psbt;
+
+/**
+ * Get address type with OPNetNetwork parameter
+ */
+export declare function getAddressType(address: string, networkType: OPNetNetwork): AddressTypes | null;
+
+/**
+ * Get the bech32 prefix for a network type
+ */
+export declare function getBech32Prefix(networkType: OPNetNetwork): string;
+
+/**
+ * HD Keyring with quantum-resistant cryptography support.
+ * Supports BIP39 mnemonic phrases with BIP360 quantum key derivation.
+ */
+export declare class HdKeyring {
+    static readonly type = "HD Key Tree";
+    readonly type = "HD Key Tree";
+    private mnemonic;
+    private readonly wallets;
+    private readonly activeIndexes;
+    private readonly network;
+    private readonly securityLevel;
+    private readonly passphrase;
+    private addressType;
+    constructor(options?: HdKeyringOptions);
+    /**
+     * Generate a new mnemonic with quantum support
+     */
+    static generate(strength?: MnemonicStrength, passphrase?: string, network?: Network, securityLevel?: MLDSASecurityLevel): HdKeyring;
+    /**
+     * Initialize from an existing mnemonic phrase
+     */
+    initFromMnemonic(phrase: string): void;
+    /**
+     * Get the mnemonic phrase
+     */
+    getMnemonic(): string;
+    /**
+     * Check if keyring has a mnemonic
+     */
+    hasMnemonic(): boolean;
+    /**
+     * Derive a wallet at a specific index using Unisat-compatible derivation
+     */
+    deriveWallet(index: number): Wallet;
+    /**
+     * Derive a wallet using standard (non-Unisat) derivation
+     */
+    deriveStandardWallet(index: number): Wallet;
+    /**
+     * Add new accounts to the keyring
+     */
+    addAccounts(numberOfAccounts?: number): string[];
+    /**
+     * Activate specific account indexes
+     */
+    activateAccounts(indexes: number[]): string[];
+    /**
+     * Get all active account public keys
+     */
+    getAccounts(): string[];
+    /**
+     * Get detailed account info for all active accounts
+     */
+    getAccountsInfo(): AccountInfo[];
+    /**
+     * Get quantum public key for an account
+     */
+    getQuantumPublicKey(publicKey: string): string;
+    /**
+     * Get the index for a public key
+     */
+    getIndexByPublicKey(publicKey: string): number | null;
+    /**
+     * Get addresses for a specific public key
+     */
+    getAddressesForPublicKey(publicKey: string): AccountAddresses;
+    /**
+     * Get an address for a public key and address type
+     */
+    getAddress(publicKey: string, addressType: AddressTypes): string;
+    /**
+     * Remove an account by public key
+     */
+    removeAccount(publicKey: string): void;
+    /**
+     * Export the private key for an account
+     */
+    exportAccount(publicKey: string): string;
+    /**
+     * Sign a PSBT transaction
+     */
+    signTransaction(psbt: Psbt, inputs: readonly ToSignInput[]): Psbt;
+    /**
+     * Sign arbitrary data with ECDSA or Schnorr
+     */
+    signData(publicKey: string, data: string, type?: 'ecdsa' | 'schnorr'): string;
+    /**
+     * Get the Wallet for a public key
+     */
+    getWallet(publicKey: string): Wallet;
+    /**
+     * Serialize the keyring state
+     */
+    serialize(): HdKeyringOptions;
+    /**
+     * Get active indexes
+     */
+    getActiveIndexes(): readonly number[];
+    /**
+     * Change the address type for new derivations
+     */
+    setAddressType(addressType: AddressTypes): void;
+    /**
+     * Get current address type
+     */
+    getAddressType(): AddressTypes;
+    /**
+     * Get the security level
+     */
+    getSecurityLevel(): MLDSASecurityLevel;
+    /**
+     * Get the network
+     */
+    getNetwork(): Network;
+    /**
+     * Get paginated addresses for display
+     */
+    getAddressesPage(page: number, perPage?: number): {
+        address: string;
+        index: number;
+    }[];
+    /**
+     * Get the chain code for a wallet
+     */
+    getChainCode(publicKey: string): Buffer;
+    /**
+     * Get ML-DSA keypair for quantum operations
+     */
+    getMLDSAKeypair(publicKey: string): QuantumBIP32Interface;
+    private findWalletByPublicKey;
+    private getAddressFromWallet;
+}
+
+/**
+ * HD Keyring deserialization options
+ */
+export declare interface HdKeyringOptions {
+    readonly mnemonic?: string | undefined;
+    readonly passphrase?: string | undefined;
+    readonly network?: Network | undefined;
+    readonly securityLevel?: MLDSASecurityLevel | undefined;
+    readonly activeIndexes?: readonly number[] | undefined;
+    readonly addressType?: AddressTypes | undefined;
+}
+
+/**
+ * Import wallet keys from unified format
+ */
+export declare function importWallet(exportData: UnifiedWalletExport): {
+    keypair: ECPairInterface;
+    quantumKeypair: ReturnType<typeof QuantumBIP32Factory.fromPrivateKey>;
+    network: Network;
+    securityLevel: MLDSASecurityLevel;
+    chainCode: Buffer;
+};
+
+/**
+ * Import wallet from portable string format
+ */
+export declare function importWalletFromString(serialized: string): {
+    keypair: ECPairInterface;
+    quantumKeypair: ReturnType<typeof QuantumBIP32Factory.fromPrivateKey>;
+    network: Network;
+    securityLevel: MLDSASecurityLevel;
+    chainCode: Buffer;
+};
+
+/**
+ * Type guard to check if sign input has address
+ */
+export declare function isAddressSignInput(input: SignInput): input is AddressSignInput;
+
+/**
+ * Check if an address is P2PKH or P2SH
+ */
+export declare function isP2PKHOrP2SHAddress(address: string, network: Network): boolean;
+
+/**
+ * Check if an address is P2WPKH
+ */
+export declare function isP2WPKHAddress(address: string, network: Network): boolean;
+
+/**
+ * Type guard to check if sign input has public key
+ */
+export declare function isPublicKeySignInput(input: SignInput): input is PublicKeySignInput;
+
+/**
+ * Validate if an address is valid for the given network
+ */
+export declare function isValidAddress(address: string, network: Network): boolean;
+
+/**
+ * Convert OPNetNetwork to Network and validate address
+ */
+export declare function isValidAddressForNetworkType(address: string, networkType: OPNetNetwork): boolean;
+
+/**
+ * Validate a Taproot (P2TR) address
+ */
+export declare function isValidP2TRAddress(address: string, network: Network): boolean;
+
+/**
+ * Validate a public key using AddressVerificator
+ */
+export declare function isValidPublicKey(publicKey: Buffer | string, network: Network): boolean;
+
+/**
+ * Keyring serialization options
+ */
+export declare interface KeyringSerializeOptions {
+    readonly includePrivateKeys?: boolean;
+}
+
+/**
+ * Keystone hardware wallet key information
+ */
+export declare interface KeystoneKey {
+    readonly path: string;
+    readonly extendedPublicKey: string;
+}
+
+/**
+ * Keystone keyring options
+ */
+export declare interface KeystoneKeyringOptions {
+    readonly mfp: string;
+    readonly keys: readonly KeystoneKey[];
+    readonly network?: Network;
+    readonly activeIndexes?: readonly number[];
+    readonly addressType?: AddressTypes;
+}
+
+/**
+ * Local wallet implementation with full signing capabilities.
+ */
+export declare class LocalWallet implements AbstractWallet {
+    private readonly keyring;
+    private readonly network;
+    private readonly addressType;
+    private readonly publicKey;
+    private readonly address;
+    private constructor();
+    /**
+     * Create wallet from WIF
+     */
+    static fromWIF(wif: string, addressType: AddressTypes | undefined, network: Network, quantumPrivateKey?: string): LocalWallet;
+    /**
+     * Create wallet from private key hex
+     */
+    static fromPrivateKey(privateKeyHex: string, addressType: AddressTypes | undefined, network: Network, quantumPrivateKey?: string): LocalWallet;
+    /**
+     * Create wallet from mnemonic
+     */
+    static fromMnemonic(mnemonic: string, addressType: AddressTypes | undefined, network: Network, passphrase?: string, accountIndex?: number): LocalWallet;
+    /**
+     * Create a random wallet
+     */
+    static random(addressType?: AddressTypes, network?: Network): LocalWallet;
+    /**
+     * Get the wallet address
+     */
+    getAddress(): string;
+    /**
+     * Get the public key
+     */
+    getPublicKey(): string;
+    /**
+     * Get the quantum public key
+     */
+    getQuantumPublicKey(): string;
+    /**
+     * Get the network
+     */
+    getNetwork(): Network;
+    /**
+     * Get the address type
+     */
+    getAddressType(): AddressTypes;
+    /**
+     * Sign a PSBT
+     */
+    signPsbt(psbt: Psbt, opts?: SignPsbtOptions): Psbt;
+    /**
+     * Sign a message
+     */
+    signMessage(message: string | Buffer, method: MessageSigningMethod): Promise<string>;
+    /**
+     * Sign raw data
+     */
+    signData(data: string, type?: 'ecdsa' | 'schnorr'): string;
+    /**
+     * Export the private key
+     */
+    exportPrivateKey(): string;
+    /**
+     * Export the quantum private key
+     */
+    exportQuantumPrivateKey(): string;
+    /**
+     * Export WIF
+     */
+    exportWIF(): string;
+    private getKeypair;
+    private getQuantumKeypair;
+    private formatInputsToSign;
+}
+
+/**
+ * Message input type - can be string, Buffer, or Uint8Array
+ */
+export declare type MessageInput = string | Buffer | Uint8Array;
+
+/**
+ * Message signing method types
+ */
+export declare type MessageSigningMethod = 'bip322-simple' | 'ecdsa' | 'schnorr' | 'mldsa';
+
+/**
+ * Result of ML-DSA signature operation
+ */
+export declare interface MLDSASignatureResult {
+    readonly message: MessageInput;
+    readonly signature: Uint8Array;
+    readonly publicKey: Uint8Array;
+    readonly securityLevel: MLDSASecurityLevel;
+}
+
+/**
+ * Mnemonic options for wallet generation
+ */
+export declare interface MnemonicOptions {
+    readonly phrase?: string;
+    readonly passphrase?: string;
+    readonly network?: Network;
+    readonly securityLevel?: MLDSASecurityLevel;
+}
+
+/**
+ * Sign input with public key specification
+ */
+export declare interface PublicKeySignInput extends BaseSignInput {
+    readonly publicKey: string;
+}
+
+/**
+ * Generate a Bitcoin address from a public key
+ */
+export declare function publicKeyToAddress(publicKey: Buffer | string, addressType: AddressTypes, network: Network): string;
+
+/**
+ * Convert OPNetNetwork-based operations to Network-based
+ */
+export declare function publicKeyToAddressWithNetworkType(publicKey: Buffer | string, addressType: AddressTypes, networkType: OPNetNetwork): string;
+
+/**
+ * Generate a payment object from a public key
+ */
+export declare function publicKeyToPayment(publicKey: Buffer | string, addressType: AddressTypes, network: Network): bitcoin.Payment;
+
+/**
+ * Generate scriptPubKey from a public key
+ */
+export declare function publicKeyToScriptPubKey(publicKey: Buffer | string, addressType: AddressTypes, network: Network): Buffer;
+
+/**
+ * Quantum key pair information
+ */
+export declare interface QuantumKeyInfo {
+    readonly publicKey: Uint8Array;
+    readonly securityLevel: MLDSASecurityLevel;
+}
+
+/**
+ * Result of Schnorr signature operation
+ */
+export declare interface SchnorrSignatureResult {
+    readonly message: MessageInput;
+    readonly signature: Uint8Array;
+    readonly publicKey: Uint8Array;
+}
+
+/**
+ * Convert scriptPubKey to an address
+ */
+export declare function scriptPubKeyToAddress(scriptPubKey: Buffer | string, network: Network): string;
+
+/**
+ * Serialize unified export to string (base64 encoded JSON)
+ */
+export declare function serializeExport(exportData: UnifiedWalletExport): string;
+
+/**
+ * Signature type for message signing operations
+ */
+export declare type SignatureType = 'ecdsa' | 'schnorr' | 'mldsa';
+
+/**
+ * Sign a message using BIP322 simple format
+ */
+export declare function signBip322Message(message: string | Buffer, address: string, network: Network, signPsbt: (psbt: Psbt) => Promise<Psbt>): Promise<string>;
+
+/**
+ * Sign a message using BIP322 with OPNetNetwork parameter
+ */
+export declare function signBip322MessageWithNetworkType(message: string | Buffer, address: string, networkType: OPNetNetwork, signPsbt: (psbt: Psbt) => Promise<Psbt>): Promise<Bip322Signature>;
+
+/**
+ * Message signature result
+ */
+export declare interface SignedMessage {
+    readonly message: string | Buffer;
+    readonly signature: Uint8Array;
+    readonly publicKey: Uint8Array;
+    readonly signatureType: SignatureType;
+    readonly securityLevel?: MLDSASecurityLevel;
+}
+
+/**
+ * Union type for sign inputs
+ */
+export declare type SignInput = AddressSignInput | PublicKeySignInput;
+
+/**
+ * Sign message with automatic type selection
+ */
+export declare function signMessage(keypair: ECPairInterface | QuantumBIP32Interface, message: MessageInput, signatureType: SignatureType): SignedMessage;
+
+/**
+ * Sign a message with ML-DSA (quantum-resistant)
+ */
+export declare function signMLDSA(keypair: QuantumBIP32Interface, message: MessageInput): MLDSASignatureResult;
+
+/**
+ * Options for signing PSBTs
+ */
+export declare interface SignPsbtOptions {
+    readonly autoFinalized?: boolean;
+    readonly toSignInputs?: readonly SignInput[];
+}
+
+/**
+ * Sign a message with Schnorr (classical)
+ */
+export declare function signSchnorr(keypair: ECPairInterface, message: MessageInput): SchnorrSignatureResult;
+
+/**
+ * Sign a message with tweaked key for Taproot
+ */
+export declare function signTweakedSchnorr(keypair: ECPairInterface, message: MessageInput, network?: Network): SchnorrSignatureResult;
+
+/**
+ * Simple Keyring for single key pair management with quantum support.
+ * When importing from WIF or private key, a quantum key must be provided or generated.
+ */
+export declare class SimpleKeyring {
+    static readonly type = "Simple Key Pair";
+    readonly type = "Simple Key Pair";
+    private readonly network;
+    private readonly securityLevel;
+    private keypair;
+    private quantumKeypair;
+    private chainCode;
+    constructor(options?: SimpleKeyringOptions);
+    /**
+     * Generate a new random key pair with quantum support
+     */
+    static generate(network?: Network, securityLevel?: MLDSASecurityLevel): SimpleKeyring;
+    /**
+     * Import from WIF (Wallet Import Format) with mandatory quantum key
+     */
+    static fromWIF(wif: string, quantumPrivateKey: string | undefined, network?: Network, securityLevel?: MLDSASecurityLevel): SimpleKeyring;
+    /**
+     * Import from hex private key with mandatory quantum key
+     */
+    static fromPrivateKey(privateKeyHex: string, quantumPrivateKey: string | undefined, network?: Network, securityLevel?: MLDSASecurityLevel): SimpleKeyring;
+    /**
+     * Import a private key (WIF or hex format)
+     */
+    importPrivateKey(privateKey: string, quantumPrivateKey?: string): void;
+    /**
+     * Import an existing quantum private key
+     */
+    importQuantumKey(quantumPrivateKeyHex: string): void;
+    /**
+     * Generate a fresh quantum key pair
+     */
+    generateFreshQuantumKey(): void;
+    /**
+     * Check if keyring has keys
+     */
+    hasKeys(): boolean;
+    /**
+     * Get the classical public key
+     */
+    getPublicKey(): string;
+    /**
+     * Get the quantum public key
+     */
+    getQuantumPublicKey(): string;
+    /**
+     * Get the quantum public key hash (universal identifier)
+     */
+    getQuantumPublicKeyHash(): string;
+    /**
+     * Get all accounts (returns array with single public key)
+     */
+    getAccounts(): string[];
+    /**
+     * Get addresses for the key pair
+     */
+    getAddresses(): AccountAddresses;
+    /**
+     * Get an address for a specific type
+     */
+    getAddress(addressType: AddressTypes): string;
+    /**
+     * Export the classical private key
+     */
+    exportPrivateKey(): string;
+    /**
+     * Export the quantum private key with chain code
+     */
+    exportQuantumPrivateKey(): string;
+    /**
+     * Export WIF format
+     */
+    exportWIF(): string;
+    /**
+     * Sign a PSBT transaction
+     */
+    signTransaction(psbt: Psbt, inputs: readonly ToSignInput[]): Psbt;
+    /**
+     * Sign arbitrary data with ECDSA or Schnorr
+     */
+    signData(data: string, type?: 'ecdsa' | 'schnorr'): string;
+    /**
+     * Verify a signature
+     */
+    verify(data: string, signature: string, type?: 'ecdsa' | 'schnorr'): boolean;
+    /**
+     * Get the keypair
+     */
+    getKeypair(): ECPairInterface;
+    /**
+     * Get the quantum keypair
+     */
+    getQuantumKeypair(): QuantumBIP32Interface;
+    /**
+     * Get the chain code
+     */
+    getChainCode(): Buffer;
+    /**
+     * Get the security level
+     */
+    getSecurityLevel(): MLDSASecurityLevel;
+    /**
+     * Get the network
+     */
+    getNetwork(): Network;
+    /**
+     * Serialize the keyring state (excludes private keys for safety)
+     */
+    serialize(): SimpleKeyringOptions;
+    /**
+     * Remove the key (clear keyring)
+     */
+    clear(): void;
+}
+
+/**
+ * Simple keyring options for WIF/private key import
+ */
+export declare interface SimpleKeyringOptions {
+    readonly privateKey: string;
+    readonly quantumPrivateKey?: string | undefined;
+    readonly network?: Network | undefined;
+    readonly securityLevel?: MLDSASecurityLevel | undefined;
+}
+
+/**
+ * Convert OPNetNetwork enum to @btc-vision/bitcoin Network object
+ */
+export declare function toNetwork(networkType: OPNetNetwork): Network;
+
+/**
+ * Convert @btc-vision/bitcoin Network object to OPNetNetwork enum
+ */
+export declare function toNetworkType(network: Network): OPNetNetwork;
+
+/**
+ * Internal representation of inputs to sign
+ */
+export declare interface ToSignInput {
+    readonly index: number;
+    readonly publicKey: string;
+    readonly sighashTypes?: readonly number[];
+    readonly disableTweakSigner?: boolean;
+}
+
+/**
+ * Unified wallet export format
+ */
+export declare interface UnifiedWalletExport {
+    readonly magic: string;
+    readonly version: number;
+    readonly network: string;
+    readonly classical: {
+        readonly privateKey: string;
+        readonly publicKey: string;
+    };
+    readonly quantum: {
+        readonly privateKey: string;
+        readonly publicKey: string;
+        readonly securityLevel: MLDSASecurityLevel;
+        readonly chainCode: string;
+    };
+    readonly checksum: string;
+}
+
+/**
+ * Validate that an address matches the expected network
+ */
+export declare function validateAddressNetwork(address: string, expectedNetwork: OPNetNetwork): boolean;
+
+/**
+ * Validate export data without importing
+ */
+export declare function validateExport(exportData: UnifiedWalletExport): boolean;
+
+/**
+ * Verify a BIP322 simple message signature
+ */
+export declare function verifyBip322Message(address: string, message: string | Buffer, signature: string, network: Network): boolean;
+
+/**
+ * Verify a BIP322 signature with OPNetNetwork parameter
+ */
+export declare function verifyBip322MessageWithNetworkType(address: string, message: string | Buffer, signature: string, networkType: OPNetNetwork): boolean;
+
+/**
+ * Verify message with automatic type detection
+ */
+export declare function verifyMessage(publicKey: Buffer | Uint8Array, message: MessageInput, signature: Uint8Array, signatureType: SignatureType, chainCode?: Buffer, network?: Network, securityLevel?: MLDSASecurityLevel): boolean;
+
+/**
+ * Verify an ML-DSA signature
+ */
+export declare function verifyMLDSA(publicKey: Uint8Array, chainCode: Buffer, network: Network, securityLevel: MLDSASecurityLevel, message: MessageInput, signature: Uint8Array): boolean;
+
+/**
+ * Verify an ML-DSA signature using an existing keypair
+ */
+export declare function verifyMLDSAWithKeypair(keypair: QuantumBIP32Interface, message: MessageInput, signature: Uint8Array): boolean;
+
+/**
+ * Verify a Schnorr signature
+ */
+export declare function verifySchnorr(publicKey: Buffer | Uint8Array, message: MessageInput, signature: Uint8Array): boolean;
+
+/**
+ * Verify a tweaked Schnorr signature
+ */
+export declare function verifyTweakedSchnorr(publicKey: Buffer | Uint8Array, message: MessageInput, signature: Uint8Array): boolean;
+
+/**
+ * Combined wallet key information (classical + quantum)
+ */
+export declare interface WalletKeyInfo {
+    readonly classical: ClassicalKeyInfo;
+    readonly quantum: QuantumKeyInfo;
+    readonly chainCode: Buffer;
+}
+
+export { }