@totemsdk/core 1.0.5 → 1.0.7

package/README.md

@@ -0,0 +1,90 @@
+# @totemsdk/core
+
+**The cryptographic engine — every other package depends on this.**
+
+Zero production dependencies (only `@noble/hashes` as a peer). Provides quantum-resistant WOTS signatures, hierarchical TreeKey address derivation, BIP39 seed phrases, Merkle Mountain Range proofs, and byte-exact Minima Java-compatible transaction serialization.
+
+## Install
+
+```bash
+npm install @totemsdk/core @noble/hashes
+```
+
+## What's inside
+
+| Module | What it does |
+|--------|-------------|
+| **WOTS** | `wotsKeypairFromSeed`, `wotsSign`, `wotsVerify`, `wotsPkFromSig` — quantum-resistant Winternitz One-Time Signatures |
+| **TreeKey** | `createPerAddressTreeKey`, `verifyTreeSignature` — 3-level hierarchical signing trees; one seed → many signing addresses |
+| **BIP39** | `generateSeedPhrase`, `validatePhrase`, `phraseToSeed` — 24-word mnemonic generation and recovery |
+| **MMR** | Full Merkle Mountain Range proof construction and verification for Minima's UTXO set |
+| **Serialization** | `serializeCoin`, `serializeTransaction`, `computeTransactionDigest`, `buildMinimaCoin` — byte-identical to the Minima Java node |
+| **Verification** | `verifySignatureDetailed`, `verifyTreeSignatureDetailed` — server-side auth helpers |
+| **Lease/Watermark** | `LeaseStore`, `WatermarkStore`, `LeaseMonitor` — WOTS key-use accounting to prevent catastrophic key reuse |
+| **TransactionService** | High-level prepare → sign → finalize lifecycle with receipt tracking |
+| **MINIMA_CONSTANTS** | Canonical chain parameters (`WOTS_W=8`, `MAX_SIGNATURES=262144`, `ADDRESS_PREFIX="Mx"`) |
+
+## Usage
+
+### WOTS keypair and signing
+
+```typescript
+import { wotsKeypairFromSeed, wotsSign, wotsVerify } from '@totemsdk/core';
+
+const seed = crypto.getRandomValues(new Uint8Array(32));
+const keypair = wotsKeypairFromSeed(seed, 0);
+
+// Sign — each (seed, index) pair is one-time use
+const signature = wotsSign(seed, 0, message);
+
+// Verify
+const ok = wotsVerify(signature, message, keypair.pk);
+```
+
+### Per-address TreeKey (matches Minima Wallet.java)
+
+```typescript
+import { createPerAddressTreeKey } from '@totemsdk/core';
+
+// One independent 3-level tree per address index (0–63)
+const treeKey = createPerAddressTreeKey(baseSeed, 0);
+
+// Convert watermark (l1, l2) to a flat counter
+const uses = l1 * 64 + l2;
+treeKey.setUses(uses);
+const { signature, publicKey, proofs } = treeKey.sign(data);
+```
+
+### Address derivation and verification
+
+```typescript
+import { scriptToAddress, publicKeyToScript, verifySignature } from '@totemsdk/core';
+
+const script   = publicKeyToScript(publicKeyHex);
+const address  = scriptToAddress(script); // "Mx..."
+
+const ok = verifySignature(address, message, signatureHex, publicKeyHex);
+```
+
+### Replay-safe challenge/response
+
+```typescript
+import { createChallenge, validateChallenge } from '@totemsdk/core';
+
+// Server: create a challenge
+const challenge = createChallenge('my-dapp.example.com');
+
+// Server: validate before accepting a signature
+const { valid, error } = validateChallenge(challenge, {
+  maxAgeMs: 5 * 60 * 1000,
+  expectedDomain: 'my-dapp.example.com',
+});
+```
+
+## See also
+
+- [`@totemsdk/connect`](../connect) — dApp gateway built on top of core
+- [`@totemsdk/node`](../node) — core wired for Node.js server-side use
+- [`@totemsdk/wots-lease`](../wots-lease) — cloud-coordinated WOTS key safety
+- [`@totemsdk/tx-builder`](../tx-builder) — full transaction construction
+- [`@totemsdk/root-identity`](../root-identity) — multi-address identity from one seed

package/dist/index.d.ts

@@ -8,7 +8,7 @@ export { LeaseStore, WatermarkStore, LeaseMonitor, prepareLease, finalizeLease,
 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 * from './utils.js';
-export { F, hex, fromHex, u16be, u32be, assert32, h, prfChainSeed, toWinternitzDigits, baseWWithChecksum, derivePKdigest, wotsKeypairFromSeed, wotsSign, wotsSignLegacy, wotsPkFromSig, wotsVerify, wotsPublicKeyFromSeed, type WotsKeypair, type WotsSignature, } from './wots.js';
+export { F, hex, fromHex, u16be, u32be, assert32, h, prfChainSeed, toWinternitzDigits, baseWWithChecksum, derivePKdigest, wotsKeypairFromSeed, wotsSign, wotsSignLegacy, wotsPkFromSig, wotsVerify, wotsVerifyDigest, wotsPublicKeyFromSeed, type WotsKeypair, type WotsSignature, } from './wots.js';
 export * from './params.js';
 export { serializeMiniNumber, serializeMiniData, hashAllObjects, deriveChainSeedJava, deriveChildTreeSeedJava, hashObject, serializeMiniNumberZERO, serializeMiniNumberONE, writeHashToStream, javaHashAllObjects, indexToMiniDataBytes, derivePerAddressSeed, createMMREntryNumber, serializeMMREntryNumber, serializeMMRData, serializeMMREntry, precomputeTransactionCoinID, type MMREntryNumber as JavaMMREntryNumber, type MMRData as JavaMMRData, type MMREntry as JavaMMREntry, } from './javaStreamables.js';
 export { TreeKey, type KeyGenProgress, type ProgressCallback, TreeKeyNode, verifyTreeSignature, serializeTreeSignature, deserializeTreeSignature, getRootPublicKey, DEFAULT_KEYS_PER_LEVEL, DEFAULT_LEVELS, type SignatureProof, type TreeSignature, createPerAddressTreeKey, createPerAddressTreeKeyAsync, deriveAddressPublicKey, getPerAddressPublicKey, } from './treekey.js';

package/dist/index.js

@@ -13,7 +13,7 @@ export { TransactionService, TransactionLifecycle, TransactionLifecycleError, Wa
 // Utilities first (canonical concatBytes source)
 export * from './utils.js';
 // WOTS Signatures - wots.concatBytes is intentionally shadowed by utils.concatBytes above
-export { F, hex, fromHex, u16be, u32be, assert32, h, prfChainSeed, toWinternitzDigits, baseWWithChecksum, derivePKdigest, wotsKeypairFromSeed, wotsSign, wotsSignLegacy, wotsPkFromSig, wotsVerify, wotsPublicKeyFromSeed, } from './wots.js';
+export { F, hex, fromHex, u16be, u32be, assert32, h, prfChainSeed, toWinternitzDigits, baseWWithChecksum, derivePKdigest, wotsKeypairFromSeed, wotsSign, wotsSignLegacy, wotsPkFromSig, wotsVerify, wotsVerifyDigest, wotsPublicKeyFromSeed, } from './wots.js';
 // WOTS Params (from params.ts, imported by wots.ts)
 export * from './params.js';
 // Java-Compatible Serialization Helpers (for Minima-compatible seed derivation)

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.5",
+  "version": "1.0.7",
   "description": "Core cryptographic primitives for Totem SDK",
   "type": "module",
   "main": "dist/index.js",
@@ -28,12 +28,6 @@
     },
     "./test-vectors.json": "./test-vectors.json"
   },
-  "scripts": {
-    "build": "tsc",
-    "clean": "rm -rf dist",
-    "test": "jest --passWithNoTests",
-    "gen:pkdigest": "node scripts/gen_wots_pkdigest_vectors.cjs"
-  },
   "files": [
     "dist",
     "src",
@@ -62,5 +56,11 @@
   "publishConfig": {
     "access": "public"
   },
-  "license": "MIT"
-}
+  "license": "MIT",
+  "scripts": {
+    "build": "tsc",
+    "clean": "rm -rf dist",
+    "test": "jest --passWithNoTests",
+    "gen:pkdigest": "node scripts/gen_wots_pkdigest_vectors.cjs"
+  }
+}

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

@@ -81,6 +81,7 @@ export {
   wotsSignLegacy,
   wotsPkFromSig,
   wotsVerify,
+  wotsVerifyDigest,
   wotsPublicKeyFromSeed,
   type WotsKeypair,
   type WotsSignature,

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;
 }