@deserialize/multi-vm-wallet 1.5.21 → 1.5.31

package/utils/evm/utils.ts

@@ -13,6 +13,8 @@ import {
     encodeFunctionData,
     parseEther,
     formatEther,
+    createPublicClient,
+    http,
 } from 'viem'
 export interface TransactionParams {
     to: string
@@ -236,6 +238,16 @@ export const fromChainToViemChain = (config: ChainWalletConfig): Chain => {
 
 
 }
+
+
+export const createPublicClientFromChainConfig = (chain: ChainWalletConfig): PublicClient => {
+    return createPublicClient({
+        chain: fromChainToViemChain(chain),
+        transport: http(chain.rpcUrl)
+    });
+}
+
+
 export function viemReceiptToEthersReceipt(
     receipt: ViemTransactionReceipt,
 ): EthersTransactionReceipt {

package/utils/index.ts

@@ -6,7 +6,7 @@ export * from "./vm"
 // Note: Utility functions (discoverTokens, getTokenBalance, etc.) have name conflicts
 // Import them directly from './evm' or './svm' submodules when needed
 export { EVMVM, EVMChainWallet, EVMSmartWallet } from "./evm"
-export { SVMVM, SVMChainWallet, } from "./svm"
+export { SVMVM, SVMChainWallet, SVMChainAddress } from "./svm"
 
 // Re-export all EVM exports as namespace to avoid conflicts
 export * as evm from "./evm"
@@ -17,4 +17,4 @@ export * from "./constant"
 export * from "bs58"
 export * from "@solana/web3.js"
 export * from "./price"
-export * from "./utils"
+export * from "./utils"

package/utils/savings/svm-savings.ts

@@ -43,7 +43,7 @@ import BN from "bn.js";
  */
 export class SVMSavingsManager extends SavingsManager<PublicKey, Connection, Keypair> {
     coinType = 501;
-    derivationPathBase = "m/44'/501'/";
+    derivationPathBase = "m/44'/501'/"; // Base path for account derivation
 
     private rpcUrl: string;
     private _client?: Connection;

package/utils/svm/svm.ts

@@ -1,7 +1,7 @@
 import { Connection, Keypair, PublicKey, Transaction, VersionedTransaction } from "@solana/web3.js";
 import { SVMDeriveChildPrivateKey } from "../walletBip32";
 import { VM } from "../vm";
-import { ChainWallet } from "../IChainWallet";
+import { ChainAddress, ChainWallet } from "../IChainWallet";
 import { Balance, ChainWalletConfig, UserTokenBalance, TokenInfo, TransactionResult, NFT, DiscoveredWallet, WalletDiscoveryOptions, WalletDiscoveryResult, PocketDiscoveryOptions } from "../types";
 import { VMValidation, sanitizeError, logSafeError } from "../vm-validation";
 import {
@@ -29,10 +29,122 @@ import { fetchPrices } from "../price";
 import { PriceResponse } from "../price.types";
 import { getSVMTransactionHistory, SVMTransactionHistoryItem } from "./transactionParsing";
 
+/**
+ * Create a Solana connection for the provided chain configuration.
+ *
+ * @param config - Chain configuration containing the RPC URL.
+ * @returns Solana `Connection` instance.
+ */
+export const createSvmConnection = (config: ChainWalletConfig): Connection =>
+    new Connection(config.rpcUrl);
+
+/**
+ * Get native SOL balance for an address.
+ *
+ * @param address - Solana public key to query.
+ * @param connection - Solana connection.
+ * @returns Native balance details.
+ */
+export const getSvmNativeBalanceForAddress = async (
+    address: PublicKey,
+    connection: Connection
+): Promise<Balance> => {
+    return await SVMVM.getNativeBalance(address, connection);
+};
+
+/**
+ * Get SPL token balance for an address.
+ *
+ * @param address - Wallet public key to query.
+ * @param tokenAddress - SPL token mint address.
+ * @param connection - Solana connection.
+ * @returns Token balance details.
+ */
+export const getSvmTokenBalanceForAddress = async (
+    address: PublicKey,
+    tokenAddress: PublicKey,
+    connection: Connection
+): Promise<Balance> => {
+    return await SVMVM.getTokenBalance(address, tokenAddress, connection);
+};
+
+/**
+ * Discover SPL tokens held by an address.
+ *
+ * @param address - Wallet public key to scan.
+ * @param connection - Solana connection.
+ * @returns Discovered token balances.
+ */
+export const discoverSvmTokens = async (
+    address: PublicKey,
+    connection: Connection
+): Promise<UserTokenBalance<PublicKey>[]> => {
+    return await discoverTokens(address, connection);
+};
+
+/**
+ * Discover NFTs held by an address.
+ *
+ * @param address - Wallet public key to scan.
+ * @param connection - Solana connection.
+ * @returns Discovered NFTs.
+ */
+export const discoverSvmNFTs = async (
+    address: PublicKey,
+    connection: Connection
+): Promise<NFT[]> => {
+    return await fetchWalletNfts(address, connection);
+};
+
+/**
+ * Get parsed transaction history for an address.
+ *
+ * @param connection - Solana connection.
+ * @param address - Wallet public key to inspect.
+ * @returns Transaction history entries.
+ */
+export const getSvmTransactionHistoryForAddress = async (
+    connection: Connection,
+    address: PublicKey
+): Promise<SVMTransactionHistoryItem[]> => {
+    return await getSVMTransactionHistory(connection, address);
+};
+
+/**
+ * Fetch token prices for SVM tokens on the configured chain.
+ *
+ * @param config - Chain configuration used for chain ID resolution.
+ * @param tokenAddresses - Token mint addresses.
+ * @returns Price response payload.
+ * @throws Error when the price service reports a failure.
+ */
+export const getSvmPricesForTokens = async (
+    config: ChainWalletConfig,
+    tokenAddresses: string[]
+): Promise<PriceResponse> => {
+    const result = await fetchPrices({
+        vm: 'SVM',
+        chainId: config.chainId,
+        tokenAddresses,
+    });
+
+    if (result.error) {
+        throw new Error(result.error.message);
+    }
+
+    return result.data as PriceResponse;
+};
+
 
 export class SVMVM extends VM<PublicKey, Keypair, Connection> {
     getTokenInfo = getTokenInfo
     static getTokenInfo = getTokenInfo
+    /**
+     * Validate that an input can be parsed as a Solana public key.
+     *
+     * @param address - Address candidate.
+     * @returns `true` if valid, otherwise `false`.
+     */
     static validateAddress(address: PublicKey): boolean {
         try {
             new PublicKey(address)
@@ -42,15 +154,30 @@ export class SVMVM extends VM<PublicKey, Keypair, Connection> {
 
         }
     }
-    derivationPath = "m/44'/501'/"; // Default SVM derivation path
+    derivationPath = "m/44'/501'/0'/"; // Phantom standard derivation path
 
     constructor(seed: string) {
         super(seed, "SVM");
     }
 
+    /**
+     * Read native SOL balance for a wallet.
+     *
+     * @param address - Wallet public key.
+     * @param connection - Solana connection.
+     * @returns Native balance details.
+     */
     static getNativeBalance(address: PublicKey, connection: Connection): Promise<Balance> {
         return getSvmNativeBalance(address, connection);
     }
+    /**
+     * Read SPL token balance for a wallet.
+     *
+     * @param address - Wallet public key.
+     * @param tokenAddress - SPL token mint address.
+     * @param connection - Solana connection.
+     * @returns Token balance details normalized to `Balance`.
+     */
     static async getTokenBalance(address: PublicKey, tokenAddress: PublicKey, connection: Connection): Promise<Balance> {
         const balance = await getTokenBalance(address, tokenAddress, connection);
         if (balance === 0) {
@@ -65,11 +192,26 @@ export class SVMVM extends VM<PublicKey, Keypair, Connection> {
 
     static sendTransaction = sendTransaction
 
+    /**
+     * Convert entropy bytes (as string) into a Solana keypair seed.
+     *
+     * @param entropy - Entropy string.
+     * @returns Derived Solana keypair.
+     */
     static convertFromEntropyToPrivateKey = (entropy: string): Keypair => {
         return Keypair.fromSeed(Buffer.from(entropy))
     }
 
 
+    /**
+     * Derive a child keypair for a wallet index.
+     *
+     * @param index - Wallet index in derivation path.
+     * @param seed - Optional explicit seed (takes priority over mnemonic).
+     * @param mnemonic - Optional mnemonic used when seed is not provided.
+     * @param derivationPath - Base derivation path prefix.
+     * @returns Derived keypair and index.
+     */
     generatePrivateKey(index: number, seed?: string, mnemonic?: string, derivationPath = this.derivationPath) {
         // Validate inputs
         VMValidation.validateIndex(index, 'Wallet index');
@@ -95,6 +237,12 @@ export class SVMVM extends VM<PublicKey, Keypair, Connection> {
 
 
 
+    /**
+     * Create an `SVMVM` instance from a mnemonic phrase.
+     *
+     * @param mnemonic - BIP-39 mnemonic phrase.
+     * @returns Initialized SVM VM instance.
+     */
     static fromMnemonic(mnemonic: string): VM<PublicKey, Keypair, Connection> {
         const seed = VM.mnemonicToSeed(mnemonic)
         return new SVMVM(seed)
@@ -562,43 +710,159 @@ export class SVMVM extends VM<PublicKey, Keypair, Connection> {
     }
 }
 
+export class SVMChainAddress extends ChainAddress<PublicKey, Connection> {
+    /**
+     * Create a chain-address wrapper with a managed Solana connection.
+     *
+     * @param config - Chain configuration.
+     * @param address - Wallet public key.
+     * @param index - Optional wallet index.
+     */
+    constructor(config: ChainWalletConfig, address: PublicKey, index?: number) {
+        const connection = createSvmConnection(config);
+        super(config, address, index);
+        this.connection = connection;
+    }
+
+    /**
+     * Get native SOL balance for this address.
+     *
+     * @returns Native balance details.
+     */
+    async getNativeBalance(): Promise<Balance> {
+        return await getSvmNativeBalanceForAddress(this.address, this.connection!);
+    }
+
+    /**
+     * Get SPL token balance for this address.
+     *
+     * @param tokenAddress - SPL token mint address.
+     * @returns Token balance details.
+     */
+    async getTokenBalance(tokenAddress: PublicKey): Promise<Balance> {
+        return await getSvmTokenBalanceForAddress(this.address, tokenAddress, this.connection!);
+    }
+
+    /**
+     * Discover SPL tokens held by this address.
+     *
+     * @returns Discovered token balances.
+     */
+    async discoverToken(): Promise<UserTokenBalance<PublicKey>[]> {
+        return await discoverSvmTokens(this.address, this.connection!);
+    }
+
+    /**
+     * Discover NFTs held by this address.
+     *
+     * @returns Discovered NFTs.
+     */
+    async discoverNFT(): Promise<NFT[]> {
+        return await discoverSvmNFTs(this.address, this.connection!);
+    }
+
+    /**
+     * Get transaction history for this address.
+     *
+     * @returns Parsed transaction history entries.
+     */
+    async getTransactionHistory(): Promise<SVMTransactionHistoryItem[]> {
+        return await getSvmTransactionHistoryForAddress(this.connection!, this.address);
+    }
+
+    /**
+     * Fetch price data for token mints.
+     *
+     * @param tokenAddresses - Token mint addresses.
+     * @returns Price response.
+     */
+    async getPrices(tokenAddresses: string[]): Promise<PriceResponse> {
+        return await getSvmPricesForTokens(this.config, tokenAddresses);
+    }
+}
+
 export class SVMChainWallet extends ChainWallet<PublicKey, Keypair, Connection> {
+    /**
+     * Create a chain wallet around a Solana keypair.
+     *
+     * @param config - Chain configuration.
+     * @param privateKey - Wallet keypair.
+     * @param index - Wallet index.
+     */
     constructor(config: ChainWalletConfig, privateKey: Keypair, index: number) {
-        super(config, privateKey, index);
+        const address = privateKey.publicKey;
+        super(config, address, privateKey, index);
         this.address = privateKey.publicKey;
         this.privateKey = privateKey;
-        this.connection = new Connection(config.rpcUrl)
+        this.connection = createSvmConnection(config);
     }
+    /**
+     * Get this wallet's public address.
+     *
+     * @returns Solana public key.
+     */
     generateAddress() {
         return this.address;
     }
 
+    /**
+     * Convert entropy bytes (as string) into a Solana keypair.
+     *
+     * @param entropy - Entropy string.
+     * @returns Derived keypair.
+     */
     convertFromEntropyToPrivateKey = (entropy: string): Keypair => {
         return Keypair.fromSeed(Buffer.from(entropy))
     }
+    /**
+     * Get native SOL balance for this wallet.
+     *
+     * @returns Native balance details.
+     */
     async getNativeBalance(): Promise<Balance> {
         // Implement native balance retrieval logic here
-        return await SVMVM.getNativeBalance(this.address, this.connection!)
+        return await getSvmNativeBalanceForAddress(this.address, this.connection!);
     }
 
 
 
+    /**
+     * Get SPL token balance for this wallet.
+     *
+     * @param tokenAddress - SPL token mint address.
+     * @returns Token balance details.
+     */
     async getTokenBalance(tokenAddress: PublicKey): Promise<Balance> {
         // Implement token balance retrieval logic here
-        return await SVMVM.getTokenBalance(this.address, (tokenAddress), this.connection!);
+        return await getSvmTokenBalanceForAddress(this.address, tokenAddress, this.connection!);
     }
+    /**
+     * Discover SPL tokens held by this wallet.
+     *
+     * @returns Discovered token balances.
+     */
     async discoverToken(): Promise<UserTokenBalance<PublicKey>[]> {
         // Implement token discovery logic here
-        const tokens = await discoverTokens(this.address, this.connection!)
-        return tokens
+        return await discoverSvmTokens(this.address, this.connection!);
     }
 
+    /**
+     * Discover NFTs held by this wallet.
+     *
+     * @returns Discovered NFTs.
+     */
     async discoverNFT(): Promise<NFT[]> {
         // Implement NFT discovery logic here
-        const nfts = await fetchWalletNfts(this.address, this.connection!)
-        return nfts
+        return await discoverSvmNFTs(this.address, this.connection!);
     }
 
+    /**
+     * Transfer native SOL to another address.
+     *
+     * @param to - Recipient public key.
+     * @param amount - Amount of SOL to transfer.
+     * @returns Transaction result containing signature hash.
+     */
     async transferNative(to: PublicKey, amount: number): Promise<TransactionResult> {
         // Implement native transfer logic here
         const transaction = await getTransferNativeTransaction(
@@ -617,6 +881,14 @@ export class SVMChainWallet extends ChainWallet<PublicKey, Keypair, Connection>
         return { success: true, hash };
     }
 
+    /**
+     * Transfer SPL tokens to another address.
+     *
+     * @param token - Token info to transfer.
+     * @param to - Recipient public key.
+     * @param amount - Amount in UI units.
+     * @returns Transaction result containing signature hash.
+     */
     async transferToken(token: TokenInfo, to: PublicKey, amount: number): Promise<TransactionResult> {
         // Implement token transfer logic here
         const transaction = await getTransferTokenTransaction(
@@ -636,41 +908,74 @@ export class SVMChainWallet extends ChainWallet<PublicKey, Keypair, Connection>
         return { success: true, hash };
     }
 
+    /**
+     * Sign a transaction with this wallet.
+     *
+     * @param transaction - Legacy or versioned transaction.
+     * @returns Signed transaction.
+     */
     async signTransaction(transaction: VersionedTransaction | Transaction) {
         return await SVMVM.signTransaction(transaction, this.privateKey)
     }
 
+    /**
+     * Send a pre-signed transaction to the network.
+     *
+     * @param transaction - Signed legacy or versioned transaction.
+     * @returns Transaction signature hash.
+     */
     async sendTransaction(transaction: VersionedTransaction | Transaction) {
         return await SVMVM.sendTransaction(transaction, this.connection!)
     }
 
+    /**
+     * Sign and send a transaction in one step.
+     *
+     * @param transaction - Legacy or versioned transaction.
+     * @returns Transaction signature hash.
+     */
     async signAndSendTransaction(transaction: VersionedTransaction | Transaction) {
         return await SVMVM.signAndSendTransaction(transaction, this.connection!, this.privateKey);
     }
 
+    /**
+     * Get transaction history for this wallet.
+     *
+     * @returns Parsed transaction history entries.
+     */
     async getTransactionHistory(): Promise<SVMTransactionHistoryItem[]> {
-        const history = await getSVMTransactionHistory(this.connection!, this.address);
-        return history;
+        return await getSvmTransactionHistoryForAddress(this.connection!, this.address);
     }
 
+    /**
+     * Get token metadata for an SPL mint.
+     *
+     * @param tokenAddress - SPL token mint address.
+     * @returns Token metadata from `getTokenInfo`.
+     */
     async getTokenInfo(tokenAddress: PublicKey) {
         return await SVMVM.getTokenInfo(tokenAddress, this.connection!)
     }
 
+    /**
+     * Fetch prices for provided token mints.
+     *
+     * @param tokenAddresses - Token mint addresses.
+     * @returns Price response.
+     */
     async getPrices(tokenAddresses: string[]): Promise<PriceResponse> {
-        const result = await fetchPrices({
-            vm: 'SVM',
-            chainId: this.config.chainId,
-            tokenAddresses,
-        });
-
-        if (result.error) {
-            throw new Error(result.error.message);
-        }
-
-        return result.data as PriceResponse;
+        return await getSvmPricesForTokens(this.config, tokenAddresses);
     }
 
+    /**
+     * Execute a token swap via Jupiter.
+     *
+     * @param fromToken - Source token info.
+     * @param toToken - Destination token mint.
+     * @param amount - Amount in source token UI units.
+     * @param slippage - Slippage tolerance in basis points.
+     * @returns Transaction result with success/error details.
+     */
     async swap(fromToken: TokenInfo, toToken: PublicKey, amount: number, slippage: number = 50): Promise<TransactionResult> {
         try {
             if (amount <= 0) {
@@ -751,6 +1056,15 @@ export class SVMChainWallet extends ChainWallet<PublicKey, Keypair, Connection>
         }
     }
 
+    /**
+     * Fetch a Jupiter quote without sending a transaction.
+     *
+     * @param fromToken - Source token info.
+     * @param toToken - Destination token mint.
+     * @param amount - Amount in source token UI units.
+     * @param slippage - Slippage tolerance in basis points.
+     * @returns Quote payload with input/output values and route data.
+     */
     async getSwapQuote(fromToken: TokenInfo, toToken: PublicKey, amount: number, slippage: number = 50): Promise<{
         success: boolean;
         inputAmount?: string;
@@ -786,8 +1100,14 @@ export class SVMChainWallet extends ChainWallet<PublicKey, Keypair, Connection>
             };
         }
     }
+    /**
+     * Sign raw message bytes using ed25519 detached signature.
+     *
+     * @param message - Message bytes to sign.
+     * @returns Detached signature bytes.
+     */
     signMessage = (message: Uint8Array<ArrayBuffer>,) => {
         const signature = nacl.sign.detached(message, this.privateKey.secretKey);
         return signature
     };
-}
+}

package/utils/test.ts

@@ -5,10 +5,10 @@ import base58 from "bs58";
 import { NATIVE_MINT } from "@solana/spl-token";
 import { Connection, PublicKey, Keypair } from "@solana/web3.js";
 // import { GenerateNewMnemonic } from "./bip32";
-import { SVMChainWallet, SVMVM, } from "./svm";
+import { SVMChainAddress, SVMChainWallet, SVMVM, } from "./svm";
 import { VM } from "./vm";
 import { ChainWalletConfig } from "./types";
-import { discoverNFTs, EVMChainWallet, EVMVM } from "./evm";
+import { discoverNFTs, EVMChainAddress, EVMChainWallet, EVMVM } from "./evm";
 import { } from "./svm/transactionParsing";
 import { getEVMTransactionHistory } from "./evm/transactionParsing";
 import { createPublicClient, encodeFunctionData, Hex, http, parseAbi, parseUnits, PublicClient, zeroAddress } from "viem";
@@ -53,7 +53,6 @@ const chainConfig: ChainWalletConfig = {
     confirmationNo: 1,
     vmType: "SVM",
     logoUrl: ""
-
 }
 
 const evmChainConfig: ChainWalletConfig = {
@@ -388,6 +387,22 @@ const testSavingsPocketMultiChain = async () => {
     console.log('\n✅ Multi-Chain Savings Test Complete\n');
 }
 
+const testEntropy = () => {
+    const p = EVMVM.convertFromEntropyToPrivateKey("thishgbmytesentropystringis32bytes!hjkjkhknkjtdyftgkh,jryctdrfygh")
+    console.log('p: ', p);
+    const res = new EVMChainWallet(evmChainConfig, p, 0)
+    console.log('res: ', res);
+}
+
+const testAddressClass = async () => {
+
+    const evmAddressClass = new EVMChainAddress(evmChainConfig, "0xC9C1D854b82BA9b4FB6f6D58E9EF3d1fAEd601AA", 0)
+    const res = await evmAddressClass.getNativeBalance()
+    console.log('res: ', res);
+
+    // const svmAddressClass = new SVMChainAddress( )
+}
+testAddressClass()
 // Uncomment to run tests
 // testSavingsPocket()
 // testSavingsPocketSVM()

package/utils/types.ts

@@ -18,13 +18,17 @@ export interface ChainWalletConfig {
     confirmationNo?: number
     testnet?: boolean;
     vmType: vmTypes
-
+    savings?: ChainSavingConfig
     // Smart wallet configuration (optional) only for EVM chains and 7702
-
     aaSupport?: AA_SupportConfig
 
 }
 
+export interface ChainSavingConfig {
+    tokens: string[]; // List of token addresses to track for savings
+
+}
+
 export interface AA_SupportConfig {
     enabled: boolean;
     entryPoints: {

package/utils/utils.ts

@@ -18,3 +18,10 @@ export const getPrivateKeyFromAnother = (privateKey: any, fromVm: vmTypes, toVm:
         throw new Error("No conversion available for this vms yet")
     }
 }
+
+
+//TODO: 
+
+// create a unified evm svm balan e querying function
+//create a chain wallet class that takes address and chain config and probably vm
+