@totemsdk/core 1.2.5 → 1.2.7

package/dist/cjs/scripts/witness-serializer.js

@@ -0,0 +1,306 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.STATETYPE_BOOL = exports.STATETYPE_STRING = exports.STATETYPE_NUMBER = exports.STATETYPE_HEX = void 0;
+exports.encodeMiniNumber = encodeMiniNumber;
+exports.encodeMiniData = encodeMiniData;
+exports.encodeMiniString = encodeMiniString;
+exports.serializeMMRProofChunk = serializeMMRProofChunk;
+exports.serializeRealMMRProof = serializeRealMMRProof;
+exports.parseMMRProofFromHex = parseMMRProofFromHex;
+exports.serializeScriptProofWithProof = serializeScriptProofWithProof;
+exports.encodeStateValue = encodeStateValue;
+exports.serializeStateVariables = serializeStateVariables;
+exports.buildScriptProofFromDescriptor = buildScriptProofFromDescriptor;
+exports.deduplicateScriptDescriptors = deduplicateScriptDescriptors;
+exports.serializeExtraScripts = serializeExtraScripts;
+exports.aggregateSignatures = aggregateSignatures;
+exports.validateExternalSignature = validateExternalSignature;
+exports.computeScriptAddress = computeScriptAddress;
+exports.concat = concat;
+const wasm_sync_js_1 = require("../wasm-sync.js");
+const mmr_js_1 = require("../mmr.js");
+const minima32_js_1 = require("../minima32.js");
+function hexToBytes(hex) {
+    const cleanHex = hex.startsWith('0x') ? hex.slice(2) : hex;
+    if (cleanHex.length % 2 !== 0) {
+        throw new Error('Invalid hex string');
+    }
+    const bytes = new Uint8Array(cleanHex.length / 2);
+    for (let i = 0; i < cleanHex.length; i += 2) {
+        bytes[i / 2] = parseInt(cleanHex.slice(i, i + 2), 16);
+    }
+    return bytes;
+}
+function normalizeHexValue(value) {
+    if (!value)
+        return '0x00';
+    const trimmed = value.trim();
+    if (trimmed.toLowerCase().startsWith('mx')) {
+        return (0, minima32_js_1.mxToHex)(trimmed);
+    }
+    return trimmed.startsWith('0x') ? trimmed : '0x' + trimmed;
+}
+function bytesToHex(bytes) {
+    return '0x' + Array.from(bytes).map(b => b.toString(16).padStart(2, '0')).join('');
+}
+function concat(...arrays) {
+    const totalLength = arrays.reduce((sum, arr) => sum + arr.length, 0);
+    const result = new Uint8Array(totalLength);
+    let offset = 0;
+    for (const arr of arrays) {
+        result.set(arr, offset);
+        offset += arr.length;
+    }
+    return result;
+}
+function encodeMiniNumber(value, scale = 0) {
+    if (typeof value !== 'bigint') {
+        throw new Error(`encodeMiniNumber requires bigint, got ${typeof value}`);
+    }
+    if (value === 0n) {
+        return new Uint8Array([scale & 0xff, 1, 0]);
+    }
+    if (value < 0n) {
+        throw new Error(`encodeMiniNumber does not support negative values: ${value}`);
+    }
+    let hex = value.toString(16);
+    if (hex.length % 2 !== 0) {
+        hex = '0' + hex;
+    }
+    let unscaledBytes = hexToBytes(hex);
+    if (unscaledBytes.length > 0 && (unscaledBytes[0] & 0x80) !== 0) {
+        const withLeadingZero = new Uint8Array(unscaledBytes.length + 1);
+        withLeadingZero[0] = 0x00;
+        withLeadingZero.set(unscaledBytes, 1);
+        unscaledBytes = withLeadingZero;
+    }
+    const length = unscaledBytes.length;
+    if (length > 32) {
+        throw new Error(`MiniNumber data too large: ${length} bytes (max 32)`);
+    }
+    const result = new Uint8Array(1 + 1 + length);
+    result[0] = scale & 0xff;
+    result[1] = length & 0xff;
+    result.set(unscaledBytes, 2);
+    return result;
+}
+function encodeMiniData(data) {
+    const length = data.length;
+    const lengthBytes = new Uint8Array([
+        (length >> 24) & 0xff,
+        (length >> 16) & 0xff,
+        (length >> 8) & 0xff,
+        length & 0xff
+    ]);
+    return concat(lengthBytes, data);
+}
+function encodeMiniString(str) {
+    const utf8Bytes = new TextEncoder().encode(str);
+    return encodeMiniData(utf8Bytes);
+}
+function encodeMiniByte(value) {
+    return new Uint8Array([value ? 1 : 0]);
+}
+function serializeMMRProofChunk(chunk) {
+    const parts = [];
+    parts.push(encodeMiniByte(chunk.isLeft));
+    parts.push(encodeMiniData(chunk.mmrData.data));
+    parts.push(encodeMiniNumber(chunk.mmrData.value));
+    return concat(...parts);
+}
+function serializeRealMMRProof(proof, blockTime = 0n) {
+    return (0, mmr_js_1.serializeMMRProof)(proof, blockTime);
+}
+function parseMMRProofFromHex(proofHex) {
+    const bytes = hexToBytes(proofHex);
+    let offset = 0;
+    const { value: blockTime, bytesRead: btRead } = readMiniNumber(bytes, offset);
+    offset += btRead;
+    const { value: chainLength, bytesRead: clRead } = readMiniNumber(bytes, offset);
+    offset += clRead;
+    const chunks = [];
+    for (let i = 0; i < Number(chainLength); i++) {
+        const { chunk, bytesRead } = readMMRProofChunk(bytes, offset);
+        chunks.push(chunk);
+        offset += bytesRead;
+    }
+    return { proof: { chunks }, blockTime };
+}
+function readMiniNumber(bytes, offset) {
+    const scale = bytes[offset];
+    const length = (bytes[offset + 1] << 24) | (bytes[offset + 2] << 16) |
+        (bytes[offset + 3] << 8) | bytes[offset + 4];
+    if (length === 0) {
+        return { value: 0n, bytesRead: 5 };
+    }
+    const dataBytes = bytes.slice(offset + 5, offset + 5 + length);
+    let value = 0n;
+    for (const b of dataBytes) {
+        value = (value << 8n) | BigInt(b);
+    }
+    return { value, bytesRead: 5 + length };
+}
+function readMMRProofChunk(bytes, offset) {
+    let pos = offset;
+    const isLeft = bytes[pos] === 1;
+    pos += 1;
+    const dataLength = (bytes[pos] << 24) | (bytes[pos + 1] << 16) |
+        (bytes[pos + 2] << 8) | bytes[pos + 3];
+    pos += 4;
+    const data = bytes.slice(pos, pos + dataLength);
+    pos += dataLength;
+    const { value, bytesRead: valueRead } = readMiniNumber(bytes, pos);
+    pos += valueRead;
+    return {
+        chunk: { isLeft, mmrData: { data, value } },
+        bytesRead: pos - offset
+    };
+}
+function serializeScriptProofWithProof(script, proof, blockTime = 0n) {
+    const scriptBytes = encodeMiniString(script);
+    const proofBytes = serializeRealMMRProof(proof, blockTime);
+    return concat(scriptBytes, proofBytes);
+}
+exports.STATETYPE_HEX = 1;
+exports.STATETYPE_NUMBER = 2;
+exports.STATETYPE_STRING = 4;
+exports.STATETYPE_BOOL = 8;
+function encodeStateValue(stateValue) {
+    if (stateValue.port < 0 || stateValue.port > 255) {
+        throw new Error(`StateVariable port must be 0-255, got ${stateValue.port}`);
+    }
+    const portByte = new Uint8Array([stateValue.port]);
+    let typeByte;
+    let dataBytes;
+    switch (stateValue.type) {
+        case 'bool':
+            typeByte = new Uint8Array([exports.STATETYPE_BOOL]);
+            if (typeof stateValue.value === 'boolean') {
+                dataBytes = new Uint8Array([stateValue.value ? 1 : 0]);
+            }
+            else if (typeof stateValue.value === 'string') {
+                const boolValue = stateValue.value.toUpperCase() === 'TRUE';
+                dataBytes = new Uint8Array([boolValue ? 1 : 0]);
+            }
+            else {
+                throw new Error(`Invalid bool state value: ${stateValue.value}`);
+            }
+            break;
+        case 'number':
+            typeByte = new Uint8Array([exports.STATETYPE_NUMBER]);
+            if (typeof stateValue.value === 'bigint') {
+                dataBytes = encodeMiniNumber(stateValue.value);
+            }
+            else if (typeof stateValue.value === 'string') {
+                const numValue = BigInt(stateValue.value);
+                dataBytes = encodeMiniNumber(numValue);
+            }
+            else {
+                throw new Error(`Invalid number state value: ${stateValue.value}`);
+            }
+            break;
+        case 'hex':
+            typeByte = new Uint8Array([exports.STATETYPE_HEX]);
+            if (typeof stateValue.value === 'string') {
+                const normalizedHex = normalizeHexValue(stateValue.value);
+                dataBytes = encodeMiniData(hexToBytes(normalizedHex));
+            }
+            else if (stateValue.value instanceof Uint8Array) {
+                dataBytes = encodeMiniData(stateValue.value);
+            }
+            else {
+                throw new Error(`Invalid hex state value: ${stateValue.value}`);
+            }
+            break;
+        case 'string':
+            typeByte = new Uint8Array([exports.STATETYPE_STRING]);
+            if (typeof stateValue.value === 'string') {
+                let bracketedValue = stateValue.value;
+                if (!stateValue.value.startsWith('[') || !stateValue.value.endsWith(']')) {
+                    bracketedValue = `[${stateValue.value}]`;
+                }
+                dataBytes = encodeMiniString(bracketedValue);
+            }
+            else {
+                throw new Error(`Invalid string state value: ${stateValue.value}`);
+            }
+            break;
+        default:
+            throw new Error(`Unknown state value type: ${stateValue.type}`);
+    }
+    return concat(portByte, typeByte, dataBytes);
+}
+function serializeStateVariables(stateValues) {
+    const parts = [];
+    const countBytes = encodeMiniNumber(BigInt(stateValues.length));
+    parts.push(countBytes);
+    const sorted = [...stateValues].sort((a, b) => a.port - b.port);
+    for (const sv of sorted) {
+        parts.push(encodeStateValue(sv));
+    }
+    return concat(...parts);
+}
+function buildScriptProofFromDescriptor(descriptor) {
+    const proof = descriptor.mastProof || { chunks: [] };
+    const serialized = serializeScriptProofWithProof(descriptor.script, proof);
+    return {
+        script: descriptor.script,
+        proof,
+        serialized
+    };
+}
+function deduplicateScriptDescriptors(descriptors) {
+    const unique = new Map();
+    for (const desc of descriptors) {
+        const normalizedAddr = desc.address.toLowerCase();
+        if (!unique.has(normalizedAddr)) {
+            unique.set(normalizedAddr, desc);
+        }
+    }
+    return unique;
+}
+function serializeExtraScripts(extraScripts) {
+    const parts = [];
+    const countBytes = encodeMiniNumber(BigInt(extraScripts.size));
+    parts.push(countBytes);
+    for (const [script, proofHex] of extraScripts) {
+        const { proof, blockTime } = proofHex
+            ? parseMMRProofFromHex(proofHex)
+            : { proof: { chunks: [] }, blockTime: 0n };
+        parts.push(serializeScriptProofWithProof(script, proof, blockTime));
+    }
+    return concat(...parts);
+}
+function aggregateSignatures(totemSignature, externalSignatures) {
+    const allSigProofs = [];
+    allSigProofs.push(serializeSignatureProof(totemSignature.publicKey, totemSignature.signature, { chunks: [] }));
+    for (const extSig of externalSignatures) {
+        if (!extSig.validated) {
+            console.warn(`[AggregateSignatures] Skipping unvalidated signature from ${extSig.publicKey}`);
+            continue;
+        }
+        const proof = extSig.proof || { chunks: [] };
+        allSigProofs.push(serializeSignatureProof(hexToBytes(extSig.publicKey), hexToBytes(extSig.signature), proof));
+    }
+    return allSigProofs;
+}
+function serializeSignatureProof(publicKey, signature, proof) {
+    const parts = [];
+    parts.push(encodeMiniData(publicKey));
+    parts.push(encodeMiniData(signature));
+    parts.push(serializeRealMMRProof(proof));
+    return concat(...parts);
+}
+function validateExternalSignature(signature, transactionDigest) {
+    if (!signature.publicKey || !signature.signature) {
+        return false;
+    }
+    console.log(`[ValidateSignature] Validating signature from ${signature.publicKey.substring(0, 16)}...`);
+    return true;
+}
+function computeScriptAddress(script) {
+    const cleanScript = script.trim().toUpperCase();
+    const scriptBytes = new TextEncoder().encode(cleanScript);
+    const hashBytes = (0, wasm_sync_js_1.sha3_256)(scriptBytes);
+    return bytesToHex(hashBytes);
+}

package/dist/cjs/transaction.d.ts

@@ -0,0 +1,106 @@
+/**
+ * Transaction Serialization & Digest Computation
+ *
+ * Port of the extension's MinimaTransactionBuilder serialization logic
+ * to the SDK core for full parity with the Totem wallet extension.
+ *
+ * Matches Minima Java's Transaction.writeDataStream() and Coin.writeDataStream() exactly.
+ *
+ * CRITICAL: Before computing the transaction digest for signing, you MUST call
+ * precomputeTransactionCoinID() to set output coin IDs. Without this, the signed
+ * digest won't match what the Minima node verifies, causing allsignaturesvalid=false.
+ */
+export interface MinimaTransaction {
+    linkHash: Uint8Array;
+    inputs: MinimaCoin[];
+    outputs: MinimaCoin[];
+    state: StateVariable[];
+}
+export interface MinimaCoin {
+    coinId: Uint8Array;
+    address: Uint8Array;
+    amount: string;
+    tokenId: Uint8Array;
+    token: MinimaToken | null;
+    storeState: boolean;
+    state: StateVariable[] | RawStateVariable[];
+    mmrEntryNumber: bigint;
+    spent: boolean;
+    created: bigint;
+    rawAmountBytes?: Uint8Array;
+    rawMmrEntryBytes?: Uint8Array;
+    rawBlockCreatedBytes?: Uint8Array;
+    rawTokenData?: Uint8Array;
+}
+export interface ParsedMiniNumber {
+    scale: number;
+    unscaledValue: bigint;
+}
+export interface MinimaToken {
+    coinId: Uint8Array;
+    scale: number;
+    totalAmount: bigint;
+    name: Uint8Array;
+    script: Uint8Array;
+    created?: bigint;
+}
+export interface StateVariable {
+    port: number;
+    value: string | bigint | boolean | Uint8Array;
+    type: 'bool' | 'number' | 'hex' | 'string';
+}
+export interface RawStateVariable {
+    port: number;
+    type: number;
+    rawData: Uint8Array;
+}
+export interface CoinProofData {
+    coinId: Uint8Array;
+    address: Uint8Array;
+    rawAmountBytes: Uint8Array;
+    tokenId: Uint8Array;
+    storeState: boolean;
+    mmrEntryNumber: bigint;
+    rawMmrEntryBytes: Uint8Array;
+    spent: boolean;
+    blockCreated: bigint;
+    rawBlockCreatedBytes: Uint8Array;
+    state: RawStateVariable[];
+    rawTokenData?: Uint8Array;
+}
+export interface SpendableCoinInput {
+    coinId: string;
+    address: string;
+    amount: string;
+    tokenId: string;
+    rawAmountBytes?: Uint8Array;
+    coinProofData?: CoinProofData;
+}
+export interface TransactionBuildResult {
+    transaction: MinimaTransaction;
+    digestTx: Uint8Array;
+    digestTxHex: string;
+    serialized: Uint8Array;
+    serializedHex: string;
+}
+export declare function parseDecimalToMiniNumber(decimal: string): ParsedMiniNumber;
+export declare function serializeCoin(coin: MinimaCoin): Uint8Array;
+export declare function serializeTransaction(tx: MinimaTransaction): Uint8Array;
+export declare function computeTransactionDigest(tx: MinimaTransaction): Uint8Array;
+export declare function precomputeTransactionCoinID(tx: MinimaTransaction): void;
+export declare function createDefaultTransaction(): MinimaTransaction;
+export declare function buildMinimaCoin(opts: {
+    coinId?: Uint8Array;
+    address: Uint8Array;
+    amount: string;
+    tokenId?: Uint8Array;
+    storeState?: boolean;
+    state?: StateVariable[];
+    mmrEntryNumber?: bigint;
+    spent?: boolean;
+    created?: bigint;
+    rawAmountBytes?: Uint8Array;
+    rawMmrEntryBytes?: Uint8Array;
+    rawBlockCreatedBytes?: Uint8Array;
+    coinProofData?: CoinProofData;
+}): MinimaCoin;

package/dist/cjs/transaction.js

@@ -0,0 +1,293 @@
+"use strict";
+/**
+ * Transaction Serialization & Digest Computation
+ *
+ * Port of the extension's MinimaTransactionBuilder serialization logic
+ * to the SDK core for full parity with the Totem wallet extension.
+ *
+ * Matches Minima Java's Transaction.writeDataStream() and Coin.writeDataStream() exactly.
+ *
+ * CRITICAL: Before computing the transaction digest for signing, you MUST call
+ * precomputeTransactionCoinID() to set output coin IDs. Without this, the signed
+ * digest won't match what the Minima node verifies, causing allsignaturesvalid=false.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseDecimalToMiniNumber = parseDecimalToMiniNumber;
+exports.serializeCoin = serializeCoin;
+exports.serializeTransaction = serializeTransaction;
+exports.computeTransactionDigest = computeTransactionDigest;
+exports.precomputeTransactionCoinID = precomputeTransactionCoinID;
+exports.createDefaultTransaction = createDefaultTransaction;
+exports.buildMinimaCoin = buildMinimaCoin;
+const wasm_sync_js_1 = require("./wasm-sync.js");
+const Streamable_js_1 = require("./Streamable.js");
+const ZERO_TXPOWID = new Uint8Array([0x00]);
+const STATETYPE_HEX = 1;
+const STATETYPE_NUMBER = 2;
+const STATETYPE_STRING = 4;
+const STATETYPE_BOOL = 8;
+function parseDecimalToMiniNumber(decimal) {
+    if (!decimal || decimal === '') {
+        return { scale: 0, unscaledValue: 0n };
+    }
+    if (decimal.includes('e') || decimal.includes('E')) {
+        throw new Error(`Scientific notation not supported: "${decimal}". Convert to plain decimal first.`);
+    }
+    let isNegative = false;
+    let cleaned = decimal.trim();
+    if (cleaned.startsWith('-')) {
+        isNegative = true;
+        cleaned = cleaned.slice(1);
+    }
+    const dotIndex = cleaned.indexOf('.');
+    let scale;
+    let unscaledStr;
+    if (dotIndex === -1) {
+        scale = 0;
+        unscaledStr = cleaned;
+    }
+    else {
+        const wholePart = cleaned.slice(0, dotIndex);
+        const fracPart = cleaned.slice(dotIndex + 1);
+        scale = fracPart.length;
+        unscaledStr = wholePart + fracPart;
+    }
+    unscaledStr = unscaledStr.replace(/^0+/, '') || '0';
+    let unscaledValue = BigInt(unscaledStr);
+    if (isNegative && unscaledValue !== 0n) {
+        unscaledValue = -unscaledValue;
+    }
+    return { scale, unscaledValue };
+}
+function encodeParsedMiniNumber(parsed) {
+    return (0, Streamable_js_1.writeMiniNumber)(parsed.unscaledValue, parsed.scale);
+}
+function normalizeAddressToHex(addr) {
+    if (!addr) {
+        return '0x00';
+    }
+    const trimmed = addr.trim();
+    const hexAddr = trimmed.startsWith('0x') ? trimmed : '0x' + trimmed;
+    const cleanHex = hexAddr.slice(2);
+    if (!/^[0-9a-fA-F]*$/.test(cleanHex)) {
+        throw new Error(`Invalid hex address: contains non-hex characters`);
+    }
+    if (cleanHex.length % 2 !== 0) {
+        throw new Error(`Invalid hex address: odd length (${cleanHex.length} chars)`);
+    }
+    return hexAddr;
+}
+function serializeStateVariable(sv) {
+    if (sv.port < 0 || sv.port > 255) {
+        throw new Error(`StateVariable port must be 0-255, got ${sv.port}`);
+    }
+    const portByte = new Uint8Array([sv.port]);
+    let typeByte;
+    let dataBytes;
+    switch (sv.type) {
+        case 'bool':
+            typeByte = new Uint8Array([STATETYPE_BOOL]);
+            if (typeof sv.value === 'boolean') {
+                dataBytes = new Uint8Array([sv.value ? 1 : 0]);
+            }
+            else if (typeof sv.value === 'string') {
+                dataBytes = new Uint8Array([sv.value.toUpperCase() === 'TRUE' ? 1 : 0]);
+            }
+            else {
+                throw new Error(`Invalid bool StateVariable value: ${sv.value}`);
+            }
+            break;
+        case 'number':
+            typeByte = new Uint8Array([STATETYPE_NUMBER]);
+            if (typeof sv.value === 'bigint') {
+                dataBytes = (0, Streamable_js_1.writeMiniNumber)(sv.value, 0);
+            }
+            else if (typeof sv.value === 'string') {
+                dataBytes = (0, Streamable_js_1.writeMiniNumber)(BigInt(sv.value), 0);
+            }
+            else {
+                throw new Error(`Invalid number StateVariable value: ${sv.value}`);
+            }
+            break;
+        case 'hex':
+            typeByte = new Uint8Array([STATETYPE_HEX]);
+            if (typeof sv.value === 'string') {
+                const normalizedHex = normalizeAddressToHex(sv.value);
+                dataBytes = (0, Streamable_js_1.writeMiniData)((0, Streamable_js_1.hexToBytes)(normalizedHex));
+            }
+            else if (sv.value instanceof Uint8Array) {
+                dataBytes = (0, Streamable_js_1.writeMiniData)(sv.value);
+            }
+            else {
+                throw new Error(`Invalid hex StateVariable value: ${sv.value}`);
+            }
+            break;
+        case 'string':
+            typeByte = new Uint8Array([STATETYPE_STRING]);
+            if (typeof sv.value === 'string') {
+                let bracketedValue = sv.value;
+                if (!sv.value.startsWith('[') || !sv.value.endsWith(']')) {
+                    bracketedValue = `[${sv.value}]`;
+                }
+                const utf8Bytes = new TextEncoder().encode(bracketedValue);
+                dataBytes = (0, Streamable_js_1.writeMiniData)(utf8Bytes);
+            }
+            else {
+                throw new Error(`Invalid string StateVariable value: ${sv.value}`);
+            }
+            break;
+        default:
+            throw new Error(`Unknown StateVariable type: ${sv.type}`);
+    }
+    return (0, Streamable_js_1.concat)(portByte, typeByte, dataBytes);
+}
+function serializeToken(token) {
+    // Java Token.writeDataStream() order: coinId, script, scale, totalAmount, name, created
+    const parts = [];
+    parts.push((0, Streamable_js_1.writeHashToStream)(token.coinId));
+    parts.push((0, Streamable_js_1.writeMiniData)(token.script));
+    parts.push((0, Streamable_js_1.writeMiniNumber)(BigInt(token.scale), 0));
+    parts.push((0, Streamable_js_1.writeMiniNumber)(token.totalAmount, 0));
+    parts.push((0, Streamable_js_1.writeMiniData)(token.name));
+    parts.push((0, Streamable_js_1.writeMiniNumber)(token.created ?? 0n, 0));
+    return (0, Streamable_js_1.concat)(...parts);
+}
+function serializeCoin(coin) {
+    const parts = [];
+    parts.push((0, Streamable_js_1.writeHashToStream)(coin.coinId));
+    parts.push((0, Streamable_js_1.writeHashToStream)(coin.address));
+    let amountBytes;
+    if (coin.rawAmountBytes && coin.rawAmountBytes.length > 0) {
+        amountBytes = coin.rawAmountBytes;
+    }
+    else {
+        const parsedAmount = parseDecimalToMiniNumber(coin.amount);
+        amountBytes = encodeParsedMiniNumber(parsedAmount);
+    }
+    parts.push(amountBytes);
+    parts.push((0, Streamable_js_1.writeMiniData)(coin.tokenId));
+    parts.push((0, Streamable_js_1.writeMiniByte)(coin.storeState));
+    let mmrBytes;
+    if (coin.rawMmrEntryBytes && coin.rawMmrEntryBytes.length > 0) {
+        mmrBytes = coin.rawMmrEntryBytes;
+    }
+    else {
+        mmrBytes = (0, Streamable_js_1.writeMMREntryNumber)(coin.mmrEntryNumber);
+    }
+    parts.push(mmrBytes);
+    parts.push((0, Streamable_js_1.writeMiniByte)(coin.spent));
+    let createdBytes;
+    if (coin.rawBlockCreatedBytes && coin.rawBlockCreatedBytes.length > 0) {
+        createdBytes = coin.rawBlockCreatedBytes;
+    }
+    else {
+        createdBytes = (0, Streamable_js_1.writeMiniNumber)(coin.created, 0);
+    }
+    parts.push(createdBytes);
+    const stateCountBytes = (0, Streamable_js_1.writeMiniNumber)(BigInt(coin.state.length), 0);
+    parts.push(stateCountBytes);
+    for (const sv of coin.state) {
+        let svBytes;
+        if ('rawData' in sv) {
+            const raw = sv;
+            const portByte = new Uint8Array([raw.port]);
+            const typeByte = new Uint8Array([raw.type]);
+            svBytes = (0, Streamable_js_1.concat)(portByte, typeByte, raw.rawData);
+        }
+        else {
+            svBytes = serializeStateVariable(sv);
+        }
+        parts.push(svBytes);
+    }
+    if (coin.rawTokenData && coin.rawTokenData.length > 0) {
+        parts.push((0, Streamable_js_1.writeMiniByte)(true));
+        parts.push(coin.rawTokenData);
+    }
+    else if (coin.token) {
+        parts.push((0, Streamable_js_1.writeMiniByte)(true));
+        parts.push(serializeToken(coin.token));
+    }
+    else {
+        parts.push((0, Streamable_js_1.writeMiniByte)(false));
+    }
+    return (0, Streamable_js_1.concat)(...parts);
+}
+function serializeTransaction(tx) {
+    const parts = [];
+    parts.push((0, Streamable_js_1.writeMiniNumber)(BigInt(tx.inputs.length), 0));
+    for (const input of tx.inputs) {
+        parts.push(serializeCoin(input));
+    }
+    parts.push((0, Streamable_js_1.writeMiniNumber)(BigInt(tx.outputs.length), 0));
+    for (const output of tx.outputs) {
+        parts.push(serializeCoin(output));
+    }
+    parts.push((0, Streamable_js_1.writeMiniNumber)(BigInt(tx.state.length), 0));
+    for (const sv of tx.state) {
+        parts.push(serializeStateVariable(sv));
+    }
+    parts.push((0, Streamable_js_1.writeHashToStream)(tx.linkHash));
+    return (0, Streamable_js_1.concat)(...parts);
+}
+function computeTransactionDigest(tx) {
+    const serialized = serializeTransaction(tx);
+    return (0, wasm_sync_js_1.sha3_256)(serialized);
+}
+function precomputeTransactionCoinID(tx) {
+    if (tx.inputs.length === 0)
+        return;
+    const baseCoinId = tx.inputs[0].coinId;
+    if (baseCoinId.length < 2) {
+        throw new Error(`Cannot precompute output coinIDs: input[0].coinId is ${baseCoinId.length} byte(s) ` +
+            `(placeholder?). Real coinId from CoinProof required for signing.`);
+    }
+    for (let i = 0; i < tx.outputs.length; i++) {
+        const baseCoinIdStream = (0, Streamable_js_1.writeMiniData)(baseCoinId);
+        const outputIndexStream = (0, Streamable_js_1.writeMiniNumber)(BigInt(i), 0);
+        const combined = (0, Streamable_js_1.concat)(baseCoinIdStream, outputIndexStream);
+        tx.outputs[i].coinId = (0, wasm_sync_js_1.sha3_256)(combined);
+    }
+}
+function createDefaultTransaction() {
+    return {
+        linkHash: ZERO_TXPOWID,
+        inputs: [],
+        outputs: [],
+        state: [],
+    };
+}
+function buildMinimaCoin(opts) {
+    if (opts.coinProofData) {
+        const cpd = opts.coinProofData;
+        return {
+            coinId: cpd.coinId,
+            address: cpd.address,
+            amount: opts.amount,
+            tokenId: cpd.tokenId,
+            token: null,
+            storeState: cpd.storeState,
+            state: cpd.state,
+            mmrEntryNumber: cpd.mmrEntryNumber,
+            spent: cpd.spent,
+            created: cpd.blockCreated,
+            rawAmountBytes: cpd.rawAmountBytes,
+            rawMmrEntryBytes: cpd.rawMmrEntryBytes,
+            rawBlockCreatedBytes: cpd.rawBlockCreatedBytes,
+        };
+    }
+    return {
+        coinId: opts.coinId || new Uint8Array([0x00]),
+        address: opts.address,
+        amount: opts.amount,
+        tokenId: opts.tokenId || new Uint8Array([0x00]),
+        token: null,
+        storeState: opts.storeState ?? false,
+        state: opts.state || [],
+        mmrEntryNumber: opts.mmrEntryNumber ?? 0n,
+        spent: opts.spent ?? false,
+        created: opts.created ?? 0n,
+        rawAmountBytes: opts.rawAmountBytes,
+        rawMmrEntryBytes: opts.rawMmrEntryBytes,
+        rawBlockCreatedBytes: opts.rawBlockCreatedBytes,
+    };
+}