@totemsdk/core 1.2.9 → 1.2.11

package/dist/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/transaction.js

@@ -116,11 +116,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 = writeMiniData(utf8Bytes);
             }
             else {
@@ -138,7 +138,10 @@ function serializeToken(token) {
     parts.push(writeHashToStream(token.coinId));
     parts.push(writeMiniData(token.script));
     parts.push(writeMiniNumber(BigInt(token.scale), 0));
-    parts.push(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(writeMiniNumber(token.totalAmount, token.totalAmountScale ?? 44));
     parts.push(writeMiniData(token.name));
     parts.push(writeMiniNumber(token.created ?? 0n, 0));
     return concat(...parts);
@@ -224,6 +227,151 @@ export function computeTransactionDigest(tx) {
     const serialized = serializeTransaction(tx);
     return 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.
+ */
+export function computeTokenId(token) {
+    return sha3_256(writeMiniData(serializeToken(token)));
+}
+/** Serialize a token descriptor (Java `Token.writeDataStream()` order). */
+export 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).
+ */
+export 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 };
+}
 export function precomputeTransactionCoinID(tx) {
     if (tx.inputs.length === 0)
         return;

package/dist/tx/TransactionReceiptStore.js

@@ -34,33 +34,28 @@ export 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();
     }
@@ -73,15 +68,29 @@ export 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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@totemsdk/core",
-  "version": "1.2.9",
+  "version": "1.2.11",
   "description": "Core cryptographic primitives for Totem SDK — backed by Rust/WASM",
   "type": "module",
   "main": "dist/cjs/index.js",
@@ -119,7 +119,7 @@
     "LICENSE"
   ],
   "dependencies": {
-    "@totemsdk/core-wasm": "^1.0.0"
+    "@totemsdk/core-wasm": "^1.0.1"
   },
   "engines": {
     "node": ">=16.0.0"
@@ -136,13 +136,13 @@
   },
   "license": "MIT",
   "author": "Totem SDK",
-  "homepage": "https://totem.ing",
+  "homepage": "https://docs.totem.ing",
   "bugs": {
-    "url": "https://github.com/totem-sdk/totem-sdk/issues"
+    "url": "https://github.com/Totem-Edge/totem-sdk/issues"
   },
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/totem-sdk/totem-sdk.git",
+    "url": "git+https://github.com/Totem-Edge/totem-sdk.git",
     "directory": "packages/core"
   },
   "keywords": [