@btc-vision/transaction 1.6.19 → 1.7.0

package/test/addressverificator-mldsa.test.ts

@@ -0,0 +1,473 @@
+import { describe, expect, it } from 'vitest';
+import { AddressTypes, AddressVerificator, MLDSASecurityLevel, Mnemonic } from '../build/opnet.js';
+import { networks } from '@btc-vision/bitcoin';
+
+describe('AddressVerificator ML-DSA Support', () => {
+    const testMnemonic =
+        'abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon about';
+
+    describe('isValidMLDSAPublicKey', () => {
+        it('should validate ML-DSA-44 (Level 2) public key from hex string', () => {
+            const mnemonic = new Mnemonic(
+                testMnemonic,
+                '',
+                networks.bitcoin,
+                MLDSASecurityLevel.LEVEL2,
+            );
+            const wallet = mnemonic.derive(0);
+            const publicKeyHex = wallet.quantumPublicKeyHex;
+
+            const securityLevel = AddressVerificator.isValidMLDSAPublicKey(publicKeyHex);
+
+            expect(securityLevel).toBe(MLDSASecurityLevel.LEVEL2);
+        });
+
+        it('should validate ML-DSA-44 (Level 2) public key from hex string with 0x prefix', () => {
+            const mnemonic = new Mnemonic(
+                testMnemonic,
+                '',
+                networks.bitcoin,
+                MLDSASecurityLevel.LEVEL2,
+            );
+            const wallet = mnemonic.derive(0);
+            const publicKeyHex = '0x' + wallet.quantumPublicKeyHex;
+
+            const securityLevel = AddressVerificator.isValidMLDSAPublicKey(publicKeyHex);
+
+            expect(securityLevel).toBe(MLDSASecurityLevel.LEVEL2);
+        });
+
+        it('should validate ML-DSA-44 (Level 2) public key from Buffer', () => {
+            const mnemonic = new Mnemonic(
+                testMnemonic,
+                '',
+                networks.bitcoin,
+                MLDSASecurityLevel.LEVEL2,
+            );
+            const wallet = mnemonic.derive(0);
+            const publicKeyBuffer = wallet.quantumPublicKey;
+
+            const securityLevel = AddressVerificator.isValidMLDSAPublicKey(publicKeyBuffer);
+
+            expect(securityLevel).toBe(MLDSASecurityLevel.LEVEL2);
+        });
+
+        it('should validate ML-DSA-44 (Level 2) public key from Uint8Array', () => {
+            const mnemonic = new Mnemonic(
+                testMnemonic,
+                '',
+                networks.bitcoin,
+                MLDSASecurityLevel.LEVEL2,
+            );
+            const wallet = mnemonic.derive(0);
+            const publicKeyArray = new Uint8Array(wallet.quantumPublicKey);
+
+            const securityLevel = AddressVerificator.isValidMLDSAPublicKey(publicKeyArray);
+
+            expect(securityLevel).toBe(MLDSASecurityLevel.LEVEL2);
+        });
+
+        it('should validate ML-DSA-65 (Level 3) public key', () => {
+            const mnemonic = new Mnemonic(
+                testMnemonic,
+                '',
+                networks.bitcoin,
+                MLDSASecurityLevel.LEVEL3,
+            );
+            const wallet = mnemonic.derive(0);
+            const publicKeyHex = wallet.quantumPublicKeyHex;
+
+            const securityLevel = AddressVerificator.isValidMLDSAPublicKey(publicKeyHex);
+
+            expect(securityLevel).toBe(MLDSASecurityLevel.LEVEL3);
+        });
+
+        it('should validate ML-DSA-65 (Level 3) public key from Buffer', () => {
+            const mnemonic = new Mnemonic(
+                testMnemonic,
+                '',
+                networks.bitcoin,
+                MLDSASecurityLevel.LEVEL3,
+            );
+            const wallet = mnemonic.derive(0);
+            const publicKeyBuffer = wallet.quantumPublicKey;
+
+            const securityLevel = AddressVerificator.isValidMLDSAPublicKey(publicKeyBuffer);
+
+            expect(securityLevel).toBe(MLDSASecurityLevel.LEVEL3);
+        });
+
+        it('should validate ML-DSA-87 (Level 5) public key', () => {
+            const mnemonic = new Mnemonic(
+                testMnemonic,
+                '',
+                networks.bitcoin,
+                MLDSASecurityLevel.LEVEL5,
+            );
+            const wallet = mnemonic.derive(0);
+            const publicKeyHex = wallet.quantumPublicKeyHex;
+
+            const securityLevel = AddressVerificator.isValidMLDSAPublicKey(publicKeyHex);
+
+            expect(securityLevel).toBe(MLDSASecurityLevel.LEVEL5);
+        });
+
+        it('should validate ML-DSA-87 (Level 5) public key from Buffer', () => {
+            const mnemonic = new Mnemonic(
+                testMnemonic,
+                '',
+                networks.bitcoin,
+                MLDSASecurityLevel.LEVEL5,
+            );
+            const wallet = mnemonic.derive(0);
+            const publicKeyBuffer = wallet.quantumPublicKey;
+
+            const securityLevel = AddressVerificator.isValidMLDSAPublicKey(publicKeyBuffer);
+
+            expect(securityLevel).toBe(MLDSASecurityLevel.LEVEL5);
+        });
+
+        it('should reject invalid hex string', () => {
+            const invalidHex = 'not a valid hex string';
+            const securityLevel = AddressVerificator.isValidMLDSAPublicKey(invalidHex);
+
+            expect(securityLevel).toBeNull();
+        });
+
+        it('should reject public key with wrong length', () => {
+            const wrongLength = 'a'.repeat(100);
+            const securityLevel = AddressVerificator.isValidMLDSAPublicKey(wrongLength);
+
+            expect(securityLevel).toBeNull();
+        });
+
+        it('should reject empty string', () => {
+            const securityLevel = AddressVerificator.isValidMLDSAPublicKey('');
+
+            expect(securityLevel).toBeNull();
+        });
+
+        it('should reject empty Buffer', () => {
+            const securityLevel = AddressVerificator.isValidMLDSAPublicKey(Buffer.alloc(0));
+
+            expect(securityLevel).toBeNull();
+        });
+
+        it('should reject classical public key (33 bytes)', () => {
+            const mnemonic = new Mnemonic(
+                testMnemonic,
+                '',
+                networks.bitcoin,
+                MLDSASecurityLevel.LEVEL2,
+            );
+            const wallet = mnemonic.derive(0);
+            const classicalPublicKey = wallet.publicKey; // 33 bytes
+
+            const securityLevel = AddressVerificator.isValidMLDSAPublicKey(classicalPublicKey);
+
+            expect(securityLevel).toBeNull();
+        });
+
+        it('should verify all valid ML-DSA lengths', () => {
+            // Test all three security levels
+            const levels = [
+                MLDSASecurityLevel.LEVEL2,
+                MLDSASecurityLevel.LEVEL3,
+                MLDSASecurityLevel.LEVEL5,
+            ];
+
+            for (const level of levels) {
+                const mnemonic = new Mnemonic(testMnemonic, '', networks.bitcoin, level);
+                const wallet = mnemonic.derive(0);
+
+                const securityLevelHex = AddressVerificator.isValidMLDSAPublicKey(
+                    wallet.quantumPublicKeyHex,
+                );
+                const securityLevelBuffer = AddressVerificator.isValidMLDSAPublicKey(
+                    wallet.quantumPublicKey,
+                );
+
+                expect(securityLevelHex).toBe(level);
+                expect(securityLevelBuffer).toBe(level);
+            }
+        });
+    });
+
+    describe('isValidP2OPAddress', () => {
+        it('should validate mainnet P2OP address', () => {
+            const mnemonic = new Mnemonic(
+                testMnemonic,
+                '',
+                networks.bitcoin,
+                MLDSASecurityLevel.LEVEL2,
+            );
+            const wallet = mnemonic.derive(0);
+            const p2opAddress = wallet.address.p2op(networks.bitcoin);
+
+            const isValid = AddressVerificator.isValidP2OPAddress(p2opAddress, networks.bitcoin);
+
+            expect(isValid).toBe(true);
+        });
+
+        it('should validate testnet P2OP address', () => {
+            const mnemonic = new Mnemonic(
+                testMnemonic,
+                '',
+                networks.testnet,
+                MLDSASecurityLevel.LEVEL2,
+            );
+            const wallet = mnemonic.derive(0);
+            const p2opAddress = wallet.address.p2op(networks.testnet);
+
+            const isValid = AddressVerificator.isValidP2OPAddress(p2opAddress, networks.testnet);
+
+            expect(isValid).toBe(true);
+        });
+
+        it('should validate regtest P2OP address', () => {
+            const mnemonic = new Mnemonic(
+                testMnemonic,
+                '',
+                networks.regtest,
+                MLDSASecurityLevel.LEVEL2,
+            );
+            const wallet = mnemonic.derive(0);
+            const p2opAddress = wallet.address.p2op(networks.regtest);
+
+            const isValid = AddressVerificator.isValidP2OPAddress(p2opAddress, networks.regtest);
+
+            expect(isValid).toBe(true);
+        });
+
+        it('should reject P2TR address as P2OP', () => {
+            const mnemonic = new Mnemonic(
+                testMnemonic,
+                '',
+                networks.bitcoin,
+                MLDSASecurityLevel.LEVEL2,
+            );
+            const wallet = mnemonic.derive(0);
+            const p2trAddress = wallet.p2tr;
+
+            const isValid = AddressVerificator.isValidP2OPAddress(p2trAddress, networks.bitcoin);
+
+            expect(isValid).toBe(false);
+        });
+
+        it('should reject P2WPKH address as P2OP', () => {
+            const mnemonic = new Mnemonic(
+                testMnemonic,
+                '',
+                networks.bitcoin,
+                MLDSASecurityLevel.LEVEL2,
+            );
+            const wallet = mnemonic.derive(0);
+            const p2wpkhAddress = wallet.p2wpkh;
+
+            const isValid = AddressVerificator.isValidP2OPAddress(p2wpkhAddress, networks.bitcoin);
+
+            expect(isValid).toBe(false);
+        });
+
+        it('should reject invalid address string', () => {
+            const invalidAddress = 'not a valid address';
+            const isValid = AddressVerificator.isValidP2OPAddress(invalidAddress, networks.bitcoin);
+
+            expect(isValid).toBe(false);
+        });
+
+        it('should reject empty string', () => {
+            const isValid = AddressVerificator.isValidP2OPAddress('', networks.bitcoin);
+
+            expect(isValid).toBe(false);
+        });
+
+        it('should reject address on wrong network', () => {
+            const mnemonic = new Mnemonic(
+                testMnemonic,
+                '',
+                networks.bitcoin,
+                MLDSASecurityLevel.LEVEL2,
+            );
+            const wallet = mnemonic.derive(0);
+            const p2opAddress = wallet.address.p2op(networks.bitcoin);
+
+            // Try to validate mainnet address on testnet
+            const isValid = AddressVerificator.isValidP2OPAddress(p2opAddress, networks.testnet);
+
+            expect(isValid).toBe(false);
+        });
+    });
+
+    describe('detectAddressType - P2OP support', () => {
+        it('should detect mainnet P2OP address type', () => {
+            const mnemonic = new Mnemonic(
+                testMnemonic,
+                '',
+                networks.bitcoin,
+                MLDSASecurityLevel.LEVEL2,
+            );
+            const wallet = mnemonic.derive(0);
+            const p2opAddress = wallet.address.p2op(networks.bitcoin);
+
+            const addressType = AddressVerificator.detectAddressType(p2opAddress, networks.bitcoin);
+
+            expect(addressType).toBe(AddressTypes.P2OP);
+        });
+
+        it('should detect testnet P2OP address type', () => {
+            const mnemonic = new Mnemonic(
+                testMnemonic,
+                '',
+                networks.testnet,
+                MLDSASecurityLevel.LEVEL2,
+            );
+            const wallet = mnemonic.derive(0);
+            const p2opAddress = wallet.address.p2op(networks.testnet);
+
+            const addressType = AddressVerificator.detectAddressType(p2opAddress, networks.testnet);
+
+            expect(addressType).toBe(AddressTypes.P2OP);
+        });
+
+        it('should detect regtest P2OP address type', () => {
+            const mnemonic = new Mnemonic(
+                testMnemonic,
+                '',
+                networks.regtest,
+                MLDSASecurityLevel.LEVEL2,
+            );
+            const wallet = mnemonic.derive(0);
+            const p2opAddress = wallet.address.p2op(networks.regtest);
+
+            const addressType = AddressVerificator.detectAddressType(p2opAddress, networks.regtest);
+
+            expect(addressType).toBe(AddressTypes.P2OP);
+        });
+
+        it('should not confuse P2OP with P2TR', () => {
+            const mnemonic = new Mnemonic(
+                testMnemonic,
+                '',
+                networks.bitcoin,
+                MLDSASecurityLevel.LEVEL2,
+            );
+            const wallet = mnemonic.derive(0);
+
+            const p2opAddress = wallet.address.p2op(networks.bitcoin);
+            const p2trAddress = wallet.p2tr;
+
+            const p2opType = AddressVerificator.detectAddressType(p2opAddress, networks.bitcoin);
+            const p2trType = AddressVerificator.detectAddressType(p2trAddress, networks.bitcoin);
+
+            expect(p2opType).toBe(AddressTypes.P2OP);
+            expect(p2trType).toBe(AddressTypes.P2TR);
+            expect(p2opType).not.toBe(p2trType);
+        });
+
+        it('should not confuse P2OP with P2WPKH', () => {
+            const mnemonic = new Mnemonic(
+                testMnemonic,
+                '',
+                networks.bitcoin,
+                MLDSASecurityLevel.LEVEL2,
+            );
+            const wallet = mnemonic.derive(0);
+
+            const p2opAddress = wallet.address.p2op(networks.bitcoin);
+            const p2wpkhAddress = wallet.p2wpkh;
+
+            const p2opType = AddressVerificator.detectAddressType(p2opAddress, networks.bitcoin);
+            const p2wpkhType = AddressVerificator.detectAddressType(
+                p2wpkhAddress,
+                networks.bitcoin,
+            );
+
+            expect(p2opType).toBe(AddressTypes.P2OP);
+            expect(p2wpkhType).toBe(AddressTypes.P2WPKH);
+            expect(p2opType).not.toBe(p2wpkhType);
+        });
+
+        it('should detect P2OP for different security levels', () => {
+            const levels = [
+                MLDSASecurityLevel.LEVEL2,
+                MLDSASecurityLevel.LEVEL3,
+                MLDSASecurityLevel.LEVEL5,
+            ];
+
+            for (const level of levels) {
+                const mnemonic = new Mnemonic(testMnemonic, '', networks.bitcoin, level);
+                const wallet = mnemonic.derive(0);
+                const p2opAddress = wallet.address.p2op(networks.bitcoin);
+
+                const addressType = AddressVerificator.detectAddressType(
+                    p2opAddress,
+                    networks.bitcoin,
+                );
+
+                expect(addressType).toBe(AddressTypes.P2OP);
+            }
+        });
+
+        it('should return null for invalid P2OP address on wrong network', () => {
+            const mnemonic = new Mnemonic(
+                testMnemonic,
+                '',
+                networks.bitcoin,
+                MLDSASecurityLevel.LEVEL2,
+            );
+            const wallet = mnemonic.derive(0);
+            const p2opAddress = wallet.address.p2op(networks.bitcoin);
+
+            // Try to detect mainnet address on testnet
+            const addressType = AddressVerificator.detectAddressType(p2opAddress, networks.testnet);
+
+            expect(addressType).toBeNull();
+        });
+    });
+
+    describe('ML-DSA integration with other address types', () => {
+        it('should correctly identify different address types from same wallet', () => {
+            const mnemonic = new Mnemonic(
+                testMnemonic,
+                '',
+                networks.bitcoin,
+                MLDSASecurityLevel.LEVEL2,
+            );
+            const wallet = mnemonic.derive(0);
+
+            const p2trType = AddressVerificator.detectAddressType(wallet.p2tr, networks.bitcoin);
+            const p2wpkhType = AddressVerificator.detectAddressType(
+                wallet.p2wpkh,
+                networks.bitcoin,
+            );
+            const p2opType = AddressVerificator.detectAddressType(
+                wallet.address.p2op(networks.bitcoin),
+                networks.bitcoin,
+            );
+
+            expect(p2trType).toBe(AddressTypes.P2TR);
+            expect(p2wpkhType).toBe(AddressTypes.P2WPKH);
+            expect(p2opType).toBe(AddressTypes.P2OP);
+        });
+
+        it('should validate classical and ML-DSA public keys separately', () => {
+            const mnemonic = new Mnemonic(
+                testMnemonic,
+                '',
+                networks.bitcoin,
+                MLDSASecurityLevel.LEVEL2,
+            );
+            const wallet = mnemonic.derive(0);
+
+            const classicalValid = AddressVerificator.isValidPublicKey(
+                wallet.toPublicKeyHex(),
+                networks.bitcoin,
+            );
+            const mldsaLevel = AddressVerificator.isValidMLDSAPublicKey(wallet.quantumPublicKeyHex);
+
+            expect(classicalValid).toBe(true);
+            expect(mldsaLevel).toBe(MLDSASecurityLevel.LEVEL2);
+        });
+    });
+});

package/test/derivePath.test.ts

@@ -0,0 +1,234 @@
+import { describe, expect, it } from 'vitest';
+import { MLDSASecurityLevel, Mnemonic } from '../build/opnet.js';
+import { networks } from '@btc-vision/bitcoin';
+
+describe('Wallet.derivePath', () => {
+    const testMnemonic =
+        'abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon about';
+
+    describe('Basic derivation', () => {
+        it('should derive child wallet with unique addresses', () => {
+            const mnemonic = new Mnemonic(
+                testMnemonic,
+                '',
+                networks.bitcoin,
+                MLDSASecurityLevel.LEVEL2,
+            );
+            const wallet = mnemonic.derive(0);
+            const child = wallet.derivePath('m/0');
+
+            // Addresses should be different
+            expect(child.p2tr).not.toBe(wallet.p2tr);
+            expect(child.p2wpkh).not.toBe(wallet.p2wpkh);
+
+            // Private keys should be different
+            expect(child.toPrivateKeyHex()).not.toBe(wallet.toPrivateKeyHex());
+            expect(child.quantumPrivateKeyHex).not.toBe(wallet.quantumPrivateKeyHex);
+        });
+
+        it('should derive wallet with correct address prefixes', () => {
+            const mnemonic = new Mnemonic(
+                testMnemonic,
+                '',
+                networks.bitcoin,
+                MLDSASecurityLevel.LEVEL2,
+            );
+            const wallet = mnemonic.derive(0);
+            const child = wallet.derivePath('m/0');
+
+            expect(child.p2tr).toMatch(/^bc1p/);
+            expect(child.p2wpkh).toMatch(/^bc1q/);
+        });
+    });
+
+    describe('Multiple child derivations', () => {
+        it('should derive multiple children with unique addresses', () => {
+            const mnemonic = new Mnemonic(
+                testMnemonic,
+                '',
+                networks.bitcoin,
+                MLDSASecurityLevel.LEVEL2,
+            );
+            const wallet = mnemonic.derive(0);
+
+            const child0 = wallet.derivePath('m/0');
+            const child1 = wallet.derivePath('m/1');
+            const child2 = wallet.derivePath('m/2');
+
+            // All addresses should be unique
+            const addresses = [child0.p2tr, child1.p2tr, child2.p2tr];
+            const uniqueAddresses = new Set(addresses);
+            expect(uniqueAddresses.size).toBe(3);
+
+            // All classical keys should be unique
+            const classicalKeys = [
+                child0.toPrivateKeyHex(),
+                child1.toPrivateKeyHex(),
+                child2.toPrivateKeyHex(),
+            ];
+            const uniqueClassicalKeys = new Set(classicalKeys);
+            expect(uniqueClassicalKeys.size).toBe(3);
+
+            // All quantum keys should be unique
+            const quantumKeys = [
+                child0.quantumPrivateKeyHex,
+                child1.quantumPrivateKeyHex,
+                child2.quantumPrivateKeyHex,
+            ];
+            const uniqueQuantumKeys = new Set(quantumKeys);
+            expect(uniqueQuantumKeys.size).toBe(3);
+        });
+    });
+
+    describe('Network preservation', () => {
+        it('should maintain mainnet network in derived wallet', () => {
+            const mnemonic = new Mnemonic(
+                testMnemonic,
+                '',
+                networks.bitcoin,
+                MLDSASecurityLevel.LEVEL2,
+            );
+            const wallet = mnemonic.derive(0);
+            const child = wallet.derivePath('m/0');
+
+            expect(child.network.bech32).toBe('bc');
+            expect(child.p2tr).toMatch(/^bc1/);
+        });
+
+        it('should maintain testnet network in derived wallet', () => {
+            const mnemonic = new Mnemonic(
+                testMnemonic,
+                '',
+                networks.testnet,
+                MLDSASecurityLevel.LEVEL2,
+            );
+            const wallet = mnemonic.derive(0);
+            const child = wallet.derivePath('m/0');
+
+            expect(child.network.bech32).toBe('tb');
+            expect(child.p2tr).toMatch(/^tb1/);
+        });
+
+        it('should maintain regtest network in derived wallet', () => {
+            const mnemonic = new Mnemonic(
+                testMnemonic,
+                '',
+                networks.regtest,
+                MLDSASecurityLevel.LEVEL2,
+            );
+            const wallet = mnemonic.derive(0);
+            const child = wallet.derivePath('m/0');
+
+            expect(child.network.bech32).toBe('bcrt');
+            expect(child.p2tr).toMatch(/^bcrt1/);
+        });
+    });
+
+    describe('Network-aware key derivation', () => {
+        it('should derive different classical keys for different networks', () => {
+            const mnemonicMainnet = new Mnemonic(
+                testMnemonic,
+                '',
+                networks.bitcoin,
+                MLDSASecurityLevel.LEVEL2,
+            );
+            const mnemonicTestnet = new Mnemonic(
+                testMnemonic,
+                '',
+                networks.testnet,
+                MLDSASecurityLevel.LEVEL2,
+            );
+
+            const mainnetParent = mnemonicMainnet.derive(0);
+            const testnetParent = mnemonicTestnet.derive(0);
+
+            const mainnetChild = mainnetParent.derivePath('m/0');
+            const testnetChild = testnetParent.derivePath('m/0');
+
+            // Classical keys should differ between networks
+            expect(mainnetChild.toPrivateKeyHex()).not.toBe(testnetChild.toPrivateKeyHex());
+        });
+
+        it('should derive different quantum keys for different networks', () => {
+            const mnemonicMainnet = new Mnemonic(
+                testMnemonic,
+                '',
+                networks.bitcoin,
+                MLDSASecurityLevel.LEVEL2,
+            );
+            const mnemonicTestnet = new Mnemonic(
+                testMnemonic,
+                '',
+                networks.testnet,
+                MLDSASecurityLevel.LEVEL2,
+            );
+
+            const mainnetParent = mnemonicMainnet.derive(0);
+            const testnetParent = mnemonicTestnet.derive(0);
+
+            const mainnetChild = mainnetParent.derivePath('m/0');
+            const testnetChild = testnetParent.derivePath('m/0');
+
+            // Quantum keys should differ between networks
+            expect(mainnetChild.quantumPrivateKeyHex).not.toBe(testnetChild.quantumPrivateKeyHex);
+        });
+    });
+
+    describe('Hardened paths', () => {
+        it('should support hardened derivation paths', () => {
+            const mnemonic = new Mnemonic(
+                testMnemonic,
+                '',
+                networks.bitcoin,
+                MLDSASecurityLevel.LEVEL2,
+            );
+            const wallet = mnemonic.derive(0);
+
+            const hardened1 = wallet.derivePath("m/0'");
+            const hardened2 = wallet.derivePath("m/44'/0'/0'");
+
+            expect(hardened1.p2tr).toBeDefined();
+            expect(hardened2.p2tr).toBeDefined();
+            expect(hardened1.p2tr).not.toBe(hardened2.p2tr);
+        });
+    });
+
+    describe('Deterministic derivation', () => {
+        it('should produce same results when using same mnemonic-derived wallet', () => {
+            const mnemonic = new Mnemonic(
+                testMnemonic,
+                '',
+                networks.bitcoin,
+                MLDSASecurityLevel.LEVEL2,
+            );
+            const wallet = mnemonic.derive(0);
+
+            // Derive the same path twice from the same wallet instance
+            const child1 = wallet.derivePath('m/0/1');
+            const child2 = wallet.derivePath('m/0/1');
+
+            // Should produce identical results (deterministic)
+            expect(child1.p2tr).toBe(child2.p2tr);
+            expect(child1.p2wpkh).toBe(child2.p2wpkh);
+            expect(child1.toPrivateKeyHex()).toBe(child2.toPrivateKeyHex());
+            expect(child1.quantumPrivateKeyHex).toBe(child2.quantumPrivateKeyHex);
+        });
+    });
+
+    describe('Deep path derivation', () => {
+        it('should support deep BIP44-style paths', () => {
+            const mnemonic = new Mnemonic(
+                testMnemonic,
+                '',
+                networks.bitcoin,
+                MLDSASecurityLevel.LEVEL2,
+            );
+            const wallet = mnemonic.derive(0);
+
+            const deepChild = wallet.derivePath("m/44'/0'/0'/0/5");
+
+            expect(deepChild.p2tr).toBeDefined();
+            expect(deepChild.p2tr).not.toBe(wallet.p2tr);
+        });
+    });
+});