feat: Update tools to use unified response formatting and error handling (#7)

Author: robot-ux

.env.example

@@ -1,7 +1,7 @@
 # Log levels: DEBUG, INFO, WARN, ERROR
 LOG_LEVEL=DEBUG
 
-# Your wallet private key (this is a test private key, DO NOT use in production)
+# Your wallet private key (this is a test private key, DO NOT use in production, 0x...)
 PRIVATE_KEY=your_private_key
 
 # Server configuration (optional, will use default values if not set)

bun.lockb

@@ -0,0 +1,15 @@
+import { describe, expect, it } from "bun:test"
+
+import { getClient } from "./util"
+
+describe("Basic Test", async () => {
+  const client = await getClient()
+
+  it("list all mcp tools", async () => {
+    const toolResult = await client.listTools()
+    const names = toolResult.tools.map((tool) => tool.name)
+    console.log("all MCP tools: ", names)
+
+    expect(names).toBeArray()
+  })
+})

e2e/basic.test.ts

@@ -0,0 +1,35 @@
+import { describe, expect, it } from "bun:test"
+
+import { getClient, parseText } from "../util"
+
+describe("EVM Blocks Test", async () => {
+  const client = await getClient()
+
+  it("get latest block", async () => {
+    const res = await client.callTool({
+      name: "get_latest_block",
+      arguments: {}
+    })
+    const text = res.content?.[0]?.text
+    const obj = parseText<{
+      hash: string
+    }>(text)
+    expect(obj.hash).toStartWith("0x")
+  })
+
+  it("get block by hash", async () => {
+    const res = await client.callTool({
+      name: "get_block_by_hash",
+      arguments: {
+        blockHash:
+          "0x5443cc9cf2820982843ac91095827561f31f595e75932c9f87c6fe610b95243c",
+        network: "bsc"
+      }
+    })
+    const text = res.content?.[0]?.text
+    const obj = parseText<{
+      withdrawalsRoot: string
+    }>(text)
+    expect(obj.withdrawalsRoot).toStartWith("0x")
+  })
+})

e2e/evm/blocks.test.ts

@@ -0,0 +1,75 @@
+import { describe, expect, it } from "bun:test"
+
+import { getClient, parseText } from "../util"
+
+describe("EVM Contracts Test", async () => {
+  const client = await getClient()
+
+  // WBNB contract on BSC
+  const WBNB_ADDRESS = "0xbb4CdB9CBd36B01bD1cBaEBF2De08d9173bc095c"
+
+  it("check if address is contract", async () => {
+    const res = await client.callTool({
+      name: "is_contract",
+      arguments: {
+        address: WBNB_ADDRESS,
+        network: "bsc"
+      }
+    })
+    const text = res.content?.[0]?.text
+    const obj = parseText<{
+      isContract: boolean
+    }>(text)
+    expect(obj.isContract).toBe(true)
+  })
+
+  it("read contract name", async () => {
+    const res = await client.callTool({
+      name: "read_contract",
+      arguments: {
+        contractAddress: WBNB_ADDRESS,
+        abi: [
+          {
+            constant: true,
+            inputs: [],
+            name: "name",
+            outputs: [{ name: "", type: "string" }],
+            payable: false,
+            stateMutability: "view",
+            type: "function"
+          }
+        ],
+        functionName: "name",
+        network: "bsc"
+      }
+    })
+    const text = res.content?.[0]?.text
+    const obj = parseText<string>(text)
+    expect(obj).toBe("Wrapped BNB")
+  })
+
+  it("read contract totalSupply", async () => {
+    const res = await client.callTool({
+      name: "read_contract",
+      arguments: {
+        contractAddress: WBNB_ADDRESS,
+        abi: [
+          {
+            constant: true,
+            inputs: [],
+            name: "totalSupply",
+            outputs: [{ name: "", type: "uint256" }],
+            payable: false,
+            stateMutability: "view",
+            type: "function"
+          }
+        ],
+        functionName: "totalSupply",
+        network: "bsc"
+      }
+    })
+    const text = res.content?.[0]?.text
+    const totalSupply = parseText<bigint>(text)
+    expect(BigInt(totalSupply)).toBeTypeOf("bigint")
+  })
+})

e2e/evm/contracts.test.ts

@@ -0,0 +1,22 @@
+import { describe, expect, it } from "bun:test"
+
+import { getClient, parseText } from "../util"
+
+describe("EVM ENS Test", async () => {
+  const client = await getClient()
+
+  it("resolve ETH ENS name", async () => {
+    const res = await client.callTool({
+      name: "resolve_ens",
+      arguments: {
+        ensName: "vitalik.eth",
+        network: "eth" // only for eth mainnet
+      }
+    })
+    const text = res.content?.[0]?.text
+    const obj = parseText<{
+      resolvedAddress: string
+    }>(text)
+    expect(obj.resolvedAddress).toStartWith("0x")
+  })
+})

e2e/evm/ens.test.ts

@@ -0,0 +1,80 @@
+import { describe, expect, it } from "bun:test"
+
+import { getClient, parseText } from "../util"
+
+describe("EVM Network Test", async () => {
+  const client = await getClient()
+
+  it("get chain info for BSC", async () => {
+    const res = await client.callTool({
+      name: "get_chain_info",
+      arguments: {
+        network: "bsc"
+      }
+    })
+    const text = res.content?.[0]?.text
+    const obj = parseText<{
+      chainId: number
+    }>(text)
+    expect(obj.chainId).toBe(56) // BSC mainnet chain ID
+  })
+
+  it("get chain info for BSC testnet", async () => {
+    const res = await client.callTool({
+      name: "get_chain_info",
+      arguments: {
+        network: "bsc-testnet"
+      }
+    })
+    const text = res.content?.[0]?.text
+    const obj = parseText<{
+      chainId: number
+    }>(text)
+    expect(obj.chainId).toBe(97) // BSC testnet chain ID
+  })
+
+  it("get chain info for opBNB", async () => {
+    const res = await client.callTool({
+      name: "get_chain_info",
+      arguments: {
+        network: "opbnb"
+      }
+    })
+    const text = res.content?.[0]?.text
+    const obj = parseText<{
+      chainId: number
+    }>(text)
+    expect(obj.chainId).toBe(204) // opBNB mainnet chain ID
+  })
+
+  it("get chain info for opBNB testnet", async () => {
+    const res = await client.callTool({
+      name: "get_chain_info",
+      arguments: {
+        network: "opbnb-testnet"
+      }
+    })
+    const text = res.content?.[0]?.text
+    const obj = parseText<{
+      chainId: number
+    }>(text)
+    expect(obj.chainId).toBe(5611) // opBNB testnet chain ID
+  })
+
+  it("get supported networks", async () => {
+    const res = await client.callTool({
+      name: "get_supported_networks",
+      arguments: {
+        random_string: "dummy"
+      }
+    })
+    const text = res.content?.[0]?.text
+    const obj = parseText<{
+      supportedNetworks: string[]
+    }>(text)
+    expect(obj.supportedNetworks).toContain("bsc")
+    expect(obj.supportedNetworks).toContain("bsc-testnet")
+    expect(obj.supportedNetworks).toContain("opbnb")
+    expect(obj.supportedNetworks).toContain("opbnb-testnet")
+  })
+})

e2e/evm/network.test.ts

@@ -0,0 +1,51 @@
+import { describe, expect, it } from "bun:test"
+
+import { getClient, parseText } from "../util"
+
+describe("EVM NFT Test", async () => {
+  const client = await getClient()
+
+  // Binance Account Bound Token (BABT) on BSC
+  const NFT_ADDRESS = "0x2b09d47d550061f995a3b5c6f0fd58005215d7c8"
+  const TOKEN_ID = "1"
+
+  // erc1155 on BSC
+  const ERC1155_ADDRESS = "0x06f352C604D36b703E04671827493c43F598dC1e"
+  const ERC1155_TOKEN_ID = "1"
+
+  describe("ERC721 Tests", () => {
+    it("get NFT info", async () => {
+      const res = await client.callTool({
+        name: "get_nft_info",
+        arguments: {
+          tokenAddress: NFT_ADDRESS,
+          tokenId: TOKEN_ID,
+          network: "bsc"
+        }
+      })
+      const text = res.content?.[0]?.text
+      const obj = parseText<{
+        symbol: string
+      }>(text)
+      expect(obj.symbol).toEqual("BABT")
+    })
+  })
+
+  describe("ERC1155 Tests", () => {
+    it("get ERC1155 token URI", async () => {
+      const res = await client.callTool({
+        name: "get_erc1155_token_uri",
+        arguments: {
+          tokenAddress: ERC1155_ADDRESS,
+          tokenId: ERC1155_TOKEN_ID,
+          network: "bsc"
+        }
+      })
+      const text = res.content?.[0]?.text
+      const obj = parseText<{
+        tokenURI: string
+      }>(text)
+      expect(obj.tokenURI).toContain("://")
+    })
+  })
+})

e2e/evm/nft.test.ts

@@ -0,0 +1,76 @@
+import { describe, expect, it } from "bun:test"
+
+import { getClient, parseText } from "../util"
+
+describe("EVM Tokens Test", async () => {
+  const client = await getClient()
+
+  // BUSD contract on BSC
+  const BUSD_ADDRESS = "0xe9e7CEA3DedcA5984780Bafc599bD69ADd087D56"
+  // Binance Hot Wallet
+  const BINANCE_HOT_WALLET = "0x8894E0a0c962CB723c1976a4421c95949bE2D4E3"
+
+  it("get ERC20 token info", async () => {
+    const res = await client.callTool({
+      name: "get_erc20_token_info",
+      arguments: {
+        tokenAddress: BUSD_ADDRESS,
+        network: "bsc"
+      }
+    })
+    const text = res.content?.[0]?.text
+    const obj = parseText<{
+      name: string
+    }>(text)
+    expect(obj.name).toBe("BUSD Token")
+  })
+
+  it("get native token balance", async () => {
+    const res = await client.callTool({
+      name: "get_native_balance",
+      arguments: {
+        address: BINANCE_HOT_WALLET,
+        network: "bsc"
+      }
+    })
+    const text = res.content?.[0]?.text
+    const obj = parseText<{
+      raw: string
+    }>(text)
+    expect(BigInt(obj.raw)).toBeTypeOf("bigint")
+  })
+
+  it("get ERC20 token balance", async () => {
+    const res = await client.callTool({
+      name: "get_erc20_balance",
+      arguments: {
+        tokenAddress: BUSD_ADDRESS,
+        address: BINANCE_HOT_WALLET,
+        network: "bsc"
+      }
+    })
+    const text = res.content?.[0]?.text
+    const obj = parseText<{
+      raw: string
+    }>(text)
+    expect(BigInt(obj.raw)).toBeTypeOf("bigint")
+  })
+
+  // it("create ERC20 token", async () => {
+  //   const res = await client.callTool({
+  //     name: "create_erc20_token",
+  //     arguments: {
+  //       name: "Test USDT Token",
+  //       symbol: "vUSDT",
+  //       network: "bsc-testnet",
+  //       privateKey: process.env.PRIVATE_KEY as string,
+  //       totalSupply: "1000000000" // 1 billion
+  //     }
+  //   })
+  //   const text = res.content?.[0]?.text
+  //   const obj = parseText<{
+  //     hash: string
+  //   }>(text)
+  //   expect(obj.hash).toStartWith("0x")
+  // })
+})