@majikah/majik-key 0.7.0 → 1.0.1

package/dist/core/keys/registry.js

@@ -0,0 +1,144 @@
+/**
+ * registry.ts — Phase 1 skeleton: DEFINITIONS ONLY (no derive/encrypt yet).
+ * Phase 2 attaches derive()/publicFromSecret() implementations to each entry.
+ */
+import { MajikKeyError } from "../error.js";
+import { CORE_KEYS, KeyId, keyFamilyOf } from "./key-id.js";
+const hkdf = (id) => ({
+    scheme: "hkdf-sha512-v1",
+    version: 1,
+    info: `majik/v1/${id}`,
+});
+const legacy = (note) => ({
+    scheme: "legacy-v1",
+    version: 1,
+    note,
+});
+function def(id, purpose, standard, derivation, opts = {}) {
+    return {
+        id,
+        family: keyFamilyOf(id),
+        purpose,
+        kind: opts.kind ?? "stored",
+        status: opts.status ?? "stable",
+        implemented: opts.implemented ?? false,
+        standard,
+        derivation,
+        derivedFrom: opts.derivedFrom,
+        note: opts.note,
+    };
+}
+const SLH = (id, variant) => def(id, "signature", `FIPS 205 (${variant})`, hkdf(id), {
+    implemented: true,
+});
+export const KEY_ALGORITHMS = Object.freeze({
+    // ── classic ── (legacy recipes are frozen; see vectors/legacy-v1.vectors.json)
+    [KeyId.X25519]: def(KeyId.X25519, "key-agreement", "RFC 7748", {
+        scheme: "ed2curve",
+        version: 1,
+        note: "ed2curve(classic:ed25519); account id/fingerprint anchor",
+    }, { implemented: true }),
+    [KeyId.ED25519]: def(KeyId.ED25519, "signature", "RFC 8032", legacy("BIP-39 seed[0..32]"), { implemented: true }),
+    // ── pq KEM ──
+    [KeyId.ML_KEM_512]: def(KeyId.ML_KEM_512, "kem", "FIPS 203", hkdf(KeyId.ML_KEM_512), { implemented: true }),
+    [KeyId.ML_KEM_768]: def(KeyId.ML_KEM_768, "kem", "FIPS 203", legacy("full 64-byte BIP-39 seed"), { implemented: true }),
+    [KeyId.ML_KEM_1024]: def(KeyId.ML_KEM_1024, "kem", "FIPS 203", hkdf(KeyId.ML_KEM_1024), { implemented: true }),
+    [KeyId.HQC_128]: def(KeyId.HQC_128, "kem", "NIST HQC (draft)", hkdf(KeyId.HQC_128), {
+        status: "reserved",
+        note: "NIST backup KEM; standard not final and no vetted JS implementation in the current dependency set.",
+    }),
+    [KeyId.HQC_192]: def(KeyId.HQC_192, "kem", "NIST HQC (draft)", hkdf(KeyId.HQC_192), { status: "reserved", note: "See pq:hqc-128." }),
+    [KeyId.HQC_256]: def(KeyId.HQC_256, "kem", "NIST HQC (draft)", hkdf(KeyId.HQC_256), { status: "reserved", note: "See pq:hqc-128." }),
+    // ── pq signatures ──
+    [KeyId.ML_DSA_44]: def(KeyId.ML_DSA_44, "signature", "FIPS 204", hkdf(KeyId.ML_DSA_44), { implemented: true }),
+    [KeyId.ML_DSA_65]: def(KeyId.ML_DSA_65, "signature", "FIPS 204", hkdf(KeyId.ML_DSA_65), { implemented: true }),
+    [KeyId.ML_DSA_87]: def(KeyId.ML_DSA_87, "signature", "FIPS 204", legacy('sha256(seed64 || "MajikSignatureSeedDSA")'), { implemented: true }),
+    [KeyId.SLH_DSA_SHA2_128S]: SLH(KeyId.SLH_DSA_SHA2_128S, "SHA2-128s"),
+    [KeyId.SLH_DSA_SHA2_128F]: SLH(KeyId.SLH_DSA_SHA2_128F, "SHA2-128f"),
+    [KeyId.SLH_DSA_SHA2_192S]: SLH(KeyId.SLH_DSA_SHA2_192S, "SHA2-192s"),
+    [KeyId.SLH_DSA_SHA2_192F]: SLH(KeyId.SLH_DSA_SHA2_192F, "SHA2-192f"),
+    [KeyId.SLH_DSA_SHA2_256S]: SLH(KeyId.SLH_DSA_SHA2_256S, "SHA2-256s"),
+    [KeyId.SLH_DSA_SHA2_256F]: SLH(KeyId.SLH_DSA_SHA2_256F, "SHA2-256f"),
+    [KeyId.SLH_DSA_SHAKE_128S]: SLH(KeyId.SLH_DSA_SHAKE_128S, "SHAKE-128s"),
+    [KeyId.SLH_DSA_SHAKE_128F]: SLH(KeyId.SLH_DSA_SHAKE_128F, "SHAKE-128f"),
+    [KeyId.SLH_DSA_SHAKE_192S]: SLH(KeyId.SLH_DSA_SHAKE_192S, "SHAKE-192s"),
+    [KeyId.SLH_DSA_SHAKE_192F]: SLH(KeyId.SLH_DSA_SHAKE_192F, "SHAKE-192f"),
+    [KeyId.SLH_DSA_SHAKE_256S]: SLH(KeyId.SLH_DSA_SHAKE_256S, "SHAKE-256s"),
+    [KeyId.SLH_DSA_SHAKE_256F]: SLH(KeyId.SLH_DSA_SHAKE_256F, "SHAKE-256f"),
+    [KeyId.FALCON_512]: def(KeyId.FALCON_512, "signature", "Falcon (NIST PQC Round 3)", hkdf(KeyId.FALCON_512), {
+        status: "experimental",
+        implemented: true,
+        note: "Round 3 Falcon, NOT FIPS 206. FN-DSA is expected to be incompatible; it will get its own ids.",
+    }),
+    [KeyId.FALCON_1024]: def(KeyId.FALCON_1024, "signature", "Falcon (NIST PQC Round 3)", hkdf(KeyId.FALCON_1024), { status: "experimental", implemented: true, note: "See pq:falcon-512." }),
+    [KeyId.FN_DSA_512]: def(KeyId.FN_DSA_512, "signature", "FIPS 206 (draft)", hkdf(KeyId.FN_DSA_512), {
+        status: "reserved",
+        note: "Reserved until FIPS 206 is final and an implementation tracks it.",
+    }),
+    [KeyId.FN_DSA_1024]: def(KeyId.FN_DSA_1024, "signature", "FIPS 206 (draft)", hkdf(KeyId.FN_DSA_1024), { status: "reserved", note: "See pq:fn-dsa-512." }),
+    [KeyId.LMS]: def(KeyId.LMS, "signature", "NIST SP 800-208 / RFC 8554", hkdf(KeyId.LMS), {
+        status: "unsupported",
+        note: "Stateful: every signature consumes a one-time key index. Mnemonic recovery, backups and multi-device use " +
+            "all reset that state and make one-time-key reuse (total forgery) likely. Not offered as a stored signing key.",
+    }),
+    // ── web3 ──
+    [KeyId.BTC]: def(KeyId.BTC, "wallet", "BIP-32 / BIP-84", {
+        scheme: "bip32",
+        version: 1,
+        path: "m/84'/1971'/0'/0/0",
+        note: "Majik domain-separated path (legacy default)",
+    }, { implemented: true }),
+    [KeyId.ETH]: def(KeyId.ETH, "wallet", "BIP-32 / BIP-44 (SLIP-44 coin 60)", {
+        scheme: "bip32",
+        version: 1,
+        path: "m/44'/60'/0'/0/0",
+        note: "Standard path: MetaMask-compatible",
+    }, { implemented: true }),
+    [KeyId.SOL]: def(KeyId.SOL, "wallet", "Ed25519 (Solana)", {
+        scheme: "derived-view",
+        version: 1,
+        note: 'sha256(edSeed || "MajikKeySolanaSeed")',
+    }, { kind: "derived", derivedFrom: KeyId.ED25519, implemented: true }),
+});
+const ORDER = Object.keys(KEY_ALGORITHMS);
+export function getAlgorithm(id) {
+    return KEY_ALGORITHMS[id];
+}
+/** Everything the registry knows, in canonical order (includes reserved/unsupported). */
+export function knownKeyIds(family) {
+    return family ? ORDER.filter((id) => keyFamilyOf(id) === family) : [...ORDER];
+}
+/** Ids that can actually be enabled today. */
+export function enableableKeyIds() {
+    return ORDER.filter((id) => {
+        const d = KEY_ALGORITHMS[id];
+        return (d.implemented && (d.status === "stable" || d.status === "experimental"));
+    });
+}
+/**
+ * Validate a caller's `keys` option and return the STORED key ids to create:
+ * CORE_KEYS ∪ requested, de-duplicated, canonical order. Derived views
+ * (e.g. web3:sol) are accepted as no-ops because they require a stored key
+ * that is already in the core set.
+ */
+export function resolveRequestedKeys(requested = []) {
+    const stored = new Set(CORE_KEYS);
+    for (const raw of requested) {
+        const d = getAlgorithm(raw);
+        if (!d)
+            throw new MajikKeyError(`Unknown key algorithm "${raw}"`);
+        if (d.status === "unsupported")
+            throw new MajikKeyError(`"${raw}" is not supported: ${d.note}`);
+        if (d.status === "reserved")
+            throw new MajikKeyError(`"${raw}" is reserved and cannot be enabled yet: ${d.note}`);
+        if (!d.implemented)
+            throw new MajikKeyError(`"${raw}" is defined but not implemented in this version`);
+        if (d.kind === "derived") {
+            if (d.derivedFrom)
+                stored.add(d.derivedFrom);
+            continue;
+        }
+        stored.add(d.id);
+    }
+    return ORDER.filter((id) => stored.has(id));
+}

package/dist/core/keys/types.d.ts

@@ -0,0 +1,47 @@
+import type { KeyFamily, KeyId } from "./key-id.js";
+export type KeyPurpose = "kem" | "key-agreement" | "signature" | "wallet";
+/**
+ * stable       — standardized or production-grade, safe to enable
+ * experimental — works, but the spec/impl may change (ids stay, derivation may be versioned)
+ * reserved     — id is claimed but cannot be enabled yet (no vetted impl / standard not final)
+ * unsupported  — deliberately not offered (see `note`)
+ */
+export type KeyStatus = "stable" | "experimental" | "reserved" | "unsupported";
+export interface KeyDerivation {
+    /** "legacy-v1" (frozen pre-registry recipes) | "hkdf-sha512-v1" | "bip32" | "ed2curve" | "derived-view" */
+    scheme: string;
+    version: number;
+    /** HKDF info string, e.g. "majik/v1/pq:ml-kem-1024". */
+    info?: string;
+    /** BIP-32 path for web3 keys. */
+    path?: string;
+    /** Free-form human note (e.g. "ed2curve(classic:ed25519)"). */
+    note?: string;
+}
+/** One stored entry inside `MajikKeyJSON.keys`. No raw secret ever lives here. */
+export interface KeyEntryJSON {
+    id: KeyId;
+    /** Base64 public key. */
+    publicKey: string;
+    /** Base64 AES-256-GCM (IV || ciphertext) under the account's passphrase-derived key. */
+    encryptedSecretKey?: string;
+    derivation: KeyDerivation;
+    createdAt?: string;
+}
+export interface KeyAlgorithmDefinition {
+    id: KeyId;
+    family: KeyFamily;
+    purpose: KeyPurpose;
+    /** "stored" = encrypted at rest in `keys`; "derived" = computed on demand from another key. */
+    kind: "stored" | "derived";
+    status: KeyStatus;
+    /** True once derive/encrypt/decrypt are wired up in the registry (phase 2+). */
+    implemented: boolean;
+    /** Standard / spec this follows. */
+    standard: string;
+    /** Recipe used when this key is derived for NEW accounts. Legacy accounts keep "legacy-v1". */
+    derivation: KeyDerivation;
+    /** For derived views: the stored key it is computed from. */
+    derivedFrom?: KeyId;
+    note?: string;
+}

package/dist/core/keys/types.js

@@ -0,0 +1 @@
+export {};

package/dist/core/types.d.ts

@@ -1,4 +1,5 @@
-import { MnemonicLanguage } from "./crypto/wordlist";
+import { MnemonicLanguage } from "./crypto/wordlist.js";
+import { KeyEntryJSON } from "./keys/types.js";
 /** ISO 8601 timestamp string, e.g. `"2026-07-11T00:00:00.000Z"`. */
 export type ISODateString = string;
 /** Base64-encoded public key material. Safe to store, log, or transmit. */
@@ -69,6 +70,10 @@ export interface MajikKeyJSON {
     encryptedBtcSecretKey?: string;
     /** BIP-39 wordlist language the original mnemonic was generated/validated against. Defaults to `"en"`. */
     mnemonicLanguage?: MnemonicLanguage;
+    /** Registry schema version. Absent on pre-registry JSON. */
+    keysVersion?: number;
+    /** Every keypair on the account (public key + passphrase-encrypted secret + derivation). */
+    keys?: KeyEntryJSON[];
 }
 /**
  * ⚠️ DANGEROUS. Every field below is a *raw, unencrypted* private key,
@@ -93,6 +98,8 @@ export interface MajikKeyDangerousJSON extends MajikKeyJSON {
     mlDsaSecretKeyBase64: string;
     /** @experimental ⚠️ Raw Bitcoin private key, base64. Unencrypted. */
     btcSecretKeyBase64?: string;
+    /** ⚠️ Raw secret of every stored key, base64, keyed by namespaced id. Unencrypted. */
+    secretKeys?: Record<string, string>;
 }
 /**
  * Lightweight, non-secret summary of a MajikKey — useful for account
@@ -119,8 +126,12 @@ export interface MajikKeyMetadata {
         hasBitcoin?: boolean;
         /** @experimental `true` if this account can derive a Solana keypair (i.e. has an Ed25519 signing key and is unlocked). */
         hasSolana?: boolean;
+        /** @experimental `true` if this account has a stored Ethereum keypair. */
+        hasEthereum?: boolean;
     };
     mnemonicLanguage?: MnemonicLanguage;
+    /** Namespaced ids of every key available on the account. */
+    keys?: string[];
 }
 /**
  * Portable seed export — the format behind `toMnemonicJSON()` /

package/dist/core/utils.d.ts

@@ -1,4 +1,4 @@
-import { MnemonicJSON } from "./types";
+import { MnemonicJSON } from "./types.js";
 export declare function keyToBase64(key: CryptoKey | {
     raw: Uint8Array;
 }): Promise<string>;

package/dist/core/utils.js

@@ -1,7 +1,7 @@
 /* ================================
  * Utilities
  * ================================ */
-import { KEY_ALGO } from "./crypto/constants";
+import { KEY_ALGO } from "./crypto/constants.js";
 export async function keyToBase64(key) {
     const anyKey = key;
     if (anyKey && anyKey.raw instanceof Uint8Array) {

package/dist/core/validator.d.ts

@@ -1,4 +1,4 @@
-import { MajikKeyJSON } from "./types";
+import { MajikKeyJSON } from "./types.js";
 export declare class MajikKeyValidator {
     static validateMnemonic(mnemonic: string): void;
     static validatePassphrase(passphrase: string, fieldName?: string): void;

package/dist/core/validator.js

@@ -1,7 +1,7 @@
 /* -------------------------------
  * Validators
  * ------------------------------- */
-import { MajikKeyError } from "./error";
+import { MajikKeyError } from "./error.js";
 export class MajikKeyValidator {
     static validateMnemonic(mnemonic) {
         if (!mnemonic || typeof mnemonic !== "string") {

package/dist/core/web3/bitcoin/bitcoin.d.ts

@@ -23,7 +23,7 @@
  *     installed, we throw a clear, actionable MajikKeyError instead of
  *     failing module load.
  */
-import { BitcoinRawPublicKey } from "../../types";
+import { BitcoinRawPublicKey } from "../../types.js";
 export interface BitcoinKeypairMaterial {
     /** 32-byte secp256k1 private key. */
     privateKey: Uint8Array;

package/dist/core/web3/bitcoin/bitcoin.js

@@ -25,10 +25,10 @@
  */
 import { HDKey } from "@scure/bip32";
 import { schnorr, secp256k1 } from "@noble/curves/secp256k1.js";
-import { MAJIK_BITCOIN_STANDARD_PATH, MAJIK_BITCOIN_DOMAIN_PATH, } from "./constants";
+import { MAJIK_BITCOIN_STANDARD_PATH, MAJIK_BITCOIN_DOMAIN_PATH, } from "./constants.js";
 import { hash } from "@stablelib/sha256";
-import { base58Encode } from "../utils";
-import { MajikKeyError } from "../../error";
+import { base58Encode } from "../utils.js";
+import { MajikKeyError } from "../../error.js";
 import { randomBytes } from "@noble/hashes/utils.js";
 // ─── Derivation ─────────────────────────────────────────────────────────────
 /**

package/dist/core/web3/bitcoin/types.d.ts

@@ -1,4 +1,4 @@
-import { BitcoinRawPublicKey } from "../../types";
+import { BitcoinRawPublicKey } from "../../types.js";
 /**
  * @experimental By default this is Majik's DOMAIN-SEPARATED Bitcoin key
  * (derived via `MAJIK_BITCOIN_DOMAIN_PATH`) — deterministic and fully

package/dist/core/web3/ethereum/constants.d.ts

@@ -0,0 +1 @@
+export declare const MAJIK_ETHEREUM_STANDARD_PATH = "m/44'/60'/0'/0/0";

package/dist/core/web3/ethereum/constants.js

@@ -0,0 +1,4 @@
+// SLIP-44 coin type 60 = Ethereum. The path MetaMask, Ledger, Trezor, Rabby, etc.
+// derive by default (account 0, address index 0) — so the address from a
+// MajikKey is the SAME address those wallets show for the same mnemonic.
+export const MAJIK_ETHEREUM_STANDARD_PATH = "m/44'/60'/0'/0/0";

package/dist/core/web3/ethereum/ethereum.d.ts

@@ -0,0 +1,21 @@
+import type { EthereumSignature } from "./types.js";
+export interface EthereumKeypairMaterial {
+    /** 32-byte secp256k1 private key. */
+    privateKey: Uint8Array;
+    /** 33-byte compressed secp256k1 public key. */
+    publicKey: Uint8Array;
+}
+/** Uncompressed (65-byte, 0x04-prefixed) form of a compressed or uncompressed public key. */
+export declare function ethereumUncompressedPublicKey(publicKey: Uint8Array): Uint8Array;
+/** EIP-55 mixed-case checksum of a lowercase 40-char hex address (no 0x). */
+export declare function toChecksumAddress(lowerHex: string): string;
+/** EIP-55 address: last 20 bytes of keccak256(uncompressed pubkey without the 0x04 prefix). */
+export declare function ethereumAddressFromPublicKey(publicKey: Uint8Array): string;
+export declare function toEthereumPrivateKeyHex(material: EthereumKeypairMaterial): string;
+/** keccak256("\x19Ethereum Signed Message:\n" + byteLength + message) — EIP-191 version 0x45. */
+export declare function hashEthereumMessage(message: string | Uint8Array): Uint8Array;
+/** Sign a 32-byte hash. Deterministic (RFC 6979), low-s, with recovery id. */
+export declare function signEthereumHash(material: EthereumKeypairMaterial, hash32: Uint8Array): EthereumSignature;
+export declare function signEthereumMessage(material: EthereumKeypairMaterial, message: string | Uint8Array): EthereumSignature;
+/** Recover the signer's EIP-55 address from a hash and signature (ecrecover). */
+export declare function recoverEthereumAddress(hash32: Uint8Array, sig: Pick<EthereumSignature, "r" | "s" | "recovery">): string;

package/dist/core/web3/ethereum/ethereum.js

@@ -0,0 +1,91 @@
+/**
+ * ethereum.ts
+ *
+ * ⚠️ EXPERIMENTAL — Ethereum keypair utilities for MajikKey.
+ *
+ * Design (mirrors bitcoin.ts):
+ *   - Real BIP-32/BIP-44 derivation off the raw 64-byte BIP-39 seed at the
+ *     STANDARD path m/44'/60'/0'/0/0 (see ./constants), so the account is
+ *     recoverable in any Ethereum wallet from the mnemonic alone.
+ *   - Everything here is pure @noble — address derivation (keccak-256 +
+ *     EIP-55), EIP-191 message hashing, recoverable signing — so NO optional
+ *     peer dependency is needed for the common operations. Transaction
+ *     building / EIP-712 typed data should lazy-load viem or ethers
+ *     (not included here).
+ */
+import { secp256k1 } from "@noble/curves/secp256k1.js";
+import { keccak_256 } from "@noble/hashes/sha3.js";
+import { bytesToHex } from "@noble/hashes/utils.js";
+import { MajikKeyError } from "../../error.js";
+const enc = (s) => new TextEncoder().encode(s);
+const hex0x = (u) => "0x" + bytesToHex(u);
+/** Uncompressed (65-byte, 0x04-prefixed) form of a compressed or uncompressed public key. */
+export function ethereumUncompressedPublicKey(publicKey) {
+    if (publicKey.length === 65 && publicKey[0] === 0x04)
+        return publicKey;
+    if (publicKey.length !== 33)
+        throw new MajikKeyError(`Expected a 33-byte compressed secp256k1 public key, got ${publicKey.length} bytes`);
+    return secp256k1.Point.fromBytes(publicKey).toBytes(false);
+}
+/** EIP-55 mixed-case checksum of a lowercase 40-char hex address (no 0x). */
+export function toChecksumAddress(lowerHex) {
+    const h = bytesToHex(keccak_256(enc(lowerHex)));
+    let out = "0x";
+    for (let i = 0; i < lowerHex.length; i++)
+        out += parseInt(h[i], 16) >= 8 ? lowerHex[i].toUpperCase() : lowerHex[i];
+    return out;
+}
+/** EIP-55 address: last 20 bytes of keccak256(uncompressed pubkey without the 0x04 prefix). */
+export function ethereumAddressFromPublicKey(publicKey) {
+    const uncompressed = ethereumUncompressedPublicKey(publicKey);
+    return toChecksumAddress(bytesToHex(keccak_256(uncompressed.slice(1)).slice(-20)));
+}
+export function toEthereumPrivateKeyHex(material) {
+    return hex0x(material.privateKey);
+}
+/** keccak256("\x19Ethereum Signed Message:\n" + byteLength + message) — EIP-191 version 0x45. */
+export function hashEthereumMessage(message) {
+    const body = typeof message === "string" ? enc(message) : message;
+    const prefix = enc(`\x19Ethereum Signed Message:\n${body.length}`);
+    const buf = new Uint8Array(prefix.length + body.length);
+    buf.set(prefix, 0);
+    buf.set(body, prefix.length);
+    return keccak_256(buf);
+}
+/** Sign a 32-byte hash. Deterministic (RFC 6979), low-s, with recovery id. */
+export function signEthereumHash(material, hash32) {
+    if (hash32.length !== 32)
+        throw new MajikKeyError(`Expected a 32-byte hash, got ${hash32.length} bytes`);
+    // noble v2 "recovered" format = [recovery(1) | r(32) | s(32)]
+    const sig = secp256k1.sign(hash32, material.privateKey, {
+        prehash: false,
+        lowS: true,
+        format: "recovered",
+    });
+    const recovery = sig[0];
+    const r = sig.slice(1, 33);
+    const s = sig.slice(33, 65);
+    const v = (27 + recovery);
+    return {
+        r: hex0x(r),
+        s: hex0x(s),
+        v,
+        recovery,
+        serialized: hex0x(r) + bytesToHex(s) + v.toString(16),
+    };
+}
+export function signEthereumMessage(material, message) {
+    return signEthereumHash(material, hashEthereumMessage(message));
+}
+/** Recover the signer's EIP-55 address from a hash and signature (ecrecover). */
+export function recoverEthereumAddress(hash32, sig) {
+    const fromHex = (h) => Uint8Array.from(Buffer.from(h.slice(2), "hex"));
+    const raw = new Uint8Array(65);
+    raw[0] = sig.recovery;
+    raw.set(fromHex(sig.r), 1);
+    raw.set(fromHex(sig.s), 33);
+    const pub = secp256k1.recoverPublicKey(raw, hash32, {
+        prehash: false,
+    });
+    return ethereumAddressFromPublicKey(pub);
+}

package/dist/core/web3/ethereum/types.d.ts

@@ -0,0 +1,32 @@
+/** @experimental */
+export interface EthereumSignature {
+    /** 0x-prefixed 32-byte hex. */
+    r: string;
+    /** 0x-prefixed 32-byte hex (low-s normalized, EIP-2). */
+    s: string;
+    /** 27 | 28 (Ethereum "v"). */
+    v: 27 | 28;
+    /** Raw recovery id, 0 | 1. */
+    recovery: 0 | 1;
+    /** 0x + r || s || v (65 bytes) — what personal_sign / ecrecover consumers expect. */
+    serialized: string;
+}
+/**
+ * @experimental Ethereum account derived at the STANDARD path
+ * (`m/44'/60'/0'/0/0`): the same address MetaMask and hardware wallets show
+ * for this mnemonic. Anyone holding the mnemonic controls the funds.
+ */
+export interface MajikKeyEthereumNamespace {
+    /** 33-byte compressed secp256k1 public key. */
+    readonly publicKey: Uint8Array;
+    /** 32-byte secp256k1 private key. Handle with the same care as any private key. */
+    readonly privateKey: Uint8Array;
+    /** EIP-55 checksummed address. Pure computation — needs no extra dependency. */
+    readonly address: string;
+    /** 0x-prefixed private key hex — pastes directly into any wallet's "import private key". */
+    getPrivateKeyHex(): string;
+    /** Sign a 32-byte hash (e.g. a tx hash or EIP-712 digest). Returns r/s/v. */
+    signHash(hash32: Uint8Array): EthereumSignature;
+    /** EIP-191 `personal_sign`: signs keccak256("\x19Ethereum Signed Message:\n" + len + message). */
+    signMessage(message: string | Uint8Array): EthereumSignature;
+}

package/dist/core/web3/ethereum/types.js

@@ -0,0 +1 @@
+export {};

package/dist/core/web3/index.d.ts

@@ -1,5 +1,10 @@
-export * from "./bitcoin/bitcoin";
-export * from "./solana/solana";
-export type * from "./types";
-export type * from "./bitcoin/types";
-export type * from "./solana/types";
+export * from "./bitcoin/bitcoin.js";
+export * from "./solana/solana.js";
+export * from "./ethereum/ethereum.js";
+export * from "./bitcoin/constants.js";
+export * from "./solana/constants.js";
+export * from "./ethereum/constants.js";
+export type * from "./types.js";
+export type * from "./bitcoin/types.js";
+export type * from "./solana/types.js";
+export type * from "./ethereum/types.js";

package/dist/core/web3/index.js

@@ -1,2 +1,7 @@
-export * from "./bitcoin/bitcoin";
-export * from "./solana/solana";
+// src/core/web3/index.ts
+export * from "./bitcoin/bitcoin.js";
+export * from "./solana/solana.js";
+export * from "./ethereum/ethereum.js";
+export * from "./bitcoin/constants.js";
+export * from "./solana/constants.js";
+export * from "./ethereum/constants.js";

package/dist/core/web3/solana/solana.d.ts

@@ -25,7 +25,7 @@
  *      signing Ed25519 keypair AS-IS. Simpler, but means the same private
  *      key secures two different protocols. Opt-in only.
  */
-import { ED25519RawPublicKey } from "../../types";
+import { ED25519RawPublicKey } from "../../types.js";
 export interface SolanaKeypairMaterial {
     /** 32-byte Ed25519 / Solana public key. */
     publicKey: ED25519RawPublicKey;
@@ -37,7 +37,7 @@ export interface SolanaKeypairMaterial {
  * message-signing Ed25519 key, but fully deterministic from it (and
  * therefore ultimately from the mnemonic).
  *
- *   seed' = SHA256(edSecretKey[0..32] || "MajikMessageSolanaSeed")
+ *   seed' = SHA256(edSecretKey[0..32] || "MajikKeySolanaSeed")
  */
 export declare function deriveSolanaKeypairFromEdSecretKey(edSecretKey: Uint8Array): SolanaKeypairMaterial;
 /**

package/dist/core/web3/solana/solana.js

@@ -27,9 +27,9 @@
  */
 import * as ed25519 from "@stablelib/ed25519";
 import { hash } from "@stablelib/sha256";
-import { MAJIK_SOLANA_SEED } from "./constants";
-import { MajikKeyError } from "../../error";
-import { base58Encode } from "../utils";
+import { MAJIK_SOLANA_SEED } from "./constants.js";
+import { MajikKeyError } from "../../error.js";
+import { base58Encode } from "../utils.js";
 const ED25519_SECRET_KEY_LENGTH = 64;
 const ED25519_SEED_LENGTH = 32;
 // ─── Derivation ─────────────────────────────────────────────────────────────
@@ -38,7 +38,7 @@ const ED25519_SEED_LENGTH = 32;
  * message-signing Ed25519 key, but fully deterministic from it (and
  * therefore ultimately from the mnemonic).
  *
- *   seed' = SHA256(edSecretKey[0..32] || "MajikMessageSolanaSeed")
+ *   seed' = SHA256(edSecretKey[0..32] || "MajikKeySolanaSeed")
  */
 export function deriveSolanaKeypairFromEdSecretKey(edSecretKey) {
     if (edSecretKey.length !== ED25519_SECRET_KEY_LENGTH) {

package/dist/core/web3/solana/types.d.ts

@@ -1,4 +1,4 @@
-import { ED25519RawPublicKey } from "../../types";
+import { ED25519RawPublicKey } from "../../types.js";
 /**
  * @experimental Web3 / blockchain integrations are experimental. This
  * namespace's shape may change without a major version bump.

package/dist/core/web3/types.d.ts

@@ -1,7 +1,9 @@
-import { MajikKeyBitcoinNamespace } from "./bitcoin/types";
-import { MajikKeySolanaNamespace } from "./solana/types";
+import type { MajikKeyBitcoinNamespace } from "./bitcoin/types.js";
+import type { MajikKeyEthereumNamespace } from "./ethereum/types.js";
+import type { MajikKeySolanaNamespace } from "./solana/types.js";
 /** @experimental */
 export interface MajikKeyWeb3Namespace {
     readonly solana: MajikKeySolanaNamespace;
     readonly bitcoin?: MajikKeyBitcoinNamespace;
+    readonly ethereum?: MajikKeyEthereumNamespace;
 }

package/dist/index.d.ts

@@ -1,6 +1,16 @@
-export * from "./majik-key";
-export type * from "./core/types";
-export * from "./core/error";
-export * from "./core/validator";
-export * from "./core/web3";
-export * from "./core/backup";
+export * from "./majik-key.js";
+export type * from "./core/types.js";
+export * from "./core/error.js";
+export * from "./core/validator.js";
+export * from "./core/web3/index.js";
+export * from "./core/backup/index.js";
+export type * from "./core/keys/types.js";
+export * from "./core/keys/hkdf-recipe.js";
+export * from "./core/keys/key-id.js";
+export * from "./core/keys/key-store.js";
+export * from "./core/keys/key-impls.js";
+export * from "./core/keys/keypair-handle.js";
+export * from "./core/keys/registry.js";
+export * from "./core/crypto/wordlist.js";
+export * from "./core/crypto/constants.js";
+export * from "./core/crypto/crypto-provider.js";

package/dist/index.js

@@ -1,5 +1,14 @@
-export * from "./majik-key";
-export * from "./core/error";
-export * from "./core/validator";
-export * from "./core/web3";
-export * from "./core/backup";
+export * from "./majik-key.js";
+export * from "./core/error.js";
+export * from "./core/validator.js";
+export * from "./core/web3/index.js";
+export * from "./core/backup/index.js";
+export * from "./core/keys/hkdf-recipe.js";
+export * from "./core/keys/key-id.js";
+export * from "./core/keys/key-store.js";
+export * from "./core/keys/key-impls.js";
+export * from "./core/keys/keypair-handle.js";
+export * from "./core/keys/registry.js";
+export * from "./core/crypto/wordlist.js";
+export * from "./core/crypto/constants.js";
+export * from "./core/crypto/crypto-provider.js";