@totemsdk/core 1.2.10 → 1.3.0

package/dist/cjs/transaction.d.ts

@@ -43,6 +43,12 @@ export interface MinimaToken {
     name: Uint8Array;
     script: Uint8Array;
     created?: bigint;
+    /**
+     * MiniNumber scale of `totalAmount` in the serialized Token. Minima's
+     * `tokencreate` builds the minima amount from `MINI_UNIT` (1E-44) times
+     * integers, so its scale is always 44; default accordingly.
+     */
+    totalAmountScale?: number;
 }
 export interface StateVariable {
     port: number;
@@ -82,11 +88,27 @@ export interface TransactionBuildResult {
     digestTxHex: string;
     serialized: Uint8Array;
     serializedHex: string;
+    /** Set when the transaction creates a token (RFC-005 #2/#11). */
+    tokenId?: 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;
+/**
+ * Compute a Minima **token id** — SHA3-256 of the MiniData-wrapped serialized
+ * Token, matching Java `Token.calculateTokenID()`. A newly created token's coins
+ * carry this value as their `tokenId`; token creation returns it.
+ */
+export declare function computeTokenId(token: MinimaToken): Uint8Array;
+/** Serialize a token descriptor (Java `Token.writeDataStream()` order). */
+export declare function serializeTokenDescriptor(token: MinimaToken): Uint8Array;
+/**
+ * Deserialize a transaction produced by {@link serializeTransaction}. The
+ * inverse is byte-exact for canonically-encoded transactions (outputs/inputs
+ * written from decimal amounts, MMR entry numbers and tokens).
+ */
+export declare function deserializeTransaction(bytes: Uint8Array): MinimaTransaction;
 export declare function precomputeTransactionCoinID(tx: MinimaTransaction): void;
 export declare function createDefaultTransaction(): MinimaTransaction;
 export declare function buildMinimaCoin(opts: {

package/dist/cjs/transaction.js

@@ -16,6 +16,9 @@ exports.parseDecimalToMiniNumber = parseDecimalToMiniNumber;
 exports.serializeCoin = serializeCoin;
 exports.serializeTransaction = serializeTransaction;
 exports.computeTransactionDigest = computeTransactionDigest;
+exports.computeTokenId = computeTokenId;
+exports.serializeTokenDescriptor = serializeTokenDescriptor;
+exports.deserializeTransaction = deserializeTransaction;
 exports.precomputeTransactionCoinID = precomputeTransactionCoinID;
 exports.createDefaultTransaction = createDefaultTransaction;
 exports.buildMinimaCoin = buildMinimaCoin;
@@ -125,11 +128,11 @@ function serializeStateVariable(sv) {
         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);
+                // Minima stores a string state variable as MiniString: MiniData of the
+                // raw UTF-8 bytes. The `[ … ]` form is KISSVM literal syntax, NOT part
+                // of the stored value (the C++ StateVariable::writeDataStream writes
+                // mData directly; the deserializer likewise strips no brackets).
+                const utf8Bytes = new TextEncoder().encode(sv.value);
                 dataBytes = (0, Streamable_js_1.writeMiniData)(utf8Bytes);
             }
             else {
@@ -147,7 +150,10 @@ function serializeToken(token) {
     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));
+    // The minima amount is a MiniNumber carrying its own scale (Java
+    // Token.writeDataStream → mTokenMinimaAmount.writeDataStream). Minima's
+    // tokencreate always builds it from MINI_UNIT (scale 44).
+    parts.push((0, Streamable_js_1.writeMiniNumber)(token.totalAmount, token.totalAmountScale ?? 44));
     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);
@@ -233,6 +239,151 @@ function computeTransactionDigest(tx) {
     const serialized = serializeTransaction(tx);
     return (0, wasm_sync_js_1.sha3_256)(serialized);
 }
+/**
+ * Compute a Minima **token id** — SHA3-256 of the MiniData-wrapped serialized
+ * Token, matching Java `Token.calculateTokenID()`. A newly created token's coins
+ * carry this value as their `tokenId`; token creation returns it.
+ */
+function computeTokenId(token) {
+    return (0, wasm_sync_js_1.sha3_256)((0, Streamable_js_1.writeMiniData)(serializeToken(token)));
+}
+/** Serialize a token descriptor (Java `Token.writeDataStream()` order). */
+function serializeTokenDescriptor(token) {
+    return serializeToken(token);
+}
+function txReadBytes(data, c, n) {
+    if (n < 0 || c.offset + n > data.length) {
+        throw new Error(`deserializeTransaction: unexpected end of input at offset ${c.offset} (need ${n})`);
+    }
+    const out = data.slice(c.offset, c.offset + n);
+    c.offset += n;
+    return out;
+}
+function txReadMiniByte(data, c) {
+    return txReadBytes(data, c, 1)[0];
+}
+/** MiniData / hash: 4-byte big-endian length + bytes. */
+function txReadMiniData(data, c) {
+    const lenBytes = txReadBytes(data, c, 4);
+    const len = ((lenBytes[0] << 24) | (lenBytes[1] << 16) | (lenBytes[2] << 8) | lenBytes[3]) >>> 0;
+    return txReadBytes(data, c, len);
+}
+/** MiniNumber: 1-byte scale + 1-byte length + two's-complement unscaled bytes. */
+function txReadMiniNumber(data, c) {
+    const scale = txReadBytes(data, c, 1)[0];
+    const len = txReadBytes(data, c, 1)[0];
+    const bytes = txReadBytes(data, c, len);
+    let value = 0n;
+    for (const b of bytes)
+        value = (value << 8n) | BigInt(b);
+    // RFC-020 P2-10 (TXB-SERIAL-003): Java's BigInteger.toByteArray() (and the
+    // canonical writers here) use two's-complement big-endian; a set high bit
+    // means the value is negative. Previously this was read as unsigned.
+    if (bytes.length > 0 && (bytes[0] & 0x80) !== 0) {
+        value -= 1n << BigInt(8 * bytes.length);
+    }
+    return { value, scale };
+}
+function txBytesToBigInt(bytes) {
+    let value = 0n;
+    for (const b of bytes)
+        value = (value << 8n) | BigInt(b);
+    return value;
+}
+/** MMREntryNumber: MiniNumber(scale) followed by MiniData(unscaled). */
+function txReadMMREntryNumber(data, c) {
+    txReadMiniNumber(data, c); // scale (always 0 for integer entry numbers)
+    return txBytesToBigInt(txReadMiniData(data, c));
+}
+function miniNumberToDecimal(value, scale) {
+    if (scale === 0)
+        return value.toString();
+    const digits = value.toString().padStart(scale + 1, '0');
+    const whole = digits.slice(0, digits.length - scale);
+    const frac = digits.slice(digits.length - scale);
+    return `${whole}.${frac}`;
+}
+function txReadStateVariable(data, c) {
+    const port = txReadBytes(data, c, 1)[0];
+    const type = txReadBytes(data, c, 1)[0];
+    switch (type) {
+        case STATETYPE_HEX:
+            return { port, type: 'hex', value: txReadMiniData(data, c) };
+        case STATETYPE_NUMBER:
+            return { port, type: 'number', value: txReadMiniNumber(data, c).value };
+        case STATETYPE_STRING:
+            return { port, type: 'string', value: new TextDecoder().decode(txReadMiniData(data, c)) };
+        case STATETYPE_BOOL:
+            return { port, type: 'bool', value: txReadMiniByte(data, c) === 1 };
+        default:
+            throw new Error(`deserializeTransaction: unknown StateVariable type ${type}`);
+    }
+}
+function txReadToken(data, c) {
+    const coinId = txReadMiniData(data, c);
+    const script = txReadMiniData(data, c);
+    const { value: scale } = txReadMiniNumber(data, c);
+    // RFC-020 P2-10 (TXB-SERIAL-002): carry the totalAmount's own scale so a
+    // serialize→deserialize→serialize round-trip is byte-exact (previously the
+    // scale was dropped and re-defaulted to 44).
+    const { value: totalAmount, scale: totalAmountScale } = txReadMiniNumber(data, c);
+    const name = txReadMiniData(data, c);
+    const { value: created } = txReadMiniNumber(data, c);
+    return { coinId, script, scale: Number(scale), totalAmount, totalAmountScale, name, created };
+}
+function txReadCoin(data, c) {
+    const coinId = txReadMiniData(data, c);
+    const address = txReadMiniData(data, c);
+    const { value: amountUnscaled, scale } = txReadMiniNumber(data, c);
+    const tokenId = txReadMiniData(data, c);
+    const storeState = txReadMiniByte(data, c) === 1;
+    const mmrEntryNumber = txReadMMREntryNumber(data, c);
+    const spent = txReadMiniByte(data, c) === 1;
+    const { value: created } = txReadMiniNumber(data, c);
+    const stateCount = Number(txReadMiniNumber(data, c).value);
+    const state = [];
+    for (let i = 0; i < stateCount; i++)
+        state.push(txReadStateVariable(data, c));
+    const hasToken = txReadMiniByte(data, c) === 1;
+    const token = hasToken ? txReadToken(data, c) : null;
+    return {
+        coinId,
+        address,
+        amount: miniNumberToDecimal(amountUnscaled, scale),
+        tokenId,
+        token,
+        storeState,
+        state,
+        mmrEntryNumber,
+        spent,
+        created,
+    };
+}
+/**
+ * Deserialize a transaction produced by {@link serializeTransaction}. The
+ * inverse is byte-exact for canonically-encoded transactions (outputs/inputs
+ * written from decimal amounts, MMR entry numbers and tokens).
+ */
+function deserializeTransaction(bytes) {
+    const c = { offset: 0 };
+    const inputCount = Number(txReadMiniNumber(bytes, c).value);
+    const inputs = [];
+    for (let i = 0; i < inputCount; i++)
+        inputs.push(txReadCoin(bytes, c));
+    const outputCount = Number(txReadMiniNumber(bytes, c).value);
+    const outputs = [];
+    for (let i = 0; i < outputCount; i++)
+        outputs.push(txReadCoin(bytes, c));
+    const stateCount = Number(txReadMiniNumber(bytes, c).value);
+    const state = [];
+    for (let i = 0; i < stateCount; i++)
+        state.push(txReadStateVariable(bytes, c));
+    const linkHash = txReadMiniData(bytes, c);
+    if (c.offset !== bytes.length) {
+        throw new Error(`deserializeTransaction: ${bytes.length - c.offset} trailing byte(s) after transaction`);
+    }
+    return { linkHash, inputs, outputs, state };
+}
 function precomputeTransactionCoinID(tx) {
     if (tx.inputs.length === 0)
         return;

package/dist/cjs/tx/TransactionReceiptStore.js

@@ -37,33 +37,28 @@ class TransactionReceiptStore {
         return this._initialized;
     }
     async load() {
-        try {
-            const receipts = await this.storage.get(this.storageKey);
-            if (receipts) {
-                this.receipts = receipts;
-                this.logger.debug(`Loaded ${this.receipts.length} transaction receipts`);
-            }
-        }
-        catch (error) {
-            this.logger.error('Failed to load receipts:', error);
+        const receipts = await this.storage.get(this.storageKey);
+        if (receipts) {
+            this.receipts = receipts;
+            this.logger.debug(`Loaded ${this.receipts.length} transaction receipts`);
         }
     }
     async persist() {
+        const trimmedReceipts = this.receipts.slice(-this.maxReceipts);
+        await this.storage.set(this.storageKey, trimmedReceipts);
+        this.receipts = trimmedReceipts;
+    }
+    async add(receipt) {
+        this.receipts.push(receipt);
+        this.logger.debug(`Added receipt: ${receipt.txpowid}`);
         try {
-            const trimmedReceipts = this.receipts.slice(-this.maxReceipts);
-            await this.storage.set(this.storageKey, trimmedReceipts);
-            this.receipts = trimmedReceipts;
+            await this.persist();
         }
         catch (error) {
-            this.logger.error('Failed to persist receipts:', error);
+            this.receipts.pop();
             throw error;
         }
     }
-    async add(receipt) {
-        this.receipts.push(receipt);
-        this.logger.debug(`Added receipt: ${receipt.txpowid}`);
-        await this.persist();
-    }
     getAll() {
         return [...this.receipts].reverse();
     }
@@ -76,15 +71,29 @@ class TransactionReceiptStore {
     async updateStatus(txpowid, status) {
         const receipt = this.receipts.find(r => r.txpowid === txpowid);
         if (receipt) {
+            const previousStatus = receipt.status;
             receipt.status = status;
             this.logger.debug(`Updated receipt status: ${txpowid} → ${status}`);
-            await this.persist();
+            try {
+                await this.persist();
+            }
+            catch (error) {
+                receipt.status = previousStatus;
+                throw error;
+            }
         }
     }
     async clear() {
+        const previous = this.receipts;
         this.receipts = [];
-        await this.storage.remove(this.storageKey);
-        this.logger.debug('Cleared all receipts');
+        try {
+            await this.storage.remove(this.storageKey);
+            this.logger.debug('Cleared all receipts');
+        }
+        catch (error) {
+            this.receipts = previous;
+            throw error;
+        }
     }
     count() {
         return this.receipts.length;

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

@@ -8,7 +8,7 @@
  *   import { wotsSign, sha3_256 } from '@totemsdk/core/wasm';
  *   const sig = wotsSign(seed, 0, message); // synchronous!
  */
-import { bytes_to_hex_wasm, clean_seed_phrase_wasm, compute_transaction_digest_wasm, concat_bytes_wasm, create_challenge_wasm, create_unified_child_tree_key_wasm, create_unified_root_tree_key_wasm, derive_chain_seed_wasm, derive_full_public_key_batch_wasm, derive_full_public_key_wasm, derive_per_address_seed_wasm, derive_pk_digest_batch_wasm, derive_pk_digest_wasm, derive_root_priv_seed_wasm, derive_unified_address_public_key_wasm, expand_private_key_wasm, generate_mnemonic_wasm, get_params, hash_chain_wasm, hex_to_bytes_wasm, make_mx_address_wasm, mine_txpow_chunk_wasm, mine_txpow_wasm, mmr_root_from_public_keys_wasm, parse_mx_address_wasm, phrase_to_seed_wasm, precompute_transaction_coin_id_wasm, serialize_transaction_wasm, sha3_256_wasm, timing_safe_equal_wasm, validate_challenge_wasm, validate_phrase_wasm, verify_mmr_proof_wasm, verify_tree_signature_wasm, wasm_tree_key_free, wasm_tree_key_get_max_uses, wasm_tree_key_get_public_key, wasm_tree_key_get_uses, wasm_tree_key_new, wasm_tree_key_set_uses, wasm_tree_key_sign, wots_pk_from_sig_wasm, wots_sign_batch_wasm, wots_sign_wasm, wots_verify_digest_wasm, wots_verify_wasm, write_mini_data_wasm, write_mini_string_wasm } from '@totemsdk/core-wasm';
+import { bytes_to_hex_wasm, clean_seed_phrase_wasm, compute_transaction_digest_wasm, concat_bytes_wasm, create_unified_child_tree_key_wasm, create_unified_root_tree_key_wasm, derive_chain_seed_wasm, derive_full_public_key_batch_wasm, derive_full_public_key_wasm, derive_per_address_seed_wasm, derive_pk_digest_batch_wasm, derive_pk_digest_wasm, derive_root_priv_seed_wasm, derive_unified_address_public_key_wasm, expand_private_key_wasm, generate_mnemonic_wasm, get_params, hash_chain_wasm, hex_to_bytes_wasm, make_mx_address_wasm, mine_txpow_chunk_wasm, mine_txpow_wasm, mmr_root_from_public_keys_wasm, parse_mx_address_wasm, phrase_to_seed_wasm, precompute_transaction_coin_id_wasm, serialize_transaction_wasm, sha3_256_wasm, timing_safe_equal_wasm, validate_phrase_wasm, verify_mmr_proof_wasm, verify_tree_signature_wasm, wasm_tree_key_free, wasm_tree_key_get_max_uses, wasm_tree_key_get_public_key, wasm_tree_key_get_uses, wasm_tree_key_new, wasm_tree_key_set_uses, wasm_tree_key_sign, wots_pk_from_sig_wasm, wots_sign_batch_wasm, wots_sign_wasm, wots_verify_digest_wasm, wots_verify_wasm, write_mini_data_wasm, write_mini_string_wasm } from '@totemsdk/core-wasm';
 export declare const bytesToHex: typeof bytes_to_hex_wasm;
 export declare const hexToBytes: typeof hex_to_bytes_wasm;
 export declare const concatBytes: typeof concat_bytes_wasm;
@@ -41,8 +41,8 @@ export declare const computeTransactionDigest: typeof compute_transaction_digest
 export declare const precomputeTransactionCoinID: typeof precompute_transaction_coin_id_wasm;
 export declare const verifyTreeSignature: typeof verify_tree_signature_wasm;
 export declare const timingSafeEqual: typeof timing_safe_equal_wasm;
-export declare const createChallenge: typeof create_challenge_wasm;
-export declare const validateChallenge: typeof validate_challenge_wasm;
+export declare function createChallenge(domain: string, statement: string): string;
+export declare function validateChallenge(challengeJson: string, domain: string): boolean;
 export declare function writeMiniNumber(value: bigint, scale?: number): Uint8Array;
 export declare const writeMiniData: typeof write_mini_data_wasm;
 export declare const writeMiniString: typeof write_mini_string_wasm;

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';
@@ -20,6 +20,7 @@ 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 { deserializeTransaction } from './transaction.js';
 export { timingSafeEqual, createChallenge, validateChallenge, } from './wasm-sync.js';
 export { scriptFromWotsPk } from './script.js';
 export { makeMxAddress as encodeMx, parseMxAddress as decodeMx } from './wasm-sync.js';
@@ -30,14 +31,16 @@ export * from './scripts/index.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, createDefaultTransaction, buildMinimaCoin, } from './transaction.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 { writeMiniByte, writeMMREntryNumber, concat, bigIntToByteArray, type Bytes, } from './Streamable.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, type KeyGenProgress, type ProgressCallback, type SignatureProof, type TreeSignature, } from './treekey.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, u16be, u32be, assert32, h, prfChainSeed, toWinternitzDigits, baseWWithChecksum, wotsSignLegacy, } from './wots.js';
-export { toHex, canonicalJson, hashCanonical } from './canonical.js';
+export { F, hex, fromHex, setWotsLogger, disableWotsLogger, u16be, u32be, assert32, h, prfChainSeed, toWinternitzDigits, baseWWithChecksum, wotsSignLegacy, } from './wots.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,18 +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;
@@ -72,18 +75,21 @@ export { WORD_LIST, convertStringToSeed, convertWordListToSeed, generateSeedPhra
 // MiniNumber class (matches Java MiniNumber/BigDecimal semantics)
 export { MiniNumber } from './MiniNumber.js';
 // Transaction types (from JS)
-export { parseDecimalToMiniNumber, serializeCoin, createDefaultTransaction, buildMinimaCoin, } from './transaction.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, concat, bigIntToByteArray, } from './Streamable.js';
+export { writeMiniByte, writeMMREntryNumber, writeSignature, writeSignatureProof, concat, bigIntToByteArray, } from './Streamable.js';
 // Java-Compatible Serialization Helpers (non-crypto)
 export { serializeMiniNumber, serializeMiniData, hashAllObjects, deriveChildTreeSeedJava, hashObject, serializeMiniNumberZERO, serializeMiniNumberONE, writeHashToStream, javaHashAllObjects, indexToMiniDataBytes, deriveUnifiedChildSeed, createMMREntryNumber, serializeMMREntryNumber, serializeMMRData, serializeMMREntry, } from './javaStreamables.js';
 // TreeKey/TreeKeyNode — JS types and helpers
-export { TreeKey, TreeKeyNode, serializeTreeSignature, deserializeTreeSignature, getRootPublicKey, DEFAULT_KEYS_PER_LEVEL, DEFAULT_LEVELS, createUnifiedChildTreeKeyAsync, createPerAddressTreeKey, createPerAddressTreeKeyAsync, } from './treekey.js';
-export { F, hex, fromHex, u16be, u32be, assert32, h, prfChainSeed, toWinternitzDigits, baseWWithChecksum, wotsSignLegacy, } from './wots.js';
+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/lease/LeaseStore.d.ts

@@ -33,6 +33,7 @@ export interface LeaseStoreConfig {
 export declare class LeaseStore {
     private leases;
     private _initialized;
+    private mutationTail;
     private readonly storageKey;
     private readonly storage;
     private readonly logger;
@@ -42,16 +43,22 @@ export declare class LeaseStore {
     private load;
     private persist;
     save(lease: StoredLease): Promise<void>;
+    private saveUnlocked;
+    delete(leaseId: string): Promise<boolean>;
+    private deleteUnlocked;
     get(leaseId: string): StoredLease | undefined;
     getByToken(leaseToken: string): StoredLease | undefined;
     getAll(): StoredLease[];
     getActive(): StoredLease[];
     getExpiringSoon(thresholdMs?: number): StoredLease[];
-    delete(leaseId: string): Promise<boolean>;
     deleteByToken(leaseToken: string): Promise<boolean>;
     updateStatus(leaseId: string, status: LeaseStatus): Promise<void>;
+    private updateStatusUnlocked;
     cleanupExpired(): Promise<number>;
+    private cleanupExpiredUnlocked;
     clear(): Promise<void>;
+    private clearUnlocked;
+    private mutate;
     getMinimumTTL(): number | null;
     calculateMonitoringInterval(): number;
     private flattenIndex;