@btc-vision/transaction 1.7.19 → 1.7.23

package/browser/verification/TapscriptVerificator.d.ts

@@ -1,4 +1,4 @@
-import { Network, Taptree } from '@btc-vision/bitcoin';
+import { Network, Taptree } from '../../node_modules/@btc-vision/bitcoin/build/index.js';
 import { ChallengeSolution } from '../epoch/ChallengeSolution.js';
 import { Feature, Features } from '../generators/Features.js';
 export interface ContractAddressVerificationParams {

package/build/_version.d.ts

@@ -1 +1 @@
-export declare const version = "1.7.18";
+export declare const version = "1.7.23";

package/build/_version.js

@@ -1 +1 @@
-export const version = '1.7.18';
+export const version = '1.7.23';

package/build/generators/builders/HashCommitmentGenerator.d.ts

@@ -0,0 +1,49 @@
+import { Network } from '@btc-vision/bitcoin';
+import { IHashCommittedP2WSH } from '../../transaction/interfaces/IConsolidatedTransactionParameters.js';
+import { IP2WSHAddress } from '../../transaction/mineable/IP2WSHAddress.js';
+import { Logger } from '@btc-vision/logger';
+export declare class HashCommitmentGenerator extends Logger {
+    static readonly MAX_CHUNK_SIZE: number;
+    static readonly MAX_STACK_ITEMS: number;
+    static readonly MAX_WITNESS_SIZE: number;
+    static readonly MAX_STANDARD_WEIGHT: number;
+    static readonly MIN_OUTPUT_VALUE: bigint;
+    private static readonly BYTES_PER_COMMITMENT;
+    private static readonly SIG_CHECK_BYTES;
+    private static readonly WITNESS_FIXED_OVERHEAD;
+    private static readonly WITNESS_PER_CHUNK_OVERHEAD;
+    static readonly MAX_CHUNKS_PER_OUTPUT: number;
+    private static readonly INPUT_BASE_WEIGHT;
+    private static readonly INPUT_WITNESS_WEIGHT_MAX;
+    static readonly WEIGHT_PER_INPUT: number;
+    readonly logColor: string;
+    private readonly publicKey;
+    private readonly network;
+    constructor(publicKey: Buffer, network?: Network);
+    static calculateMaxInputsPerTx(): number;
+    static calculateMaxDataPerTx(): number;
+    static estimateOutputCount(dataSize: number): number;
+    static estimateChunkCount(dataSize: number): number;
+    static validateHashCommittedScript(witnessScript: Buffer): boolean;
+    static extractDataHashes(witnessScript: Buffer): Buffer[] | null;
+    static extractPublicKey(witnessScript: Buffer): Buffer | null;
+    static verifyChunkCommitments(dataChunks: Buffer[], witnessScript: Buffer): boolean;
+    static estimateFees(dataSize: number, feeRate: number, compressionRatio?: number): {
+        compressedSize: number;
+        outputCount: number;
+        chunkCount: number;
+        setupVBytes: number;
+        revealVBytes: number;
+        setupFee: bigint;
+        revealFee: bigint;
+        totalFee: bigint;
+        outputsValue: bigint;
+        totalCost: bigint;
+    };
+    hashChunk(data: Buffer): Buffer;
+    generateWitnessScript(dataHashes: Buffer[]): Buffer;
+    generateP2WSHAddress(witnessScript: Buffer): IP2WSHAddress & {
+        scriptPubKey: Buffer;
+    };
+    prepareChunks(data: Buffer, maxChunkSize?: number): IHashCommittedP2WSH[];
+}

package/build/generators/builders/HashCommitmentGenerator.js

@@ -0,0 +1,229 @@
+import { crypto, networks, opcodes, payments, script } from '@btc-vision/bitcoin';
+import { Logger } from '@btc-vision/logger';
+export class HashCommitmentGenerator extends Logger {
+    constructor(publicKey, network = networks.bitcoin) {
+        super();
+        this.logColor = '#4a90d9';
+        if (publicKey.length !== 33) {
+            throw new Error('Public key must be 33 bytes (compressed)');
+        }
+        this.publicKey = publicKey;
+        this.network = network;
+    }
+    static calculateMaxInputsPerTx() {
+        const txOverhead = 40;
+        const outputOverhead = 200;
+        const availableWeight = HashCommitmentGenerator.MAX_STANDARD_WEIGHT - txOverhead - outputOverhead;
+        return Math.floor(availableWeight / HashCommitmentGenerator.WEIGHT_PER_INPUT);
+    }
+    static calculateMaxDataPerTx() {
+        return (HashCommitmentGenerator.calculateMaxInputsPerTx() *
+            HashCommitmentGenerator.MAX_CHUNKS_PER_OUTPUT *
+            HashCommitmentGenerator.MAX_CHUNK_SIZE);
+    }
+    static estimateOutputCount(dataSize) {
+        return Math.ceil(dataSize /
+            (HashCommitmentGenerator.MAX_CHUNKS_PER_OUTPUT *
+                HashCommitmentGenerator.MAX_CHUNK_SIZE));
+    }
+    static estimateChunkCount(dataSize) {
+        return Math.ceil(dataSize / HashCommitmentGenerator.MAX_CHUNK_SIZE);
+    }
+    static validateHashCommittedScript(witnessScript) {
+        try {
+            const decompiled = script.decompile(witnessScript);
+            if (!decompiled || decompiled.length < 5) {
+                return false;
+            }
+            const lastIdx = decompiled.length - 1;
+            if (decompiled[lastIdx] !== opcodes.OP_CHECKSIG) {
+                return false;
+            }
+            const pubkey = decompiled[lastIdx - 1];
+            if (!Buffer.isBuffer(pubkey) || pubkey.length !== 33) {
+                return false;
+            }
+            const hashParts = decompiled.slice(0, -2);
+            if (hashParts.length % 3 !== 0 || hashParts.length === 0) {
+                return false;
+            }
+            for (let i = 0; i < hashParts.length; i += 3) {
+                const hash = hashParts[i + 1];
+                if (hashParts[i] !== opcodes.OP_HASH160 ||
+                    !Buffer.isBuffer(hash) ||
+                    hash.length !== 20 ||
+                    hashParts[i + 2] !== opcodes.OP_EQUALVERIFY) {
+                    return false;
+                }
+            }
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    static extractDataHashes(witnessScript) {
+        try {
+            const decompiled = script.decompile(witnessScript);
+            if (!decompiled ||
+                !HashCommitmentGenerator.validateHashCommittedScript(witnessScript)) {
+                return null;
+            }
+            const hashParts = decompiled.slice(0, -2);
+            const hashes = [];
+            for (let i = 0; i < hashParts.length; i += 3) {
+                hashes.push(hashParts[i + 1]);
+            }
+            return hashes.reverse();
+        }
+        catch {
+            return null;
+        }
+    }
+    static extractPublicKey(witnessScript) {
+        try {
+            const decompiled = script.decompile(witnessScript);
+            if (!decompiled ||
+                !HashCommitmentGenerator.validateHashCommittedScript(witnessScript)) {
+                return null;
+            }
+            return decompiled[decompiled.length - 2];
+        }
+        catch {
+            return null;
+        }
+    }
+    static verifyChunkCommitments(dataChunks, witnessScript) {
+        const committedHashes = HashCommitmentGenerator.extractDataHashes(witnessScript);
+        if (!committedHashes || committedHashes.length !== dataChunks.length) {
+            return false;
+        }
+        for (let i = 0; i < dataChunks.length; i++) {
+            const actualHash = crypto.hash160(dataChunks[i]);
+            if (!committedHashes[i].equals(actualHash)) {
+                return false;
+            }
+        }
+        return true;
+    }
+    static estimateFees(dataSize, feeRate, compressionRatio = 0.7) {
+        const compressedSize = Math.ceil(dataSize * compressionRatio);
+        const outputCount = HashCommitmentGenerator.estimateOutputCount(compressedSize);
+        const chunkCount = HashCommitmentGenerator.estimateChunkCount(compressedSize);
+        const setupInputVBytes = 2 * 58;
+        const setupOutputVBytes = outputCount * 43 + 43;
+        const setupOverhead = 11;
+        const setupVBytes = setupOverhead + setupInputVBytes + setupOutputVBytes;
+        const revealWeight = 40 + outputCount * HashCommitmentGenerator.WEIGHT_PER_INPUT + 200;
+        const revealVBytes = Math.ceil(revealWeight / 4);
+        const setupFee = BigInt(Math.ceil(setupVBytes * feeRate));
+        const revealFee = BigInt(Math.ceil(revealVBytes * feeRate));
+        const totalFee = setupFee + revealFee;
+        const outputsValue = BigInt(outputCount) * HashCommitmentGenerator.MIN_OUTPUT_VALUE;
+        const totalCost = totalFee + outputsValue;
+        return {
+            compressedSize,
+            outputCount,
+            chunkCount,
+            setupVBytes,
+            revealVBytes,
+            setupFee,
+            revealFee,
+            totalFee,
+            outputsValue,
+            totalCost,
+        };
+    }
+    hashChunk(data) {
+        return crypto.hash160(data);
+    }
+    generateWitnessScript(dataHashes) {
+        if (dataHashes.length === 0) {
+            throw new Error('At least one data hash is required');
+        }
+        if (dataHashes.length > HashCommitmentGenerator.MAX_CHUNKS_PER_OUTPUT) {
+            throw new Error(`Too many chunks: ${dataHashes.length} exceeds limit of ${HashCommitmentGenerator.MAX_CHUNKS_PER_OUTPUT}`);
+        }
+        for (const hash of dataHashes) {
+            if (hash.length !== 20) {
+                throw new Error(`HASH160 requires 20-byte hash, got ${hash.length}`);
+            }
+        }
+        const scriptParts = [];
+        for (let i = dataHashes.length - 1; i >= 0; i--) {
+            scriptParts.push(opcodes.OP_HASH160);
+            scriptParts.push(dataHashes[i]);
+            scriptParts.push(opcodes.OP_EQUALVERIFY);
+        }
+        scriptParts.push(this.publicKey);
+        scriptParts.push(opcodes.OP_CHECKSIG);
+        return script.compile(scriptParts);
+    }
+    generateP2WSHAddress(witnessScript) {
+        const p2wsh = payments.p2wsh({
+            redeem: { output: witnessScript },
+            network: this.network,
+        });
+        if (!p2wsh.address || !p2wsh.output) {
+            throw new Error('Failed to generate P2WSH address');
+        }
+        return {
+            address: p2wsh.address,
+            witnessScript,
+            scriptPubKey: p2wsh.output,
+        };
+    }
+    prepareChunks(data, maxChunkSize = HashCommitmentGenerator.MAX_CHUNK_SIZE) {
+        if (maxChunkSize > HashCommitmentGenerator.MAX_CHUNK_SIZE) {
+            throw new Error(`Chunk size ${maxChunkSize} exceeds P2WSH stack item limit of ${HashCommitmentGenerator.MAX_CHUNK_SIZE}`);
+        }
+        if (data.length === 0) {
+            throw new Error('Data cannot be empty');
+        }
+        const allChunks = [];
+        let offset = 0;
+        while (offset < data.length) {
+            const chunkSize = Math.min(maxChunkSize, data.length - offset);
+            allChunks.push(Buffer.from(data.subarray(offset, offset + chunkSize)));
+            offset += chunkSize;
+        }
+        const outputs = [];
+        let chunkIndex = 0;
+        while (chunkIndex < allChunks.length) {
+            const chunksForThisOutput = allChunks.slice(chunkIndex, chunkIndex + HashCommitmentGenerator.MAX_CHUNKS_PER_OUTPUT);
+            const dataChunks = chunksForThisOutput;
+            const dataHashes = dataChunks.map((chunk) => this.hashChunk(chunk));
+            const witnessScript = this.generateWitnessScript(dataHashes);
+            const p2wsh = this.generateP2WSHAddress(witnessScript);
+            outputs.push({
+                address: p2wsh.address,
+                witnessScript: p2wsh.witnessScript,
+                scriptPubKey: p2wsh.scriptPubKey,
+                dataHashes,
+                dataChunks,
+                chunkStartIndex: chunkIndex,
+            });
+            chunkIndex += chunksForThisOutput.length;
+        }
+        const totalChunks = allChunks.length;
+        this.log(`Prepared ${outputs.length} P2WSH outputs with ${totalChunks} chunks ` +
+            `(${data.length} bytes, ~${Math.ceil(data.length / outputs.length)} bytes/output)`);
+        return outputs;
+    }
+}
+HashCommitmentGenerator.MAX_CHUNK_SIZE = 80;
+HashCommitmentGenerator.MAX_STACK_ITEMS = 100;
+HashCommitmentGenerator.MAX_WITNESS_SIZE = 1650;
+HashCommitmentGenerator.MAX_STANDARD_WEIGHT = 400000;
+HashCommitmentGenerator.MIN_OUTPUT_VALUE = 330n;
+HashCommitmentGenerator.BYTES_PER_COMMITMENT = 23;
+HashCommitmentGenerator.SIG_CHECK_BYTES = 35;
+HashCommitmentGenerator.WITNESS_FIXED_OVERHEAD = 1 + 73 + 3 + 35;
+HashCommitmentGenerator.WITNESS_PER_CHUNK_OVERHEAD = HashCommitmentGenerator.MAX_CHUNK_SIZE + 1 + HashCommitmentGenerator.BYTES_PER_COMMITMENT;
+HashCommitmentGenerator.MAX_CHUNKS_PER_OUTPUT = Math.floor((HashCommitmentGenerator.MAX_WITNESS_SIZE -
+    HashCommitmentGenerator.WITNESS_FIXED_OVERHEAD) /
+    HashCommitmentGenerator.WITNESS_PER_CHUNK_OVERHEAD);
+HashCommitmentGenerator.INPUT_BASE_WEIGHT = 164;
+HashCommitmentGenerator.INPUT_WITNESS_WEIGHT_MAX = HashCommitmentGenerator.MAX_WITNESS_SIZE;
+HashCommitmentGenerator.WEIGHT_PER_INPUT = HashCommitmentGenerator.INPUT_BASE_WEIGHT +
+    HashCommitmentGenerator.INPUT_WITNESS_WEIGHT_MAX;

package/build/keypair/Address.d.ts

@@ -3,7 +3,6 @@ import { IP2WSHAddress } from '../transaction/mineable/IP2WSHAddress.js';
 import { MLDSASecurityLevel } from '@btc-vision/bip32';
 export declare class Address extends Uint8Array {
     #private;
-    private legacyPublicKey;
     constructor(mldsaPublicKey?: ArrayLike<number>, publicKeyOrTweak?: ArrayLike<number>);
     get mldsaLevel(): MLDSASecurityLevel | undefined;
     set mldsaLevel(level: MLDSASecurityLevel);
@@ -11,6 +10,7 @@ export declare class Address extends Uint8Array {
     set originalMDLSAPublicKey(key: Buffer | Uint8Array);
     get originalPublicKey(): Uint8Array | undefined;
     get mldsaPublicKey(): Uint8Array | undefined;
+    private get legacyPublicKey();
     private get keyPair();
     static dead(): Address;
     static fromString(mldsaPublicKey: string, legacyPublicKey?: string): Address;
@@ -48,5 +48,7 @@ export declare class Address extends Uint8Array {
     p2op(network: Network): string;
     toTweakedHybridPublicKeyHex(): string;
     toTweakedHybridPublicKeyBuffer(): Buffer;
+    private setMldsaKey;
+    private ensureLegacyProcessed;
     private autoFormat;
 }

package/build/keypair/Address.js

@@ -1,15 +1,15 @@
-var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
-    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 __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
     if (kind === "m") throw new TypeError("Private method is not writable");
     if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
     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, _Address_cachedBigInt, _Address_cachedUint64Array, _Address_originalMDLSAPublicKey, _Address_mldsaLevel;
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    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;
 import { decompressPublicKey, toXOnly } from '@btc-vision/bitcoin';
 import { ADDRESS_BYTE_LENGTH } from '../utils/lengths.js';
 import { AddressVerificator } from './AddressVerificator.js';
@@ -35,14 +35,17 @@ export class Address extends Uint8Array {
         _Address_cachedUint64Array.set(this, void 0);
         _Address_originalMDLSAPublicKey.set(this, void 0);
         _Address_mldsaLevel.set(this, void 0);
+        _Address_pendingLegacyKey.set(this, void 0);
+        _Address_legacyProcessed.set(this, false);
+        _Address_legacyPublicKey.set(this, void 0);
         if (!mldsaPublicKey) {
             return;
         }
         if (publicKeyOrTweak) {
-            this.legacyPublicKey = new Uint8Array(publicKeyOrTweak.length);
-            this.legacyPublicKey.set(publicKeyOrTweak);
+            __classPrivateFieldSet(this, _Address_pendingLegacyKey, new Uint8Array(publicKeyOrTweak.length), "f");
+            __classPrivateFieldGet(this, _Address_pendingLegacyKey, "f").set(publicKeyOrTweak);
         }
-        this.set(mldsaPublicKey);
+        this.setMldsaKey(mldsaPublicKey);
     }
     get mldsaLevel() {
         return __classPrivateFieldGet(this, _Address_mldsaLevel, "f");
@@ -57,12 +60,18 @@ export class Address extends Uint8Array {
         __classPrivateFieldSet(this, _Address_originalMDLSAPublicKey, new Uint8Array(key), "f");
     }
     get originalPublicKey() {
+        this.ensureLegacyProcessed();
         return __classPrivateFieldGet(this, _Address_originalPublicKey, "f");
     }
     get mldsaPublicKey() {
         return __classPrivateFieldGet(this, _Address_mldsaPublicKey, "f");
     }
+    get legacyPublicKey() {
+        this.ensureLegacyProcessed();
+        return __classPrivateFieldGet(this, _Address_legacyPublicKey, "f");
+    }
     get keyPair() {
+        this.ensureLegacyProcessed();
         if (!__classPrivateFieldGet(this, _Address_keyPair, "f")) {
             throw new Error('Legacy public key not set for address');
         }
@@ -148,45 +157,52 @@ export class Address extends Uint8Array {
         return '0x' + Buffer.from(this).toString('hex');
     }
     tweakedToHex() {
-        if (!this.legacyPublicKey) {
+        const key = this.legacyPublicKey;
+        if (!key) {
             throw new Error('Legacy public key not set');
         }
-        return '0x' + Buffer.from(this.legacyPublicKey).toString('hex');
+        return '0x' + Buffer.from(key).toString('hex');
     }
     toBuffer() {
         return Buffer.from(this);
     }
     tweakedPublicKeyToBuffer() {
-        if (!this.legacyPublicKey) {
+        const key = this.legacyPublicKey;
+        if (!key) {
             throw new Error('Legacy public key not set');
         }
-        return Buffer.from(this.legacyPublicKey);
+        return Buffer.from(key);
     }
     toUncompressedHex() {
+        this.ensureLegacyProcessed();
         if (!__classPrivateFieldGet(this, _Address_uncompressed, "f")) {
             throw new Error('Legacy public key not set');
         }
         return '0x' + __classPrivateFieldGet(this, _Address_uncompressed, "f").uncompressed.toString('hex');
     }
     toUncompressedBuffer() {
+        this.ensureLegacyProcessed();
         if (!__classPrivateFieldGet(this, _Address_uncompressed, "f")) {
             throw new Error('Legacy public key not set');
         }
         return __classPrivateFieldGet(this, _Address_uncompressed, "f").uncompressed;
     }
     toHybridPublicKeyHex() {
+        this.ensureLegacyProcessed();
         if (!__classPrivateFieldGet(this, _Address_uncompressed, "f")) {
             throw new Error('Legacy public key not set');
         }
         return '0x' + __classPrivateFieldGet(this, _Address_uncompressed, "f").hybrid.toString('hex');
     }
     toHybridPublicKeyBuffer() {
+        this.ensureLegacyProcessed();
         if (!__classPrivateFieldGet(this, _Address_uncompressed, "f")) {
             throw new Error('Legacy public key not set');
         }
         return __classPrivateFieldGet(this, _Address_uncompressed, "f").hybrid;
     }
     originalPublicKeyBuffer() {
+        this.ensureLegacyProcessed();
         if (!__classPrivateFieldGet(this, _Address_originalPublicKey, "f")) {
             throw new Error('Legacy public key not set');
         }
@@ -244,44 +260,14 @@ export class Address extends Uint8Array {
         return false;
     }
     set(mldsaPublicKey) {
-        if (this.legacyPublicKey) {
-            const validLengths = [ADDRESS_BYTE_LENGTH, 33, 65];
-            if (!validLengths.includes(this.legacyPublicKey.length)) {
-                throw new Error(`Invalid public key length ${this.legacyPublicKey.length}`);
-            }
-            if (this.legacyPublicKey.length === ADDRESS_BYTE_LENGTH) {
-                const buf = Buffer.alloc(ADDRESS_BYTE_LENGTH);
-                buf.set(this.legacyPublicKey);
-                __classPrivateFieldSet(this, _Address_tweakedUncompressed, ContractAddress.generateHybridKeyFromHash(buf), "f");
-            }
-            else {
-                this.autoFormat(this.legacyPublicKey);
-            }
-        }
-        if (mldsaPublicKey.length === ADDRESS_BYTE_LENGTH) {
-            const buf = new Uint8Array(ADDRESS_BYTE_LENGTH);
-            buf.set(mldsaPublicKey);
-            super.set(buf);
-        }
-        else {
-            const validMLDSALengths = [1312, 1952, 2592];
-            if (!validMLDSALengths.includes(mldsaPublicKey.length)) {
-                throw new Error(`Invalid ML-DSA public key length: ${mldsaPublicKey.length}. ` +
-                    `Expected 1312 (ML-DSA-44/LEVEL2), 1952 (ML-DSA-65/LEVEL3), or 2592 (ML-DSA-87/LEVEL5) bytes.`);
-            }
-            __classPrivateFieldSet(this, _Address_mldsaPublicKey, new Uint8Array(mldsaPublicKey.length), "f");
-            __classPrivateFieldGet(this, _Address_mldsaPublicKey, "f").set(mldsaPublicKey);
-            const hashedPublicKey = sha256(new Uint8Array(mldsaPublicKey));
-            const buf = new Uint8Array(ADDRESS_BYTE_LENGTH);
-            buf.set(hashedPublicKey);
-            super.set(buf);
-        }
+        this.setMldsaKey(mldsaPublicKey);
     }
     isValidLegacyPublicKey(network) {
-        if (!this.legacyPublicKey) {
+        const key = this.legacyPublicKey;
+        if (!key) {
             throw new Error(`Legacy key not set.`);
         }
-        return AddressVerificator.isValidPublicKey(Buffer.from(this.legacyPublicKey).toString('hex'), network);
+        return AddressVerificator.isValidPublicKey(Buffer.from(key).toString('hex'), network);
     }
     p2pk() {
         return this.toHex();
@@ -302,13 +288,14 @@ export class Address extends Uint8Array {
         return this.toHex();
     }
     p2tr(network) {
-        if (!this.legacyPublicKey) {
-            throw new Error('Legacy public key not set');
-        }
         if (__classPrivateFieldGet(this, _Address_p2tr, "f") && __classPrivateFieldGet(this, _Address_network, "f") === network) {
             return __classPrivateFieldGet(this, _Address_p2tr, "f");
         }
-        const p2trAddy = EcKeyPair.tweakedPubKeyBufferToAddress(this.legacyPublicKey, network);
+        const key = this.legacyPublicKey;
+        if (!key) {
+            throw new Error('Legacy public key not set');
+        }
+        const p2trAddy = EcKeyPair.tweakedPubKeyBufferToAddress(key, network);
         if (p2trAddy) {
             __classPrivateFieldSet(this, _Address_network, network, "f");
             __classPrivateFieldSet(this, _Address_p2tr, p2trAddy, "f");
@@ -320,6 +307,7 @@ export class Address extends Uint8Array {
         if (__classPrivateFieldGet(this, _Address_p2wda, "f") && __classPrivateFieldGet(this, _Address_network, "f") === network) {
             return __classPrivateFieldGet(this, _Address_p2wda, "f");
         }
+        this.ensureLegacyProcessed();
         if (!__classPrivateFieldGet(this, _Address_originalPublicKey, "f")) {
             throw new Error('Cannot create P2WDA address: public key not set');
         }
@@ -345,6 +333,7 @@ export class Address extends Uint8Array {
         if (n < 1 || n > 65535) {
             throw new Error('CSV block number must be between 1 and 65535');
         }
+        this.ensureLegacyProcessed();
         if (!__classPrivateFieldGet(this, _Address_originalPublicKey, "f")) {
             throw new Error('Cannot create CSV address: public key not set');
         }
@@ -356,6 +345,7 @@ export class Address extends Uint8Array {
         if (n < 1 || n > 65535) {
             throw new Error('CSV block number must be between 1 and 65535');
         }
+        this.ensureLegacyProcessed();
         if (!__classPrivateFieldGet(this, _Address_originalPublicKey, "f")) {
             throw new Error('Cannot create CSV address: public key not set');
         }
@@ -374,17 +364,60 @@ export class Address extends Uint8Array {
         throw new Error('ML-DSA public key not set');
     }
     toTweakedHybridPublicKeyHex() {
+        this.ensureLegacyProcessed();
         if (!__classPrivateFieldGet(this, _Address_tweakedUncompressed, "f")) {
             throw new Error('Legacy public key not set');
         }
         return '0x' + __classPrivateFieldGet(this, _Address_tweakedUncompressed, "f").toString('hex');
     }
     toTweakedHybridPublicKeyBuffer() {
+        this.ensureLegacyProcessed();
         if (!__classPrivateFieldGet(this, _Address_tweakedUncompressed, "f")) {
             throw new Error('Legacy public key not set');
         }
         return __classPrivateFieldGet(this, _Address_tweakedUncompressed, "f");
     }
+    setMldsaKey(mldsaPublicKey) {
+        if (mldsaPublicKey.length === ADDRESS_BYTE_LENGTH) {
+            const buf = new Uint8Array(ADDRESS_BYTE_LENGTH);
+            buf.set(mldsaPublicKey);
+            super.set(buf);
+        }
+        else {
+            const validMLDSALengths = [1312, 1952, 2592];
+            if (!validMLDSALengths.includes(mldsaPublicKey.length)) {
+                throw new Error(`Invalid ML-DSA public key length: ${mldsaPublicKey.length}. ` +
+                    `Expected 1312 (ML-DSA-44/LEVEL2), 1952 (ML-DSA-65/LEVEL3), or 2592 (ML-DSA-87/LEVEL5) bytes.`);
+            }
+            __classPrivateFieldSet(this, _Address_mldsaPublicKey, new Uint8Array(mldsaPublicKey.length), "f");
+            __classPrivateFieldGet(this, _Address_mldsaPublicKey, "f").set(mldsaPublicKey);
+            const hashedPublicKey = sha256(new Uint8Array(mldsaPublicKey));
+            const buf = new Uint8Array(ADDRESS_BYTE_LENGTH);
+            buf.set(hashedPublicKey);
+            super.set(buf);
+        }
+    }
+    ensureLegacyProcessed() {
+        if (__classPrivateFieldGet(this, _Address_legacyProcessed, "f"))
+            return;
+        __classPrivateFieldSet(this, _Address_legacyProcessed, true, "f");
+        const pending = __classPrivateFieldGet(this, _Address_pendingLegacyKey, "f");
+        if (!pending)
+            return;
+        const validLengths = [ADDRESS_BYTE_LENGTH, 33, 65];
+        if (!validLengths.includes(pending.length)) {
+            throw new Error(`Invalid public key length ${pending.length}`);
+        }
+        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 {
+            this.autoFormat(pending);
+        }
+    }
     autoFormat(publicKey) {
         const firstByte = publicKey[0];
         if (firstByte === 0x03 || firstByte === 0x02) {
@@ -397,8 +430,8 @@ export class Address extends Uint8Array {
         __classPrivateFieldSet(this, _Address_uncompressed, decompressPublicKey(__classPrivateFieldGet(this, _Address_originalPublicKey, "f")), "f");
         const tweakedBytes = toXOnly(EcKeyPair.tweakPublicKey(Buffer.from(__classPrivateFieldGet(this, _Address_originalPublicKey, "f"))));
         __classPrivateFieldSet(this, _Address_tweakedUncompressed, ContractAddress.generateHybridKeyFromHash(tweakedBytes), "f");
-        this.legacyPublicKey = new Uint8Array(ADDRESS_BYTE_LENGTH);
-        this.legacyPublicKey.set(tweakedBytes);
+        __classPrivateFieldSet(this, _Address_legacyPublicKey, new Uint8Array(ADDRESS_BYTE_LENGTH), "f");
+        __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_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();

package/build/opnet.d.ts

@@ -4,6 +4,7 @@ export * from './bytecode/Compressor.js';
 export * from './generators/builders/CalldataGenerator.js';
 export * from './generators/builders/CustomGenerator.js';
 export * from './generators/builders/DeploymentGenerator.js';
+export * from './generators/builders/HashCommitmentGenerator.js';
 export * from './generators/builders/LegacyCalldataGenerator.js';
 export * from './generators/builders/MultiSignGenerator.js';
 export * from './generators/builders/P2WDAGenerator.js';
@@ -27,10 +28,14 @@ export * from './generators/MLDSAData.js';
 export * from './metadata/ContractBaseMetadata.js';
 export * from './network/ChainId.js';
 export * from './signer/TweakedSigner.js';
+export * from './signer/AddressRotation.js';
 export * from './transaction/enums/TransactionType.js';
 export * from './transaction/interfaces/ITransactionParameters.js';
+export * from './transaction/interfaces/IConsolidatedTransactionParameters.js';
 export * from './transaction/interfaces/Tap.js';
 export * from './transaction/TransactionFactory.js';
+export * from './transaction/builders/CancelTransaction.js';
+export * from './transaction/builders/ConsolidatedInteractionTransaction.js';
 export * from './transaction/builders/CustomScriptTransaction.js';
 export * from './transaction/builders/DeploymentTransaction.js';
 export * from './transaction/builders/FundingTransaction.js';
@@ -39,7 +44,15 @@ export * from './transaction/builders/InteractionTransactionP2WDA.js';
 export * from './transaction/builders/MultiSignTransaction.js';
 export * from './transaction/builders/SharedInteractionTransaction.js';
 export * from './transaction/builders/TransactionBuilder.js';
-export * from './transaction/builders/CancelTransaction.js';
+export * from './transaction/offline/interfaces/ISerializableState.js';
+export * from './transaction/offline/interfaces/ITypeSpecificData.js';
+export { TransactionSerializer } from './transaction/offline/TransactionSerializer.js';
+export { TransactionStateCapture } from './transaction/offline/TransactionStateCapture.js';
+export type { CaptureParams } from './transaction/offline/TransactionStateCapture.js';
+export { TransactionReconstructor } from './transaction/offline/TransactionReconstructor.js';
+export type { ReconstructionOptions } from './transaction/offline/TransactionReconstructor.js';
+export { OfflineTransactionManager } from './transaction/offline/OfflineTransactionManager.js';
+export type { ExportOptions } from './transaction/offline/OfflineTransactionManager.js';
 export * from './epoch/interfaces/IChallengeSolution.js';
 export * from './epoch/validator/EpochValidator.js';
 export * from './epoch/ChallengeSolution.js';