@majikah/majik-key 0.3.2 → 0.3.4

package/README.md

@@ -1,13 +1,16 @@
 # Majik Key
 
+[![ZENODO](https://img.shields.io/badge/Read_the_Technical_Whitepaper_Here-1682D4?style=for-the-badge&logo=zenodo&logoColor=white)](https://doi.org/10.5281/zenodo.21339132)
 
 
 [![Developed by Zelijah](https://img.shields.io/badge/Developed%20by-Zelijah-red?logo=github&logoColor=white)](https://www.thezelijah.world) ![GitHub Sponsors](https://img.shields.io/github/sponsors/jedlsf?style=plastic&label=Sponsors&link=https%3A%2F%2Fgithub.com%2Fsponsors%2Fjedlsf)
 
-[![DOI](https://zenodo.org/badge/DOI/10.5281/zenodo.21339132.svg)](https://doi.org/10.5281/zenodo.21339132) ![npm](https://img.shields.io/npm/v/@majikah/majik-key) ![npm downloads](https://img.shields.io/npm/dm/@majikah/majik-key) ![TypeScript](https://img.shields.io/badge/TypeScript-Ready-blue) [![License](https://img.shields.io/badge/License-Apache_2.0-blue.svg)](https://opensource.org/licenses/Apache-2.0)
+
 
 **Majik Key** turns a single BIP-39 mnemonic into a complete cryptographic identity — encryption, classical + post-quantum signing, and (experimentally) Bitcoin and Solana keys — encrypted at rest and ready to plug into the rest of the Majikah ecosystem.
 
+[![DOI](https://zenodo.org/badge/DOI/10.5281/zenodo.21339132.svg)](https://doi.org/10.5281/zenodo.21339132) ![npm](https://img.shields.io/npm/v/@majikah/majik-key) ![npm downloads](https://img.shields.io/npm/dm/@majikah/majik-key) ![TypeScript](https://img.shields.io/badge/TypeScript-Ready-blue) [![License](https://img.shields.io/badge/License-Apache_2.0-blue.svg)](https://opensource.org/licenses/Apache-2.0)
+
 ---
 
 ## Why Majik Key

package/dist/core/crypto/crypto-provider.js

@@ -12,6 +12,7 @@ import { ARGON2_PARAMS } from "./constants";
 import { ml_kem768 } from "@noble/post-quantum/ml-kem.js";
 import { argon2id as hashWasmArgon2id } from "hash-wasm";
 const secureGetRandomValues = crypto.getRandomValues.bind(crypto);
+const secureFill = Uint8Array.prototype.fill;
 export const IV_LENGTH = 12;
 export function generateRandomBytes(len) {
     const b = new Uint8Array(len);
@@ -134,8 +135,13 @@ async function _argon2id(input, salt, params) {
  */
 export async function deriveKeyFromPassphraseArgon2(passphrase, salt) {
     const pw = new TextEncoder().encode(passphrase);
-    const result = await _argon2id(pw, salt, ARGON2_PARAMS.PASSPHRASE);
-    return result.slice(); // ← force a copy out of WASM memory
+    try {
+        const result = await _argon2id(pw, salt, ARGON2_PARAMS.PASSPHRASE);
+        return result.slice();
+    }
+    finally {
+        secureFill.call(pw, 0);
+    }
 }
 /**
  * Derive a 32-byte AES key from a BIP-39 mnemonic using Argon2id.
@@ -147,8 +153,13 @@ export async function deriveKeyFromPassphraseArgon2(passphrase, salt) {
  */
 export async function deriveKeyFromMnemonicArgon2(mnemonic, salt) {
     const m = new TextEncoder().encode(mnemonic);
-    const result = await _argon2id(m, salt, ARGON2_PARAMS.MNEMONIC);
-    return result.slice(); // ← force a copy out of WASM memory
+    try {
+        const result = await _argon2id(m, salt, ARGON2_PARAMS.MNEMONIC);
+        return result.slice(); // ← force a copy out of WASM memory
+    }
+    finally {
+        secureFill.call(m, 0);
+    }
 }
 // ─── KDF v1: PBKDF2-SHA256 (legacy — do not use for new operations) ───────────
 /**

package/dist/core/crypto/encryption-engine.d.ts

@@ -1,8 +1,8 @@
 export interface EncryptionIdentity {
-    publicKey: CryptoKey | {
+    publicKey: {
         raw: Uint8Array;
     };
-    privateKey: CryptoKey | {
+    privateKey: {
         raw: Uint8Array;
     };
     fingerprint: string;

package/dist/core/crypto/encryption-engine.js

@@ -42,6 +42,13 @@ export class EncryptionEngine {
         // Step 1: BIP-39 seed → 64 bytes
         const seed = mnemonicToSeedSync(mnemonic); // returns Buffer (Node) or Uint8Array
         const seed64 = new Uint8Array(seed); // normalize to Uint8Array
+        // Step 3: ML-KEM-768 keypair from FULL 64-byte seed (new)
+        // ml_kem768.keygen() accepts a 64-byte seed directly.
+        // seed[0..32] → lattice key matrix expansion (K-PKE keygen)
+        // seed[32..64] → implicit rejection parameter z (stored in secretKey)
+        const mlKemKeypair = deriveMlKemKeypairFromSeed(seed64);
+        const mlDsaSeedInput = concatUint8Arrays(seed64, new TextEncoder().encode(MAJIK_SIGNATURE_SEED));
+        const mlDsaSeed = hash(mlDsaSeedInput);
         // Step 2: X25519 identity from first 32 bytes (existing path)
         const seed32 = seed64.subarray(0, 32);
         try {
@@ -56,12 +63,6 @@ export class EncryptionEngine {
             const publicKey = { type: "public", raw: pkCurveBytes };
             const privateKey = { type: "private", raw: skCurveBytes };
             const fingerprint = fingerprintFromPublicRaw(pkCurveBytes);
-            // Step 3: ML-KEM-768 keypair from FULL 64-byte seed (new)
-            // ml_kem768.keygen() accepts a 64-byte seed directly.
-            // seed[0..32] → lattice key matrix expansion (K-PKE keygen)
-            // seed[32..64] → implicit rejection parameter z (stored in secretKey)
-            const mlKemKeypair = deriveMlKemKeypairFromSeed(seed64);
-            const mlDsaSeed = hash(concatUint8Arrays(seed64, new TextEncoder().encode(MAJIK_SIGNATURE_SEED))); // 32 bytes, deterministic, domain-separated
             const mlDsaKeypair = ml_dsa87.keygen(mlDsaSeed);
             return {
                 publicKey,
@@ -79,12 +80,12 @@ export class EncryptionEngine {
             throw new CryptoError("Failed to derive identity from mnemonic", err);
         }
         finally {
-            // CRITICAL: Zeroize the master seed
             secureFill.call(seed64, 0);
             secureFill.call(seed32, 0);
-            if (seed instanceof Uint8Array) {
+            secureFill.call(mlDsaSeedInput, 0);
+            secureFill.call(mlDsaSeed, 0);
+            if (seed instanceof Uint8Array)
                 secureFill.call(seed, 0);
-            }
         }
     }
     /* ================================

package/dist/core/types.d.ts

@@ -132,4 +132,5 @@ export interface MnemonicJSON {
     id: string;
     /** Optional passphrase, carried in plaintext for convenience during export/import. ⚠️ Not encrypted. */
     phrase?: string;
+    language?: MnemonicLanguage;
 }

package/dist/majik-key.d.ts

@@ -26,13 +26,13 @@ export interface MajikKeyIdentity {
     /** Account identifier. Equal to `fingerprint` for accounts created by this library. */
     id: string;
     /** X25519 public key — native `CryptoKey` where WebCrypto supports it, otherwise a raw-bytes wrapper. */
-    publicKey: CryptoKey | {
+    publicKey: {
         raw: Uint8Array;
     };
     /** SHA-256 fingerprint of `publicKey`. */
     fingerprint: MajikKeyFingerprint;
     /** X25519 private key, decrypted into memory. ⚠️ Live key material — do not log or serialize directly. */
-    privateKey: CryptoKey | {
+    privateKey: {
         raw: Uint8Array;
     };
     /** AES-256-GCM-encrypted X25519 private key (IV + ciphertext), as stored at rest. */
@@ -106,7 +106,7 @@ export interface SerializedIdentity {
  */
 export interface MajikKeyConstructorOptions {
     id: string;
-    publicKey: CryptoKey | {
+    publicKey: {
         raw: Uint8Array;
     };
     publicKeyBase64: MajikKeyAddress;
@@ -126,11 +126,9 @@ export interface MajikKeyConstructorOptions {
     encryptedMlKemSecretKey?: ArrayBuffer;
     encryptedMlKemSecretKeyBase64?: string;
     /** Present only when constructing an already-unlocked instance. ⚠️ Live key material. */
-    privateKey?: CryptoKey | {
+    privateKey?: {
         raw: Uint8Array;
     };
-    /** Present only when constructing an already-unlocked instance. ⚠️ Live key material. */
-    privateKeyBase64?: string;
     edPublicKey?: Uint8Array;
     encryptedEdSecretKey?: ArrayBuffer;
     encryptedEdSecretKeyBase64?: string;
@@ -192,7 +190,6 @@ export declare class MajikKey {
     private _encryptedMlKemSecretKey?;
     private _encryptedMlKemSecretKeyBase64?;
     private _privateKey?;
-    private _privateKeyBase64?;
     private _edPublicKey?;
     private _edSecretKey?;
     private _encryptedEdSecretKey?;

package/dist/majik-key.js

@@ -8,7 +8,7 @@ import { aesGcmDecrypt, aesGcmEncrypt, deriveKeyFromPassphraseArgon2, deriveKeyF
 import { EncryptionEngine } from "./core/crypto/encryption-engine";
 import { MajikContact } from "@majikah/majik-contact";
 import { arrayBufferToBase64, arrayToBase64, base64ToArrayBuffer, concatUint8Arrays, utf8ToBase64, base64ToUtf8, seedStringToArray, seedArrayToString, base64ToUint8Array, } from "./core/utils";
-import { KDF_VERSION, KEY_ALGO, MAJIK_MNEMONIC_SALT, } from "./core/crypto/constants";
+import { KDF_VERSION, MAJIK_MNEMONIC_SALT, } from "./core/crypto/constants";
 import { MajikKeyValidator } from "./core/validator";
 import { MajikKeyError } from "./core/error";
 import { MajikMessageIdentity } from "./core/database/system/identity";
@@ -57,7 +57,6 @@ export class MajikKey {
     _encryptedMlKemSecretKey;
     _encryptedMlKemSecretKeyBase64;
     _privateKey;
-    _privateKeyBase64;
     _edPublicKey;
     _edSecretKey;
     _encryptedEdSecretKey;
@@ -103,7 +102,6 @@ export class MajikKey {
         this._encryptedMlKemSecretKey = options.encryptedMlKemSecretKey;
         this._encryptedMlKemSecretKeyBase64 = options.encryptedMlKemSecretKeyBase64;
         this._privateKey = options.privateKey;
-        this._privateKeyBase64 = options.privateKeyBase64;
         this._edPublicKey = options.edPublicKey;
         this._encryptedEdSecretKey = options.encryptedEdSecretKey;
         this._encryptedEdSecretKeyBase64 = options.encryptedEdSecretKeyBase64;
@@ -285,7 +283,6 @@ export class MajikKey {
                 encryptedMlKemSecretKey: identity.encryptedMlKemSecretKey,
                 encryptedMlKemSecretKeyBase64: arrayBufferToBase64(identity.encryptedMlKemSecretKey),
                 privateKey: identity.privateKey,
-                privateKeyBase64,
                 edPublicKey: identity.edPublicKey,
                 encryptedEdSecretKey: identity.encryptedEdSecretKey,
                 encryptedEdSecretKeyBase64: arrayBufferToBase64(identity.encryptedEdSecretKey),
@@ -397,11 +394,11 @@ export class MajikKey {
         if (!this._edSecretKey ||
             !this._mlDsaSecretKey ||
             !this._mlKemSecretKey ||
-            !this._privateKeyBase64)
+            !this._privateKey)
             throw new MajikKeyError("MajikKey is missing secret keys — re-import via importFromMnemonicBackup() first.");
         return {
             ...this.toJSON(),
-            privateKeyBase64: this._privateKeyBase64,
+            privateKeyBase64: arrayToBase64(this._privateKey.raw),
             mlKemSecretKeyBase64: arrayToBase64(this._mlKemSecretKey),
             edSecretKeyBase64: arrayToBase64(this._edSecretKey),
             mlDsaSecretKeyBase64: arrayToBase64(this._mlDsaSecretKey),
@@ -449,7 +446,6 @@ export class MajikKey {
                 publicKey: { raw: base64ToUint8Array(parsed.publicKey) },
                 publicKeyBase64: parsed.publicKey,
                 privateKey: { raw: privateKeyBytes },
-                privateKeyBase64: parsed.privateKeyBase64,
                 encryptedPrivateKey: new ArrayBuffer(0),
                 encryptedPrivateKeyBase64: parsed.encryptedPrivateKey,
                 salt: parsed.salt,
@@ -482,6 +478,7 @@ export class MajikKey {
             id: this._backup,
             seed: seedStringToArray(mnemonic.trim()),
             phrase: passphrase?.trim() || undefined,
+            language: this._mnemonicLanguage,
         };
     }
     static async fromMnemonicJSON(mnemonicJson, passphrase, label, options = {
@@ -511,6 +508,8 @@ export class MajikKey {
         return this;
     }
     async updatePassphrase(currentPassphrase, newPassphrase) {
+        if (this.isLocked)
+            throw new MajikKeyError("MajikKey must be unlocked to update passphrase");
         MajikKeyValidator.validatePassphrase(currentPassphrase, "Current passphrase");
         MajikKeyValidator.validatePassphrase(newPassphrase, "New passphrase");
         const salt = new Uint8Array(base64ToArrayBuffer(this._salt));
@@ -530,6 +529,8 @@ export class MajikKey {
                 const encMlKem = await MajikKey._encryptMlKemSecretKey(mlKemSecretKeyBytes, newPassphrase, newSalt);
                 this._encryptedMlKemSecretKey = encMlKem;
                 this._encryptedMlKemSecretKeyBase64 = arrayBufferToBase64(encMlKem);
+                if (this._mlKemSecretKey)
+                    secureFill.call(this._mlKemSecretKey, 0);
                 this._mlKemSecretKey = mlKemSecretKeyBytes;
             }
             if (this._encryptedEdSecretKey) {
@@ -537,6 +538,8 @@ export class MajikKey {
                 const encEd = await MajikKey._encryptSigningKey(edSecretKeyBytes, newPassphrase, newSalt);
                 this._encryptedEdSecretKey = encEd;
                 this._encryptedEdSecretKeyBase64 = arrayBufferToBase64(encEd);
+                if (this._edSecretKey)
+                    secureFill.call(this._edSecretKey, 0);
                 this._edSecretKey = edSecretKeyBytes;
             }
             if (this._encryptedMlDsaSecretKey) {
@@ -544,6 +547,8 @@ export class MajikKey {
                 const encDsa = await MajikKey._encryptSigningKey(mlDsaSecretKeyBytes, newPassphrase, newSalt);
                 this._encryptedMlDsaSecretKey = encDsa;
                 this._encryptedMlDsaSecretKeyBase64 = arrayBufferToBase64(encDsa);
+                if (this._mlDsaSecretKey)
+                    secureFill.call(this._mlDsaSecretKey, 0);
                 this._mlDsaSecretKey = mlDsaSecretKeyBytes;
             }
             if (this._encryptedBtcSecretKey) {
@@ -551,6 +556,8 @@ export class MajikKey {
                 const encBtc = await MajikKey._encryptSigningKey(btcSecretKeyBytes, newPassphrase, newSalt);
                 this._encryptedBtcSecretKey = encBtc;
                 this._encryptedBtcSecretKeyBase64 = arrayBufferToBase64(encBtc);
+                if (this._btcSecretKey)
+                    secureFill.call(this._btcSecretKey, 0);
                 this._btcSecretKey = btcSecretKeyBytes;
             }
             return this;
@@ -571,12 +578,13 @@ export class MajikKey {
      * NOTE: Does not add ML-KEM keys — use importFromMnemonicBackup() for full upgrade.
      */
     async migrate(passphrase) {
+        MajikKeyValidator.validatePassphrase(passphrase);
+        if (this._kdfVersion === KDF_VERSION.ARGON2ID)
+            return this;
+        const salt = new Uint8Array(base64ToArrayBuffer(this._salt));
+        let privateKeyBuffer;
         try {
-            MajikKeyValidator.validatePassphrase(passphrase);
-            if (this._kdfVersion === KDF_VERSION.ARGON2ID)
-                return this;
-            const salt = new Uint8Array(base64ToArrayBuffer(this._salt));
-            const privateKeyBuffer = await MajikKey._decryptPrivateKey(this._encryptedPrivateKey, passphrase, salt, KDF_VERSION.PBKDF2);
+            privateKeyBuffer = await MajikKey._decryptPrivateKey(this._encryptedPrivateKey, passphrase, salt, KDF_VERSION.PBKDF2);
             const newSalt = generateRandomBytes(SALT_SIZE);
             const { blob } = await MajikKey._encryptPrivateKey(privateKeyBuffer, passphrase, newSalt);
             this._encryptedPrivateKey = blob;
@@ -590,6 +598,11 @@ export class MajikKey {
                 throw err;
             throw new MajikKeyError("Failed to migrate MajikKey to Argon2id", err);
         }
+        finally {
+            if (privateKeyBuffer)
+                secureFill.call(new Uint8Array(privateKeyBuffer), 0);
+            secureFill.call(salt, 0);
+        }
     }
     // ── LOCK / UNLOCK ────────────────────────────────────────────────────────────
     // required
@@ -613,7 +626,6 @@ export class MajikKey {
             secureFill.call(this._solanaKeypairMaterial.secretKey, 0);
         }
         this._privateKey = undefined;
-        this._privateKeyBase64 = undefined;
         this._mlKemSecretKey = undefined;
         this._edSecretKey = undefined;
         this._mlDsaSecretKey = undefined;
@@ -628,18 +640,11 @@ export class MajikKey {
             MajikKeyValidator.validatePassphrase(passphrase);
             const salt = new Uint8Array(base64ToArrayBuffer(this._salt));
             const privateKeyBuffer = await MajikKey._decryptPrivateKey(this._encryptedPrivateKey, passphrase, salt, this._kdfVersion);
-            let privateKey;
-            try {
-                privateKey = await crypto.subtle.importKey("raw", privateKeyBuffer, KEY_ALGO, true, ["sign"]);
-            }
-            catch {
-                privateKey = {
-                    type: "private",
-                    raw: new Uint8Array(privateKeyBuffer),
-                };
-            }
+            const privateKey = {
+                type: "private",
+                raw: new Uint8Array(privateKeyBuffer),
+            };
             this._privateKey = privateKey;
-            this._privateKeyBase64 = arrayBufferToBase64(privateKeyBuffer);
             if (this._encryptedMlKemSecretKey) {
                 this._mlKemSecretKey = await MajikKey._decryptMlKemSecretKey(this._encryptedMlKemSecretKey, passphrase, salt);
             }
@@ -678,7 +683,7 @@ export class MajikKey {
     getPrivateKeyBase64() {
         if (this.isLocked)
             throw new MajikKeyError("MajikKey is locked. Call unlock() first.");
-        return this._privateKeyBase64;
+        return arrayToBase64(this._privateKey.raw);
     }
     getMlKemSecretKey() {
         if (this.isLocked)
@@ -873,7 +878,6 @@ export class MajikKey {
                 encryptedMlKemSecretKey: identity.encryptedMlKemSecretKey,
                 encryptedMlKemSecretKeyBase64: arrayBufferToBase64(identity.encryptedMlKemSecretKey),
                 privateKey: identity.privateKey,
-                privateKeyBase64,
                 edPublicKey: identity.edPublicKey,
                 encryptedEdSecretKey: identity.encryptedEdSecretKey,
                 encryptedEdSecretKeyBase64: arrayBufferToBase64(identity.encryptedEdSecretKey),
@@ -910,19 +914,8 @@ export class MajikKey {
     static async _deriveAndEncryptFromMnemonic(mnemonic, passphrase, options) {
         const deriveBitcoin = options?.deriveBitcoin ?? true;
         const encIdentity = await EncryptionEngine.deriveIdentityFromMnemonic(mnemonic);
-        let exportedXPrivate;
-        try {
-            exportedXPrivate = await crypto.subtle.exportKey("raw", encIdentity.privateKey);
-        }
-        catch {
-            const anyPriv = encIdentity.privateKey;
-            if (anyPriv?.raw instanceof Uint8Array) {
-                exportedXPrivate = anyPriv.raw.buffer.slice(anyPriv.raw.byteOffset, anyPriv.raw.byteOffset + anyPriv.raw.byteLength);
-            }
-            else {
-                throw new MajikKeyError("Cannot export private key: unsupported format");
-            }
-        }
+        const anyPriv = encIdentity.privateKey;
+        const exportedXPrivate = anyPriv.raw.buffer.slice(anyPriv.raw.byteOffset, anyPriv.raw.byteOffset + anyPriv.raw.byteLength);
         // Single salt — one Argon2id derivation unlocks every key below
         const salt = generateRandomBytes(SALT_SIZE);
         const { blob: encryptedPrivateKey } = await MajikKey._encryptPrivateKey(exportedXPrivate, passphrase, salt);
@@ -1021,13 +1014,18 @@ export class MajikKey {
     }
     static async _decryptSigningKey(buffer, passphrase, salt) {
         const keyBytes = await deriveKeyFromPassphraseArgon2(passphrase, salt);
-        const full = new Uint8Array(buffer);
-        const iv = full.slice(0, IV_LENGTH);
-        const ciphertext = full.slice(IV_LENGTH);
-        const plain = aesGcmDecrypt(keyBytes, iv, ciphertext);
-        if (!plain)
-            throw new MajikKeyError("Failed to decrypt signing key");
-        return plain;
+        try {
+            const full = new Uint8Array(buffer);
+            const iv = full.slice(0, IV_LENGTH);
+            const ciphertext = full.slice(IV_LENGTH);
+            const plain = aesGcmDecrypt(keyBytes, iv, ciphertext);
+            if (!plain)
+                throw new MajikKeyError("Failed to decrypt signing key");
+            return plain;
+        }
+        finally {
+            secureFill.call(keyBytes, 0);
+        }
     }
     // ── PRIVATE: Backup ──────────────────────────────────────────────────────────
     static async _verifyBackupDecryption(ivBase64, ciphertextBase64, mnemonic, backupKdfVersion) {
@@ -1053,26 +1051,10 @@ export class MajikKey {
     static async _exportMnemonicBackup(identity, mnemonic) {
         if (!identity?.privateKey)
             throw new MajikKeyError("Identity must have privateKey to export backup");
-        let privRawBuf;
-        let pubRawBuf;
-        try {
-            privRawBuf = await crypto.subtle.exportKey("raw", identity.privateKey);
-            pubRawBuf = await crypto.subtle.exportKey("raw", identity.publicKey);
-        }
-        catch {
-            const anyPriv = identity.privateKey;
-            const anyPub = identity.publicKey;
-            if (anyPriv?.raw instanceof Uint8Array) {
-                privRawBuf = anyPriv.raw.buffer.slice(anyPriv.raw.byteOffset, anyPriv.raw.byteOffset + anyPriv.raw.byteLength);
-            }
-            else
-                throw new MajikKeyError("Cannot export private key");
-            if (anyPub?.raw instanceof Uint8Array) {
-                pubRawBuf = anyPub.raw.buffer.slice(anyPub.raw.byteOffset, anyPub.raw.byteOffset + anyPub.raw.byteLength);
-            }
-            else
-                throw new MajikKeyError("Cannot export public key");
-        }
+        const anyPriv = identity.privateKey;
+        const anyPub = identity.publicKey;
+        const privRawBuf = anyPriv.raw.buffer.slice(anyPriv.raw.byteOffset, anyPriv.raw.byteOffset + anyPriv.raw.byteLength);
+        const pubRawBuf = anyPub.raw.buffer.slice(anyPub.raw.byteOffset, anyPub.raw.byteOffset + anyPub.raw.byteLength);
         const mnemonicSalt = new TextEncoder().encode(MAJIK_MNEMONIC_SALT);
         const keyBytes = await deriveKeyFromMnemonicArgon2(mnemonic, mnemonicSalt);
         const iv = generateRandomBytes(IV_LENGTH);

package/package.json

@@ -2,7 +2,7 @@
   "name": "@majikah/majik-key",
   "type": "module",
   "description": "A post-quantum ready seed phrase account library for the Majikah ecosystem. Manages deterministic X25519 and ML-KEM-768 identities with Argon2id protection and seamless legacy account migration.",
-  "version": "0.3.2",
+  "version": "0.3.4",
   "license": "Apache-2.0",
   "author": "Zelijah",
   "main": "./dist/index.js",
@@ -75,9 +75,9 @@
     "@scure/btc-signer": "^2.2.0",
     "@solana/kit": "^7.0.0",
     "@types/ed2curve": "^0.2.4",
-    "@types/node": "^26.1.0",
-    "typescript": "^6.0.3",
-    "vitest": "^4.1.9"
+    "@types/node": "^26.1.1",
+    "typescript": "^7.0.2",
+    "vitest": "^4.1.10"
   },
   "peerDependencies": {
     "@scure/btc-signer": "^2.2.0",