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

package/build/_version.d.ts

@@ -1 +1 @@
-export declare const version = "1.7.31";
+export declare const version = "1.8.0-alpha.2";

package/build/_version.js

@@ -1 +1 @@
-export const version = '1.7.31';
+export const version = '1.8.0-alpha.2';

package/build/abi/ABICoder.d.ts

@@ -5,15 +5,23 @@ export declare enum ABIDataTypes {
     UINT64 = "UINT64",
     UINT128 = "UINT128",
     UINT256 = "UINT256",
+    INT8 = "INT8",
+    INT16 = "INT16",
+    INT32 = "INT32",
+    INT64 = "INT64",
     INT128 = "INT128",
     BOOL = "BOOL",
     ADDRESS = "ADDRESS",
+    EXTENDED_ADDRESS = "EXTENDED_ADDRESS",
     STRING = "STRING",
     BYTES4 = "BYTES4",
     BYTES32 = "BYTES32",
     BYTES = "BYTES",
     ADDRESS_UINT256_TUPLE = "ADDRESS_UINT256_TUPLE",
+    EXTENDED_ADDRESS_UINT256_TUPLE = "EXTENDED_ADDRESS_UINT256_TUPLE",
+    SCHNORR_SIGNATURE = "SCHNORR_SIGNATURE",
     ARRAY_OF_ADDRESSES = "ARRAY_OF_ADDRESSES",
+    ARRAY_OF_EXTENDED_ADDRESSES = "ARRAY_OF_EXTENDED_ADDRESSES",
     ARRAY_OF_UINT256 = "ARRAY_OF_UINT256",
     ARRAY_OF_UINT128 = "ARRAY_OF_UINT128",
     ARRAY_OF_UINT64 = "ARRAY_OF_UINT64",

package/build/abi/ABICoder.js

@@ -9,15 +9,23 @@ export var ABIDataTypes;
     ABIDataTypes["UINT64"] = "UINT64";
     ABIDataTypes["UINT128"] = "UINT128";
     ABIDataTypes["UINT256"] = "UINT256";
+    ABIDataTypes["INT8"] = "INT8";
+    ABIDataTypes["INT16"] = "INT16";
+    ABIDataTypes["INT32"] = "INT32";
+    ABIDataTypes["INT64"] = "INT64";
     ABIDataTypes["INT128"] = "INT128";
     ABIDataTypes["BOOL"] = "BOOL";
     ABIDataTypes["ADDRESS"] = "ADDRESS";
+    ABIDataTypes["EXTENDED_ADDRESS"] = "EXTENDED_ADDRESS";
     ABIDataTypes["STRING"] = "STRING";
     ABIDataTypes["BYTES4"] = "BYTES4";
     ABIDataTypes["BYTES32"] = "BYTES32";
     ABIDataTypes["BYTES"] = "BYTES";
     ABIDataTypes["ADDRESS_UINT256_TUPLE"] = "ADDRESS_UINT256_TUPLE";
+    ABIDataTypes["EXTENDED_ADDRESS_UINT256_TUPLE"] = "EXTENDED_ADDRESS_UINT256_TUPLE";
+    ABIDataTypes["SCHNORR_SIGNATURE"] = "SCHNORR_SIGNATURE";
     ABIDataTypes["ARRAY_OF_ADDRESSES"] = "ARRAY_OF_ADDRESSES";
+    ABIDataTypes["ARRAY_OF_EXTENDED_ADDRESSES"] = "ARRAY_OF_EXTENDED_ADDRESSES";
     ABIDataTypes["ARRAY_OF_UINT256"] = "ARRAY_OF_UINT256";
     ABIDataTypes["ARRAY_OF_UINT128"] = "ARRAY_OF_UINT128";
     ABIDataTypes["ARRAY_OF_UINT64"] = "ARRAY_OF_UINT64";
@@ -65,12 +73,33 @@ export class ABICoder {
                 case ABIDataTypes.UINT256:
                     result.push(byteReader.readU256());
                     break;
+                case ABIDataTypes.INT8:
+                    result.push(byteReader.readI8());
+                    break;
+                case ABIDataTypes.INT16:
+                    result.push(byteReader.readI16());
+                    break;
+                case ABIDataTypes.INT32:
+                    result.push(byteReader.readI32());
+                    break;
+                case ABIDataTypes.INT64:
+                    result.push(byteReader.readI64());
+                    break;
                 case ABIDataTypes.INT128:
                     result.push(byteReader.readI128());
                     break;
+                case ABIDataTypes.EXTENDED_ADDRESS:
+                    result.push(byteReader.readExtendedAddress());
+                    break;
                 case ABIDataTypes.ADDRESS_UINT256_TUPLE:
                     result.push(byteReader.readAddressValueTuple());
                     break;
+                case ABIDataTypes.EXTENDED_ADDRESS_UINT256_TUPLE:
+                    result.push(byteReader.readExtendedAddressMapU256());
+                    break;
+                case ABIDataTypes.SCHNORR_SIGNATURE:
+                    result.push(byteReader.readSchnorrSignature());
+                    break;
                 case ABIDataTypes.BYTES:
                     result.push(byteReader.readBytesWithLength());
                     break;
@@ -80,6 +109,9 @@ export class ABICoder {
                 case ABIDataTypes.ARRAY_OF_ADDRESSES:
                     result.push(byteReader.readAddressArray());
                     break;
+                case ABIDataTypes.ARRAY_OF_EXTENDED_ADDRESSES:
+                    result.push(byteReader.readExtendedAddressArray());
+                    break;
                 case ABIDataTypes.ARRAY_OF_UINT256:
                     result.push(byteReader.readU256Array());
                     break;

package/build/buffer/BinaryReader.d.ts

@@ -1,6 +1,11 @@
 import { AddressMap } from '../deterministic/AddressMap.js';
+import { ExtendedAddressMap } from '../deterministic/ExtendedAddressMap.js';
 import { Address } from '../keypair/Address.js';
-import { BufferLike, Selector, u16, u32, u8 } from '../utils/types.js';
+import { BufferLike, i16, i32, i64, i8, Selector, u16, u32, u8 } from '../utils/types.js';
+export interface SchnorrSignature {
+    readonly address: Address;
+    readonly signature: Uint8Array;
+}
 export declare class BinaryReader {
     private buffer;
     private currentOffset;
@@ -9,8 +14,13 @@ export declare class BinaryReader {
     static bigintCompare(a: bigint, b: bigint): number;
     static numberCompare(a: number, b: number): number;
     setBuffer(bytes: BufferLike): void;
+    get byteLength(): number;
     length(): number;
     bytesLeft(): number;
+    readI8(): i8;
+    readI16(be?: boolean): i16;
+    readI32(be?: boolean): i32;
+    readI64(be?: boolean): i64;
     readU8(): u8;
     readU16(be?: boolean): u16;
     readU32(be?: boolean): u32;
@@ -24,6 +34,9 @@ export declare class BinaryReader {
     readString(length: u32): string;
     readStringWithLength(be?: boolean): string;
     readAddress(): Address;
+    readTweakedPublicKey(): Uint8Array;
+    readExtendedAddress(): Address;
+    readSchnorrSignature(): SchnorrSignature;
     readBytesWithLength(maxLength?: number, be?: boolean): Uint8Array;
     readArrayOfBuffer(be?: boolean): Uint8Array[];
     readAddressArray(be?: boolean): Address[];
@@ -36,6 +49,8 @@ export declare class BinaryReader {
     readStringArray(be?: boolean): string[];
     readBytesArray(be?: boolean): Uint8Array[];
     readAddressValueTuple(be?: boolean): AddressMap<bigint>;
+    readExtendedAddressArray(be?: boolean): Address[];
+    readExtendedAddressMapU256(be?: boolean): ExtendedAddressMap<bigint>;
     getOffset(): u16;
     setOffset(offset: u16): void;
     verifyEnd(size: number): void;

package/build/buffer/BinaryReader.js

@@ -1,6 +1,7 @@
 import { AddressMap } from '../deterministic/AddressMap.js';
+import { ExtendedAddressMap } from '../deterministic/ExtendedAddressMap.js';
 import { Address } from '../keypair/Address.js';
-import { ADDRESS_BYTE_LENGTH, I128_BYTE_LENGTH, U128_BYTE_LENGTH, U16_BYTE_LENGTH, U256_BYTE_LENGTH, U32_BYTE_LENGTH, U64_BYTE_LENGTH, U8_BYTE_LENGTH, } from '../utils/lengths.js';
+import { ADDRESS_BYTE_LENGTH, EXTENDED_ADDRESS_BYTE_LENGTH, I128_BYTE_LENGTH, I16_BYTE_LENGTH, I32_BYTE_LENGTH, I64_BYTE_LENGTH, I8_BYTE_LENGTH, SCHNORR_SIGNATURE_BYTE_LENGTH, U128_BYTE_LENGTH, U16_BYTE_LENGTH, U256_BYTE_LENGTH, U32_BYTE_LENGTH, U64_BYTE_LENGTH, U8_BYTE_LENGTH, } from '../utils/lengths.js';
 export class BinaryReader {
     constructor(bytes) {
         this.currentOffset = 0;
@@ -27,12 +28,39 @@ export class BinaryReader {
         this.buffer = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
         this.currentOffset = 0;
     }
+    get byteLength() {
+        return this.buffer.byteLength;
+    }
     length() {
         return this.buffer.byteLength;
     }
     bytesLeft() {
         return this.buffer.byteLength - this.currentOffset;
     }
+    readI8() {
+        this.verifyEnd(this.currentOffset + I8_BYTE_LENGTH);
+        const value = this.buffer.getInt8(this.currentOffset);
+        this.currentOffset += I8_BYTE_LENGTH;
+        return value;
+    }
+    readI16(be = true) {
+        this.verifyEnd(this.currentOffset + I16_BYTE_LENGTH);
+        const value = this.buffer.getInt16(this.currentOffset, !be);
+        this.currentOffset += I16_BYTE_LENGTH;
+        return value;
+    }
+    readI32(be = true) {
+        this.verifyEnd(this.currentOffset + I32_BYTE_LENGTH);
+        const value = this.buffer.getInt32(this.currentOffset, !be);
+        this.currentOffset += I32_BYTE_LENGTH;
+        return value;
+    }
+    readI64(be = true) {
+        this.verifyEnd(this.currentOffset + I64_BYTE_LENGTH);
+        const value = this.buffer.getBigInt64(this.currentOffset, !be);
+        this.currentOffset += I64_BYTE_LENGTH;
+        return value;
+    }
     readU8() {
         this.verifyEnd(this.currentOffset + U8_BYTE_LENGTH);
         const value = this.buffer.getUint8(this.currentOffset);
@@ -119,6 +147,22 @@ export class BinaryReader {
         const bytes = Array.from(this.readBytes(ADDRESS_BYTE_LENGTH));
         return new Address(bytes);
     }
+    readTweakedPublicKey() {
+        this.verifyEnd(this.currentOffset + ADDRESS_BYTE_LENGTH);
+        return this.readBytes(ADDRESS_BYTE_LENGTH);
+    }
+    readExtendedAddress() {
+        this.verifyEnd(this.currentOffset + EXTENDED_ADDRESS_BYTE_LENGTH);
+        const tweakedPublicKey = Array.from(this.readBytes(ADDRESS_BYTE_LENGTH));
+        const mldsaKeyHash = Array.from(this.readBytes(ADDRESS_BYTE_LENGTH));
+        return new Address(mldsaKeyHash, tweakedPublicKey);
+    }
+    readSchnorrSignature() {
+        this.verifyEnd(this.currentOffset + EXTENDED_ADDRESS_BYTE_LENGTH + SCHNORR_SIGNATURE_BYTE_LENGTH);
+        const address = this.readExtendedAddress();
+        const signature = this.readBytes(SCHNORR_SIGNATURE_BYTE_LENGTH);
+        return { address, signature };
+    }
     readBytesWithLength(maxLength = 0, be = true) {
         const length = this.readU32(be);
         if (maxLength > 0 && length > maxLength) {
@@ -219,6 +263,27 @@ export class BinaryReader {
         }
         return result;
     }
+    readExtendedAddressArray(be = true) {
+        const length = this.readU16(be);
+        const result = new Array(length);
+        for (let i = 0; i < length; i++) {
+            result[i] = this.readExtendedAddress();
+        }
+        return result;
+    }
+    readExtendedAddressMapU256(be = true) {
+        const length = this.readU16(be);
+        const result = new ExtendedAddressMap();
+        for (let i = 0; i < length; i++) {
+            const address = this.readExtendedAddress();
+            const value = this.readU256(be);
+            if (result.has(address)) {
+                throw new Error('Duplicate tweaked address found in map');
+            }
+            result.set(address, value);
+        }
+        return result;
+    }
     getOffset() {
         return this.currentOffset;
     }

package/build/buffer/BinaryWriter.d.ts

@@ -1,6 +1,7 @@
 import { AddressMap } from '../deterministic/AddressMap.js';
+import { ExtendedAddressMap } from '../deterministic/ExtendedAddressMap.js';
 import { Address } from '../keypair/Address.js';
-import { Selector, u16, u32, u64, u8 } from '../utils/types.js';
+import { i16, i32, i64, i8, Selector, u16, u32, u64, u8 } from '../utils/types.js';
 import { BinaryReader } from './BinaryReader.js';
 export declare class BinaryWriter {
     private currentOffset;
@@ -11,6 +12,10 @@ export declare class BinaryWriter {
     writeU16(value: u16, be?: boolean): void;
     writeU32(value: u32, be?: boolean): void;
     writeU64(value: u64, be?: boolean): void;
+    writeI8(value: i8): void;
+    writeI16(value: i16, be?: boolean): void;
+    writeI32(value: i32, be?: boolean): void;
+    writeI64(value: i64, be?: boolean): void;
     writeSelector(value: Selector): void;
     writeBoolean(value: boolean): void;
     writeI128(bigIntValue: bigint, be?: boolean): void;
@@ -20,6 +25,9 @@ export declare class BinaryWriter {
     writeString(value: string): void;
     writeStringWithLength(value: string): void;
     writeAddress(value: Address): void;
+    writeTweakedPublicKey(value: Address): void;
+    writeExtendedAddress(value: Address): void;
+    writeSchnorrSignature(address: Address, signature: Uint8Array): void;
     getBuffer(clear?: boolean): Uint8Array;
     reset(): void;
     toBytesReader(): BinaryReader;
@@ -28,9 +36,11 @@ export declare class BinaryWriter {
     clear(): void;
     allocSafe(size: u32): void;
     writeAddressValueTuple(map: AddressMap<bigint>, be?: boolean): void;
+    writeExtendedAddressMapU256(map: ExtendedAddressMap<bigint>, be?: boolean): void;
     writeBytesWithLength(value: Uint8Array): void;
     writeArrayOfBuffer(values: Uint8Array[], be?: boolean): void;
     writeAddressArray(value: Address[]): void;
+    writeExtendedAddressArray(value: Address[]): void;
     writeU32Array(value: u32[], be?: boolean): void;
     writeU256Array(value: bigint[], be?: boolean): void;
     writeU128Array(value: bigint[], be?: boolean): void;

package/build/buffer/BinaryWriter.js

@@ -1,5 +1,5 @@
 import { BufferHelper } from '../utils/BufferHelper.js';
-import { ADDRESS_BYTE_LENGTH, I128_BYTE_LENGTH, U128_BYTE_LENGTH, U16_BYTE_LENGTH, U256_BYTE_LENGTH, U32_BYTE_LENGTH, U64_BYTE_LENGTH, U8_BYTE_LENGTH, } from '../utils/lengths.js';
+import { ADDRESS_BYTE_LENGTH, EXTENDED_ADDRESS_BYTE_LENGTH, I128_BYTE_LENGTH, I16_BYTE_LENGTH, I32_BYTE_LENGTH, I64_BYTE_LENGTH, I8_BYTE_LENGTH, SCHNORR_SIGNATURE_BYTE_LENGTH, U128_BYTE_LENGTH, U16_BYTE_LENGTH, U256_BYTE_LENGTH, U32_BYTE_LENGTH, U64_BYTE_LENGTH, U8_BYTE_LENGTH, } from '../utils/lengths.js';
 import { BinaryReader } from './BinaryReader.js';
 export class BinaryWriter {
     constructor(length = 0) {
@@ -42,6 +42,35 @@ export class BinaryWriter {
         this.buffer.setBigUint64(this.currentOffset, value, !be);
         this.currentOffset += 8;
     }
+    writeI8(value) {
+        if (value < -128 || value > 127)
+            throw new Error('i8 value is out of range.');
+        this.allocSafe(I8_BYTE_LENGTH);
+        this.buffer.setInt8(this.currentOffset, value);
+        this.currentOffset += I8_BYTE_LENGTH;
+    }
+    writeI16(value, be = true) {
+        if (value < -32768 || value > 32767)
+            throw new Error('i16 value is out of range.');
+        this.allocSafe(I16_BYTE_LENGTH);
+        this.buffer.setInt16(this.currentOffset, value, !be);
+        this.currentOffset += I16_BYTE_LENGTH;
+    }
+    writeI32(value, be = true) {
+        if (value < -2147483648 || value > 2147483647)
+            throw new Error('i32 value is out of range.');
+        this.allocSafe(I32_BYTE_LENGTH);
+        this.buffer.setInt32(this.currentOffset, value, !be);
+        this.currentOffset += I32_BYTE_LENGTH;
+    }
+    writeI64(value, be = true) {
+        if (value < -9223372036854775808n || value > 9223372036854775807n) {
+            throw new Error('i64 value is out of range.');
+        }
+        this.allocSafe(I64_BYTE_LENGTH);
+        this.buffer.setBigInt64(this.currentOffset, value, !be);
+        this.currentOffset += I64_BYTE_LENGTH;
+    }
     writeSelector(value) {
         this.writeU32(value, true);
     }
@@ -134,6 +163,24 @@ export class BinaryWriter {
         this.verifyAddress(value);
         this.writeBytes(value);
     }
+    writeTweakedPublicKey(value) {
+        const tweakedKey = value.tweakedPublicKeyToBuffer();
+        this.allocSafe(ADDRESS_BYTE_LENGTH);
+        this.writeBytes(tweakedKey);
+    }
+    writeExtendedAddress(value) {
+        this.allocSafe(EXTENDED_ADDRESS_BYTE_LENGTH);
+        this.writeTweakedPublicKey(value);
+        this.writeBytes(value);
+    }
+    writeSchnorrSignature(address, signature) {
+        if (signature.length !== SCHNORR_SIGNATURE_BYTE_LENGTH) {
+            throw new Error(`Invalid Schnorr signature length: expected ${SCHNORR_SIGNATURE_BYTE_LENGTH}, got ${signature.length}`);
+        }
+        this.allocSafe(EXTENDED_ADDRESS_BYTE_LENGTH + SCHNORR_SIGNATURE_BYTE_LENGTH);
+        this.writeExtendedAddress(address);
+        this.writeBytes(signature);
+    }
     getBuffer(clear = true) {
         const buf = new Uint8Array(this.buffer.byteLength);
         for (let i = 0; i < this.buffer.byteLength; i++) {
@@ -179,6 +226,15 @@ export class BinaryWriter {
             this.writeU256(value, be);
         }
     }
+    writeExtendedAddressMapU256(map, be = true) {
+        if (map.size > 65535)
+            throw new Error('Map size is too large');
+        this.writeU16(map.size, be);
+        for (const [key, value] of map.entries()) {
+            this.writeExtendedAddress(key);
+            this.writeU256(value, be);
+        }
+    }
     writeBytesWithLength(value) {
         this.writeU32(value.length);
         this.writeBytes(value);
@@ -200,6 +256,15 @@ export class BinaryWriter {
             this.writeAddress(value[i]);
         }
     }
+    writeExtendedAddressArray(value) {
+        if (value.length > 65535)
+            throw new Error('Array size is too large');
+        this.allocSafe(U16_BYTE_LENGTH + value.length * EXTENDED_ADDRESS_BYTE_LENGTH);
+        this.writeU16(value.length);
+        for (let i = 0; i < value.length; i++) {
+            this.writeExtendedAddress(value[i]);
+        }
+    }
     writeU32Array(value, be = true) {
         if (value.length > 65535)
             throw new Error('Array size is too large');

package/build/deterministic/ExtendedAddressMap.d.ts

@@ -0,0 +1,19 @@
+import { Address } from '../keypair/Address.js';
+export declare class ExtendedAddressMap<V> {
+    private indexMap;
+    private _keys;
+    private _values;
+    constructor(iterable?: ReadonlyArray<readonly [Address, V]> | null);
+    get size(): number;
+    set(key: Address, value: V): this;
+    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: ExtendedAddressMap<V>) => void, thisArg?: unknown): void;
+    [Symbol.iterator](): IterableIterator<[Address, V]>;
+}

package/build/deterministic/ExtendedAddressMap.js

@@ -0,0 +1,87 @@
+import { FastMap } from './FastMap.js';
+export class ExtendedAddressMap {
+    constructor(iterable) {
+        this._keys = [];
+        this._values = [];
+        this.indexMap = new FastMap();
+        if (iterable) {
+            for (const [key, value] of iterable) {
+                this.set(key, value);
+            }
+        }
+    }
+    get size() {
+        return this._keys.length;
+    }
+    set(key, value) {
+        const keyBigInt = key.tweakedToBigInt();
+        const existingIndex = this.indexMap.get(keyBigInt);
+        if (existingIndex !== undefined) {
+            this._values[existingIndex] = value;
+        }
+        else {
+            const newIndex = this._keys.length;
+            this._keys.push(key);
+            this._values.push(value);
+            this.indexMap.set(keyBigInt, newIndex);
+        }
+        return this;
+    }
+    get(key) {
+        const keyBigInt = key.tweakedToBigInt();
+        const index = this.indexMap.get(keyBigInt);
+        if (index === undefined) {
+            return undefined;
+        }
+        return this._values[index];
+    }
+    has(key) {
+        return this.indexMap.has(key.tweakedToBigInt());
+    }
+    delete(key) {
+        const keyBigInt = key.tweakedToBigInt();
+        const index = this.indexMap.get(keyBigInt);
+        if (index === undefined) {
+            return false;
+        }
+        this._keys.splice(index, 1);
+        this._values.splice(index, 1);
+        this.indexMap.clear();
+        for (let i = 0; i < this._keys.length; i++) {
+            this.indexMap.set(this._keys[i].tweakedToBigInt(), i);
+        }
+        return true;
+    }
+    clear() {
+        this.indexMap.clear();
+        this._keys = [];
+        this._values = [];
+    }
+    indexOf(address) {
+        const index = this.indexMap.get(address.tweakedToBigInt());
+        return index !== undefined ? index : -1;
+    }
+    *entries() {
+        for (let i = 0; i < this._keys.length; i++) {
+            yield [this._keys[i], this._values[i]];
+        }
+    }
+    *keys() {
+        for (const key of this._keys) {
+            yield key;
+        }
+    }
+    *values() {
+        for (const value of this._values) {
+            yield value;
+        }
+    }
+    forEach(callback, thisArg) {
+        for (let i = 0; i < this._keys.length; i++) {
+            callback.call(thisArg, this._values[i], this._keys[i], this);
+        }
+    }
+    *[Symbol.iterator]() {
+        yield* this.entries();
+    }
+}

package/build/keypair/Address.d.ts

@@ -16,8 +16,9 @@ export declare class Address extends Uint8Array {
     static fromString(mldsaPublicKey: string, legacyPublicKey?: string): Address;
     static wrap(bytes: ArrayLike<number>): Address;
     static uncompressedToCompressed(publicKey: ArrayLike<number>): Buffer;
-    static fromBigInt(value: bigint): Address;
+    static fromBigInt(value: bigint, tweakedValue?: bigint): Address;
     static fromUint64Array(w0: bigint, w1: bigint, w2: bigint, w3: bigint): Address;
+    private static bigintToUint8Array;
     toUint64Array(): [bigint, bigint, bigint, bigint];
     isDead(): boolean;
     toHex(): string;
@@ -30,6 +31,7 @@ export declare class Address extends Uint8Array {
     toHybridPublicKeyBuffer(): Buffer;
     originalPublicKeyBuffer(): Buffer;
     toBigInt(): bigint;
+    tweakedToBigInt(): bigint;
     equals(a: Address): boolean;
     lessThan(a: Address): boolean;
     greaterThan(a: Address): boolean;
@@ -48,6 +50,7 @@ export declare class Address extends Uint8Array {
     p2op(network: Network): string;
     toTweakedHybridPublicKeyHex(): string;
     toTweakedHybridPublicKeyBuffer(): Buffer;
+    private ensureTweakedUncompressed;
     private setMldsaKey;
     private ensureLegacyProcessed;
     private autoFormat;

package/build/keypair/Address.js

@@ -9,7 +9,7 @@ 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 _Address_p2tr, _Address_p2op, _Address_network, _Address_originalPublicKey, _Address_keyPair, _Address_uncompressed, _Address_tweakedUncompressed, _Address_p2wda, _Address_mldsaPublicKey, _Address_cachedBigInt, _Address_cachedUint64Array, _Address_originalMDLSAPublicKey, _Address_mldsaLevel, _Address_pendingLegacyKey, _Address_legacyProcessed, _Address_legacyPublicKey;
+var _Address_p2tr, _Address_p2op, _Address_network, _Address_originalPublicKey, _Address_keyPair, _Address_uncompressed, _Address_tweakedUncompressed, _Address_p2wda, _Address_mldsaPublicKey, _Address_cachedBigInt, _Address_cachedBigIntTweaked, _Address_cachedUint64Array, _Address_originalMDLSAPublicKey, _Address_mldsaLevel, _Address_pendingLegacyKey, _Address_legacyProcessed, _Address_legacyPublicKey;
 import { decompressPublicKey, toXOnly } from '@btc-vision/bitcoin';
 import { ADDRESS_BYTE_LENGTH } from '../utils/lengths.js';
 import { AddressVerificator } from './AddressVerificator.js';
@@ -32,6 +32,7 @@ export class Address extends Uint8Array {
         _Address_p2wda.set(this, void 0);
         _Address_mldsaPublicKey.set(this, void 0);
         _Address_cachedBigInt.set(this, void 0);
+        _Address_cachedBigIntTweaked.set(this, void 0);
         _Address_cachedUint64Array.set(this, void 0);
         _Address_originalMDLSAPublicKey.set(this, void 0);
         _Address_mldsaLevel.set(this, void 0);
@@ -118,14 +119,10 @@ 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 fromBigInt(value, tweakedValue) {
+        const address = Address.bigintToUint8Array(value);
+        const legacyAddress = tweakedValue !== undefined ? Address.bigintToUint8Array(tweakedValue) : undefined;
+        return new Address(address, legacyAddress);
     }
     static fromUint64Array(w0, w1, w2, w3) {
         const buffer = new Uint8Array(32);
@@ -136,6 +133,15 @@ export class Address extends Uint8Array {
         view.setBigUint64(24, w3, false);
         return new Address(buffer);
     }
+    static bigintToUint8Array(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 buffer;
+    }
     toUint64Array() {
         if (__classPrivateFieldGet(this, _Address_cachedUint64Array, "f") !== undefined) {
             return __classPrivateFieldGet(this, _Address_cachedUint64Array, "f");
@@ -223,6 +229,20 @@ export class Address extends Uint8Array {
             view.getBigUint64(24, false), "f");
         return __classPrivateFieldGet(this, _Address_cachedBigInt, "f");
     }
+    tweakedToBigInt() {
+        if (!this.legacyPublicKey) {
+            throw new Error('Legacy public key not set');
+        }
+        if (__classPrivateFieldGet(this, _Address_cachedBigIntTweaked, "f") !== undefined) {
+            return __classPrivateFieldGet(this, _Address_cachedBigIntTweaked, "f");
+        }
+        const view = new DataView(this.legacyPublicKey.buffer, this.byteOffset, 32);
+        __classPrivateFieldSet(this, _Address_cachedBigIntTweaked, (view.getBigUint64(0, false) << 192n) |
+            (view.getBigUint64(8, false) << 128n) |
+            (view.getBigUint64(16, false) << 64n) |
+            view.getBigUint64(24, false), "f");
+        return __classPrivateFieldGet(this, _Address_cachedBigIntTweaked, "f");
+    }
     equals(a) {
         const b = this;
         if (a.length !== b.length) {
@@ -369,6 +389,7 @@ export class Address extends Uint8Array {
     }
     toTweakedHybridPublicKeyHex() {
         this.ensureLegacyProcessed();
+        this.ensureTweakedUncompressed();
         if (!__classPrivateFieldGet(this, _Address_tweakedUncompressed, "f")) {
             throw new Error('Legacy public key not set');
         }
@@ -376,11 +397,28 @@ export class Address extends Uint8Array {
     }
     toTweakedHybridPublicKeyBuffer() {
         this.ensureLegacyProcessed();
+        this.ensureTweakedUncompressed();
         if (!__classPrivateFieldGet(this, _Address_tweakedUncompressed, "f")) {
             throw new Error('Legacy public key not set');
         }
         return __classPrivateFieldGet(this, _Address_tweakedUncompressed, "f");
     }
+    ensureTweakedUncompressed() {
+        if (__classPrivateFieldGet(this, _Address_tweakedUncompressed, "f"))
+            return;
+        const key = __classPrivateFieldGet(this, _Address_legacyPublicKey, "f");
+        if (!key)
+            return;
+        if (key.length === ADDRESS_BYTE_LENGTH && !__classPrivateFieldGet(this, _Address_originalPublicKey, "f")) {
+            try {
+                const buf = Buffer.alloc(ADDRESS_BYTE_LENGTH);
+                buf.set(key);
+                __classPrivateFieldSet(this, _Address_tweakedUncompressed, ContractAddress.generateHybridKeyFromHash(buf), "f");
+            }
+            catch {
+            }
+        }
+    }
     setMldsaKey(mldsaPublicKey) {
         if (mldsaPublicKey.length === ADDRESS_BYTE_LENGTH) {
             const buf = new Uint8Array(ADDRESS_BYTE_LENGTH);
@@ -409,9 +447,6 @@ export class Address extends Uint8Array {
         if (!pending)
             return;
         if (pending.length === ADDRESS_BYTE_LENGTH) {
-            const buf = Buffer.alloc(ADDRESS_BYTE_LENGTH);
-            buf.set(pending);
-            __classPrivateFieldSet(this, _Address_tweakedUncompressed, ContractAddress.generateHybridKeyFromHash(buf), "f");
             __classPrivateFieldSet(this, _Address_legacyPublicKey, pending, "f");
         }
         else {
@@ -434,4 +469,4 @@ export class Address extends Uint8Array {
         __classPrivateFieldGet(this, _Address_legacyPublicKey, "f").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_cachedBigInt = new WeakMap(), _Address_cachedUint64Array = new WeakMap(), _Address_originalMDLSAPublicKey = new WeakMap(), _Address_mldsaLevel = new WeakMap(), _Address_pendingLegacyKey = new WeakMap(), _Address_legacyProcessed = new WeakMap(), _Address_legacyPublicKey = 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_cachedBigIntTweaked = new WeakMap(), _Address_cachedUint64Array = new WeakMap(), _Address_originalMDLSAPublicKey = new WeakMap(), _Address_mldsaLevel = new WeakMap(), _Address_pendingLegacyKey = new WeakMap(), _Address_legacyProcessed = new WeakMap(), _Address_legacyPublicKey = new WeakMap();

package/build/mnemonic/Mnemonic.d.ts

@@ -22,7 +22,7 @@ export declare class Mnemonic {
     static generate(strength?: MnemonicStrength, passphrase?: string, network?: Network, securityLevel?: MLDSASecurityLevel): Mnemonic;
     static validate(phrase: string): boolean;
     derive(index?: number, account?: number, isChange?: boolean, bipStandard?: BIPStandard): Wallet;
-    deriveUnisat(addressType?: AddressTypes, index?: number, account?: number, isChange?: boolean): Wallet;
+    deriveOPWallet(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;