@deserialize/multi-vm-wallet 1.0.3 → 1.0.4

package/utils/test.ts

@@ -0,0 +1,49 @@
+import { generateKey } from "crypto";
+
+import { Keypair, PublicKey } from "@solana/web3.js";
+import base58 from "bs58";
+import { NATIVE_MINT } from "@solana/spl-token";
+import { GenerateNewMnemonic } from "./bip32";
+import { SVMChainWallet, SVMVM } from "./svm";
+import { VM } from "./vm";
+import { ChainWalletConfig } from "./types";
+const mnemonic = GenerateNewMnemonic()
+
+
+console.log('mnemonic: ', mnemonic);
+
+const seed = VM.mnemonicToSeed(mnemonic)
+const pKey = "4QxETeX9pndiF1XNghUiDTnZnHq3cfjmuPLBJysrgocsLq1yb8w96aPWALa8ZnRZWmDU4wM8Tg8d1ZRVVByj7uXE"
+
+export const testUserKeyPair = Keypair.fromSecretKey(base58.decode(pKey));
+const vm = new SVMVM(seed)
+// const vmFromMnemonic = SVMVM.fromMnemonic(mnemonic)
+// const keyFromMnemonic = vmFromMnemonic.generatePrivateKey(0)
+// console.log('keyFromMnemonic: ', keyFromMnemonic.privateKey.publicKey);
+const key = vm.generatePrivateKey(0)
+console.log('key: ', key.privateKey.publicKey);
+const chainConfig: ChainWalletConfig = {
+    chainId: "solana-mainnet",
+    name: "Solana",
+    rpcUrl: "https://solana-mainnet.g.alchemy.com/v2/vB5mKztdJeFdz9RkW99Qf",
+    explorerUrl: "https://explorer.solana.com",
+    nativeToken: { name: "Solana", symbol: "SOL", decimals: 9 },
+    confirmationNo: 1,
+
+}
+
+
+const wallet = new SVMChainWallet(chainConfig, testUserKeyPair, key.index)
+const toBuy = new PublicKey("9BB6NFEcjBCtnNLFko2FqVQBq8HHM13kCyYcdQbgpump")
+wallet.swap({
+    name: NATIVE_MINT.toBase58(),
+    address: NATIVE_MINT.toBase58(),
+    symbol: NATIVE_MINT.toBase58(),
+    decimals: 9
+}, toBuy, 0.005,).then(res => console.log(res))
+
+
+// console.log('wal: ', wal.address);
+// wal.getNativeBalance().then(e => console.log(e))
+
+

package/utils/vm.ts

@@ -1,7 +1,7 @@
 
 import { Balance, ChainWalletConfig, vmTypes } from "./types";
 import * as bip39 from "bip39";
-
+import CryptoJS from "crypto-js";
 // Abstract Base Classes
 export abstract class VM<AddressType, PrivateKeyType, ConnectionType> {
     protected seed: string;
@@ -15,12 +15,61 @@ export abstract class VM<AddressType, PrivateKeyType, ConnectionType> {
         return bip39.mnemonicToSeedSync(mnemonic).toString("hex");
     }
 
+    static generateSalt(): string {
+        return CryptoJS.lib.WordArray.random(16).toString(); // 128-bit salt
+    }
+    static deriveKey(
+        password: string,
+        salt: string,
+        iterations = 10000,
+        keySize = 256 / 32
+    ) {
+        return CryptoJS.PBKDF2(password, CryptoJS.enc.Hex.parse(salt), {
+            keySize: keySize,
+            iterations: iterations,
+        }).toString();
+    }
+    static encryptSeedPhrase(seedPhrase: string, password: string) {
+        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
+        const encrypted = CryptoJS.AES.encrypt(seedPhrase, key).toString();
+
+        // Return the encrypted data and the salt (needed for decryption)
+        return { encrypted, salt };
+    }
+
+    static decryptSeedPhrase(
+        encryptedSeedPhrase: string,
+        password: string,
+        salt: string
+    ) {
+        try {
+            const key = this.deriveKey(password, salt); // Derive the key using the same salt
+            const bytes = CryptoJS.AES.decrypt(encryptedSeedPhrase, key);
+            const seedPhrase = bytes.toString(CryptoJS.enc.Utf8);
+
+            // Check if decryption was successful
+            if (!seedPhrase) throw new Error("Decryption failed.");
+            return seedPhrase;
+        } catch (e: any) {
+            console.error("Invalid password or corrupted data:", e.message);
+            return null;
+        }
+    }
+    generateSalt = VM.generateSalt
+    deriveKey = VM.deriveKey
+    encryptSeedPhrase = VM.encryptSeedPhrase
+    decryptSeedPhrase = VM.decryptSeedPhrase
+
     abstract derivationPath: string
 
 
 
     abstract generatePrivateKey(index: number, mnemonic?: string, derivationPath?: string): { privateKey: PrivateKeyType, index: number };
 
+
     // abstract validateAddress(address: AddressType): boolean;
     // abstract getNativeBalance(address: AddressType, connection: ConnectionType): Promise<Balance>;
 }