@totemsdk/root-identity 1.0.6 → 1.0.8

package/dist/UnifiedIdentityWallet.d.ts

@@ -0,0 +1,158 @@
+/**
+ * UnifiedIdentityWallet — single root identity with true hierarchical key derivation.
+ *
+ * Architecture
+ * ────────────
+ *  baseSeed (32 bytes)
+ *    │
+ *    ├── root_priv_seed = deriveRootPrivSeed(baseSeed)
+ *    │     └── rootTreeKey = createUnifiedRootTreeKey(baseSeed)  ← identity anchor (NEVER a spend address)
+ *    │
+ *    ├── child_seed_0 = deriveUnifiedChildSeed(baseSeed, 0)
+ *    │     └── childTreeKey_0                                     ← spend address 0
+ *    ├── child_seed_1 = deriveUnifiedChildSeed(baseSeed, 1)
+ *    │     └── childTreeKey_1                                     ← spend address 1
+ *    │   …
+ *    └── child_seed_N = deriveUnifiedChildSeed(baseSeed, N)
+ *          └── childTreeKey_N                                     ← spend address N
+ *
+ * Child seeds are cryptographically descended from root_priv_seed, not siblings.
+ * This enables genuine ancestral proofs: the root can prove control of any child
+ * without revealing relationships between children.
+ *
+ * Addresses are Minima-compatible: RETURN SIGNEDBY(treeKey.rootPubKey) scripts,
+ * WOTS proof-chain signatures. Nodes never see the derivation hierarchy.
+ *
+ * Watermarks are tracked in memory. Callers that need persistence should read
+ * `getRootUses()` / `getChildUses(index)` after each signing operation and
+ * restore them via `setRootUses()` / `setChildUses()` on the next session.
+ */
+import { type TreeKey } from '@totemsdk/core';
+import type { WotsProof, OwnershipProof } from './types.js';
+export declare const MAX_CHILD_COUNT = 64;
+export declare class UnifiedIdentityWallet {
+    private readonly baseSeed;
+    private readonly childCount;
+    /** Cached root TreeKey (identity anchor). Created lazily. */
+    private cachedRootTreeKey?;
+    /** Cached child TreeKey instances. Created lazily. */
+    private readonly childTreeKeyCache;
+    /** Cached addresses and public keys (populated on first access per key). */
+    private cachedRootAddress?;
+    private cachedRootPublicKey?;
+    private readonly childAddressCache;
+    private readonly childPubKeyCache;
+    /** Per-slot watermarks (in-memory; persist via getWatermarkState / restoreWatermarkState). */
+    private rootUses;
+    private readonly childUsesMap;
+    /**
+     * @param baseSeed   - 32-byte raw seed (use `UnifiedIdentityWallet.fromPhrase` for mnemonic input)
+     * @param childCount - Number of child addresses (1–64, default 64)
+     */
+    constructor(baseSeed: Uint8Array, childCount?: number);
+    /** Create a wallet from a Minima-compatible BIP39 seed phrase. */
+    static fromPhrase(phrase: string, childCount?: number): UnifiedIdentityWallet;
+    /** Generate a new random Minima-compatible 24-word seed phrase. */
+    static generatePhrase(): string;
+    /** Validate a Minima-compatible seed phrase. */
+    static validatePhrase(phrase: string): boolean;
+    /** Minima address for the root key. NEVER use this address for spending. */
+    getRootAddress(): string;
+    /** 64-char hex public key for the root key. */
+    getRootPublicKey(): string;
+    /** Minima spend address for child `index` (0-based). */
+    getChildAddress(index: number): string;
+    /** 64-char hex public key for child `index`. */
+    getChildPublicKey(index: number): string;
+    /** All addresses: root first, then all children in order. */
+    getAllAddresses(): string[];
+    /** Root address and children as a structured object. */
+    getAddressMap(): {
+        root: string;
+        children: string[];
+    };
+    /**
+     * Sign `message` with the root identity key (for off-chain attestations).
+     * Hashes the message with SHA3-256 before signing.
+     * @throws if root TreeKey is exhausted (262 144 uses)
+     */
+    signFromRoot(message: string): WotsProof;
+    /**
+     * Sign `message` with child key `index` (0-based) for on-chain transactions.
+     * Each child maintains its own independent use counter.
+     * @throws if child TreeKey is exhausted or index out of range
+     */
+    signFromChild(index: number, message: string): WotsProof;
+    /**
+     * Produce an ownership proof demonstrating that this root identity controls
+     * all given child addresses.
+     *
+     * The root key signs a canonical JSON message containing all child public keys
+     * (sorted) and a timestamp, enabling third-party verification without any
+     * network access.
+     *
+     * @param childIndices - Which children to include (0-based)
+     */
+    proveOwnership(childIndices: number[]): OwnershipProof;
+    /**
+     * Verify an ownership proof produced by `proveOwnership`.
+     *
+     * Returns `true` only when:
+     * - The canonical message is reconstructed correctly (child keys are sorted).
+     * - The root WOTS signature validates against the root public key and address.
+     * - Every child public key correctly derives the corresponding child address.
+     *
+     * Pure crypto — no network access required.
+     * Always returns `false` (never throws) on malformed or incomplete proof data.
+     */
+    static verifyOwnershipProof(proof: OwnershipProof): boolean;
+    /**
+     * Get (or create and cache) the TreeKey for child `index` (0-based).
+     *
+     * Use this for transaction signing — the child TreeKey is the spend key.
+     * Call `getChildUses` / `setChildUses` to manage the watermark manually.
+     */
+    getChildTreeKey(index: number): TreeKey;
+    /**
+     * Get (or create and cache) the root identity TreeKey.
+     *
+     * Use this only for off-chain attestation signing, not for spending.
+     */
+    getRootTreeKey(): TreeKey;
+    /** Number of times the root identity key has signed (for persistence). */
+    getRootUses(): number;
+    /** Restore root watermark from a previously persisted value. */
+    setRootUses(uses: number): void;
+    /** Number of times child `index` has signed (for persistence). */
+    getChildUses(index: number): number;
+    /** Restore child watermark from a previously persisted value. */
+    setChildUses(index: number, uses: number): void;
+    /** Number of child addresses configured for this wallet. */
+    getChildCount(): number;
+    /** Maximum one-time signatures available per slot (3 levels × 64 keys = 262 144). */
+    getMaxUsesPerSlot(): number;
+    /**
+     * Return a serialisable snapshot of all current watermark counters.
+     *
+     * Persist the returned object (e.g. to encrypted storage) and pass it back
+     * to `restoreWatermarkState()` at the start of the next session so that no
+     * one-time-use signing slot is ever reused.
+     */
+    getWatermarkState(): {
+        rootUses: number;
+        childUses: Record<number, number>;
+    };
+    /**
+     * Restore watermark counters from a previously persisted snapshot.
+     *
+     * Call this immediately after constructing the wallet to prevent slot reuse
+     * across sessions. Out-of-range or invalid entries are silently skipped.
+     */
+    restoreWatermarkState(state: {
+        rootUses?: number;
+        childUses?: Record<number, number>;
+    }): void;
+    private assertChildIndex;
+    private populateRootCache;
+    private getOrCreateChildTreeKey;
+}

package/dist/UnifiedIdentityWallet.js

@@ -0,0 +1,361 @@
+"use strict";
+/**
+ * UnifiedIdentityWallet — single root identity with true hierarchical key derivation.
+ *
+ * Architecture
+ * ────────────
+ *  baseSeed (32 bytes)
+ *    │
+ *    ├── root_priv_seed = deriveRootPrivSeed(baseSeed)
+ *    │     └── rootTreeKey = createUnifiedRootTreeKey(baseSeed)  ← identity anchor (NEVER a spend address)
+ *    │
+ *    ├── child_seed_0 = deriveUnifiedChildSeed(baseSeed, 0)
+ *    │     └── childTreeKey_0                                     ← spend address 0
+ *    ├── child_seed_1 = deriveUnifiedChildSeed(baseSeed, 1)
+ *    │     └── childTreeKey_1                                     ← spend address 1
+ *    │   …
+ *    └── child_seed_N = deriveUnifiedChildSeed(baseSeed, N)
+ *          └── childTreeKey_N                                     ← spend address N
+ *
+ * Child seeds are cryptographically descended from root_priv_seed, not siblings.
+ * This enables genuine ancestral proofs: the root can prove control of any child
+ * without revealing relationships between children.
+ *
+ * Addresses are Minima-compatible: RETURN SIGNEDBY(treeKey.rootPubKey) scripts,
+ * WOTS proof-chain signatures. Nodes never see the derivation hierarchy.
+ *
+ * Watermarks are tracked in memory. Callers that need persistence should read
+ * `getRootUses()` / `getChildUses(index)` after each signing operation and
+ * restore them via `setRootUses()` / `setChildUses()` on the next session.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UnifiedIdentityWallet = exports.MAX_CHILD_COUNT = void 0;
+const core_1 = require("@totemsdk/core");
+const core_2 = require("@totemsdk/core");
+exports.MAX_CHILD_COUNT = 64;
+const OWNERSHIP_OP = 'TOTEM_OWNERSHIP_PROOF_V1';
+// ─────────────────────────────────────────────────────────────────────────────
+// Helpers
+// ─────────────────────────────────────────────────────────────────────────────
+function hashMessage(message) {
+    return (0, core_1.sha3_256)(new TextEncoder().encode(message));
+}
+function addressFromPublicKeyBytes(pkBytes) {
+    const script = (0, core_2.scriptFromWotsPk)(pkBytes);
+    return (0, core_2.scriptToAddress)(script);
+}
+/**
+ * Build the deterministic ownership-proof message that the root key signs.
+ *
+ * Child public keys are sorted lexicographically before serialization so that
+ * the same child set always produces the same canonical message regardless of
+ * the order in which indices were passed to `proveOwnership`.
+ */
+function buildOwnershipMessage(rootAddress, childPublicKeys, timestamp) {
+    return JSON.stringify({
+        op: OWNERSHIP_OP,
+        rootAddress,
+        childPublicKeys: [...childPublicKeys].sort(),
+        timestamp,
+    });
+}
+// ─────────────────────────────────────────────────────────────────────────────
+// UnifiedIdentityWallet
+// ─────────────────────────────────────────────────────────────────────────────
+class UnifiedIdentityWallet {
+    // ── Construction ────────────────────────────────────────────────────────────
+    /**
+     * @param baseSeed   - 32-byte raw seed (use `UnifiedIdentityWallet.fromPhrase` for mnemonic input)
+     * @param childCount - Number of child addresses (1–64, default 64)
+     */
+    constructor(baseSeed, childCount = exports.MAX_CHILD_COUNT) {
+        /** Cached child TreeKey instances. Created lazily. */
+        this.childTreeKeyCache = new Map();
+        this.childAddressCache = new Map();
+        this.childPubKeyCache = new Map();
+        /** Per-slot watermarks (in-memory; persist via getWatermarkState / restoreWatermarkState). */
+        this.rootUses = 0;
+        this.childUsesMap = new Map();
+        if (baseSeed.length !== 32) {
+            throw new Error(`baseSeed must be exactly 32 bytes, got ${baseSeed.length}`);
+        }
+        if (childCount < 1 || childCount > exports.MAX_CHILD_COUNT) {
+            throw new Error(`childCount must be 1–${exports.MAX_CHILD_COUNT}, got ${childCount}`);
+        }
+        this.baseSeed = baseSeed;
+        this.childCount = childCount;
+    }
+    /** Create a wallet from a Minima-compatible BIP39 seed phrase. */
+    static fromPhrase(phrase, childCount = exports.MAX_CHILD_COUNT) {
+        return new UnifiedIdentityWallet((0, core_2.phraseToSeed)(phrase), childCount);
+    }
+    /** Generate a new random Minima-compatible 24-word seed phrase. */
+    static generatePhrase() {
+        return (0, core_2.generateSeedPhrase)();
+    }
+    /** Validate a Minima-compatible seed phrase. */
+    static validatePhrase(phrase) {
+        return (0, core_2.validatePhrase)(phrase);
+    }
+    // ── Address accessors ────────────────────────────────────────────────────────
+    /** Minima address for the root key. NEVER use this address for spending. */
+    getRootAddress() {
+        if (!this.cachedRootAddress) {
+            this.populateRootCache();
+        }
+        return this.cachedRootAddress;
+    }
+    /** 64-char hex public key for the root key. */
+    getRootPublicKey() {
+        if (!this.cachedRootPublicKey) {
+            this.populateRootCache();
+        }
+        return this.cachedRootPublicKey;
+    }
+    /** Minima spend address for child `index` (0-based). */
+    getChildAddress(index) {
+        this.assertChildIndex(index);
+        if (!this.childAddressCache.has(index)) {
+            this.getOrCreateChildTreeKey(index);
+        }
+        return this.childAddressCache.get(index);
+    }
+    /** 64-char hex public key for child `index`. */
+    getChildPublicKey(index) {
+        this.assertChildIndex(index);
+        if (!this.childPubKeyCache.has(index)) {
+            this.getOrCreateChildTreeKey(index);
+        }
+        return this.childPubKeyCache.get(index);
+    }
+    /** All addresses: root first, then all children in order. */
+    getAllAddresses() {
+        const out = [this.getRootAddress()];
+        for (let i = 0; i < this.childCount; i++) {
+            out.push(this.getChildAddress(i));
+        }
+        return out;
+    }
+    /** Root address and children as a structured object. */
+    getAddressMap() {
+        const children = [];
+        for (let i = 0; i < this.childCount; i++) {
+            children.push(this.getChildAddress(i));
+        }
+        return { root: this.getRootAddress(), children };
+    }
+    // ── Signing ─────────────────────────────────────────────────────────────────
+    /**
+     * Sign `message` with the root identity key (for off-chain attestations).
+     * Hashes the message with SHA3-256 before signing.
+     * @throws if root TreeKey is exhausted (262 144 uses)
+     */
+    signFromRoot(message) {
+        const treeKey = this.getRootTreeKey();
+        treeKey.setUses(this.rootUses);
+        const sig = treeKey.sign(hashMessage(message));
+        this.rootUses++;
+        return {
+            address: this.getRootAddress(),
+            publicKey: this.getRootPublicKey(),
+            signature: (0, core_2.bytesToHex)((0, core_2.serializeTreeSignature)(sig)),
+            message,
+        };
+    }
+    /**
+     * Sign `message` with child key `index` (0-based) for on-chain transactions.
+     * Each child maintains its own independent use counter.
+     * @throws if child TreeKey is exhausted or index out of range
+     */
+    signFromChild(index, message) {
+        this.assertChildIndex(index);
+        const treeKey = this.getOrCreateChildTreeKey(index);
+        const uses = this.childUsesMap.get(index) ?? 0;
+        treeKey.setUses(uses);
+        const sig = treeKey.sign(hashMessage(message));
+        this.childUsesMap.set(index, uses + 1);
+        return {
+            address: this.getChildAddress(index),
+            publicKey: this.getChildPublicKey(index),
+            signature: (0, core_2.bytesToHex)((0, core_2.serializeTreeSignature)(sig)),
+            message,
+        };
+    }
+    // ── Ownership proofs ─────────────────────────────────────────────────────────
+    /**
+     * Produce an ownership proof demonstrating that this root identity controls
+     * all given child addresses.
+     *
+     * The root key signs a canonical JSON message containing all child public keys
+     * (sorted) and a timestamp, enabling third-party verification without any
+     * network access.
+     *
+     * @param childIndices - Which children to include (0-based)
+     */
+    proveOwnership(childIndices) {
+        if (childIndices.length === 0) {
+            throw new Error('childIndices must contain at least one index');
+        }
+        const seen = new Set();
+        for (const idx of childIndices) {
+            this.assertChildIndex(idx);
+            if (seen.has(idx))
+                throw new Error(`Duplicate child index: ${idx}`);
+            seen.add(idx);
+        }
+        const timestamp = new Date().toISOString();
+        const childAddresses = childIndices.map(i => this.getChildAddress(i));
+        const childPublicKeys = childIndices.map(i => this.getChildPublicKey(i));
+        const rootAddress = this.getRootAddress();
+        const rootPublicKey = this.getRootPublicKey();
+        const message = buildOwnershipMessage(rootAddress, childPublicKeys, timestamp);
+        const rootProof = this.signFromRoot(message);
+        return { rootAddress, rootPublicKey, childAddresses, childPublicKeys, rootProof, timestamp };
+    }
+    /**
+     * Verify an ownership proof produced by `proveOwnership`.
+     *
+     * Returns `true` only when:
+     * - The canonical message is reconstructed correctly (child keys are sorted).
+     * - The root WOTS signature validates against the root public key and address.
+     * - Every child public key correctly derives the corresponding child address.
+     *
+     * Pure crypto — no network access required.
+     * Always returns `false` (never throws) on malformed or incomplete proof data.
+     */
+    static verifyOwnershipProof(proof) {
+        try {
+            if (!proof || typeof proof !== 'object')
+                return false;
+            const { rootAddress, rootPublicKey, childAddresses, childPublicKeys, rootProof, timestamp } = proof;
+            if (!rootAddress || !rootPublicKey || !timestamp ||
+                !Array.isArray(childAddresses) || !Array.isArray(childPublicKeys) ||
+                !rootProof || typeof rootProof.signature !== 'string') {
+                return false;
+            }
+            if (childAddresses.length === 0)
+                return false;
+            if (childAddresses.length !== childPublicKeys.length)
+                return false;
+            const canonicalMessage = buildOwnershipMessage(rootAddress, childPublicKeys, timestamp);
+            if (rootProof.message !== canonicalMessage)
+                return false;
+            const sigResult = (0, core_2.verifySignatureDetailed)(rootAddress, canonicalMessage, rootProof.signature, rootPublicKey);
+            if (!sigResult.valid)
+                return false;
+            for (let i = 0; i < childPublicKeys.length; i++) {
+                const pkBytes = (0, core_2.hexToBytes)(childPublicKeys[i]);
+                const derivedAddress = addressFromPublicKeyBytes(pkBytes);
+                if (derivedAddress.toLowerCase() !== childAddresses[i].toLowerCase())
+                    return false;
+            }
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    // ── TreeKey access (for low-level transaction signing) ───────────────────────
+    /**
+     * Get (or create and cache) the TreeKey for child `index` (0-based).
+     *
+     * Use this for transaction signing — the child TreeKey is the spend key.
+     * Call `getChildUses` / `setChildUses` to manage the watermark manually.
+     */
+    getChildTreeKey(index) {
+        this.assertChildIndex(index);
+        return this.getOrCreateChildTreeKey(index);
+    }
+    /**
+     * Get (or create and cache) the root identity TreeKey.
+     *
+     * Use this only for off-chain attestation signing, not for spending.
+     */
+    getRootTreeKey() {
+        if (!this.cachedRootTreeKey) {
+            this.cachedRootTreeKey = (0, core_2.createUnifiedRootTreeKey)(this.baseSeed);
+        }
+        return this.cachedRootTreeKey;
+    }
+    // ── Watermark access ─────────────────────────────────────────────────────────
+    /** Number of times the root identity key has signed (for persistence). */
+    getRootUses() { return this.rootUses; }
+    /** Restore root watermark from a previously persisted value. */
+    setRootUses(uses) {
+        if (uses < 0)
+            throw new Error('uses must be non-negative');
+        this.rootUses = uses;
+    }
+    /** Number of times child `index` has signed (for persistence). */
+    getChildUses(index) {
+        this.assertChildIndex(index);
+        return this.childUsesMap.get(index) ?? 0;
+    }
+    /** Restore child watermark from a previously persisted value. */
+    setChildUses(index, uses) {
+        this.assertChildIndex(index);
+        if (uses < 0)
+            throw new Error('uses must be non-negative');
+        this.childUsesMap.set(index, uses);
+    }
+    /** Number of child addresses configured for this wallet. */
+    getChildCount() { return this.childCount; }
+    /** Maximum one-time signatures available per slot (3 levels × 64 keys = 262 144). */
+    getMaxUsesPerSlot() { return 64 * 64 * 64; }
+    /**
+     * Return a serialisable snapshot of all current watermark counters.
+     *
+     * Persist the returned object (e.g. to encrypted storage) and pass it back
+     * to `restoreWatermarkState()` at the start of the next session so that no
+     * one-time-use signing slot is ever reused.
+     */
+    getWatermarkState() {
+        const childUses = {};
+        for (const [index, uses] of this.childUsesMap) {
+            childUses[index] = uses;
+        }
+        return { rootUses: this.rootUses, childUses };
+    }
+    /**
+     * Restore watermark counters from a previously persisted snapshot.
+     *
+     * Call this immediately after constructing the wallet to prevent slot reuse
+     * across sessions. Out-of-range or invalid entries are silently skipped.
+     */
+    restoreWatermarkState(state) {
+        if (typeof state?.rootUses === 'number' && state.rootUses >= 0) {
+            this.rootUses = Math.floor(state.rootUses);
+        }
+        if (state?.childUses && typeof state.childUses === 'object') {
+            for (const [key, uses] of Object.entries(state.childUses)) {
+                const index = Number(key);
+                if (Number.isInteger(index) && index >= 0 && index < this.childCount && typeof uses === 'number' && uses >= 0) {
+                    this.childUsesMap.set(index, Math.floor(uses));
+                }
+            }
+        }
+    }
+    // ── Private helpers ──────────────────────────────────────────────────────────
+    assertChildIndex(index) {
+        if (!Number.isInteger(index) || index < 0 || index >= this.childCount) {
+            throw new Error(`Child index ${index} is out of range [0, ${this.childCount - 1}]`);
+        }
+    }
+    populateRootCache() {
+        const pkBytes = this.getRootTreeKey().getPublicKey();
+        this.cachedRootPublicKey = (0, core_2.bytesToHex)(pkBytes);
+        this.cachedRootAddress = addressFromPublicKeyBytes(pkBytes);
+    }
+    getOrCreateChildTreeKey(index) {
+        const cached = this.childTreeKeyCache.get(index);
+        if (cached)
+            return cached;
+        const treeKey = (0, core_2.createUnifiedChildTreeKey)(this.baseSeed, index);
+        this.childTreeKeyCache.set(index, treeKey);
+        const pkBytes = treeKey.getPublicKey();
+        this.childPubKeyCache.set(index, (0, core_2.bytesToHex)(pkBytes));
+        this.childAddressCache.set(index, addressFromPublicKeyBytes(pkBytes));
+        return treeKey;
+    }
+}
+exports.UnifiedIdentityWallet = UnifiedIdentityWallet;

package/dist/index.d.ts

@@ -2,7 +2,13 @@
  * @module @totemsdk/root-identity
  *
  * Single root identity controlling up to 64 on-chain Minima addresses,
- * all cryptographically linked via full independent 3-level WOTS TreeKeys.
+ * all cryptographically linked via genuine hierarchical key derivation.
+ *
+ * Architecture:
+ *   root_priv_seed  = deriveRootPrivSeed(baseSeed)
+ *   child_seed_i    = deriveUnifiedChildSeed(baseSeed, i)
+ *   rootTreeKey     = TreeKey(root_priv_seed)  ← identity anchor, never spent
+ *   childTreeKey_i  = TreeKey(child_seed_i)    ← Minima spend address i
  *
  * Use cases:
  *  - Chain-of-custody proofs
@@ -10,5 +16,6 @@
  *  - Privacy-preserving KYC (selective disclosure)
  *  - NFT / token ownership linking
  */
-export { RootIdentityWallet, MAX_CHILD_COUNT } from './RootIdentityWallet.js';
+export { UnifiedIdentityWallet, MAX_CHILD_COUNT } from './UnifiedIdentityWallet.js';
+export { UnifiedIdentityWallet as RootIdentityWallet } from './UnifiedIdentityWallet.js';
 export type { WotsProof, OwnershipProof } from './types.js';

package/dist/index.js

@@ -3,7 +3,13 @@
  * @module @totemsdk/root-identity
  *
  * Single root identity controlling up to 64 on-chain Minima addresses,
- * all cryptographically linked via full independent 3-level WOTS TreeKeys.
+ * all cryptographically linked via genuine hierarchical key derivation.
+ *
+ * Architecture:
+ *   root_priv_seed  = deriveRootPrivSeed(baseSeed)
+ *   child_seed_i    = deriveUnifiedChildSeed(baseSeed, i)
+ *   rootTreeKey     = TreeKey(root_priv_seed)  ← identity anchor, never spent
+ *   childTreeKey_i  = TreeKey(child_seed_i)    ← Minima spend address i
  *
  * Use cases:
  *  - Chain-of-custody proofs
@@ -12,7 +18,9 @@
  *  - NFT / token ownership linking
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.MAX_CHILD_COUNT = exports.RootIdentityWallet = void 0;
-var RootIdentityWallet_js_1 = require("./RootIdentityWallet.js");
-Object.defineProperty(exports, "RootIdentityWallet", { enumerable: true, get: function () { return RootIdentityWallet_js_1.RootIdentityWallet; } });
-Object.defineProperty(exports, "MAX_CHILD_COUNT", { enumerable: true, get: function () { return RootIdentityWallet_js_1.MAX_CHILD_COUNT; } });
+exports.RootIdentityWallet = exports.MAX_CHILD_COUNT = exports.UnifiedIdentityWallet = void 0;
+var UnifiedIdentityWallet_js_1 = require("./UnifiedIdentityWallet.js");
+Object.defineProperty(exports, "UnifiedIdentityWallet", { enumerable: true, get: function () { return UnifiedIdentityWallet_js_1.UnifiedIdentityWallet; } });
+Object.defineProperty(exports, "MAX_CHILD_COUNT", { enumerable: true, get: function () { return UnifiedIdentityWallet_js_1.MAX_CHILD_COUNT; } });
+var UnifiedIdentityWallet_js_2 = require("./UnifiedIdentityWallet.js");
+Object.defineProperty(exports, "RootIdentityWallet", { enumerable: true, get: function () { return UnifiedIdentityWallet_js_2.UnifiedIdentityWallet; } });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@totemsdk/root-identity",
-  "version": "1.0.6",
+  "version": "1.0.8",
   "description": "Single root identity controlling up to 64 on-chain addresses — all cryptographically linked via full independent 3-level TreeKeys",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -10,22 +10,20 @@
       "bare": "./dist/index.js",
       "browser": "./dist/index.js",
       "import": "./dist/index.js",
-      "require": "./dist/index.cjs"
+      "require": "./dist/index.js"
     }
   },
   "files": [
     "dist",
+    "rust/pkg/",
+    "rust/pkg-node/",
     "README.md",
     "LICENSE"
   ],
   "peerDependencies": {
-    "@noble/hashes": "^2.0.0",
-    "@totemsdk/core": ">=1.0.1"
+    "@totemsdk/core": "^1.2.8"
   },
   "peerDependenciesMeta": {
-    "@noble/hashes": {
-      "optional": false
-    },
     "@totemsdk/core": {
       "optional": false
     }
@@ -38,13 +36,12 @@
     "access": "public"
   },
   "devDependencies": {
-    "@noble/hashes": "^2.2.0",
-    "@types/jest": "^29.0.0",
+    "@types/jest": "^30.0.0",
     "@types/node": "^20.0.0",
-    "jest": "^29.0.0",
+    "jest": "^30.4.2",
     "ts-jest": "^29.0.0",
-    "typescript": "^5.0.0",
-    "@totemsdk/core": "1.0.10"
+    "typescript": "^7.0.2",
+    "@totemsdk/core": "^1.2.8"
   },
   "keywords": [
     "totem",
@@ -53,7 +50,6 @@
     "blockchain",
     "quantum-resistant",
     "wots",
-    "kissvm",
     "utxo",
     "identity",
     "did",
@@ -63,19 +59,20 @@
   ],
   "author": "Totem SDK",
   "license": "MIT",
-  "homepage": "https://totemsdk.com",
+  "homepage": "https://totem.ing",
   "bugs": {
-    "url": "https://github.com/MrGheek/axia-totem/issues"
+    "url": "https://github.com/totem-sdk/totem-sdk/issues"
   },
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/MrGheek/axia-totem.git",
-    "directory": "packages/totem-sdk/packages/root-identity"
+    "url": "git+https://github.com/totem-sdk/totem-sdk.git",
+    "directory": "packages/root-identity"
   },
   "scripts": {
-    "build": "tsc",
-    "clean": "rm -rf dist",
+    "build": "npm run build:wasm && tsc && node ../../scripts/clean-wasm-output-ignores.mjs",
+    "clean": "rm -rf dist rust/pkg rust/pkg-node rust/target",
     "pretest": "cd ../core && npm run build",
-    "test": "node --experimental-vm-modules node_modules/jest/bin/jest.js --passWithNoTests"
+    "test": "jest",
+    "build:wasm": "cd rust && wasm-pack build --target bundler --out-dir pkg && wasm-pack build --target nodejs --out-dir pkg-node"
   }
 }