@deserialize/multi-vm-wallet 1.4.12 → 1.5.0

package/dist/types.d.ts

@@ -208,6 +208,42 @@ export interface Balance {
     formatted: number;
     decimal: number;
 }
+export interface DiscoveredWallet {
+    index: number;
+    address: string;
+    derivationPath: string;
+    nativeBalance: {
+        amount: bigint;
+        formatted: number;
+        symbol: string;
+    };
+    privateKey?: string;
+}
+export interface WalletDiscoveryOptions {
+    startIndex?: number;
+    maxIndex?: number;
+    gapLimit?: number;
+    minBalance?: bigint;
+    includeZeroBalance?: boolean;
+    includePrivateKeys?: boolean;
+    checkInParallel?: boolean;
+    batchSize?: number;
+    checkDelay?: number;
+    onProgress?: (current: number, total: number, found: number) => void;
+    onDiscovered?: (wallet: DiscoveredWallet) => void;
+}
+export interface PocketDiscoveryOptions extends Omit<WalletDiscoveryOptions, 'onDiscovered'> {
+    walletIndex?: number;
+    onDiscovered?: (pocket: DiscoveredWallet) => void;
+}
+export interface WalletDiscoveryResult {
+    discovered: DiscoveredWallet[];
+    scannedIndices: number;
+    highestIndex: number;
+    totalBalance: bigint;
+    stoppedByGapLimit: boolean;
+    duration: number;
+}
 export declare const SUPPORTED_VM: {
     readonly EVM: typeof EVMVM;
     readonly SVM: typeof SVMVM;

package/dist/types.js

@@ -7,4 +7,3 @@ exports.SUPPORTED_VM = {
     'EVM': evm_1.EVMVM,
     'SVM': svm_1.SVMVM
 };
-//# sourceMappingURL=types.js.map

package/dist/utils.js

@@ -20,4 +20,3 @@ const getPrivateKeyFromAnother = (privateKey, fromVm, toVm) => {
     }
 };
 exports.getPrivateKeyFromAnother = getPrivateKeyFromAnother;
-//# sourceMappingURL=utils.js.map

package/dist/vm-validation.d.ts

@@ -0,0 +1,11 @@
+export declare class VMValidation {
+    static validateIndex(index: number, label?: string): void;
+    static validateSeed(seed: string): void;
+    static validateMnemonic(mnemonic: string): void;
+    static validateDerivationPath(path: string, vmType?: 'EVM' | 'SVM'): void;
+    static validatePassword(password: string, minLength?: number): void;
+    static validateAmount(amount: bigint, label?: string): void;
+    static validateEthereumAddress(address: string, label?: string): void;
+}
+export declare function sanitizeError(error: any, additionalSensitiveFields?: string[]): Error;
+export declare function logSafeError(message: string, error: any, context?: Record<string, any>): void;

package/dist/vm-validation.js

@@ -0,0 +1,151 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VMValidation = void 0;
+exports.sanitizeError = sanitizeError;
+exports.logSafeError = logSafeError;
+class VMValidation {
+    static validateIndex(index, label = 'Index') {
+        if (!Number.isInteger(index)) {
+            throw new Error(`${label} must be an integer, got: ${index}`);
+        }
+        if (index < 0) {
+            throw new Error(`${label} must be non-negative, got: ${index}`);
+        }
+        if (index > 0x7FFFFFFF) {
+            throw new Error(`${label} exceeds maximum (2147483647), got: ${index}`);
+        }
+    }
+    static validateSeed(seed) {
+        if (typeof seed !== 'string') {
+            throw new Error(`Seed must be a string, got: ${typeof seed}`);
+        }
+        if (seed.length === 0) {
+            throw new Error('Seed cannot be empty');
+        }
+        if (!/^[0-9a-fA-F]+$/.test(seed)) {
+            throw new Error('Seed must be a hex string');
+        }
+        if (seed.length < 32) {
+            throw new Error(`Seed too short: ${seed.length} chars (minimum 32)`);
+        }
+    }
+    static validateMnemonic(mnemonic) {
+        if (typeof mnemonic !== 'string') {
+            throw new Error(`Mnemonic must be a string, got: ${typeof mnemonic}`);
+        }
+        const trimmed = mnemonic.trim();
+        if (trimmed.length === 0) {
+            throw new Error('Mnemonic cannot be empty');
+        }
+        const words = trimmed.split(/\s+/);
+        const validWordCounts = [12, 15, 18, 21, 24];
+        if (!validWordCounts.includes(words.length)) {
+            throw new Error(`Mnemonic must have 12, 15, 18, 21, or 24 words (BIP-39 standard), got: ${words.length} words`);
+        }
+    }
+    static validateDerivationPath(path, vmType) {
+        if (typeof path !== 'string') {
+            throw new Error(`Derivation path must be a string, got: ${typeof path}`);
+        }
+        const pathRegex = /^m(\/\d+')+$/;
+        if (!pathRegex.test(path)) {
+            throw new Error(`Invalid derivation path format: ${path}. ` +
+                `Expected format: m/44'/cointype'/account'/... (all segments hardened)`);
+        }
+        const parts = path.split('/');
+        if (parts.length < 3) {
+            throw new Error(`Derivation path too short: ${path}`);
+        }
+        const purpose = parseInt(parts[1].replace("'", ""));
+        if (purpose !== 44) {
+            console.warn(`Warning: Non-BIP-44 purpose value: ${purpose}`);
+        }
+        if (vmType && parts.length >= 3) {
+            const coinType = parseInt(parts[2].replace("'", ""));
+            if (vmType === 'EVM' && coinType !== 60) {
+                throw new Error(`Invalid coin type for EVM: ${coinType}. Expected 60 (Ethereum).`);
+            }
+            if (vmType === 'SVM' && coinType !== 501) {
+                throw new Error(`Invalid coin type for SVM: ${coinType}. Expected 501 (Solana).`);
+            }
+        }
+        for (let i = 1; i < parts.length; i++) {
+            const indexStr = parts[i].replace("'", "");
+            const index = parseInt(indexStr);
+            if (isNaN(index)) {
+                throw new Error(`Invalid index in path segment ${i}: ${parts[i]}`);
+            }
+            if (parts[i].endsWith("'")) {
+                if (index > 0x7FFFFFFF) {
+                    throw new Error(`Hardened index ${index} exceeds maximum`);
+                }
+            }
+            else {
+                if (index > 0x7FFFFFFF) {
+                    throw new Error(`Non-hardened index ${index} exceeds maximum`);
+                }
+            }
+        }
+    }
+    static validatePassword(password, minLength = 8) {
+        if (typeof password !== 'string') {
+            throw new Error(`Password must be a string, got: ${typeof password}`);
+        }
+        if (password.length < minLength) {
+            throw new Error(`Password too short. Minimum length: ${minLength}, got: ${password.length}`);
+        }
+        const weakPasswords = ['password', '12345678', 'qwerty', 'abc123'];
+        if (weakPasswords.includes(password.toLowerCase())) {
+            throw new Error('Password is too weak. Choose a stronger password.');
+        }
+    }
+    static validateAmount(amount, label = 'Amount') {
+        if (typeof amount !== 'bigint') {
+            throw new Error(`${label} must be a bigint, got: ${typeof amount}`);
+        }
+        if (amount <= 0n) {
+            throw new Error(`${label} must be positive, got: ${amount}`);
+        }
+    }
+    static validateEthereumAddress(address, label = 'Address') {
+        if (typeof address !== 'string') {
+            throw new Error(`${label} must be a string, got: ${typeof address}`);
+        }
+        if (!/^0x[a-fA-F0-9]{40}$/.test(address)) {
+            throw new Error(`${label} has invalid format. Expected 0x followed by 40 hex characters, got: ${address}`);
+        }
+    }
+}
+exports.VMValidation = VMValidation;
+function sanitizeError(error, additionalSensitiveFields = []) {
+    const message = error.message || error.toString();
+    let sanitized = message
+        .replace(/seed:\s*[0-9a-fA-F]{32,}/gi, 'seed: [REDACTED]')
+        .replace(/password:\s*\S+/gi, 'password: [REDACTED]')
+        .replace(/mnemonic:\s*.+/gi, 'mnemonic: [REDACTED]')
+        .replace(/private\s*key:\s*[0-9a-fA-F]+/gi, 'privateKey: [REDACTED]')
+        .replace(/0x[0-9a-fA-F]{64,}/g, '[PRIVATE_KEY_REDACTED]')
+        .replace(/secret:\s*\S+/gi, 'secret: [REDACTED]');
+    additionalSensitiveFields.forEach(field => {
+        const regex = new RegExp(`${field}:\\s*\\S+`, 'gi');
+        sanitized = sanitized.replace(regex, `${field}: [REDACTED]`);
+    });
+    const sanitizedError = new Error(sanitized);
+    sanitizedError.stack = error.stack;
+    return sanitizedError;
+}
+function logSafeError(message, error, context) {
+    const sanitized = sanitizeError(error);
+    const safeContext = context ? { ...context } : {};
+    const sensitiveKeys = ['seed', 'mnemonic', 'privateKey', 'password', 'secret'];
+    sensitiveKeys.forEach(key => {
+        if (safeContext[key]) {
+            safeContext[key] = '[REDACTED]';
+        }
+    });
+    console.error(message, {
+        error: sanitized.message,
+        stack: sanitized.stack,
+        context: safeContext
+    });
+}

package/dist/vm.d.ts

@@ -1,16 +1,28 @@
 import { TokenInfo, vmTypes } from "./types";
+import { EntropyToMnemonic } from "./walletBip32";
 export declare abstract class VM<AddressType, PrivateKeyType, ConnectionType> {
     protected seed: string;
     type: vmTypes;
+    private disposed;
     constructor(seed: string, vm: vmTypes);
     static mnemonicToSeed: (mnemonic: string) => string;
+    dispose(): void;
+    isDisposed(): boolean;
+    protected checkNotDisposed(): void;
     static generateSalt(): string;
+    static getMnemonicFromEntropy: typeof EntropyToMnemonic;
     static deriveKey(password: string, salt: string, iterations?: number, keySize?: number): string;
-    static encryptSeedPhrase(seedPhrase: string, password: string): {
+    static encryptSeedPhrase(seedPhrase: string, password: string, iterations?: number): {
         encrypted: string;
         salt: string;
+        iterations: number;
     };
-    static decryptSeedPhrase(encryptedSeedPhrase: string, password: string, salt: string): string | null;
+    static encryptSeedPhraseLegacy(seedPhrase: string, password: string): {
+        encrypted: string;
+        salt: string;
+    };
+    static decryptSeedPhrase(encryptedSeedPhrase: string, password: string, salt: string, iterations?: number): string | null;
+    static decryptSeedPhraseLegacy(encryptedSeedPhrase: string, password: string, salt: string): string | null;
     generateSalt: typeof VM.generateSalt;
     deriveKey: typeof VM.deriveKey;
     encryptSeedPhrase: typeof VM.encryptSeedPhrase;
@@ -21,18 +33,4 @@ export declare abstract class VM<AddressType, PrivateKeyType, ConnectionType> {
         index: number;
     };
     abstract getTokenInfo(tokenAddress: AddressType, connection: ConnectionType): Promise<TokenInfo>;
-    /**
-     * Derive a savings account using BIP-44 account index
-     *
-     * Main wallet uses: m/44'/60'/0'/0/0 (account index 0)
-     * Savings accounts use: m/44'/60'/N'/0/0 (account index N)
-     *
-     * @param accountIndex - The BIP-44 account index (1 for first savings, 2 for second, etc.)
-     * @returns Object containing privateKey, address, and derivation path
-     */
-    abstract deriveSavingsAccount(accountIndex: number): {
-        privateKey: PrivateKeyType;
-        address: AddressType;
-        derivationPath: string;
-    };
 }

package/dist/vm.js

@@ -1,91 +1,102 @@
 "use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.VM = void 0;
-const bip39 = __importStar(require("@scure/bip39"));
 const crypto_js_1 = __importDefault(require("crypto-js"));
-// Abstract Base Classes
+const walletBip32_1 = require("./walletBip32");
 class VM {
     seed;
     type;
+    disposed = false;
     constructor(seed, vm) {
         this.type = vm;
         this.seed = seed;
     }
-    static mnemonicToSeed = (mnemonic) => {
-        return Buffer.from(bip39.mnemonicToSeedSync(mnemonic)).toString("hex");
-    };
+    static mnemonicToSeed = walletBip32_1.mnemonicToSeed;
+    dispose() {
+        if (this.disposed) {
+            return;
+        }
+        this.seed = '';
+        this.disposed = true;
+    }
+    isDisposed() {
+        return this.disposed || !this.seed || this.seed === '';
+    }
+    checkNotDisposed() {
+        if (this.isDisposed()) {
+            throw new Error('VM has been disposed. Create a new instance to perform operations.');
+        }
+    }
     static generateSalt() {
-        return crypto_js_1.default.lib.WordArray.random(16).toString(); // 128-bit salt
+        return crypto_js_1.default.lib.WordArray.random(16).toString();
     }
-    static deriveKey(password, salt, iterations = 10000, keySize = 256 / 32) {
+    static getMnemonicFromEntropy = walletBip32_1.EntropyToMnemonic;
+    static deriveKey(password, salt, iterations = 600000, keySize = 256 / 32) {
+        if (!password || password.length < 8) {
+            throw new Error('Password must be at least 8 characters');
+        }
+        if (!salt) {
+            throw new Error('Salt is required');
+        }
+        if (iterations < 100000) {
+            console.warn(`⚠️ WARNING: Using ${iterations} PBKDF2 iterations is insecure. ` +
+                `Minimum recommended: 100,000. Recommended: 600,000.`);
+        }
         return crypto_js_1.default.PBKDF2(password, crypto_js_1.default.enc.Hex.parse(salt), {
             keySize: keySize,
             iterations: iterations,
+            hasher: crypto_js_1.default.algo.SHA256
         }).toString();
     }
-    static encryptSeedPhrase(seedPhrase, password) {
-        const salt = this.generateSalt(); // Generate a unique salt for this encryption
-        const key = this.deriveKey(password, salt); // Derive a key using PBKDF2
-        // Encrypt the seed phrase with AES using the derived key
+    static encryptSeedPhrase(seedPhrase, password, iterations = 600000) {
+        if (!seedPhrase || seedPhrase.trim().length === 0) {
+            throw new Error('Seed phrase cannot be empty');
+        }
+        if (!password || password.length < 8) {
+            throw new Error('Password must be at least 8 characters');
+        }
+        const salt = this.generateSalt();
+        const key = this.deriveKey(password, salt, iterations);
         const encrypted = crypto_js_1.default.AES.encrypt(seedPhrase, key).toString();
-        // Return the encrypted data and the salt (needed for decryption)
-        return { encrypted, salt };
+        return { encrypted, salt, iterations };
+    }
+    static encryptSeedPhraseLegacy(seedPhrase, password) {
+        const result = this.encryptSeedPhrase(seedPhrase, password, 10000);
+        return { encrypted: result.encrypted, salt: result.salt };
     }
-    static decryptSeedPhrase(encryptedSeedPhrase, password, salt) {
+    static decryptSeedPhrase(encryptedSeedPhrase, password, salt, iterations = 600000) {
         try {
-            const key = this.deriveKey(password, salt); // Derive the key using the same salt
+            if (!encryptedSeedPhrase) {
+                throw new Error('Encrypted seed phrase is required');
+            }
+            if (!password || password.length < 8) {
+                throw new Error('Password must be at least 8 characters');
+            }
+            if (!salt) {
+                throw new Error('Salt is required');
+            }
+            const key = this.deriveKey(password, salt, iterations);
             const bytes = crypto_js_1.default.AES.decrypt(encryptedSeedPhrase, key);
             const seedPhrase = bytes.toString(crypto_js_1.default.enc.Utf8);
-            // Check if decryption was successful
-            if (!seedPhrase)
-                throw new Error("Decryption failed.");
+            if (!seedPhrase || seedPhrase.trim().length === 0) {
+                throw new Error("Decryption failed - invalid password or corrupted data");
+            }
             return seedPhrase;
         }
         catch (e) {
-            console.error("Invalid password or corrupted data:", e.message);
+            console.error("Decryption failed:", e.message);
             return null;
         }
     }
+    static decryptSeedPhraseLegacy(encryptedSeedPhrase, password, salt) {
+        return this.decryptSeedPhrase(encryptedSeedPhrase, password, salt, 10000);
+    }
     generateSalt = VM.generateSalt;
     deriveKey = VM.deriveKey;
     encryptSeedPhrase = VM.encryptSeedPhrase;
     decryptSeedPhrase = VM.decryptSeedPhrase;
 }
 exports.VM = VM;
-//# sourceMappingURL=vm.js.map

package/dist/walletBip32.d.ts

@@ -1,5 +1,7 @@
 import { Keypair } from "@solana/web3.js";
 export declare function GenerateNewMnemonic(): string;
+export declare const mnemonicToSeed: (mnemonic: string) => string;
+export declare function EntropyToMnemonic(entropy: string): string;
 export declare function ValidateMnemonic(mnemonic: string): true;
 export declare function GenerateSeed(_mnemonic?: string): Uint8Array<ArrayBufferLike>;
 export declare function EVMDeriveChildPrivateKey(seed: string, index: number, derivationPath: string): {

package/dist/walletBip32.js

@@ -1,10 +1,4 @@
 "use strict";
-// import * as bip39 from "bip39";
-// import BIP32Factory from "bip32";
-// import * as ecc from "tiny-secp256k1";
-// import { BIP32Interface } from "bip32";
-// import * as ed25519 from "ed25519-hd-key";
-// import { Keypair } from "@solana/web3.js";
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     var desc = Object.getOwnPropertyDescriptor(m, k);
@@ -39,74 +33,45 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.mnemonicToSeed = void 0;
 exports.GenerateNewMnemonic = GenerateNewMnemonic;
+exports.EntropyToMnemonic = EntropyToMnemonic;
 exports.ValidateMnemonic = ValidateMnemonic;
 exports.GenerateSeed = GenerateSeed;
 exports.EVMDeriveChildPrivateKey = EVMDeriveChildPrivateKey;
 exports.SVMDeriveChildPrivateKey = SVMDeriveChildPrivateKey;
-// // export function getPublicKeyFromSeed(seed: string, index: number) {
-// //     const node = getSeedNode(seed);
-// //     const { publicKey } = deriveChildPrivateKey(node, index);
-// //     return publicKey;
-// // }
-// // export function getPrivateKeyFromSeed(seed: string, index: number) {
-// //     const node = getSeedNode(seed);
-// //     const keyPair = deriveChildPrivateKey(node, index);
-// //     return keyPair.privateKey;
-// // }
-// export function GenerateNewMnemonic() {
-//     const mnemonic = bip39.generateMnemonic();
-//     return mnemonic;
-// }
-// export function ValidateMnemonic(mnemonic: string) {
-//     const isValid = bip39.validateMnemonic(mnemonic);
-//     if (!isValid) {
-//         throw new Error("Invalid mnemonic");
-//     }
-//     return isValid;
-// }
-// export function GenerateSeed(_mnemonic?: string) {
-//     const mnemonic = _mnemonic || bip39.generateMnemonic();
-//     const seed = bip39.mnemonicToSeedSync(mnemonic);
-//     const seedString = seed.toString("hex");
-//     return seedString;
-// }
-// export function getSeedNode(seed: string) {
-//     const bip32 = BIP32Factory(ecc);
-//     const restoredSeedBuffer = Buffer.from(seed, "hex");
-//     const node: BIP32Interface = bip32.fromSeed(restoredSeedBuffer);
-//     return node;
-// }
-// //EVM
-// export function EVMDeriveChildPrivateKey(seed: string, index: number, derivationPath: string) {
-//     const node = getSeedNode(seed);
-//     const child = node.derivePath(`${derivationPath}${index}'`);
-//     const privateKey = child.privateKey!.toString("hex");
-//     const publicKey = child.publicKey.toString("hex");
-//     return { privateKey, publicKey };
-// }
-// //SVM
-// export function SVMDeriveChildPrivateKey(seed: string, index: number, derivationPath: string) {
-//     const path = `${derivationPath}${index}'`;
-//     // Derive a seed from the given path
-//     const derivedSeed = ed25519.derivePath(path, seed).key;
-//     const derivedKeyPair = Keypair.fromSeed(derivedSeed);
-//     return derivedKeyPair;
-// }
 const web3_js_1 = require("@solana/web3.js");
 const bip39 = __importStar(require("@scure/bip39"));
 const bip32_1 = require("@scure/bip32");
-const buffer_1 = require("buffer"); // Import the polyfill
+const buffer_1 = require("buffer");
 if (typeof window !== 'undefined') {
-    window.Buffer = buffer_1.Buffer; // Inject Buffer into the global scope
+    window.Buffer = buffer_1.Buffer;
 }
 const english_1 = require("./english");
 const hmac_1 = require("@noble/hashes/hmac");
 const sha2_1 = require("@noble/hashes/sha2");
+const vm_validation_1 = require("./vm-validation");
 function GenerateNewMnemonic() {
     const mnemonic = bip39.generateMnemonic(english_1.wordlist);
     return mnemonic;
 }
+const mnemonicToSeed = (mnemonic) => {
+    return buffer_1.Buffer.from(bip39.mnemonicToSeedSync(mnemonic)).toString("hex");
+};
+exports.mnemonicToSeed = mnemonicToSeed;
+function EntropyToMnemonic(entropy) {
+    const entropyBytes = buffer_1.Buffer.from(entropy);
+    const validLength = 16;
+    const truncatedBytes = entropyBytes.length >= validLength
+        ? entropyBytes.slice(0, validLength)
+        : entropyBytes;
+    if (truncatedBytes.length < validLength) {
+        const padded = buffer_1.Buffer.alloc(validLength, 0);
+        truncatedBytes.copy(padded);
+        return bip39.entropyToMnemonic(padded, english_1.wordlist);
+    }
+    return bip39.entropyToMnemonic(truncatedBytes, english_1.wordlist);
+}
 function ValidateMnemonic(mnemonic) {
     const isValid = bip39.validateMnemonic(mnemonic, english_1.wordlist);
     if (!isValid) {
@@ -119,19 +84,25 @@ function GenerateSeed(_mnemonic) {
     const seedString = bip39.mnemonicToSeedSync(mnemonic);
     return seedString;
 }
-//EVM
 function EVMDeriveChildPrivateKey(seed, index, derivationPath) {
+    vm_validation_1.VMValidation.validateSeed(seed);
+    vm_validation_1.VMValidation.validateIndex(index, 'Wallet index');
+    vm_validation_1.VMValidation.validateDerivationPath(derivationPath + index + "'", 'EVM');
     const path = `${derivationPath}${index}'`;
     const scureNode = bip32_1.HDKey.fromMasterSeed(buffer_1.Buffer.from(seed, "hex"));
     const child = scureNode.derive(path);
+    if (!child.privateKey) {
+        throw new Error(`Failed to derive private key at path: ${path}`);
+    }
     const privateKey = buffer_1.Buffer.from(child.privateKey).toString("hex");
     const publicKey = buffer_1.Buffer.from(child.publicKey).toString("hex");
     return { privateKey, publicKey };
 }
-//SVM
 function SVMDeriveChildPrivateKey(seed, index, derivationPath) {
+    vm_validation_1.VMValidation.validateSeed(seed);
+    vm_validation_1.VMValidation.validateIndex(index, 'Wallet index');
+    vm_validation_1.VMValidation.validateDerivationPath(derivationPath + index + "'", 'SVM');
     const path = `${derivationPath}${index}'`;
-    // Derive a seed from the given path
     const derivedSeed = derivePathEclipticCurve(path, buffer_1.Buffer.from(seed, "hex")).key;
     const derivedKeyPair = web3_js_1.Keypair.fromSeed(derivedSeed);
     return derivedKeyPair;
@@ -146,11 +117,9 @@ function derivePathEclipticCurve(path, seed) {
         }
         return parseInt(seg.slice(0, -1), 10) + 0x80000000;
     });
-    // Initialize with master key derivation
     let hmacResult = (0, hmac_1.hmac)(sha2_1.sha512, buffer_1.Buffer.from("ed25519 seed"), seed);
     let key = hmacResult.slice(0, 32);
     let chainCode = hmacResult.slice(32, 64);
-    // Derive each path segment
     for (const segment of segments) {
         const result = hardenedDerivation(key, chainCode, segment);
         key = buffer_1.Buffer.from(result.key);
@@ -161,12 +130,10 @@ function derivePathEclipticCurve(path, seed) {
 function hardenedDerivation(parentKey, parentChainCode, index) {
     const indexBuffer = new Uint8Array(4);
     new DataView(indexBuffer.buffer).setUint32(0, index, false);
-    // Proper SLIP-0010 format: 0x00 + parent_key + index
     const data = new Uint8Array([0x00, ...parentKey, ...indexBuffer]);
     const hmacResult = (0, hmac_1.hmac)(sha2_1.sha512, parentChainCode, data);
     return {
-        key: hmacResult.slice(0, 32), // Left 32 bytes
-        chainCode: hmacResult.slice(32, 64) // Right 32 bytes
+        key: hmacResult.slice(0, 32),
+        chainCode: hmacResult.slice(32, 64)
     };
 }
-//# sourceMappingURL=walletBip32.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@deserialize/multi-vm-wallet",
-  "version": "1.4.12",
+  "version": "1.5.0",
   "devDependencies": {
     "@types/bn.js": "^5.2.0",
     "@types/crypto-js": "^4.2.2",
@@ -40,10 +40,15 @@
   "types": "dist/index.d.ts",
   "scripts": {
     "test": "echo \"Error: no test specified\" && exit 1",
-    "build": "tsc -p tsconfig.json",
-    "dev": "ts-node-dev --respawn --transpile-only utils/index.ts",
-    "publish:sdk": "npm run build && npm publish --access=public"
+    "build": "bun run build:tsc",
+    "build:tsc": "tsc -p tsconfig.prod.json",
+    "build:fast": "bun build utils/index.ts --outdir dist --target node --format cjs --sourcemap && tsc -p tsconfig.prod.json --emitDeclarationOnly",
+    "build:dev": "tsc -p tsconfig.json",
+    "build:watch": "tsc -p tsconfig.json --watch",
+    "dev": "bun --watch utils/index.ts",
+    "publish:sdk": "bun run build && npm publish --access=public"
   },
+  "packageManager": "bun@1.3.1",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/Bravark/deserialize-swap-sdk.git"