@majikah/majik-key 0.2.11 → 0.2.13

package/dist/core/types.d.ts

@@ -19,6 +19,8 @@ export interface MajikKeyJSON {
     encryptedEdSecretKey?: string;
     mlDsaPublicKey?: string;
     encryptedMlDsaSecretKey?: string;
+    btcPublicKey?: string;
+    encryptedBtcSecretKey?: string;
     mnemonicLanguage?: MnemonicLanguage;
 }
 export interface MajikKeyDangerousJSON extends MajikKeyJSON {
@@ -26,6 +28,7 @@ export interface MajikKeyDangerousJSON extends MajikKeyJSON {
     mlKemSecretKeyBase64: string;
     edSecretKeyBase64: string;
     mlDsaSecretKeyBase64: string;
+    btcSecretKeyBase64?: string;
 }
 export interface MajikKeyMetadata {
     id: string;
@@ -35,6 +38,10 @@ export interface MajikKeyMetadata {
     isLocked: boolean;
     kdfVersion: number;
     hasMlKem: boolean;
+    web3: {
+        hasBitcoin?: boolean;
+        hasSolana?: boolean;
+    };
     mnemonicLanguage?: MnemonicLanguage;
 }
 export interface MnemonicJSON {

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

@@ -0,0 +1,71 @@
+/**
+ * bitcoin.ts
+ *
+ * ⚠️ EXPERIMENTAL — Bitcoin keypair utilities for MajikKey.
+ * This module's API may change or be removed without notice in a minor version.
+ *
+ * Design:
+ *   - Real BIP-32/BIP-84 HD derivation directly off the raw 64-byte BIP-39
+ *     seed — NOT a hash-based domain separation like Solana. This matters:
+ *     BIP-32's tree structure lets us get privacy AND portability from the
+ *     exact same standard, auditable derivation, just by choosing the path:
+ *
+ *       MAJIK_BITCOIN_DOMAIN_PATH   (default) — effectively private to Majik;
+ *         not the path any generic wallet would derive by default.
+ *       MAJIK_BITCOIN_STANDARD_PATH (opt-in)  — the REAL BIP-84 mainnet path;
+ *         recoverable in any standard wallet using nothing but the mnemonic.
+ *
+ *   - `privateKey` is the raw 32-byte secp256k1 scalar. `toWIF()` encodes it
+ *     into Wallet Import Format — the universal paste-in-import string every
+ *     Bitcoin wallet accepts (base58check, versioned, deterministic).
+ *   - `@scure/btc-signer` is NOT a hard dependency. It is lazily `import()`-ed
+ *     only for bech32 address encoding / PSBT construction. If it isn't
+ *     installed, we throw a clear, actionable MajikKeyError instead of
+ *     failing module load.
+ */
+export interface BitcoinKeypairMaterial {
+    /** 32-byte secp256k1 private key. */
+    privateKey: Uint8Array;
+    /** 33-byte compressed secp256k1 public key. */
+    publicKey: Uint8Array;
+}
+export interface BitcoinDerivationOptions {
+    /**
+     * If true, derive the REAL BIP-84 mainnet path (SLIP-44 coin type 0) —
+     * the address any standard wallet would show for this mnemonic.
+     * Defaults to false (Majik's domain-separated path).
+     */
+    standard?: boolean;
+    /** Explicit derivation path — overrides `standard` if provided. */
+    path?: string;
+}
+/**
+ * Derive a Bitcoin keypair via standard BIP-32/BIP-84 from the raw 64-byte
+ * BIP-39 seed. Call this once at account creation/import time (mirrors
+ * ML-KEM/Ed25519/ML-DSA derivation) — the seed itself is never stored, only
+ * the resulting key, encrypted at rest like the others.
+ */
+export declare function deriveBitcoinKeypairFromSeed(seed: Uint8Array, options?: BitcoinDerivationOptions): BitcoinKeypairMaterial;
+/**
+ * Re-derive the public key from a raw private key. Used when unlocking —
+ * we only encrypt/store the private key, so the public key is recomputed
+ * on unlock rather than stored redundantly encrypted.
+ */
+export declare function bitcoinPublicKeyFromPrivateKey(privateKey: Uint8Array): Uint8Array;
+/** Sign a 32-byte message hash (already hashed — e.g. a Bitcoin sighash). */
+export declare function signWithBitcoinMaterial(material: BitcoinKeypairMaterial, messageHash: Uint8Array, scheme?: "ecdsa" | "schnorr"): Uint8Array;
+/**
+ * Encode a private key as WIF — the universal paste-in-import string every
+ * Bitcoin wallet accepts. Deterministic: same private key → same WIF, always.
+ */
+export declare function toWIF(material: BitcoinKeypairMaterial, options?: {
+    compressed?: boolean;
+}): string;
+type BtcSignerModule = typeof import("@scure/btc-signer");
+export declare function loadBtcSigner(): Promise<BtcSignerModule>;
+/**
+ * Native SegWit (bech32, "bc1...") mainnet address for this material's
+ * public key. Requires @scure/btc-signer — see loadBtcSigner().
+ */
+export declare function toBitcoinAddress(material: BitcoinKeypairMaterial): Promise<string>;
+export {};

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

@@ -0,0 +1,126 @@
+/**
+ * bitcoin.ts
+ *
+ * ⚠️ EXPERIMENTAL — Bitcoin keypair utilities for MajikKey.
+ * This module's API may change or be removed without notice in a minor version.
+ *
+ * Design:
+ *   - Real BIP-32/BIP-84 HD derivation directly off the raw 64-byte BIP-39
+ *     seed — NOT a hash-based domain separation like Solana. This matters:
+ *     BIP-32's tree structure lets us get privacy AND portability from the
+ *     exact same standard, auditable derivation, just by choosing the path:
+ *
+ *       MAJIK_BITCOIN_DOMAIN_PATH   (default) — effectively private to Majik;
+ *         not the path any generic wallet would derive by default.
+ *       MAJIK_BITCOIN_STANDARD_PATH (opt-in)  — the REAL BIP-84 mainnet path;
+ *         recoverable in any standard wallet using nothing but the mnemonic.
+ *
+ *   - `privateKey` is the raw 32-byte secp256k1 scalar. `toWIF()` encodes it
+ *     into Wallet Import Format — the universal paste-in-import string every
+ *     Bitcoin wallet accepts (base58check, versioned, deterministic).
+ *   - `@scure/btc-signer` is NOT a hard dependency. It is lazily `import()`-ed
+ *     only for bech32 address encoding / PSBT construction. If it isn't
+ *     installed, we throw a clear, actionable MajikKeyError instead of
+ *     failing module load.
+ */
+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 { hash } from "@stablelib/sha256";
+import { base58Encode } from "../utils";
+import { MajikKeyError } from "../../error";
+import { randomBytes } from "@noble/hashes/utils.js";
+// ─── Derivation ─────────────────────────────────────────────────────────────
+/**
+ * Derive a Bitcoin keypair via standard BIP-32/BIP-84 from the raw 64-byte
+ * BIP-39 seed. Call this once at account creation/import time (mirrors
+ * ML-KEM/Ed25519/ML-DSA derivation) — the seed itself is never stored, only
+ * the resulting key, encrypted at rest like the others.
+ */
+export function deriveBitcoinKeypairFromSeed(seed, options) {
+    const path = options?.path ??
+        (options?.standard
+            ? MAJIK_BITCOIN_STANDARD_PATH
+            : MAJIK_BITCOIN_DOMAIN_PATH);
+    const child = HDKey.fromMasterSeed(seed).derive(path);
+    if (!child.privateKey || !child.publicKey) {
+        throw new MajikKeyError("Failed to derive Bitcoin keypair from seed");
+    }
+    return {
+        privateKey: child.privateKey,
+        publicKey: child.publicKey,
+    };
+}
+/**
+ * Re-derive the public key from a raw private key. Used when unlocking —
+ * we only encrypt/store the private key, so the public key is recomputed
+ * on unlock rather than stored redundantly encrypted.
+ */
+export function bitcoinPublicKeyFromPrivateKey(privateKey) {
+    return secp256k1.getPublicKey(privateKey, true); // compressed
+}
+/** Sign a 32-byte message hash (already hashed — e.g. a Bitcoin sighash). */
+export function signWithBitcoinMaterial(material, messageHash, scheme = "ecdsa") {
+    if (scheme === "schnorr") {
+        return schnorr.sign(messageHash, material.privateKey, randomBytes(32));
+    }
+    const signature = secp256k1.sign(messageHash, material.privateKey, {
+        prehash: false,
+        lowS: true, // Note: lowS is technically default in v2 for secp256k1, but it's good practice to be explicit!
+    });
+    return signature;
+}
+// ─── WIF export (Wallet Import Format) — no external lib needed ────────────
+const WIF_VERSION_MAINNET = 0x80;
+function doubleSha256(data) {
+    return hash(hash(data));
+}
+function base58checkEncode(payload) {
+    const checksum = doubleSha256(payload).slice(0, 4);
+    const full = new Uint8Array(payload.length + 4);
+    full.set(payload, 0);
+    full.set(checksum, payload.length);
+    return base58Encode(full);
+}
+/**
+ * Encode a private key as WIF — the universal paste-in-import string every
+ * Bitcoin wallet accepts. Deterministic: same private key → same WIF, always.
+ */
+export function toWIF(material, options) {
+    const compressed = options?.compressed ?? true;
+    const payload = new Uint8Array(compressed ? 34 : 33);
+    payload[0] = WIF_VERSION_MAINNET;
+    payload.set(material.privateKey, 1);
+    if (compressed)
+        payload[33] = 0x01;
+    return base58checkEncode(payload);
+}
+let _btcModule = null;
+export async function loadBtcSigner() {
+    if (_btcModule)
+        return _btcModule;
+    try {
+        _btcModule = (await import(
+        /* webpackIgnore: true */
+        /* @vite-ignore */
+        "@scure/btc-signer"));
+        return _btcModule;
+    }
+    catch (err) {
+        throw new MajikKeyError("@scure/btc-signer is required for this operation but is not installed. " +
+            "Install it in your project with `npm install @scure/btc-signer` " +
+            "(or the yarn/pnpm equivalent) and try again.", err);
+    }
+}
+/**
+ * Native SegWit (bech32, "bc1...") mainnet address for this material's
+ * public key. Requires @scure/btc-signer — see loadBtcSigner().
+ */
+export async function toBitcoinAddress(material) {
+    const btc = await loadBtcSigner();
+    const p2wpkh = btc.p2wpkh(material.publicKey);
+    if (!p2wpkh.address) {
+        throw new MajikKeyError("Failed to derive Bitcoin address");
+    }
+    return p2wpkh.address;
+}

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

@@ -0,0 +1,2 @@
+export declare const MAJIK_BITCOIN_STANDARD_PATH = "m/84'/0'/0'/0/0";
+export declare const MAJIK_BITCOIN_DOMAIN_PATH = "m/84'/1989'/0'/0/0";

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

@@ -0,0 +1,7 @@
+// SLIP-44 coin type 0 = Bitcoin mainnet — the path any standard wallet
+// (Electrum, Sparrow, hardware wallets) derives by default from this mnemonic.
+export const MAJIK_BITCOIN_STANDARD_PATH = "m/84'/0'/0'/0/0";
+// Unregistered/private coin-type index — domain-separates Majik's default
+// Bitcoin key from a user's "real" BTC wallet, while remaining 100% standard
+// BIP-32 math (just a different branch of the same tree).
+export const MAJIK_BITCOIN_DOMAIN_PATH = "m/84'/1989'/0'/0/0";

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

@@ -0,0 +1,23 @@
+/**
+ * @experimental By default this is Majik's DOMAIN-SEPARATED Bitcoin key
+ * (derived via `MAJIK_BITCOIN_DOMAIN_PATH`) — deterministic and fully
+ * standard BIP-32, but not the path a generic wallet would derive by
+ * default, so it stays effectively private to Majik. Use
+ * `MajikKey.getBitcoinKeypairMaterial({ standard: true })` /
+ * `getBitcoinWIF({ standard: true })` for the REAL BIP-84 mainnet key —
+ * recoverable in any standard wallet from the same mnemonic alone.
+ */
+export interface MajikKeyBitcoinNamespace {
+    /** 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;
+    /** Native SegWit (bech32) address. Lazily loads @scure/btc-signer — throws if not installed. */
+    getBitcoinAddress(): Promise<string>;
+    /** WIF string — pastes directly into any standard Bitcoin wallet. */
+    getWIF(options?: {
+        compressed?: boolean;
+    }): string;
+    /** Sign a 32-byte message hash. ECDSA (default) or Schnorr. */
+    sign(messageHash: Uint8Array, scheme?: "ecdsa" | "schnorr"): Uint8Array;
+}

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

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

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

@@ -0,0 +1,5 @@
+export * from "./bitcoin/bitcoin";
+export * from "./solana/solana";
+export type * from "./types";
+export type * from "./bitcoin/types";
+export type * from "./solana/types";

package/dist/core/web3/index.js

@@ -0,0 +1,2 @@
+export * from "./bitcoin/bitcoin";
+export * from "./solana/solana";

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

@@ -0,0 +1 @@
+export declare const MAJIK_SOLANA_SEED = "MajikKeySolanaSeed";

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

@@ -0,0 +1 @@
+export const MAJIK_SOLANA_SEED = "MajikKeySolanaSeed";

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

@@ -0,0 +1,73 @@
+/**
+ * solana.ts
+ *
+ * ⚠️ EXPERIMENTAL — Solana keypair utilities for MajikKey.
+ * This module's API may change or be removed without notice in a minor version.
+ *
+ * Design:
+ *   - Solana accounts are plain Ed25519 keypairs — no new key material or
+ *     wallet standard is needed, just bytes in the right shape.
+ *   - `secretKey` is always the 64-byte nacl/tweetnacl-compatible format
+ *     (32-byte seed || 32-byte public key) — exactly what
+ *     `@solana/web3.js`'s `Keypair.fromSecretKey()` expects, and exactly
+ *     what `@stablelib/ed25519` already produces.
+ *   - `@solana/web3.js` is NOT a dependency of this package. It is lazily
+ *     `import()`-ed only when a caller needs an actual `Keypair`/`PublicKey`
+ *     instance (e.g. to build a transaction). If it isn't installed, we
+ *     throw a clear, actionable MajikKeyError instead of failing module
+ *     load. Base58 address derivation does NOT require the library at all.
+ *
+ * Two ways to obtain a Solana identity from a MajikKey:
+ *   1. deriveSolanaKeypairFromEdSecretKey() — RECOMMENDED. Domain-separates
+ *      a brand-new Ed25519 keypair from the MajikKey's message-signing
+ *      Ed25519 secret key, so the Solana key is never reused elsewhere.
+ *   2. solanaMaterialFromEd25519SecretKey() — reuses the MajikKey's message
+ *      signing Ed25519 keypair AS-IS. Simpler, but means the same private
+ *      key secures two different protocols. Opt-in only.
+ */
+export interface SolanaKeypairMaterial {
+    /** 32-byte Ed25519 / Solana public key. */
+    publicKey: Uint8Array;
+    /** 64-byte nacl-format secret key (32-byte seed || 32-byte public key). */
+    secretKey: Uint8Array;
+}
+/**
+ * Derive a Solana keypair domain-separated from the MajikKey's
+ * message-signing Ed25519 key, but fully deterministic from it (and
+ * therefore ultimately from the mnemonic).
+ *
+ *   seed' = SHA256(edSecretKey[0..32] || "MajikMessageSolanaSeed")
+ */
+export declare function deriveSolanaKeypairFromEdSecretKey(edSecretKey: Uint8Array): SolanaKeypairMaterial;
+/**
+ * Reuse the MajikKey's existing message-signing Ed25519 keypair directly
+ * as a Solana keypair (no re-derivation).
+ *
+ * ⚠️ Not recommended: the same private key would secure both Majik message
+ * signing AND any Solana transactions. Prefer
+ * `deriveSolanaKeypairFromEdSecretKey()` unless you specifically want the
+ * identical key on both.
+ */
+export declare function solanaMaterialFromEd25519SecretKey(edSecretKey: Uint8Array): SolanaKeypairMaterial;
+/**
+ * Solana address for a given Solana/Ed25519 public key — just its base58
+ * encoding. Does NOT require @solana/web3.js.
+ */
+export declare function solanaAddressFromPublicKey(publicKey: Uint8Array): string;
+type SolanaKitModule = typeof import("@solana/kit");
+export declare function loadSolanaKit(): Promise<SolanaKitModule>;
+/**
+ * Real @solana/kit KeyPairSigner backed by a genuine CryptoKeyPair.
+ * Requires @solana/kit — see loadSolanaKit().
+ */
+export declare function toSolanaKeyPairSigner(material: SolanaKeypairMaterial): Promise<Awaited<ReturnType<SolanaKitModule["createKeyPairSignerFromBytes"]>>>;
+/**
+ * Real @solana/kit Address (branded string) for this material's public key.
+ */
+export declare function toSolanaAddress(material: SolanaKeypairMaterial): Promise<Awaited<ReturnType<SolanaKitModule["getAddressFromPublicKey"]>>>;
+/**
+ * Sign an arbitrary message with a Solana keypair's Ed25519 secret key.
+ * Uses @stablelib/ed25519 directly — does NOT require @solana/web3.js.
+ */
+export declare function signWithSolanaMaterial(material: SolanaKeypairMaterial, message: Uint8Array): Uint8Array;
+export {};

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

@@ -0,0 +1,120 @@
+/**
+ * solana.ts
+ *
+ * ⚠️ EXPERIMENTAL — Solana keypair utilities for MajikKey.
+ * This module's API may change or be removed without notice in a minor version.
+ *
+ * Design:
+ *   - Solana accounts are plain Ed25519 keypairs — no new key material or
+ *     wallet standard is needed, just bytes in the right shape.
+ *   - `secretKey` is always the 64-byte nacl/tweetnacl-compatible format
+ *     (32-byte seed || 32-byte public key) — exactly what
+ *     `@solana/web3.js`'s `Keypair.fromSecretKey()` expects, and exactly
+ *     what `@stablelib/ed25519` already produces.
+ *   - `@solana/web3.js` is NOT a dependency of this package. It is lazily
+ *     `import()`-ed only when a caller needs an actual `Keypair`/`PublicKey`
+ *     instance (e.g. to build a transaction). If it isn't installed, we
+ *     throw a clear, actionable MajikKeyError instead of failing module
+ *     load. Base58 address derivation does NOT require the library at all.
+ *
+ * Two ways to obtain a Solana identity from a MajikKey:
+ *   1. deriveSolanaKeypairFromEdSecretKey() — RECOMMENDED. Domain-separates
+ *      a brand-new Ed25519 keypair from the MajikKey's message-signing
+ *      Ed25519 secret key, so the Solana key is never reused elsewhere.
+ *   2. solanaMaterialFromEd25519SecretKey() — reuses the MajikKey's message
+ *      signing Ed25519 keypair AS-IS. Simpler, but means the same private
+ *      key secures two different protocols. Opt-in only.
+ */
+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";
+const ED25519_SECRET_KEY_LENGTH = 64;
+const ED25519_SEED_LENGTH = 32;
+// ─── Derivation ─────────────────────────────────────────────────────────────
+/**
+ * Derive a Solana keypair domain-separated from the MajikKey's
+ * message-signing Ed25519 key, but fully deterministic from it (and
+ * therefore ultimately from the mnemonic).
+ *
+ *   seed' = SHA256(edSecretKey[0..32] || "MajikMessageSolanaSeed")
+ */
+export function deriveSolanaKeypairFromEdSecretKey(edSecretKey) {
+    if (edSecretKey.length !== ED25519_SECRET_KEY_LENGTH) {
+        throw new MajikKeyError(`Expected a 64-byte Ed25519 secret key, got ${edSecretKey.length} bytes`);
+    }
+    const edSeed = edSecretKey.slice(0, ED25519_SEED_LENGTH);
+    const domain = new TextEncoder().encode(MAJIK_SOLANA_SEED);
+    const combined = new Uint8Array(edSeed.length + domain.length);
+    combined.set(edSeed, 0);
+    combined.set(domain, edSeed.length);
+    const solanaSeed = hash(combined); // 32 bytes
+    const kp = ed25519.generateKeyPairFromSeed(solanaSeed);
+    return { publicKey: kp.publicKey, secretKey: kp.secretKey };
+}
+/**
+ * Reuse the MajikKey's existing message-signing Ed25519 keypair directly
+ * as a Solana keypair (no re-derivation).
+ *
+ * ⚠️ Not recommended: the same private key would secure both Majik message
+ * signing AND any Solana transactions. Prefer
+ * `deriveSolanaKeypairFromEdSecretKey()` unless you specifically want the
+ * identical key on both.
+ */
+export function solanaMaterialFromEd25519SecretKey(edSecretKey) {
+    if (edSecretKey.length !== ED25519_SECRET_KEY_LENGTH) {
+        throw new MajikKeyError(`Expected a 64-byte Ed25519 secret key, got ${edSecretKey.length} bytes`);
+    }
+    return {
+        publicKey: edSecretKey.slice(ED25519_SEED_LENGTH),
+        secretKey: edSecretKey.slice(),
+    };
+}
+/**
+ * Solana address for a given Solana/Ed25519 public key — just its base58
+ * encoding. Does NOT require @solana/web3.js.
+ */
+export function solanaAddressFromPublicKey(publicKey) {
+    return base58Encode(publicKey);
+}
+let _kitModule = null;
+export async function loadSolanaKit() {
+    if (_kitModule)
+        return _kitModule;
+    try {
+        _kitModule = (await import(
+        /* webpackIgnore: true */
+        /* @vite-ignore */
+        "@solana/kit"));
+        return _kitModule;
+    }
+    catch (err) {
+        throw new MajikKeyError("@solana/kit is required for this operation but is not installed. " +
+            "Install it in your project with `npm install @solana/kit` " +
+            "(or the yarn/pnpm equivalent) and try again.", err);
+    }
+}
+/**
+ * Real @solana/kit KeyPairSigner backed by a genuine CryptoKeyPair.
+ * Requires @solana/kit — see loadSolanaKit().
+ */
+export async function toSolanaKeyPairSigner(material) {
+    const kit = await loadSolanaKit();
+    return kit.createKeyPairSignerFromBytes(material.secretKey);
+}
+/**
+ * Real @solana/kit Address (branded string) for this material's public key.
+ */
+export async function toSolanaAddress(material) {
+    const kit = await loadSolanaKit();
+    const signer = await toSolanaKeyPairSigner(material);
+    return signer.address;
+}
+/**
+ * Sign an arbitrary message with a Solana keypair's Ed25519 secret key.
+ * Uses @stablelib/ed25519 directly — does NOT require @solana/web3.js.
+ */
+export function signWithSolanaMaterial(material, message) {
+    return ed25519.sign(material.secretKey, message);
+}

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

@@ -0,0 +1,18 @@
+/**
+ * @experimental Web3 / blockchain integrations are experimental. This
+ * namespace's shape may change without a major version bump.
+ */
+export interface MajikKeySolanaNamespace {
+    /** 32-byte Solana/Ed25519 public key. */
+    readonly publicKey: Uint8Array;
+    /** 64-byte nacl-format secret key. Handle with the same care as any private key. */
+    readonly secretKey: Uint8Array;
+    /** Base58 Solana address — does not require @solana/kit. */
+    readonly address: string;
+    /** Real @solana/kit Keypair. Lazily loads @solana/kit — throws if not installed. */
+    getSolanaKeypair(): Promise<any>;
+    /** Real @solana/kit PublicKey. Lazily loads @solana/kit — throws if not installed. */
+    getSolanaAddress(): Promise<any>;
+    /** Sign a message with this Solana keypair's Ed25519 key. No web3.js needed. */
+    sign(message: Uint8Array): Uint8Array;
+}

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

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

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

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

package/dist/core/web3/types.js

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

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

@@ -0,0 +1 @@
+export declare function base58Encode(bytes: Uint8Array): string;

package/dist/core/web3/utils.js

@@ -0,0 +1,27 @@
+// ─── Base58 (Solana address encoding) — no external dependency ─────────────
+const BASE58_ALPHABET = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
+export function base58Encode(bytes) {
+    if (bytes.length === 0)
+        return "";
+    const digits = [0];
+    for (let i = 0; i < bytes.length; i++) {
+        let carry = bytes[i];
+        for (let j = 0; j < digits.length; j++) {
+            carry += digits[j] << 8;
+            digits[j] = carry % 58;
+            carry = (carry / 58) | 0;
+        }
+        while (carry > 0) {
+            digits.push(carry % 58);
+            carry = (carry / 58) | 0;
+        }
+    }
+    let leadingZeros = 0;
+    for (let i = 0; i < bytes.length && bytes[i] === 0; i++)
+        leadingZeros++;
+    let result = "1".repeat(leadingZeros);
+    for (let i = digits.length - 1; i >= 0; i--) {
+        result += BASE58_ALPHABET[digits[i]];
+    }
+    return result;
+}

package/dist/index.d.ts

@@ -2,3 +2,4 @@ export * from "./majik-key";
 export type * from "./core/types";
 export * from "./core/error";
 export * from "./core/validator";
+export * from "./core/web3";

package/dist/index.js

@@ -1,3 +1,4 @@
 export * from "./majik-key";
 export * from "./core/error";
 export * from "./core/validator";
+export * from "./core/web3";