@btc-vision/transaction 1.8.0-beta.3 → 1.8.0-beta.4

package/build/transaction/offline/TransactionSerializer.js

@@ -1,46 +1,83 @@
 import { createHash } from 'crypto';
+import { toHex, fromHex } from '@btc-vision/bitcoin';
 import { BinaryWriter } from '../../buffer/BinaryWriter.js';
 import { BinaryReader } from '../../buffer/BinaryReader.js';
 import { SERIALIZATION_FORMAT_VERSION, SERIALIZATION_MAGIC_BYTE, } from './interfaces/ISerializableState.js';
 import { TransactionType } from '../enums/TransactionType.js';
+/**
+ * Serializes and deserializes transaction state for offline signing.
+ * Uses binary format for compact size.
+ */
 export class TransactionSerializer {
+    /**
+     * Serialize transaction state to binary format
+     * @param state - The transaction state to serialize
+     * @returns Uint8Array containing serialized state with checksum
+     */
     static serialize(state) {
         const writer = new BinaryWriter();
+        // Write header
         this.writeHeader(writer, state.header);
+        // Write base params
         this.writeBaseParams(writer, state.baseParams);
+        // Write UTXOs
         this.writeUTXOArray(writer, state.utxos);
         this.writeUTXOArray(writer, state.optionalInputs);
+        // Write optional outputs
         this.writeOutputArray(writer, state.optionalOutputs);
+        // Write signer mappings
         writer.writeBoolean(state.addressRotationEnabled);
         this.writeSignerMappings(writer, state.signerMappings);
+        // Write type-specific data
         this.writeTypeSpecificData(writer, state.typeSpecificData);
+        // Write precomputed data
         this.writePrecomputedData(writer, state.precomputedData);
-        const dataBuffer = Buffer.from(writer.getBuffer());
+        // Get buffer and calculate checksum
+        const dataBuffer = writer.getBuffer();
         const checksum = this.calculateChecksum(dataBuffer);
-        return Buffer.concat([dataBuffer, checksum]);
-    }
+        // Concatenate data + checksum
+        const result = new Uint8Array(dataBuffer.length + checksum.length);
+        result.set(dataBuffer, 0);
+        result.set(checksum, dataBuffer.length);
+        return result;
+    }
+    /**
+     * Deserialize binary format to transaction state
+     * @param data - Uint8Array containing serialized state
+     * @returns Deserialized transaction state
+     * @throws Error if checksum validation fails or format is invalid
+     */
     static deserialize(data) {
+        // Verify checksum (last 32 bytes)
         if (data.length < 32) {
             throw new Error('Invalid serialized data: too short');
         }
         const checksum = data.subarray(-32);
         const payload = data.subarray(0, -32);
         const expectedChecksum = this.calculateChecksum(payload);
-        if (!checksum.equals(expectedChecksum)) {
+        if (!this.bytesEqual(checksum, expectedChecksum)) {
             throw new Error('Invalid checksum - data may be corrupted');
         }
         const reader = new BinaryReader(payload);
+        // Read header
         const header = this.readHeader(reader);
+        // Verify format version
         if (header.formatVersion > SERIALIZATION_FORMAT_VERSION) {
             throw new Error(`Unsupported format version: ${header.formatVersion}`);
         }
+        // Read base params
         const baseParams = this.readBaseParams(reader);
+        // Read UTXOs
         const utxos = this.readUTXOArray(reader);
         const optionalInputs = this.readUTXOArray(reader);
+        // Read optional outputs
         const optionalOutputs = this.readOutputArray(reader);
+        // Read signer mappings
         const addressRotationEnabled = reader.readBoolean();
         const signerMappings = this.readSignerMappings(reader);
+        // Read type-specific data
         const typeSpecificData = this.readTypeSpecificData(reader, header.transactionType);
+        // Read precomputed data
         const precomputedData = this.readPrecomputedData(reader);
         return {
             header,
@@ -54,17 +91,38 @@ export class TransactionSerializer {
             precomputedData,
         };
     }
+    /**
+     * Export state as base64 string (for transport)
+     * @param state - Transaction state to export
+     * @returns Base64-encoded string
+     */
     static toBase64(state) {
-        return this.serialize(state).toString('base64');
-    }
+        const bytes = this.serialize(state);
+        return this.uint8ArrayToBase64(bytes);
+    }
+    /**
+     * Import state from base64 string
+     * @param base64 - Base64-encoded state
+     * @returns Deserialized transaction state
+     */
     static fromBase64(base64) {
-        return this.deserialize(Buffer.from(base64, 'base64'));
+        return this.deserialize(this.base64ToUint8Array(base64));
     }
+    /**
+     * Export state as hex string
+     * @param state - Transaction state to export
+     * @returns Hex-encoded string
+     */
     static toHex(state) {
-        return this.serialize(state).toString('hex');
+        return toHex(this.serialize(state));
     }
+    /**
+     * Import state from hex string
+     * @param hex - Hex-encoded state
+     * @returns Deserialized transaction state
+     */
     static fromHex(hex) {
-        return this.deserialize(Buffer.from(hex, 'hex'));
+        return this.deserialize(fromHex(hex));
     }
     static writeHeader(writer, header) {
         writer.writeU8(SERIALIZATION_MAGIC_BYTE);
@@ -93,14 +151,14 @@ export class TransactionSerializer {
         if (params.to !== undefined) {
             writer.writeStringWithLength(params.to);
         }
-        writer.writeU32(Math.floor(params.feeRate * 1000));
+        writer.writeU32(Math.floor(params.feeRate * 1000)); // Store as milli-sat/vB for precision
         writer.writeU64(BigInt(params.priorityFee));
         writer.writeU64(BigInt(params.gasSatFee));
         writer.writeU8(this.networkNameToU8(params.networkName));
         writer.writeU8(params.txVersion);
         writer.writeBoolean(params.note !== undefined);
         if (params.note !== undefined) {
-            writer.writeBytesWithLength(Buffer.from(params.note, 'hex'));
+            writer.writeBytesWithLength(fromHex(params.note));
         }
         writer.writeBoolean(params.anchor);
         writer.writeBoolean(params.debugFees ?? false);
@@ -109,28 +167,28 @@ export class TransactionSerializer {
         const from = reader.readStringWithLength();
         const hasTo = reader.readBoolean();
         const to = hasTo ? reader.readStringWithLength() : undefined;
-        const feeRate = reader.readU32() / 1000;
+        const feeRate = reader.readU32() / 1000; // Convert back from milli-sat/vB
         const priorityFee = reader.readU64().toString();
         const gasSatFee = reader.readU64().toString();
         const networkName = this.u8ToNetworkName(reader.readU8());
         const txVersion = reader.readU8();
         const hasNote = reader.readBoolean();
         const note = hasNote
-            ? Buffer.from(reader.readBytesWithLength()).toString('hex')
+            ? toHex(reader.readBytesWithLength())
             : undefined;
         const anchor = reader.readBoolean();
         const debugFees = reader.readBoolean();
         return {
             from,
-            to,
             feeRate,
             priorityFee,
             gasSatFee,
             networkName,
             txVersion,
-            note,
             anchor,
             debugFees,
+            ...(to !== undefined ? { to } : {}),
+            ...(note !== undefined ? { note } : {}),
         };
     }
     static writeUTXOArray(writer, utxos) {
@@ -140,25 +198,28 @@ export class TransactionSerializer {
         }
     }
     static writeUTXO(writer, utxo) {
-        writer.writeBytes(Buffer.from(utxo.transactionId, 'hex'));
+        // Transaction ID (32 bytes)
+        writer.writeBytes(fromHex(utxo.transactionId));
         writer.writeU32(utxo.outputIndex);
         writer.writeU64(BigInt(utxo.value));
-        writer.writeBytesWithLength(Buffer.from(utxo.scriptPubKeyHex, 'hex'));
+        writer.writeBytesWithLength(fromHex(utxo.scriptPubKeyHex));
+        // Optional address
         writer.writeBoolean(utxo.scriptPubKeyAddress !== undefined);
         if (utxo.scriptPubKeyAddress !== undefined) {
             writer.writeStringWithLength(utxo.scriptPubKeyAddress);
         }
+        // Optional scripts
         writer.writeBoolean(utxo.redeemScript !== undefined);
         if (utxo.redeemScript !== undefined) {
-            writer.writeBytesWithLength(Buffer.from(utxo.redeemScript, 'hex'));
+            writer.writeBytesWithLength(fromHex(utxo.redeemScript));
         }
         writer.writeBoolean(utxo.witnessScript !== undefined);
         if (utxo.witnessScript !== undefined) {
-            writer.writeBytesWithLength(Buffer.from(utxo.witnessScript, 'hex'));
+            writer.writeBytesWithLength(fromHex(utxo.witnessScript));
         }
         writer.writeBoolean(utxo.nonWitnessUtxo !== undefined);
         if (utxo.nonWitnessUtxo !== undefined) {
-            writer.writeBytesWithLength(Buffer.from(utxo.nonWitnessUtxo, 'hex'));
+            writer.writeBytesWithLength(fromHex(utxo.nonWitnessUtxo));
         }
     }
     static readUTXOArray(reader) {
@@ -170,33 +231,33 @@ export class TransactionSerializer {
         return utxos;
     }
     static readUTXO(reader) {
-        const transactionId = Buffer.from(reader.readBytes(32)).toString('hex');
+        const transactionId = toHex(reader.readBytes(32));
         const outputIndex = reader.readU32();
         const value = reader.readU64().toString();
-        const scriptPubKeyHex = Buffer.from(reader.readBytesWithLength()).toString('hex');
+        const scriptPubKeyHex = toHex(reader.readBytesWithLength());
         const hasAddress = reader.readBoolean();
         const scriptPubKeyAddress = hasAddress ? reader.readStringWithLength() : undefined;
         const hasRedeemScript = reader.readBoolean();
         const redeemScript = hasRedeemScript
-            ? Buffer.from(reader.readBytesWithLength()).toString('hex')
+            ? toHex(reader.readBytesWithLength())
             : undefined;
         const hasWitnessScript = reader.readBoolean();
         const witnessScript = hasWitnessScript
-            ? Buffer.from(reader.readBytesWithLength()).toString('hex')
+            ? toHex(reader.readBytesWithLength())
             : undefined;
         const hasNonWitnessUtxo = reader.readBoolean();
         const nonWitnessUtxo = hasNonWitnessUtxo
-            ? Buffer.from(reader.readBytesWithLength()).toString('hex')
+            ? toHex(reader.readBytesWithLength())
             : undefined;
         return {
             transactionId,
             outputIndex,
             value,
             scriptPubKeyHex,
-            scriptPubKeyAddress,
-            redeemScript,
-            witnessScript,
-            nonWitnessUtxo,
+            ...(scriptPubKeyAddress !== undefined ? { scriptPubKeyAddress } : {}),
+            ...(redeemScript !== undefined ? { redeemScript } : {}),
+            ...(witnessScript !== undefined ? { witnessScript } : {}),
+            ...(nonWitnessUtxo !== undefined ? { nonWitnessUtxo } : {}),
         };
     }
     static writeOutputArray(writer, outputs) {
@@ -213,11 +274,11 @@ export class TransactionSerializer {
         }
         writer.writeBoolean(output.script !== undefined);
         if (output.script !== undefined) {
-            writer.writeBytesWithLength(Buffer.from(output.script, 'hex'));
+            writer.writeBytesWithLength(fromHex(output.script));
         }
         writer.writeBoolean(output.tapInternalKey !== undefined);
         if (output.tapInternalKey !== undefined) {
-            writer.writeBytesWithLength(Buffer.from(output.tapInternalKey, 'hex'));
+            writer.writeBytesWithLength(fromHex(output.tapInternalKey));
         }
     }
     static readOutputArray(reader) {
@@ -234,13 +295,18 @@ export class TransactionSerializer {
         const address = hasAddress ? reader.readStringWithLength() : undefined;
         const hasScript = reader.readBoolean();
         const script = hasScript
-            ? Buffer.from(reader.readBytesWithLength()).toString('hex')
+            ? toHex(reader.readBytesWithLength())
             : undefined;
         const hasTapInternalKey = reader.readBoolean();
         const tapInternalKey = hasTapInternalKey
-            ? Buffer.from(reader.readBytesWithLength()).toString('hex')
+            ? toHex(reader.readBytesWithLength())
             : undefined;
-        return { value, address, script, tapInternalKey };
+        return {
+            value,
+            ...(address !== undefined ? { address } : {}),
+            ...(script !== undefined ? { script } : {}),
+            ...(tapInternalKey !== undefined ? { tapInternalKey } : {}),
+        };
     }
     static writeSignerMappings(writer, mappings) {
         writer.writeU16(mappings.length);
@@ -308,6 +374,7 @@ export class TransactionSerializer {
                 throw new Error(`Unsupported transaction type: ${type}`);
         }
     }
+    // Funding
     static writeFundingData(writer, data) {
         writer.writeU64(BigInt(data.amount));
         writer.writeU16(data.splitInputsInto);
@@ -319,45 +386,47 @@ export class TransactionSerializer {
             splitInputsInto: reader.readU16(),
         };
     }
+    // Deployment
     static writeDeploymentData(writer, data) {
-        writer.writeBytesWithLength(Buffer.from(data.bytecode, 'hex'));
+        writer.writeBytesWithLength(fromHex(data.bytecode));
         writer.writeBoolean(data.calldata !== undefined);
         if (data.calldata !== undefined) {
-            writer.writeBytesWithLength(Buffer.from(data.calldata, 'hex'));
+            writer.writeBytesWithLength(fromHex(data.calldata));
         }
         this.writeChallenge(writer, data.challenge);
         writer.writeBoolean(data.revealMLDSAPublicKey ?? false);
         writer.writeBoolean(data.linkMLDSAPublicKeyToAddress ?? false);
         writer.writeBoolean(data.hashedPublicKey !== undefined);
         if (data.hashedPublicKey !== undefined) {
-            writer.writeBytesWithLength(Buffer.from(data.hashedPublicKey, 'hex'));
+            writer.writeBytesWithLength(fromHex(data.hashedPublicKey));
         }
     }
     static readDeploymentData(reader) {
-        const bytecode = Buffer.from(reader.readBytesWithLength()).toString('hex');
+        const bytecode = toHex(reader.readBytesWithLength());
         const hasCalldata = reader.readBoolean();
         const calldata = hasCalldata
-            ? Buffer.from(reader.readBytesWithLength()).toString('hex')
+            ? toHex(reader.readBytesWithLength())
             : undefined;
         const challenge = this.readChallenge(reader);
         const revealMLDSAPublicKey = reader.readBoolean();
         const linkMLDSAPublicKeyToAddress = reader.readBoolean();
         const hasHashedPublicKey = reader.readBoolean();
         const hashedPublicKey = hasHashedPublicKey
-            ? Buffer.from(reader.readBytesWithLength()).toString('hex')
+            ? toHex(reader.readBytesWithLength())
             : undefined;
         return {
             type: TransactionType.DEPLOYMENT,
             bytecode,
-            calldata,
             challenge,
             revealMLDSAPublicKey,
             linkMLDSAPublicKeyToAddress,
-            hashedPublicKey,
+            ...(calldata !== undefined ? { calldata } : {}),
+            ...(hashedPublicKey !== undefined ? { hashedPublicKey } : {}),
         };
     }
+    // Interaction
     static writeInteractionData(writer, data) {
-        writer.writeBytesWithLength(Buffer.from(data.calldata, 'hex'));
+        writer.writeBytesWithLength(fromHex(data.calldata));
         writer.writeBoolean(data.contract !== undefined);
         if (data.contract !== undefined) {
             writer.writeStringWithLength(data.contract);
@@ -373,11 +442,11 @@ export class TransactionSerializer {
         writer.writeBoolean(data.linkMLDSAPublicKeyToAddress ?? false);
         writer.writeBoolean(data.hashedPublicKey !== undefined);
         if (data.hashedPublicKey !== undefined) {
-            writer.writeBytesWithLength(Buffer.from(data.hashedPublicKey, 'hex'));
+            writer.writeBytesWithLength(fromHex(data.hashedPublicKey));
         }
     }
     static readInteractionData(reader) {
-        const calldata = Buffer.from(reader.readBytesWithLength()).toString('hex');
+        const calldata = toHex(reader.readBytesWithLength());
         const hasContract = reader.readBoolean();
         const contract = hasContract ? reader.readStringWithLength() : undefined;
         const challenge = this.readChallenge(reader);
@@ -389,25 +458,26 @@ export class TransactionSerializer {
         const linkMLDSAPublicKeyToAddress = reader.readBoolean();
         const hasHashedPublicKey = reader.readBoolean();
         const hashedPublicKey = hasHashedPublicKey
-            ? Buffer.from(reader.readBytesWithLength()).toString('hex')
+            ? toHex(reader.readBytesWithLength())
             : undefined;
         return {
             type: TransactionType.INTERACTION,
             calldata,
-            contract,
             challenge,
-            loadedStorage,
             isCancellation,
             disableAutoRefund,
             revealMLDSAPublicKey,
             linkMLDSAPublicKeyToAddress,
-            hashedPublicKey,
+            ...(contract !== undefined ? { contract } : {}),
+            ...(loadedStorage !== undefined ? { loadedStorage } : {}),
+            ...(hashedPublicKey !== undefined ? { hashedPublicKey } : {}),
         };
     }
+    // MultiSig
     static writeMultiSigData(writer, data) {
         writer.writeU16(data.pubkeys.length);
         for (const pubkey of data.pubkeys) {
-            writer.writeBytesWithLength(Buffer.from(pubkey, 'hex'));
+            writer.writeBytesWithLength(fromHex(pubkey));
         }
         writer.writeU8(data.minimumSignatures);
         writer.writeStringWithLength(data.receiver);
@@ -423,7 +493,7 @@ export class TransactionSerializer {
         const pubkeysCount = reader.readU16();
         const pubkeys = [];
         for (let i = 0; i < pubkeysCount; i++) {
-            pubkeys.push(Buffer.from(reader.readBytesWithLength()).toString('hex'));
+            pubkeys.push(toHex(reader.readBytesWithLength()));
         }
         const minimumSignatures = reader.readU8();
         const receiver = reader.readStringWithLength();
@@ -440,9 +510,10 @@ export class TransactionSerializer {
             requestedAmount,
             refundVault,
             originalInputCount,
-            existingPsbtBase64,
+            ...(existingPsbtBase64 !== undefined ? { existingPsbtBase64 } : {}),
         };
     }
+    // Custom Script
     static writeCustomScriptData(writer, data) {
         writer.writeU16(data.scriptElements.length);
         for (const element of data.scriptElements) {
@@ -450,17 +521,17 @@ export class TransactionSerializer {
         }
         writer.writeU16(data.witnesses.length);
         for (const witness of data.witnesses) {
-            writer.writeBytesWithLength(Buffer.from(witness, 'hex'));
+            writer.writeBytesWithLength(fromHex(witness));
         }
         writer.writeBoolean(data.annex !== undefined);
         if (data.annex !== undefined) {
-            writer.writeBytesWithLength(Buffer.from(data.annex, 'hex'));
+            writer.writeBytesWithLength(fromHex(data.annex));
         }
     }
     static writeScriptElement(writer, element) {
         writer.writeU8(element.elementType === 'buffer' ? 0 : 1);
         if (element.elementType === 'buffer') {
-            writer.writeBytesWithLength(Buffer.from(element.value, 'hex'));
+            writer.writeBytesWithLength(fromHex(element.value));
         }
         else {
             writer.writeU32(element.value);
@@ -475,17 +546,17 @@ export class TransactionSerializer {
         const witnessesCount = reader.readU16();
         const witnesses = [];
         for (let i = 0; i < witnessesCount; i++) {
-            witnesses.push(Buffer.from(reader.readBytesWithLength()).toString('hex'));
+            witnesses.push(toHex(reader.readBytesWithLength()));
         }
         const hasAnnex = reader.readBoolean();
         const annex = hasAnnex
-            ? Buffer.from(reader.readBytesWithLength()).toString('hex')
+            ? toHex(reader.readBytesWithLength())
             : undefined;
         return {
             type: TransactionType.CUSTOM_CODE,
             scriptElements,
             witnesses,
-            annex,
+            ...(annex !== undefined ? { annex } : {}),
         };
     }
     static readScriptElement(reader) {
@@ -493,7 +564,7 @@ export class TransactionSerializer {
         if (typeFlag === 0) {
             return {
                 elementType: 'buffer',
-                value: Buffer.from(reader.readBytesWithLength()).toString('hex'),
+                value: toHex(reader.readBytesWithLength()),
             };
         }
         else {
@@ -503,55 +574,58 @@ export class TransactionSerializer {
             };
         }
     }
+    // Cancel
     static writeCancelData(writer, data) {
-        writer.writeBytesWithLength(Buffer.from(data.compiledTargetScript, 'hex'));
+        writer.writeBytesWithLength(fromHex(data.compiledTargetScript));
     }
     static readCancelData(reader) {
         return {
             type: TransactionType.CANCEL,
-            compiledTargetScript: Buffer.from(reader.readBytesWithLength()).toString('hex'),
+            compiledTargetScript: toHex(reader.readBytesWithLength()),
         };
     }
     static writeChallenge(writer, challenge) {
         writer.writeU64(BigInt(challenge.epochNumber));
         writer.writeStringWithLength(challenge.mldsaPublicKey);
         writer.writeStringWithLength(challenge.legacyPublicKey);
-        writer.writeBytesWithLength(Buffer.from(challenge.solution.replace('0x', ''), 'hex'));
-        writer.writeBytesWithLength(Buffer.from(challenge.salt.replace('0x', ''), 'hex'));
-        writer.writeBytesWithLength(Buffer.from(challenge.graffiti.replace('0x', ''), 'hex'));
+        writer.writeBytesWithLength(fromHex(challenge.solution.replace('0x', '')));
+        writer.writeBytesWithLength(fromHex(challenge.salt.replace('0x', '')));
+        writer.writeBytesWithLength(fromHex(challenge.graffiti.replace('0x', '')));
         writer.writeU8(challenge.difficulty);
+        // Verification
         this.writeChallengeVerification(writer, challenge.verification);
+        // Optional submission
         writer.writeBoolean(challenge.submission !== undefined);
         if (challenge.submission !== undefined) {
             writer.writeStringWithLength(challenge.submission.mldsaPublicKey);
             writer.writeStringWithLength(challenge.submission.legacyPublicKey);
-            writer.writeBytesWithLength(Buffer.from(challenge.submission.solution.replace('0x', ''), 'hex'));
+            writer.writeBytesWithLength(fromHex(challenge.submission.solution.replace('0x', '')));
             writer.writeBoolean(challenge.submission.graffiti !== undefined);
             if (challenge.submission.graffiti !== undefined) {
-                writer.writeBytesWithLength(Buffer.from(challenge.submission.graffiti.replace('0x', ''), 'hex'));
+                writer.writeBytesWithLength(fromHex(challenge.submission.graffiti.replace('0x', '')));
             }
-            writer.writeBytesWithLength(Buffer.from(challenge.submission.signature.replace('0x', ''), 'hex'));
+            writer.writeBytesWithLength(fromHex(challenge.submission.signature.replace('0x', '')));
         }
     }
     static writeChallengeVerification(writer, verification) {
-        writer.writeBytesWithLength(Buffer.from(verification.epochHash.replace('0x', ''), 'hex'));
-        writer.writeBytesWithLength(Buffer.from(verification.epochRoot.replace('0x', ''), 'hex'));
-        writer.writeBytesWithLength(Buffer.from(verification.targetHash.replace('0x', ''), 'hex'));
-        writer.writeBytesWithLength(Buffer.from(verification.targetChecksum.replace('0x', ''), 'hex'));
+        writer.writeBytesWithLength(fromHex(verification.epochHash.replace('0x', '')));
+        writer.writeBytesWithLength(fromHex(verification.epochRoot.replace('0x', '')));
+        writer.writeBytesWithLength(fromHex(verification.targetHash.replace('0x', '')));
+        writer.writeBytesWithLength(fromHex(verification.targetChecksum.replace('0x', '')));
         writer.writeU64(BigInt(verification.startBlock));
         writer.writeU64(BigInt(verification.endBlock));
         writer.writeU16(verification.proofs.length);
         for (const proof of verification.proofs) {
-            writer.writeBytesWithLength(Buffer.from(proof.replace('0x', ''), 'hex'));
+            writer.writeBytesWithLength(fromHex(proof.replace('0x', '')));
         }
     }
     static readChallenge(reader) {
         const epochNumber = reader.readU64().toString();
         const mldsaPublicKey = reader.readStringWithLength();
         const legacyPublicKey = reader.readStringWithLength();
-        const solution = '0x' + Buffer.from(reader.readBytesWithLength()).toString('hex');
-        const salt = '0x' + Buffer.from(reader.readBytesWithLength()).toString('hex');
-        const graffiti = '0x' + Buffer.from(reader.readBytesWithLength()).toString('hex');
+        const solution = '0x' + toHex(reader.readBytesWithLength());
+        const salt = '0x' + toHex(reader.readBytesWithLength());
+        const graffiti = '0x' + toHex(reader.readBytesWithLength());
         const difficulty = reader.readU8();
         const verification = this.readChallengeVerification(reader);
         const hasSubmission = reader.readBoolean();
@@ -559,18 +633,18 @@ export class TransactionSerializer {
         if (hasSubmission) {
             const subMldsaPublicKey = reader.readStringWithLength();
             const subLegacyPublicKey = reader.readStringWithLength();
-            const subSolution = '0x' + Buffer.from(reader.readBytesWithLength()).toString('hex');
+            const subSolution = '0x' + toHex(reader.readBytesWithLength());
             const hasGraffiti = reader.readBoolean();
             const subGraffiti = hasGraffiti
-                ? '0x' + Buffer.from(reader.readBytesWithLength()).toString('hex')
+                ? '0x' + toHex(reader.readBytesWithLength())
                 : undefined;
-            const subSignature = '0x' + Buffer.from(reader.readBytesWithLength()).toString('hex');
+            const subSignature = '0x' + toHex(reader.readBytesWithLength());
             submission = {
                 mldsaPublicKey: subMldsaPublicKey,
                 legacyPublicKey: subLegacyPublicKey,
                 solution: subSolution,
-                graffiti: subGraffiti,
                 signature: subSignature,
+                ...(subGraffiti !== undefined ? { graffiti: subGraffiti } : {}),
             };
         }
         return {
@@ -582,20 +656,20 @@ export class TransactionSerializer {
             graffiti,
             difficulty,
             verification,
-            submission,
+            ...(submission !== undefined ? { submission } : {}),
         };
     }
     static readChallengeVerification(reader) {
-        const epochHash = '0x' + Buffer.from(reader.readBytesWithLength()).toString('hex');
-        const epochRoot = '0x' + Buffer.from(reader.readBytesWithLength()).toString('hex');
-        const targetHash = '0x' + Buffer.from(reader.readBytesWithLength()).toString('hex');
-        const targetChecksum = '0x' + Buffer.from(reader.readBytesWithLength()).toString('hex');
+        const epochHash = '0x' + toHex(reader.readBytesWithLength());
+        const epochRoot = '0x' + toHex(reader.readBytesWithLength());
+        const targetHash = '0x' + toHex(reader.readBytesWithLength());
+        const targetChecksum = '0x' + toHex(reader.readBytesWithLength());
         const startBlock = reader.readU64().toString();
         const endBlock = reader.readU64().toString();
         const proofsCount = reader.readU16();
         const proofs = [];
         for (let i = 0; i < proofsCount; i++) {
-            proofs.push('0x' + Buffer.from(reader.readBytesWithLength()).toString('hex'));
+            proofs.push('0x' + toHex(reader.readBytesWithLength()));
         }
         return {
             epochHash,
@@ -627,11 +701,11 @@ export class TransactionSerializer {
     static writePrecomputedData(writer, data) {
         writer.writeBoolean(data.compiledTargetScript !== undefined);
         if (data.compiledTargetScript !== undefined) {
-            writer.writeBytesWithLength(Buffer.from(data.compiledTargetScript, 'hex'));
+            writer.writeBytesWithLength(fromHex(data.compiledTargetScript));
         }
         writer.writeBoolean(data.randomBytes !== undefined);
         if (data.randomBytes !== undefined) {
-            writer.writeBytesWithLength(Buffer.from(data.randomBytes, 'hex'));
+            writer.writeBytesWithLength(fromHex(data.randomBytes));
         }
         writer.writeBoolean(data.estimatedFees !== undefined);
         if (data.estimatedFees !== undefined) {
@@ -649,11 +723,11 @@ export class TransactionSerializer {
     static readPrecomputedData(reader) {
         const hasCompiledTargetScript = reader.readBoolean();
         const compiledTargetScript = hasCompiledTargetScript
-            ? Buffer.from(reader.readBytesWithLength()).toString('hex')
+            ? toHex(reader.readBytesWithLength())
             : undefined;
         const hasRandomBytes = reader.readBoolean();
         const randomBytes = hasRandomBytes
-            ? Buffer.from(reader.readBytesWithLength()).toString('hex')
+            ? toHex(reader.readBytesWithLength())
             : undefined;
         const hasEstimatedFees = reader.readBoolean();
         const estimatedFees = hasEstimatedFees ? reader.readU64().toString() : undefined;
@@ -662,16 +736,52 @@ export class TransactionSerializer {
         const hasContractAddress = reader.readBoolean();
         const contractAddress = hasContractAddress ? reader.readStringWithLength() : undefined;
         return {
-            compiledTargetScript,
-            randomBytes,
-            estimatedFees,
-            contractSeed,
-            contractAddress,
+            ...(compiledTargetScript !== undefined ? { compiledTargetScript } : {}),
+            ...(randomBytes !== undefined ? { randomBytes } : {}),
+            ...(estimatedFees !== undefined ? { estimatedFees } : {}),
+            ...(contractSeed !== undefined ? { contractSeed } : {}),
+            ...(contractAddress !== undefined ? { contractAddress } : {}),
         };
     }
+    /**
+     * Calculate double SHA256 checksum (Bitcoin standard)
+     */
     static calculateChecksum(data) {
         const hash1 = createHash('sha256').update(data).digest();
-        return createHash('sha256').update(hash1).digest();
+        return new Uint8Array(createHash('sha256').update(hash1).digest());
+    }
+    /**
+     * Compare two Uint8Arrays for equality
+     */
+    static bytesEqual(a, b) {
+        if (a.length !== b.length)
+            return false;
+        for (let i = 0; i < a.length; i++) {
+            if (a[i] !== b[i])
+                return false;
+        }
+        return true;
+    }
+    /**
+     * Encode Uint8Array to base64 string
+     */
+    static uint8ArrayToBase64(bytes) {
+        let binary = '';
+        for (let i = 0; i < bytes.length; i++) {
+            binary += String.fromCharCode(bytes[i]);
+        }
+        return btoa(binary);
+    }
+    /**
+     * Decode base64 string to Uint8Array
+     */
+    static base64ToUint8Array(base64) {
+        const binary = atob(base64);
+        const bytes = new Uint8Array(binary.length);
+        for (let i = 0; i < binary.length; i++) {
+            bytes[i] = binary.charCodeAt(i);
+        }
+        return bytes;
     }
     static networkNameToU8(name) {
         switch (name) {
@@ -698,3 +808,4 @@ export class TransactionSerializer {
         }
     }
 }
+//# sourceMappingURL=TransactionSerializer.js.map