Merge pull request #20 from nearai/contract_searching_and_build

Contract searching and build

Author: cmrfrd

CHANGELOG.md

@@ -1,5 +1,11 @@
 # @nearai/near-mcp
 
+## 0.0.32
+
+### Patch Changes
+
+- Reduce build size and improve contract search
+
 ## 0.0.31
 
 ### Patch Changes

bun.lock

@@ -1,6 +1,6 @@
 {
   "name": "@nearai/near-mcp",
-  "version": "0.0.31",
+  "version": "0.0.32",
   "description": "MCP server for interacting with Near Blockchain",
   "homepage": "https://github.com/near-ai/near-mcp",
   "repository": {
@@ -13,7 +13,7 @@
     "lint": "eslint . --ext .ts,.tsx",
     "lint:fix": "eslint . --ext .ts,.tsx --fix",
     "typecheck": "tsc --noEmit",
-    "build": "rm -rf dist/* && bun build --sourcemap=external --entrypoints $(find ./src -name '*.ts' | grep -v '*.test.ts') --target node --outdir dist/ && bun run build:declaration",
+    "build": "rm -rf dist/* && bun build --sourcemap=external --entrypoints $(find ./src -name '*.ts' | grep -v '*.test.ts') --minify --splitting --target node --outdir dist/ && bun run build:declaration",
     "build:declaration": "tsc --emitDeclarationOnly",
     "cli": "bun run build && dist/near-mcp.js"
   },
@@ -59,6 +59,7 @@
     "eslint": "^9.17.0",
     "eslint-config-prettier": "^9.1.0",
     "eslint-plugin-simple-import-sort": "^10.0.0",
+    "openapi-types": "^12.1.3",
     "prettier": "^3.4.2",
     "shx": "^0.4.0",
     "typescript": "^5.7.2"

package.json

@@ -31,14 +31,16 @@ import { ZSTDDecoder } from 'zstddec';
 import {
   curvePrefixToKeyType,
   DEFAULT_GAS,
+  getFungibleTokenContractInfo,
   getParsedContractMethod,
   json_to_zod,
   keyTypeToCurvePrefix,
+  mapSemaphore,
   MCP_SERVER_NAME,
   NearToken,
   noLeadingWhitespace,
   type Result,
-  searchPopularFungibleTokenContractInfos,
+  searchFungibleTokenContracts,
   stringify_bigint,
 } from './utils';
 
@@ -576,31 +578,81 @@ export const createMcpServer = async (keyDir: string) => {
   );
 
   mcp.tool(
-    'system_search_popular_fungible_token_contracts',
+    'system_search_fungible_token_contracts_info',
     noLeadingWhitespace`
-    Search for popular fungible token contract information on the NEAR blockchain, with a grep-like search.
-    Use this tool to search for popular fungible token contract information. This tool works by 'grepping'
-    through a list of contract information JSON objects. Useful for getting contract information about popular
-    tokens like USDC native, USDT, WNEAR, and more.`,
+    Search for fungible token contract information on the NEAR blockchain, with a grep-like search.
+    Use this tool to search for fungible token contract information. This tool works by 'grepping'
+    through a list of contract information JSON objects. Be careful with this tool, it can return a lot of results.
+    If used too much, it could overwhelm the API and cause issues.`,
     {
-      searchPattern: z
+      searchTerm: z
         .string()
         .describe(
-          'The grep search pattern to use for filtering popular fungible token contract information.',
+          'The search term to use for finding fungible token contract information.',
+        ),
+      maxNumberOfResults: z
+        .number()
+        .default(3)
+        .describe(
+          'The maximum number of results to return. This is a limit to the number of results returned by the API. Keep this number low to avoid overwhelming the API.',
         ),
     },
     async (args, __) => {
-      const tokenContracts = await searchPopularFungibleTokenContractInfos(
-        args.searchPattern,
+      const tokenContractsSearchResult = await searchFungibleTokenContracts(
+        args.searchTerm,
+        args.maxNumberOfResults,
       );
-      if (!tokenContracts.ok) {
+      if (!tokenContractsSearchResult.ok) {
         return {
-          content: [{ type: 'text', text: `Error: ${tokenContracts.error}` }],
+          content: [
+            {
+              type: 'text',
+              text: `Error: ${tokenContractsSearchResult.error}`,
+            },
+          ],
         };
       }
+      const tokenContracts = tokenContractsSearchResult.value;
+
+      // get the contract info for each contract
+      const contractInfoResults = await mapSemaphore(
+        tokenContracts.map((token) => token.contract),
+        4,
+        async (contract): Promise<[string, Result<object, Error>]> => {
+          return [contract, await getFungibleTokenContractInfo(contract)];
+        },
+      );
+      const filteredErrorResults = contractInfoResults.filter(
+        ([_, result]) => !result.ok,
+      );
+      if (filteredErrorResults.length > 0) {
+        const errorTokens = filteredErrorResults
+          .map(([contract, _]) => contract)
+          .join(', ');
+        return {
+          content: [
+            {
+              type: 'text',
+              text: `Error: ${errorTokens}`,
+            },
+          ],
+        };
+      }
+      const contractInfos = contractInfoResults
+        .filter(([_, result]) => result.ok)
+        .map(([_, result]) => {
+          if (result.ok) {
+            return result.value;
+          }
+          throw new Error('Unexpected error in filtered results');
+        });
+
       return {
         content: [
-          { type: 'text', text: stringify_bigint(tokenContracts.value) },
+          {
+            type: 'text',
+            text: stringify_bigint(contractInfos),
+          },
         ],
       };
     },
@@ -1754,6 +1806,27 @@ export const createMcpServer = async (keyDir: string) => {
       args: z
         .record(z.string(), z.any())
         .describe('The arguments to pass to the method.'),
+      jsonQuery: z
+        .string()
+        .optional()
+        .describe('The json query to post process.'),
+      outputFile: z
+        .string()
+        .optional()
+        .describe('The file to write the output to.'),
+      chainingCall: z
+        .object({
+          nextMCPServer: z
+            .string()
+            .optional()
+            .describe('The next MCP server to call.'),
+          args: z
+            .any()
+            .optional()
+            .describe('The arguments to pass to the next MCP server.'),
+        })
+        .optional()
+        .describe('The contract to call after the current contract.'),
     },
     async (args, _) => {
       const connection = await connect({

src/services.ts

@@ -1,5 +1,6 @@
 import { KeyType } from '@near-js/crypto';
 import { DEFAULT_FUNCTION_CALL_GAS } from '@near-js/utils';
+import { type OpenAPIV3 } from 'openapi-types';
 import { z } from 'zod';
 
 export const DEFAULT_GAS = DEFAULT_FUNCTION_CALL_GAS * BigInt(10);
@@ -62,25 +63,21 @@ type FungibleTokenContract = {
   symbol: string;
 };
 
-export const getPopularFungibleTokenContracts = async (): Promise<
-  Result<FungibleTokenContract[], Error>
-> => {
+export const searchFungibleTokenContracts = async (
+  searchTerm: string,
+  maxNumberOfResults: number,
+): Promise<Result<FungibleTokenContract[], Error>> => {
   try {
-    const url =
-      'https://nearblocks.io/_next/data/nearblocks/en/tokens.json?page=1';
+    const url = `https://api.nearblocks.io/v1/fts?page=1&per_page=${maxNumberOfResults}&search=${searchTerm}`;
     const response = await fetch(url);
     const data = (await response.json()) as {
-      pageProps?: {
-        data?: {
-          tokens?: {
-            contract: string;
-            name: string;
-            symbol: string;
-          }[];
-        };
-      };
+      tokens?: {
+        contract: string;
+        name: string;
+        symbol: string;
+      }[];
     };
-    const tokens = data.pageProps?.data?.tokens;
+    const tokens = data.tokens;
     if (!tokens) {
       return {
         ok: false,
@@ -103,34 +100,29 @@ export const getPopularFungibleTokenContracts = async (): Promise<
 };
 
 export const getFungibleTokenContractInfo = async (
-  accountId: string,
+  contractId: string,
 ): Promise<Result<object, Error>> => {
   try {
-    const url = `https://nearblocks.io/_next/data/nearblocks/en/token/${accountId}.json`;
+    const url = `https://api.nearblocks.io/v1/fts/${contractId}`;
     const response = await fetch(url);
     const data = (await response.json()) as {
-      pageProps?: {
-        tokenDetails?: {
-          contracts?: {
-            contract: string;
-            name: string;
-            symbol: string;
-            decimals: number;
-            description: string;
-            website: string;
-          }[];
-        };
-      };
+      contracts?: {
+        contract: string;
+        name: string;
+        symbol: string;
+        decimals: number;
+        description: string;
+        website: string;
+      }[];
     };
-    const pageProps = data?.pageProps;
-    const tokenDetails = pageProps?.tokenDetails;
-    if (!tokenDetails?.contracts) {
+    const contracts = data?.contracts;
+    if (!contracts) {
       return {
         ok: false,
         error: new Error('No fungible token contracts found'),
       };
     }
-    const contractInfo = tokenDetails.contracts.map((contract) => ({
+    const contractInfo = contracts.map((contract) => ({
       contract: contract.contract,
       name: contract.name,
       symbol: contract.symbol,
@@ -147,61 +139,6 @@ export const getFungibleTokenContractInfo = async (
   }
 };
 
-export const getPopularFungibleTokenContractInfos = async (): Promise<
-  Result<object[], Error>
-> => {
-  const popularFungibleTokenContracts =
-    await getPopularFungibleTokenContracts();
-  if (!popularFungibleTokenContracts.ok) {
-    return { ok: false, error: popularFungibleTokenContracts.error };
-  }
-  const results = await mapSemaphore(
-    popularFungibleTokenContracts.value.map((token) => token.contract),
-    8,
-    async (contract): Promise<[string, Result<object, Error>]> => {
-      return [contract, await getFungibleTokenContractInfo(contract)];
-    },
-  );
-
-  const filteredErrorResults = results.filter(([_, result]) => !result.ok);
-  if (filteredErrorResults.length > 0) {
-    const errorTokens = filteredErrorResults
-      .map(([contract, _]) => contract)
-      .join(', ');
-    return {
-      ok: false,
-      error: new Error(
-        `Failure to receive fungible token contract info for: ${errorTokens}`,
-      ),
-    };
-  }
-  const values = results
-    .map(([_, result]) => result)
-    .filter((result) => result.ok)
-    .map((result) => result.value);
-  return { ok: true, value: values };
-};
-
-export const searchPopularFungibleTokenContractInfos = async (
-  searchTerm: string,
-): Promise<Result<object[], Error>> => {
-  const popularFungibleTokenContractInfos =
-    await getPopularFungibleTokenContractInfos();
-  if (!popularFungibleTokenContractInfos.ok) {
-    return { ok: false, error: popularFungibleTokenContractInfos.error };
-  }
-
-  try {
-    const searchRegex = new RegExp(searchTerm, 'i');
-    const filteredTokens = popularFungibleTokenContractInfos.value.filter(
-      (token) => searchRegex.test(JSON.stringify(token)),
-    );
-    return { ok: true, value: filteredTokens };
-  } catch (error) {
-    return { ok: false, error: error as Error };
-  }
-};
-
 const ParsedMethodSchema = z.object({
   action: z.array(
     z.object({
@@ -252,6 +189,20 @@ export const getParsedContractMethod = async (
   }
 };
 
+export const getNearBlocksJsonSchema = async (): Promise<
+  Result<OpenAPIV3.Document, Error>
+> => {
+  const url = 'https://api.nearblocks.io/openapi.json';
+  const response = await fetch(url);
+  const nearblocksJsonSchema = (await response.json()) as OpenAPIV3.Document;
+  nearblocksJsonSchema.paths = Object.fromEntries(
+    Object.entries(nearblocksJsonSchema.paths || {}).filter(([path]) =>
+      path.includes('/v1/account/'),
+    ),
+  );
+  return { ok: true, value: nearblocksJsonSchema };
+};
+
 export interface JsonToZodConfig {
   convertTuples?: boolean;
   zodValueOverrides?: Record<string, Record<string, z.ZodTypeAny>>;