@totemsdk/core 1.0.4 → 1.0.6

package/dist/index.d.ts

@@ -28,3 +28,4 @@ export declare const MINIMA_CONSTANTS: {
     readonly ADDRESS_PREFIX: "Mx";
     readonly NETWORK_ID: 1;
 };
+export { writeMiniNumber, writeMiniData, writeMiniByte, writeMMREntryNumber, concat, hexToBytes, bytesToHex, bigIntToByteArray, writeMiniString, type Bytes, } from './Streamable.js';

package/dist/index.js

@@ -51,3 +51,5 @@ export const MINIMA_CONSTANTS = {
     ADDRESS_PREFIX: 'Mx',
     NETWORK_ID: 1
 };
+// Streamable primitives (low-level serialization building blocks)
+export { writeMiniNumber, writeMiniData, writeMiniByte, writeMMREntryNumber, concat, hexToBytes, bytesToHex, bigIntToByteArray, writeMiniString, } from './Streamable.js';

package/dist/tx/TransactionService.js

@@ -38,6 +38,8 @@ export class TransactionService {
                 burn: params.burn || null,
                 paramSet: this.config.paramSet || 'v2-spec',
                 addressIndex: params.addressIndex,
+                walletMode: params.walletMode || 'AnonTree',
+                perAddressPublicKey: params.perAddressPublicKey ?? null,
             }, {
                 headers: {
                     'Content-Type': 'application/json',

package/dist/tx/types.d.ts

@@ -14,6 +14,8 @@ export interface PrepareRequest {
     burn?: string;
     txId?: string;
     addressIndex?: number;
+    walletMode?: 'AnonTree' | 'RootTree';
+    perAddressPublicKey?: string;
 }
 export interface PrepareResponse {
     addressIndex: number;
@@ -28,6 +30,7 @@ export interface PrepareResponse {
     paramSet: string;
     leaseId: string;
     leaseTTL: number;
+    perAddressScript?: string | null;
 }
 export interface SignRequest {
     addressIndex: number;

package/dist/verify.js

@@ -118,16 +118,17 @@ function timingSafeEqual(a, b) {
 function cryptoRandomBytes(length) {
     const buf = new Uint8Array(length);
     if (typeof globalThis.crypto !== 'undefined' && globalThis.crypto.getRandomValues) {
+        // Web Crypto API — available in browsers, Bare/Pear, and Node.js ≥ 19
         globalThis.crypto.getRandomValues(buf);
     }
+    else if (typeof process !== 'undefined' && process.versions?.node) {
+        // Node.js < 19 fallback — dynamic import avoids static resolution in Bare/bundlers
+        // eslint-disable-next-line @typescript-eslint/no-var-requires
+        const nodeCrypto = Function('return require')()('crypto');
+        nodeCrypto.randomFillSync(buf);
+    }
     else {
-        try {
-            const { randomFillSync } = require('crypto');
-            randomFillSync(buf);
-        }
-        catch {
-            throw new Error('No cryptographically secure RNG available');
-        }
+        throw new Error('No cryptographically secure RNG available in this runtime');
     }
     return buf;
 }

package/dist/wots.d.ts

@@ -33,7 +33,7 @@ export declare function disableWotsLogger(): void;
 export declare function isWotsDebugEnabled(): boolean;
 export declare const F: (x: Uint8Array) => Uint8Array<ArrayBufferLike>;
 export declare const hex: (u: Uint8Array) => string;
-export declare const fromHex: (h: string) => Uint8Array<ArrayBuffer>;
+export declare const fromHex: (h: string) => Uint8Array;
 export declare const concatBytes: (...arrs: Uint8Array[]) => Uint8Array<ArrayBuffer>;
 export declare const u16be: (n: number) => Uint8Array<ArrayBuffer>;
 export declare const u32be: (n: number) => Uint8Array<ArrayBuffer>;

package/dist/wots.js

@@ -46,8 +46,19 @@ export function isWotsDebugEnabled() {
 }
 // === Canonical helpers ===
 export const F = (x) => sha3_256(x);
-export const hex = (u) => Buffer.from(u).toString('hex');
-export const fromHex = (h) => Uint8Array.from(Buffer.from(h.replace(/^0x/, ''), 'hex'));
+export const hex = (u) => {
+    let s = '';
+    for (let i = 0; i < u.length; i++)
+        s += u[i].toString(16).padStart(2, '0');
+    return s;
+};
+export const fromHex = (h) => {
+    const s = h.replace(/^0x/, '');
+    const out = new Uint8Array(s.length >> 1);
+    for (let i = 0; i < out.length; i++)
+        out[i] = parseInt(s.slice(i * 2, i * 2 + 2), 16);
+    return out;
+};
 export const concatBytes = (...arrs) => {
     const len = arrs.reduce((n, a) => n + a.length, 0);
     const out = new Uint8Array(len);
@@ -490,7 +501,12 @@ export function wotsVerify(sig, message, pkFull, ps = getParamSet()) {
     }
     // Compare FULL 1088-byte reconstructed key to expected FULL public key
     // This matches Java: resp.isEqual(zPublicKey) where both are 1088 bytes
-    return Buffer.from(buf).equals(Buffer.from(pkFull));
+    if (buf.length !== pkFull.length)
+        return false;
+    let diff = 0;
+    for (let i = 0; i < buf.length; i++)
+        diff |= buf[i] ^ pkFull[i];
+    return diff === 0;
 }
 /**
  * Legacy verify function that accepts a 32-byte digest
@@ -512,7 +528,12 @@ export function wotsVerifyDigest(sig, message, pkDigest, ps = getParamSet()) {
         buf.set(top, j * 32);
     }
     const recomputed = F(buf);
-    return Buffer.from(recomputed).equals(Buffer.from(pkDigest));
+    if (recomputed.length !== pkDigest.length)
+        return false;
+    let diff = 0;
+    for (let i = 0; i < recomputed.length; i++)
+        diff |= recomputed[i] ^ pkDigest[i];
+    return diff === 0;
 }
 /**
  * Generate WOTS public key from seed (convenience wrapper)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@totemsdk/core",
-  "version": "1.0.4",
+  "version": "1.0.6",
   "description": "Core cryptographic primitives for Totem SDK",
   "type": "module",
   "main": "dist/index.js",

package/src/__tests__/roottree-prepare.test.ts

@@ -0,0 +1,101 @@
+/**
+ * RootTree prepare() propagation tests
+ *
+ * Verifies that TransactionService.prepare() correctly forwards walletMode
+ * and perAddressPublicKey in the POST body so the /prepare endpoint can
+ * apply RootTree-specific validation and return perAddressScript.
+ */
+
+import { TransactionService } from '../tx/TransactionService.js';
+import type { TransactionServiceConfig } from '../tx/TransactionService.js';
+import type { HttpClient } from '../adapters/index.js';
+
+function makeMockHttp(capturedBodies: any[]): HttpClient {
+  return {
+    post: async <T>(_url: string, body: any): Promise<{ ok: boolean; status: number; data: T }> => {
+      capturedBodies.push({ body });
+      return {
+        ok: true,
+        status: 200,
+        data: {
+          addressIndex: 0,
+          l1: 0,
+          l2: 0,
+          leaseToken: 'mock-lease-token',
+          digestTx: '0x' + 'ab'.repeat(32),
+          digestL2: null,
+          digestL3: null,
+          txId: 'tx-mock',
+          rootPublicKey: '0x' + 'ff'.repeat(32),
+          paramSet: 'v2-spec',
+          leaseId: 'lease-mock',
+          leaseTTL: 120000,
+          perAddressScript: 'RETURN SIGNEDBY(0x' + 'ff'.repeat(32) + ')',
+        } as T,
+      };
+    },
+    get: async <T>(): Promise<{ ok: boolean; status: number; data: T }> => ({
+      ok: true, status: 200, data: {} as T,
+    }),
+  };
+}
+
+const config: TransactionServiceConfig = {
+  baseUrl: 'https://api.example.com',
+  apiKey: 'test-api-key',
+  paramSet: 'v2-spec',
+};
+
+const MOCK_ROOT_PK = '0x' + 'aa'.repeat(32);
+const MOCK_PER_ADDR_PK = '0x' + 'bb'.repeat(32);
+
+describe('TransactionService.prepare() — RootTree propagation', () => {
+  it('sends walletMode=AnonTree by default', async () => {
+    const bodies: any[] = [];
+    const svc = new TransactionService(makeMockHttp(bodies), config);
+
+    await svc.prepare(
+      { to: 'MxABC', amount: '1', addressIndex: 0 },
+      MOCK_ROOT_PK
+    );
+
+    expect(bodies).toHaveLength(1);
+    expect(bodies[0].body.walletMode).toBe('AnonTree');
+    expect(bodies[0].body.perAddressPublicKey).toBeNull();
+  });
+
+  it('forwards walletMode=RootTree and perAddressPublicKey in POST body', async () => {
+    const bodies: any[] = [];
+    const svc = new TransactionService(makeMockHttp(bodies), config);
+
+    await svc.prepare(
+      {
+        to: 'MxABC',
+        amount: '1',
+        addressIndex: 0,
+        walletMode: 'RootTree',
+        perAddressPublicKey: MOCK_PER_ADDR_PK,
+      },
+      MOCK_ROOT_PK
+    );
+
+    expect(bodies).toHaveLength(1);
+    const sent = bodies[0].body;
+    expect(sent.walletMode).toBe('RootTree');
+    expect(sent.perAddressPublicKey).toBe(MOCK_PER_ADDR_PK);
+    expect(sent.rootPublicKey).toBe(MOCK_ROOT_PK);
+  });
+
+  it('PrepareResponse includes perAddressScript field from server', async () => {
+    const bodies: any[] = [];
+    const svc = new TransactionService(makeMockHttp(bodies), config);
+
+    const result = await svc.prepare(
+      { to: 'MxABC', amount: '1', addressIndex: 0, walletMode: 'RootTree', perAddressPublicKey: MOCK_PER_ADDR_PK },
+      MOCK_ROOT_PK
+    );
+
+    expect(result.perAddressScript).toBeDefined();
+    expect(typeof result.perAddressScript).toBe('string');
+  });
+});

package/src/index.ts

@@ -204,3 +204,17 @@ export const MINIMA_CONSTANTS = {
   ADDRESS_PREFIX: 'Mx',
   NETWORK_ID: 1
 } as const;
+
+// Streamable primitives (low-level serialization building blocks)
+export {
+  writeMiniNumber,
+  writeMiniData,
+  writeMiniByte,
+  writeMMREntryNumber,
+  concat,
+  hexToBytes,
+  bytesToHex,
+  bigIntToByteArray,
+  writeMiniString,
+  type Bytes,
+} from './Streamable.js';

package/src/tx/TransactionService.ts

@@ -83,6 +83,8 @@ export class TransactionService {
         burn: params.burn || null,
         paramSet: this.config.paramSet || 'v2-spec',
         addressIndex: params.addressIndex,
+        walletMode: params.walletMode || 'AnonTree',
+        perAddressPublicKey: params.perAddressPublicKey ?? null,
       }, {
         headers: {
           'Content-Type': 'application/json',

package/src/tx/types.ts

@@ -15,7 +15,9 @@ export interface PrepareRequest {
   tokenId?: string;
   burn?: string;
   txId?: string;
-  addressIndex?: number;   // Required by v2-spec backend (0-63, must match the coin's address)
+  addressIndex?: number;          // Required by v2-spec backend (0-63, must match the coin's address)
+  walletMode?: 'AnonTree' | 'RootTree'; // Key derivation scheme — omit for legacy/AnonTree
+  perAddressPublicKey?: string;   // Hex pubkey of per-address TreeKey root (required for RootTree validation)
 }
 
 export interface PrepareResponse {
@@ -31,6 +33,7 @@ export interface PrepareResponse {
   paramSet: string;
   leaseId: string;
   leaseTTL: number;
+  perAddressScript?: string | null; // RETURN SIGNEDBY(<perAddressPublicKey>) — present in RootTree mode
 }
 
 export interface SignRequest {

package/src/verify.ts

@@ -157,14 +157,15 @@ function timingSafeEqual(a: Uint8Array, b: Uint8Array): boolean {
 function cryptoRandomBytes(length: number): Uint8Array {
   const buf = new Uint8Array(length);
   if (typeof globalThis.crypto !== 'undefined' && globalThis.crypto.getRandomValues) {
+    // Web Crypto API — available in browsers, Bare/Pear, and Node.js ≥ 19
     globalThis.crypto.getRandomValues(buf);
+  } else if (typeof process !== 'undefined' && process.versions?.node) {
+    // Node.js < 19 fallback — dynamic import avoids static resolution in Bare/bundlers
+    // eslint-disable-next-line @typescript-eslint/no-var-requires
+    const nodeCrypto = Function('return require')()('crypto') as { randomFillSync: (buf: Uint8Array) => void };
+    nodeCrypto.randomFillSync(buf);
   } else {
-    try {
-      const { randomFillSync } = require('crypto');
-      randomFillSync(buf);
-    } catch {
-      throw new Error('No cryptographically secure RNG available');
-    }
+    throw new Error('No cryptographically secure RNG available in this runtime');
   }
   return buf;
 }

package/src/wots.js

@@ -70,9 +70,9 @@ function isWotsDebugEnabled() {
 // === Canonical helpers ===
 const F = (x) => (0, sha3_1.sha3_256)(x);
 exports.F = F;
-const hex = (u) => Buffer.from(u).toString('hex');
+const hex = (u) => { let s = ''; for (let i = 0; i < u.length; i++) s += u[i].toString(16).padStart(2, '0'); return s; };
 exports.hex = hex;
-const fromHex = (h) => Uint8Array.from(Buffer.from(h.replace(/^0x/, ''), 'hex'));
+const fromHex = (h) => { const s = h.replace(/^0x/, ''); const out = new Uint8Array(s.length >> 1); for (let i = 0; i < out.length; i++) out[i] = parseInt(s.slice(i * 2, i * 2 + 2), 16); return out; };
 exports.fromHex = fromHex;
 const concatBytes = (...arrs) => {
     const len = arrs.reduce((n, a) => n + a.length, 0);
@@ -511,7 +511,10 @@ function wotsVerify(sig, message, pkFull, ps = (0, params_1.getParamSet)()) {
     }
     // Compare FULL 1088-byte reconstructed key to expected FULL public key
     // This matches Java: resp.isEqual(zPublicKey) where both are 1088 bytes
-    return Buffer.from(buf).equals(Buffer.from(pkFull));
+    if (buf.length !== pkFull.length) return false;
+    let diff = 0;
+    for (let i = 0; i < buf.length; i++) diff |= buf[i] ^ pkFull[i];
+    return diff === 0;
 }
 /**
  * Legacy verify function that accepts a 32-byte digest
@@ -533,7 +536,10 @@ function wotsVerifyDigest(sig, message, pkDigest, ps = (0, params_1.getParamSet)
         buf.set(top, j * 32);
     }
     const recomputed = (0, exports.F)(buf);
-    return Buffer.from(recomputed).equals(Buffer.from(pkDigest));
+    if (recomputed.length !== pkDigest.length) return false;
+    let diff = 0;
+    for (let i = 0; i < recomputed.length; i++) diff |= recomputed[i] ^ pkDigest[i];
+    return diff === 0;
 }
 /**
  * Generate WOTS public key from seed (convenience wrapper)

package/src/wots.ts

@@ -53,8 +53,17 @@ export function isWotsDebugEnabled(): boolean {
 
 // === Canonical helpers ===
 export const F = (x: Uint8Array) => sha3_256(x);
-export const hex = (u: Uint8Array) => Buffer.from(u).toString('hex');
-export const fromHex = (h: string) => Uint8Array.from(Buffer.from(h.replace(/^0x/, ''), 'hex'));
+export const hex = (u: Uint8Array): string => {
+  let s = '';
+  for (let i = 0; i < u.length; i++) s += u[i].toString(16).padStart(2, '0');
+  return s;
+};
+export const fromHex = (h: string): Uint8Array => {
+  const s = h.replace(/^0x/, '');
+  const out = new Uint8Array(s.length >> 1);
+  for (let i = 0; i < out.length; i++) out[i] = parseInt(s.slice(i * 2, i * 2 + 2), 16);
+  return out;
+};
 export const concatBytes = (...arrs: Uint8Array[]) => {
   const len = arrs.reduce((n, a) => n + a.length, 0);
   const out = new Uint8Array(len);
@@ -579,7 +588,10 @@ export function wotsVerify(sig: Uint8Array, message: Uint8Array, pkFull: Uint8Ar
   
   // Compare FULL 1088-byte reconstructed key to expected FULL public key
   // This matches Java: resp.isEqual(zPublicKey) where both are 1088 bytes
-  return Buffer.from(buf).equals(Buffer.from(pkFull));
+  if (buf.length !== pkFull.length) return false;
+  let diff = 0;
+  for (let i = 0; i < buf.length; i++) diff |= buf[i] ^ pkFull[i];
+  return diff === 0;
 }
 
 /**
@@ -606,7 +618,10 @@ export function wotsVerifyDigest(sig: Uint8Array, message: Uint8Array, pkDigest:
   }
   
   const recomputed = F(buf);
-  return Buffer.from(recomputed).equals(Buffer.from(pkDigest));
+  if (recomputed.length !== pkDigest.length) return false;
+  let diff = 0;
+  for (let i = 0; i < recomputed.length; i++) diff |= recomputed[i] ^ pkDigest[i];
+  return diff === 0;
 }