@btc-vision/transaction 1.8.0-alpha.1 → 1.8.0-beta.0

package/browser/keypair/Address.d.ts

@@ -50,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/browser/noble-hashes.js

@@ -1647,8 +1647,8 @@ export {
   ys as a,
   Pe as b,
   gs as c,
-  It as d,
-  ws as e,
+  ws as d,
+  It as e,
   _s as f,
   Ss as g,
   Is as h,

package/browser/utils/lengths.d.ts

@@ -1,4 +1,6 @@
 export declare const ADDRESS_BYTE_LENGTH: number;
+export declare const EXTENDED_ADDRESS_BYTE_LENGTH: number;
+export declare const SCHNORR_SIGNATURE_BYTE_LENGTH: number;
 export declare const SELECTOR_BYTE_LENGTH: number;
 export declare const U256_BYTE_LENGTH: number;
 export declare const U128_BYTE_LENGTH: number;
@@ -9,7 +11,7 @@ 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 I32_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/browser/utils/types.d.ts

@@ -4,7 +4,10 @@ export type BufferLike = Uint8Array | Buffer;
 export type MemorySlotData<T> = T;
 export type PointerStorage = DeterministicMap<MemorySlotPointer, MemorySlotData<bigint>>;
 export type BlockchainStorage = DeterministicMap<string, PointerStorage>;
+export type i8 = number;
+export type i16 = number;
 export type i32 = number;
+export type i64 = bigint;
 export type u8 = number;
 export type u16 = number;
 export type u32 = number;

package/browser/vendors.js

@@ -1,4 +1,4 @@
-import { s as fn, r as th, a as kn, b as nh, c as hf, d as ar, e as ah, f as ts, i as oh, g as ih, h as sr, j as ns, k as sh, p as ch, l as uh, m as lh } from "./noble-hashes.js";
+import { s as fn, r as th, a as kn, b as nh, c as hf, d as ah, e as ar, f as ts, i as oh, g as ih, h as sr, j as ns, k as sh, p as ch, l as uh, m as lh } from "./noble-hashes.js";
 import { r as fh, a as dh, b as hh, F as Rs, c as ph, d as gh } from "./noble-curves.js";
 import { r as as } from "./valibot.js";
 function bh(e, t) {
@@ -12021,10 +12021,10 @@ export {
   cv as d,
   fv as e,
   sv as f,
-  mv as g,
+  bv as g,
   _m as h,
   uv as i,
-  bv as j,
+  mv as j,
   jd as k,
   nd as l,
   _v as m,

package/build/_version.d.ts

@@ -1 +1 @@
-export declare const version = "1.7.31";
+export declare const version = "1.8.0-beta.0";

package/build/_version.js

@@ -1 +1 @@
-export const version = '1.7.31';
+export const version = '1.8.0-beta.0';

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

@@ -1,6 +1,8 @@
 import { Address } from '../keypair/Address.js';
 export declare class ExtendedAddressMap<V> {
-    private items;
+    private indexMap;
+    private _keys;
+    private _values;
     constructor(iterable?: ReadonlyArray<readonly [Address, V]> | null);
     get size(): number;
     set(key: Address, value: V): this;

package/build/deterministic/ExtendedAddressMap.js

@@ -1,8 +1,9 @@
-import { Address } from '../keypair/Address.js';
 import { FastMap } from './FastMap.js';
 export class ExtendedAddressMap {
     constructor(iterable) {
-        this.items = new FastMap();
+        this._keys = [];
+        this._values = [];
+        this.indexMap = new FastMap();
         if (iterable) {
             for (const [key, value] of iterable) {
                 this.set(key, value);
@@ -10,48 +11,74 @@ export class ExtendedAddressMap {
         }
     }
     get size() {
-        return this.items.size;
+        return this._keys.length;
     }
     set(key, value) {
         const keyBigInt = key.tweakedToBigInt();
-        this.items.set(keyBigInt, value);
+        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) {
-        return this.items.get(key.tweakedToBigInt());
+        const keyBigInt = key.tweakedToBigInt();
+        const index = this.indexMap.get(keyBigInt);
+        if (index === undefined) {
+            return undefined;
+        }
+        return this._values[index];
     }
     has(key) {
-        return this.items.has(key.tweakedToBigInt());
+        return this.indexMap.has(key.tweakedToBigInt());
     }
     delete(key) {
         const keyBigInt = key.tweakedToBigInt();
-        return this.items.delete(keyBigInt);
+        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.items.clear();
+        this.indexMap.clear();
+        this._keys = [];
+        this._values = [];
     }
     indexOf(address) {
-        return this.items.indexOf(address.tweakedToBigInt());
+        const index = this.indexMap.get(address.tweakedToBigInt());
+        return index !== undefined ? index : -1;
     }
     *entries() {
-        for (const [keyBigInt, value] of this.items.entries()) {
-            yield [Address.fromBigInt(keyBigInt), value];
+        for (let i = 0; i < this._keys.length; i++) {
+            yield [this._keys[i], this._values[i]];
         }
     }
     *keys() {
-        for (const keyBigInt of this.items.keys()) {
-            yield Address.fromBigInt(keyBigInt);
+        for (const key of this._keys) {
+            yield key;
         }
     }
     *values() {
-        for (const value of this.items.values()) {
+        for (const value of this._values) {
             yield value;
         }
     }
     forEach(callback, thisArg) {
-        for (const [keyBigInt, value] of this.items.entries()) {
-            const key = Address.fromBigInt(0n, keyBigInt);
-            callback.call(thisArg, value, key, this);
+        for (let i = 0; i < this._keys.length; i++) {
+            callback.call(thisArg, this._values[i], this._keys[i], this);
         }
     }
     *[Symbol.iterator]() {

package/build/keypair/Address.d.ts

@@ -50,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

@@ -121,7 +121,7 @@ export class Address extends Uint8Array {
     }
     static fromBigInt(value, tweakedValue) {
         const address = Address.bigintToUint8Array(value);
-        const legacyAddress = tweakedValue ? Address.bigintToUint8Array(tweakedValue) : undefined;
+        const legacyAddress = tweakedValue !== undefined ? Address.bigintToUint8Array(tweakedValue) : undefined;
         return new Address(address, legacyAddress);
     }
     static fromUint64Array(w0, w1, w2, w3) {
@@ -389,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');
         }
@@ -396,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);
@@ -429,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 {

package/build/transaction/builders/MultiSignTransaction.js

@@ -109,7 +109,7 @@ export class MultiSignTransaction extends TransactionBuilder {
                 }
                 input.tapScriptSig = (input.tapScriptSig || []).concat(partialSignatures);
             }
-            delete input.finalScriptWitness;
+            Reflect.deleteProperty(input, 'finalScriptWitness');
             const signHashTypes = MultiSignTransaction.signHashTypesArray
                 ? [MultiSignTransaction.calculateSignHash(MultiSignTransaction.signHashTypesArray)]
                 : [];
@@ -172,7 +172,7 @@ export class MultiSignTransaction extends TransactionBuilder {
                     ];
                     input.tapScriptSig = MultiSignTransaction.dedupeSignatures(input.tapScriptSig || [], partialSignatures);
                 }
-                delete input.finalScriptWitness;
+                Reflect.deleteProperty(input, 'finalScriptWitness');
                 psbt.finalizeInput(i, (inputIndex, input) => {
                     return MultiSignTransaction.partialFinalizer(inputIndex, input, [], orderedPubKeys[i - startIndex], isFinal);
                 });