@btc-vision/transaction 1.7.0 → 1.7.1

package/documentation/quantum-support/05-address-verification.md

@@ -0,0 +1,307 @@
+# Address Verification Guide
+
+## Table of Contents
+- [ML-DSA Public Key Validation](#ml-dsa-public-key-validation)
+- [Address Type Detection](#address-type-detection)
+- [Classical Address Validation](#classical-address-validation)
+- [Complete Validation Example](#complete-validation-example)
+
+## ML-DSA Public Key Validation
+
+### Validating ML-DSA Public Keys
+
+The `AddressVerificator` provides methods to validate ML-DSA public keys and determine their security level:
+
+```typescript
+import { AddressVerificator, MLDSASecurityLevel } from '@btc-vision/transaction';
+
+// Valid ML-DSA-44 public key (1312 bytes)
+const level2Key = Buffer.alloc(1312);
+const level2Check = AddressVerificator.isValidMLDSAPublicKey(level2Key);
+console.log('LEVEL2 valid:', level2Check);  // MLDSASecurityLevel.LEVEL2
+
+// Valid ML-DSA-65 public key (1952 bytes)
+const level3Key = Buffer.alloc(1952);
+const level3Check = AddressVerificator.isValidMLDSAPublicKey(level3Key);
+console.log('LEVEL3 valid:', level3Check);  // MLDSASecurityLevel.LEVEL3
+
+// Valid ML-DSA-87 public key (2592 bytes)
+const level5Key = Buffer.alloc(2592);
+const level5Check = AddressVerificator.isValidMLDSAPublicKey(level5Key);
+console.log('LEVEL5 valid:', level5Check);  // MLDSASecurityLevel.LEVEL5
+
+// Invalid length
+const invalidKey = Buffer.alloc(1000);
+const invalidCheck = AddressVerificator.isValidMLDSAPublicKey(invalidKey);
+console.log('Invalid:', invalidCheck);  // null
+```
+
+### Input Format Support
+
+Validation supports multiple input formats:
+
+```typescript
+import { AddressVerificator, MLDSASecurityLevel } from '@btc-vision/transaction';
+
+// Hex string (with 0x prefix)
+const hexWith0x = '0x' + 'a'.repeat(2624);  // 1312 bytes in hex
+const check1 = AddressVerificator.isValidMLDSAPublicKey(hexWith0x);
+console.log('Hex with 0x:', check1);  // MLDSASecurityLevel.LEVEL2
+
+// Hex string (without 0x prefix)
+const hexWithout0x = 'a'.repeat(2624);
+const check2 = AddressVerificator.isValidMLDSAPublicKey(hexWithout0x);
+console.log('Hex without 0x:', check2);  // MLDSASecurityLevel.LEVEL2
+
+// Buffer
+const buffer = Buffer.alloc(1312);
+const check3 = AddressVerificator.isValidMLDSAPublicKey(buffer);
+console.log('Buffer:', check3);  // MLDSASecurityLevel.LEVEL2
+
+// Uint8Array
+const uint8Array = new Uint8Array(1312);
+const check4 = AddressVerificator.isValidMLDSAPublicKey(uint8Array);
+console.log('Uint8Array:', check4);  // MLDSASecurityLevel.LEVEL2
+```
+
+### Validating Wallet Keys
+
+```typescript
+import { Mnemonic, AddressVerificator, MLDSASecurityLevel } from '@btc-vision/transaction';
+import { networks } from '@btc-vision/bitcoin';
+
+// Generate wallet
+const mnemonic = Mnemonic.generate(undefined, '', networks.bitcoin, MLDSASecurityLevel.LEVEL2);
+const wallet = mnemonic.derive(0);
+
+// Validate quantum public key
+const quantumKeyHex = wallet.quantumPublicKeyHex;
+const securityLevel = AddressVerificator.isValidMLDSAPublicKey(quantumKeyHex);
+
+console.log('Quantum key valid:', securityLevel !== null);
+console.log('Security level:', securityLevel);  // MLDSASecurityLevel.LEVEL2
+console.log('Expected:', wallet.securityLevel);  // MLDSASecurityLevel.LEVEL2
+console.log('Match:', securityLevel === wallet.securityLevel);  // true
+```
+
+### Error Cases
+
+```typescript
+// Empty string
+console.log(AddressVerificator.isValidMLDSAPublicKey(''));  // null
+
+// Empty Buffer
+console.log(AddressVerificator.isValidMLDSAPublicKey(Buffer.alloc(0)));  // null
+
+// Invalid hex
+console.log(AddressVerificator.isValidMLDSAPublicKey('not hex'));  // null
+
+// Wrong length (classical key size)
+const classicalKey = Buffer.alloc(33);
+console.log(AddressVerificator.isValidMLDSAPublicKey(classicalKey));  // null
+
+// Wrong length (arbitrary size)
+const wrongSize = Buffer.alloc(1500);
+console.log(AddressVerificator.isValidMLDSAPublicKey(wrongSize));  // null
+```
+
+## Address Type Detection
+
+### Detecting Address Types
+
+```typescript
+import { AddressVerificator, AddressTypes } from '@btc-vision/transaction';
+import { networks } from '@btc-vision/bitcoin';
+
+const wallet = mnemonic.derive(0);
+
+// P2TR Detection
+const p2tr = wallet.p2tr;
+const p2trType = AddressVerificator.detectAddressType(p2tr, networks.bitcoin);
+console.log('P2TR type:', p2trType);  // AddressTypes.P2TR
+
+// P2WPKH Detection
+const p2wpkh = wallet.p2wpkh;
+const p2wpkhType = AddressVerificator.detectAddressType(p2wpkh, networks.bitcoin);
+console.log('P2WPKH type:', p2wpkhType);  // AddressTypes.P2WPKH
+
+// P2PKH Detection
+const p2pkh = wallet.p2pkh;
+const p2pkhType = AddressVerificator.detectAddressType(p2pkh, networks.bitcoin);
+console.log('P2PKH type:', p2pkhType);  // AddressTypes.P2PKH
+```
+
+### Available Address Types
+
+```typescript
+enum AddressTypes {
+    P2PKH = 'P2PKH',                      // Legacy (1...)
+    P2SH_OR_P2SH_P2WPKH = 'P2SH_OR_P2SH-P2WPKH',  // Script hash (3...)
+    P2PK = 'P2PK',                        // Public key
+    P2TR = 'P2TR',                        // Taproot (bc1p...)
+    P2WPKH = 'P2WPKH',                    // SegWit (bc1q...)
+    P2WSH = 'P2WSH',                      // SegWit script (bc1q...)
+    P2WDA = 'P2WDA',                      // Witness data auth
+}
+```
+
+### Distinguishing Similar Addresses
+
+```typescript
+const wallet = mnemonic.derive(0);
+
+// P2TR vs P2WPKH (both Bech32 formats)
+const p2tr = wallet.p2tr;
+const p2wpkh = wallet.p2wpkh;
+
+const p2trType = AddressVerificator.detectAddressType(p2tr, networks.bitcoin);
+const p2wpkhType = AddressVerificator.detectAddressType(p2wpkh, networks.bitcoin);
+
+console.log('P2TR detected as:', p2trType);  // AddressTypes.P2TR
+console.log('P2WPKH detected as:', p2wpkhType);  // AddressTypes.P2WPKH
+console.log('Different types:', p2trType !== p2wpkhType);  // true
+```
+
+### Network-Specific Detection
+
+```typescript
+// Mainnet address on mainnet
+const mainnetAddr = wallet.p2tr;
+const mainnetDetect = AddressVerificator.detectAddressType(mainnetAddr, networks.bitcoin);
+console.log('Mainnet on mainnet:', mainnetDetect);  // AddressTypes.P2TR
+
+// Mainnet address on wrong network
+const wrongNetwork = AddressVerificator.detectAddressType(mainnetAddr, networks.testnet);
+console.log('Mainnet on testnet:', wrongNetwork);  // null
+```
+
+## Classical Address Validation
+
+### Validating Classical Public Keys
+
+```typescript
+import { AddressVerificator } from '@btc-vision/transaction';
+import { networks } from '@btc-vision/bitcoin';
+
+const wallet = mnemonic.derive(0);
+
+// Validate compressed public key (33 bytes)
+const compressedKey = wallet.toPublicKeyHex();
+const isValid = AddressVerificator.isValidPublicKey(compressedKey, networks.bitcoin);
+console.log('Compressed key valid:', isValid);  // true
+
+// Validate uncompressed public key (65 bytes)
+const uncompressedKey = wallet.toUncompressedPublicKey().toString('hex');
+const isUncompressedValid = AddressVerificator.isValidPublicKey(uncompressedKey, networks.bitcoin);
+console.log('Uncompressed key valid:', isUncompressedValid);  // true
+```
+
+### Validating Other Address Types
+
+```typescript
+// P2TR validation
+const p2tr = wallet.p2tr;
+const isP2TRValid = AddressVerificator.isValidP2TRAddress(p2tr, networks.bitcoin);
+console.log('P2TR valid:', isP2TRValid);  // true
+
+// P2WPKH validation
+const p2wpkh = wallet.p2wpkh;
+const isP2WPKHValid = AddressVerificator.isP2WPKHAddress(p2wpkh, networks.bitcoin);
+console.log('P2WPKH valid:', isP2WPKHValid);  // true
+
+// P2PKH or P2SH validation
+const p2pkh = wallet.p2pkh;
+const isLegacyValid = AddressVerificator.isP2PKHOrP2SH(p2pkh, networks.bitcoin);
+console.log('Legacy valid:', isLegacyValid);  // true
+```
+
+## Complete Validation Example
+
+```typescript
+import {
+    Mnemonic,
+    AddressVerificator,
+    AddressTypes,
+    MLDSASecurityLevel,
+} from '@btc-vision/transaction';
+import { networks } from '@btc-vision/bitcoin';
+
+// Generate wallet
+const mnemonic = Mnemonic.generate(undefined, '', networks.bitcoin, MLDSASecurityLevel.LEVEL2);
+const wallet = mnemonic.derive(0);
+
+console.log('=== ML-DSA Public Key Validation ===');
+
+// Validate quantum public key
+const quantumKeyHex = wallet.quantumPublicKeyHex;
+const quantumKeyBuffer = wallet.quantumPublicKey;
+
+const securityLevelFromHex = AddressVerificator.isValidMLDSAPublicKey(quantumKeyHex);
+const securityLevelFromBuffer = AddressVerificator.isValidMLDSAPublicKey(quantumKeyBuffer);
+
+console.log('Hex validation:', securityLevelFromHex);  // MLDSASecurityLevel.LEVEL2
+console.log('Buffer validation:', securityLevelFromBuffer);  // MLDSASecurityLevel.LEVEL2
+console.log('Matches wallet:', securityLevelFromHex === wallet.securityLevel);  // true
+
+console.log('\n=== Address Type Detection ===');
+
+// Detect all address types
+const addresses = {
+    p2tr: wallet.p2tr,
+    p2wpkh: wallet.p2wpkh,
+    p2pkh: wallet.p2pkh,
+};
+
+for (const [name, addr] of Object.entries(addresses)) {
+    const type = AddressVerificator.detectAddressType(addr, networks.bitcoin);
+    console.log(`${name}: ${type}`);
+}
+
+console.log('\n=== Classical Key Validation ===');
+
+// Validate classical public key
+const classicalKey = wallet.toPublicKeyHex();
+const isClassicalValid = AddressVerificator.isValidPublicKey(classicalKey, networks.bitcoin);
+
+console.log('Classical key:', classicalKey);
+console.log('Classical valid:', isClassicalValid);  // true
+
+console.log('\n=== Cross-Network Validation ===');
+
+// Test network mismatch
+const mainnetP2TR = wallet.p2tr;
+const testnetMnemonic = Mnemonic.generate(undefined, '', networks.testnet, MLDSASecurityLevel.LEVEL2);
+const testnetWallet = testnetMnemonic.derive(0);
+const testnetP2TR = testnetWallet.p2tr;
+
+const mainnetType = AddressVerificator.detectAddressType(mainnetP2TR, networks.bitcoin);
+const wrongNetworkType = AddressVerificator.detectAddressType(mainnetP2TR, networks.testnet);
+
+console.log('Mainnet P2TR on mainnet:', mainnetType);  // AddressTypes.P2TR
+console.log('Mainnet P2TR on testnet:', wrongNetworkType);  // null
+
+console.log('\n=== Complete Wallet Validation ===');
+
+function validateWallet(wallet: any, network: any): boolean {
+    // Validate quantum key
+    const quantumValid = AddressVerificator.isValidMLDSAPublicKey(
+        wallet.quantumPublicKey
+    ) !== null;
+
+    // Validate classical key
+    const classicalValid = AddressVerificator.isValidPublicKey(
+        wallet.toPublicKeyHex(),
+        network
+    );
+
+    return quantumValid && classicalValid;
+}
+
+const isWalletValid = validateWallet(wallet, networks.bitcoin);
+console.log('Complete wallet validation:', isWalletValid);  // true
+```
+
+## Next Steps
+
+- [Message Signing](./04-message-signing.md) - Sign and verify messages
+- [Introduction](./01-introduction.md) - Back to overview

package/documentation/quantum-support/README.md

@@ -0,0 +1,65 @@
+# OPNet ML-DSA Quantum Support Documentation
+
+Welcome to the OPNet ML-DSA (Post-Quantum Cryptography) documentation! This guide will help you integrate quantum-resistant signatures and addresses into your OPNet applications.
+
+## Documentation Index
+
+### [1. Introduction to ML-DSA](./01-introduction.md)
+Learn about ML-DSA (Module-Lattice-Based Digital Signature Algorithm), the hybrid quantum-classical architecture, and when to use quantum-resistant cryptography.
+
+**Topics covered:**
+- What is ML-DSA and post-quantum cryptography
+- Three security levels: **LEVEL2 (BIP360 RECOMMENDED DEFAULT)**, LEVEL3, LEVEL5
+- Hybrid classical + quantum architecture
+- Quick start guide
+- When to use ML-DSA vs classical crypto
+
+### [2. Mnemonic & Wallet Management](./02-mnemonic-and-wallet.md)
+Complete guide to generating and managing quantum-resistant wallets using BIP39 mnemonics and BIP360 quantum key derivation.
+
+**Topics covered:**
+- Generating new mnemonics with quantum support
+- Loading existing mnemonics
+- Deriving wallets (single and multiple)
+- Wallet properties (classical and quantum keys)
+- Security best practices
+- Network awareness
+- Advanced usage
+
+### [3. Address Generation](./03-address-generation.md)
+Learn to generate P2OP and classical Bitcoin addresses for all networks.
+
+**Topics covered:**
+- P2OP addresses (Pay-to-OPNet, for contract addresses)
+- Classical addresses (P2TR, P2WPKH, P2PKH, P2SH)
+- P2WDA (Witness Data Authentication)
+- Network support (mainnet, testnet, regtest)
+- Address comparison and ordering
+- Time-locked addresses (CSV)
+- Address caching
+
+### [4. Message Signing](./04-message-signing.md)
+Sign and verify messages using ML-DSA (quantum) and Schnorr (classical) signatures. Includes detailed explanation of `QuantumBIP32Factory.fromPublicKey()` usage for signature verification.
+
+**Topics covered:**
+- ML-DSA message signing and verification
+- Schnorr message signing
+- Multiple input formats (string, Buffer, Uint8Array, hex)
+- Cross-format verification
+- Tweaked signatures for Taproot
+- Message hashing (SHA-256)
+- Best practices
+
+### [5. Address Verification](./05-address-verification.md)
+Validate ML-DSA public keys and detect classical address types.
+
+**Topics covered:**
+- ML-DSA public key validation
+- Address type detection
+- Classical address validation
+- Network-specific validation
+- Complete validation examples
+
+---
+
+**Ready to get started?** Begin with the [Introduction](./01-introduction.md)!

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "@btc-vision/transaction",
     "type": "module",
-    "version": "1.7.0",
+    "version": "1.7.1",
     "author": "BlobMaster41",
     "description": "OPNet transaction library allows you to create and sign transactions for the OPNet network.",
     "engines": {

package/src/_version.ts

@@ -1 +1 @@
-export const version = '1.7.0';
+export const version = '1.7.1';

package/src/mnemonic/BIPStandard.ts

@@ -0,0 +1,92 @@
+/**
+ * BIP (Bitcoin Improvement Proposal) derivation path standards
+ *
+ * These define standardized derivation paths for different address types
+ * in hierarchical deterministic (HD) wallets.
+ *
+ * @see https://github.com/bitcoin/bips
+ */
+export enum BIPStandard {
+    /**
+     * BIP44: Multi-Account Hierarchy for Deterministic Wallets
+     *
+     * Path: m/44'/coin_type'/account'/change/address_index
+     * Original standard for P2PKH (legacy) addresses
+     * Widely used by wallets like Unisat for all address types
+     *
+     * @see https://github.com/bitcoin/bips/blob/master/bip-0044.mediawiki
+     */
+    BIP44 = 44,
+
+    /**
+     * BIP49: Derivation scheme for P2WPKH-nested-in-P2SH based accounts
+     *
+     * Path: m/49'/coin_type'/account'/change/address_index
+     * For wrapped SegWit addresses (P2SH-P2WPKH starting with '3')
+     *
+     * @see https://github.com/bitcoin/bips/blob/master/bip-0049.mediawiki
+     */
+    BIP49 = 49,
+
+    /**
+     * BIP84: Derivation scheme for P2WPKH based accounts
+     *
+     * Path: m/84'/coin_type'/account'/change/address_index
+     * For native SegWit addresses (P2WPKH starting with 'bc1q')
+     * DEFAULT for this library
+     *
+     * @see https://github.com/bitcoin/bips/blob/master/bip-0084.mediawiki
+     */
+    BIP84 = 84,
+
+    /**
+     * BIP86: Derivation scheme for P2TR based accounts
+     *
+     * Path: m/86'/coin_type'/account'/change/address_index
+     * For Taproot addresses (P2TR starting with 'bc1p')
+     *
+     * @see https://github.com/bitcoin/bips/blob/master/bip-0086.mediawiki
+     */
+    BIP86 = 86,
+}
+
+/**
+ * Get a human-readable description of a BIP standard
+ *
+ * @param standard - The BIP standard
+ * @returns A description of the standard and its typical use case
+ */
+export function getBIPDescription(standard: BIPStandard): string {
+    switch (standard) {
+        case BIPStandard.BIP44:
+            return 'BIP44: Legacy addresses (P2PKH), widely used by Unisat and other wallets';
+        case BIPStandard.BIP49:
+            return 'BIP49: Wrapped SegWit addresses (P2SH-P2WPKH)';
+        case BIPStandard.BIP84:
+            return 'BIP84: Native SegWit addresses (P2WPKH) - DEFAULT';
+        case BIPStandard.BIP86:
+            return 'BIP86: Taproot addresses (P2TR)';
+        default:
+            return 'Unknown BIP standard';
+    }
+}
+
+/**
+ * Build a derivation path for a given BIP standard
+ *
+ * @param standard - The BIP standard to use
+ * @param coinType - The coin type (0 for mainnet, 1 for testnet/regtest)
+ * @param account - The account index
+ * @param change - The change index (0 for receiving, 1 for change)
+ * @param addressIndex - The address index
+ * @returns The full derivation path
+ */
+export function buildBIPPath(
+    standard: BIPStandard,
+    coinType: number,
+    account: number,
+    change: number,
+    addressIndex: number,
+): string {
+    return `m/${standard}'/${coinType}'/${account}'/${change}/${addressIndex}`;
+}

package/src/mnemonic/Mnemonic.ts

@@ -10,11 +10,15 @@ import * as ecc from '@bitcoinerlab/secp256k1';
 import { initEccLib, Network, networks } from '@btc-vision/bitcoin';
 import { Wallet } from '../keypair/Wallet.js';
 import { MnemonicStrength } from './MnemonicStrength.js';
+import { BIPStandard, buildBIPPath } from './BIPStandard.js';
+import { AddressTypes } from '../keypair/AddressVerificator.js';
 
 initEccLib(ecc);
 
 const bip32 = BIP32Factory(ecc);
 
+export { BIPStandard, getBIPDescription } from './BIPStandard.js';
+
 /**
  * Mnemonic class for managing BIP39 mnemonic phrases with BIP360 quantum support
  *
@@ -189,7 +193,7 @@ export class Mnemonic {
     }
 
     /**
-     * Derive a wallet at a specific index using BIP360 (quantum) and BIP84 (classical) paths
+     * Derive a wallet at a specific index using BIP360 (quantum) and configurable BIP standard (classical) paths
      *
      * This method derives both classical ECDSA/Schnorr keys and quantum-resistant ML-DSA keys
      * for the wallet, providing hybrid post-quantum security.
@@ -197,11 +201,29 @@ export class Mnemonic {
      * @param index - The address index to derive (default: 0)
      * @param account - The account index (default: 0)
      * @param isChange - Whether this is a change address (default: false)
+     * @param bipStandard - The BIP standard to use for classical derivation (default: BIP84)
      * @returns A Wallet instance with both classical and quantum keys
+     *
+     * @example
+     * ```typescript
+     * // Default: BIP84 (Native SegWit)
+     * const wallet1 = mnemonic.derive(0);
+     *
+     * // BIP44 (Compatible with Unisat)
+     * const wallet2 = mnemonic.derive(0, 0, false, BIPStandard.BIP44);
+     *
+     * // BIP86 (Taproot)
+     * const wallet3 = mnemonic.derive(0, 0, false, BIPStandard.BIP86);
+     * ```
      */
-    public derive(index: number = 0, account: number = 0, isChange: boolean = false): Wallet {
-        // Derive classical key using BIP84 (Native SegWit)
-        const classicalPath = this.buildClassicalPath(account, index, isChange);
+    public derive(
+        index: number = 0,
+        account: number = 0,
+        isChange: boolean = false,
+        bipStandard: BIPStandard = BIPStandard.BIP84,
+    ): Wallet {
+        // Derive classical key using specified BIP standard
+        const classicalPath = this.buildClassicalPath(account, index, isChange, bipStandard);
         const classicalChild = this._classicalRoot.derivePath(classicalPath);
 
         if (!classicalChild.privateKey) {
@@ -225,6 +247,101 @@ export class Mnemonic {
         );
     }
 
+    /**
+     * Derive a Unisat-compatible wallet
+     *
+     * Unisat uses different derivation paths based on address type:
+     * - Legacy (P2PKH): m/44'/coinType'/account'/change/index
+     * - Nested SegWit (P2SH-P2WPKH): m/49'/coinType'/account'/change/index
+     * - Native SegWit (P2WPKH): m/84'/coinType'/account'/change/index
+     * - Taproot (P2TR): m/86'/coinType'/account'/change/index
+     *
+     * @param addressType - The address type to generate
+     * @param index - The address index (default: 0)
+     * @param account - The account index (default: 0)
+     * @param isChange - Whether this is a change address (default: false)
+     * @returns A Wallet instance with both classical and quantum keys
+     */
+    public deriveUnisat(
+        addressType: AddressTypes = AddressTypes.P2TR,
+        index: number = 0,
+        account: number = 0,
+        isChange: boolean = false,
+    ): Wallet {
+        // Determine BIP purpose based on address type
+        let purpose: number;
+        switch (addressType) {
+            case AddressTypes.P2PKH:
+                purpose = 44;
+                break;
+            case AddressTypes.P2SH_OR_P2SH_P2WPKH:
+                purpose = 49;
+                break;
+            case AddressTypes.P2WPKH:
+                purpose = 84;
+                break;
+            case AddressTypes.P2TR:
+                purpose = 86;
+                break;
+            default:
+                throw new Error(`Unsupported address type: ${addressType}`);
+        }
+
+        // Build classical derivation path for Unisat
+        const coinType = this.getCoinType();
+        const change = isChange ? 1 : 0;
+        const classicalPath = `m/${purpose}'/0'/${account}'/${change}/${index}`;
+
+        // Derive classical key
+        const classicalChild = this._classicalRoot.derivePath(classicalPath);
+
+        if (!classicalChild.privateKey) {
+            throw new Error(`Failed to derive classical private key at path ${classicalPath}`);
+        }
+
+        // Derive quantum key using BIP360
+        const quantumPath = `m/360'/${coinType}'/${account}'/${change}/${index}`;
+        const quantumChild = this._quantumRoot.derivePath(quantumPath);
+
+        if (!quantumChild.privateKey) {
+            throw new Error(`Failed to derive quantum private key at path ${quantumPath}`);
+        }
+
+        // Create wallet with both classical and quantum keys
+        return new Wallet(
+            Buffer.from(classicalChild.privateKey).toString('hex'),
+            Buffer.from(quantumChild.privateKey).toString('hex'),
+            this._network,
+            this._securityLevel,
+        );
+    }
+
+    /**
+     * Derive multiple Unisat-compatible wallets
+     *
+     * @param addressType - The address type to generate
+     * @param count - Number of wallets to derive
+     * @param startIndex - Starting index (default: 0)
+     * @param account - The account index (default: 0)
+     * @param isChange - Whether these are change addresses (default: false)
+     * @returns Array of Wallet instances
+     */
+    public deriveMultipleUnisat(
+        addressType: AddressTypes = AddressTypes.P2TR,
+        count: number = 5,
+        startIndex: number = 0,
+        account: number = 0,
+        isChange: boolean = false,
+    ): Wallet[] {
+        const wallets: Wallet[] = [];
+
+        for (let i = 0; i < count; i++) {
+            wallets.push(this.deriveUnisat(addressType, startIndex + i, account, isChange));
+        }
+
+        return wallets;
+    }
+
     /**
      * Derive multiple wallets with sequential indices
      *
@@ -232,6 +349,7 @@ export class Mnemonic {
      * @param startIndex - The starting address index (default: 0)
      * @param account - The account index (default: 0)
      * @param isChange - Whether these are change addresses (default: false)
+     * @param bipStandard - The BIP standard to use for classical derivation (default: BIP84)
      * @returns An array of Wallet instances
      */
     public deriveMultiple(
@@ -239,11 +357,12 @@ export class Mnemonic {
         startIndex: number = 0,
         account: number = 0,
         isChange: boolean = false,
+        bipStandard: BIPStandard = BIPStandard.BIP84,
     ): Wallet[] {
         const wallets: Wallet[] = [];
 
         for (let i = 0; i < count; i++) {
-            wallets.push(this.derive(startIndex + i, account, isChange));
+            wallets.push(this.derive(startIndex + i, account, isChange, bipStandard));
         }
 
         return wallets;
@@ -296,17 +415,23 @@ export class Mnemonic {
     }
 
     /**
-     * Build a classical derivation path (BIP84 for Native SegWit)
+     * Build a classical derivation path using specified BIP standard
      *
      * @param account - The account index
      * @param index - The address index
      * @param isChange - Whether this is a change address
+     * @param bipStandard - The BIP standard to use (default: BIP84)
      * @returns The derivation path string
      */
-    private buildClassicalPath(account: number, index: number, isChange: boolean): string {
+    private buildClassicalPath(
+        account: number,
+        index: number,
+        isChange: boolean,
+        bipStandard: BIPStandard = BIPStandard.BIP84,
+    ): string {
         const coinType = this.getCoinType();
         const change = isChange ? 1 : 0;
-        return `m/84'/${coinType}'/${account}'/${change}/${index}`;
+        return buildBIPPath(bipStandard, coinType, account, change, index);
     }
 
     /**

package/src/opnet.ts

@@ -33,6 +33,7 @@ export * from './keypair/Wallet.js';
 /** Mnemonic */
 export * from './mnemonic/Mnemonic.js';
 export * from './mnemonic/MnemonicStrength.js';
+export * from './mnemonic/BIPStandard.js';
 
 /** Quantum (ML-DSA) */
 export {