@mcp-dockmaster/mcp-cryptowallet-evm 1.0.0

package/build/handlers/wallet.js

@@ -0,0 +1,781 @@
+import { ethers } from "ethers";
+import { createSuccessResponse, createErrorResponse, getProvider, getWallet } from "./utils.js";
+import { generateMnemonic, } from '@scure/bip39';
+// Wallet Creation and Management
+export const createWalletHandler = async (input) => {
+    try {
+        const options = {};
+        if (input.path) {
+            options.path = input.path;
+        }
+        if (input.locale) {
+            options.locale = input.locale;
+        }
+        const wallet = ethers.Wallet.createRandom(options);
+        let result = {
+            address: wallet.address,
+            mnemonic: wallet.mnemonic?.phrase,
+            privateKey: wallet.privateKey,
+            publicKey: wallet.publicKey
+        };
+        if (input.password) {
+            // If a password is provided, encrypt the wallet
+            const encryptedWallet = await wallet.encrypt(input.password);
+            result.encryptedWallet = encryptedWallet;
+        }
+        return createSuccessResponse(result, `Wallet created successfully:
+      Address: ${wallet.address}
+      Private Key: ${wallet.privateKey}
+      Public Key: ${wallet.publicKey}
+      Mnemonic: ${wallet.mnemonic?.phrase}
+      Encrypted Wallet: ${result.encryptedWallet ? "Yes" : "No"}
+    `);
+    }
+    catch (error) {
+        return createErrorResponse(`Failed to create wallet: ${error.message}`);
+    }
+};
+export const fromPrivateKeyHandler = async (input) => {
+    try {
+        if (!input.privateKey) {
+            return createErrorResponse("Private key is required");
+        }
+        const provider = input.provider ? getProvider(input.provider) : undefined;
+        const wallet = new ethers.Wallet(input.privateKey, provider);
+        return createSuccessResponse({
+            address: wallet.address,
+            privateKey: wallet.privateKey,
+            publicKey: wallet.publicKey
+        }, `Wallet created from private key successfully:
+      Address: ${wallet.address}
+      Private Key: ${wallet.privateKey}
+      Public Key: ${wallet.publicKey}
+    `);
+    }
+    catch (error) {
+        return createErrorResponse(`Failed to create wallet from private key: ${error.message}`);
+    }
+};
+export const createMnemonicPhraseHandler = async (input) => {
+    try {
+        const { wordlist } = await import(`@scure/bip39/wordlists/${input.locale || 'english'}`);
+        if (!wordlist) {
+            return createErrorResponse("Invalid locale");
+        }
+        // Convert length to entropy bits (12 words = 128 bits, 15 words = 160 bits, etc)
+        const entropyBits = ((input.length ?? 12) / 3) * 32;
+        const mnemonic = generateMnemonic(wordlist, entropyBits);
+        return createSuccessResponse({
+            mnemonic: mnemonic
+        }, `Mnemonic phrase created successfully:
+      Mnemonic: "${mnemonic}"
+    `);
+    }
+    catch (error) {
+        return createErrorResponse(`Failed to create mnemonic phrase: ${error.message}`);
+    }
+};
+export const fromMnemonicHandler = async (input) => {
+    try {
+        if (!input.mnemonic) {
+            return createErrorResponse("Mnemonic is required");
+        }
+        const options = {
+            path: input.path,
+            wordlist: (input.locale && ethers.wordlists[input.locale]) || ethers.wordlists.en
+        };
+        const provider = input.provider ? getProvider(input.provider) : undefined;
+        const wallet = ethers.Wallet.fromMnemonic(input.mnemonic, options.path, options.wordlist);
+        if (provider)
+            wallet.connect(provider);
+        return createSuccessResponse({
+            address: wallet.address,
+            mnemonic: wallet.mnemonic?.phrase,
+            privateKey: wallet.privateKey,
+            publicKey: wallet.publicKey
+        }, `Wallet created from mnemonic successfully:
+      Address: ${wallet.address}
+      Private Key: ${wallet.privateKey}
+      Public Key: ${wallet.publicKey}
+    `);
+    }
+    catch (error) {
+        return createErrorResponse(`Failed to create wallet from mnemonic: ${error.message}`);
+    }
+};
+export const fromEncryptedJsonHandler = async (input) => {
+    try {
+        if (!input.json) {
+            return createErrorResponse("Encrypted JSON is required");
+        }
+        if (!input.password) {
+            return createErrorResponse("Password is required");
+        }
+        const wallet = await ethers.Wallet.fromEncryptedJson(input.json, input.password);
+        const provider = input.provider ? getProvider(input.provider) : undefined;
+        if (provider) {
+            wallet.connect(provider);
+        }
+        return createSuccessResponse({
+            address: wallet.address,
+            privateKey: wallet.privateKey,
+            publicKey: wallet.publicKey
+        }, "Wallet created from encrypted JSON successfully");
+    }
+    catch (error) {
+        return createErrorResponse(`Failed to create wallet from encrypted JSON: ${error.message}`);
+    }
+};
+export const encryptWalletHandler = async (input) => {
+    try {
+        if (!input.wallet) {
+            return createErrorResponse("Wallet is required");
+        }
+        if (!input.password) {
+            return createErrorResponse("Password is required");
+        }
+        const wallet = await getWallet(input.wallet);
+        const encryptedWallet = await wallet.encrypt(input.password, input.options);
+        return createSuccessResponse({
+            encryptedWallet
+        }, "Wallet encrypted successfully");
+    }
+    catch (error) {
+        return createErrorResponse(`Failed to encrypt wallet: ${error.message}`);
+    }
+};
+// Wallet Properties
+export const getAddressHandler = async (input) => {
+    try {
+        if (!input.wallet) {
+            return createErrorResponse("Wallet is required");
+        }
+        const wallet = await getWallet(input.wallet);
+        return createSuccessResponse({
+            address: wallet.address
+        }, "Wallet address retrieved successfully");
+    }
+    catch (error) {
+        return createErrorResponse(`Failed to get wallet address: ${error.message}`);
+    }
+};
+export const getPublicKeyHandler = async (input) => {
+    try {
+        if (!input.wallet) {
+            return createErrorResponse("Wallet is required");
+        }
+        const wallet = await getWallet(input.wallet);
+        return createSuccessResponse({
+            publicKey: wallet.publicKey
+        }, "Wallet public key retrieved successfully");
+    }
+    catch (error) {
+        return createErrorResponse(`Failed to get wallet public key: ${error.message}`);
+    }
+};
+export const getPrivateKeyHandler = async (input) => {
+    try {
+        if (!input.wallet) {
+            return createErrorResponse("Wallet is required");
+        }
+        const wallet = await getWallet(input.wallet, input.password);
+        return createSuccessResponse({
+            privateKey: wallet.privateKey
+        }, "WARNING: Never share your private key with anyone. Wallet private key retrieved successfully");
+    }
+    catch (error) {
+        return createErrorResponse(`Failed to get wallet private key: ${error.message}`);
+    }
+};
+// Blockchain Methods
+export const getBalanceHandler = async (input) => {
+    try {
+        if (!input.wallet) {
+            return createErrorResponse("Wallet is required");
+        }
+        if (!input.provider) {
+            return createErrorResponse("Provider URL is required to get balance");
+        }
+        const wallet = await getWallet(input.wallet, input.password, input.provider);
+        const balance = await wallet.getBalance(input.blockTag ?? "latest");
+        return createSuccessResponse({
+            balance: balance.toString(),
+            balanceInEth: ethers.utils.formatEther(balance)
+        }, `Wallet balance retrieved successfully
+      Balance: ${balance.toString()}
+      Balance in ETH: ${ethers.utils.formatEther(balance)}
+    `);
+    }
+    catch (error) {
+        return createErrorResponse(`Failed to get wallet balance: ${error.message}`);
+    }
+};
+export const getChainIdHandler = async (input) => {
+    try {
+        if (!input.wallet) {
+            return createErrorResponse("Wallet is required");
+        }
+        const wallet = await getWallet(input.wallet, input.password, input.provider);
+        if (!wallet.provider) {
+            return createErrorResponse("Provider is required to get chain ID");
+        }
+        const chainId = await wallet.getChainId();
+        return createSuccessResponse({
+            chainId
+        }, `Chain ID retrieved successfully
+      Chain ID: ${chainId.toString()}
+    `);
+    }
+    catch (error) {
+        return createErrorResponse(`Failed to get chain ID: ${error.message}`);
+    }
+};
+export const getGasPriceHandler = async (input) => {
+    try {
+        if (!input.wallet) {
+            return createErrorResponse("Wallet is required");
+        }
+        const wallet = await getWallet(input.wallet, input.password, input.provider);
+        if (!wallet.provider) {
+            return createErrorResponse("Provider is required to get gas price");
+        }
+        const gasPrice = await wallet.getGasPrice();
+        return createSuccessResponse({
+            gasPrice: gasPrice.toString(),
+            gasPriceInGwei: ethers.utils.formatUnits(gasPrice, "gwei")
+        }, `Gas price retrieved successfully
+      Gas price: ${gasPrice.toString()}
+      Gas price in Gwei: ${ethers.utils.formatUnits(gasPrice, "gwei")}
+    `);
+    }
+    catch (error) {
+        return createErrorResponse(`Failed to get gas price: ${error.message}`);
+    }
+};
+export const getTransactionCountHandler = async (input) => {
+    try {
+        if (!input.wallet) {
+            return createErrorResponse("Wallet is required");
+        }
+        const wallet = await getWallet(input.wallet, input.password, input.provider);
+        if (!wallet.provider) {
+            return createErrorResponse("Provider is required to get transaction count");
+        }
+        const transactionCount = await wallet.getTransactionCount(input.blockTag);
+        return createSuccessResponse({
+            transactionCount
+        }, `Transaction count retrieved successfully
+      Transaction count: ${transactionCount.toString()}
+    `);
+    }
+    catch (error) {
+        return createErrorResponse(`Failed to get transaction count: ${error.message}`);
+    }
+};
+export const callHandler = async (input) => {
+    try {
+        if (!input.wallet) {
+            return createErrorResponse("Wallet is required");
+        }
+        if (!input.transaction) {
+            return createErrorResponse("Transaction is required");
+        }
+        const wallet = await getWallet(input.wallet, input.password, input.provider);
+        if (!wallet.provider) {
+            return createErrorResponse("Provider is required to call a contract");
+        }
+        const result = await wallet.call(input.transaction, input.blockTag);
+        return createSuccessResponse({
+            result
+        }, `Contract call executed successfully
+      Result: ${result}
+    `);
+    }
+    catch (error) {
+        return createErrorResponse(`Failed to call contract: ${error.message}`);
+    }
+};
+// Transaction Methods
+export const sendTransactionHandler = async (input) => {
+    try {
+        if (!input.wallet) {
+            return createErrorResponse("Wallet is required");
+        }
+        if (!input.transaction) {
+            return createErrorResponse("Transaction is required");
+        }
+        const wallet = await getWallet(input.wallet, input.password, input.provider);
+        if (!wallet.provider) {
+            return createErrorResponse("Provider is required to send a transaction");
+        }
+        const tx = await wallet.sendTransaction(input.transaction);
+        return createSuccessResponse({
+            hash: tx.hash,
+            nonce: tx.nonce,
+            gasLimit: tx.gasLimit.toString(),
+            gasPrice: tx.gasPrice?.toString(),
+            data: tx.data,
+            value: tx.value.toString(),
+            chainId: tx.chainId,
+            from: tx.from,
+            to: tx.to,
+            type: tx.type
+        }, `Transaction sent successfully
+      Hash: ${tx.hash}
+      Nonce: ${tx.nonce.toString()}
+      Gas limit: ${tx.gasLimit.toString()}
+      Gas price: ${tx.gasPrice?.toString()}
+      Data: ${tx.data}
+    `);
+    }
+    catch (error) {
+        return createErrorResponse(`Failed to send transaction: ${error.message}`);
+    }
+};
+export const signTransactionHandler = async (input) => {
+    try {
+        if (!input.wallet) {
+            return createErrorResponse("Wallet is required");
+        }
+        if (!input.transaction) {
+            return createErrorResponse("Transaction is required");
+        }
+        const wallet = await getWallet(input.wallet, input.password, input.provider);
+        // For signing a transaction, we need to populate it first
+        const populatedTx = await wallet.populateTransaction(input.transaction);
+        const signedTx = await wallet.signTransaction(populatedTx);
+        return createSuccessResponse({
+            signedTransaction: signedTx
+        }, `Transaction signed successfully
+      Signed transaction: ${signedTx}
+    `);
+    }
+    catch (error) {
+        return createErrorResponse(`Failed to sign transaction: ${error.message}`);
+    }
+};
+export const populateTransactionHandler = async (input) => {
+    try {
+        if (!input.wallet) {
+            return createErrorResponse("Wallet is required");
+        }
+        if (!input.transaction) {
+            return createErrorResponse("Transaction is required");
+        }
+        const wallet = await getWallet(input.wallet, input.password, input.provider);
+        if (!wallet.provider) {
+            return createErrorResponse("Provider is required to populate a transaction");
+        }
+        const populatedTx = await wallet.populateTransaction(input.transaction);
+        return createSuccessResponse({
+            populatedTransaction: {
+                to: populatedTx.to,
+                from: populatedTx.from,
+                nonce: populatedTx.nonce,
+                gasLimit: populatedTx.gasLimit?.toString(),
+                gasPrice: populatedTx.gasPrice?.toString(),
+                data: populatedTx.data,
+                value: populatedTx.value?.toString(),
+                chainId: populatedTx.chainId,
+                type: populatedTx.type,
+                maxFeePerGas: populatedTx.maxFeePerGas?.toString(),
+                maxPriorityFeePerGas: populatedTx.maxPriorityFeePerGas?.toString()
+            }
+        }, `Transaction populated successfully
+      To: ${populatedTx.to}
+      From: ${populatedTx.from}
+      Nonce: ${populatedTx.nonce?.toString() ?? "Not specified"}
+      Gas limit: ${populatedTx.gasLimit?.toString() ?? "Not specified"}
+      Gas price: ${populatedTx.gasPrice?.toString() ?? "Not specified"}
+    `);
+    }
+    catch (error) {
+        return createErrorResponse(`Failed to populate transaction: ${error.message}`);
+    }
+};
+// Signing Methods
+export const signMessageHandler = async (input) => {
+    try {
+        if (!input.wallet) {
+            return createErrorResponse("Wallet is required");
+        }
+        if (!input.message) {
+            return createErrorResponse("Message is required");
+        }
+        const wallet = await getWallet(input.wallet, input.password);
+        const signature = await wallet.signMessage(input.message);
+        return createSuccessResponse({
+            signature,
+            message: input.message
+        }, `Message signed successfully
+      Signature: ${signature}
+      Message: "${input.message}"
+    `);
+    }
+    catch (error) {
+        return createErrorResponse(`Failed to sign message: ${error.message}`);
+    }
+};
+export const signTypedDataHandler = async (input) => {
+    try {
+        if (!input.wallet) {
+            return createErrorResponse("Wallet is required");
+        }
+        if (!input.domain || !input.types || !input.value) {
+            return createErrorResponse("Domain, types, and value are required");
+        }
+        const wallet = await getWallet(input.wallet, input.password);
+        // Use ethers._signTypedData for EIP-712 signing
+        // @ts-ignore - _signTypedData is not in the type definitions but is available
+        const signature = await wallet._signTypedData(input.domain, input.types, input.value);
+        return createSuccessResponse({
+            signature,
+            domain: input.domain,
+            types: input.types,
+            value: input.value
+        }, `Typed data signed successfully
+      Signature: ${signature}
+      Domain: ${input.domain}
+      Types: ${input.types}
+      Value: ${input.value}
+    `);
+    }
+    catch (error) {
+        return createErrorResponse(`Failed to sign typed data: ${error.message}`);
+    }
+};
+export const verifyMessageHandler = async (input) => {
+    try {
+        if (!input.message || !input.signature || !input.address) {
+            return createErrorResponse("Message, signature, and address are required");
+        }
+        const recoveredAddress = ethers.utils.verifyMessage(input.message, input.signature);
+        const isValid = recoveredAddress.toLowerCase() === input.address.toLowerCase();
+        return createSuccessResponse({
+            isValid,
+            recoveredAddress
+        }, isValid ? `Signature verified successfully
+      Message: "${input.message}"
+      Signature: ${input.signature}
+      Address: ${input.address}
+    ` : `Signature verification failed
+      Message: "${input.message}"
+      Signature: ${input.signature}
+      Address: ${input.address}
+    `);
+    }
+    catch (error) {
+        return createErrorResponse(`Failed to verify message: ${error.message}`);
+    }
+};
+export const verifyTypedDataHandler = async (input) => {
+    try {
+        if (!input.domain || !input.types || !input.value || !input.signature || !input.address) {
+            return createErrorResponse("Domain, types, value, signature, and address are required");
+        }
+        // Use ethers.utils.verifyTypedData for EIP-712 verification
+        const recoveredAddress = ethers.utils.verifyTypedData(input.domain, input.types, input.value, input.signature);
+        const isValid = recoveredAddress.toLowerCase() === input.address.toLowerCase();
+        return createSuccessResponse({
+            isValid,
+            recoveredAddress
+        }, isValid ? `Typed data signature is valid
+      Domain: ${input.domain}
+      Types: ${input.types}
+      Value: ${input.value}
+      Signature: ${input.signature}
+      Address: ${input.address}
+    ` : "Typed data signature is invalid");
+    }
+    catch (error) {
+        return createErrorResponse(`Failed to verify typed data: ${error.message}`);
+    }
+};
+// Provider Methods
+export const getBlockHandler = async (input) => {
+    try {
+        if (!input.provider) {
+            return createErrorResponse("Provider is required");
+        }
+        if (!input.blockHashOrBlockTag) {
+            return createErrorResponse("Block hash or block tag is required");
+        }
+        const provider = getProvider(input.provider);
+        // In ethers.js v5, getBlock can take includeTransactions as a second parameter
+        // but TypeScript definitions might not reflect this
+        const block = await provider.getBlock(input.blockHashOrBlockTag, input.includeTransactions);
+        return createSuccessResponse({
+            block
+        }, `Block retrieved successfully
+      Block hash: ${block.hash}
+      Block number: ${block.number?.toString() ?? "Not specified"}
+      Block timestamp: ${block.timestamp?.toString() ?? "Not specified"}
+      Block transactions: ${block.transactions?.length ?? "Not specified"}
+    `);
+    }
+    catch (error) {
+        return createErrorResponse(`Failed to get block: ${error.message}`);
+    }
+};
+export const getTransactionHandler = async (input) => {
+    try {
+        if (!input.provider) {
+            return createErrorResponse("Provider is required");
+        }
+        if (!input.transactionHash) {
+            return createErrorResponse("Transaction hash is required");
+        }
+        const provider = getProvider(input.provider);
+        const transaction = await provider.getTransaction(input.transactionHash);
+        return createSuccessResponse({
+            transaction
+        }, `Transaction retrieved successfully
+      Transaction hash: ${input.transactionHash}
+      Transaction: ${transaction}
+    `);
+    }
+    catch (error) {
+        return createErrorResponse(`Failed to get transaction: ${error.message}`);
+    }
+};
+export const getTransactionReceiptHandler = async (input) => {
+    try {
+        if (!input.provider) {
+            return createErrorResponse("Provider is required");
+        }
+        if (!input.transactionHash) {
+            return createErrorResponse("Transaction hash is required");
+        }
+        const provider = getProvider(input.provider);
+        const receipt = await provider.getTransactionReceipt(input.transactionHash);
+        return createSuccessResponse({
+            receipt
+        }, `Transaction receipt retrieved successfully
+      Transaction hash: ${input.transactionHash}
+      Transaction receipt: ${receipt}
+    `);
+    }
+    catch (error) {
+        return createErrorResponse(`Failed to get transaction receipt: ${error.message}`);
+    }
+};
+export const getCodeHandler = async (input) => {
+    try {
+        if (!input.provider) {
+            return createErrorResponse("Provider is required");
+        }
+        if (!input.address) {
+            return createErrorResponse("Address is required");
+        }
+        const provider = getProvider(input.provider);
+        const code = await provider.getCode(input.address, input.blockTag);
+        return createSuccessResponse({
+            code
+        }, `Code retrieved successfully
+      Address: ${input.address}
+      Code: ${code}
+    `);
+    }
+    catch (error) {
+        return createErrorResponse(`Failed to get code: ${error.message}`);
+    }
+};
+export const getStorageAtHandler = async (input) => {
+    try {
+        if (!input.provider) {
+            return createErrorResponse("Provider is required");
+        }
+        if (!input.address) {
+            return createErrorResponse("Address is required");
+        }
+        if (!input.position) {
+            return createErrorResponse("Position is required");
+        }
+        const provider = getProvider(input.provider);
+        const storage = await provider.getStorageAt(input.address, input.position, input.blockTag);
+        return createSuccessResponse({
+            storage
+        }, `Storage retrieved successfully
+      Address: ${input.address}
+      Position: ${input.position}
+      Storage: ${storage}
+    `);
+    }
+    catch (error) {
+        return createErrorResponse(`Failed to get storage: ${error.message}`);
+    }
+};
+export const estimateGasHandler = async (input) => {
+    try {
+        if (!input.provider) {
+            return createErrorResponse("Provider is required");
+        }
+        if (!input.transaction) {
+            return createErrorResponse("Transaction is required");
+        }
+        const provider = getProvider(input.provider);
+        const gasEstimate = await provider.estimateGas(input.transaction);
+        return createSuccessResponse({
+            gasEstimate: gasEstimate.toString()
+        }, `Gas estimate retrieved successfully
+      Gas estimate: ${gasEstimate.toString()}
+    `);
+    }
+    catch (error) {
+        return createErrorResponse(`Failed to estimate gas: ${error.message}`);
+    }
+};
+export const getLogsHandler = async (input) => {
+    try {
+        if (!input.provider) {
+            return createErrorResponse("Provider is required");
+        }
+        if (!input.filter) {
+            return createErrorResponse("Filter is required");
+        }
+        const provider = getProvider(input.provider);
+        const logs = await provider.getLogs(input.filter);
+        return createSuccessResponse({
+            logs
+        }, `Logs retrieved successfully
+      Logs: ${logs}
+    `);
+    }
+    catch (error) {
+        return createErrorResponse(`Failed to get logs: ${error.message}`);
+    }
+};
+export const getEnsResolverHandler = async (input) => {
+    try {
+        if (!input.provider) {
+            return createErrorResponse("Provider is required");
+        }
+        if (!input.name) {
+            return createErrorResponse("ENS name is required");
+        }
+        const provider = getProvider(input.provider);
+        // In ethers.js v5, getResolver might not be directly on the provider type
+        // but it's available in the implementation
+        const resolver = await provider.getResolver(input.name);
+        return createSuccessResponse({
+            resolver: resolver ? {
+                address: resolver.address,
+                name: resolver.name
+            } : null
+        }, resolver ? `ENS resolver retrieved successfully
+      Address: ${resolver.address}
+      Name: ${resolver.name}
+    ` : "No resolver found for this ENS name");
+    }
+    catch (error) {
+        return createErrorResponse(`Failed to get ENS resolver: ${error.message}`);
+    }
+};
+export const lookupAddressHandler = async (input) => {
+    try {
+        if (!input.provider) {
+            return createErrorResponse("Provider is required");
+        }
+        if (!input.address) {
+            return createErrorResponse("Address is required");
+        }
+        const provider = getProvider(input.provider);
+        const name = await provider.lookupAddress(input.address);
+        return createSuccessResponse({
+            name
+        }, name ? `ENS name retrieved successfully
+      Name: ${name}
+    ` : "No ENS name found for this address");
+    }
+    catch (error) {
+        return createErrorResponse(`Failed to lookup ENS name: ${error.message}`);
+    }
+};
+export const resolveNameHandler = async (input) => {
+    try {
+        if (!input.provider) {
+            return createErrorResponse("Provider is required");
+        }
+        if (!input.name) {
+            return createErrorResponse("ENS name is required");
+        }
+        const provider = getProvider(input.provider);
+        const address = await provider.resolveName(input.name);
+        return createSuccessResponse({
+            address
+        }, address ? `ENS name resolved successfully
+      Name: ${input.name}
+      Address: ${address}
+    ` : "Could not resolve this ENS name");
+    }
+    catch (error) {
+        return createErrorResponse(`Failed to resolve ENS name: ${error.message}`);
+    }
+};
+// Network Methods
+export const getNetworkHandler = async (input) => {
+    try {
+        if (!input.provider) {
+            return createErrorResponse("Provider is required");
+        }
+        const provider = getProvider(input.provider);
+        const network = await provider.getNetwork();
+        return createSuccessResponse({
+            network: {
+                name: network.name,
+                chainId: network.chainId,
+                ensAddress: network.ensAddress
+            }
+        }, `Network information retrieved successfully
+      Network name: ${network.name}
+      Chain ID: ${network.chainId}
+      ENS address: ${network.ensAddress}
+    `);
+    }
+    catch (error) {
+        return createErrorResponse(`Failed to get network information: ${error.message}`);
+    }
+};
+export const getBlockNumberHandler = async (input) => {
+    try {
+        if (!input.provider) {
+            return createErrorResponse("Provider is required");
+        }
+        const provider = getProvider(input.provider);
+        const blockNumber = await provider.getBlockNumber();
+        return createSuccessResponse({
+            blockNumber
+        }, `Block number retrieved successfully
+      Block number: ${blockNumber.toString()}
+    `);
+    }
+    catch (error) {
+        return createErrorResponse(`Failed to get block number: ${error.message}`);
+    }
+};
+export const getFeeDataHandler = async (input) => {
+    try {
+        if (!input.provider) {
+            return createErrorResponse("Provider is required");
+        }
+        const provider = getProvider(input.provider);
+        // getFeeData is available in ethers v5.5.0+
+        // @ts-ignore - getFeeData might not be in the type definitions depending on the version
+        const feeData = await provider.getFeeData();
+        return createSuccessResponse({
+            feeData: {
+                gasPrice: feeData.gasPrice?.toString(),
+                maxFeePerGas: feeData.maxFeePerGas?.toString(),
+                maxPriorityFeePerGas: feeData.maxPriorityFeePerGas?.toString()
+            }
+        }, `Fee data retrieved successfully
+      Gas price: ${feeData.gasPrice?.toString()}
+      Max fee per gas: ${feeData.maxFeePerGas?.toString()}
+      Max priority fee per gas: ${feeData.maxPriorityFeePerGas?.toString()}
+    `);
+    }
+    catch (error) {
+        return createErrorResponse(`Failed to get fee data: ${error.message}`);
+    }
+};
+//# sourceMappingURL=wallet.js.map