@openzeppelin/contracts-mcp 0.0.5

package/src/stellar/tools/fungible.ts

@@ -0,0 +1,35 @@
+import type { McpServer, RegisteredTool } from '@modelcontextprotocol/sdk/server/mcp.js';
+import type { FungibleOptions } from '@openzeppelin/wizard-stellar';
+import { fungible } from '@openzeppelin/wizard-stellar';
+import { safePrintRustCodeBlock, makeDetailedPrompt } from '../../utils';
+import { fungibleSchema } from '../schemas';
+import { stellarPrompts } from '@openzeppelin/wizard-common';
+
+export function registerStellarFungible(server: McpServer): RegisteredTool {
+  return server.tool(
+    'stellar-fungible',
+    makeDetailedPrompt(stellarPrompts.Fungible),
+    fungibleSchema,
+    async ({ name, symbol, burnable, pausable, premint, mintable, upgradeable, access, info }) => {
+      const opts: FungibleOptions = {
+        name,
+        symbol,
+        burnable,
+        pausable,
+        premint,
+        mintable,
+        upgradeable,
+        access,
+        info,
+      };
+      return {
+        content: [
+          {
+            type: 'text',
+            text: safePrintRustCodeBlock(() => fungible.print(opts)),
+          },
+        ],
+      };
+    },
+  );
+}

package/src/stellar/tools/non-fungible.ts

@@ -0,0 +1,36 @@
+import type { McpServer, RegisteredTool } from '@modelcontextprotocol/sdk/server/mcp.js';
+import type { NonFungibleOptions } from '@openzeppelin/wizard-stellar';
+import { nonFungible } from '@openzeppelin/wizard-stellar';
+import { safePrintRustCodeBlock, makeDetailedPrompt } from '../../utils';
+import { nonFungibleSchema } from '../schemas';
+import { stellarPrompts } from '@openzeppelin/wizard-common';
+
+export function registerStellarNonFungible(server: McpServer): RegisteredTool {
+  return server.tool(
+    'stellar-non-fungible',
+    makeDetailedPrompt(stellarPrompts.NonFungible),
+    nonFungibleSchema,
+    async ({ name, symbol, burnable, enumerable, consecutive, pausable, mintable, sequential, upgradeable, info }) => {
+      const opts: NonFungibleOptions = {
+        name,
+        symbol,
+        burnable,
+        enumerable,
+        consecutive,
+        pausable,
+        mintable,
+        sequential,
+        upgradeable,
+        info,
+      };
+      return {
+        content: [
+          {
+            type: 'text',
+            text: safePrintRustCodeBlock(() => nonFungible.print(opts)),
+          },
+        ],
+      };
+    },
+  );
+}

package/src/stellar/tools/stablecoin.ts

@@ -0,0 +1,36 @@
+import type { McpServer, RegisteredTool } from '@modelcontextprotocol/sdk/server/mcp.js';
+import type { StablecoinOptions } from '@openzeppelin/wizard-stellar';
+import { stablecoin } from '@openzeppelin/wizard-stellar';
+import { safePrintRustCodeBlock, makeDetailedPrompt } from '../../utils';
+import { stablecoinSchema } from '../schemas';
+import { stellarPrompts } from '@openzeppelin/wizard-common';
+
+export function registerStellarStablecoin(server: McpServer): RegisteredTool {
+  return server.tool(
+    'stellar-stablecoin',
+    makeDetailedPrompt(stellarPrompts.Stablecoin),
+    stablecoinSchema,
+    async ({ name, symbol, burnable, pausable, premint, mintable, upgradeable, access, limitations, info }) => {
+      const opts: StablecoinOptions = {
+        name,
+        symbol,
+        burnable,
+        pausable,
+        premint,
+        mintable,
+        upgradeable,
+        access,
+        limitations,
+        info,
+      };
+      return {
+        content: [
+          {
+            type: 'text',
+            text: safePrintRustCodeBlock(() => stablecoin.print(opts)),
+          },
+        ],
+      };
+    },
+  );
+}

package/src/stellar/tools.ts

@@ -0,0 +1,24 @@
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { registerStellarFungible } from './tools/fungible.js';
+import { registerStellarStablecoin } from './tools/stablecoin.js';
+import { registerStellarNonFungible } from './tools/non-fungible.js';
+import type { KindedOptions } from '@openzeppelin/wizard-stellar';
+import type { RegisteredTool } from '@modelcontextprotocol/sdk/server/mcp.js';
+
+type StellarToolRegisterFunctions = {
+  [kind in keyof KindedOptions]: (server: McpServer) => RegisteredTool;
+};
+
+function getRegisterFunctions(server: McpServer): StellarToolRegisterFunctions {
+  return {
+    Fungible: () => registerStellarFungible(server),
+    Stablecoin: () => registerStellarStablecoin(server),
+    NonFungible: () => registerStellarNonFungible(server),
+  };
+}
+
+export function registerStellarTools(server: McpServer) {
+  Object.values(getRegisterFunctions(server)).forEach(registerTool => {
+    registerTool(server);
+  });
+}

package/src/stylus/schemas.ts

@@ -0,0 +1,54 @@
+import { z } from 'zod';
+import {
+  commonDescriptions,
+  infoDescriptions,
+  stylusERC20Descriptions,
+  stylusERC721Descriptions,
+  stylusERC1155Descriptions,
+} from '@openzeppelin/wizard-common';
+import type { KindedOptions } from '@openzeppelin/wizard-stylus';
+
+/**
+ * Static type assertions to ensure schemas satisfy the Wizard API types. Not called at runtime.
+ */
+function _typeAssertions() {
+  const _assertions: {
+    [K in keyof KindedOptions]: Omit<KindedOptions[K], 'kind'>;
+  } = {
+    ERC20: z.object(erc20Schema).parse({}),
+    ERC721: z.object(erc721Schema).parse({}),
+    ERC1155: z.object(erc1155Schema).parse({}),
+  };
+}
+
+export const commonSchema = {
+  info: z
+    .object({
+      securityContact: z.string().optional().describe(infoDescriptions.securityContact),
+      license: z.string().optional().describe(infoDescriptions.license),
+    })
+    .optional()
+    .describe(infoDescriptions.info),
+} as const satisfies z.ZodRawShape;
+
+export const erc20Schema = {
+  name: z.string().describe(commonDescriptions.name),
+  burnable: z.boolean().optional().describe(commonDescriptions.burnable),
+  permit: z.boolean().optional().describe(stylusERC20Descriptions.permit),
+  flashmint: z.boolean().optional().describe(stylusERC20Descriptions.flashmint),
+  ...commonSchema,
+} as const satisfies z.ZodRawShape;
+
+export const erc721Schema = {
+  name: z.string().describe(commonDescriptions.name),
+  burnable: z.boolean().optional().describe(commonDescriptions.burnable),
+  enumerable: z.boolean().optional().describe(stylusERC721Descriptions.enumerable),
+  ...commonSchema,
+} as const satisfies z.ZodRawShape;
+
+export const erc1155Schema = {
+  name: z.string().describe(commonDescriptions.name),
+  burnable: z.boolean().optional().describe(commonDescriptions.burnable),
+  supply: z.boolean().optional().describe(stylusERC1155Descriptions.supply),
+  ...commonSchema,
+} as const satisfies z.ZodRawShape;

package/src/stylus/tools/erc1155.ts

@@ -0,0 +1,30 @@
+import type { McpServer, RegisteredTool } from '@modelcontextprotocol/sdk/server/mcp.js';
+import type { ERC1155Options } from '@openzeppelin/wizard-stylus';
+import { erc1155 } from '@openzeppelin/wizard-stylus';
+import { safePrintRustCodeBlock, makeDetailedPrompt } from '../../utils';
+import { erc1155Schema } from '../schemas';
+import { stylusPrompts } from '@openzeppelin/wizard-common';
+
+export function registerStylusERC1155(server: McpServer): RegisteredTool {
+  return server.tool(
+    'stylus-erc1155',
+    makeDetailedPrompt(stylusPrompts.ERC1155),
+    erc1155Schema,
+    async ({ name, burnable, supply, info }) => {
+      const opts: ERC1155Options = {
+        name,
+        burnable,
+        supply,
+        info,
+      };
+      return {
+        content: [
+          {
+            type: 'text',
+            text: safePrintRustCodeBlock(() => erc1155.print(opts)),
+          },
+        ],
+      };
+    },
+  );
+}

package/src/stylus/tools/erc20.ts

@@ -0,0 +1,31 @@
+import type { McpServer, RegisteredTool } from '@modelcontextprotocol/sdk/server/mcp.js';
+import type { ERC20Options } from '@openzeppelin/wizard-stylus';
+import { erc20 } from '@openzeppelin/wizard-stylus';
+import { safePrintRustCodeBlock, makeDetailedPrompt } from '../../utils';
+import { erc20Schema } from '../schemas';
+import { stylusPrompts } from '@openzeppelin/wizard-common';
+
+export function registerStylusERC20(server: McpServer): RegisteredTool {
+  return server.tool(
+    'stylus-erc20',
+    makeDetailedPrompt(stylusPrompts.ERC20),
+    erc20Schema,
+    async ({ name, burnable, permit, flashmint, info }) => {
+      const opts: ERC20Options = {
+        name,
+        burnable,
+        permit,
+        flashmint,
+        info,
+      };
+      return {
+        content: [
+          {
+            type: 'text',
+            text: safePrintRustCodeBlock(() => erc20.print(opts)),
+          },
+        ],
+      };
+    },
+  );
+}

package/src/stylus/tools/erc721.ts

@@ -0,0 +1,30 @@
+import type { McpServer, RegisteredTool } from '@modelcontextprotocol/sdk/server/mcp.js';
+import type { ERC721Options } from '@openzeppelin/wizard-stylus';
+import { erc721 } from '@openzeppelin/wizard-stylus';
+import { safePrintRustCodeBlock, makeDetailedPrompt } from '../../utils';
+import { erc721Schema } from '../schemas';
+import { stylusPrompts } from '@openzeppelin/wizard-common';
+
+export function registerStylusERC721(server: McpServer): RegisteredTool {
+  return server.tool(
+    'stylus-erc721',
+    makeDetailedPrompt(stylusPrompts.ERC721),
+    erc721Schema,
+    async ({ name, burnable, enumerable, info }) => {
+      const opts: ERC721Options = {
+        name,
+        burnable,
+        enumerable,
+        info,
+      };
+      return {
+        content: [
+          {
+            type: 'text',
+            text: safePrintRustCodeBlock(() => erc721.print(opts)),
+          },
+        ],
+      };
+    },
+  );
+}

package/src/stylus/tools.ts

@@ -0,0 +1,24 @@
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { registerStylusERC20 } from './tools/erc20';
+import { registerStylusERC721 } from './tools/erc721';
+import { registerStylusERC1155 } from './tools/erc1155';
+import type { KindedOptions } from '@openzeppelin/wizard-stylus';
+import type { RegisteredTool } from '@modelcontextprotocol/sdk/server/mcp.js';
+
+type StylusToolRegisterFunctions = {
+  [kind in keyof KindedOptions]: (server: McpServer) => RegisteredTool;
+};
+
+function getRegisterFunctions(server: McpServer): StylusToolRegisterFunctions {
+  return {
+    ERC20: () => registerStylusERC20(server),
+    ERC721: () => registerStylusERC721(server),
+    ERC1155: () => registerStylusERC1155(server),
+  };
+}
+
+export function registerStylusTools(server: McpServer) {
+  Object.values(getRegisterFunctions(server)).forEach(registerTool => {
+    registerTool(server);
+  });
+}

package/src/utils.ts

@@ -0,0 +1,59 @@
+import { OptionsError as OptionsErrorSolidity } from '@openzeppelin/wizard';
+import { OptionsError as OptionsErrorCairo } from '@openzeppelin/wizard-cairo';
+import { OptionsError as OptionsErrorStylus } from '@openzeppelin/wizard-stylus';
+import { OptionsError as OptionsErrorStellar } from '@openzeppelin/wizard-stellar';
+
+function safePrintCodeBlock(printFn: () => string, syntaxHighlightingLanguage: string): string {
+  try {
+    return `\
+\`\`\`${syntaxHighlightingLanguage}
+${printFn()}
+\`\`\`
+`;
+  } catch (e) {
+    if (
+      e instanceof OptionsErrorSolidity ||
+      e instanceof OptionsErrorCairo ||
+      e instanceof OptionsErrorStylus ||
+      e instanceof OptionsErrorStellar
+    ) {
+      return `${e.message}\n\n${JSON.stringify(e.messages, null, 2)}`;
+    } else {
+      return `Unexpected error: ${e}`;
+    }
+  }
+}
+
+/**
+ * Prints the contract source code, wrapped in a Markdown code block with syntax highlighting as `solidity`.
+ * Or prints the error message if an error occurs.
+ */
+export function safePrintSolidityCodeBlock(printFn: () => string): string {
+  return safePrintCodeBlock(printFn, 'solidity');
+}
+
+/**
+ * Prints the contract source code, wrapped in a Markdown code block with syntax highlighting as `cairo`.
+ * Or prints the error message if an error occurs.
+ */
+export function safePrintCairoCodeBlock(printFn: () => string): string {
+  return safePrintCodeBlock(printFn, 'cairo');
+}
+
+/**
+ * Prints the contract source code, wrapped in a Markdown code block with syntax highlighting as `rust`.
+ * Or prints the error message if an error occurs.
+ */
+export function safePrintRustCodeBlock(printFn: () => string): string {
+  return safePrintCodeBlock(printFn, 'rust');
+}
+
+/**
+ * Adds a description to the prompt that explains the return format of the tool.
+ */
+export function makeDetailedPrompt(origPrompt: string): string {
+  return `\
+${origPrompt}
+
+Returns the source code of the generated contract, formatted in a Markdown code block. Does not write to disk.`;
+}