@totemsdk/core 1.2.11 → 1.4.0

package/dist/cjs/wasm-sync.js

@@ -10,8 +10,10 @@
  *   const sig = wotsSign(seed, 0, message); // synchronous!
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.wasmTreeKeyFree = exports.wasmTreeKeyGetMaxUses = exports.wasmTreeKeySetUses = exports.wasmTreeKeyGetUses = exports.wasmTreeKeyGetPublicKey = exports.wasmTreeKeySign = exports.wasmTreeKeyNew = exports.mineTxPoWChunk = exports.mineTxPoW = exports.deriveFullPublicKeyBatch = exports.derivePKdigestBatch = exports.wotsSignBatch = exports.getParams = exports.verifyMMRProof = exports.mmrRootFromPublicKeys = exports.deriveUnifiedAddressPublicKey = exports.createUnifiedRootTreeKey = exports.createUnifiedChildTreeKey = exports.writeMiniString = exports.writeMiniData = exports.validateChallenge = exports.createChallenge = exports.timingSafeEqual = exports.verifyTreeSignature = exports.precomputeTransactionCoinID = exports.computeTransactionDigest = exports.serializeTransaction = exports.parseMxAddress = exports.makeMxAddress = exports.cleanSeedPhrase = exports.validatePhrase = exports.generateWordList = exports.phraseToSeed = exports.deriveRootPrivSeed = exports.derivePerAddressSeed = exports.deriveChainSeedJava = exports.wotsPublicKeyFromSeed = exports.wotsPkFromSig = exports.wotsVerifyDigest = exports.wotsVerify = exports.wotsSign = exports.deriveFullPublicKey = exports.derivePKdigest = exports.hashChain = exports.expandPrivateKey = exports.sha3_256 = exports.concatBytes = exports.hexToBytes = exports.bytesToHex = void 0;
+exports.wasmTreeKeyFree = exports.wasmTreeKeyGetMaxUses = exports.wasmTreeKeySetUses = exports.wasmTreeKeyGetUses = exports.wasmTreeKeyGetPublicKey = exports.wasmTreeKeySign = exports.wasmTreeKeyNew = exports.mineTxPoWChunk = exports.mineTxPoW = exports.deriveFullPublicKeyBatch = exports.derivePKdigestBatch = exports.wotsSignBatch = exports.getParams = exports.verifyMMRProof = exports.mmrRootFromPublicKeys = exports.deriveUnifiedAddressPublicKey = exports.createUnifiedRootTreeKey = exports.createUnifiedChildTreeKey = exports.writeMiniString = exports.writeMiniData = exports.timingSafeEqual = exports.verifyTreeSignature = exports.precomputeTransactionCoinID = exports.computeTransactionDigest = exports.serializeTransaction = exports.parseMxAddress = exports.makeMxAddress = exports.cleanSeedPhrase = exports.validatePhrase = exports.generateWordList = exports.phraseToSeed = exports.deriveRootPrivSeed = exports.derivePerAddressSeed = exports.deriveChainSeedJava = exports.wotsPublicKeyFromSeed = exports.wotsPkFromSig = exports.wotsVerifyDigest = exports.wotsVerify = exports.wotsSign = exports.deriveFullPublicKey = exports.derivePKdigest = exports.hashChain = exports.expandPrivateKey = exports.sha3_256 = exports.concatBytes = exports.hexToBytes = exports.bytesToHex = void 0;
 exports.wotsAddressFromKeypair = wotsAddressFromKeypair;
+exports.createChallenge = createChallenge;
+exports.validateChallenge = validateChallenge;
 exports.writeMiniNumber = writeMiniNumber;
 exports.wotsKeypairFromSeed = wotsKeypairFromSeed;
 // The bundler target initializes WASM synchronously at import time.
@@ -55,8 +57,13 @@ exports.computeTransactionDigest = core_wasm_1.compute_transaction_digest_wasm;
 exports.precomputeTransactionCoinID = core_wasm_1.precompute_transaction_coin_id_wasm;
 exports.verifyTreeSignature = core_wasm_1.verify_tree_signature_wasm;
 exports.timingSafeEqual = core_wasm_1.timing_safe_equal_wasm;
-exports.createChallenge = core_wasm_1.create_challenge_wasm;
-exports.validateChallenge = core_wasm_1.validate_challenge_wasm;
+// SystemTime panics on wasm32-unknown-unknown; supply the clock from JS.
+function createChallenge(domain, statement) {
+    return (0, core_wasm_1.create_challenge_wasm)(domain, statement, Math.floor(Date.now() / 1000));
+}
+function validateChallenge(challengeJson, domain) {
+    return (0, core_wasm_1.validate_challenge_wasm)(challengeJson, domain, Math.floor(Date.now() / 1000));
+}
 function writeMiniNumber(value, scale = 0) {
     return (0, core_wasm_1.write_mini_number_wasm)(value.toString(), scale);
 }

package/dist/index.d.ts

@@ -10,7 +10,7 @@ export * from './adapters/index.js';
 export { LeaseStore, WatermarkStore, LeaseMonitor, prepareLease, finalizeLease, flatIndexFromLanes, type StoredLease, type LeaseStatus, type LeaseStoreConfig, type LeaseWotsIndices, type WatermarkState, type SyncResult, type WatermarkStoreConfig, type LeaseExpiryEvent, type LeaseExpiryCallback, type LeaseMonitorConfig, type PrepareArgs, type PrepareResp, } from './lease/index.js';
 export { TransactionService, TransactionLifecycle, TransactionLifecycleError, WatermarkExhaustedError, TransactionReceiptStore, type TransactionServiceConfig, type WotsSigningDependencies, type TransactionLifecycleConfig, type WatermarkSyncFunction, type PrepareResult, type TransactionReceiptStoreConfig, type PrepareRequest, type PrepareResponse, type SignRequest, type SignResult, type HierarchicalWitnessBundle, type WitnessBundle, type FinalizeRequest, type FinalizeResponse, type TransactionMetadata, type TransactionReceipt, type TransactionError, } from './tx/index.js';
 export type { WotsIndices } from './tx/index.js';
-export { bytesToHex, hexToBytes, concatBytes } from './wasm-sync.js';
+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';
@@ -28,17 +28,20 @@ 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';
 export { type MinimaTransaction, type MinimaCoin, type ParsedMiniNumber, type MinimaToken, type StateVariable, type RawStateVariable, type CoinProofData, type SpendableCoinInput, type TransactionBuildResult, parseDecimalToMiniNumber, serializeCoin, serializeTransaction as serializeTransactionObject, computeTokenId, serializeTokenDescriptor, createDefaultTransaction, buildMinimaCoin, } from './transaction.js';
 export { verifySignature, verifySignatureDetailed, verifyTreeSignatureDetailed, deriveAddressFromPublicKey, normalizeHex, type VerificationResult, } from './verify.js';
+export { deriveDeterministicAddress, deriveUnifiedAddress, deriveAddress, verifyDeterministicAddress, type AddressScheme, type DerivedAddress, } from './address-derivation.js';
 export { writeMiniByte, writeMMREntryNumber, writeSignature, writeSignatureProof, concat, bigIntToByteArray, type Bytes, } from './Streamable.js';
 export { serializeMiniNumber, serializeMiniData, hashAllObjects, deriveChildTreeSeedJava, hashObject, serializeMiniNumberZERO, serializeMiniNumberONE, writeHashToStream, javaHashAllObjects, indexToMiniDataBytes, deriveUnifiedChildSeed, createMMREntryNumber, serializeMMREntryNumber, serializeMMRData, serializeMMREntry, type MMREntryNumber as JavaMMREntryNumber, type MMRData as JavaMMRData, type MMREntry as JavaMMREntry, } from './javaStreamables.js';
 export { TreeKey, TreeKeyNode, serializeTreeSignature, deserializeTreeSignature, getRootPublicKey, DEFAULT_KEYS_PER_LEVEL, DEFAULT_LEVELS, createUnifiedChildTreeKeyAsync, createPerAddressTreeKey, createPerAddressTreeKeyAsync, setTreeKeyLogger, disableTreeKeyLogger, type KeyGenProgress, type ProgressCallback, type SignatureProof, type TreeSignature, } from './treekey.js';
 export type { WotsKeypair, WotsSignature } from './wots.js';
 export { F, hex, fromHex, setWotsLogger, disableWotsLogger, u16be, u32be, assert32, h, prfChainSeed, toWinternitzDigits, baseWWithChecksum, wotsSignLegacy, } from './wots.js';
-export { toHex, canonicalJson, hashCanonical } from './canonical.js';
+export { toHex, canonicalJson } from './canonical.js';
+export { hashCanonical } from './canonical-hash.js';
 export { utf8ToBytes, bytesToUtf8 } from './utils.js';
 export declare const MINIMA_CONSTANTS: {
     readonly WOTS_W: 8;

package/dist/index.js

@@ -17,23 +17,24 @@ export { TransactionService, TransactionLifecycle, TransactionLifecycleError, Wa
 // Cryptographic primitives — backed by Rust/WASM (@totemsdk/core-wasm)
 // ---------------------------------------------------------------------------
 // Utilities
-export { bytesToHex, hexToBytes, concatBytes } from './wasm-sync.js';
-import { bytesToHex, parseMxAddress } from './wasm-sync.js';
+export { bytesToHex, hexToBytes, concatBytes } from './bytes.js';
+import { bytesToHex } from './bytes.js';
+import { parseMxAddress } from './wasm-async.js';
 // SHA3-256
-export { sha3_256 } from './wasm-sync.js';
+export { sha3_256 } from './wasm-async.js';
 // WOTS Signatures
-export { expandPrivateKey, hashChain, derivePKdigest, deriveFullPublicKey, wotsSign, wotsVerify, wotsVerifyDigest, wotsPkFromSig, wotsPublicKeyFromSeed, wotsKeypairFromSeed, } from './wasm-sync.js';
+export { expandPrivateKey, hashChain, derivePKdigest, deriveFullPublicKey, wotsSign, wotsVerify, wotsVerifyDigest, wotsPkFromSig, wotsPublicKeyFromSeed, wotsKeypairFromSeed, } from './wasm-async.js';
 // 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-sync.js';
+export { deriveChainSeedJava, derivePerAddressSeed, deriveRootPrivSeed, writeMiniNumber, writeMiniData, writeMiniString, precomputeTransactionCoinID, } from './wasm-async.js';
 // TreeKey/TreeKeyNode — WASM-backed
 // createUnifiedChildTreeKey / createUnifiedRootTreeKey come from the TS
 // implementation (returning a full TreeKey object with setUses/sign/getPublicKey)
 // to match the object API that downstream consumers (server, root-identity)
 // rely on. The WASM binding only returns the root public key bytes.
 export { createUnifiedChildTreeKey, createUnifiedRootTreeKey, deriveUnifiedAddressPublicKey, verifyTreeSignature, } from './treekey.js';
-export { mmrRootFromPublicKeys, verifyMMRProof, } from './wasm-sync.js';
+export { mmrRootFromPublicKeys, verifyMMRProof, } from './wasm-async.js';
 // BIP39 Seed Phrase Handling
 // The WASM binding (wasm-sync.ts) shares the canonical 2048-word BIP39 list
 // and Minima-compatible uppercase canonicalization with the TS implementation
@@ -42,20 +43,20 @@ export { mmrRootFromPublicKeys, verifyMMRProof, } from './wasm-sync.js';
 // canonical source of truth and avoids double-entering the list.
 export { phraseToSeed, generateWordList, validatePhrase, cleanSeedPhrase, } from './bip39.js';
 // Address Derivation
-export { makeMxAddress, parseMxAddress, wotsAddressFromKeypair, } from './wasm-sync.js';
+export { makeMxAddress, parseMxAddress, wotsAddressFromKeypair, } from './wasm-async.js';
 // Transaction Serialization & Digest
-export { serializeTransaction, computeTransactionDigest, } from './wasm-sync.js';
+export { serializeTransaction, computeTransactionDigest, } from './wasm-async.js';
 // Transaction deserialization (byte-exact inverse of the TS serializer)
 export { deserializeTransaction } from './transaction.js';
 // Verification
-export { timingSafeEqual, createChallenge, validateChallenge, } from './wasm-sync.js';
+export { timingSafeEqual, createChallenge, validateChallenge, } from './wasm-async.js';
 // ---------------------------------------------------------------------------
 // TypeScript-only modules (no crypto — keep as-is)
 // ---------------------------------------------------------------------------
 // Script helpers (for address derivation)
 export { scriptFromWotsPk } from './script.js';
 // Base32 Encoding (Minima-compatible) — re-export from WASM
-export { makeMxAddress as encodeMx, parseMxAddress as decodeMx } from './wasm-sync.js';
+export { makeMxAddress as encodeMx, parseMxAddress as decodeMx } from './wasm-async.js';
 /** Convert an Mx (radix-32) or hex Minima address to lowercase hex. */
 export function mxToHex(address) {
     const upper = address.startsWith('0x') || address.startsWith('0X') ? address.slice(2) : address;
@@ -67,6 +68,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
@@ -77,6 +79,8 @@ export { MiniNumber } from './MiniNumber.js';
 export { parseDecimalToMiniNumber, serializeCoin, serializeTransaction as serializeTransactionObject, computeTokenId, serializeTokenDescriptor, createDefaultTransaction, buildMinimaCoin, } from './transaction.js';
 // High-level Verification API (convenience functions for integrators)
 export { verifySignature, verifySignatureDetailed, verifyTreeSignatureDetailed, deriveAddressFromPublicKey, normalizeHex, } from './verify.js';
+// Deterministic address derivation (CAN-005)
+export { deriveDeterministicAddress, deriveUnifiedAddress, deriveAddress, verifyDeterministicAddress, } from './address-derivation.js';
 // Streamable primitives (low-level serialization building blocks)
 export { writeMiniByte, writeMMREntryNumber, writeSignature, writeSignatureProof, concat, bigIntToByteArray, } from './Streamable.js';
 // Java-Compatible Serialization Helpers (non-crypto)
@@ -85,7 +89,8 @@ export { serializeMiniNumber, serializeMiniData, hashAllObjects, deriveChildTree
 export { TreeKey, TreeKeyNode, serializeTreeSignature, deserializeTreeSignature, getRootPublicKey, DEFAULT_KEYS_PER_LEVEL, DEFAULT_LEVELS, createUnifiedChildTreeKeyAsync, createPerAddressTreeKey, createPerAddressTreeKeyAsync, setTreeKeyLogger, disableTreeKeyLogger, } from './treekey.js';
 export { F, hex, fromHex, setWotsLogger, disableWotsLogger, u16be, u32be, assert32, h, prfChainSeed, toWinternitzDigits, baseWWithChecksum, wotsSignLegacy, } from './wots.js';
 // Canonical helpers (deterministic JSON + hashing)
-export { toHex, canonicalJson, hashCanonical } from './canonical.js';
+export { toHex, canonicalJson } from './canonical.js';
+export { hashCanonical } from './canonical-hash.js';
 // Byte/string utilities
 export { utf8ToBytes, bytesToUtf8 } from './utils.js';
 // Constants

package/dist/javaStreamables.js

@@ -12,7 +12,7 @@
  * NOTE: This module provides number-based wrappers for backward compatibility.
  * The canonical implementations are in Streamable.ts which uses bigint for precision.
  */
-import { sha3_256 } from './wasm-sync.js';
+import { sha3_256 } from './wasm-async.js';
 import { writeMiniNumber as streamableWriteMiniNumber, writeMiniData as streamableWriteMiniData, writeHashToStream as streamableWriteHashToStream, bigIntToByteArray } from './Streamable.js';
 /**
  * Serialize a number in MiniNumber format (Java compatible)

package/dist/legacy.d.ts

@@ -1,12 +1,21 @@
 /**
- * Legacy JS implementations — backward compatibility.
+ * Legacy JS crypto kernels — **deprecated (RFC-031 P4), frozen**.
  *
- * These are the original TypeScript implementations preserved for
- * environments where WASM is not available. The main entry point
- * (`@totemsdk/core`) now delegates to WASM by default.
+ * @deprecated The pure-JS kernels are scheduled for removal (RFC-031 P5). Use
+ * the WASM surface instead:
+ *   - `@totemsdk/core` / `@totemsdk/core/wasm` — synchronous WASM (bundler loader required)
+ *   - `@totemsdk/core/wasm-async` — async-init WASM (portable to edge/Workers)
  *
- * Import legacy implementations directly:
- *   import { wotsSign } from '@totemsdk/core/legacy';
+ * This entry stays only as a migration bridge for environments that cannot run
+ * WASM yet; it is **frozen** (no new kernels are added here) and will be deleted
+ * in a major release. Exports are `legacy`-prefixed where they collide with the
+ * WASM names (`legacyWotsSign`, …).
+ *
+ *   // before
+ *   import { legacyWotsSign } from '@totemsdk/core/legacy';
+ *   // after
+ *   import { init, wotsSign } from '@totemsdk/core/wasm-async';
+ *   await init();
  */
 export { F, hex, fromHex, u16be, u32be, assert32, h, prfChainSeed, toWinternitzDigits, baseWWithChecksum, derivePKdigest as legacyDerivePKdigest, wotsKeypairFromSeed as legacyWotsKeypairFromSeed, wotsSign as legacyWotsSign, wotsSignLegacy, wotsPkFromSig as legacyWotsPkFromSig, wotsVerify as legacyWotsVerify, wotsVerifyDigest as legacyWotsVerifyDigest, wotsPublicKeyFromSeed as legacyWotsPublicKeyFromSeed, type WotsKeypair, type WotsSignature, } from './wots.js';
 export { TreeKey, TreeKeyNode, verifyTreeSignature as legacyVerifyTreeSignature, serializeTreeSignature, deserializeTreeSignature, getRootPublicKey, DEFAULT_KEYS_PER_LEVEL, DEFAULT_LEVELS, createUnifiedChildTreeKey as legacyCreateUnifiedChildTreeKey, createUnifiedChildTreeKeyAsync, createUnifiedRootTreeKey as legacyCreateUnifiedRootTreeKey, deriveUnifiedAddressPublicKey as legacyDeriveUnifiedAddressPublicKey, createPerAddressTreeKey, createPerAddressTreeKeyAsync, type KeyGenProgress, type ProgressCallback, type SignatureProof, type TreeSignature, } from './treekey.js';

package/dist/legacy.js

@@ -1,12 +1,21 @@
 /**
- * Legacy JS implementations — backward compatibility.
+ * Legacy JS crypto kernels — **deprecated (RFC-031 P4), frozen**.
  *
- * These are the original TypeScript implementations preserved for
- * environments where WASM is not available. The main entry point
- * (`@totemsdk/core`) now delegates to WASM by default.
+ * @deprecated The pure-JS kernels are scheduled for removal (RFC-031 P5). Use
+ * the WASM surface instead:
+ *   - `@totemsdk/core` / `@totemsdk/core/wasm` — synchronous WASM (bundler loader required)
+ *   - `@totemsdk/core/wasm-async` — async-init WASM (portable to edge/Workers)
  *
- * Import legacy implementations directly:
- *   import { wotsSign } from '@totemsdk/core/legacy';
+ * This entry stays only as a migration bridge for environments that cannot run
+ * WASM yet; it is **frozen** (no new kernels are added here) and will be deleted
+ * in a major release. Exports are `legacy`-prefixed where they collide with the
+ * WASM names (`legacyWotsSign`, …).
+ *
+ *   // before
+ *   import { legacyWotsSign } from '@totemsdk/core/legacy';
+ *   // after
+ *   import { init, wotsSign } from '@totemsdk/core/wasm-async';
+ *   await init();
  */
 // WOTS — unique exports
 export { F, hex, fromHex, u16be, u32be, assert32, h, prfChainSeed, toWinternitzDigits, baseWWithChecksum, derivePKdigest as legacyDerivePKdigest, wotsKeypairFromSeed as legacyWotsKeypairFromSeed, wotsSign as legacyWotsSign, wotsSignLegacy, wotsPkFromSig as legacyWotsPkFromSig, wotsVerify as legacyWotsVerify, wotsVerifyDigest as legacyWotsVerifyDigest, wotsPublicKeyFromSeed as legacyWotsPublicKeyFromSeed, } from './wots.js';

package/dist/minima32.js

@@ -39,7 +39,7 @@ export function decodeMxRadix32Frame(mx) {
     }
     return bigIntToBytes(x);
 }
-import { sha3_256 as nobleSha3 } from './wasm-sync.js';
+import { sha3_256 as nobleSha3 } from './wasm-async.js';
 /** Encode raw 32 bytes to Mx address with frame and checksum */
 export function makeMxAddress(root32) {
     if (root32.length !== 32) {

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

@@ -1,9 +1,12 @@
 // packages/core/src/mmr.ts
 // Full MMR implementation matching Minima's MMR.java, MMRData.java, and TreeKeyNode.java
-import { sha3_256 as nobleSha3 } from './wasm-sync.js';
+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/contract-helpers.js

@@ -13,10 +13,10 @@
  * Each helper validates inputs and builds the appropriate ScriptDescriptor
  * for use with the EnhancedTransactionBuilder.
  */
-import { sha3_256 } from '../wasm-sync.js';
-import { createHash, randomBytes } from 'node:crypto';
+import { sha3_256 } from '../wasm-async.js';
+import { sha256 as nobleSha256 } from '@noble/hashes/sha256.js';
 function sha256(data) {
-    return new Uint8Array(createHash('sha256').update(data).digest());
+    return nobleSha256(data);
 }
 import { createTimelockDescriptor, createHTLCDescriptor, createMASTDescriptor, createExchangeDescriptor, createFlashCashDescriptor, createSlowCashDescriptor } from './types.js';
 function kissHex(hex) {
@@ -79,7 +79,7 @@ export class HTLCHelper {
      * Generate a random preimage and its hash.
      */
     static generateSecret() {
-        const preimageBytes = randomBytes(32);
+        const preimageBytes = globalThis.crypto.getRandomValues(new Uint8Array(32));
         const preimage = bytesToHex(preimageBytes);
         const hashBytes = sha3_256(preimageBytes);
         const hash = bytesToHex(hashBytes);

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-sync.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.js

@@ -10,7 +10,7 @@
  * precomputeTransactionCoinID() to set output coin IDs. Without this, the signed
  * digest won't match what the Minima node verifies, causing allsignaturesvalid=false.
  */
-import { sha3_256 } from './wasm-sync.js';
+import { sha3_256 } from './wasm-async.js';
 import { writeMiniNumber, writeMiniData, writeHashToStream, writeMiniByte, writeMMREntryNumber, concat, hexToBytes, } from './Streamable.js';
 const ZERO_TXPOWID = new Uint8Array([0x00]);
 const STATETYPE_HEX = 1;

package/dist/verify.js

@@ -1,4 +1,4 @@
-import { sha3_256 } from './wasm-sync.js';
+import { sha3_256 } from './wasm-async.js';
 import { deserializeTreeSignature } from './treekey.js';
 import { scriptToAddress } from './derive.js';
 import { scriptFromWotsPk } from './script.js';