@btc-vision/transaction 1.7.0 → 1.7.2

package/browser/src/_version.d.ts

@@ -1 +1 @@
-export declare const version = "1.7.0";
+export declare const version = "1.7.1";

package/browser/src/buffer/BinaryReader.d.ts

@@ -1,6 +1,6 @@
 import { AddressMap } from '../deterministic/AddressMap.js';
 import { Address } from '../keypair/Address.js';
-import { BufferLike, i32, Selector, u16, u32, u8 } from '../utils/types.js';
+import { BufferLike, Selector, u16, u32, u8 } from '../utils/types.js';
 export declare class BinaryReader {
     private buffer;
     private currentOffset;
@@ -38,7 +38,7 @@ export declare class BinaryReader {
     readAddressValueTuple(be?: boolean): AddressMap<bigint>;
     getOffset(): u16;
     setOffset(offset: u16): void;
-    verifyEnd(size: i32): void;
+    verifyEnd(size: number): void;
     private reverseBytes;
     private toHexString;
 }

package/browser/src/deterministic/AddressMap.d.ts

@@ -1,11 +1,18 @@
-import { i32 } from '../utils/types.js';
 import { Address } from '../keypair/Address.js';
-import { Map } from './Map.js';
-export declare class AddressMap<V> extends Map<Address, V> {
+export declare class AddressMap<V> {
+    private items;
+    private keyOrder;
+    constructor(iterable?: ReadonlyArray<readonly [Address, V]> | null);
+    get size(): number;
     set(key: Address, value: V): void;
-    indexOf(address: Address): i32;
-    has(key: Address): boolean;
     get(key: Address): V | undefined;
+    has(key: Address): boolean;
     delete(key: Address): boolean;
+    clear(): void;
+    indexOf(address: Address): number;
+    entries(): IterableIterator<[Address, V]>;
+    keys(): IterableIterator<Address>;
+    values(): IterableIterator<V>;
+    forEach(callback: (value: V, key: Address, map: AddressMap<V>) => void, thisArg?: unknown): void;
     [Symbol.iterator](): IterableIterator<[Address, V]>;
 }

package/browser/src/deterministic/AddressSet.d.ts

@@ -1,5 +1,6 @@
 import { Address } from '../keypair/Address.js';
 export declare class AddressSet {
+    private items;
     private keys;
     constructor(keys?: Address[]);
     get size(): number;
@@ -9,5 +10,5 @@ export declare class AddressSet {
     clone(): AddressSet;
     clear(): void;
     combine(set: AddressSet): AddressSet;
-    [Symbol.iterator](): Generator<Address, void, unknown>;
+    [Symbol.iterator](): IterableIterator<Address>;
 }

package/browser/src/deterministic/DeterministicMap.d.ts

@@ -1,7 +1,7 @@
 export declare class DeterministicMap<K, V> {
     #private;
-    private compareFn;
     private map;
+    private readonly compareFn;
     constructor(compareFn: (a: K, b: K) => number);
     get size(): number;
     static fromMap<K, V>(map: Map<K, V>, compareFn: (a: K, b: K) => number): DeterministicMap<K, V>;

package/browser/src/keypair/Address.d.ts

@@ -11,6 +11,9 @@ export declare class Address extends Uint8Array {
     static fromString(mldsaPublicKey: string, classicPublicKey?: string): Address;
     static wrap(bytes: ArrayLike<number>): Address;
     static uncompressedToCompressed(publicKey: ArrayLike<number>): Buffer;
+    static fromBigInt(value: bigint): Address;
+    static fromUint64Array(w0: bigint, w1: bigint, w2: bigint, w3: bigint): Address;
+    toUint64Array(): [bigint, bigint, bigint, bigint];
     toHex(): string;
     tweakedToHex(): string;
     toBuffer(): Buffer;
@@ -20,6 +23,7 @@ export declare class Address extends Uint8Array {
     toHybridPublicKeyHex(): string;
     toHybridPublicKeyBuffer(): Buffer;
     originalPublicKeyBuffer(): Buffer;
+    toBigInt(): bigint;
     equals(a: Address): boolean;
     lessThan(a: Address): boolean;
     greaterThan(a: Address): boolean;

package/browser/src/mnemonic/BIPStandard.d.ts

@@ -0,0 +1,8 @@
+export declare enum BIPStandard {
+    BIP44 = 44,
+    BIP49 = 49,
+    BIP84 = 84,
+    BIP86 = 86
+}
+export declare function getBIPDescription(standard: BIPStandard): string;
+export declare function buildBIPPath(standard: BIPStandard, coinType: number, account: number, change: number, addressIndex: number): string;

package/browser/src/mnemonic/Mnemonic.d.ts

@@ -2,6 +2,9 @@ import { BIP32Interface, MLDSASecurityLevel, QuantumBIP32Interface } from '@btc-
 import { Network } from '@btc-vision/bitcoin';
 import { Wallet } from '../keypair/Wallet.js';
 import { MnemonicStrength } from './MnemonicStrength.js';
+import { BIPStandard } from './BIPStandard.js';
+import { AddressTypes } from '../keypair/AddressVerificator.js';
+export { BIPStandard, getBIPDescription } from './BIPStandard.js';
 export declare class Mnemonic {
     private readonly _phrase;
     private readonly _passphrase;
@@ -18,8 +21,10 @@ export declare class Mnemonic {
     static generatePhrase(strength?: MnemonicStrength): string;
     static generate(strength?: MnemonicStrength, passphrase?: string, network?: Network, securityLevel?: MLDSASecurityLevel): Mnemonic;
     static validate(phrase: string): boolean;
-    derive(index?: number, account?: number, isChange?: boolean): Wallet;
-    deriveMultiple(count: number, startIndex?: number, account?: number, isChange?: boolean): Wallet[];
+    derive(index?: number, account?: number, isChange?: boolean, bipStandard?: BIPStandard): Wallet;
+    deriveUnisat(addressType?: AddressTypes, index?: number, account?: number, isChange?: boolean): Wallet;
+    deriveMultipleUnisat(addressType?: AddressTypes, count?: number, startIndex?: number, account?: number, isChange?: boolean): Wallet[];
+    deriveMultiple(count: number, startIndex?: number, account?: number, isChange?: boolean, bipStandard?: BIPStandard): Wallet[];
     deriveCustomPath(classicalPath: string, quantumPath: string): Wallet;
     getClassicalRoot(): BIP32Interface;
     getQuantumRoot(): QuantumBIP32Interface;

package/browser/src/opnet.d.ts

@@ -21,6 +21,7 @@ export * from './keypair/MessageSigner.js';
 export * from './keypair/Wallet.js';
 export * from './mnemonic/Mnemonic.js';
 export * from './mnemonic/MnemonicStrength.js';
+export * from './mnemonic/BIPStandard.js';
 export { MLDSASecurityLevel, MLDSAKeyPair, QuantumBIP32Interface, QuantumBIP32API, QuantumSigner, QuantumBIP32Factory, QuantumDerivationPath, } from '@btc-vision/bip32';
 export * from './metadata/ContractBaseMetadata.js';
 export * from './network/ChainId.js';

package/browser/src/utils/lengths.d.ts

@@ -1,16 +1,15 @@
-import { i32 } from './types';
-export declare const ADDRESS_BYTE_LENGTH: i32;
-export declare const SELECTOR_BYTE_LENGTH: i32;
-export declare const U256_BYTE_LENGTH: i32;
-export declare const U128_BYTE_LENGTH: i32;
-export declare const U64_BYTE_LENGTH: i32;
-export declare const U32_BYTE_LENGTH: i32;
-export declare const U16_BYTE_LENGTH: i32;
-export declare const U8_BYTE_LENGTH: i32;
-export declare const I256_BYTE_LENGTH: i32;
-export declare const I128_BYTE_LENGTH: i32;
-export declare const I64_BYTE_LENGTH: i32;
-export declare const I32_BYTE_LENGTH: i32;
-export declare const I16_BYTE_LENGTH: i32;
-export declare const I8_BYTE_LENGTH: i32;
-export declare const BOOLEAN_BYTE_LENGTH: i32;
+export declare const ADDRESS_BYTE_LENGTH: number;
+export declare const SELECTOR_BYTE_LENGTH: number;
+export declare const U256_BYTE_LENGTH: number;
+export declare const U128_BYTE_LENGTH: number;
+export declare const U64_BYTE_LENGTH: number;
+export declare const U32_BYTE_LENGTH: number;
+export declare const U16_BYTE_LENGTH: number;
+export declare const U8_BYTE_LENGTH: number;
+export declare const I256_BYTE_LENGTH: number;
+export declare const I128_BYTE_LENGTH: number;
+export declare const I64_BYTE_LENGTH: number;
+export declare const number_BYTE_LENGTH: number;
+export declare const I16_BYTE_LENGTH: number;
+export declare const I8_BYTE_LENGTH: number;
+export declare const BOOLEAN_BYTE_LENGTH: number;

package/build/_version.d.ts

@@ -1 +1 @@
-export declare const version = "1.7.0";
+export declare const version = "1.7.1";

package/build/_version.js

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

package/build/buffer/BinaryReader.d.ts

@@ -1,6 +1,6 @@
 import { AddressMap } from '../deterministic/AddressMap.js';
 import { Address } from '../keypair/Address.js';
-import { BufferLike, i32, Selector, u16, u32, u8 } from '../utils/types.js';
+import { BufferLike, Selector, u16, u32, u8 } from '../utils/types.js';
 export declare class BinaryReader {
     private buffer;
     private currentOffset;
@@ -38,7 +38,7 @@ export declare class BinaryReader {
     readAddressValueTuple(be?: boolean): AddressMap<bigint>;
     getOffset(): u16;
     setOffset(offset: u16): void;
-    verifyEnd(size: i32): void;
+    verifyEnd(size: number): void;
     private reverseBytes;
     private toHexString;
 }

package/build/deterministic/AddressMap.d.ts

@@ -1,11 +1,18 @@
-import { i32 } from '../utils/types.js';
 import { Address } from '../keypair/Address.js';
-import { Map } from './Map.js';
-export declare class AddressMap<V> extends Map<Address, V> {
+export declare class AddressMap<V> {
+    private items;
+    private keyOrder;
+    constructor(iterable?: ReadonlyArray<readonly [Address, V]> | null);
+    get size(): number;
     set(key: Address, value: V): void;
-    indexOf(address: Address): i32;
-    has(key: Address): boolean;
     get(key: Address): V | undefined;
+    has(key: Address): boolean;
     delete(key: Address): boolean;
+    clear(): void;
+    indexOf(address: Address): number;
+    entries(): IterableIterator<[Address, V]>;
+    keys(): IterableIterator<Address>;
+    values(): IterableIterator<V>;
+    forEach(callback: (value: V, key: Address, map: AddressMap<V>) => void, thisArg?: unknown): void;
     [Symbol.iterator](): IterableIterator<[Address, V]>;
 }

package/build/deterministic/AddressMap.js

@@ -1,51 +1,69 @@
-import { Map } from './Map.js';
-export class AddressMap extends Map {
+export class AddressMap {
+    constructor(iterable) {
+        this.items = new Map();
+        this.keyOrder = [];
+        if (iterable) {
+            for (const [key, value] of iterable) {
+                this.set(key, value);
+            }
+        }
+    }
+    get size() {
+        return this.keyOrder.length;
+    }
     set(key, value) {
-        const index = this.indexOf(key);
-        if (index == -1) {
-            this._keys.push(key);
-            this._values.push(value);
+        const keyBigInt = key.toBigInt();
+        if (!this.items.has(keyBigInt)) {
+            this.keyOrder.push(key);
         }
-        else {
-            this._values[index] = value;
+        this.items.set(keyBigInt, value);
+    }
+    get(key) {
+        return this.items.get(key.toBigInt());
+    }
+    has(key) {
+        return this.items.has(key.toBigInt());
+    }
+    delete(key) {
+        const keyBigInt = key.toBigInt();
+        if (this.items.delete(keyBigInt)) {
+            this.keyOrder = this.keyOrder.filter((k) => k.toBigInt() !== keyBigInt);
+            return true;
         }
+        return false;
+    }
+    clear() {
+        this.items.clear();
+        this.keyOrder = [];
     }
     indexOf(address) {
-        for (let i = 0; i < this._keys.length; i++) {
-            const key = this._keys[i];
-            if (address.equals(key)) {
+        const addressBigInt = address.toBigInt();
+        for (let i = 0; i < this.keyOrder.length; i++) {
+            if (this.keyOrder[i].toBigInt() === addressBigInt) {
                 return i;
             }
         }
         return -1;
     }
-    has(key) {
-        for (let i = 0; i < this._keys.length; i++) {
-            if (key.equals(this._keys[i])) {
-                return true;
-            }
+    *entries() {
+        for (const key of this.keyOrder) {
+            yield [key, this.items.get(key.toBigInt())];
         }
-        return false;
     }
-    get(key) {
-        const index = this.indexOf(key);
-        if (index == -1) {
-            return;
-        }
-        return this._values[index];
+    *keys() {
+        yield* this.keyOrder;
     }
-    delete(key) {
-        const index = this.indexOf(key);
-        if (index == -1) {
-            return false;
+    *values() {
+        for (const key of this.keyOrder) {
+            yield this.items.get(key.toBigInt());
         }
-        this._keys.splice(index, 1);
-        this._values.splice(index, 1);
-        return true;
     }
-    *[Symbol.iterator]() {
-        for (const key of this._keys) {
-            yield [key, this.get(key)];
+    forEach(callback, thisArg) {
+        for (const key of this.keyOrder) {
+            callback.call(thisArg, this.items.get(key.toBigInt()), key, this);
         }
     }
+    [Symbol.iterator]() {
+        return this.entries();
+    }
 }

package/build/deterministic/AddressSet.d.ts

@@ -1,5 +1,6 @@
 import { Address } from '../keypair/Address.js';
 export declare class AddressSet {
+    private items;
     private keys;
     constructor(keys?: Address[]);
     get size(): number;
@@ -9,5 +10,5 @@ export declare class AddressSet {
     clone(): AddressSet;
     clear(): void;
     combine(set: AddressSet): AddressSet;
-    [Symbol.iterator](): Generator<Address, void, unknown>;
+    [Symbol.iterator](): IterableIterator<Address>;
 }

package/build/deterministic/AddressSet.js

@@ -1,49 +1,45 @@
 export class AddressSet {
     constructor(keys = []) {
-        this.keys = keys;
+        this.items = new Set();
+        this.keys = [];
+        for (const key of keys) {
+            this.add(key);
+        }
     }
     get size() {
         return this.keys.length;
     }
     add(address) {
-        if (!this.has(address)) {
+        const addressBigInt = address.toBigInt();
+        if (!this.items.has(addressBigInt)) {
+            this.items.add(addressBigInt);
             this.keys.push(address);
         }
     }
     has(address) {
-        for (let i = 0; i < this.keys.length; i++) {
-            if (this.keys[i].equals(address)) {
-                return true;
-            }
-        }
-        return false;
+        return this.items.has(address.toBigInt());
     }
     remove(address) {
-        const index = this.keys.findIndex((key) => key.equals(address));
-        if (index !== -1) {
-            this.keys.splice(index, 1);
+        const addressBigInt = address.toBigInt();
+        if (this.items.delete(addressBigInt)) {
+            this.keys = this.keys.filter((k) => k.toBigInt() !== addressBigInt);
         }
     }
     clone() {
-        const clone = new AddressSet();
-        for (let i = 0; i < this.keys.length; i++) {
-            clone.add(this.keys[i]);
-        }
-        return clone;
+        return new AddressSet(this.keys);
     }
     clear() {
+        this.items.clear();
         this.keys = [];
     }
     combine(set) {
         const clone = this.clone();
-        for (let i = 0; i < set.keys.length; i++) {
-            clone.add(set.keys[i]);
+        for (const key of set.keys) {
+            clone.add(key);
         }
         return clone;
     }
     *[Symbol.iterator]() {
-        for (let i = 0; i < this.keys.length; i++) {
-            yield this.keys[i];
-        }
+        yield* this.keys;
     }
 }

package/build/deterministic/DeterministicMap.d.ts

@@ -1,7 +1,7 @@
 export declare class DeterministicMap<K, V> {
     #private;
-    private compareFn;
     private map;
+    private readonly compareFn;
     constructor(compareFn: (a: K, b: K) => number);
     get size(): number;
     static fromMap<K, V>(map: Map<K, V>, compareFn: (a: K, b: K) => number): DeterministicMap<K, V>;

package/build/deterministic/DeterministicMap.js

@@ -9,13 +9,13 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
     if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
     return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
 };
-var _DeterministicMap_keys;
+var _DeterministicMap_keyOrder;
 export class DeterministicMap {
     constructor(compareFn) {
-        this.compareFn = compareFn;
-        _DeterministicMap_keys.set(this, void 0);
+        _DeterministicMap_keyOrder.set(this, void 0);
         this.map = new Map();
-        __classPrivateFieldSet(this, _DeterministicMap_keys, [], "f");
+        __classPrivateFieldSet(this, _DeterministicMap_keyOrder, [], "f");
+        this.compareFn = compareFn;
     }
     get size() {
         return this.map.size;
@@ -29,8 +29,8 @@ export class DeterministicMap {
     }
     set(key, value) {
         if (!this.map.has(key)) {
-            __classPrivateFieldGet(this, _DeterministicMap_keys, "f").push(key);
-            __classPrivateFieldGet(this, _DeterministicMap_keys, "f").sort(this.compareFn);
+            __classPrivateFieldGet(this, _DeterministicMap_keyOrder, "f").push(key);
+            __classPrivateFieldGet(this, _DeterministicMap_keyOrder, "f").sort(this.compareFn);
         }
         this.map.set(key, value);
     }
@@ -38,14 +38,14 @@ export class DeterministicMap {
         return this.map.get(key);
     }
     keys() {
-        return __classPrivateFieldGet(this, _DeterministicMap_keys, "f").values();
+        return __classPrivateFieldGet(this, _DeterministicMap_keyOrder, "f").values();
     }
     values() {
         const values = [];
-        for (let i = 0; i < __classPrivateFieldGet(this, _DeterministicMap_keys, "f").length; i++) {
-            const key = __classPrivateFieldGet(this, _DeterministicMap_keys, "f")[i];
+        for (let i = 0; i < __classPrivateFieldGet(this, _DeterministicMap_keyOrder, "f").length; i++) {
+            const key = __classPrivateFieldGet(this, _DeterministicMap_keyOrder, "f")[i];
             const value = this.map.get(key);
-            if (value) {
+            if (value !== undefined) {
                 values.push(value);
             }
             else {
@@ -60,23 +60,23 @@ export class DeterministicMap {
     delete(key) {
         if (this.map.has(key)) {
             this.map.delete(key);
-            __classPrivateFieldSet(this, _DeterministicMap_keys, __classPrivateFieldGet(this, _DeterministicMap_keys, "f").filter((k) => k !== key), "f");
+            __classPrivateFieldSet(this, _DeterministicMap_keyOrder, __classPrivateFieldGet(this, _DeterministicMap_keyOrder, "f").filter((k) => k !== key), "f");
             return true;
         }
         return false;
     }
     clear() {
         this.map.clear();
-        __classPrivateFieldSet(this, _DeterministicMap_keys, [], "f");
+        __classPrivateFieldSet(this, _DeterministicMap_keyOrder, [], "f");
     }
     forEach(callback) {
-        for (const key of __classPrivateFieldGet(this, _DeterministicMap_keys, "f")) {
+        for (const key of __classPrivateFieldGet(this, _DeterministicMap_keyOrder, "f")) {
             const value = this.map.get(key);
             callback(value, key, this);
         }
     }
-    *[(_DeterministicMap_keys = new WeakMap(), Symbol.iterator)]() {
-        for (const key of __classPrivateFieldGet(this, _DeterministicMap_keys, "f")) {
+    *[(_DeterministicMap_keyOrder = new WeakMap(), Symbol.iterator)]() {
+        for (const key of __classPrivateFieldGet(this, _DeterministicMap_keyOrder, "f")) {
             yield [key, this.map.get(key)];
         }
     }

package/build/keypair/Address.d.ts

@@ -11,6 +11,9 @@ export declare class Address extends Uint8Array {
     static fromString(mldsaPublicKey: string, classicPublicKey?: string): Address;
     static wrap(bytes: ArrayLike<number>): Address;
     static uncompressedToCompressed(publicKey: ArrayLike<number>): Buffer;
+    static fromBigInt(value: bigint): Address;
+    static fromUint64Array(w0: bigint, w1: bigint, w2: bigint, w3: bigint): Address;
+    toUint64Array(): [bigint, bigint, bigint, bigint];
     toHex(): string;
     tweakedToHex(): string;
     toBuffer(): Buffer;
@@ -20,6 +23,7 @@ export declare class Address extends Uint8Array {
     toHybridPublicKeyHex(): string;
     toHybridPublicKeyBuffer(): Buffer;
     originalPublicKeyBuffer(): Buffer;
+    toBigInt(): bigint;
     equals(a: Address): boolean;
     lessThan(a: Address): boolean;
     greaterThan(a: Address): boolean;

package/build/keypair/Address.js

@@ -9,7 +9,7 @@ var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (
     if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
     return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
 };
-var _Address_p2tr, _Address_p2op, _Address_network, _Address_originalPublicKey, _Address_keyPair, _Address_uncompressed, _Address_tweakedUncompressed, _Address_p2wda, _Address_mldsaPublicKey;
+var _Address_p2tr, _Address_p2op, _Address_network, _Address_originalPublicKey, _Address_keyPair, _Address_uncompressed, _Address_tweakedUncompressed, _Address_p2wda, _Address_mldsaPublicKey, _Address_cachedBigInt, _Address_cachedUint64Array;
 import { decompressPublicKey, toXOnly } from '@btc-vision/bitcoin';
 import { ADDRESS_BYTE_LENGTH } from '../utils/lengths.js';
 import { AddressVerificator } from './AddressVerificator.js';
@@ -31,6 +31,8 @@ export class Address extends Uint8Array {
         _Address_tweakedUncompressed.set(this, void 0);
         _Address_p2wda.set(this, void 0);
         _Address_mldsaPublicKey.set(this, void 0);
+        _Address_cachedBigInt.set(this, void 0);
+        _Address_cachedUint64Array.set(this, void 0);
         if (!mldsaPublicKey) {
             return;
         }
@@ -89,6 +91,37 @@ export class Address extends Uint8Array {
         compressed.set(x, 1);
         return compressed;
     }
+    static fromBigInt(value) {
+        const buffer = new Uint8Array(32);
+        const view = new DataView(buffer.buffer);
+        view.setBigUint64(0, (value >> 192n) & 0xffffffffffffffffn, false);
+        view.setBigUint64(8, (value >> 128n) & 0xffffffffffffffffn, false);
+        view.setBigUint64(16, (value >> 64n) & 0xffffffffffffffffn, false);
+        view.setBigUint64(24, value & 0xffffffffffffffffn, false);
+        return new Address(buffer);
+    }
+    static fromUint64Array(w0, w1, w2, w3) {
+        const buffer = new Uint8Array(32);
+        const view = new DataView(buffer.buffer);
+        view.setBigUint64(0, w0, false);
+        view.setBigUint64(8, w1, false);
+        view.setBigUint64(16, w2, false);
+        view.setBigUint64(24, w3, false);
+        return new Address(buffer);
+    }
+    toUint64Array() {
+        if (__classPrivateFieldGet(this, _Address_cachedUint64Array, "f") !== undefined) {
+            return __classPrivateFieldGet(this, _Address_cachedUint64Array, "f");
+        }
+        const view = new DataView(this.buffer, this.byteOffset, 32);
+        __classPrivateFieldSet(this, _Address_cachedUint64Array, [
+            view.getBigUint64(0, false),
+            view.getBigUint64(8, false),
+            view.getBigUint64(16, false),
+            view.getBigUint64(24, false),
+        ], "f");
+        return __classPrivateFieldGet(this, _Address_cachedUint64Array, "f");
+    }
     toHex() {
         return '0x' + Buffer.from(this).toString('hex');
     }
@@ -137,6 +170,17 @@ export class Address extends Uint8Array {
         }
         return Buffer.from(__classPrivateFieldGet(this, _Address_originalPublicKey, "f"));
     }
+    toBigInt() {
+        if (__classPrivateFieldGet(this, _Address_cachedBigInt, "f") !== undefined) {
+            return __classPrivateFieldGet(this, _Address_cachedBigInt, "f");
+        }
+        const view = new DataView(this.buffer, this.byteOffset, 32);
+        __classPrivateFieldSet(this, _Address_cachedBigInt, (view.getBigUint64(0, false) << 192n) |
+            (view.getBigUint64(8, false) << 128n) |
+            (view.getBigUint64(16, false) << 64n) |
+            view.getBigUint64(24, false), "f");
+        return __classPrivateFieldGet(this, _Address_cachedBigInt, "f");
+    }
     equals(a) {
         const b = this;
         if (a.length !== b.length) {
@@ -322,4 +366,4 @@ export class Address extends Uint8Array {
         this.classicPublicKey.set(tweakedBytes);
     }
 }
-_Address_p2tr = new WeakMap(), _Address_p2op = new WeakMap(), _Address_network = new WeakMap(), _Address_originalPublicKey = new WeakMap(), _Address_keyPair = new WeakMap(), _Address_uncompressed = new WeakMap(), _Address_tweakedUncompressed = new WeakMap(), _Address_p2wda = new WeakMap(), _Address_mldsaPublicKey = new WeakMap();
+_Address_p2tr = new WeakMap(), _Address_p2op = new WeakMap(), _Address_network = new WeakMap(), _Address_originalPublicKey = new WeakMap(), _Address_keyPair = new WeakMap(), _Address_uncompressed = new WeakMap(), _Address_tweakedUncompressed = new WeakMap(), _Address_p2wda = new WeakMap(), _Address_mldsaPublicKey = new WeakMap(), _Address_cachedBigInt = new WeakMap(), _Address_cachedUint64Array = new WeakMap();

package/build/mnemonic/BIPStandard.d.ts

@@ -0,0 +1,8 @@
+export declare enum BIPStandard {
+    BIP44 = 44,
+    BIP49 = 49,
+    BIP84 = 84,
+    BIP86 = 86
+}
+export declare function getBIPDescription(standard: BIPStandard): string;
+export declare function buildBIPPath(standard: BIPStandard, coinType: number, account: number, change: number, addressIndex: number): string;

package/build/mnemonic/BIPStandard.js

@@ -0,0 +1,24 @@
+export var BIPStandard;
+(function (BIPStandard) {
+    BIPStandard[BIPStandard["BIP44"] = 44] = "BIP44";
+    BIPStandard[BIPStandard["BIP49"] = 49] = "BIP49";
+    BIPStandard[BIPStandard["BIP84"] = 84] = "BIP84";
+    BIPStandard[BIPStandard["BIP86"] = 86] = "BIP86";
+})(BIPStandard || (BIPStandard = {}));
+export function getBIPDescription(standard) {
+    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';
+    }
+}
+export function buildBIPPath(standard, coinType, account, change, addressIndex) {
+    return `m/${standard}'/${coinType}'/${account}'/${change}/${addressIndex}`;
+}

package/build/mnemonic/Mnemonic.d.ts

@@ -2,6 +2,9 @@ import { BIP32Interface, MLDSASecurityLevel, QuantumBIP32Interface } from '@btc-
 import { Network } from '@btc-vision/bitcoin';
 import { Wallet } from '../keypair/Wallet.js';
 import { MnemonicStrength } from './MnemonicStrength.js';
+import { BIPStandard } from './BIPStandard.js';
+import { AddressTypes } from '../keypair/AddressVerificator.js';
+export { BIPStandard, getBIPDescription } from './BIPStandard.js';
 export declare class Mnemonic {
     private readonly _phrase;
     private readonly _passphrase;
@@ -18,8 +21,10 @@ export declare class Mnemonic {
     static generatePhrase(strength?: MnemonicStrength): string;
     static generate(strength?: MnemonicStrength, passphrase?: string, network?: Network, securityLevel?: MLDSASecurityLevel): Mnemonic;
     static validate(phrase: string): boolean;
-    derive(index?: number, account?: number, isChange?: boolean): Wallet;
-    deriveMultiple(count: number, startIndex?: number, account?: number, isChange?: boolean): Wallet[];
+    derive(index?: number, account?: number, isChange?: boolean, bipStandard?: BIPStandard): Wallet;
+    deriveUnisat(addressType?: AddressTypes, index?: number, account?: number, isChange?: boolean): Wallet;
+    deriveMultipleUnisat(addressType?: AddressTypes, count?: number, startIndex?: number, account?: number, isChange?: boolean): Wallet[];
+    deriveMultiple(count: number, startIndex?: number, account?: number, isChange?: boolean, bipStandard?: BIPStandard): Wallet[];
     deriveCustomPath(classicalPath: string, quantumPath: string): Wallet;
     getClassicalRoot(): BIP32Interface;
     getQuantumRoot(): QuantumBIP32Interface;