@majikah/majik-key 0.2.12 → 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.d.ts → solana/solana.d.ts}

@@ -49,7 +49,6 @@ export declare function deriveSolanaKeypairFromEdSecretKey(edSecretKey: Uint8Arr
  * identical key on both.
  */
 export declare function solanaMaterialFromEd25519SecretKey(edSecretKey: Uint8Array): SolanaKeypairMaterial;
-export declare function base58Encode(bytes: Uint8Array): string;
 /**
  * Solana address for a given Solana/Ed25519 public key — just its base58
  * encoding. Does NOT require @solana/web3.js.

package/dist/core/web3/{solana.js → solana/solana.js}

@@ -28,7 +28,8 @@
 import * as ed25519 from "@stablelib/ed25519";
 import { hash } from "@stablelib/sha256";
 import { MAJIK_SOLANA_SEED } from "./constants";
-import { MajikKeyError } from "../error";
+import { MajikKeyError } from "../../error";
+import { base58Encode } from "../utils";
 const ED25519_SECRET_KEY_LENGTH = 64;
 const ED25519_SEED_LENGTH = 32;
 // ─── Derivation ─────────────────────────────────────────────────────────────
@@ -70,33 +71,6 @@ export function solanaMaterialFromEd25519SecretKey(edSecretKey) {
         secretKey: edSecretKey.slice(),
     };
 }
-// ─── 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;
-}
 /**
  * Solana address for a given Solana/Ed25519 public key — just its base58
  * encoding. Does NOT require @solana/web3.js.

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

@@ -1,26 +1,7 @@
-/**
- * @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;
-}
-/** @experimental */
-export interface MajikKeyWeb3Namespace {
-    readonly solana: MajikKeySolanaNamespace;
-}
+import { MajikKeyBitcoinNamespace } from "./bitcoin/types";
+import { MajikKeySolanaNamespace } from "./solana/types";
 /** @experimental */
 export interface MajikKeyWeb3Namespace {
     readonly solana: MajikKeySolanaNamespace;
+    readonly bitcoin?: MajikKeyBitcoinNamespace;
 }

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

package/dist/majik-key.d.ts

@@ -27,8 +27,7 @@ import type { MajikKeyDangerousJSON, MajikKeyJSON, MajikKeyMetadata, MnemonicJSO
 import { MajikMessageIdentity } from "./core/database/system/identity";
 import { MajikUser } from "@thezelijah/majik-user";
 import { MnemonicLanguage } from "./core/crypto/wordlist";
-import { SolanaKeypairMaterial } from "./core/web3/solana";
-import { MajikKeyWeb3Namespace } from "./core/web3/types";
+import { MajikKeyWeb3Namespace, BitcoinDerivationOptions, BitcoinKeypairMaterial, SolanaKeypairMaterial } from "./core/web3";
 export interface MajikKeyIdentity {
     id: string;
     publicKey: CryptoKey | {
@@ -47,11 +46,14 @@ export interface MajikKeyIdentity {
     edSecretKey?: Uint8Array;
     mlDsaPublicKey?: Uint8Array;
     mlDsaSecretKey?: Uint8Array;
+    btcPublicKey?: Uint8Array;
+    btcSecretKey?: Uint8Array;
 }
 export type MajikKeyDerivedIdentity = MajikKeyIdentity & {
     encryptedMlKemSecretKey: ArrayBuffer;
     encryptedEdSecretKey: ArrayBuffer;
     encryptedMlDsaSecretKey: ArrayBuffer;
+    encryptedBtcSecretKey: ArrayBuffer;
 };
 export interface SerializedIdentity {
     id: string;
@@ -90,6 +92,10 @@ export interface MajikKeyConstructorOptions {
     encryptedMlDsaSecretKeyBase64?: string;
     edSecretKey?: Uint8Array;
     mlDsaSecretKey?: Uint8Array;
+    btcPublicKey?: Uint8Array;
+    encryptedBtcSecretKey?: ArrayBuffer;
+    encryptedBtcSecretKeyBase64?: string;
+    btcSecretKey?: Uint8Array;
     mnemonicLanguage?: MnemonicLanguage;
 }
 export declare class MajikKey {
@@ -120,6 +126,10 @@ export declare class MajikKey {
     private _encryptedMlDsaSecretKey?;
     private _encryptedMlDsaSecretKeyBase64?;
     private _solanaKeypairMaterial?;
+    private _btcPublicKey?;
+    private _btcSecretKey?;
+    private _encryptedBtcSecretKey?;
+    private _encryptedBtcSecretKeyBase64?;
     private constructor();
     get id(): string;
     get fingerprint(): string;
@@ -139,6 +149,8 @@ export declare class MajikKey {
     get mlKemSecretKey(): Uint8Array | undefined;
     get hasMlKem(): boolean;
     get isFullyUpgraded(): boolean;
+    get btcPublicKey(): Uint8Array | undefined;
+    get hasBitcoin(): boolean;
     get metadata(): MajikKeyMetadata;
     get edPublicKey(): Uint8Array | undefined;
     get mlDsaPublicKey(): Uint8Array | undefined;
@@ -224,17 +236,36 @@ export declare class MajikKey {
     private static _exportMnemonicBackup;
     private static _deriveLegacyMnemonicKey;
     private static _exportKeyToBase64;
+    getBtcSecretKey(): Uint8Array;
+    get web3(): MajikKeyWeb3Namespace | undefined;
+    /**
+     * @experimental True if this MajikKey can currently produce Bitcoin
+     * material (i.e. it's unlocked and has a Bitcoin secret key).
+     */
+    get hasBitcoinKeypair(): boolean;
     /**
-     * @experimental Blockchain/web3 integrations are experimental — this API
-     * may change without notice. `undefined` when the MajikKey is locked or
-     * has no Ed25519 signing key to derive from.
+     * @experimental Raw Bitcoin keypair material. Pass `{ standard: true }` to
+     * get the REAL BIP-84 mainnet key (recoverable in any standard wallet from
+     * the mnemonic alone) instead of Majik's default domain-separated key.
      *
-     * By default `web3.solana` is DOMAIN-SEPARATED from the MajikKey's message
-     * signing key (see deriveSolanaKeypairFromEdSecretKey). Use
-     * `getSolanaKeypairMaterial({ reuseMessageKey: true })` if you specifically
-     * want the identical key reused for Solana instead.
+     * NOTE: `{ standard: true }` re-derives from the raw seed on demand and is
+     * NOT the same key as `web3.bitcoin` (which is always the stored,
+     * domain-separated default) — it requires the mnemonic to reproduce again
+     * outside Majik, whereas the stored default does not.
      */
-    get web3(): MajikKeyWeb3Namespace | undefined;
+    getBitcoinKeypairMaterial(options?: BitcoinDerivationOptions): BitcoinKeypairMaterial;
+    /**
+     * @experimental Derive the REAL BIP-84 mainnet Bitcoin keypair straight
+     * from a mnemonic — for one-off export/verification. Does not require
+     * an unlocked MajikKey instance.
+     */
+    static deriveStandardBitcoinFromMnemonic(mnemonic: string, mnemonicLanguage?: MnemonicLanguage): Promise<BitcoinKeypairMaterial>;
+    /**
+     * @experimental WIF export of the default (domain-separated) Bitcoin key.
+     */
+    getBitcoinWIF(options?: {
+        compressed?: boolean;
+    }): string;
     /**
      * @experimental True if this MajikKey can currently produce a Solana
      * keypair (i.e. it's unlocked and has an Ed25519 signing key).