@totemsdk/core 1.3.0 → 1.4.1

package/dist/cjs/scripts/witness-serializer.d.ts

@@ -25,5 +25,24 @@ export declare function aggregateSignatures(totemSignature: {
     signature: Uint8Array;
 }, externalSignatures: ExternalSignature[], transactionDigest: Uint8Array): Uint8Array[];
 export declare function validateExternalSignature(signature: ExternalSignature, transactionDigest: Uint8Array): boolean;
+/**
+ * Derive a Minima script address exactly as the node does
+ * (`Address::Address(script)` / `ScriptProof::calculateAddress`):
+ *
+ *   address = sha3( MiniNumber.ZERO || MiniString(script) || MiniNumber.ZERO )
+ *
+ * The script is first canonicalised (`toNodeScript`) so the address is over the
+ * same bytes the node will execute and that `buildScriptProof` attests. The
+ * previous implementation hashed `sha3(upper(script))`, which is not a Minima
+ * script address — coins sent to it could never be spent by that script
+ * ("Script Missing from TxPoW for address …").
+ */
+/**
+ * Address data (hex) of a WOTS public-key digest's single-key script
+ * (`RETURN SIGNEDBY(0x<pk>)`). This is the value a `VERIFYOUT` compares against
+ * (the node compares the output coin's *address data*), distinct from the WOTS
+ * public key used by `SIGNEDBY`.
+ */
+export declare function wotsAddressData(publicKeyDigest: string): string;
 export declare function computeScriptAddress(script: string): string;
 export { concat };

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

@@ -15,9 +15,10 @@ exports.deduplicateScriptDescriptors = deduplicateScriptDescriptors;
 exports.serializeExtraScripts = serializeExtraScripts;
 exports.aggregateSignatures = aggregateSignatures;
 exports.validateExternalSignature = validateExternalSignature;
+exports.wotsAddressData = wotsAddressData;
 exports.computeScriptAddress = computeScriptAddress;
 exports.concat = concat;
-const wasm_sync_js_1 = require("../wasm-sync.js");
+const canonical_js_1 = require("./canonical.js");
 const wots_js_1 = require("../wots.js");
 const mmr_js_1 = require("../mmr.js");
 const minima32_js_1 = require("../minima32.js");
@@ -321,9 +322,28 @@ function validateExternalSignature(signature, transactionDigest) {
         return false;
     }
 }
+/**
+ * Derive a Minima script address exactly as the node does
+ * (`Address::Address(script)` / `ScriptProof::calculateAddress`):
+ *
+ *   address = sha3( MiniNumber.ZERO || MiniString(script) || MiniNumber.ZERO )
+ *
+ * The script is first canonicalised (`toNodeScript`) so the address is over the
+ * same bytes the node will execute and that `buildScriptProof` attests. The
+ * previous implementation hashed `sha3(upper(script))`, which is not a Minima
+ * script address — coins sent to it could never be spent by that script
+ * ("Script Missing from TxPoW for address …").
+ */
+/**
+ * Address data (hex) of a WOTS public-key digest's single-key script
+ * (`RETURN SIGNEDBY(0x<pk>)`). This is the value a `VERIFYOUT` compares against
+ * (the node compares the output coin's *address data*), distinct from the WOTS
+ * public key used by `SIGNEDBY`.
+ */
+function wotsAddressData(publicKeyDigest) {
+    const raw = publicKeyDigest.replace(/^0x/i, '').toUpperCase();
+    return computeScriptAddress(`RETURN SIGNEDBY(0x${raw})`);
+}
 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);
+    return bytesToHex((0, mmr_js_1.mmrRootFromSingleLeaf)((0, canonical_js_1.toNodeScript)(script)));
 }

package/dist/cjs/transaction-json.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Compatibility adapters for the legacy JSON transaction surface.
+ *
+ * The WASM bindings are retained as `*Wasm` exports, but the public
+ * `serializeTransaction` / `precomputeTransactionCoinID` names route through
+ * the TypeScript implementation. This avoids the WASM serializer crash on
+ * token+state outputs and the incorrect coin-ID precompute semantics.
+ */
+import { bytesToHex } from './Streamable.js';
+import { type MinimaTransaction } from './transaction.js';
+/** Convert the legacy JSON transaction shape into the TS object shape. */
+export declare function minimaTransactionFromJson(json: string): MinimaTransaction;
+/** Public serializer: accepts the TS object or the legacy JSON string. */
+export declare function serializeTransaction(tx: MinimaTransaction | string): Uint8Array;
+/** Coin-ID rollover: SHA3(MiniData(coinId) || MiniNumber(index)). */
+export declare function rollCoinId(coinId: Uint8Array, outputIndex?: number): Uint8Array;
+export declare function precomputeTransactionCoinID(tx: MinimaTransaction): void;
+export declare function precomputeTransactionCoinID(tx: Uint8Array | string, outputIndex?: number): Uint8Array;
+export { bytesToHex };

package/dist/cjs/transaction-json.js

@@ -0,0 +1,114 @@
+"use strict";
+/**
+ * Compatibility adapters for the legacy JSON transaction surface.
+ *
+ * The WASM bindings are retained as `*Wasm` exports, but the public
+ * `serializeTransaction` / `precomputeTransactionCoinID` names route through
+ * the TypeScript implementation. This avoids the WASM serializer crash on
+ * token+state outputs and the incorrect coin-ID precompute semantics.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.bytesToHex = void 0;
+exports.minimaTransactionFromJson = minimaTransactionFromJson;
+exports.serializeTransaction = serializeTransaction;
+exports.rollCoinId = rollCoinId;
+exports.precomputeTransactionCoinID = precomputeTransactionCoinID;
+const Streamable_js_1 = require("./Streamable.js");
+Object.defineProperty(exports, "bytesToHex", { enumerable: true, get: function () { return Streamable_js_1.bytesToHex; } });
+const transaction_js_1 = require("./transaction.js");
+const Streamable_js_2 = require("./Streamable.js");
+const wasm_sync_js_1 = require("./wasm-sync.js");
+function bytes(value) {
+    if (!value || value === '0x')
+        return new Uint8Array([0]);
+    return (0, Streamable_js_1.hexToBytes)(value);
+}
+function evenHex(value) {
+    const raw = value.trim().replace(/^0x/i, '');
+    return '0x' + (raw.length % 2 === 0 ? raw : `0${raw}`);
+}
+function stateVariables(input) {
+    return (input ?? []).map((sv) => {
+        const rawType = (sv.svtype ?? sv.type ?? '').toLowerCase();
+        if (rawType === 'bool' || rawType === 'boolean') {
+            return { port: sv.port, type: 'bool', value: sv.data === 'true' || sv.data === '1' || sv.data === '01' };
+        }
+        if (rawType === 'number')
+            return { port: sv.port, type: 'number', value: sv.data };
+        if (rawType === 'string')
+            return { port: sv.port, type: 'string', value: sv.data };
+        return { port: sv.port, type: 'hex', value: evenHex(sv.data) };
+    });
+}
+function token(input) {
+    if (!input)
+        return null;
+    const parsed = (0, transaction_js_1.parseDecimalToMiniNumber)(input.totalamount ?? '0');
+    return {
+        coinId: bytes(input.coinid),
+        scale: Number(input.scale ?? 0),
+        totalAmount: parsed.unscaledValue,
+        totalAmountScale: parsed.scale,
+        name: new TextEncoder().encode(input.name ?? ''),
+        script: bytes(input.script),
+        created: BigInt(input.created ?? '0'),
+    };
+}
+function coin(input) {
+    return {
+        coinId: bytes(input.coinid),
+        address: bytes(input.address),
+        amount: input.amount,
+        tokenId: bytes(input.tokenid),
+        token: token(input.token),
+        storeState: input.storestate ?? false,
+        state: stateVariables(input.state),
+        mmrEntryNumber: BigInt(input.mmrentry ?? '0'),
+        spent: input.spent ?? false,
+        created: BigInt(input.created ?? '0'),
+    };
+}
+/** Convert the legacy JSON transaction shape into the TS object shape. */
+function minimaTransactionFromJson(json) {
+    const parsed = JSON.parse(json);
+    return {
+        inputs: (parsed.inputs ?? []).map(coin),
+        outputs: (parsed.outputs ?? []).map(coin),
+        state: stateVariables(parsed.state),
+        linkHash: bytes(parsed.linkhash ?? '0x00'),
+    };
+}
+/** Public serializer: accepts the TS object or the legacy JSON string. */
+function serializeTransaction(tx) {
+    const value = typeof tx === 'string' ? minimaTransactionFromJson(tx) : tx;
+    return (0, transaction_js_1.serializeTransaction)(value);
+}
+/** Coin-ID rollover: SHA3(MiniData(coinId) || MiniNumber(index)). */
+function rollCoinId(coinId, outputIndex = 0) {
+    return (0, wasm_sync_js_1.sha3_256)((0, Streamable_js_2.concat)((0, Streamable_js_2.writeMiniData)(coinId), (0, Streamable_js_2.writeMiniNumber)(BigInt(outputIndex), 0)));
+}
+function precomputeTransactionCoinID(tx, outputIndex = 0) {
+    if (typeof tx === 'object' && !(tx instanceof Uint8Array)) {
+        (0, transaction_js_1.precomputeTransactionCoinID)(tx);
+        return;
+    }
+    if (typeof tx === 'string') {
+        const value = minimaTransactionFromJson(tx);
+        (0, transaction_js_1.precomputeTransactionCoinID)(value);
+        return value.outputs[outputIndex]?.coinId ?? new Uint8Array();
+    }
+    // Legacy callers pass either a 32-byte input coin ID (rollover) or serialized
+    // transaction bytes (output coin ID). Prefer the transaction interpretation,
+    // but fall back to coin-ID rollover for a bare 32-byte value.
+    try {
+        const value = (0, transaction_js_1.deserializeTransaction)(tx);
+        if (value.inputs.length > 0) {
+            (0, transaction_js_1.precomputeTransactionCoinID)(value);
+            return value.outputs[outputIndex]?.coinId ?? new Uint8Array();
+        }
+    }
+    catch {
+        // not a serialized transaction
+    }
+    return rollCoinId(tx, outputIndex);
+}

package/dist/cjs/wasm-sync.d.ts

@@ -69,3 +69,13 @@ export declare function wotsKeypairFromSeed(seed: Uint8Array, index: number): {
     index: number;
     pk: Uint8Array;
 };
+/**
+ * Compatibility initializer for the synchronous bridge.
+ *
+ * The CJS/sync build has already instantiated WASM at module load; this exists
+ * so the public ESM and CJS APIs expose the same `init()` contract. The ESM
+ * build rewrites this module to `wasm-async.js`, where init is the real
+ * wasm-bindgen initializer.
+ */
+export declare function init(): Promise<void>;
+export declare function initSync(): void;

package/dist/cjs/wasm-sync.js

@@ -16,6 +16,8 @@ exports.createChallenge = createChallenge;
 exports.validateChallenge = validateChallenge;
 exports.writeMiniNumber = writeMiniNumber;
 exports.wotsKeypairFromSeed = wotsKeypairFromSeed;
+exports.init = init;
+exports.initSync = initSync;
 // The bundler target initializes WASM synchronously at import time.
 // The nodejs target uses require() which is also synchronous.
 // Both targets export functions that are ready to call immediately.
@@ -102,3 +104,17 @@ function wotsKeypairFromSeed(seed, index) {
     const pk = (0, core_wasm_1.derive_pk_digest_wasm)(seed, index);
     return { seed, index, pk };
 }
+/**
+ * Compatibility initializer for the synchronous bridge.
+ *
+ * The CJS/sync build has already instantiated WASM at module load; this exists
+ * so the public ESM and CJS APIs expose the same `init()` contract. The ESM
+ * build rewrites this module to `wasm-async.js`, where init is the real
+ * wasm-bindgen initializer.
+ */
+async function init() {
+    // no-op: the synchronous bridge is initialized at import time
+}
+function initSync() {
+    // no-op: the synchronous bridge is initialized at import time
+}

package/dist/index.d.ts

@@ -14,12 +14,13 @@ export { bytesToHex, hexToBytes, concatBytes } from './bytes.js';
 export { sha3_256 } from './wasm-sync.js';
 export { expandPrivateKey, hashChain, derivePKdigest, deriveFullPublicKey, wotsSign, wotsVerify, wotsVerifyDigest, wotsPkFromSig, wotsPublicKeyFromSeed, wotsKeypairFromSeed, } from './wasm-sync.js';
 export * from './params.js';
-export { deriveChainSeedJava, derivePerAddressSeed, deriveRootPrivSeed, writeMiniNumber, writeMiniData, writeMiniString, precomputeTransactionCoinID, } from './wasm-sync.js';
+export { deriveChainSeedJava, derivePerAddressSeed, deriveRootPrivSeed, writeMiniNumber, writeMiniData, writeMiniString, init, initSync, } from './wasm-sync.js';
 export { createUnifiedChildTreeKey, createUnifiedRootTreeKey, deriveUnifiedAddressPublicKey, verifyTreeSignature, } from './treekey.js';
 export { mmrRootFromPublicKeys, verifyMMRProof, } from './wasm-sync.js';
 export { phraseToSeed, generateWordList, validatePhrase, cleanSeedPhrase, } from './bip39.js';
 export { makeMxAddress, parseMxAddress, wotsAddressFromKeypair, } from './wasm-sync.js';
-export { serializeTransaction, computeTransactionDigest, } from './wasm-sync.js';
+export { serializeTransaction, precomputeTransactionCoinID, rollCoinId, minimaTransactionFromJson, } from './transaction-json.js';
+export { serializeTransaction as serializeTransactionWasm, precomputeTransactionCoinID as precomputeTransactionCoinIDWasm, computeTransactionDigest, } from './wasm-sync.js';
 export { deserializeTransaction } from './transaction.js';
 export { timingSafeEqual, createChallenge, validateChallenge, } from './wasm-sync.js';
 export { scriptFromWotsPk } from './script.js';
@@ -28,6 +29,7 @@ export { makeMxAddress as encodeMx, parseMxAddress as decodeMx } from './wasm-sy
 export declare function mxToHex(address: string): string;
 export * from './mmr.js';
 export * from './scripts/index.js';
+export { toNodeScript } from './scripts/canonical.js';
 export { scriptToAddress, addressToRoot } from './derive.js';
 export { WORD_LIST, convertStringToSeed, convertWordListToSeed, generateSeedPhrase, } from './bip39.js';
 export { MiniNumber } from './MiniNumber.js';

package/dist/index.js

@@ -27,7 +27,7 @@ export { expandPrivateKey, hashChain, derivePKdigest, deriveFullPublicKey, wotsS
 // WOTS Params (from params.ts — constants, no crypto)
 export * from './params.js';
 // Java-Compatible Serialization
-export { deriveChainSeedJava, derivePerAddressSeed, deriveRootPrivSeed, writeMiniNumber, writeMiniData, writeMiniString, precomputeTransactionCoinID, } from './wasm-async.js';
+export { deriveChainSeedJava, derivePerAddressSeed, deriveRootPrivSeed, writeMiniNumber, writeMiniData, writeMiniString, init, initSync, } from './wasm-async.js';
 // TreeKey/TreeKeyNode — WASM-backed
 // createUnifiedChildTreeKey / createUnifiedRootTreeKey come from the TS
 // implementation (returning a full TreeKey object with setUses/sign/getPublicKey)
@@ -45,7 +45,11 @@ export { phraseToSeed, generateWordList, validatePhrase, cleanSeedPhrase, } from
 // Address Derivation
 export { makeMxAddress, parseMxAddress, wotsAddressFromKeypair, } from './wasm-async.js';
 // Transaction Serialization & Digest
-export { serializeTransaction, computeTransactionDigest, } from './wasm-async.js';
+// Public names route through the TypeScript implementation. The WASM bindings
+// remain available explicitly for parity tests and legacy callers that
+// intentionally want the byte-level WASM surface.
+export { serializeTransaction, precomputeTransactionCoinID, rollCoinId, minimaTransactionFromJson, } from './transaction-json.js';
+export { serializeTransaction as serializeTransactionWasm, precomputeTransactionCoinID as precomputeTransactionCoinIDWasm, computeTransactionDigest, } from './wasm-async.js';
 // Transaction deserialization (byte-exact inverse of the TS serializer)
 export { deserializeTransaction } from './transaction.js';
 // Verification
@@ -68,6 +72,7 @@ export function mxToHex(address) {
 export * from './mmr.js';
 // Script Types, Witness Serializer, Contract Helpers
 export * from './scripts/index.js';
+export { toNodeScript } from './scripts/canonical.js';
 // Address Derivation (original)
 export { scriptToAddress, addressToRoot } from './derive.js';
 // BIP39 — re-export word list and legacy helpers from JS

package/dist/mmr.d.ts

@@ -16,6 +16,28 @@ export type Bytes = Uint8Array;
 export declare function mmrLeafExact(script: string): Bytes;
 /** In a single-leaf MMR the root equals the leaf commitment. */
 export declare function mmrRootFromSingleLeaf(script: string): Bytes;
+/**
+ * Build the serialized Minima `ScriptProof` bytes for a single-leaf MMR.
+ *
+ * Mirrors the node's `ScriptProof(const std::string& zScript)` constructor
+ * (org/minima/objects/script_proof.cpp): the script is added as the sole leaf
+ * of a fresh MMR with sum value ZERO, so the proof chain is empty and the
+ * resulting address is the leaf commitment itself:
+ *
+ *   address = sha3( MiniNumber.ZERO || MiniString(script) || MiniNumber.ZERO )
+ *           = mmrLeafExact(script)
+ *
+ * This is exactly how the node derives `Address(script)`, so a witness carrying
+ * this proof satisfies `Witness::getScript(input.getAddress())` for every input
+ * paying to that script. Without it the node rejects the TxPoW with
+ * "Script Missing from TxPoW for address <addr>".
+ *
+ * Wire format (`ScriptProof::writeDataStream`):
+ *   MiniString(script) || MMRProof(blockTime = 0, chunks = [])
+ *
+ * @param script - The Minima (KISSVM) script whose address the proof attests.
+ */
+export declare function buildScriptProof(script: string): Bytes;
 /**
  * MMRData structure matching Minima's MMRData.java
  * Contains hash and value (for sum tree functionality)

package/dist/mmr.js

@@ -3,7 +3,10 @@
 import { sha3_256 as nobleSha3 } from './wasm-async.js';
 import { serializeMiniNumber, serializeMiniData, javaHashAllObjects } from "./javaStreamables.js";
 // Import canonical wire serialization from Streamable.ts (single source of truth)
-import { writeMMRProof } from "./Streamable.js";
+import { writeMMRProof, writeMiniString } from "./Streamable.js";
+// Canonicalise to the exact script the node will receive, so the proof's
+// computed address matches `computeScriptAddress` (which canonicalises too).
+import { toNodeScript } from "./scripts/canonical.js";
 // Re-export for API compatibility (existing code imports from mmr.ts)
 // Using a wrapper function for better compatibility with dynamic imports
 export function serializeMMRProof(proof, blockTime = 0n) {
@@ -69,6 +72,35 @@ export function mmrLeafExact(script) {
 export function mmrRootFromSingleLeaf(script) {
     return mmrLeafExact(script);
 }
+/**
+ * Build the serialized Minima `ScriptProof` bytes for a single-leaf MMR.
+ *
+ * Mirrors the node's `ScriptProof(const std::string& zScript)` constructor
+ * (org/minima/objects/script_proof.cpp): the script is added as the sole leaf
+ * of a fresh MMR with sum value ZERO, so the proof chain is empty and the
+ * resulting address is the leaf commitment itself:
+ *
+ *   address = sha3( MiniNumber.ZERO || MiniString(script) || MiniNumber.ZERO )
+ *           = mmrLeafExact(script)
+ *
+ * This is exactly how the node derives `Address(script)`, so a witness carrying
+ * this proof satisfies `Witness::getScript(input.getAddress())` for every input
+ * paying to that script. Without it the node rejects the TxPoW with
+ * "Script Missing from TxPoW for address <addr>".
+ *
+ * Wire format (`ScriptProof::writeDataStream`):
+ *   MiniString(script) || MMRProof(blockTime = 0, chunks = [])
+ *
+ * @param script - The Minima (KISSVM) script whose address the proof attests.
+ */
+export function buildScriptProof(script) {
+    // The node derives the proof's address as
+    //   sha3( MiniNumber.ZERO || MiniString(script) || MiniNumber.ZERO )
+    // so the script bytes here must be exactly the canonical script whose address
+    // was used for the coin (see computeScriptAddress).
+    const canonical = toNodeScript(script);
+    return concat(writeMiniString(canonical), serializeMMRProof({ chunks: [] }, 0n));
+}
 /**
  * Create MMRData leaf node matching Minima's MMRData.CreateMMRDataLeafNode
  *

package/dist/scripts/canonical.d.ts

@@ -0,0 +1,20 @@
+/**
+ * `toNodeScript` — canonicalize a KISSVM script to the syntax the Minima **node**
+ * tokenizer accepts (RFC-048 §3.1 L4 finding; audit
+ * `docs/audits/kissvm-node-validity-l4-2026-10.md`).
+ *
+ * The node tokenizer requires:
+ *   - user variable names `^[a-z]+$` (lowercase letters only — no digits/underscores/uppercase),
+ *   - hex literals `^0x[0-9a-fA-F]+$` (lowercase `0x` prefix),
+ *   - arithmetic via the `+` / `-` operators (`ADD`/`SUB` are not node functions).
+ *
+ * This is a token-level rewrite: commands, functions, operators, globals (`@…`), hex
+ * literals, numbers and `[…]` string literals are preserved; only **user identifiers**
+ * are rewritten to lowercase letters (with deterministic de-collision), `0X`→`0x`, and
+ * `ADD`/`SUB`→`+`/`-`. It is idempotent.
+ *
+ * Semantics are unchanged: the SDK evaluators normalize `+`→ADD and `-`→SUB (and vice
+ * versa), so a canonical script behaves identically to its source.
+ */
+/** Canonicalize a KISSVM script to node-accepted syntax. Idempotent. */
+export declare function toNodeScript(script: string): string;

package/dist/scripts/canonical.js

@@ -0,0 +1,96 @@
+/**
+ * `toNodeScript` — canonicalize a KISSVM script to the syntax the Minima **node**
+ * tokenizer accepts (RFC-048 §3.1 L4 finding; audit
+ * `docs/audits/kissvm-node-validity-l4-2026-10.md`).
+ *
+ * The node tokenizer requires:
+ *   - user variable names `^[a-z]+$` (lowercase letters only — no digits/underscores/uppercase),
+ *   - hex literals `^0x[0-9a-fA-F]+$` (lowercase `0x` prefix),
+ *   - arithmetic via the `+` / `-` operators (`ADD`/`SUB` are not node functions).
+ *
+ * This is a token-level rewrite: commands, functions, operators, globals (`@…`), hex
+ * literals, numbers and `[…]` string literals are preserved; only **user identifiers**
+ * are rewritten to lowercase letters (with deterministic de-collision), `0X`→`0x`, and
+ * `ADD`/`SUB`→`+`/`-`. It is idempotent.
+ *
+ * Semantics are unchanged: the SDK evaluators normalize `+`→ADD and `-`→SUB (and vice
+ * versa), so a canonical script behaves identically to its source.
+ */
+const KEYWORDS = new Set([
+    'LET', 'IF', 'THEN', 'ELSE', 'ELSEIF', 'ENDIF', 'RETURN', 'ASSERT', 'EXEC', 'MAST',
+    'WHILE', 'DO', 'ENDWHILE', 'FOR', 'TO', 'BY', 'ENDFOR', 'FOREACH', 'IN', 'SWITCH',
+    'CASE', 'DEFAULT', 'ENDSWITCH', 'FUNC', 'ENDFUNC', 'TRUE', 'FALSE', 'STORE', 'WITH', 'FUNCTION', 'RETURN',
+]);
+// Word operators kept as-is (ADD/SUB are handled separately → +/−).
+const OPS = new Set([
+    'GT', 'LT', 'EQ', 'GTE', 'LTE', 'NEQ', 'AND', 'OR', 'XOR', 'NAND', 'NOR', 'NXOR',
+    'NOT', 'NEG', 'MUL', 'DIV', 'MOD', 'LSHIFT', 'RSHIFT', 'BITAND', 'BITOR', 'BITXOR', 'BITNOT',
+]);
+const FUNCTIONS = new Set([
+    'SHA3', 'SHA2', 'HASH', 'PROOF', 'SIGNEDBY', 'MULTISIG', 'CHECKSIG', 'VERIFYOUT', 'VERIFYIN',
+    'GETOUTADDR', 'GETOUTAMT', 'GETOUTTOK', 'GETOUTKEEPSTATE', 'GETINADDR', 'GETINAMT', 'GETINID',
+    'GETINTOK', 'STATE', 'PREVSTATE', 'SAMESTATE', 'SAMECOINS', 'COINAGE', 'COINDATA', 'NUMBER',
+    'HEX', 'STRING', 'ASCII', 'UTF8', 'BOOL', 'CONCAT', 'LEN', 'REV', 'SUBSET', 'SETLEN',
+    'SUBSTR', 'REPLACE', 'REPLACEFIRST', 'OVERWRITE', 'ABS', 'CEIL', 'FLOOR', 'MAX', 'MIN',
+    'DEC', 'INC', 'SIGDIG', 'POW', 'SQRT', 'BITSET', 'BITGET', 'BITCOUNT', 'ADDRESS', 'EXISTS',
+    'GET', 'SUMINPUTS', 'SUMOUTPUTS', 'CHECKSIG',
+]);
+function classify(id) {
+    const up = id.toUpperCase();
+    if (up === 'ADD')
+        return { kind: 'keep', out: '+' };
+    if (up === 'SUB')
+        return { kind: 'keep', out: '-' };
+    if (KEYWORDS.has(up) || OPS.has(up) || FUNCTIONS.has(up))
+        return { kind: 'keep', out: up };
+    return { kind: 'var' };
+}
+/** a, b, …, z, aa, ab, … */
+function letters(n) {
+    let s = '';
+    n += 1;
+    while (n > 0) {
+        const r = (n - 1) % 26;
+        s = String.fromCharCode(97 + r) + s;
+        n = Math.floor((n - 1) / 26);
+    }
+    return s;
+}
+const TOKEN = /(\[[^\]]*\]|0[xX][0-9a-fA-F]+|@[A-Za-z][A-Za-z0-9]*|[A-Za-z_][A-Za-z0-9_]*)/g;
+/** Canonicalize a KISSVM script to node-accepted syntax. Idempotent. */
+export function toNodeScript(script) {
+    // The node tokenizer has no comment syntax; strip `//` line comments.
+    script = script.replace(/\/\/[^\n]*/g, '');
+    const varMap = new Map();
+    const used = new Set();
+    // First pass: assign canonical names to user variables (in first-occurrence order).
+    let m;
+    const re1 = new RegExp(TOKEN.source, 'g');
+    while ((m = re1.exec(script))) {
+        const tok = m[0];
+        if (tok[0] === '[' || tok.startsWith('0x') || tok.startsWith('0X') || tok[0] === '@')
+            continue;
+        if (classify(tok).kind !== 'var' || varMap.has(tok))
+            continue;
+        const base = tok.toLowerCase().replace(/[^a-z]/g, '') || 'v';
+        let cand = base;
+        let i = 0;
+        while (used.has(cand))
+            cand = base + letters(i++);
+        used.add(cand);
+        varMap.set(tok, cand);
+    }
+    // Second pass: rewrite.
+    return script.replace(TOKEN, (tok) => {
+        if (tok[0] === '[')
+            return tok;
+        if (tok.startsWith('0x') || tok.startsWith('0X'))
+            return '0x' + tok.slice(2);
+        if (tok[0] === '@')
+            return '@' + tok.slice(1).toUpperCase();
+        const c = classify(tok);
+        if (c.kind === 'keep')
+            return c.out;
+        return varMap.get(tok) ?? tok;
+    });
+}

package/dist/scripts/index.d.ts

@@ -1,4 +1,5 @@
 export * from './types.js';
 export * from './dapp-types.js';
-export { encodeMiniNumber, encodeMiniData, encodeMiniString, serializeMMRProofChunk, serializeScriptProofWithProof, STATETYPE_HEX, STATETYPE_NUMBER, STATETYPE_STRING, STATETYPE_BOOL, encodeStateValue, serializeStateVariables, buildScriptProofFromDescriptor, deduplicateScriptDescriptors, serializeExtraScripts, aggregateSignatures, validateExternalSignature, computeScriptAddress, } from './witness-serializer.js';
+export { encodeMiniNumber, encodeMiniData, encodeMiniString, serializeMMRProofChunk, serializeScriptProofWithProof, STATETYPE_HEX, STATETYPE_NUMBER, STATETYPE_STRING, STATETYPE_BOOL, encodeStateValue, serializeStateVariables, buildScriptProofFromDescriptor, deduplicateScriptDescriptors, serializeExtraScripts, aggregateSignatures, validateExternalSignature, computeScriptAddress, wotsAddressData, } from './witness-serializer.js';
 export * from './contract-helpers.js';
+export { toNodeScript } from "./canonical.js";

package/dist/scripts/index.js

@@ -1,4 +1,5 @@
 export * from './types.js';
 export * from './dapp-types.js';
-export { encodeMiniNumber, encodeMiniData, encodeMiniString, serializeMMRProofChunk, serializeScriptProofWithProof, STATETYPE_HEX, STATETYPE_NUMBER, STATETYPE_STRING, STATETYPE_BOOL, encodeStateValue, serializeStateVariables, buildScriptProofFromDescriptor, deduplicateScriptDescriptors, serializeExtraScripts, aggregateSignatures, validateExternalSignature, computeScriptAddress, } from './witness-serializer.js';
+export { encodeMiniNumber, encodeMiniData, encodeMiniString, serializeMMRProofChunk, serializeScriptProofWithProof, STATETYPE_HEX, STATETYPE_NUMBER, STATETYPE_STRING, STATETYPE_BOOL, encodeStateValue, serializeStateVariables, buildScriptProofFromDescriptor, deduplicateScriptDescriptors, serializeExtraScripts, aggregateSignatures, validateExternalSignature, computeScriptAddress, wotsAddressData, } from './witness-serializer.js';
 export * from './contract-helpers.js';
+export { toNodeScript } from "./canonical.js";

package/dist/scripts/witness-serializer.d.ts

@@ -25,5 +25,24 @@ export declare function aggregateSignatures(totemSignature: {
     signature: Uint8Array;
 }, externalSignatures: ExternalSignature[], transactionDigest: Uint8Array): Uint8Array[];
 export declare function validateExternalSignature(signature: ExternalSignature, transactionDigest: Uint8Array): boolean;
+/**
+ * Derive a Minima script address exactly as the node does
+ * (`Address::Address(script)` / `ScriptProof::calculateAddress`):
+ *
+ *   address = sha3( MiniNumber.ZERO || MiniString(script) || MiniNumber.ZERO )
+ *
+ * The script is first canonicalised (`toNodeScript`) so the address is over the
+ * same bytes the node will execute and that `buildScriptProof` attests. The
+ * previous implementation hashed `sha3(upper(script))`, which is not a Minima
+ * script address — coins sent to it could never be spent by that script
+ * ("Script Missing from TxPoW for address …").
+ */
+/**
+ * Address data (hex) of a WOTS public-key digest's single-key script
+ * (`RETURN SIGNEDBY(0x<pk>)`). This is the value a `VERIFYOUT` compares against
+ * (the node compares the output coin's *address data*), distinct from the WOTS
+ * public key used by `SIGNEDBY`.
+ */
+export declare function wotsAddressData(publicKeyDigest: string): string;
 export declare function computeScriptAddress(script: string): string;
 export { concat };

package/dist/scripts/witness-serializer.js

@@ -1,6 +1,6 @@
-import { sha3_256 } from '../wasm-async.js';
+import { toNodeScript } from './canonical.js';
 import { wotsVerifyDigest } from '../wots.js';
-import { serializeMMRProof } from '../mmr.js';
+import { serializeMMRProof, mmrRootFromSingleLeaf } from '../mmr.js';
 import { mxToHex } from '../minima32.js';
 function hexToBytes(hex) {
     const cleanHex = hex.startsWith('0x') ? hex.slice(2) : hex;
@@ -302,10 +302,29 @@ export function validateExternalSignature(signature, transactionDigest) {
         return false;
     }
 }
+/**
+ * Derive a Minima script address exactly as the node does
+ * (`Address::Address(script)` / `ScriptProof::calculateAddress`):
+ *
+ *   address = sha3( MiniNumber.ZERO || MiniString(script) || MiniNumber.ZERO )
+ *
+ * The script is first canonicalised (`toNodeScript`) so the address is over the
+ * same bytes the node will execute and that `buildScriptProof` attests. The
+ * previous implementation hashed `sha3(upper(script))`, which is not a Minima
+ * script address — coins sent to it could never be spent by that script
+ * ("Script Missing from TxPoW for address …").
+ */
+/**
+ * Address data (hex) of a WOTS public-key digest's single-key script
+ * (`RETURN SIGNEDBY(0x<pk>)`). This is the value a `VERIFYOUT` compares against
+ * (the node compares the output coin's *address data*), distinct from the WOTS
+ * public key used by `SIGNEDBY`.
+ */
+export function wotsAddressData(publicKeyDigest) {
+    const raw = publicKeyDigest.replace(/^0x/i, '').toUpperCase();
+    return computeScriptAddress(`RETURN SIGNEDBY(0x${raw})`);
+}
 export function computeScriptAddress(script) {
-    const cleanScript = script.trim().toUpperCase();
-    const scriptBytes = new TextEncoder().encode(cleanScript);
-    const hashBytes = sha3_256(scriptBytes);
-    return bytesToHex(hashBytes);
+    return bytesToHex(mmrRootFromSingleLeaf(toNodeScript(script)));
 }
 export { concat };

package/dist/transaction-json.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Compatibility adapters for the legacy JSON transaction surface.
+ *
+ * The WASM bindings are retained as `*Wasm` exports, but the public
+ * `serializeTransaction` / `precomputeTransactionCoinID` names route through
+ * the TypeScript implementation. This avoids the WASM serializer crash on
+ * token+state outputs and the incorrect coin-ID precompute semantics.
+ */
+import { bytesToHex } from './Streamable.js';
+import { type MinimaTransaction } from './transaction.js';
+/** Convert the legacy JSON transaction shape into the TS object shape. */
+export declare function minimaTransactionFromJson(json: string): MinimaTransaction;
+/** Public serializer: accepts the TS object or the legacy JSON string. */
+export declare function serializeTransaction(tx: MinimaTransaction | string): Uint8Array;
+/** Coin-ID rollover: SHA3(MiniData(coinId) || MiniNumber(index)). */
+export declare function rollCoinId(coinId: Uint8Array, outputIndex?: number): Uint8Array;
+export declare function precomputeTransactionCoinID(tx: MinimaTransaction): void;
+export declare function precomputeTransactionCoinID(tx: Uint8Array | string, outputIndex?: number): Uint8Array;
+export { bytesToHex };