@openzeppelin/contracts-mcp 0.0.5

package/dist/utils.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.safePrintSolidityCodeBlock = safePrintSolidityCodeBlock;
+exports.safePrintCairoCodeBlock = safePrintCairoCodeBlock;
+exports.safePrintRustCodeBlock = safePrintRustCodeBlock;
+exports.makeDetailedPrompt = makeDetailedPrompt;
+const wizard_1 = require("@openzeppelin/wizard");
+const wizard_cairo_1 = require("@openzeppelin/wizard-cairo");
+const wizard_stylus_1 = require("@openzeppelin/wizard-stylus");
+const wizard_stellar_1 = require("@openzeppelin/wizard-stellar");
+function safePrintCodeBlock(printFn, syntaxHighlightingLanguage) {
+    try {
+        return `\
+\`\`\`${syntaxHighlightingLanguage}
+${printFn()}
+\`\`\`
+`;
+    }
+    catch (e) {
+        if (e instanceof wizard_1.OptionsError ||
+            e instanceof wizard_cairo_1.OptionsError ||
+            e instanceof wizard_stylus_1.OptionsError ||
+            e instanceof wizard_stellar_1.OptionsError) {
+            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.
+ */
+function safePrintSolidityCodeBlock(printFn) {
+    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.
+ */
+function safePrintCairoCodeBlock(printFn) {
+    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.
+ */
+function safePrintRustCodeBlock(printFn) {
+    return safePrintCodeBlock(printFn, 'rust');
+}
+/**
+ * Adds a description to the prompt that explains the return format of the tool.
+ */
+function makeDetailedPrompt(origPrompt) {
+    return `\
+${origPrompt}
+
+Returns the source code of the generated contract, formatted in a Markdown code block. Does not write to disk.`;
+}
+//# sourceMappingURL=utils.js.map

package/dist/utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.js","sourceRoot":"","sources":["../src/utils.ts"],"names":[],"mappings":";;AA8BA,gEAEC;AAMD,0DAEC;AAMD,wDAEC;AAKD,gDAKC;AA1DD,iDAA4E;AAC5E,6DAA+E;AAC/E,+DAAiF;AACjF,iEAAmF;AAEnF,SAAS,kBAAkB,CAAC,OAAqB,EAAE,0BAAkC;IACnF,IAAI,CAAC;QACH,OAAO;QACH,0BAA0B;EAChC,OAAO,EAAE;;CAEV,CAAC;IACA,CAAC;IAAC,OAAO,CAAC,EAAE,CAAC;QACX,IACE,CAAC,YAAY,qBAAoB;YACjC,CAAC,YAAY,2BAAiB;YAC9B,CAAC,YAAY,4BAAkB;YAC/B,CAAC,YAAY,6BAAmB,EAChC,CAAC;YACD,OAAO,GAAG,CAAC,CAAC,OAAO,OAAO,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,QAAQ,EAAE,IAAI,EAAE,CAAC,CAAC,EAAE,CAAC;QAClE,CAAC;aAAM,CAAC;YACN,OAAO,qBAAqB,CAAC,EAAE,CAAC;QAClC,CAAC;IACH,CAAC;AACH,CAAC;AAED;;;GAGG;AACH,SAAgB,0BAA0B,CAAC,OAAqB;IAC9D,OAAO,kBAAkB,CAAC,OAAO,EAAE,UAAU,CAAC,CAAC;AACjD,CAAC;AAED;;;GAGG;AACH,SAAgB,uBAAuB,CAAC,OAAqB;IAC3D,OAAO,kBAAkB,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC;AAC9C,CAAC;AAED;;;GAGG;AACH,SAAgB,sBAAsB,CAAC,OAAqB;IAC1D,OAAO,kBAAkB,CAAC,OAAO,EAAE,MAAM,CAAC,CAAC;AAC7C,CAAC;AAED;;GAEG;AACH,SAAgB,kBAAkB,CAAC,UAAkB;IACnD,OAAO;EACP,UAAU;;+GAEmG,CAAC;AAChH,CAAC"}

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "@openzeppelin/contracts-mcp",
+  "version": "0.0.5",
+  "description": "OpenZeppelin Contracts MCP Server",
+  "license": "AGPL-3.0-only",
+  "repository": "https://github.com/OpenZeppelin/contracts-wizard",
+  "main": "dist/index.js",
+  "bin": {
+    "contracts-mcp": "dist/index.js"
+  },
+  "ts:main": "src/index.ts",
+  "files": [
+    "LICENSE",
+    "NOTICE",
+    "/dist",
+    "/src",
+    "!**/*.test.*"
+  ],
+  "scripts": {
+    "prepare": "tsc",
+    "watch": "tsc --watch",
+    "test": "ava",
+    "test:update-snapshots": "ava --update-snapshots",
+    "test:watch": "ava --watch"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.11.1",
+    "@openzeppelin/wizard-common": "^0.0.2",
+    "@openzeppelin/wizard": "^0.6.0",
+    "@openzeppelin/wizard-stylus": "^0.2.0-alpha.5",
+    "@openzeppelin/wizard-stellar": "^0.4.1",
+    "@openzeppelin/wizard-cairo": "^2.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "typescript": "^5.0.0",
+    "ava": "^6.0.0",
+    "ts-node": "^10.4.0"
+  }
+}

package/src/cairo/schemas.ts

@@ -0,0 +1,153 @@
+import { z } from 'zod';
+import {
+  commonDescriptions,
+  infoDescriptions,
+  cairoCommonDescriptions,
+  cairoERC20Descriptions,
+  cairoERC721Descriptions,
+  cairoRoyaltyInfoDescriptions,
+  cairoERC1155Descriptions,
+  cairoAccountDescriptions,
+  cairoGovernorDescriptions,
+  cairoMultisigDescriptions,
+  cairoVestingDescriptions,
+} from '@openzeppelin/wizard-common';
+import type { KindedOptions } from '@openzeppelin/wizard-cairo';
+
+/**
+ * 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({}),
+    Account: z.object(accountSchema).parse({}),
+    Multisig: z.object(multisigSchema).parse({}),
+    Governor: z.object(governorSchema).parse({}),
+    Vesting: z.object(vestingSchema).parse({}),
+    Custom: z.object(customSchema).parse({}),
+  };
+}
+
+export const commonSchema = {
+  access: z.literal('ownable').or(z.literal('roles')).optional().describe(cairoCommonDescriptions.access),
+  upgradeable: z.boolean().optional().describe(cairoCommonDescriptions.upgradeable),
+  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),
+  symbol: z.string().describe(commonDescriptions.symbol),
+  burnable: z.boolean().optional().describe(commonDescriptions.burnable),
+  pausable: z.boolean().optional().describe(commonDescriptions.pausable),
+  premint: z.string().optional().describe(cairoERC20Descriptions.premint),
+  mintable: z.boolean().optional().describe(commonDescriptions.mintable),
+  votes: z.boolean().optional().describe(cairoERC20Descriptions.votes),
+  appName: z.string().optional().describe(cairoCommonDescriptions.appName),
+  appVersion: z.string().optional().describe(cairoCommonDescriptions.appVersion),
+  ...commonSchema,
+} as const satisfies z.ZodRawShape;
+
+export const erc721Schema = {
+  name: z.string().describe(commonDescriptions.name),
+  symbol: z.string().describe(commonDescriptions.symbol),
+  baseUri: z.string().optional().describe(cairoERC721Descriptions.baseUri),
+  burnable: z.boolean().optional().describe(commonDescriptions.burnable),
+  pausable: z.boolean().optional().describe(commonDescriptions.pausable),
+  mintable: z.boolean().optional().describe(commonDescriptions.mintable),
+  enumerable: z.boolean().optional().describe(cairoERC721Descriptions.enumerable),
+  votes: z.boolean().optional().describe(cairoERC721Descriptions.votes),
+  royaltyInfo: z
+    .object({
+      enabled: z.boolean().describe(cairoRoyaltyInfoDescriptions.enabled),
+      defaultRoyaltyFraction: z.string().describe(cairoRoyaltyInfoDescriptions.defaultRoyaltyFraction),
+      feeDenominator: z.string().describe(cairoRoyaltyInfoDescriptions.feeDenominator),
+    })
+    .optional()
+    .describe(cairoCommonDescriptions.royaltyInfo),
+  appName: z.string().optional().describe(cairoCommonDescriptions.appName),
+  appVersion: z.string().optional().describe(cairoCommonDescriptions.appVersion),
+  ...commonSchema,
+} as const satisfies z.ZodRawShape;
+
+export const erc1155Schema = {
+  name: z.string().describe(commonDescriptions.name),
+  baseUri: z.string().describe(cairoERC1155Descriptions.baseUri),
+  burnable: z.boolean().optional().describe(commonDescriptions.burnable),
+  pausable: z.boolean().optional().describe(commonDescriptions.pausable),
+  mintable: z.boolean().optional().describe(commonDescriptions.mintable),
+  updatableUri: z.boolean().optional().describe(cairoERC1155Descriptions.updatableUri),
+  royaltyInfo: z
+    .object({
+      enabled: z.boolean().describe(cairoRoyaltyInfoDescriptions.enabled),
+      defaultRoyaltyFraction: z.string().describe(cairoRoyaltyInfoDescriptions.defaultRoyaltyFraction),
+      feeDenominator: z.string().describe(cairoRoyaltyInfoDescriptions.feeDenominator),
+    })
+    .optional()
+    .describe(cairoCommonDescriptions.royaltyInfo),
+  ...commonSchema,
+} as const satisfies z.ZodRawShape;
+
+export const accountSchema = {
+  name: z.string().describe(commonDescriptions.name),
+  type: z.enum(['stark', 'eth']).describe(cairoAccountDescriptions.type),
+  declare: z.boolean().optional().describe(cairoAccountDescriptions.declare),
+  deploy: z.boolean().optional().describe(cairoAccountDescriptions.deploy),
+  pubkey: z.boolean().optional().describe(cairoAccountDescriptions.pubkey),
+  outsideExecution: z.boolean().optional().describe(cairoAccountDescriptions.outsideExecution),
+  upgradeable: commonSchema.upgradeable,
+  info: commonSchema.info,
+} as const satisfies z.ZodRawShape;
+
+export const multisigSchema = {
+  name: z.string().describe(commonDescriptions.name),
+  quorum: z.string().describe(cairoMultisigDescriptions.quorum),
+  upgradeable: commonSchema.upgradeable,
+  info: commonSchema.info,
+} as const satisfies z.ZodRawShape;
+
+export const governorSchema = {
+  name: z.string().describe(commonDescriptions.name),
+  delay: z.string().describe(cairoGovernorDescriptions.delay),
+  period: z.string().describe(cairoGovernorDescriptions.period),
+  votes: z.enum(['erc20votes', 'erc721votes']).optional().describe(cairoGovernorDescriptions.votes),
+  clockMode: z.enum(['timestamp']).optional().describe(cairoGovernorDescriptions.clockMode),
+  timelock: z
+    .union([z.literal(false), z.literal('openzeppelin')])
+    .optional()
+    .describe(cairoGovernorDescriptions.timelock),
+  decimals: z.number().optional().describe(cairoGovernorDescriptions.decimals),
+  proposalThreshold: z.string().optional().describe(cairoGovernorDescriptions.proposalThreshold),
+  quorumMode: z.enum(['percent', 'absolute']).optional().describe(cairoGovernorDescriptions.quorumMode),
+  quorumPercent: z.number().optional().describe(cairoGovernorDescriptions.quorumPercent),
+  quorumAbsolute: z.string().optional().describe(cairoGovernorDescriptions.quorumAbsolute),
+  settings: z.boolean().optional().describe(cairoGovernorDescriptions.settings),
+  upgradeable: commonSchema.upgradeable,
+  appName: z.string().optional().describe(cairoCommonDescriptions.appName),
+  appVersion: z.string().optional().describe(cairoCommonDescriptions.appVersion),
+  info: commonSchema.info,
+} as const satisfies z.ZodRawShape;
+
+export const vestingSchema = {
+  name: z.string().describe(commonDescriptions.name),
+  startDate: z.string().describe(cairoVestingDescriptions.startDate),
+  duration: z.string().describe(cairoVestingDescriptions.duration),
+  cliffDuration: z.string().describe(cairoVestingDescriptions.cliffDuration),
+  schedule: z.enum(['linear', 'custom']).describe(cairoVestingDescriptions.schedule),
+  info: commonSchema.info,
+} as const satisfies z.ZodRawShape;
+
+export const customSchema = {
+  name: z.string().describe(commonDescriptions.name),
+  pausable: z.boolean().optional().describe(commonDescriptions.pausable),
+  ...commonSchema,
+} as const satisfies z.ZodRawShape;

package/src/cairo/tools/account.ts

@@ -0,0 +1,34 @@
+import type { McpServer, RegisteredTool } from '@modelcontextprotocol/sdk/server/mcp.js';
+import type { AccountOptions } from '@openzeppelin/wizard-cairo';
+import { account } from '@openzeppelin/wizard-cairo';
+import { safePrintCairoCodeBlock, makeDetailedPrompt } from '../../utils';
+import { accountSchema } from '../schemas';
+import { cairoPrompts } from '@openzeppelin/wizard-common';
+
+export function registerCairoAccount(server: McpServer): RegisteredTool {
+  return server.tool(
+    'cairo-account',
+    makeDetailedPrompt(cairoPrompts.Account),
+    accountSchema,
+    async ({ name, type, declare, deploy, pubkey, outsideExecution, upgradeable, info }) => {
+      const opts: AccountOptions = {
+        name,
+        type,
+        declare,
+        deploy,
+        pubkey,
+        outsideExecution,
+        upgradeable,
+        info,
+      };
+      return {
+        content: [
+          {
+            type: 'text',
+            text: safePrintCairoCodeBlock(() => account.print(opts)),
+          },
+        ],
+      };
+    },
+  );
+}

package/src/cairo/tools/custom.ts

@@ -0,0 +1,31 @@
+import type { McpServer, RegisteredTool } from '@modelcontextprotocol/sdk/server/mcp.js';
+import type { CustomOptions } from '@openzeppelin/wizard-cairo';
+import { custom } from '@openzeppelin/wizard-cairo';
+import { safePrintCairoCodeBlock, makeDetailedPrompt } from '../../utils';
+import { customSchema } from '../schemas';
+import { cairoPrompts } from '@openzeppelin/wizard-common';
+
+export function registerCairoCustom(server: McpServer): RegisteredTool {
+  return server.tool(
+    'cairo-custom',
+    makeDetailedPrompt(cairoPrompts.Custom),
+    customSchema,
+    async ({ name, pausable, access, upgradeable, info }) => {
+      const opts: CustomOptions = {
+        name,
+        pausable,
+        access,
+        upgradeable,
+        info,
+      };
+      return {
+        content: [
+          {
+            type: 'text',
+            text: safePrintCairoCodeBlock(() => custom.print(opts)),
+          },
+        ],
+      };
+    },
+  );
+}

package/src/cairo/tools/erc1155.ts

@@ -0,0 +1,36 @@
+import type { McpServer, RegisteredTool } from '@modelcontextprotocol/sdk/server/mcp.js';
+import type { ERC1155Options } from '@openzeppelin/wizard-cairo';
+import { erc1155 } from '@openzeppelin/wizard-cairo';
+import { safePrintCairoCodeBlock, makeDetailedPrompt } from '../../utils';
+import { erc1155Schema } from '../schemas';
+import { cairoPrompts } from '@openzeppelin/wizard-common';
+
+export function registerCairoERC1155(server: McpServer): RegisteredTool {
+  return server.tool(
+    'cairo-erc1155',
+    makeDetailedPrompt(cairoPrompts.ERC1155),
+    erc1155Schema,
+    async ({ name, baseUri, burnable, pausable, mintable, updatableUri, royaltyInfo, access, upgradeable, info }) => {
+      const opts: ERC1155Options = {
+        name,
+        baseUri,
+        burnable,
+        pausable,
+        mintable,
+        updatableUri,
+        royaltyInfo,
+        access,
+        upgradeable,
+        info,
+      };
+      return {
+        content: [
+          {
+            type: 'text',
+            text: safePrintCairoCodeBlock(() => erc1155.print(opts)),
+          },
+        ],
+      };
+    },
+  );
+}

package/src/cairo/tools/erc20.ts

@@ -0,0 +1,51 @@
+import type { McpServer, RegisteredTool } from '@modelcontextprotocol/sdk/server/mcp.js';
+import type { ERC20Options } from '@openzeppelin/wizard-cairo';
+import { erc20 } from '@openzeppelin/wizard-cairo';
+import { safePrintCairoCodeBlock, makeDetailedPrompt } from '../../utils';
+import { erc20Schema } from '../schemas';
+import { cairoPrompts } from '@openzeppelin/wizard-common';
+
+export function registerCairoERC20(server: McpServer): RegisteredTool {
+  return server.tool(
+    'cairo-erc20',
+    makeDetailedPrompt(cairoPrompts.ERC20),
+    erc20Schema,
+    async ({
+      name,
+      symbol,
+      burnable,
+      pausable,
+      premint,
+      mintable,
+      votes,
+      appName,
+      appVersion,
+      access,
+      upgradeable,
+      info,
+    }) => {
+      const opts: ERC20Options = {
+        name,
+        symbol,
+        burnable,
+        pausable,
+        premint,
+        mintable,
+        votes,
+        appName,
+        appVersion,
+        access,
+        upgradeable,
+        info,
+      };
+      return {
+        content: [
+          {
+            type: 'text',
+            text: safePrintCairoCodeBlock(() => erc20.print(opts)),
+          },
+        ],
+      };
+    },
+  );
+}

package/src/cairo/tools/erc721.ts

@@ -0,0 +1,55 @@
+import type { McpServer, RegisteredTool } from '@modelcontextprotocol/sdk/server/mcp.js';
+import type { ERC721Options } from '@openzeppelin/wizard-cairo';
+import { erc721 } from '@openzeppelin/wizard-cairo';
+import { safePrintCairoCodeBlock, makeDetailedPrompt } from '../../utils';
+import { erc721Schema } from '../schemas';
+import { cairoPrompts } from '@openzeppelin/wizard-common';
+
+export function registerCairoERC721(server: McpServer): RegisteredTool {
+  return server.tool(
+    'cairo-erc721',
+    makeDetailedPrompt(cairoPrompts.ERC721),
+    erc721Schema,
+    async ({
+      name,
+      symbol,
+      baseUri,
+      burnable,
+      pausable,
+      mintable,
+      enumerable,
+      votes,
+      royaltyInfo,
+      appName,
+      appVersion,
+      access,
+      upgradeable,
+      info,
+    }) => {
+      const opts: ERC721Options = {
+        name,
+        symbol,
+        baseUri,
+        burnable,
+        pausable,
+        mintable,
+        enumerable,
+        votes,
+        royaltyInfo,
+        appName,
+        appVersion,
+        access,
+        upgradeable,
+        info,
+      };
+      return {
+        content: [
+          {
+            type: 'text',
+            text: safePrintCairoCodeBlock(() => erc721.print(opts)),
+          },
+        ],
+      };
+    },
+  );
+}

package/src/cairo/tools/governor.ts

@@ -0,0 +1,59 @@
+import type { McpServer, RegisteredTool } from '@modelcontextprotocol/sdk/server/mcp.js';
+import type { GovernorOptions } from '@openzeppelin/wizard-cairo';
+import { governor } from '@openzeppelin/wizard-cairo';
+import { safePrintCairoCodeBlock, makeDetailedPrompt } from '../../utils';
+import { governorSchema } from '../schemas';
+import { cairoPrompts } from '@openzeppelin/wizard-common';
+
+export function registerCairoGovernor(server: McpServer): RegisteredTool {
+  return server.tool(
+    'cairo-governor',
+    makeDetailedPrompt(cairoPrompts.Governor),
+    governorSchema,
+    async ({
+      name,
+      delay,
+      period,
+      votes,
+      clockMode,
+      timelock,
+      decimals,
+      proposalThreshold,
+      quorumMode,
+      quorumPercent,
+      quorumAbsolute,
+      settings,
+      upgradeable,
+      appName,
+      appVersion,
+      info,
+    }) => {
+      const opts: GovernorOptions = {
+        name,
+        delay,
+        period,
+        votes,
+        clockMode,
+        timelock,
+        decimals,
+        proposalThreshold,
+        quorumMode,
+        quorumPercent,
+        quorumAbsolute,
+        settings,
+        upgradeable,
+        appName,
+        appVersion,
+        info,
+      };
+      return {
+        content: [
+          {
+            type: 'text',
+            text: safePrintCairoCodeBlock(() => governor.print(opts)),
+          },
+        ],
+      };
+    },
+  );
+}

package/src/cairo/tools/multisig.ts

@@ -0,0 +1,30 @@
+import type { McpServer, RegisteredTool } from '@modelcontextprotocol/sdk/server/mcp.js';
+import type { MultisigOptions } from '@openzeppelin/wizard-cairo';
+import { multisig } from '@openzeppelin/wizard-cairo';
+import { safePrintCairoCodeBlock, makeDetailedPrompt } from '../../utils';
+import { multisigSchema } from '../schemas';
+import { cairoPrompts } from '@openzeppelin/wizard-common';
+
+export function registerCairoMultisig(server: McpServer): RegisteredTool {
+  return server.tool(
+    'cairo-multisig',
+    makeDetailedPrompt(cairoPrompts.Multisig),
+    multisigSchema,
+    async ({ name, quorum, upgradeable, info }) => {
+      const opts: MultisigOptions = {
+        name,
+        quorum,
+        upgradeable,
+        info,
+      };
+      return {
+        content: [
+          {
+            type: 'text',
+            text: safePrintCairoCodeBlock(() => multisig.print(opts)),
+          },
+        ],
+      };
+    },
+  );
+}

package/src/cairo/tools/vesting.ts

@@ -0,0 +1,32 @@
+import type { McpServer, RegisteredTool } from '@modelcontextprotocol/sdk/server/mcp.js';
+import type { VestingOptions } from '@openzeppelin/wizard-cairo';
+import { vesting } from '@openzeppelin/wizard-cairo';
+import { safePrintCairoCodeBlock, makeDetailedPrompt } from '../../utils';
+import { vestingSchema } from '../schemas';
+import { cairoPrompts } from '@openzeppelin/wizard-common';
+
+export function registerCairoVesting(server: McpServer): RegisteredTool {
+  return server.tool(
+    'cairo-vesting',
+    makeDetailedPrompt(cairoPrompts.Vesting),
+    vestingSchema,
+    async ({ name, startDate, duration, cliffDuration, schedule, info }) => {
+      const opts: VestingOptions = {
+        name,
+        startDate,
+        duration,
+        cliffDuration,
+        schedule,
+        info,
+      };
+      return {
+        content: [
+          {
+            type: 'text',
+            text: safePrintCairoCodeBlock(() => vesting.print(opts)),
+          },
+        ],
+      };
+    },
+  );
+}

package/src/cairo/tools.ts

@@ -0,0 +1,34 @@
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { registerCairoAccount } from './tools/account.js';
+import { registerCairoCustom } from './tools/custom.js';
+import { registerCairoERC20 } from './tools/erc20.js';
+import { registerCairoERC721 } from './tools/erc721.js';
+import { registerCairoERC1155 } from './tools/erc1155.js';
+import { registerCairoGovernor } from './tools/governor.js';
+import { registerCairoMultisig } from './tools/multisig.js';
+import { registerCairoVesting } from './tools/vesting.js';
+import type { KindedOptions } from '@openzeppelin/wizard-cairo';
+import type { RegisteredTool } from '@modelcontextprotocol/sdk/server/mcp.js';
+
+type CairoToolRegisterFunctions = {
+  [kind in keyof KindedOptions]: (server: McpServer) => RegisteredTool;
+};
+
+function getRegisterFunctions(server: McpServer): CairoToolRegisterFunctions {
+  return {
+    ERC20: () => registerCairoERC20(server),
+    ERC721: () => registerCairoERC721(server),
+    ERC1155: () => registerCairoERC1155(server),
+    Account: () => registerCairoAccount(server),
+    Multisig: () => registerCairoMultisig(server),
+    Governor: () => registerCairoGovernor(server),
+    Vesting: () => registerCairoVesting(server),
+    Custom: () => registerCairoCustom(server),
+  };
+}
+
+export function registerCairoTools(server: McpServer) {
+  Object.values(getRegisterFunctions(server)).forEach(registerTool => {
+    registerTool(server);
+  });
+}

package/src/index.ts

@@ -0,0 +1,11 @@
+#!/usr/bin/env node
+
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { createServer } from './server';
+
+// Start receiving messages on stdin and sending messages on stdout
+const transport = new StdioServerTransport();
+(async () => {
+  const server = createServer();
+  await server.connect(transport);
+})();

package/src/server.ts

@@ -0,0 +1,30 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { registerSolidityTools } from './solidity/tools.js';
+import { registerCairoTools } from './cairo/tools.js';
+import { registerStellarTools } from './stellar/tools.js';
+import { registerStylusTools } from './stylus/tools.js';
+import { version } from '../package.json';
+
+export function createServer() {
+  const server = new McpServer(
+    {
+      name: 'OpenZeppelin Contracts Wizard',
+      version,
+    },
+    {
+      instructions: `\
+Tools are provided for different smart contract languages: Solidity, Starknet's Cairo, Stellar Soroban, and Arbitrum Stylus.
+Each tool generates a smart contract using recommended best practices with OpenZeppelin Contracts libraries, and returns the source code. The tools do not write to disk.
+If the user requests to create a new smart contract, use the appropriate tool to generate the contract.
+If the user asks to modify an existing smart contract, use these tools to determine the recommended patterns. Toggle the options in a tool to determine how different features affect the code, then apply the same types of changes to the user's contract.
+`,
+    },
+  );
+
+  registerSolidityTools(server);
+  registerCairoTools(server);
+  registerStellarTools(server);
+  registerStylusTools(server);
+
+  return server;
+}