@openzeppelin/contracts-mcp 0.0.5

package/src/solidity/schemas.ts

@@ -0,0 +1,180 @@
+import { z } from 'zod';
+import {
+  commonDescriptions,
+  infoDescriptions,
+  solidityCommonDescriptions,
+  solidityERC20Descriptions,
+  solidityERC721Descriptions,
+  solidityERC1155Descriptions,
+  solidityGovernorDescriptions,
+  solidityAccountDescriptions,
+  solidityStablecoinDescriptions,
+} from '@openzeppelin/wizard-common';
+import type { KindedOptions } from '@openzeppelin/wizard';
+
+/**
+ * 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({}),
+    Stablecoin: z.object(stablecoinSchema).parse({}),
+    RealWorldAsset: z.object(rwaSchema).parse({}),
+    Account: z.object(accountSchema).parse({}),
+    Governor: z.object(governorSchema).parse({}),
+    Custom: z.object(customSchema).parse({}),
+  };
+}
+
+export const commonSchema = {
+  access: z
+    .literal('ownable')
+    .or(z.literal('roles'))
+    .or(z.literal('managed'))
+    .optional()
+    .describe(solidityCommonDescriptions.access),
+  upgradeable: z
+    .literal('transparent')
+    .or(z.literal('uups'))
+    .optional()
+    .describe(solidityCommonDescriptions.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(solidityERC20Descriptions.premint),
+  premintChainId: z.string().optional().describe(solidityERC20Descriptions.premintChainId),
+  mintable: z.boolean().optional().describe(commonDescriptions.mintable),
+  callback: z.boolean().optional().describe(solidityERC20Descriptions.callback),
+  permit: z.boolean().optional().describe(solidityERC20Descriptions.permit),
+  votes: z.literal('blocknumber').or(z.literal('timestamp')).optional().describe(solidityERC20Descriptions.votes),
+  flashmint: z.boolean().optional().describe(solidityERC20Descriptions.flashmint),
+  crossChainBridging: z
+    .literal('custom')
+    .or(z.literal('superchain'))
+    .optional()
+    .describe(solidityERC20Descriptions.crossChainBridging),
+  ...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(solidityERC721Descriptions.baseUri),
+  enumerable: z.boolean().optional().describe(solidityERC721Descriptions.enumerable),
+  uriStorage: z.boolean().optional().describe(solidityERC721Descriptions.uriStorage),
+  burnable: z.boolean().optional().describe(commonDescriptions.burnable),
+  pausable: z.boolean().optional().describe(commonDescriptions.pausable),
+  mintable: z.boolean().optional().describe(commonDescriptions.mintable),
+  incremental: z.boolean().optional().describe(solidityERC721Descriptions.incremental),
+  votes: z.literal('blocknumber').or(z.literal('timestamp')).optional().describe(solidityERC721Descriptions.votes),
+  ...commonSchema,
+} as const satisfies z.ZodRawShape;
+
+export const erc1155Schema = {
+  name: z.string().describe(commonDescriptions.name),
+  uri: z.string().describe(solidityERC1155Descriptions.uri),
+  burnable: z.boolean().optional().describe(commonDescriptions.burnable),
+  pausable: z.boolean().optional().describe(commonDescriptions.pausable),
+  mintable: z.boolean().optional().describe(commonDescriptions.mintable),
+  supply: z.boolean().optional().describe(solidityERC1155Descriptions.supply),
+  updatableUri: z.boolean().optional().describe(solidityERC1155Descriptions.updatableUri),
+  ...commonSchema,
+} as const satisfies z.ZodRawShape;
+
+const { upgradeable: _, ...erc20SchemaOmitUpgradeable } = erc20Schema;
+
+export const stablecoinSchema = {
+  ...erc20SchemaOmitUpgradeable,
+  limitations: z
+    .literal(false)
+    .or(z.literal('allowlist'))
+    .or(z.literal('blocklist'))
+    .optional()
+    .describe(solidityStablecoinDescriptions.limitations),
+  custodian: z.boolean().optional().describe(solidityStablecoinDescriptions.custodian),
+} as const satisfies z.ZodRawShape;
+
+export const rwaSchema = stablecoinSchema;
+
+export const accountSchema = {
+  name: z.string().describe('The name of the account contract'),
+  signatureValidation: z
+    .literal(false)
+    .or(z.literal('ERC1271'))
+    .or(z.literal('ERC7739'))
+    .optional()
+    .describe(solidityAccountDescriptions.signatureValidation),
+  ERC721Holder: z.boolean().optional().describe(solidityAccountDescriptions.ERC721Holder),
+  ERC1155Holder: z.boolean().optional().describe(solidityAccountDescriptions.ERC1155Holder),
+  signer: z
+    .literal(false)
+    .or(z.literal('ERC7702'))
+    .or(z.literal('ECDSA'))
+    .or(z.literal('P256'))
+    .or(z.literal('RSA'))
+    .or(z.literal('Multisig'))
+    .or(z.literal('MultisigWeighted'))
+    .optional()
+    .describe(solidityAccountDescriptions.signer),
+  batchedExecution: z.boolean().optional().describe(solidityAccountDescriptions.batchedExecution),
+  ERC7579Modules: z
+    .literal(false)
+    .or(z.literal('AccountERC7579'))
+    .or(z.literal('AccountERC7579Hooked'))
+    .optional()
+    .describe(solidityAccountDescriptions.ERC7579Modules),
+  info: commonSchema.info,
+} as const satisfies z.ZodRawShape;
+
+export const governorSchema = {
+  name: z.string().describe(commonDescriptions.name),
+  delay: z.string().describe(solidityGovernorDescriptions.delay),
+  period: z.string().describe(solidityGovernorDescriptions.period),
+  votes: z.literal('erc20votes').or(z.literal('erc721votes')).optional().describe(solidityGovernorDescriptions.votes),
+  clockMode: z
+    .literal('blocknumber')
+    .or(z.literal('timestamp'))
+    .optional()
+    .describe(solidityGovernorDescriptions.clockMode),
+  timelock: z
+    .literal(false)
+    .or(z.literal('openzeppelin'))
+    .or(z.literal('compound'))
+    .optional()
+    .describe(solidityGovernorDescriptions.timelock),
+  blockTime: z.number().optional().describe(solidityGovernorDescriptions.blockTime),
+  decimals: z.number().optional().describe(solidityGovernorDescriptions.decimals),
+  proposalThreshold: z.string().optional().describe(solidityGovernorDescriptions.proposalThreshold),
+  quorumMode: z
+    .literal('percent')
+    .or(z.literal('absolute'))
+    .optional()
+    .describe(solidityGovernorDescriptions.quorumMode),
+  quorumPercent: z.number().optional().describe(solidityGovernorDescriptions.quorumPercent),
+  quorumAbsolute: z.string().optional().describe(solidityGovernorDescriptions.quorumAbsolute),
+  storage: z.boolean().optional().describe(solidityGovernorDescriptions.storage),
+  settings: z.boolean().optional().describe(solidityGovernorDescriptions.settings),
+  upgradeable: commonSchema.upgradeable,
+  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/solidity/tools/account.ts

@@ -0,0 +1,43 @@
+import type { McpServer, RegisteredTool } from '@modelcontextprotocol/sdk/server/mcp.js';
+import type { AccountOptions } from '@openzeppelin/wizard';
+import { account } from '@openzeppelin/wizard';
+import { safePrintSolidityCodeBlock, makeDetailedPrompt } from '../../utils';
+import { accountSchema } from '../schemas';
+import { solidityPrompts } from '@openzeppelin/wizard-common';
+
+export function registerSolidityAccount(server: McpServer): RegisteredTool {
+  return server.tool(
+    'solidity-account',
+    makeDetailedPrompt(solidityPrompts.Account),
+    accountSchema,
+    async ({
+      name,
+      signatureValidation,
+      ERC721Holder,
+      ERC1155Holder,
+      signer,
+      batchedExecution,
+      ERC7579Modules,
+      info,
+    }) => {
+      const opts: AccountOptions = {
+        name,
+        signatureValidation,
+        ERC721Holder,
+        ERC1155Holder,
+        signer,
+        batchedExecution,
+        ERC7579Modules,
+        info,
+      };
+      return {
+        content: [
+          {
+            type: 'text',
+            text: safePrintSolidityCodeBlock(() => account.print(opts)),
+          },
+        ],
+      };
+    },
+  );
+}

package/src/solidity/tools/custom.ts

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

package/src/solidity/tools/erc1155.ts

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

package/src/solidity/tools/erc20.ts

@@ -0,0 +1,57 @@
+import type { McpServer, RegisteredTool } from '@modelcontextprotocol/sdk/server/mcp.js';
+import type { ERC20Options } from '@openzeppelin/wizard';
+import { erc20 } from '@openzeppelin/wizard';
+import { safePrintSolidityCodeBlock, makeDetailedPrompt } from '../../utils';
+import { erc20Schema } from '../schemas';
+import { solidityPrompts } from '@openzeppelin/wizard-common';
+
+export function registerSolidityERC20(server: McpServer): RegisteredTool {
+  return server.tool(
+    'solidity-erc20',
+    makeDetailedPrompt(solidityPrompts.ERC20),
+    erc20Schema,
+    async ({
+      name,
+      symbol,
+      burnable,
+      pausable,
+      premint,
+      premintChainId,
+      mintable,
+      callback,
+      permit,
+      votes,
+      flashmint,
+      crossChainBridging,
+      access,
+      upgradeable,
+      info,
+    }) => {
+      const opts: ERC20Options = {
+        name,
+        symbol,
+        burnable,
+        pausable,
+        premint,
+        premintChainId,
+        mintable,
+        callback,
+        permit,
+        votes,
+        flashmint,
+        crossChainBridging,
+        access,
+        upgradeable,
+        info,
+      };
+      return {
+        content: [
+          {
+            type: 'text',
+            text: safePrintSolidityCodeBlock(() => erc20.print(opts)),
+          },
+        ],
+      };
+    },
+  );
+}

package/src/solidity/tools/erc721.ts

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

package/src/solidity/tools/governor.ts

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

package/src/solidity/tools/rwa.ts

@@ -0,0 +1,59 @@
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import type { StablecoinOptions } from '@openzeppelin/wizard';
+import { realWorldAsset } from '@openzeppelin/wizard';
+import { safePrintSolidityCodeBlock, makeDetailedPrompt } from '../../utils';
+import { rwaSchema } from '../schemas';
+import { solidityPrompts } from '@openzeppelin/wizard-common';
+
+export function registerSolidityRWA(server: McpServer) {
+  return server.tool(
+    'solidity-rwa',
+    makeDetailedPrompt(solidityPrompts.RWA),
+    rwaSchema,
+    async ({
+      name,
+      symbol,
+      burnable,
+      pausable,
+      premint,
+      premintChainId,
+      mintable,
+      callback,
+      permit,
+      votes,
+      flashmint,
+      crossChainBridging,
+      access,
+      info,
+      limitations,
+      custodian,
+    }) => {
+      const opts: StablecoinOptions = {
+        name,
+        symbol,
+        burnable,
+        pausable,
+        premint,
+        premintChainId,
+        mintable,
+        callback,
+        permit,
+        votes,
+        flashmint,
+        crossChainBridging,
+        access,
+        info,
+        limitations,
+        custodian,
+      };
+      return {
+        content: [
+          {
+            type: 'text',
+            text: safePrintSolidityCodeBlock(() => realWorldAsset.print(opts)),
+          },
+        ],
+      };
+    },
+  );
+}

package/src/solidity/tools/stablecoin.ts

@@ -0,0 +1,59 @@
+import type { McpServer, RegisteredTool } from '@modelcontextprotocol/sdk/server/mcp.js';
+import type { StablecoinOptions } from '@openzeppelin/wizard';
+import { stablecoin } from '@openzeppelin/wizard';
+import { safePrintSolidityCodeBlock, makeDetailedPrompt } from '../../utils';
+import { stablecoinSchema } from '../schemas';
+import { solidityPrompts } from '@openzeppelin/wizard-common';
+
+export function registerSolidityStablecoin(server: McpServer): RegisteredTool {
+  return server.tool(
+    'solidity-stablecoin',
+    makeDetailedPrompt(solidityPrompts.Stablecoin),
+    stablecoinSchema,
+    async ({
+      name,
+      symbol,
+      burnable,
+      pausable,
+      premint,
+      premintChainId,
+      mintable,
+      callback,
+      permit,
+      votes,
+      flashmint,
+      crossChainBridging,
+      access,
+      info,
+      limitations,
+      custodian,
+    }) => {
+      const opts: StablecoinOptions = {
+        name,
+        symbol,
+        burnable,
+        pausable,
+        premint,
+        premintChainId,
+        mintable,
+        callback,
+        permit,
+        votes,
+        flashmint,
+        crossChainBridging,
+        access,
+        info,
+        limitations,
+        custodian,
+      };
+      return {
+        content: [
+          {
+            type: 'text',
+            text: safePrintSolidityCodeBlock(() => stablecoin.print(opts)),
+          },
+        ],
+      };
+    },
+  );
+}

package/src/solidity/tools.ts

@@ -0,0 +1,34 @@
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { registerSolidityAccount } from './tools/account.js';
+import { registerSolidityCustom } from './tools/custom.js';
+import { registerSolidityERC20 } from './tools/erc20.js';
+import { registerSolidityERC721 } from './tools/erc721.js';
+import { registerSolidityERC1155 } from './tools/erc1155.js';
+import { registerSolidityGovernor } from './tools/governor.js';
+import { registerSolidityStablecoin } from './tools/stablecoin.js';
+import { registerSolidityRWA } from './tools/rwa.js';
+import type { KindedOptions } from '@openzeppelin/wizard';
+import type { RegisteredTool } from '@modelcontextprotocol/sdk/server/mcp.js';
+
+type SolidityToolRegisterFunctions = {
+  [kind in keyof KindedOptions]: (server: McpServer) => RegisteredTool;
+};
+
+function getRegisterFunctions(server: McpServer): SolidityToolRegisterFunctions {
+  return {
+    ERC20: () => registerSolidityERC20(server),
+    ERC721: () => registerSolidityERC721(server),
+    ERC1155: () => registerSolidityERC1155(server),
+    Stablecoin: () => registerSolidityStablecoin(server),
+    RealWorldAsset: () => registerSolidityRWA(server),
+    Account: () => registerSolidityAccount(server),
+    Governor: () => registerSolidityGovernor(server),
+    Custom: () => registerSolidityCustom(server),
+  };
+}
+
+export function registerSolidityTools(server: McpServer) {
+  Object.values(getRegisterFunctions(server)).forEach(registerTool => {
+    registerTool(server);
+  });
+}

package/src/stellar/schemas.ts

@@ -0,0 +1,67 @@
+import { z } from 'zod';
+import {
+  commonDescriptions,
+  infoDescriptions,
+  stellarCommonDescriptions,
+  stellarFungibleDescriptions,
+  stellarNonFungibleDescriptions,
+  stellarStablecoinDescriptions,
+} from '@openzeppelin/wizard-common';
+import type { KindedOptions } from '@openzeppelin/wizard-stellar';
+
+/**
+ * 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'>;
+  } = {
+    Fungible: z.object(fungibleSchema).parse({}),
+    Stablecoin: z.object(stablecoinSchema).parse({}),
+    NonFungible: z.object(nonFungibleSchema).parse({}),
+  };
+}
+
+export const commonSchema = {
+  access: z.literal('ownable').or(z.literal('roles')).optional().describe(stellarCommonDescriptions.access),
+  upgradeable: z.boolean().optional().describe(stellarCommonDescriptions.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 fungibleSchema = {
+  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(stellarFungibleDescriptions.premint),
+  mintable: z.boolean().optional().describe(commonDescriptions.mintable),
+  ...commonSchema,
+} as const satisfies z.ZodRawShape;
+
+export const stablecoinSchema = {
+  ...fungibleSchema,
+  limitations: z
+    .literal(false)
+    .or(z.literal('allowlist'))
+    .or(z.literal('blocklist'))
+    .optional()
+    .describe(stellarStablecoinDescriptions.limitations),
+} as const satisfies z.ZodRawShape;
+
+export const nonFungibleSchema = {
+  name: z.string().describe(commonDescriptions.name),
+  symbol: z.string().describe(commonDescriptions.symbol),
+  burnable: z.boolean().optional().describe(commonDescriptions.burnable),
+  enumerable: z.boolean().optional().describe(stellarNonFungibleDescriptions.enumerable),
+  consecutive: z.boolean().optional().describe(stellarNonFungibleDescriptions.consecutive),
+  pausable: z.boolean().optional().describe(commonDescriptions.pausable),
+  mintable: z.boolean().optional().describe(commonDescriptions.mintable),
+  sequential: z.boolean().optional().describe(stellarNonFungibleDescriptions.sequential),
+  ...commonSchema,
+} as const satisfies z.ZodRawShape;