@mcp-dockmaster/mcp-cryptowallet-evm 1.0.0

package/tests/handlers/network.test.ts

@@ -0,0 +1,73 @@
+import { ethers } from 'ethers';
+import {
+  getNetworkHandler,
+  getBlockNumberHandler,
+  getFeeDataHandler
+} from '../../src/handlers/wallet.js';
+
+// Mock ethers.js functions
+jest.mock('ethers', () => {
+  const originalModule = jest.requireActual('ethers');
+  
+  // Create a mock provider
+  const mockProvider = {
+    getNetwork: jest.fn().mockResolvedValue({ 
+      name: 'homestead', 
+      chainId: 1,
+      ensAddress: '0x00000000000C2E074eC69A0dFb2997BA6C7d2e1e'
+    }),
+    getBlockNumber: jest.fn().mockResolvedValue(1000000),
+    getFeeData: jest.fn().mockResolvedValue({
+      gasPrice: originalModule.utils.parseUnits('50', 'gwei'),
+      maxFeePerGas: originalModule.utils.parseUnits('100', 'gwei'),
+      maxPriorityFeePerGas: originalModule.utils.parseUnits('2', 'gwei')
+    })
+  };
+  
+  return {
+    ...originalModule,
+    providers: {
+      JsonRpcProvider: jest.fn().mockReturnValue(mockProvider)
+    },
+    getDefaultProvider: jest.fn().mockReturnValue(mockProvider),
+    utils: originalModule.utils
+  };
+});
+
+describe('Network Methods Handlers', () => {
+  test('getNetworkHandler should return network information', async () => {
+    const result = await getNetworkHandler({ 
+      provider: 'https://mainnet.infura.io/v3/your-api-key'
+    });
+    
+    expect(result.isError).toBe(false);
+    expect(result.toolResult).toHaveProperty('network');
+    expect(result.toolResult.network).toHaveProperty('name');
+    expect(result.toolResult.network).toHaveProperty('chainId');
+    expect(result.toolResult.network).toHaveProperty('ensAddress');
+    expect(result.toolResult.network.name).toBe('homestead');
+    expect(result.toolResult.network.chainId).toBe(1);
+  });
+  
+  test('getBlockNumberHandler should return the current block number', async () => {
+    const result = await getBlockNumberHandler({ 
+      provider: 'https://mainnet.infura.io/v3/your-api-key'
+    });
+    
+    expect(result.isError).toBe(false);
+    expect(result.toolResult).toHaveProperty('blockNumber');
+    expect(result.toolResult.blockNumber).toBe(1000000);
+  });
+  
+  test('getFeeDataHandler should return fee data', async () => {
+    const result = await getFeeDataHandler({ 
+      provider: 'https://mainnet.infura.io/v3/your-api-key'
+    });
+    
+    expect(result.isError).toBe(false);
+    expect(result.toolResult).toHaveProperty('feeData');
+    expect(result.toolResult.feeData).toHaveProperty('gasPrice');
+    expect(result.toolResult.feeData).toHaveProperty('maxFeePerGas');
+    expect(result.toolResult.feeData).toHaveProperty('maxPriorityFeePerGas');
+  });
+});

package/tests/handlers/provider.test.ts

@@ -0,0 +1,197 @@
+import { ethers } from 'ethers';
+import {
+  getBlockHandler,
+  getTransactionHandler,
+  getTransactionReceiptHandler,
+  getCodeHandler,
+  getStorageAtHandler,
+  estimateGasHandler,
+  getLogsHandler,
+  getEnsResolverHandler,
+  lookupAddressHandler,
+  resolveNameHandler
+} from '../../src/handlers/wallet.js';
+
+// Mock ethers.js functions
+jest.mock('ethers', () => {
+  const originalModule = jest.requireActual('ethers');
+  
+  // Create a mock provider
+  const mockProvider = {
+    getBlock: jest.fn().mockResolvedValue({ 
+      hash: '0xblock', 
+      number: 1000000, 
+      timestamp: Date.now() / 1000,
+      transactions: ['0xtx1', '0xtx2']
+    }),
+    getTransaction: jest.fn().mockResolvedValue({ 
+      hash: '0xtx', 
+      from: '0x742d35Cc6634C0532925a3b844Bc454e4438f44e', 
+      to: '0x742d35Cc6634C0532925a3b844Bc454e4438f44e' 
+    }),
+    getTransactionReceipt: jest.fn().mockResolvedValue({ 
+      status: 1, 
+      blockNumber: 1000000,
+      gasUsed: originalModule.BigNumber.from(21000)
+    }),
+    getCode: jest.fn().mockResolvedValue('0x'),
+    getStorageAt: jest.fn().mockResolvedValue('0x0000000000000000000000000000000000000000000000000000000000000000'),
+    estimateGas: jest.fn().mockResolvedValue(originalModule.BigNumber.from(21000)),
+    getLogs: jest.fn().mockResolvedValue([{
+      blockNumber: 1000000,
+      blockHash: '0xblock',
+      transactionIndex: 0,
+      removed: false,
+      address: '0x742d35Cc6634C0532925a3b844Bc454e4438f44e',
+      data: '0x',
+      topics: ['0xtopic1', '0xtopic2']
+    }]),
+    getResolver: jest.fn().mockResolvedValue({
+      address: '0x742d35Cc6634C0532925a3b844Bc454e4438f44e',
+      name: 'test.eth'
+    }),
+    lookupAddress: jest.fn().mockResolvedValue('test.eth'),
+    resolveName: jest.fn().mockResolvedValue('0x742d35Cc6634C0532925a3b844Bc454e4438f44e')
+  };
+  
+  return {
+    ...originalModule,
+    providers: {
+      JsonRpcProvider: jest.fn().mockReturnValue(mockProvider)
+    },
+    getDefaultProvider: jest.fn().mockReturnValue(mockProvider),
+    utils: originalModule.utils
+  };
+});
+
+describe('Provider Methods Handlers', () => {
+  test('getBlockHandler should return a block', async () => {
+    const result = await getBlockHandler({ 
+      provider: 'https://mainnet.infura.io/v3/your-api-key',
+      blockHashOrBlockTag: 'latest',
+      includeTransactions: true
+    });
+    
+    expect(result.isError).toBe(false);
+    expect(result.toolResult).toHaveProperty('block');
+    expect(result.toolResult.block).toHaveProperty('hash');
+    expect(result.toolResult.block).toHaveProperty('number');
+    expect(result.toolResult.block).toHaveProperty('timestamp');
+    expect(result.toolResult.block).toHaveProperty('transactions');
+  });
+  
+  test('getTransactionHandler should return a transaction', async () => {
+    const result = await getTransactionHandler({ 
+      provider: 'https://mainnet.infura.io/v3/your-api-key',
+      transactionHash: '0xtx'
+    });
+    
+    expect(result.isError).toBe(false);
+    expect(result.toolResult).toHaveProperty('transaction');
+    expect(result.toolResult.transaction).toHaveProperty('hash');
+    expect(result.toolResult.transaction).toHaveProperty('from');
+    expect(result.toolResult.transaction).toHaveProperty('to');
+  });
+  
+  test('getTransactionReceiptHandler should return a transaction receipt', async () => {
+    const result = await getTransactionReceiptHandler({ 
+      provider: 'https://mainnet.infura.io/v3/your-api-key',
+      transactionHash: '0xtx'
+    });
+    
+    expect(result.isError).toBe(false);
+    expect(result.toolResult).toHaveProperty('receipt');
+    expect(result.toolResult.receipt).toHaveProperty('status');
+    expect(result.toolResult.receipt).toHaveProperty('blockNumber');
+    expect(result.toolResult.receipt).toHaveProperty('gasUsed');
+  });
+  
+  test('getCodeHandler should return code at an address', async () => {
+    const result = await getCodeHandler({ 
+      provider: 'https://mainnet.infura.io/v3/your-api-key',
+      address: '0x742d35Cc6634C0532925a3b844Bc454e4438f44e'
+    });
+    
+    expect(result.isError).toBe(false);
+    expect(result.toolResult).toHaveProperty('code');
+    expect(result.toolResult.code).toBe('0x');
+  });
+  
+  test('getStorageAtHandler should return storage at a position', async () => {
+    const result = await getStorageAtHandler({ 
+      provider: 'https://mainnet.infura.io/v3/your-api-key',
+      address: '0x742d35Cc6634C0532925a3b844Bc454e4438f44e',
+      position: '0x0'
+    });
+    
+    expect(result.isError).toBe(false);
+    expect(result.toolResult).toHaveProperty('storage');
+    expect(result.toolResult.storage).toBe('0x0000000000000000000000000000000000000000000000000000000000000000');
+  });
+  
+  test('estimateGasHandler should estimate gas for a transaction', async () => {
+    const result = await estimateGasHandler({ 
+      provider: 'https://mainnet.infura.io/v3/your-api-key',
+      transaction: {
+        to: '0x742d35Cc6634C0532925a3b844Bc454e4438f44e',
+        data: '0x'
+      }
+    });
+    
+    expect(result.isError).toBe(false);
+    expect(result.toolResult).toHaveProperty('gasEstimate');
+    expect(result.toolResult.gasEstimate).toBe('21000');
+  });
+  
+  test('getLogsHandler should return logs matching a filter', async () => {
+    const result = await getLogsHandler({ 
+      provider: 'https://mainnet.infura.io/v3/your-api-key',
+      filter: {
+        address: '0x742d35Cc6634C0532925a3b844Bc454e4438f44e',
+        fromBlock: 'latest',
+        toBlock: 'latest'
+      }
+    });
+    
+    expect(result.isError).toBe(false);
+    expect(result.toolResult).toHaveProperty('logs');
+    expect(Array.isArray(result.toolResult.logs)).toBe(true);
+    expect(result.toolResult.logs.length).toBe(1);
+    expect(result.toolResult.logs[0]).toHaveProperty('blockNumber');
+    expect(result.toolResult.logs[0]).toHaveProperty('topics');
+  });
+  
+  test('getEnsResolverHandler should return an ENS resolver', async () => {
+    const result = await getEnsResolverHandler({ 
+      provider: 'https://mainnet.infura.io/v3/your-api-key',
+      name: 'test.eth'
+    });
+    
+    expect(result.isError).toBe(false);
+    expect(result.toolResult).toHaveProperty('resolver');
+    expect(result.toolResult.resolver).toHaveProperty('address');
+    expect(result.toolResult.resolver).toHaveProperty('name');
+  });
+  
+  test('lookupAddressHandler should lookup an ENS name for an address', async () => {
+    const result = await lookupAddressHandler({ 
+      provider: 'https://mainnet.infura.io/v3/your-api-key',
+      address: '0x742d35Cc6634C0532925a3b844Bc454e4438f44e'
+    });
+    
+    expect(result.isError).toBe(false);
+    expect(result.toolResult).toHaveProperty('name');
+    expect(result.toolResult.name).toBe('test.eth');
+  });
+  
+  test('resolveNameHandler should resolve an ENS name to an address', async () => {
+    const result = await resolveNameHandler({ 
+      provider: 'https://mainnet.infura.io/v3/your-api-key',
+      name: 'test.eth'
+    });
+    
+    expect(result.isError).toBe(false);
+    expect(result.toolResult).toHaveProperty('address');
+    expect(result.toolResult.address).toBe('0x742d35Cc6634C0532925a3b844Bc454e4438f44e');
+  });
+});

package/tests/handlers/wallet.test.ts

@@ -0,0 +1,289 @@
+import { ethers } from 'ethers';
+import {
+  createWalletHandler,
+  fromPrivateKeyHandler,
+  fromMnemonicHandler,
+  fromEncryptedJsonHandler,
+  encryptWalletHandler,
+  getAddressHandler,
+  getPublicKeyHandler,
+  getPrivateKeyHandler,
+  getMnemonicHandler,
+  getBalanceHandler,
+  getChainIdHandler,
+  getGasPriceHandler,
+  getTransactionCountHandler,
+  callHandler,
+  signMessageHandler,
+  verifyMessageHandler
+} from '../../src/handlers/wallet.js';
+
+// Mock ethers.js functions
+jest.mock('ethers', () => {
+  const originalModule = jest.requireActual('ethers');
+  
+  // Create a mock wallet
+  const mockWallet = {
+    address: '0x742d35Cc6634C0532925a3b844Bc454e4438f44e',
+    privateKey: '0x0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef',
+    publicKey: '0x04a1b2c3d4e5f6a1b2c3d4e5f6a1b2c3d4e5f6a1b2c3d4e5f6a1b2c3d4e5f6a1b2c3d4e5f6a1b2c3d4e5f6a1b2c3d4e5f6a1b2c3d4e5f6a1b2c3d4e5f6',
+    mnemonic: {
+      phrase: 'test test test test test test test test test test test junk',
+      path: "m/44'/60'/0'/0/0",
+      locale: 'en'
+    },
+    connect: jest.fn().mockImplementation((provider) => {
+      mockWallet.provider = provider;
+      return mockWallet;
+    }),
+    getBalance: jest.fn().mockResolvedValue(originalModule.utils.parseEther('1.0')),
+    getChainId: jest.fn().mockResolvedValue(1),
+    getGasPrice: jest.fn().mockResolvedValue(originalModule.utils.parseUnits('50', 'gwei')),
+    getTransactionCount: jest.fn().mockResolvedValue(5),
+    call: jest.fn().mockResolvedValue('0x0000000000000000000000000000000000000000000000000000000000000001'),
+    signMessage: jest.fn().mockResolvedValue('0xsignature'),
+    encrypt: jest.fn().mockResolvedValue(JSON.stringify({ version: 3, id: 'test', address: '742d35cc6634c0532925a3b844bc454e4438f44e' })),
+    provider: null
+  };
+  
+  // Create a mock provider
+  const mockProvider = {
+    getBalance: jest.fn().mockResolvedValue(originalModule.utils.parseEther('1.0')),
+    getBlock: jest.fn().mockResolvedValue({ 
+      hash: '0xblock', 
+      number: 1000000, 
+      timestamp: Date.now() / 1000 
+    }),
+    getTransaction: jest.fn().mockResolvedValue({ 
+      hash: '0xtx', 
+      from: '0x742d35Cc6634C0532925a3b844Bc454e4438f44e', 
+      to: '0x742d35Cc6634C0532925a3b844Bc454e4438f44e' 
+    }),
+    getTransactionReceipt: jest.fn().mockResolvedValue({ 
+      status: 1, 
+      blockNumber: 1000000 
+    }),
+    getCode: jest.fn().mockResolvedValue('0x'),
+    getStorageAt: jest.fn().mockResolvedValue('0x0000000000000000000000000000000000000000000000000000000000000000'),
+    estimateGas: jest.fn().mockResolvedValue(ethers.BigNumber.from(21000)),
+    getLogs: jest.fn().mockResolvedValue([]),
+    getResolver: jest.fn().mockResolvedValue(null),
+    lookupAddress: jest.fn().mockResolvedValue(null),
+    resolveName: jest.fn().mockResolvedValue(null),
+    getNetwork: jest.fn().mockResolvedValue({ name: 'homestead', chainId: 1 }),
+    getBlockNumber: jest.fn().mockResolvedValue(1000000),
+    getFeeData: jest.fn().mockResolvedValue({
+      gasPrice: ethers.utils.parseUnits('50', 'gwei'),
+      maxFeePerGas: ethers.utils.parseUnits('100', 'gwei'),
+      maxPriorityFeePerGas: ethers.utils.parseUnits('2', 'gwei')
+    })
+  };
+  
+  return {
+    ...originalModule,
+    Wallet: {
+      createRandom: jest.fn().mockReturnValue(mockWallet),
+      fromMnemonic: jest.fn().mockReturnValue(mockWallet),
+      fromEncryptedJson: jest.fn().mockResolvedValue(mockWallet)
+    },
+    providers: {
+      JsonRpcProvider: jest.fn().mockReturnValue(mockProvider)
+    },
+    getDefaultProvider: jest.fn().mockReturnValue(mockProvider),
+    utils: originalModule.utils
+  };
+});
+
+describe('Wallet Creation and Management Handlers', () => {
+  test('createWalletHandler should create a random wallet', async () => {
+    const result = await createWalletHandler({});
+    
+    expect(result.isError).toBe(false);
+    expect(result.toolResult).toHaveProperty('address');
+    expect(result.toolResult).toHaveProperty('privateKey');
+    expect(result.toolResult).toHaveProperty('publicKey');
+    expect(result.toolResult).toHaveProperty('mnemonic');
+  });
+  
+  test('createWalletHandler should encrypt wallet if password is provided', async () => {
+    const result = await createWalletHandler({ password: 'test123' });
+    
+    expect(result.isError).toBe(false);
+    expect(result.toolResult).toHaveProperty('encryptedWallet');
+  });
+  
+  test('fromPrivateKeyHandler should create a wallet from a private key', async () => {
+    const result = await fromPrivateKeyHandler({ 
+      privateKey: '0x0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef' 
+    });
+    
+    expect(result.isError).toBe(false);
+    expect(result.toolResult).toHaveProperty('address');
+    expect(result.toolResult).toHaveProperty('privateKey');
+    expect(result.toolResult).toHaveProperty('publicKey');
+  });
+  
+  test('fromMnemonicHandler should create a wallet from a mnemonic', async () => {
+    const result = await fromMnemonicHandler({ 
+      mnemonic: 'test test test test test test test test test test test junk' 
+    });
+    
+    expect(result.isError).toBe(false);
+    expect(result.toolResult).toHaveProperty('address');
+    expect(result.toolResult).toHaveProperty('privateKey');
+    expect(result.toolResult).toHaveProperty('publicKey');
+    expect(result.toolResult).toHaveProperty('mnemonic');
+  });
+  
+  test('fromEncryptedJsonHandler should create a wallet from encrypted JSON', async () => {
+    const result = await fromEncryptedJsonHandler({ 
+      json: JSON.stringify({ version: 3, id: 'test', address: '742d35cc6634c0532925a3b844bc454e4438f44e' }),
+      password: 'test123'
+    });
+    
+    expect(result.isError).toBe(false);
+    expect(result.toolResult).toHaveProperty('address');
+    expect(result.toolResult).toHaveProperty('privateKey');
+    expect(result.toolResult).toHaveProperty('publicKey');
+  });
+  
+  test('encryptWalletHandler should encrypt a wallet', async () => {
+    const result = await encryptWalletHandler({ 
+      wallet: '0x0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef',
+      password: 'test123'
+    });
+    
+    expect(result.isError).toBe(false);
+    expect(result.toolResult).toHaveProperty('encryptedWallet');
+  });
+});
+
+describe('Wallet Properties Handlers', () => {
+  test('getAddressHandler should return the wallet address', async () => {
+    const result = await getAddressHandler({ 
+      wallet: '0x0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef' 
+    });
+    
+    expect(result.isError).toBe(false);
+    expect(result.toolResult).toHaveProperty('address');
+    expect(result.toolResult.address).toBe('0x742d35Cc6634C0532925a3b844Bc454e4438f44e');
+  });
+  
+  test('getPublicKeyHandler should return the wallet public key', async () => {
+    const result = await getPublicKeyHandler({ 
+      wallet: '0x0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef' 
+    });
+    
+    expect(result.isError).toBe(false);
+    expect(result.toolResult).toHaveProperty('publicKey');
+  });
+  
+  test('getPrivateKeyHandler should return the wallet private key', async () => {
+    const result = await getPrivateKeyHandler({ 
+      wallet: '0x0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef' 
+    });
+    
+    expect(result.isError).toBe(false);
+    expect(result.toolResult).toHaveProperty('privateKey');
+    expect(result.toolResult.privateKey).toBe('0x0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef');
+  });
+  
+  test('getMnemonicHandler should return the wallet mnemonic', async () => {
+    const result = await getMnemonicHandler({ 
+      wallet: 'test test test test test test test test test test test junk' 
+    });
+    
+    expect(result.isError).toBe(false);
+    expect(result.toolResult).toHaveProperty('mnemonic');
+    expect(result.toolResult.mnemonic).toBe('test test test test test test test test test test test junk');
+  });
+});
+
+describe('Blockchain Methods Handlers', () => {
+  test('getBalanceHandler should return the wallet balance', async () => {
+    const result = await getBalanceHandler({ 
+      wallet: '0x0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef',
+      provider: 'https://mainnet.infura.io/v3/your-api-key'
+    });
+    
+    expect(result.isError).toBe(false);
+    expect(result.toolResult).toHaveProperty('balance');
+    expect(result.toolResult).toHaveProperty('balanceInEth');
+    expect(result.toolResult.balanceInEth).toBe('1.0');
+  });
+  
+  test('getChainIdHandler should return the chain ID', async () => {
+    const result = await getChainIdHandler({ 
+      wallet: '0x0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef',
+      provider: 'https://mainnet.infura.io/v3/your-api-key'
+    });
+    
+    expect(result.isError).toBe(false);
+    expect(result.toolResult).toHaveProperty('chainId');
+    expect(result.toolResult.chainId).toBe(1);
+  });
+  
+  test('getGasPriceHandler should return the gas price', async () => {
+    const result = await getGasPriceHandler({ 
+      wallet: '0x0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef',
+      provider: 'https://mainnet.infura.io/v3/your-api-key'
+    });
+    
+    expect(result.isError).toBe(false);
+    expect(result.toolResult).toHaveProperty('gasPrice');
+    expect(result.toolResult).toHaveProperty('gasPriceInGwei');
+    expect(result.toolResult.gasPriceInGwei).toBe('50.0');
+  });
+  
+  test('getTransactionCountHandler should return the transaction count', async () => {
+    const result = await getTransactionCountHandler({ 
+      wallet: '0x0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef',
+      provider: 'https://mainnet.infura.io/v3/your-api-key'
+    });
+    
+    expect(result.isError).toBe(false);
+    expect(result.toolResult).toHaveProperty('transactionCount');
+    expect(result.toolResult.transactionCount).toBe(5);
+  });
+  
+  test('callHandler should call a contract method', async () => {
+    const result = await callHandler({ 
+      wallet: '0x0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef',
+      provider: 'https://mainnet.infura.io/v3/your-api-key',
+      transaction: {
+        to: '0x742d35Cc6634C0532925a3b844Bc454e4438f44e',
+        data: '0x70a08231000000000000000000000000742d35cc6634c0532925a3b844bc454e4438f44e'
+      }
+    });
+    
+    expect(result.isError).toBe(false);
+    expect(result.toolResult).toHaveProperty('result');
+  });
+});
+
+describe('Signing Methods Handlers', () => {
+  test('signMessageHandler should sign a message', async () => {
+    const result = await signMessageHandler({ 
+      wallet: '0x0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef',
+      message: 'Hello, world!'
+    });
+    
+    expect(result.isError).toBe(false);
+    expect(result.toolResult).toHaveProperty('signature');
+    expect(result.toolResult).toHaveProperty('message');
+    expect(result.toolResult.signature).toBe('0xsignature');
+    expect(result.toolResult.message).toBe('Hello, world!');
+  });
+  
+  test('verifyMessageHandler should verify a signed message', async () => {
+    const result = await verifyMessageHandler({ 
+      message: 'Hello, world!',
+      signature: '0xsignature',
+      address: '0x742d35Cc6634C0532925a3b844Bc454e4438f44e'
+    });
+    
+    expect(result.isError).toBe(false);
+    expect(result.toolResult).toHaveProperty('isValid');
+    expect(result.toolResult).toHaveProperty('recoveredAddress');
+  });
+});

package/tsconfig.json

@@ -0,0 +1,17 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "esModuleInterop": true,
+    "outDir": "build",
+    "strict": true,
+    "declaration": true,
+    "sourceMap": true,
+    "resolveJsonModule": true,
+    "allowSyntheticDefaultImports": true,
+    "skipLibCheck": true
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "build", "tests"]
+}