@mcp-dockmaster/mcp-cryptowallet-evm 1.0.4 → 1.0.6

package/src/handlers/wallet.ts

@@ -1,11 +1,25 @@
-import { ethers } from "ethers";
+import { ethers, providers } from "ethers";
 import { ToolResultSchema } from "../types.js";
-import { createSuccessResponse, createErrorResponse, getProvider, getWallet } from "./utils.js";
+import { createSuccessResponse, createErrorResponse, getProvider, getWallet, setProvider } from "./utils.js";
 import { fromPrivateKeyHandlerInput, createMnemonicPhraseHandlerInput } from "./wallet.types.js";
 import { generateMnemonic,  } from '@scure/bip39';
-// Wallet Creation and Management
 
-export const createWalletHandler = async (input: any): Promise<ToolResultSchema<any>> => {
+// Provider handlers
+
+export const setProviderHandler = async (input: any): Promise<ToolResultSchema> => {
+  try {
+    setProvider(input.providerURL);
+    return createSuccessResponse(`Provider set successfully:
+      Provider URL: ${input.providerURL}
+    `);
+  } catch (error) {
+    return createErrorResponse(`Failed to set provider: ${(error as Error).message}`);
+  }
+};
+
+
+// Wallet Creation and Management
+export const createWalletHandler = async (input: any): Promise<ToolResultSchema> => {
   try {
     const options: any = {};
 
@@ -32,7 +46,7 @@ export const createWalletHandler = async (input: any): Promise<ToolResultSchema<
       result.encryptedWallet = encryptedWallet;
     }
 
-    return createSuccessResponse(result, `Wallet created successfully:
+    return createSuccessResponse(`Wallet created successfully:
       Address: ${wallet.address}
       Private Key: ${wallet.privateKey}
       Public Key: ${wallet.publicKey}
@@ -44,20 +58,17 @@ export const createWalletHandler = async (input: any): Promise<ToolResultSchema<
   }
 };
 
-export const fromPrivateKeyHandler = async (input: fromPrivateKeyHandlerInput): Promise<ToolResultSchema<any>> => {
+export const fromPrivateKeyHandler = async (input: fromPrivateKeyHandlerInput): Promise<ToolResultSchema> => {
   try {
     if (!input.privateKey) {
       return createErrorResponse("Private key is required");
     }
 
-    const provider = input.provider ? getProvider(input.provider) : undefined;
+    const provider = getProvider()
     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:
+    return createSuccessResponse(
+    `Wallet created from private key successfully:
       Address: ${wallet.address}
       Private Key: ${wallet.privateKey}
       Public Key: ${wallet.publicKey}
@@ -67,7 +78,7 @@ export const fromPrivateKeyHandler = async (input: fromPrivateKeyHandlerInput):
   }
 };
 
-export const createMnemonicPhraseHandler = async (input: createMnemonicPhraseHandlerInput): Promise<ToolResultSchema<any>> => {
+export const createMnemonicPhraseHandler = async (input: createMnemonicPhraseHandlerInput): Promise<ToolResultSchema> => {
   try {
     const { wordlist } = await import(`@scure/bip39/wordlists/${input.locale || 'english'}`);
     if (!wordlist) {
@@ -77,9 +88,8 @@ export const createMnemonicPhraseHandler = async (input: createMnemonicPhraseHan
     const entropyBits = ((input.length ?? 12) / 3) * 32;
     const mnemonic = generateMnemonic(wordlist, entropyBits);
 
-    return createSuccessResponse({
-      mnemonic: mnemonic
-    }, `Mnemonic phrase created successfully:
+    return createSuccessResponse(
+    `Mnemonic phrase created successfully:
       Mnemonic: "${mnemonic}"
     `);
   } catch (error) {
@@ -87,7 +97,7 @@ export const createMnemonicPhraseHandler = async (input: createMnemonicPhraseHan
   }
 };
 
-export const fromMnemonicHandler = async (input: any): Promise<ToolResultSchema<any>> => {
+export const fromMnemonicHandler = async (input: any): Promise<ToolResultSchema> => {
   try {
     if (!input.mnemonic) {
       return createErrorResponse("Mnemonic is required");
@@ -98,18 +108,15 @@ export const fromMnemonicHandler = async (input: any): Promise<ToolResultSchema<
       wordlist: (input.locale && ethers.wordlists[input.locale]) || ethers.wordlists.en
     };
 
-    const provider = input.provider ? getProvider(input.provider) : undefined;
+    const provider = getProvider();
     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:
+    return createSuccessResponse(
+    `Wallet created from mnemonic successfully:
       Address: ${wallet.address}
+      Mnemonic: ${input.mnemonic}
       Private Key: ${wallet.privateKey}
       Public Key: ${wallet.publicKey}
     `);
@@ -118,7 +125,7 @@ export const fromMnemonicHandler = async (input: any): Promise<ToolResultSchema<
   }
 };
 
-export const fromEncryptedJsonHandler = async (input: any): Promise<ToolResultSchema<any>> => {
+export const fromEncryptedJsonHandler = async (input: any): Promise<ToolResultSchema> => {
   try {
     if (!input.json) {
       return createErrorResponse("Encrypted JSON is required");
@@ -129,23 +136,24 @@ export const fromEncryptedJsonHandler = async (input: any): Promise<ToolResultSc
     }
 
     const wallet = await ethers.Wallet.fromEncryptedJson(input.json, input.password);
-    const provider = input.provider ? getProvider(input.provider) : undefined;
+    const provider = getProvider()
 
     if (provider) {
       wallet.connect(provider);
     }
 
-    return createSuccessResponse({
-      address: wallet.address,
-      privateKey: wallet.privateKey,
-      publicKey: wallet.publicKey
-    }, "Wallet created from encrypted JSON successfully");
+    return createSuccessResponse(
+    `Wallet created from encrypted JSON successfully
+      Address: ${wallet.address}
+      Private Key: ${wallet.privateKey}
+      Public Key: ${wallet.publicKey}
+    `);
   } catch (error) {
     return createErrorResponse(`Failed to create wallet from encrypted JSON: ${(error as Error).message}`);
   }
 };
 
-export const encryptWalletHandler = async (input: any): Promise<ToolResultSchema<any>> => {
+export const encryptWalletHandler = async (input: any): Promise<ToolResultSchema> => {
   try {
     if (!input.wallet) {
       return createErrorResponse("Wallet is required");
@@ -158,9 +166,10 @@ export const encryptWalletHandler = async (input: any): Promise<ToolResultSchema
     const wallet = await getWallet(input.wallet);
     const encryptedWallet = await wallet.encrypt(input.password, input.options);
 
-    return createSuccessResponse({
-      encryptedWallet
-    }, "Wallet encrypted successfully");
+    return createSuccessResponse(
+    `Wallet encrypted successfully
+      Encrypted Wallet: ${encryptedWallet}
+    `);
   } catch (error) {
     return createErrorResponse(`Failed to encrypt wallet: ${(error as Error).message}`);
   }
@@ -168,13 +177,12 @@ export const encryptWalletHandler = async (input: any): Promise<ToolResultSchema
 
 // Wallet Properties
 
-export const getAddressHandler = async (input: any): Promise<ToolResultSchema<any>> => {
+export const getAddressHandler = async (input: any): Promise<ToolResultSchema> => {
   try {
     const wallet = await getWallet(input.wallet);
 
-    return createSuccessResponse({
-      address: wallet.address
-    }, `Wallet address retrieved successfully:
+    return createSuccessResponse(
+    `Wallet address retrieved successfully:
       Address: ${wallet.address}
     `);
   } catch (error) {
@@ -182,13 +190,12 @@ export const getAddressHandler = async (input: any): Promise<ToolResultSchema<an
   }
 };
 
-export const getPublicKeyHandler = async (input: any): Promise<ToolResultSchema<any>> => {
+export const getPublicKeyHandler = async (input: any): Promise<ToolResultSchema> => {
   try {
     const wallet = await getWallet(input.wallet);
 
-    return createSuccessResponse({
-      publicKey: wallet.publicKey
-    }, `Wallet public key retrieved successfully:
+    return createSuccessResponse(
+    `Wallet public key retrieved successfully:
       Public Key: ${wallet.publicKey}
     `);
   } catch (error) {
@@ -196,13 +203,12 @@ export const getPublicKeyHandler = async (input: any): Promise<ToolResultSchema<
   }
 };
 
-export const getPrivateKeyHandler = async (input: any): Promise<ToolResultSchema<any>> => {
+export const getPrivateKeyHandler = async (input: any): Promise<ToolResultSchema> => {
   try {
     const wallet = await getWallet(input.wallet, input.password);
 
-    return createSuccessResponse({
-      privateKey: wallet.privateKey
-    }, `Wallet private key retrieved successfully:
+    return createSuccessResponse(
+    `Wallet private key retrieved successfully:
       Private Key: ${wallet.privateKey}
     `);
   } catch (error) {
@@ -211,20 +217,14 @@ export const getPrivateKeyHandler = async (input: any): Promise<ToolResultSchema
 };
 // Blockchain Methods
 
-export const getBalanceHandler = async (input: any): Promise<ToolResultSchema<any>> => {
+export const getBalanceHandler = async (input: any): Promise<ToolResultSchema> => {
   try {
-    if (!input.provider) {
-      return createErrorResponse("Provider URL is required to get balance");
-    }
-
-    const wallet = await getWallet(input.wallet, input.password, input.provider);
+    const wallet = await getWallet(input.wallet, input.password);
 
     const balance = await wallet.getBalance(input.blockTag ?? "latest");
 
-    return createSuccessResponse({
-      balance: balance.toString(),
-      balanceInEth: ethers.utils.formatEther(balance)
-    }, `Wallet balance retrieved successfully
+    return createSuccessResponse(
+      `Wallet balance retrieved successfully
       Balance: ${balance.toString()}
       Balance in ETH: ${ethers.utils.formatEther(balance)}
     `);
@@ -233,19 +233,18 @@ export const getBalanceHandler = async (input: any): Promise<ToolResultSchema<an
   }
 };
 
-export const getChainIdHandler = async (input: any): Promise<ToolResultSchema<any>> => {
+export const getChainIdHandler = async (input: any): Promise<ToolResultSchema> => {
   try {
-    const wallet = await getWallet(input.wallet, input.password, input.provider);
+    const wallet = await getWallet(input.wallet, input.password);
 
     if (!wallet.provider) {
-      return createErrorResponse("Provider is required to get chain ID");
+      return createErrorResponse("Provider is required to get chain ID, please set the provider URL");
     }
 
     const chainId = await wallet.getChainId();
 
-    return createSuccessResponse({
-      chainId
-    }, `Chain ID retrieved successfully
+    return createSuccessResponse(
+    `Chain ID retrieved successfully
       Chain ID: ${chainId.toString()}
     `);
   } catch (error) {
@@ -253,20 +252,18 @@ export const getChainIdHandler = async (input: any): Promise<ToolResultSchema<an
   }
 };
 
-export const getGasPriceHandler = async (input: any): Promise<ToolResultSchema<any>> => {
+export const getGasPriceHandler = async (input: any): Promise<ToolResultSchema> => {
   try {
-    const wallet = await getWallet(input.wallet, input.password, input.provider);
+    const wallet = await getWallet(input.wallet, input.password);
 
     if (!wallet.provider) {
-      return createErrorResponse("Provider is required to get gas price");
+      return createErrorResponse("Provider is required to get gas price, please set the provider URL");
     }
 
     const gasPrice = await wallet.getGasPrice();
 
-    return createSuccessResponse({
-      gasPrice: gasPrice.toString(),
-      gasPriceInGwei: ethers.utils.formatUnits(gasPrice, "gwei")
-    }, `Gas price retrieved successfully
+    return createSuccessResponse(
+    `Gas price retrieved successfully
       Gas price: ${gasPrice.toString()}
       Gas price in Gwei: ${ethers.utils.formatUnits(gasPrice, "gwei")}
     `);
@@ -275,19 +272,18 @@ export const getGasPriceHandler = async (input: any): Promise<ToolResultSchema<a
   }
 };
 
-export const getTransactionCountHandler = async (input: any): Promise<ToolResultSchema<any>> => {
+export const getTransactionCountHandler = async (input: any): Promise<ToolResultSchema> => {
   try {
-    const wallet = await getWallet(input.wallet, input.password, input.provider);
+    const wallet = await getWallet(input.wallet, input.password);
 
     if (!wallet.provider) {
-      return createErrorResponse("Provider is required to get transaction count");
+      return createErrorResponse("Provider is required to get transaction count, please set the provider URL");
     }
 
     const transactionCount = await wallet.getTransactionCount(input.blockTag);
 
-    return createSuccessResponse({
-      transactionCount
-    }, `Transaction count retrieved successfully
+    return createSuccessResponse(
+    `Transaction count retrieved successfully
       Transaction count: ${transactionCount.toString()}
     `);
   } catch (error) {
@@ -295,23 +291,22 @@ export const getTransactionCountHandler = async (input: any): Promise<ToolResult
   }
 };
 
-export const callHandler = async (input: any): Promise<ToolResultSchema<any>> => {
+export const callHandler = async (input: any): Promise<ToolResultSchema> => {
   try {
     if (!input.transaction) {
       return createErrorResponse("Transaction is required");
     }
 
-    const wallet = await getWallet(input.wallet, input.password, input.provider);
+    const wallet = await getWallet(input.wallet, input.password);
 
     if (!wallet.provider) {
-      return createErrorResponse("Provider is required to call a contract");
+      return createErrorResponse("Provider is required to call a contract, please set the provider URL");
     }
 
     const result = await wallet.call(input.transaction, input.blockTag);
 
-    return createSuccessResponse({
-      result
-    }, `Contract call executed successfully
+    return createSuccessResponse(
+    `Contract call executed successfully
       Result: ${result}
     `);
   } catch (error) {
@@ -321,32 +316,21 @@ export const callHandler = async (input: any): Promise<ToolResultSchema<any>> =>
 
 // Transaction Methods
 
-export const sendTransactionHandler = async (input: any): Promise<ToolResultSchema<any>> => {
+export const sendTransactionHandler = async (input: any): Promise<ToolResultSchema> => {
   try {
     if (!input.transaction) {
       return createErrorResponse("Transaction is required");
     }
 
-    const wallet = await getWallet(input.wallet, input.password, input.provider);
-
+    const wallet = await getWallet(input.wallet, input.password);
     if (!wallet.provider) {
-      return createErrorResponse("Provider is required to send a transaction");
+      return createErrorResponse("Provider is required to send a transaction, please set the provider URL");
     }
 
     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
+    return createSuccessResponse(
+    `Transaction sent successfully
       Hash: ${tx.hash}
       Nonce: ${tx.nonce.toString()}
       Gas limit: ${tx.gasLimit.toString()}
@@ -358,21 +342,20 @@ export const sendTransactionHandler = async (input: any): Promise<ToolResultSche
   }
 };
 
-export const signTransactionHandler = async (input: any): Promise<ToolResultSchema<any>> => {
+export const signTransactionHandler = async (input: any): Promise<ToolResultSchema> => {
   try {
     if (!input.transaction) {
       return createErrorResponse("Transaction is required");
     }
 
-    const wallet = await getWallet(input.wallet, input.password, input.provider);
+    const wallet = await getWallet(input.wallet, input.password);
 
     // 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
+    return createSuccessResponse(
+    `Transaction signed successfully
       Signed transaction: ${signedTx}
     `);
   } catch (error) {
@@ -380,35 +363,22 @@ export const signTransactionHandler = async (input: any): Promise<ToolResultSche
   }
 };
 
-export const populateTransactionHandler = async (input: any): Promise<ToolResultSchema<any>> => {
+export const populateTransactionHandler = async (input: any): Promise<ToolResultSchema> => {
   try {
     if (!input.transaction) {
       return createErrorResponse("Transaction is required");
     }
 
-    const wallet = await getWallet(input.wallet, input.password, input.provider);
+    const wallet = await getWallet(input.wallet, input.password);
 
     if (!wallet.provider) {
-      return createErrorResponse("Provider is required to populate a transaction");
+      return createErrorResponse("Provider is required to populate a transaction, please set the provider URL");
     }
 
     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
+    return createSuccessResponse(
+    `Transaction populated successfully
       To: ${populatedTx.to}
       From: ${populatedTx.from}
       Nonce: ${populatedTx.nonce?.toString() ?? "Not specified"}
@@ -422,7 +392,7 @@ export const populateTransactionHandler = async (input: any): Promise<ToolResult
 
 // Signing Methods
 
-export const signMessageHandler = async (input: any): Promise<ToolResultSchema<any>> => {
+export const signMessageHandler = async (input: any): Promise<ToolResultSchema> => {
   try {
     if (!input.message) {
       return createErrorResponse("Message is required");
@@ -431,10 +401,7 @@ export const signMessageHandler = async (input: any): Promise<ToolResultSchema<a
     const wallet = await getWallet(input.wallet, input.password);
     const signature = await wallet.signMessage(input.message);
 
-    return createSuccessResponse({
-      signature,
-      message: input.message
-    }, `Message signed successfully
+    return createSuccessResponse(`Message signed successfully
       Signature: ${signature}
       Message: "${input.message}"
     `);
@@ -443,7 +410,7 @@ export const signMessageHandler = async (input: any): Promise<ToolResultSchema<a
   }
 };
 
-export const signTypedDataHandler = async (input: any): Promise<ToolResultSchema<any>> => {
+export const signTypedDataHandler = async (input: any): Promise<ToolResultSchema> => {
   try {
     if (!input.wallet) {
       return createErrorResponse("Wallet is required");
@@ -459,12 +426,8 @@ export const signTypedDataHandler = async (input: any): Promise<ToolResultSchema
     // @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
+    return createSuccessResponse(
+    `Typed data signed successfully
       Signature: ${signature}
       Domain: ${input.domain}
       Types: ${input.types}
@@ -475,7 +438,7 @@ export const signTypedDataHandler = async (input: any): Promise<ToolResultSchema
   }
 };
 
-export const verifyMessageHandler = async (input: any): Promise<ToolResultSchema<any>> => {
+export const verifyMessageHandler = async (input: any): Promise<ToolResultSchema> => {
   try {
     if (!input.message || !input.signature || !input.address) {
       return createErrorResponse("Message, signature, and address are required");
@@ -484,10 +447,8 @@ export const verifyMessageHandler = async (input: any): Promise<ToolResultSchema
     const recoveredAddress = ethers.utils.verifyMessage(input.message, input.signature);
     const isValid = recoveredAddress.toLowerCase() === input.address.toLowerCase();
 
-    return createSuccessResponse({
-      isValid,
-      recoveredAddress
-    }, isValid ? `Signature verified successfully
+    return createSuccessResponse(
+    isValid ? `Signature verified successfully
       Message: "${input.message}"
       Signature: ${input.signature}
       Address: ${input.address}
@@ -501,7 +462,7 @@ export const verifyMessageHandler = async (input: any): Promise<ToolResultSchema
   }
 };
 
-export const verifyTypedDataHandler = async (input: any): Promise<ToolResultSchema<any>> => {
+export const verifyTypedDataHandler = async (input: any): Promise<ToolResultSchema> => {
   try {
     if (!input.domain || !input.types || !input.value || !input.signature || !input.address) {
       return createErrorResponse("Domain, types, value, signature, and address are required");
@@ -517,10 +478,8 @@ export const verifyTypedDataHandler = async (input: any): Promise<ToolResultSche
 
     const isValid = recoveredAddress.toLowerCase() === input.address.toLowerCase();
 
-    return createSuccessResponse({
-      isValid,
-      recoveredAddress
-    }, isValid ? `Typed data signature is valid
+    return createSuccessResponse(
+    isValid ? `Typed data signature is valid
       Domain: ${input.domain}
       Types: ${input.types}
       Value: ${input.value}
@@ -534,24 +493,19 @@ export const verifyTypedDataHandler = async (input: any): Promise<ToolResultSche
 
 // Provider Methods
 
-export const getBlockHandler = async (input: any): Promise<ToolResultSchema<any>> => {
+export const getBlockHandler = async (input: any): Promise<ToolResultSchema> => {
   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);
+    const provider = getProvider();
     // In ethers.js v5, getBlock can take includeTransactions as a second parameter
     // but TypeScript definitions might not reflect this
     const block = await (provider as any).getBlock(input.blockHashOrBlockTag, input.includeTransactions);
 
-    return createSuccessResponse({
-      block
-    }, `Block retrieved successfully
+    return createSuccessResponse(
+    `Block retrieved successfully
       Block hash: ${block.hash}
       Block number: ${block.number?.toString() ?? "Not specified"}
       Block timestamp: ${block.timestamp?.toString() ?? "Not specified"}
@@ -562,22 +516,17 @@ export const getBlockHandler = async (input: any): Promise<ToolResultSchema<any>
   }
 };
 
-export const getTransactionHandler = async (input: any): Promise<ToolResultSchema<any>> => {
+export const getTransactionHandler = async (input: any): Promise<ToolResultSchema> => {
   try {
-    if (!input.provider) {
-      return createErrorResponse("Provider is required");
-    }
-
     if (!input.transactionHash) {
       return createErrorResponse("Transaction hash is required");
     }
 
-    const provider = getProvider(input.provider);
+    const provider = getProvider();
     const transaction = await provider.getTransaction(input.transactionHash);
 
-    return createSuccessResponse({
-      transaction
-    }, `Transaction retrieved successfully
+    return createSuccessResponse(
+    `Transaction retrieved successfully
       Transaction hash: ${input.transactionHash}
       Transaction: ${transaction}
     `);
@@ -586,22 +535,17 @@ export const getTransactionHandler = async (input: any): Promise<ToolResultSchem
   }
 };
 
-export const getTransactionReceiptHandler = async (input: any): Promise<ToolResultSchema<any>> => {
+export const getTransactionReceiptHandler = async (input: any): Promise<ToolResultSchema> => {
   try {
-    if (!input.provider) {
-      return createErrorResponse("Provider is required");
-    }
-
     if (!input.transactionHash) {
       return createErrorResponse("Transaction hash is required");
     }
 
-    const provider = getProvider(input.provider);
+    const provider = getProvider();
     const receipt = await provider.getTransactionReceipt(input.transactionHash);
 
-    return createSuccessResponse({
-      receipt
-    }, `Transaction receipt retrieved successfully
+    return createSuccessResponse(
+    `Transaction receipt retrieved successfully
       Transaction hash: ${input.transactionHash}
       Transaction receipt: ${receipt}
     `);
@@ -610,22 +554,17 @@ export const getTransactionReceiptHandler = async (input: any): Promise<ToolResu
   }
 };
 
-export const getCodeHandler = async (input: any): Promise<ToolResultSchema<any>> => {
+export const getCodeHandler = async (input: any): Promise<ToolResultSchema> => {
   try {
-    if (!input.provider) {
-      return createErrorResponse("Provider is required");
-    }
-
     if (!input.address) {
       return createErrorResponse("Address is required");
     }
 
-    const provider = getProvider(input.provider);
+    const provider = getProvider();
     const code = await provider.getCode(input.address, input.blockTag);
 
-    return createSuccessResponse({
-      code
-    }, `Code retrieved successfully
+    return createSuccessResponse(
+    `Code retrieved successfully
       Address: ${input.address}
       Code: ${code}
     `);
@@ -634,12 +573,8 @@ export const getCodeHandler = async (input: any): Promise<ToolResultSchema<any>>
   }
 };
 
-export const getStorageAtHandler = async (input: any): Promise<ToolResultSchema<any>> => {
+export const getStorageAtHandler = async (input: any): Promise<ToolResultSchema> => {
   try {
-    if (!input.provider) {
-      return createErrorResponse("Provider is required");
-    }
-
     if (!input.address) {
       return createErrorResponse("Address is required");
     }
@@ -648,12 +583,11 @@ export const getStorageAtHandler = async (input: any): Promise<ToolResultSchema<
       return createErrorResponse("Position is required");
     }
 
-    const provider = getProvider(input.provider);
+    const provider = getProvider();
     const storage = await provider.getStorageAt(input.address, input.position, input.blockTag);
 
-    return createSuccessResponse({
-      storage
-    }, `Storage retrieved successfully
+    return createSuccessResponse(
+    `Storage retrieved successfully
       Address: ${input.address}
       Position: ${input.position}
       Storage: ${storage}
@@ -663,22 +597,20 @@ export const getStorageAtHandler = async (input: any): Promise<ToolResultSchema<
   }
 };
 
-export const estimateGasHandler = async (input: any): Promise<ToolResultSchema<any>> => {
+export const estimateGasHandler = async (input: any): Promise<ToolResultSchema> => {
   try {
-    if (!input.provider) {
-      return createErrorResponse("Provider is required");
-    }
-
     if (!input.transaction) {
       return createErrorResponse("Transaction is required");
     }
 
-    const provider = getProvider(input.provider);
+    const provider = getProvider();
+    if (!provider) {
+      return createErrorResponse("Provider is required to estimate gas, please set the provider URL");
+    }
     const gasEstimate = await provider.estimateGas(input.transaction);
 
-    return createSuccessResponse({
-      gasEstimate: gasEstimate.toString()
-    }, `Gas estimate retrieved successfully
+    return createSuccessResponse(
+    `Gas estimate retrieved successfully
       Gas estimate: ${gasEstimate.toString()}
     `);
   } catch (error) {
@@ -686,22 +618,20 @@ export const estimateGasHandler = async (input: any): Promise<ToolResultSchema<a
   }
 };
 
-export const getLogsHandler = async (input: any): Promise<ToolResultSchema<any>> => {
+export const getLogsHandler = async (input: any): Promise<ToolResultSchema> => {
   try {
-    if (!input.provider) {
-      return createErrorResponse("Provider is required");
-    }
-
     if (!input.filter) {
       return createErrorResponse("Filter is required");
     }
 
-    const provider = getProvider(input.provider);
+    const provider = getProvider();
+    if (!provider) {
+      return createErrorResponse("Provider is required to get logs, please set the provider URL");
+    }
     const logs = await provider.getLogs(input.filter);
 
-    return createSuccessResponse({
-      logs
-    }, `Logs retrieved successfully
+    return createSuccessResponse(
+    `Logs retrieved successfully
       Logs: ${logs}
     `);
   } catch (error) {
@@ -709,27 +639,22 @@ export const getLogsHandler = async (input: any): Promise<ToolResultSchema<any>>
   }
 };
 
-export const getEnsResolverHandler = async (input: any): Promise<ToolResultSchema<any>> => {
+export const getEnsResolverHandler = async (input: any): Promise<ToolResultSchema> => {
   try {
-    if (!input.provider) {
-      return createErrorResponse("Provider is required");
-    }
-
     if (!input.name) {
       return createErrorResponse("ENS name is required");
     }
 
-    const provider = getProvider(input.provider);
+    const provider = getProvider();
+    if (!provider) {
+      return createErrorResponse("Provider is required to get ENS resolver, please set the provider URL");
+    }
     // In ethers.js v5, getResolver might not be directly on the provider type
     // but it's available in the implementation
     const resolver = await (provider as any).getResolver(input.name);
 
-    return createSuccessResponse({
-      resolver: resolver ? {
-        address: resolver.address,
-        name: resolver.name
-      } : null
-    }, resolver ? `ENS resolver retrieved successfully
+    return createSuccessResponse(
+    resolver ? `ENS resolver retrieved successfully
       Address: ${resolver.address}
       Name: ${resolver.name}
     ` : "No resolver found for this ENS name");
@@ -738,22 +663,20 @@ export const getEnsResolverHandler = async (input: any): Promise<ToolResultSchem
   }
 };
 
-export const lookupAddressHandler = async (input: any): Promise<ToolResultSchema<any>> => {
+export const lookupAddressHandler = async (input: any): Promise<ToolResultSchema> => {
   try {
-    if (!input.provider) {
-      return createErrorResponse("Provider is required");
-    }
-
     if (!input.address) {
       return createErrorResponse("Address is required");
     }
 
-    const provider = getProvider(input.provider);
+    const provider = getProvider();
+    if (!provider) {
+      return createErrorResponse("Provider is required to lookup ENS name, please set the provider URL");
+    }
     const name = await provider.lookupAddress(input.address);
 
-    return createSuccessResponse({
-      name
-    }, name ? `ENS name retrieved successfully
+    return createSuccessResponse(
+    name ? `ENS name retrieved successfully
       Name: ${name}
     ` : "No ENS name found for this address");
   } catch (error) {
@@ -761,22 +684,20 @@ export const lookupAddressHandler = async (input: any): Promise<ToolResultSchema
   }
 };
 
-export const resolveNameHandler = async (input: any): Promise<ToolResultSchema<any>> => {
+export const resolveNameHandler = async (input: any): Promise<ToolResultSchema> => {
   try {
-    if (!input.provider) {
-      return createErrorResponse("Provider is required");
-    }
-
     if (!input.name) {
       return createErrorResponse("ENS name is required");
     }
 
-    const provider = getProvider(input.provider);
+    const provider = getProvider();
+    if (!provider) {
+      return createErrorResponse("Provider is required to resolve ENS name, please set the provider URL");
+    }
     const address = await provider.resolveName(input.name);
 
-    return createSuccessResponse({
-      address
-    }, address ? `ENS name resolved successfully
+    return createSuccessResponse(
+    address ? `ENS name resolved successfully
       Name: ${input.name}
       Address: ${address}
     ` : "Could not resolve this ENS name");
@@ -787,22 +708,15 @@ export const resolveNameHandler = async (input: any): Promise<ToolResultSchema<a
 
 // Network Methods
 
-export const getNetworkHandler = async (input: any): Promise<ToolResultSchema<any>> => {
+export const getNetworkHandler = async (input: any): Promise<ToolResultSchema> => {
   try {
-    if (!input.provider) {
-      return createErrorResponse("Provider is required");
+    const provider = getProvider();
+    if (!provider) {
+      return createErrorResponse("Provider is required to get network information, please set the provider URL");
     }
-
-    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
+    return createSuccessResponse(`Network information retrieved successfully
       Network name: ${network.name}
       Chain ID: ${network.chainId}
       ENS address: ${network.ensAddress}
@@ -812,18 +726,16 @@ export const getNetworkHandler = async (input: any): Promise<ToolResultSchema<an
   }
 };
 
-export const getBlockNumberHandler = async (input: any): Promise<ToolResultSchema<any>> => {
+export const getBlockNumberHandler = async (input: any): Promise<ToolResultSchema> => {
   try {
-    if (!input.provider) {
-      return createErrorResponse("Provider is required");
+    const provider = getProvider();
+    if (!provider) {
+      return createErrorResponse("Provider is required to get block number, please set the provider URL");
     }
-
-    const provider = getProvider(input.provider);
     const blockNumber = await provider.getBlockNumber();
 
-    return createSuccessResponse({
-      blockNumber
-    }, `Block number retrieved successfully
+    return createSuccessResponse(
+    `Block number retrieved successfully
       Block number: ${blockNumber.toString()}
     `);
   } catch (error) {
@@ -831,25 +743,17 @@ export const getBlockNumberHandler = async (input: any): Promise<ToolResultSchem
   }
 };
 
-export const getFeeDataHandler = async (input: any): Promise<ToolResultSchema<any>> => {
+export const getFeeDataHandler = async (input: any): Promise<ToolResultSchema> => {
   try {
-    if (!input.provider) {
-      return createErrorResponse("Provider is required");
+    const provider = getProvider();
+    if (!provider) {
+      return createErrorResponse("Provider is required to get fee data, please set the provider URL");
     }
-
-    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
+    return createSuccessResponse(`Fee data retrieved successfully
       Gas price: ${feeData.gasPrice?.toString()}
       Max fee per gas: ${feeData.maxFeePerGas?.toString()}
       Max priority fee per gas: ${feeData.maxPriorityFeePerGas?.toString()}