@deserialize/multi-vm-wallet 1.5.33 → 1.5.35

package/dist/evm/evm.d.ts

@@ -3,7 +3,7 @@ import { Balance, ChainWalletConfig, UserTokenBalance, TokenInfo, TransactionRes
 import { VM } from "../vm";
 import { JsonRpcProvider } from "ethers";
 import { EVMTransactionHistoryItem } from "./transactionParsing";
-import { Hex, WalletClient, PublicClient } from "viem";
+import { Hex, Call, WalletClient, PublicClient } from "viem";
 import { EVMSmartWallet } from "./smartWallet";
 import { SmartWalletOptions } from "./aa-service";
 import { PriceResponse } from "../price.types";
@@ -45,6 +45,7 @@ export declare class EVMChainAddress extends ChainAddress<string, PublicClient>
     discoverToken(): Promise<UserTokenBalance<string>[]>;
     discoverNFT(): Promise<NFT[]>;
     getTransactionHistory(): Promise<EVMTransactionHistoryItem[]>;
+    estimateGas(transaction: Call): Promise<bigint>;
     getPrices(tokenAddresses: string[]): Promise<PriceResponse>;
 }
 export declare class EVMChainWallet extends ChainWallet<string, string, PublicClient> {

package/dist/evm/evm.js

@@ -457,6 +457,16 @@ class EVMChainAddress extends IChainWallet_1.ChainAddress {
     async getTransactionHistory() {
         return await (0, exports.getEvmTransactionHistorySafe)(this.connection, this.address);
     }
+    async estimateGas(transaction) {
+        try {
+            const gasEstimate = await this.connection.estimateGas(transaction);
+            return gasEstimate;
+        }
+        catch (error) {
+            console.error('Gas estimation failed:', error);
+            throw new Error('Failed to estimate gas for the transaction.');
+        }
+    }
     async getPrices(tokenAddresses) {
         return await (0, exports.getSvmPricesForTokens)(this.config, tokenAddresses);
     }

package/dist/svm/svm.d.ts

@@ -20,6 +20,7 @@ export declare class SVMVM extends VM<PublicKey, Keypair, Connection> {
     constructor(seed: string);
     static getNativeBalance(address: PublicKey, connection: Connection): Promise<Balance>;
     static getTokenBalance(address: PublicKey, tokenAddress: PublicKey, connection: Connection): Promise<Balance>;
+    static generateMnemonicFromPrivateKey(privateKey: Keypair): string;
     static signAndSendTransaction: (transaction: VersionedTransaction | Transaction, connection: Connection, signers: Keypair, options?: {
         partialSign?: boolean;
         feePayerSigner?: Keypair;
@@ -66,6 +67,11 @@ export declare class SVMChainWallet extends ChainWallet<PublicKey, Keypair, Conn
     sendTransaction(transaction: VersionedTransaction | Transaction): Promise<string>;
     signAndSendTransaction(transaction: VersionedTransaction | Transaction): Promise<string>;
     getTransactionHistory(): Promise<SVMTransactionHistoryItem[]>;
+    estimateGas(transaction: VersionedTransaction | Transaction): Promise<number>;
+    private extractComputeBudgetDetails;
+    private readU32LE;
+    private readU64LE;
+    private ceilDiv;
     getTokenInfo(tokenAddress: PublicKey): Promise<TokenInfo>;
     getPrices(tokenAddresses: string[]): Promise<PriceResponse>;
     swap(fromToken: TokenInfo, toToken: PublicKey, amount: number, slippage?: number): Promise<TransactionResult>;

package/dist/svm/svm.js

@@ -75,6 +75,9 @@ class SVMVM extends vm_1.VM {
         }
         return { balance: new bn_js_1.default(balance.amount), formatted: balance.uiAmount || parseInt(balance.amount) / 10 ** balance.decimals, decimal: balance.decimals };
     }
+    static generateMnemonicFromPrivateKey(privateKey) {
+        return (0, walletBip32_1.EntropyToMnemonic)(bs58_1.default.encode(privateKey.secretKey));
+    }
     static signAndSendTransaction = utils_1.signAndSendTransaction;
     static signTransaction = utils_1.signTransaction;
     static sendTransaction = utils_1.sendTransaction;
@@ -438,6 +441,106 @@ class SVMChainWallet extends IChainWallet_1.ChainWallet {
     async getTransactionHistory() {
         return await (0, exports.getSvmTransactionHistoryForAddress)(this.connection, this.address);
     }
+    async estimateGas(transaction) {
+        const connection = this.connection;
+        if (transaction instanceof web3_js_1.Transaction) {
+            if (!transaction.feePayer) {
+                transaction.feePayer = this.address;
+            }
+            if (!transaction.recentBlockhash) {
+                const { blockhash } = await connection.getLatestBlockhash();
+                transaction.recentBlockhash = blockhash;
+            }
+        }
+        const message = transaction instanceof web3_js_1.Transaction
+            ? transaction.compileMessage()
+            : transaction.message;
+        const feeResponse = await connection.getFeeForMessage(message);
+        const baseFeeLamports = feeResponse.value ?? 0;
+        const { computeUnitPriceMicroLamports, computeUnitLimit } = this.extractComputeBudgetDetails(transaction);
+        if (computeUnitPriceMicroLamports === 0n) {
+            return baseFeeLamports;
+        }
+        let unitsConsumed;
+        try {
+            const simulation = transaction instanceof web3_js_1.Transaction
+                ? await connection.simulateTransaction(transaction)
+                : await connection.simulateTransaction(transaction, {
+                    sigVerify: false,
+                    replaceRecentBlockhash: true,
+                });
+            unitsConsumed = simulation.value.unitsConsumed ?? undefined;
+        }
+        catch {
+        }
+        const effectiveComputeUnits = BigInt(unitsConsumed ?? computeUnitLimit ?? 200_000);
+        const priorityFeeLamports = this.ceilDiv(effectiveComputeUnits * computeUnitPriceMicroLamports, 1000000n);
+        const totalFeeLamports = BigInt(baseFeeLamports) + priorityFeeLamports;
+        if (totalFeeLamports > BigInt(Number.MAX_SAFE_INTEGER)) {
+            throw new Error("Estimated fee exceeds JavaScript safe integer range");
+        }
+        return Number(totalFeeLamports);
+    }
+    extractComputeBudgetDetails(transaction) {
+        let computeUnitPriceMicroLamports = 0n;
+        let computeUnitLimit;
+        if (transaction instanceof web3_js_1.Transaction) {
+            for (const instruction of transaction.instructions) {
+                if (!instruction.programId.equals(web3_js_1.ComputeBudgetProgram.programId)) {
+                    continue;
+                }
+                const data = instruction.data;
+                if (!data || data.length === 0) {
+                    continue;
+                }
+                const discriminator = data[0];
+                if (discriminator === 2 && data.length >= 5) {
+                    computeUnitLimit = this.readU32LE(data, 1);
+                }
+                else if (discriminator === 3 && data.length >= 9) {
+                    computeUnitPriceMicroLamports = this.readU64LE(data, 1);
+                }
+            }
+            return { computeUnitPriceMicroLamports, computeUnitLimit };
+        }
+        const message = transaction.message;
+        const compiledInstructions = message.compiledInstructions ?? [];
+        const staticAccountKeys = message.staticAccountKeys ?? [];
+        for (const instruction of compiledInstructions) {
+            const programId = staticAccountKeys[instruction.programIdIndex];
+            if (!programId || !programId.equals(web3_js_1.ComputeBudgetProgram.programId)) {
+                continue;
+            }
+            const data = instruction.data;
+            if (!data || data.length === 0) {
+                continue;
+            }
+            const discriminator = data[0];
+            if (discriminator === 2 && data.length >= 5) {
+                computeUnitLimit = this.readU32LE(data, 1);
+            }
+            else if (discriminator === 3 && data.length >= 9) {
+                computeUnitPriceMicroLamports = this.readU64LE(data, 1);
+            }
+        }
+        return { computeUnitPriceMicroLamports, computeUnitLimit };
+    }
+    readU32LE(data, offset) {
+        return (data[offset] |
+            (data[offset + 1] << 8) |
+            (data[offset + 2] << 16) |
+            (data[offset + 3] << 24)) >>> 0;
+    }
+    readU64LE(data, offset) {
+        let value = 0n;
+        for (let i = 0; i < 8; i++) {
+            value |= BigInt(data[offset + i]) << BigInt(8 * i);
+        }
+        return value;
+    }
+    ceilDiv(a, b) {
+        return (a + b - 1n) / b;
+    }
     async getTokenInfo(tokenAddress) {
         return await SVMVM.getTokenInfo(tokenAddress, this.connection);
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@deserialize/multi-vm-wallet",
-  "version": "1.5.33",
+  "version": "1.5.35",
   "devDependencies": {
     "@types/bn.js": "^5.2.0",
     "@types/crypto-js": "^4.2.2",

package/utils/evm/evm.ts

@@ -917,6 +917,17 @@ export class EVMChainAddress extends ChainAddress<string, PublicClient> {
         return await getEvmTransactionHistorySafe(this.connection!, this.address);
     }
 
+    //add gas estimation method here?
+    async estimateGas(transaction: Call): Promise<bigint> {
+        try {
+            const gasEstimate = await this.connection!.estimateGas(transaction);
+            return gasEstimate;
+        } catch (error) {
+            console.error('Gas estimation failed:', error);
+            throw new Error('Failed to estimate gas for the transaction.');
+        }
+    }
+
     /**
      * Fetch price data for the provided token addresses.
      *

package/utils/svm/svm.ts

@@ -1,5 +1,5 @@
-import { Connection, Keypair, PublicKey, Transaction, VersionedTransaction } from "@solana/web3.js";
-import { SVMDeriveChildPrivateKey } from "../walletBip32";
+import { ComputeBudgetProgram, Connection, Keypair, PublicKey, Transaction, VersionedTransaction } from "@solana/web3.js";
+import { EntropyToMnemonic, SVMDeriveChildPrivateKey } from "../walletBip32";
 import { VM } from "../vm";
 import { ChainAddress, ChainWallet } from "../IChainWallet";
 import { Balance, ChainWalletConfig, UserTokenBalance, TokenInfo, TransactionResult, NFT, DiscoveredWallet, WalletDiscoveryOptions, WalletDiscoveryResult, PocketDiscoveryOptions } from "../types";
@@ -185,6 +185,10 @@ export class SVMVM extends VM<PublicKey, Keypair, Connection> {
         }
         return { balance: new BN(balance.amount), formatted: balance.uiAmount || parseInt(balance.amount) / 10 ** balance.decimals, decimal: balance.decimals };
     }
+    static generateMnemonicFromPrivateKey(privateKey: Keypair): string {
+
+        return EntropyToMnemonic(base58.encode(privateKey.secretKey))
+    }
 
     static signAndSendTransaction = signAndSendTransaction
 
@@ -947,6 +951,143 @@ export class SVMChainWallet extends ChainWallet<PublicKey, Keypair, Connection>
         return await getSvmTransactionHistoryForAddress(this.connection!, this.address);
     }
 
+    //add gas estimation method here if needed, but note that Solana transactions typically have a fixed fee per signature and do not require gas estimation like EVM chains
+    async estimateGas(transaction: VersionedTransaction | Transaction): Promise<number> {
+        const connection = this.connection!;
+
+        if (transaction instanceof Transaction) {
+            if (!transaction.feePayer) {
+                transaction.feePayer = this.address;
+            }
+
+            if (!transaction.recentBlockhash) {
+                const { blockhash } = await connection.getLatestBlockhash();
+                transaction.recentBlockhash = blockhash;
+            }
+        }
+
+        const message = transaction instanceof Transaction
+            ? transaction.compileMessage()
+            : transaction.message;
+
+        const feeResponse = await connection.getFeeForMessage(message);
+        const baseFeeLamports = feeResponse.value ?? 0;
+
+        const { computeUnitPriceMicroLamports, computeUnitLimit } =
+            this.extractComputeBudgetDetails(transaction);
+
+        if (computeUnitPriceMicroLamports === 0n) {
+            return baseFeeLamports;
+        }
+
+        let unitsConsumed: number | undefined;
+        try {
+            const simulation = transaction instanceof Transaction
+                ? await connection.simulateTransaction(transaction)
+                : await connection.simulateTransaction(transaction, {
+                    sigVerify: false,
+                    replaceRecentBlockhash: true,
+                });
+            unitsConsumed = simulation.value.unitsConsumed ?? undefined;
+        } catch {
+            // Non-fatal: fall back to declared CU limit or a conservative default.
+        }
+
+        const effectiveComputeUnits = BigInt(
+            unitsConsumed ?? computeUnitLimit ?? 200_000
+        );
+
+        const priorityFeeLamports = this.ceilDiv(
+            effectiveComputeUnits * computeUnitPriceMicroLamports,
+            1_000_000n
+        );
+
+        const totalFeeLamports = BigInt(baseFeeLamports) + priorityFeeLamports;
+        if (totalFeeLamports > BigInt(Number.MAX_SAFE_INTEGER)) {
+            throw new Error("Estimated fee exceeds JavaScript safe integer range");
+        }
+
+        return Number(totalFeeLamports);
+    }
+
+    private extractComputeBudgetDetails(
+        transaction: VersionedTransaction | Transaction
+    ): { computeUnitPriceMicroLamports: bigint; computeUnitLimit?: number } {
+        let computeUnitPriceMicroLamports = 0n;
+        let computeUnitLimit: number | undefined;
+
+        if (transaction instanceof Transaction) {
+            for (const instruction of transaction.instructions) {
+                if (!instruction.programId.equals(ComputeBudgetProgram.programId)) {
+                    continue;
+                }
+
+                const data = instruction.data;
+                if (!data || data.length === 0) {
+                    continue;
+                }
+
+                const discriminator = data[0];
+                if (discriminator === 2 && data.length >= 5) {
+                    computeUnitLimit = this.readU32LE(data, 1);
+                } else if (discriminator === 3 && data.length >= 9) {
+                    computeUnitPriceMicroLamports = this.readU64LE(data, 1);
+                }
+            }
+            return { computeUnitPriceMicroLamports, computeUnitLimit };
+        }
+
+        const message = transaction.message as {
+            compiledInstructions?: Array<{ programIdIndex: number; data: Uint8Array }>;
+            staticAccountKeys?: PublicKey[];
+        };
+
+        const compiledInstructions = message.compiledInstructions ?? [];
+        const staticAccountKeys = message.staticAccountKeys ?? [];
+
+        for (const instruction of compiledInstructions) {
+            const programId = staticAccountKeys[instruction.programIdIndex];
+            if (!programId || !programId.equals(ComputeBudgetProgram.programId)) {
+                continue;
+            }
+
+            const data = instruction.data;
+            if (!data || data.length === 0) {
+                continue;
+            }
+
+            const discriminator = data[0];
+            if (discriminator === 2 && data.length >= 5) {
+                computeUnitLimit = this.readU32LE(data, 1);
+            } else if (discriminator === 3 && data.length >= 9) {
+                computeUnitPriceMicroLamports = this.readU64LE(data, 1);
+            }
+        }
+
+        return { computeUnitPriceMicroLamports, computeUnitLimit };
+    }
+
+    private readU32LE(data: Uint8Array, offset: number): number {
+        return (
+            data[offset] |
+            (data[offset + 1] << 8) |
+            (data[offset + 2] << 16) |
+            (data[offset + 3] << 24)
+        ) >>> 0;
+    }
+
+    private readU64LE(data: Uint8Array, offset: number): bigint {
+        let value = 0n;
+        for (let i = 0; i < 8; i++) {
+            value |= BigInt(data[offset + i]) << BigInt(8 * i);
+        }
+        return value;
+    }
+
+    private ceilDiv(a: bigint, b: bigint): bigint {
+        return (a + b - 1n) / b;
+    }
+
     /**
      * Get token metadata for an SPL mint.
      *