@btc-vision/transaction 1.7.31 → 1.8.0-alpha.2

package/test/binary-reader-writer.test.ts

@@ -0,0 +1,457 @@
+import { describe, expect, it } from 'vitest';
+import { Address, BinaryReader, BinaryWriter, ExtendedAddressMap } from '../src/opnet.js';
+
+describe('BinaryReader/BinaryWriter', () => {
+    // Helper to create an Address with both MLDSA and tweaked keys
+    const createFullAddress = (mldsaValue: bigint, tweakedValue: bigint): Address => {
+        return Address.fromBigInt(mldsaValue, tweakedValue);
+    };
+
+    describe('Signed Integer Methods', () => {
+        describe('i8', () => {
+            it('should write and read positive i8', () => {
+                const writer = new BinaryWriter();
+                writer.writeI8(127);
+                writer.writeI8(0);
+                writer.writeI8(1);
+
+                const reader = new BinaryReader(writer.getBuffer());
+                expect(reader.readI8()).toBe(127);
+                expect(reader.readI8()).toBe(0);
+                expect(reader.readI8()).toBe(1);
+            });
+
+            it('should write and read negative i8', () => {
+                const writer = new BinaryWriter();
+                writer.writeI8(-128);
+                writer.writeI8(-1);
+                writer.writeI8(-50);
+
+                const reader = new BinaryReader(writer.getBuffer());
+                expect(reader.readI8()).toBe(-128);
+                expect(reader.readI8()).toBe(-1);
+                expect(reader.readI8()).toBe(-50);
+            });
+
+            it('should throw on out of range i8', () => {
+                const writer = new BinaryWriter();
+                expect(() => writer.writeI8(128)).toThrow();
+                expect(() => writer.writeI8(-129)).toThrow();
+            });
+        });
+
+        describe('i16', () => {
+            it('should write and read positive i16 big-endian', () => {
+                const writer = new BinaryWriter();
+                writer.writeI16(32767);
+                writer.writeI16(256);
+                writer.writeI16(0);
+
+                const reader = new BinaryReader(writer.getBuffer());
+                expect(reader.readI16()).toBe(32767);
+                expect(reader.readI16()).toBe(256);
+                expect(reader.readI16()).toBe(0);
+            });
+
+            it('should write and read negative i16 big-endian', () => {
+                const writer = new BinaryWriter();
+                writer.writeI16(-32768);
+                writer.writeI16(-1);
+                writer.writeI16(-256);
+
+                const reader = new BinaryReader(writer.getBuffer());
+                expect(reader.readI16()).toBe(-32768);
+                expect(reader.readI16()).toBe(-1);
+                expect(reader.readI16()).toBe(-256);
+            });
+
+            it('should write and read i16 little-endian', () => {
+                const writer = new BinaryWriter();
+                writer.writeI16(12345, false);
+                writer.writeI16(-12345, false);
+
+                const reader = new BinaryReader(writer.getBuffer());
+                expect(reader.readI16(false)).toBe(12345);
+                expect(reader.readI16(false)).toBe(-12345);
+            });
+
+            it('should throw on out of range i16', () => {
+                const writer = new BinaryWriter();
+                expect(() => writer.writeI16(32768)).toThrow();
+                expect(() => writer.writeI16(-32769)).toThrow();
+            });
+        });
+
+        describe('i32', () => {
+            it('should write and read positive i32 big-endian', () => {
+                const writer = new BinaryWriter();
+                writer.writeI32(2147483647);
+                writer.writeI32(65536);
+                writer.writeI32(0);
+
+                const reader = new BinaryReader(writer.getBuffer());
+                expect(reader.readI32()).toBe(2147483647);
+                expect(reader.readI32()).toBe(65536);
+                expect(reader.readI32()).toBe(0);
+            });
+
+            it('should write and read negative i32 big-endian', () => {
+                const writer = new BinaryWriter();
+                writer.writeI32(-2147483648);
+                writer.writeI32(-1);
+                writer.writeI32(-65536);
+
+                const reader = new BinaryReader(writer.getBuffer());
+                expect(reader.readI32()).toBe(-2147483648);
+                expect(reader.readI32()).toBe(-1);
+                expect(reader.readI32()).toBe(-65536);
+            });
+
+            it('should write and read i32 little-endian', () => {
+                const writer = new BinaryWriter();
+                writer.writeI32(123456789, false);
+                writer.writeI32(-123456789, false);
+
+                const reader = new BinaryReader(writer.getBuffer());
+                expect(reader.readI32(false)).toBe(123456789);
+                expect(reader.readI32(false)).toBe(-123456789);
+            });
+
+            it('should throw on out of range i32', () => {
+                const writer = new BinaryWriter();
+                expect(() => writer.writeI32(2147483648)).toThrow();
+                expect(() => writer.writeI32(-2147483649)).toThrow();
+            });
+        });
+
+        describe('i64', () => {
+            it('should write and read positive i64 big-endian', () => {
+                const writer = new BinaryWriter();
+                writer.writeI64(9223372036854775807n);
+                writer.writeI64(4294967296n);
+                writer.writeI64(0n);
+
+                const reader = new BinaryReader(writer.getBuffer());
+                expect(reader.readI64()).toBe(9223372036854775807n);
+                expect(reader.readI64()).toBe(4294967296n);
+                expect(reader.readI64()).toBe(0n);
+            });
+
+            it('should write and read negative i64 big-endian', () => {
+                const writer = new BinaryWriter();
+                writer.writeI64(-9223372036854775808n);
+                writer.writeI64(-1n);
+                writer.writeI64(-4294967296n);
+
+                const reader = new BinaryReader(writer.getBuffer());
+                expect(reader.readI64()).toBe(-9223372036854775808n);
+                expect(reader.readI64()).toBe(-1n);
+                expect(reader.readI64()).toBe(-4294967296n);
+            });
+
+            it('should write and read i64 little-endian', () => {
+                const writer = new BinaryWriter();
+                writer.writeI64(1234567890123456789n, false);
+                writer.writeI64(-1234567890123456789n, false);
+
+                const reader = new BinaryReader(writer.getBuffer());
+                expect(reader.readI64(false)).toBe(1234567890123456789n);
+                expect(reader.readI64(false)).toBe(-1234567890123456789n);
+            });
+
+            it('should throw on out of range i64', () => {
+                const writer = new BinaryWriter();
+                expect(() => writer.writeI64(9223372036854775808n)).toThrow();
+                expect(() => writer.writeI64(-9223372036854775809n)).toThrow();
+            });
+        });
+    });
+
+    describe('Extended Address Methods', () => {
+        describe('readExtendedAddress / writeExtendedAddress', () => {
+            it('should write and read extended address', () => {
+                const writer = new BinaryWriter();
+                const address = createFullAddress(123n, 456n);
+
+                writer.writeExtendedAddress(address);
+
+                const reader = new BinaryReader(writer.getBuffer());
+                const result = reader.readExtendedAddress();
+
+                expect(result.toBigInt()).toBe(123n);
+                expect(result.tweakedToBigInt()).toBe(456n);
+            });
+
+            it('should write and read multiple extended addresses', () => {
+                const writer = new BinaryWriter();
+                const addr1 = createFullAddress(100n, 200n);
+                const addr2 = createFullAddress(300n, 400n);
+                const addr3 = createFullAddress(500n, 600n);
+
+                writer.writeExtendedAddress(addr1);
+                writer.writeExtendedAddress(addr2);
+                writer.writeExtendedAddress(addr3);
+
+                const reader = new BinaryReader(writer.getBuffer());
+
+                const result1 = reader.readExtendedAddress();
+                expect(result1.toBigInt()).toBe(100n);
+                expect(result1.tweakedToBigInt()).toBe(200n);
+
+                const result2 = reader.readExtendedAddress();
+                expect(result2.toBigInt()).toBe(300n);
+                expect(result2.tweakedToBigInt()).toBe(400n);
+
+                const result3 = reader.readExtendedAddress();
+                expect(result3.toBigInt()).toBe(500n);
+                expect(result3.tweakedToBigInt()).toBe(600n);
+            });
+
+            it('should handle zero addresses', () => {
+                const writer = new BinaryWriter();
+                const address = createFullAddress(0n, 0n);
+
+                writer.writeExtendedAddress(address);
+
+                const reader = new BinaryReader(writer.getBuffer());
+                const result = reader.readExtendedAddress();
+
+                expect(result.toBigInt()).toBe(0n);
+                expect(result.tweakedToBigInt()).toBe(0n);
+            });
+
+            it('should handle max value addresses', () => {
+                const writer = new BinaryWriter();
+                const maxValue = 2n ** 256n - 1n;
+                const address = createFullAddress(maxValue, maxValue);
+
+                writer.writeExtendedAddress(address);
+
+                const reader = new BinaryReader(writer.getBuffer());
+                const result = reader.readExtendedAddress();
+
+                expect(result.toBigInt()).toBe(maxValue);
+                expect(result.tweakedToBigInt()).toBe(maxValue);
+            });
+        });
+
+        describe('readExtendedAddressArray / writeExtendedAddressArray', () => {
+            it('should write and read empty array', () => {
+                const writer = new BinaryWriter();
+                writer.writeExtendedAddressArray([]);
+
+                const reader = new BinaryReader(writer.getBuffer());
+                const result = reader.readExtendedAddressArray();
+
+                expect(result).toEqual([]);
+            });
+
+            it('should write and read array of extended addresses', () => {
+                const writer = new BinaryWriter();
+                const addresses = [
+                    createFullAddress(1n, 2n),
+                    createFullAddress(3n, 4n),
+                    createFullAddress(5n, 6n),
+                ];
+
+                writer.writeExtendedAddressArray(addresses);
+
+                const reader = new BinaryReader(writer.getBuffer());
+                const result = reader.readExtendedAddressArray();
+
+                expect(result.length).toBe(3);
+                expect(result[0].toBigInt()).toBe(1n);
+                expect(result[0].tweakedToBigInt()).toBe(2n);
+                expect(result[1].toBigInt()).toBe(3n);
+                expect(result[1].tweakedToBigInt()).toBe(4n);
+                expect(result[2].toBigInt()).toBe(5n);
+                expect(result[2].tweakedToBigInt()).toBe(6n);
+            });
+
+            it('should handle large arrays', () => {
+                const writer = new BinaryWriter();
+                const addresses: Address[] = [];
+                for (let i = 0; i < 100; i++) {
+                    addresses.push(createFullAddress(BigInt(i), BigInt(i * 2)));
+                }
+
+                writer.writeExtendedAddressArray(addresses);
+
+                const reader = new BinaryReader(writer.getBuffer());
+                const result = reader.readExtendedAddressArray();
+
+                expect(result.length).toBe(100);
+                for (let i = 0; i < 100; i++) {
+                    expect(result[i].toBigInt()).toBe(BigInt(i));
+                    expect(result[i].tweakedToBigInt()).toBe(BigInt(i * 2));
+                }
+            });
+        });
+    });
+
+    describe('ExtendedAddressMapU256 Methods', () => {
+        describe('readExtendedAddressMapU256 / writeExtendedAddressMapU256', () => {
+            it('should write and read empty map', () => {
+                const writer = new BinaryWriter();
+                const map = new ExtendedAddressMap<bigint>();
+
+                writer.writeExtendedAddressMapU256(map);
+
+                const reader = new BinaryReader(writer.getBuffer());
+                const result = reader.readExtendedAddressMapU256();
+
+                expect(result.size).toBe(0);
+            });
+
+            it('should write and read map with entries', () => {
+                const writer = new BinaryWriter();
+                const map = new ExtendedAddressMap<bigint>();
+
+                const addr1 = createFullAddress(100n, 200n);
+                const addr2 = createFullAddress(300n, 400n);
+
+                map.set(addr1, 1000n);
+                map.set(addr2, 2000n);
+
+                writer.writeExtendedAddressMapU256(map);
+
+                const reader = new BinaryReader(writer.getBuffer());
+                const result = reader.readExtendedAddressMapU256();
+
+                expect(result.size).toBe(2);
+            });
+
+            it('should handle large u256 values', () => {
+                const writer = new BinaryWriter();
+                const map = new ExtendedAddressMap<bigint>();
+
+                const addr = createFullAddress(1n, 2n);
+                const largeValue = 2n ** 256n - 1n;
+
+                map.set(addr, largeValue);
+
+                writer.writeExtendedAddressMapU256(map);
+
+                const reader = new BinaryReader(writer.getBuffer());
+                const result = reader.readExtendedAddressMapU256();
+
+                expect(result.size).toBe(1);
+            });
+        });
+    });
+
+    describe('Schnorr Signature Methods', () => {
+        describe('readSchnorrSignature / writeSchnorrSignature', () => {
+            it('should write and read Schnorr signature', () => {
+                const writer = new BinaryWriter();
+                const address = createFullAddress(12345n, 67890n);
+                const signature = new Uint8Array(64);
+                for (let i = 0; i < 64; i++) {
+                    signature[i] = i;
+                }
+
+                writer.writeSchnorrSignature(address, signature);
+
+                const reader = new BinaryReader(writer.getBuffer());
+                const result = reader.readSchnorrSignature();
+
+                expect(result.address.toBigInt()).toBe(12345n);
+                expect(result.address.tweakedToBigInt()).toBe(67890n);
+                expect(result.signature.length).toBe(64);
+                for (let i = 0; i < 64; i++) {
+                    expect(result.signature[i]).toBe(i);
+                }
+            });
+
+            it('should throw on invalid signature length', () => {
+                const writer = new BinaryWriter();
+                const address = createFullAddress(1n, 2n);
+                const invalidSignature = new Uint8Array(32); // Should be 64
+
+                expect(() => writer.writeSchnorrSignature(address, invalidSignature)).toThrow();
+            });
+
+            it('should handle multiple signatures', () => {
+                const writer = new BinaryWriter();
+
+                const sig1 = new Uint8Array(64).fill(1);
+                const sig2 = new Uint8Array(64).fill(2);
+
+                writer.writeSchnorrSignature(createFullAddress(1n, 2n), sig1);
+                writer.writeSchnorrSignature(createFullAddress(3n, 4n), sig2);
+
+                const reader = new BinaryReader(writer.getBuffer());
+
+                const result1 = reader.readSchnorrSignature();
+                expect(result1.address.toBigInt()).toBe(1n);
+                expect(result1.signature[0]).toBe(1);
+
+                const result2 = reader.readSchnorrSignature();
+                expect(result2.address.toBigInt()).toBe(3n);
+                expect(result2.signature[0]).toBe(2);
+            });
+        });
+    });
+
+    describe('Mixed Operations', () => {
+        it('should handle mixed data types in sequence', () => {
+            const writer = new BinaryWriter();
+
+            // Write various types
+            writer.writeI8(-50);
+            writer.writeI16(-1000);
+            writer.writeI32(-100000);
+            writer.writeI64(-10000000000n);
+            writer.writeExtendedAddress(createFullAddress(111n, 222n));
+            writer.writeU256(999n);
+
+            const reader = new BinaryReader(writer.getBuffer());
+
+            expect(reader.readI8()).toBe(-50);
+            expect(reader.readI16()).toBe(-1000);
+            expect(reader.readI32()).toBe(-100000);
+            expect(reader.readI64()).toBe(-10000000000n);
+
+            const addr = reader.readExtendedAddress();
+            expect(addr.toBigInt()).toBe(111n);
+            expect(addr.tweakedToBigInt()).toBe(222n);
+
+            expect(reader.readU256()).toBe(999n);
+        });
+
+        it('should correctly track buffer position', () => {
+            const writer = new BinaryWriter();
+
+            writer.writeI8(1);
+            writer.writeI16(2);
+            writer.writeI32(3);
+            writer.writeI64(4n);
+            writer.writeExtendedAddress(createFullAddress(5n, 6n));
+
+            const buffer = writer.getBuffer();
+            // i8: 1 byte, i16: 2 bytes, i32: 4 bytes, i64: 8 bytes, extended address: 64 bytes
+            expect(buffer.length).toBe(1 + 2 + 4 + 8 + 64);
+        });
+    });
+
+    describe('Error Handling', () => {
+        it('should throw when reading beyond buffer', () => {
+            const writer = new BinaryWriter();
+            writer.writeI8(1);
+
+            const reader = new BinaryReader(writer.getBuffer());
+            reader.readI8();
+
+            expect(() => reader.readI8()).toThrow();
+        });
+
+        it('should throw when reading extended address from insufficient buffer', () => {
+            const writer = new BinaryWriter();
+            writer.writeU256(1n); // Only 32 bytes
+
+            const reader = new BinaryReader(writer.getBuffer());
+
+            expect(() => reader.readExtendedAddress()).toThrow();
+        });
+    });
+});

package/test/derivePath.test.ts

@@ -233,10 +233,11 @@ describe('Wallet.derivePath', () => {
     });
 });
 
-describe('Mnemonic.deriveUnisat', () => {
+describe('Mnemonic.deriveOPWallet', () => {
     const testMnemonic =
         'episode frost someone page color giraffe match vanish sheriff veteran hub year pull save dizzy limb already turn reopen truth cradle rural wisdom change';
-    const unisatExpectedAddress = 'bcrt1phn6ej9ct038j722wdzkvsk7c6pmugtd5d3qnpwxc8g40zerf2ujs55tkz3';
+    const unisatExpectedAddress =
+        'bcrt1phn6ej9ct038j722wdzkvsk7c6pmugtd5d3qnpwxc8g40zerf2ujs55tkz3';
 
     describe('P2TR (Taproot) derivation', () => {
         it('should match Unisat P2TR address for regtest', () => {
@@ -247,7 +248,7 @@ describe('Mnemonic.deriveUnisat', () => {
                 MLDSASecurityLevel.LEVEL2,
             );
 
-            const wallet = mnemonic.deriveUnisat(AddressTypes.P2TR, 0, 0, false);
+            const wallet = mnemonic.deriveOPWallet(AddressTypes.P2TR, 0, 0, false);
 
             expect(wallet.p2tr).toBe(unisatExpectedAddress);
         });
@@ -260,7 +261,7 @@ describe('Mnemonic.deriveUnisat', () => {
                 MLDSASecurityLevel.LEVEL2,
             );
 
-            const wallet = mnemonic.deriveUnisat(AddressTypes.P2TR, 0);
+            const wallet = mnemonic.deriveOPWallet(AddressTypes.P2TR, 0);
 
             expect(wallet.p2tr).toMatch(/^bc1p/);
         });
@@ -273,7 +274,7 @@ describe('Mnemonic.deriveUnisat', () => {
                 MLDSASecurityLevel.LEVEL2,
             );
 
-            const wallet = mnemonic.deriveUnisat(AddressTypes.P2TR, 0);
+            const wallet = mnemonic.deriveOPWallet(AddressTypes.P2TR, 0);
 
             expect(wallet.p2tr).toMatch(/^tb1p/);
         });
@@ -288,13 +289,13 @@ describe('Mnemonic.deriveUnisat', () => {
                 MLDSASecurityLevel.LEVEL2,
             );
 
-            const wallet = mnemonic.deriveUnisat(AddressTypes.P2WPKH, 0);
+            const wallet = mnemonic.deriveOPWallet(AddressTypes.P2WPKH, 0);
 
             expect(wallet.p2wpkh).toBeDefined();
             expect(wallet.p2wpkh).toMatch(/^bc1q/);
         });
 
-        it('should use BIP84 path (m/84\'/0\'/0\'/0/0)', () => {
+        it("should use BIP84 path (m/84'/0'/0'/0/0)", () => {
             const mnemonic = new Mnemonic(
                 testMnemonic,
                 '',
@@ -302,7 +303,7 @@ describe('Mnemonic.deriveUnisat', () => {
                 MLDSASecurityLevel.LEVEL2,
             );
 
-            const wallet = mnemonic.deriveUnisat(AddressTypes.P2WPKH, 0);
+            const wallet = mnemonic.deriveOPWallet(AddressTypes.P2WPKH, 0);
             expect(wallet.p2wpkh).toBeDefined();
         });
     });
@@ -316,7 +317,7 @@ describe('Mnemonic.deriveUnisat', () => {
                 MLDSASecurityLevel.LEVEL2,
             );
 
-            const wallet = mnemonic.deriveUnisat(AddressTypes.P2PKH, 0);
+            const wallet = mnemonic.deriveOPWallet(AddressTypes.P2PKH, 0);
 
             expect(wallet.legacy).toBeDefined();
             expect(wallet.legacy).toMatch(/^1/);
@@ -332,9 +333,9 @@ describe('Mnemonic.deriveUnisat', () => {
                 MLDSASecurityLevel.LEVEL2,
             );
 
-            const wallet0 = mnemonic.deriveUnisat(AddressTypes.P2TR, 0);
-            const wallet1 = mnemonic.deriveUnisat(AddressTypes.P2TR, 1);
-            const wallet2 = mnemonic.deriveUnisat(AddressTypes.P2TR, 2);
+            const wallet0 = mnemonic.deriveOPWallet(AddressTypes.P2TR, 0);
+            const wallet1 = mnemonic.deriveOPWallet(AddressTypes.P2TR, 1);
+            const wallet2 = mnemonic.deriveOPWallet(AddressTypes.P2TR, 2);
 
             expect(wallet0.p2tr).not.toBe(wallet1.p2tr);
             expect(wallet1.p2tr).not.toBe(wallet2.p2tr);
@@ -349,8 +350,8 @@ describe('Mnemonic.deriveUnisat', () => {
                 MLDSASecurityLevel.LEVEL2,
             );
 
-            const wallet1 = mnemonic.deriveUnisat(AddressTypes.P2TR, 5);
-            const wallet2 = mnemonic.deriveUnisat(AddressTypes.P2TR, 5);
+            const wallet1 = mnemonic.deriveOPWallet(AddressTypes.P2TR, 5);
+            const wallet2 = mnemonic.deriveOPWallet(AddressTypes.P2TR, 5);
 
             expect(wallet1.p2tr).toBe(wallet2.p2tr);
             expect(wallet1.toPublicKeyHex()).toBe(wallet2.toPublicKeyHex());
@@ -366,8 +367,8 @@ describe('Mnemonic.deriveUnisat', () => {
                 MLDSASecurityLevel.LEVEL2,
             );
 
-            const account0 = mnemonic.deriveUnisat(AddressTypes.P2TR, 0, 0);
-            const account1 = mnemonic.deriveUnisat(AddressTypes.P2TR, 0, 1);
+            const account0 = mnemonic.deriveOPWallet(AddressTypes.P2TR, 0, 0);
+            const account1 = mnemonic.deriveOPWallet(AddressTypes.P2TR, 0, 1);
 
             expect(account0.p2tr).not.toBe(account1.p2tr);
         });
@@ -380,8 +381,8 @@ describe('Mnemonic.deriveUnisat', () => {
                 MLDSASecurityLevel.LEVEL2,
             );
 
-            const receiving = mnemonic.deriveUnisat(AddressTypes.P2TR, 0, 0, false);
-            const change = mnemonic.deriveUnisat(AddressTypes.P2TR, 0, 0, true);
+            const receiving = mnemonic.deriveOPWallet(AddressTypes.P2TR, 0, 0, false);
+            const change = mnemonic.deriveOPWallet(AddressTypes.P2TR, 0, 0, true);
 
             expect(receiving.p2tr).not.toBe(change.p2tr);
         });
@@ -396,7 +397,7 @@ describe('Mnemonic.deriveUnisat', () => {
                 MLDSASecurityLevel.LEVEL2,
             );
 
-            const wallet = mnemonic.deriveUnisat(AddressTypes.P2TR, 0);
+            const wallet = mnemonic.deriveOPWallet(AddressTypes.P2TR, 0);
 
             expect(wallet.quantumPublicKey).toBeDefined();
             expect(wallet.quantumPublicKey.length).toBe(1312); // LEVEL2 size
@@ -411,8 +412,8 @@ describe('Mnemonic.deriveUnisat', () => {
                 MLDSASecurityLevel.LEVEL2,
             );
 
-            const wallet0 = mnemonic.deriveUnisat(AddressTypes.P2TR, 0);
-            const wallet1 = mnemonic.deriveUnisat(AddressTypes.P2TR, 1);
+            const wallet0 = mnemonic.deriveOPWallet(AddressTypes.P2TR, 0);
+            const wallet1 = mnemonic.deriveOPWallet(AddressTypes.P2TR, 1);
 
             expect(wallet0.address.toHex()).not.toBe(wallet1.address.toHex());
         });
@@ -459,7 +460,7 @@ describe('Mnemonic.deriveUnisat', () => {
             );
 
             const wallets = mnemonic.deriveMultipleUnisat(AddressTypes.P2TR, 2, 5);
-            const wallet5 = mnemonic.deriveUnisat(AddressTypes.P2TR, 5);
+            const wallet5 = mnemonic.deriveOPWallet(AddressTypes.P2TR, 5);
 
             expect(wallets[0].p2tr).toBe(wallet5.p2tr);
         });
@@ -475,7 +476,7 @@ describe('Mnemonic.deriveUnisat', () => {
             );
 
             expect(() => {
-                mnemonic.deriveUnisat('INVALID_TYPE' as AddressTypes, 0);
+                mnemonic.deriveOPWallet('INVALID_TYPE' as AddressTypes, 0);
             }).toThrow('Unsupported address type');
         });
     });
@@ -489,7 +490,7 @@ describe('Mnemonic.deriveUnisat', () => {
                 MLDSASecurityLevel.LEVEL2,
             );
 
-            const wallet = mnemonic.deriveUnisat(AddressTypes.P2TR, 0);
+            const wallet = mnemonic.deriveOPWallet(AddressTypes.P2TR, 0);
 
             expect(wallet.network.bech32).toBe('tb');
         });
@@ -504,7 +505,7 @@ describe('Mnemonic.deriveUnisat', () => {
                 MLDSASecurityLevel.LEVEL3,
             );
 
-            const wallet = mnemonic.deriveUnisat(AddressTypes.P2TR, 0);
+            const wallet = mnemonic.deriveOPWallet(AddressTypes.P2TR, 0);
 
             expect(wallet.securityLevel).toBe(MLDSASecurityLevel.LEVEL3);
             expect(wallet.quantumPublicKey.length).toBe(1952); // LEVEL3 size