@deserialize/multi-vm-wallet 1.0.0

package/utils/evm/evm.ts

@@ -0,0 +1,84 @@
+/**
+ * 
+ * @param phrase this is the pass phrase for this vm
+ * this is a class that will be responsible for creating several evm wallets
+ */
+
+import { EVMDeriveChildPrivateKey, getSeedNode } from "../bip32";
+import { ChainWallet } from "../IChainWallet";
+import { Balance, ChainWalletConfig, NFTInfo, TokenInfo, TransactionResult } from "../types";
+import { VM } from "../vm";
+import { ethers, JsonRpcProvider, Wallet } from "ethers";
+import { getNativeBalance, getTokenBalance, sendERC20Token, sendNativeToken } from "./utils";
+
+export const createEvmVmPrivateKey = (phrase: string) => { }
+
+
+
+export class EVMVM extends VM<string, string, JsonRpcProvider> {
+    derivationPath = "m/44'/60'/0'/0/"; // Default EVM derivation path
+
+    constructor(mnemonic: string) {
+        super(mnemonic, "EVM");
+    }
+    generatePrivateKey(index: number, seedPhrase = this.mnemonic, derivationPath = this.derivationPath) {
+        const seed = this.mnemonicToSeed(seedPhrase);
+        const privateKey = EVMDeriveChildPrivateKey(seed, index, derivationPath).privateKey;
+        return { privateKey, index };
+    }
+
+    validateAddress(address: string): boolean {
+        return ethers.isAddress(address);
+    }
+
+    static async getNativeBalance(address: string, connection: JsonRpcProvider): Promise<Balance> {
+        // Implement native balance retrieval logic here
+        return await getNativeBalance(address, connection)
+    }
+
+    static async getTokenBalance(address: string, tokenAddress: string, connection: JsonRpcProvider): Promise<Balance> {
+        // Implement token balance retrieval logic here
+        return await getTokenBalance(tokenAddress, address, connection)
+    }
+}
+
+export class EVMChainWallet extends ChainWallet<string, string, JsonRpcProvider> {
+
+    constructor(config: ChainWalletConfig, privateKey: string, index: number) {
+        super(config, privateKey, index);
+        const wallet = new Wallet(privateKey);
+        this.address = wallet.address;
+        this.privateKey = privateKey;
+        this.connection = new JsonRpcProvider(config.rpcUrl)
+    }
+    getWallet(): Wallet {
+        return new Wallet(this.privateKey);
+    }
+    generateAddress(): string {
+        return this.address;
+    }
+
+    async getNativeBalance(): Promise<Balance> {
+        // Implement native balance retrieval logic here
+        return await EVMVM.getNativeBalance(this.address, this.connection!)
+    }
+
+    async getTokenBalance(tokenAddress: string): Promise<Balance> {
+        // Implement token balance retrieval logic here
+        return await EVMVM.getTokenBalance(this.address, tokenAddress, this.connection!)
+    }
+
+    async transferNative(to: string, amount: number): Promise<TransactionResult> {
+        // Implement native transfer logic here
+        const wallet = this.getWallet()
+        return await sendNativeToken(wallet, to, amount.toString(), undefined, this.config.confirmationNo || 5)
+    }
+
+    async transferToken(tokenAddress: TokenInfo, to: string, amount: number): Promise<TransactionResult> {
+        // Implement token transfer logic here
+        const wallet = this.getWallet()
+        return await sendERC20Token(wallet, tokenAddress.address, to, amount.toString(), undefined, this.config.confirmationNo || 5)
+    }
+
+}
+

package/utils/evm/index.ts

@@ -0,0 +1,2 @@
+export * from "./evm"
+export * from "./utils"

package/utils/evm/utils.ts

@@ -0,0 +1,504 @@
+
+import { Balance } from '../types'
+import { JsonRpcProvider, Contract, Wallet, TransactionRequest, TransactionResponse, TransactionReceipt } from 'ethers'
+import BN from 'bn.js'
+
+
+interface TransactionParams {
+    to: string
+    value?: string | bigint  // For native token transfers
+    data?: string           // For contract calls
+    gasLimit?: string | bigint
+    gasPrice?: string | bigint
+    maxFeePerGas?: string | bigint     // For EIP-1559
+    maxPriorityFeePerGas?: string | bigint // For EIP-1559
+    nonce?: number
+}
+
+interface TransactionResult {
+    hash: string
+    receipt: TransactionReceipt | null
+    success: boolean
+    gasUsed?: bigint
+    effectiveGasPrice?: bigint
+    blockNumber?: number
+    confirmations: number
+}
+
+// ERC-20 ABI
+const ERC20_ABI = [
+    "function balanceOf(address owner) view returns (uint256)",
+    "function decimals() view returns (uint8)",
+    "function symbol() view returns (string)",
+    "function name() view returns (string)",
+    "function transfer(address to, uint256 amount) returns (bool)",
+    "function transferFrom(address from, address to, uint256 amount) returns (bool)",
+    "function approve(address spender, uint256 amount) returns (bool)",
+    "function allowance(address owner, address spender) view returns (uint256)"
+]
+
+export const getNativeBalance = async (address: string, provider: JsonRpcProvider): Promise<Balance> => {
+    const balance = await provider.getBalance(address)
+
+    return {
+        balance: new BN(balance),
+        formatted: Number(balance / 10n ** 18n),
+        decimal: 18
+    }
+}
+
+export const getTokenBalance = async (
+    tokenAddress: string,
+    walletAddress: string,
+    provider: JsonRpcProvider
+): Promise<Balance> => {
+    try {
+        // Create contract instance
+        const tokenContract = new Contract(tokenAddress, ERC20_ABI, provider)
+
+        // Get balance (returns BigNumber)
+        const balance: bigint = await tokenContract.balanceOf(walletAddress)
+
+        // Get decimals to format the balance properly
+        const decimals = await tokenContract.decimals()
+        // Format balance by dividing by 10^decimals
+        const formattedBalance = balance / (10n ** BigInt(decimals))
+
+        return {
+            balance: new BN(balance.toString()), // Raw balance as BigNumber
+            formatted: Number(formattedBalance.toString()),
+            decimal: decimals
+        }
+    } catch (error) {
+        console.error('Error fetching token balance:', error)
+        throw error
+    }
+}
+
+/**
+ * Sign, send, and confirm any EVM transaction
+ */
+export const signSendAndConfirm = async (
+    wallet: Wallet, // Connected wallet (private key + provider)
+    transactionParams: TransactionParams,
+    confirmations: number = 1, // Number of confirmations to wait for
+    timeout: number = 300000 // 5 minutes timeout
+): Promise<TransactionResult> => {
+    try {
+        // Prepare transaction object
+        const tx: TransactionRequest = {
+            to: transactionParams.to,
+            value: transactionParams.value || 0,
+            data: transactionParams.data || '0x',
+        }
+
+        // Set gas parameters
+        if (transactionParams.gasLimit) {
+            tx.gasLimit = transactionParams.gasLimit
+        }
+
+        // Handle gas pricing (EIP-1559 vs legacy)
+        if (transactionParams.maxFeePerGas && transactionParams.maxPriorityFeePerGas) {
+            // EIP-1559 transaction
+            tx.maxFeePerGas = transactionParams.maxFeePerGas
+            tx.maxPriorityFeePerGas = transactionParams.maxPriorityFeePerGas
+        } else if (transactionParams.gasPrice) {
+            // Legacy transaction
+            tx.gasPrice = transactionParams.gasPrice
+        }
+
+        // Set nonce if provided
+        if (transactionParams.nonce !== undefined) {
+            tx.nonce = transactionParams.nonce
+        }
+
+        // Estimate gas if not provided
+        if (!tx.gasLimit) {
+            tx.gasLimit = await wallet.estimateGas(tx)
+        }
+
+        console.log('Sending transaction:', tx)
+
+        // Sign and send transaction
+        const txResponse: TransactionResponse = await wallet.sendTransaction(tx)
+
+        console.log(`Transaction sent with hash: ${txResponse.hash}`)
+
+        // Wait for confirmation with timeout
+        const receipt = await Promise.race([
+            txResponse.wait(confirmations),
+            new Promise<null>((_, reject) =>
+                setTimeout(() => reject(new Error('Transaction confirmation timeout')), timeout)
+            )
+        ])
+
+        const result: TransactionResult = {
+            hash: txResponse.hash,
+            receipt: receipt,
+            success: receipt?.status === 1,
+            gasUsed: receipt?.gasUsed,
+            effectiveGasPrice: receipt?.gasPrice,
+            blockNumber: receipt?.blockNumber,
+            confirmations: confirmations
+        }
+
+        console.log(`Transaction ${result.success ? 'successful' : 'failed'}:`, result)
+
+        return result
+
+    } catch (error) {
+        console.error('Transaction failed:', error)
+        throw error
+    }
+}
+
+/**
+ * Send native token (ETH, BNB, MATIC, etc.)
+ */
+export const sendNativeToken = async (
+    wallet: Wallet,
+    to: string,
+    amount: string | bigint, // Amount in wei
+    gasLimit?: string | bigint,
+    confirmations: number = 1
+): Promise<TransactionResult> => {
+    return await signSendAndConfirm(
+        wallet,
+        {
+            to,
+            value: (Number(amount) * 10 ** 18).toString(),
+            gasLimit
+        },
+        confirmations
+    )
+}
+
+/**
+ * Send ERC-20 token
+ */
+export const sendERC20Token = async (
+    wallet: Wallet,
+    tokenAddress: string,
+    to: string,
+    amount: string | bigint, // Amount in token's smallest unit
+    gasLimit?: string | bigint,
+    confirmations: number = 1
+): Promise<TransactionResult> => {
+    try {
+        // Create contract instance
+        const tokenContract = new Contract(tokenAddress, ERC20_ABI, wallet)
+
+        // Encode transfer function call
+        const data = tokenContract.interface.encodeFunctionData('transfer', [to, amount])
+
+        return await signSendAndConfirm(
+            wallet,
+            {
+                to: tokenAddress,
+                data,
+                gasLimit
+            },
+            confirmations
+        )
+    } catch (error) {
+        console.error('ERC-20 transfer failed:', error)
+        throw error
+    }
+}
+
+/**
+ * Execute any contract method
+ */
+export const executeContractMethod = async (
+    wallet: Wallet,
+    contractAddress: string,
+    abi: any[],
+    methodName: string,
+    methodParams: any[] = [],
+    value?: string | bigint, // For payable methods
+    gasLimit?: string | bigint,
+    confirmations: number = 1
+): Promise<TransactionResult> => {
+    try {
+        // Create contract instance
+        const contract = new Contract(contractAddress, abi, wallet)
+
+        // Encode method call
+        const data = contract.interface.encodeFunctionData(methodName, methodParams)
+
+        return await signSendAndConfirm(
+            wallet,
+            {
+                to: contractAddress,
+                data,
+                value,
+                gasLimit
+            },
+            confirmations
+        )
+    } catch (error) {
+        console.error('Contract method execution failed:', error)
+        throw error
+    }
+}
+
+/**
+ * Get current gas prices (both legacy and EIP-1559)
+ */
+export const getGasPrices = async (provider: JsonRpcProvider) => {
+    try {
+        const feeData = await provider.getFeeData()
+
+        return {
+            // Legacy
+            gasPrice: feeData.gasPrice,
+            // EIP-1559
+            maxFeePerGas: feeData.maxFeePerGas,
+            maxPriorityFeePerGas: feeData.maxPriorityFeePerGas
+        }
+    } catch (error) {
+        console.error('Error fetching gas prices:', error)
+        throw error
+    }
+}
+
+/**
+ * Estimate gas for a transaction
+ */
+export const estimateGas = async (
+    provider: JsonRpcProvider,
+    transactionParams: TransactionParams
+): Promise<bigint> => {
+    try {
+        const tx: TransactionRequest = {
+            to: transactionParams.to,
+            value: transactionParams.value || 0,
+            data: transactionParams.data || '0x'
+        }
+
+        return await provider.estimateGas(tx)
+    } catch (error) {
+        console.error('Gas estimation failed:', error)
+        throw error
+    }
+}
+
+
+/**
+ * Check ERC-20 token allowance
+ */
+export const checkAllowance = async (
+    tokenAddress: string,
+    owner: string,
+    spender: string,
+    provider: JsonRpcProvider
+): Promise<{
+    allowance: bigint,
+    formatted: string,
+    decimals: number
+}> => {
+    try {
+        const tokenContract = new Contract(tokenAddress, ERC20_ABI, provider)
+
+        // Get allowance and decimals
+        const [allowance, decimals] = await Promise.all([
+            tokenContract.allowance(owner, spender),
+            tokenContract.decimals()
+        ])
+
+        // Format allowance for display
+        const formattedAllowance = allowance / (10n ** BigInt(decimals))
+
+        return {
+            allowance,
+            formatted: formattedAllowance.toString(),
+            decimals
+        }
+    } catch (error) {
+        console.error('Error checking allowance:', error)
+        throw error
+    }
+}
+
+/**
+ * Check if allowance is sufficient for a transaction
+ */
+export const isAllowanceSufficient = async (
+    tokenAddress: string,
+    owner: string,
+    spender: string,
+    requiredAmount: string | bigint,
+    provider: JsonRpcProvider
+): Promise<boolean> => {
+    try {
+        const { allowance } = await checkAllowance(tokenAddress, owner, spender, provider)
+        const required = typeof requiredAmount === 'string' ? BigInt(requiredAmount) : requiredAmount
+
+        return allowance >= required
+    } catch (error) {
+        console.error('Error checking allowance sufficiency:', error)
+        throw error
+    }
+}
+
+/**
+ * Approve ERC-20 token spending
+ */
+export const approveToken = async (
+    wallet: Wallet,
+    tokenAddress: string,
+    spender: string,
+    amount: string | bigint, // Amount to approve, use MaxUint256 for unlimited
+    gasLimit?: string | bigint,
+    confirmations: number = 1
+): Promise<TransactionResult> => {
+    try {
+        const tokenContract = new Contract(tokenAddress, ERC20_ABI, wallet)
+
+        // Encode approve function call
+        const data = tokenContract.interface.encodeFunctionData('approve', [spender, amount])
+
+        return await signSendAndConfirm(
+            wallet,
+            {
+                to: tokenAddress,
+                data,
+                gasLimit
+            },
+            confirmations
+        )
+    } catch (error) {
+        console.error('Token approval failed:', error)
+        throw error
+    }
+}
+
+/**
+ * Approve unlimited token spending (MaxUint256)
+ */
+export const approveTokenUnlimited = async (
+    wallet: Wallet,
+    tokenAddress: string,
+    spender: string,
+    gasLimit?: string | bigint,
+    confirmations: number = 1
+): Promise<TransactionResult> => {
+    // MaxUint256 = 2^256 - 1
+    const MAX_UINT256 = "115792089237316195423570985008687907853269984665640564039457584007913129639935"
+
+    return await approveToken(wallet, tokenAddress, spender, MAX_UINT256, gasLimit, confirmations)
+}
+
+/**
+ * Check allowance and approve if necessary
+ */
+export const checkAndApprove = async (
+    wallet: Wallet,
+    tokenAddress: string,
+    spender: string,
+    requiredAmount: string | bigint,
+    approvalAmount?: string | bigint, // If not provided, will approve exactly the required amount
+    gasLimit?: string | bigint,
+    confirmations: number = 1
+): Promise<{
+    approvalNeeded: boolean,
+    currentAllowance: bigint,
+    approvalResult?: TransactionResult
+}> => {
+    try {
+        const owner = await wallet.getAddress()
+        const provider = wallet.provider as JsonRpcProvider
+
+        // Check current allowance
+        const { allowance } = await checkAllowance(tokenAddress, owner, spender, provider)
+        const required = typeof requiredAmount === 'string' ? BigInt(requiredAmount) : requiredAmount
+
+        const approvalNeeded = allowance < required
+
+        if (!approvalNeeded) {
+            return {
+                approvalNeeded: false,
+                currentAllowance: allowance
+            }
+        }
+
+        console.log(`Approval needed. Current: ${allowance}, Required: ${required}`)
+
+        // Determine approval amount
+        const amountToApprove = approvalAmount || required
+
+        // Execute approval
+        const approvalResult = await approveToken(
+            wallet,
+            tokenAddress,
+            spender,
+            amountToApprove,
+            gasLimit,
+            confirmations
+        )
+
+        return {
+            approvalNeeded: true,
+            currentAllowance: allowance,
+            approvalResult
+        }
+    } catch (error) {
+        console.error('Check and approve failed:', error)
+        throw error
+    }
+}
+
+/**
+ * Reset token allowance to zero (security best practice before setting new allowance)
+ */
+export const resetAllowance = async (
+    wallet: Wallet,
+    tokenAddress: string,
+    spender: string,
+    gasLimit?: string | bigint,
+    confirmations: number = 1
+): Promise<TransactionResult> => {
+    return await approveToken(wallet, tokenAddress, spender, "0", gasLimit, confirmations)
+}
+
+/**
+ * Safe approve: Reset to zero first, then approve the desired amount
+ * (Some tokens like USDT require this)
+ */
+export const safeApprove = async (
+    wallet: Wallet,
+    tokenAddress: string,
+    spender: string,
+    amount: string | bigint,
+    gasLimit?: string | bigint,
+    confirmations: number = 1
+): Promise<{
+    resetResult: TransactionResult,
+    approveResult: TransactionResult
+}> => {
+    try {
+        console.log('Performing safe approve: reset then approve')
+
+        // First reset to zero
+        const resetResult = await resetAllowance(wallet, tokenAddress, spender, gasLimit, confirmations)
+
+        if (!resetResult.success) {
+            throw new Error('Failed to reset allowance to zero')
+        }
+
+        // Then approve the desired amount
+        const approveResult = await approveToken(wallet, tokenAddress, spender, amount, gasLimit, confirmations)
+
+        return {
+            resetResult,
+            approveResult
+        }
+    } catch (error) {
+        console.error('Safe approve failed:', error)
+        throw error
+    }
+}
+
+
+//swaps
+

package/utils/index.ts

@@ -0,0 +1,6 @@
+export * from "./bip32"
+export * from "./evm/evm"
+export * from "./types"
+export * from "./vm"
+export * from "./evm"
+export * from "./svm"

package/utils/svm/index.js

@@ -0,0 +1,17 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./svm"), exports);

package/utils/svm/index.ts

@@ -0,0 +1 @@
+export * from "./svm"

package/utils/svm/svm.js

@@ -0,0 +1,71 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SVMChainWallet = exports.SVMVM = void 0;
+const web3_js_1 = require("@solana/web3.js");
+const bip32_1 = require("../bip32");
+const vm_1 = require("../vm");
+const IChainWallet_1 = require("../IChainWallet");
+const utils_1 = require("./utils");
+const bn_js_1 = __importDefault(require("bn.js"));
+class SVMVM extends vm_1.VM {
+    constructor(mnemonic) {
+        super(mnemonic, "SVM");
+        this.derivationPath = "m/44'/501'/"; // Default EVM derivation path
+    }
+    static validateAddress(address) {
+        return web3_js_1.PublicKey.isOnCurve(address.toBuffer());
+    }
+    static getNativeBalance(address, connection) {
+        return (0, utils_1.getSvmNativeBalance)(address, connection);
+    }
+    static async getTokenBalance(address, tokenAddress, connection) {
+        const balance = await (0, utils_1.getTokenBalance)(address, tokenAddress, connection);
+        if (balance === 0) {
+            return { balance: new bn_js_1.default(0), formatted: 0, decimal: 0 };
+        }
+        return { balance: new bn_js_1.default(balance.amount), formatted: balance.uiAmount || parseInt(balance.amount) / 10 ** balance.decimals, decimal: balance.decimals };
+    }
+    generatePrivateKey(index, seedPhrase = this.mnemonic, derivationPath = this.derivationPath) {
+        const seed = this.mnemonicToSeed(seedPhrase);
+        const privateKey = (0, bip32_1.SVMDeriveChildPrivateKey)(seed, index, derivationPath);
+        return { privateKey, index };
+    }
+}
+exports.SVMVM = SVMVM;
+SVMVM.signAndSendTransaction = utils_1.signAndSendTransaction;
+class SVMChainWallet extends IChainWallet_1.ChainWallet {
+    constructor(config, privateKey, index) {
+        super(config, privateKey, index);
+        this.address = privateKey.publicKey;
+        this.privateKey = privateKey;
+        this.connection = new web3_js_1.Connection(config.rpcUrl);
+    }
+    generateAddress() {
+        return this.address;
+    }
+    async getNativeBalance() {
+        // Implement native balance retrieval logic here
+        return await SVMVM.getNativeBalance(this.address, this.connection);
+    }
+    async getTokenBalance(tokenAddress) {
+        // Implement token balance retrieval logic here
+        return await SVMVM.getTokenBalance(this.address, (tokenAddress), this.connection);
+    }
+    async transferNative(to, amount) {
+        // Implement native transfer logic here
+        const transaction = await (0, utils_1.getTransferNativeTransaction)(this.privateKey, to, amount, this.connection);
+        const hash = await SVMVM.signAndSendTransaction(transaction, this.connection, [this.privateKey]);
+        return { success: true, hash }; // Placeholder
+    }
+    async transferToken(token, to, amount) {
+        // Implement token transfer logic here
+        const transaction = await (0, utils_1.getTransferTokenTransaction)(this.privateKey, new web3_js_1.PublicKey(to), token, (amount), this.connection);
+        const hash = await SVMVM.signAndSendTransaction(transaction, this.connection, [this.privateKey]);
+        return { success: true, hash }; // Placeholder
+    }
+}
+exports.SVMChainWallet = SVMChainWallet;
+//swaps jupiter swap here