@totemsdk/core 1.3.0 → 1.4.1

package/dist/transaction-json.js

@@ -0,0 +1,107 @@
+/**
+ * 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 { hexToBytes, bytesToHex } from './Streamable.js';
+import { deserializeTransaction, parseDecimalToMiniNumber, precomputeTransactionCoinID as precomputeObject, serializeTransaction as serializeObject, } from './transaction.js';
+import { writeMiniData, writeMiniNumber, concat } from './Streamable.js';
+import { sha3_256 } from './wasm-async.js';
+function bytes(value) {
+    if (!value || value === '0x')
+        return new Uint8Array([0]);
+    return 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 = 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. */
+export 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. */
+export function serializeTransaction(tx) {
+    const value = typeof tx === 'string' ? minimaTransactionFromJson(tx) : tx;
+    return serializeObject(value);
+}
+/** Coin-ID rollover: SHA3(MiniData(coinId) || MiniNumber(index)). */
+export function rollCoinId(coinId, outputIndex = 0) {
+    return sha3_256(concat(writeMiniData(coinId), writeMiniNumber(BigInt(outputIndex), 0)));
+}
+export function precomputeTransactionCoinID(tx, outputIndex = 0) {
+    if (typeof tx === 'object' && !(tx instanceof Uint8Array)) {
+        precomputeObject(tx);
+        return;
+    }
+    if (typeof tx === 'string') {
+        const value = minimaTransactionFromJson(tx);
+        precomputeObject(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 = deserializeTransaction(tx);
+        if (value.inputs.length > 0) {
+            precomputeObject(value);
+            return value.outputs[outputIndex]?.coinId ?? new Uint8Array();
+        }
+    }
+    catch {
+        // not a serialized transaction
+    }
+    return rollCoinId(tx, outputIndex);
+}
+export { bytesToHex };

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

@@ -94,3 +94,17 @@ export function wotsKeypairFromSeed(seed, index) {
     const pk = 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.
+ */
+export async function init() {
+    // no-op: the synchronous bridge is initialized at import time
+}
+export function initSync() {
+    // no-op: the synchronous bridge is initialized at import time
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@totemsdk/core",
-  "version": "1.3.0",
+  "version": "1.4.1",
   "description": "Core cryptographic primitives for Totem SDK — backed by Rust/WASM",
   "type": "module",
   "main": "dist/cjs/index.js",
@@ -158,11 +158,12 @@
   "files": [
     "dist",
     "README.md",
-    "LICENSE"
+    "LICENSE",
+    "NOTICE"
   ],
   "dependencies": {
     "@noble/hashes": "^1.8.0",
-    "@totemsdk/core-wasm": "^1.0.2"
+    "@totemsdk/core-wasm": "^1.0.4"
   },
   "engines": {
     "node": ">=16.0.0"
@@ -177,7 +178,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "license": "MIT",
+  "license": "Apache-2.0",
   "author": "Totem SDK",
   "homepage": "https://docs.totem.ing",
   "bugs": {