@secondlayer/cli 8.14.3 → 9.0.0

package/dist/plugins/index.d.ts

@@ -287,6 +287,11 @@ interface ClarinetPluginOptions {
 	include?: string[];
 	/** Exclude specific contracts */
 	exclude?: string[];
+	/**
+	* Also generate interfaces for dependency contracts declared under
+	* `[project.requirements]` in Clarinet.toml (default: true).
+	*/
+	includeRequirements?: boolean;
 	/** Enable debug output */
 	debug?: boolean;
 }
@@ -298,24 +303,6 @@ declare const clarinet: PluginFactory<ClarinetPluginOptions>;
 * Utility function to check if a Clarinet project exists
 */
 declare function hasClarinetProject(path?: string): Promise<boolean>;
-interface ActionsPluginOptions {
-	/** Include only specific contracts */
-	include?: string[];
-	/** Exclude specific contracts */
-	exclude?: string[];
-	/** Include only specific functions */
-	includeFunctions?: string[];
-	/** Exclude specific functions */
-	excludeFunctions?: string[];
-	/** Enable debug output */
-	debug?: boolean;
-	/** Environment variable name for default sender key (default: "STX_SENDER_KEY") */
-	senderKeyEnv?: string;
-}
-/**
-* Actions plugin factory
-*/
-declare const actions: PluginFactory<ActionsPluginOptions>;
 /**
 * React plugin configuration options
 */
@@ -361,4 +348,4 @@ declare function filterByOptions<T extends {
 * Utility function to create a simple plugin
 */
 declare function createPlugin(name: string, version: string, implementation: Partial<SecondLayerPlugin>): SecondLayerPlugin;
-export { testing, react, hasClarinetProject, filterByOptions, createPlugin, clarinet, actions, TestingPluginOptions, SecondLayerPlugin, ReactPluginOptions, PluginUtils, PluginOptions, PluginManager, PluginFactory, PluginContext, Logger, GenerateContext, ClarinetPluginOptions, BasePluginOptions, ActionsPluginOptions };
+export { testing, react, hasClarinetProject, filterByOptions, createPlugin, clarinet, TestingPluginOptions, SecondLayerPlugin, ReactPluginOptions, PluginUtils, PluginOptions, PluginManager, PluginFactory, PluginContext, Logger, GenerateContext, ClarinetPluginOptions, BasePluginOptions };

package/dist/plugins/index.js

@@ -576,22 +576,38 @@ function matchesContractFilters(name, options) {
 function sanitizeContractName(name) {
   return toCamelCase2(name);
 }
-async function isUserDefinedContract(contractId, manifestPath) {
-  const { address, contractName } = parseContractId(contractId);
+async function readManifestInfo(manifestPath) {
   try {
     const { promises: fs2 } = await import("node:fs");
     const tomlContent = await fs2.readFile(manifestPath, "utf-8");
+    const projectContracts = new Set;
     const contractSectionRegex = /^\[contracts\.([^\]]+)\]/gm;
-    const userContracts = new Set;
     let match = contractSectionRegex.exec(tomlContent);
     while (match !== null) {
-      userContracts.add(match[1]);
+      projectContracts.add(match[1]);
       match = contractSectionRegex.exec(tomlContent);
     }
-    if (userContracts.has(contractName)) {
-      return true;
+    const requirementIds = new Set;
+    const requirementRegex = /contract_id\s*=\s*["']([^"']+)["']/g;
+    match = requirementRegex.exec(tomlContent);
+    while (match !== null) {
+      requirementIds.add(match[1]);
+      match = requirementRegex.exec(tomlContent);
     }
-  } catch {}
+    return { projectContracts, requirementIds };
+  } catch {
+    return null;
+  }
+}
+function classifyContract(contractId, manifest) {
+  const { address, contractName } = parseContractId(contractId);
+  if (manifest) {
+    if (manifest.projectContracts.has(contractName))
+      return "project";
+    if (manifest.requirementIds.has(contractId))
+      return "requirement";
+    return "system";
+  }
   const systemContractPatterns = [
     /^pox-\d+$/,
     /^bns$/,
@@ -599,16 +615,16 @@ async function isUserDefinedContract(contractId, manifestPath) {
     /^lockup$/
   ];
   if (systemContractPatterns.some((pattern) => pattern.test(contractName))) {
-    return false;
+    return "system";
   }
   const systemAddresses = [
     DEFAULT_SENDER_ADDRESS,
     "ST000000000000000000002AMW42H"
   ];
   if (systemAddresses.includes(address)) {
-    return false;
+    return "system";
   }
-  return true;
+  return "project";
 }
 var clarinet = (options = {}) => {
   const manifestPath = options.path || "./Clarinet.toml";
@@ -621,11 +637,14 @@ var clarinet = (options = {}) => {
         simnet = await initSimnet(manifestPath);
         const contractInterfaces = simnet.getContractsInterfaces();
         const contracts = [];
+        const manifest = await readManifestInfo(manifestPath);
+        const includeRequirements = options.includeRequirements ?? true;
         for (const [contractId, abi] of contractInterfaces) {
           const { contractName } = parseContractId(contractId);
-          if (!await isUserDefinedContract(contractId, manifestPath)) {
+          const kind = classifyContract(contractId, manifest);
+          if (kind === "system" || kind === "requirement" && !includeRequirements) {
             if (options.debug) {
-              console.log(`\uD83D\uDEAB Skipping system contract: ${contractId}`);
+              console.log(`\uD83D\uDEAB Skipping ${kind} contract: ${contractId}`);
             }
             continue;
           }
@@ -683,208 +702,16 @@ async function hasClarinetProject(path2 = "./Clarinet.toml") {
     return false;
   }
 }
-// src/plugins/actions/generators.ts
-import { toCamelCase as toCamelCase3 } from "@secondlayer/stacks/clarity";
-
-// src/utils/generator-helpers.ts
-import {
-  generateArgsSignature,
-  generateClarityArgs,
-  generateMapKeyConversion
-} from "@secondlayer/scaffold";
-
-// src/plugins/actions/generators.ts
-function applyFunctionFilters(functions, options) {
-  return functions.filter((func) => {
-    if (options.includeFunctions && !options.includeFunctions.includes(func.name)) {
-      return false;
-    }
-    if (options.excludeFunctions?.includes(func.name)) {
-      return false;
-    }
-    return true;
-  });
-}
-function generateReadHelpers(contract, options) {
-  const { abi } = contract;
-  const functions = abi.functions || [];
-  const readOnlyFunctions = functions.filter((f) => f.access === "read-only");
-  if (readOnlyFunctions.length === 0) {
-    return "";
-  }
-  const filteredFunctions = applyFunctionFilters(readOnlyFunctions, options);
-  if (filteredFunctions.length === 0) {
-    return "";
-  }
-  const helpers = filteredFunctions.map((func) => {
-    const methodName = toCamelCase3(func.name);
-    const argsSignature = generateArgsSignature(func.args);
-    const clarityArgs = generateClarityArgs(func.args);
-    return `async ${methodName}(${argsSignature}options?: {
-      network?: 'mainnet' | 'testnet' | 'devnet';
-      senderAddress?: string;
-    }) {
-      return await fetchCallReadOnlyFunction({
-        contractAddress: '${contract.address}',
-        contractName: '${contract.contractName}',
-        functionName: '${func.name}',
-        functionArgs: [${clarityArgs}],
-        network: options?.network ?? inferNetworkFromAddress('${contract.address}') ?? 'mainnet',
-        senderAddress: options?.senderAddress || '${DEFAULT_SENDER_ADDRESS}'
-      });
-    }`;
-  });
-  return `read: {
-    ${helpers.join(`,
-
-    `)}
-  }`;
-}
-function generateWriteHelpers(contract, options) {
-  const { abi } = contract;
-  const functions = abi.functions || [];
-  const envVarName = options.senderKeyEnv ?? "STX_SENDER_KEY";
-  const publicFunctions = functions.filter((f) => f.access === "public");
-  if (publicFunctions.length === 0) {
-    return "";
-  }
-  const filteredFunctions = applyFunctionFilters(publicFunctions, options);
-  if (filteredFunctions.length === 0) {
-    return "";
-  }
-  const helpers = filteredFunctions.map((func) => {
-    const methodName = toCamelCase3(func.name);
-    const argsSignature = generateArgsSignature(func.args);
-    const clarityArgs = generateClarityArgs(func.args);
-    return `async ${methodName}(${argsSignature}senderKey?: string, options?: {
-      network?: 'mainnet' | 'testnet' | 'devnet';
-      fee?: string | number | undefined;
-      nonce?: bigint;
-      anchorMode?: 1 | 2 | 3; // AnchorMode: OnChainOnly = 1, OffChainOnly = 2, Any = 3
-      postConditions?: PostCondition[];
-      validateWithAbi?: boolean;
-    }) {
-      const resolvedSenderKey = senderKey ?? process.env.${envVarName};
-      if (!resolvedSenderKey) {
-        throw new Error('senderKey required: pass as argument or set ${envVarName} env var');
-      }
-      const { network = 'mainnet', ...txOptions } = options ?? {};
-
-      return await makeContractCall({
-        contractAddress: '${contract.address}',
-        contractName: '${contract.contractName}',
-        functionName: '${func.name}',
-        functionArgs: [${clarityArgs}],
-        senderKey: resolvedSenderKey,
-        network,
-        validateWithAbi: true,
-        ...txOptions
-      });
-    }`;
-  });
-  return `write: {
-    ${helpers.join(`,
-
-    `)}
-  }`;
-}
-async function generateActionHelpers(contract, options) {
-  const readHelpers = generateReadHelpers(contract, options);
-  const writeHelpers = generateWriteHelpers(contract, options);
-  if (!readHelpers && !writeHelpers) {
-    return "";
-  }
-  const helpers = [readHelpers, writeHelpers].filter(Boolean);
-  return helpers.join(`,
-
-`);
-}
-
-// src/plugins/actions/index.ts
-var actions = (options = {}) => {
-  return {
-    name: "@secondlayer/cli/plugin-actions",
-    version: "1.0.0",
-    async generate(context) {
-      const { contracts } = context;
-      const filteredContracts = contracts.filter((contract) => matchesContractFilters(contract.name, options));
-      if (filteredContracts.length === 0) {
-        if (options.debug) {
-          context.logger.debug("Actions plugin: No contracts to process");
-        }
-        return;
-      }
-      if (options.debug) {
-        context.logger.debug(`Actions plugin: Generating read/write helpers for ${filteredContracts.length} contracts`);
-      }
-      const contractHelpers = new Map;
-      for (const contract of filteredContracts) {
-        const actionsCode = await generateActionHelpers(contract, options);
-        if (actionsCode) {
-          contractHelpers.set(contract.name, actionsCode);
-        }
-      }
-      if (contractHelpers.size > 0) {
-        const existingOutput = context.outputs.get("contracts");
-        if (existingOutput) {
-          let modifiedContent = addRequiredImports(existingOutput.content);
-          for (const [contractName, helpersCode] of contractHelpers) {
-            modifiedContent = injectHelpersIntoContract(modifiedContent, contractName, helpersCode);
-          }
-          context.outputs.set("contracts", {
-            ...existingOutput,
-            content: modifiedContent
-          });
-        }
-      }
-    }
-  };
-};
-function addRequiredImports(content) {
-  const stacksImportRegex = /import\s+\{([^}]+)\}\s+from\s+['"]@secondlayer\/stacks['"];/;
-  const match = content.match(stacksImportRegex);
-  if (match) {
-    let updatedContent = content;
-    if (!updatedContent.includes("fetchCallReadOnlyFunction")) {
-      updatedContent = updatedContent.replace(stacksImportRegex, `${match[0]}
-import { fetchCallReadOnlyFunction, makeContractCall } from '@secondlayer/stacks/clarity';`);
-    }
-    if (!updatedContent.includes("type PostCondition")) {
-      updatedContent = updatedContent.replace(stacksImportRegex, `${match[0]}
-import type { PostCondition } from '@secondlayer/stacks';`);
-    }
-    return updatedContent;
-  }
-  return content;
-}
-function injectHelpersIntoContract(content, contractName, helpersCode) {
-  const contractPattern = new RegExp(`(export const ${contractName} = \\{[\\s\\S]*?)\\n\\} as const;`, "g");
-  return content.replace(contractPattern, (_, contractBody) => {
-    const cleanBody = contractBody.replace(/,\s*$/, "");
-    const indentedHelpersCode = helpersCode.split(`
-`).map((line) => {
-      if (line.match(/^[a-zA-Z_$][a-zA-Z0-9_$]*\s*:/)) {
-        return `  ${line}`;
-      }
-      return line;
-    }).join(`
-`);
-    return `${cleanBody},
-
-${indentedHelpersCode}
-} as const;`;
-  });
-}
 // src/plugins/react/generators/contract.ts
 init_format();
 
 // src/utils/case-conversion.ts
-import { toCamelCase as toCamelCase4 } from "@secondlayer/stacks/clarity";
+import { toCamelCase as toCamelCase3 } from "@secondlayer/stacks/clarity";
 function capitalize(str) {
   return str.charAt(0).toUpperCase() + str.slice(1);
 }
 function toPascalCase(str) {
-  return capitalize(toCamelCase4(str));
+  return capitalize(toCamelCase3(str));
 }
 
 // src/utils/type-mapping.ts
@@ -898,23 +725,23 @@ import {
 function generateHookArgsSignature(args) {
   if (args.length === 0)
     return "";
-  const argsList = args.map((arg) => `${toCamelCase4(arg.name)}: ${clarityTypeToTS(arg.type)}`).join(", ");
+  const argsList = args.map((arg) => `${toCamelCase3(arg.name)}: ${clarityTypeToTS(arg.type)}`).join(", ");
   return `${argsList}`;
 }
 function generateArgsType(args) {
   if (args.length === 0)
     return "void";
-  const argsList = args.map((arg) => `${toCamelCase4(arg.name)}: ${clarityTypeToTS(arg.type)}`).join("; ");
+  const argsList = args.map((arg) => `${toCamelCase3(arg.name)}: ${clarityTypeToTS(arg.type)}`).join("; ");
   return `{ ${argsList} }`;
 }
 function generateArgNames(args) {
   if (args.length === 0)
     return "";
-  return args.map((arg) => toCamelCase4(arg.name)).join(", ");
+  return args.map((arg) => toCamelCase3(arg.name)).join(", ");
 }
 function generateEnabledCondition(args) {
   return args.map((arg) => {
-    const camelName = toCamelCase4(arg.name);
+    const camelName = toCamelCase3(arg.name);
     const type = clarityTypeToTS(arg.type);
     if (type === "string")
       return `!!${camelName}`;
@@ -926,7 +753,7 @@ function generateEnabledCondition(args) {
 function generateObjectArgs(args) {
   if (args.length === 0)
     return "";
-  return args.map((arg) => `${arg.name}: ${toCamelCase4(arg.name)}`).join(", ");
+  return args.map((arg) => `${arg.name}: ${toCamelCase3(arg.name)}`).join(", ");
 }
 
 // src/plugins/react/generators/contract.ts
@@ -959,21 +786,21 @@ function generateContractHookMethods(contract, excludeList) {
   const readOnlyFunctions = functions.filter((f) => f.access === "read-only");
   const publicFunctions = functions.filter((f) => f.access === "public");
   const readHooks = readOnlyFunctions.map((func) => {
-    const hookName = `use${capitalize(name)}${capitalize(toCamelCase4(func.name))}`;
+    const hookName = `use${capitalize(name)}${capitalize(toCamelCase3(func.name))}`;
     if (excludeList.includes(hookName)) {
       return null;
     }
     return generateReadHook(func, name);
   }).filter(Boolean);
   const writeHooks = publicFunctions.map((func) => {
-    const hookName = `use${capitalize(name)}${capitalize(toCamelCase4(func.name))}`;
+    const hookName = `use${capitalize(name)}${capitalize(toCamelCase3(func.name))}`;
     if (excludeList.includes(hookName)) {
       return null;
     }
     return generateWriteHook(func, name);
   }).filter(Boolean);
   const mapHooks = maps.map((map) => {
-    const hookName = `use${capitalize(name)}${capitalize(toCamelCase4(map.name))}`;
+    const hookName = `use${capitalize(name)}${capitalize(toCamelCase3(map.name))}`;
     if (excludeList.includes(hookName)) {
       return null;
     }
@@ -981,7 +808,7 @@ function generateContractHookMethods(contract, excludeList) {
   }).filter(Boolean);
   const dataVars = variables.filter((v) => v.access === "variable");
   const varHooks = dataVars.map((variable) => {
-    const hookName = `use${capitalize(name)}${capitalize(toCamelCase4(variable.name))}`;
+    const hookName = `use${capitalize(name)}${capitalize(toCamelCase3(variable.name))}`;
     if (excludeList.includes(hookName)) {
       return null;
     }
@@ -989,7 +816,7 @@ function generateContractHookMethods(contract, excludeList) {
   }).filter(Boolean);
   const constants = variables.filter((v) => v.access === "constant");
   const constantHooks = constants.map((constant) => {
-    const hookName = `use${capitalize(name)}${capitalize(toCamelCase4(constant.name))}`;
+    const hookName = `use${capitalize(name)}${capitalize(toCamelCase3(constant.name))}`;
     if (excludeList.includes(hookName)) {
       return null;
     }
@@ -1010,7 +837,7 @@ function generateContractHookMethods(contract, excludeList) {
 `);
 }
 function generateReadHook(func, contractName) {
-  const hookName = `use${capitalize(contractName)}${capitalize(toCamelCase4(func.name))}`;
+  const hookName = `use${capitalize(contractName)}${capitalize(toCamelCase3(func.name))}`;
   const argsSignature = generateHookArgsSignature(func.args);
   const enabledParam = func.args.length > 0 ? ", options?: { enabled?: boolean }" : "options?: { enabled?: boolean }";
   const returnType = clarityTypeToTS(func.outputs);
@@ -1019,7 +846,7 @@ function generateReadHook(func, contractName) {
 
   return useQuery<${returnType}>({
     queryKey: ['${func.name}', ${contractName}.address, ${generateArgNames(func.args)}],
-    queryFn: () => ${contractName}.read.${toCamelCase4(func.name)}(${generateArgNames(func.args) ? `{ ${generateObjectArgs(func.args)} }, ` : ""}{
+    queryFn: () => ${contractName}.read.${toCamelCase3(func.name)}(${generateArgNames(func.args) ? `{ ${generateObjectArgs(func.args)} }, ` : ""}{
       network: config.network,
       senderAddress: config.senderAddress || '${DEFAULT_SENDER_ADDRESS}'
     }),
@@ -1029,7 +856,7 @@ function generateReadHook(func, contractName) {
 }`;
 }
 function generateWriteHook(func, contractName) {
-  const hookName = `use${capitalize(contractName)}${capitalize(toCamelCase4(func.name))}`;
+  const hookName = `use${capitalize(contractName)}${capitalize(toCamelCase3(func.name))}`;
   const argsType = generateArgsType(func.args);
   return `export function ${hookName}() {
   const config = useSecondLayerConfig()
@@ -1046,7 +873,7 @@ function generateWriteHook(func, contractName) {
       };
     }) => {
       const { args, options = {} } = params
-      const contractCallData = ${contractName}.${toCamelCase4(func.name)}(args)
+      const contractCallData = ${contractName}.${toCamelCase3(func.name)}(args)
       const { contractAddress, contractName: name, functionName, functionArgs } = contractCallData
       const network = config.network || 'mainnet'
       const contract = \`\${contractAddress}.\${name}\`
@@ -1071,7 +898,7 @@ function generateWriteHook(func, contractName) {
     }
   })
 
-  const ${toCamelCase4(func.name)} = useCallback(async (
+  const ${toCamelCase3(func.name)} = useCallback(async (
     args: ${argsType},
     options?: {
       postConditions?: PostCondition[];
@@ -1084,7 +911,7 @@ function generateWriteHook(func, contractName) {
   }, [mutation])
 
   return {
-    ${toCamelCase4(func.name)},
+    ${toCamelCase3(func.name)},
     // Expose mutation state
     isPending: mutation.isPending,
     isError: mutation.isError,
@@ -1096,7 +923,7 @@ function generateWriteHook(func, contractName) {
 }`;
 }
 function generateMapHook(map, contractVarName, _address, _contractName) {
-  const hookName = `use${capitalize(contractVarName)}${capitalize(toCamelCase4(map.name))}`;
+  const hookName = `use${capitalize(contractVarName)}${capitalize(toCamelCase3(map.name))}`;
   const keyType = clarityTypeToTS(map.key);
   const valueType = clarityTypeToTS(map.value);
   return `export function ${hookName}(key: ${keyType}, options?: { enabled?: boolean }) {
@@ -1105,14 +932,14 @@ function generateMapHook(map, contractVarName, _address, _contractName) {
   return useQuery<${valueType} | null>({
     queryKey: ['${contractVarName}', '${map.name}', 'map', key, config.network],
     queryFn: async () => {
-      return ${contractVarName}.maps.${toCamelCase4(map.name)}.get(key, { network: config.network })
+      return ${contractVarName}.maps.${toCamelCase3(map.name)}.get(key, { network: config.network })
     },
     enabled: options?.enabled ?? true
   })
 }`;
 }
 function generateVarHook(variable, contractVarName, _address, _contractName) {
-  const hookName = `use${capitalize(contractVarName)}${capitalize(toCamelCase4(variable.name))}`;
+  const hookName = `use${capitalize(contractVarName)}${capitalize(toCamelCase3(variable.name))}`;
   const valueType = clarityTypeToTS(variable.type);
   return `export function ${hookName}(options?: { enabled?: boolean }) {
   const config = useSecondLayerConfig()
@@ -1120,14 +947,14 @@ function generateVarHook(variable, contractVarName, _address, _contractName) {
   return useQuery<${valueType}>({
     queryKey: ['${contractVarName}', '${variable.name}', 'var', config.network],
     queryFn: async () => {
-      return ${contractVarName}.vars.${toCamelCase4(variable.name)}.get({ network: config.network })
+      return ${contractVarName}.vars.${toCamelCase3(variable.name)}.get({ network: config.network })
     },
     enabled: options?.enabled ?? true
   })
 }`;
 }
 function generateConstantHook(constant, contractVarName, _address, _contractName) {
-  const hookName = `use${capitalize(contractVarName)}${capitalize(toCamelCase4(constant.name))}`;
+  const hookName = `use${capitalize(contractVarName)}${capitalize(toCamelCase3(constant.name))}`;
   const valueType = clarityTypeToTS(constant.type);
   return `export function ${hookName}(options?: { enabled?: boolean }) {
   const config = useSecondLayerConfig()
@@ -1135,7 +962,7 @@ function generateConstantHook(constant, contractVarName, _address, _contractName
   return useQuery<${valueType}>({
     queryKey: ['${contractVarName}', '${constant.name}', 'constant', config.network],
     queryFn: async () => {
-      return ${contractVarName}.constants.${toCamelCase4(constant.name)}.get({ network: config.network })
+      return ${contractVarName}.constants.${toCamelCase3(constant.name)}.get({ network: config.network })
     },
     enabled: options?.enabled ?? true,
     staleTime: Infinity // Constants never change
@@ -1988,8 +1815,17 @@ var react = (options = {}) => {
 import {
   isAbiTuple
 } from "@secondlayer/stacks/clarity";
+
+// src/utils/generator-helpers.ts
+import {
+  generateArgsSignature,
+  generateClarityArgs,
+  generateMapKeyConversion
+} from "@secondlayer/scaffold";
+
+// src/plugins/testing/generators.ts
 function generatePublicFunction(func, contractId) {
-  const methodName = toCamelCase4(func.name);
+  const methodName = toCamelCase3(func.name);
   const argsSignature = generateArgsSignature(func.args);
   const clarityArgs = generateClarityArgs(func.args);
   return `${methodName}: (${argsSignature}caller: string) => {
@@ -2003,7 +1839,7 @@ function generatePublicFunction(func, contractId) {
     }`;
 }
 function generateReadOnlyFunction(func, contractId) {
-  const methodName = toCamelCase4(func.name);
+  const methodName = toCamelCase3(func.name);
   const argsSignature = generateArgsSignature(func.args);
   const clarityArgs = generateClarityArgs(func.args);
   const hasArgs = func.args.length > 0;
@@ -2018,7 +1854,7 @@ function generateReadOnlyFunction(func, contractId) {
     }`;
 }
 function generatePrivateFunction(func, contractId) {
-  const methodName = toCamelCase4(func.name);
+  const methodName = toCamelCase3(func.name);
   const argsSignature = generateArgsSignature(func.args);
   const clarityArgs = generateClarityArgs(func.args);
   return `${methodName}: (${argsSignature}caller: string) => {
@@ -2032,20 +1868,20 @@ function generatePrivateFunction(func, contractId) {
     }`;
 }
 function generateDataVarHelper(variable, contractId) {
-  const methodName = toCamelCase4(variable.name);
+  const methodName = toCamelCase3(variable.name);
   return `${methodName}: () => {
       return simnet.getDataVar('${contractId}', '${variable.name}');
     }`;
 }
 function getMapKeyType(keyType) {
   if (isAbiTuple(keyType)) {
-    const fields = keyType.tuple.map((field) => `${toCamelCase4(field.name)}: ${getTypeForArg({ type: field.type })}`).join("; ");
+    const fields = keyType.tuple.map((field) => `${toCamelCase3(field.name)}: ${getTypeForArg({ type: field.type })}`).join("; ");
     return `{ ${fields} }`;
   }
   return getTypeForArg({ type: keyType });
 }
 function generateMapEntryHelper(map, contractId) {
-  const methodName = toCamelCase4(map.name);
+  const methodName = toCamelCase3(map.name);
   const keyType = getMapKeyType(map.key);
   const keyConversion = generateMapKeyConversion(map.key);
   return `${methodName}: (key: ${keyType}) => {
@@ -2115,7 +1951,7 @@ function generateContractHelper(contract, options) {
 }
 function generateGetContracts(contracts) {
   const contractEntries = contracts.map((contract) => {
-    const camelName = toCamelCase4(contract.name);
+    const camelName = toCamelCase3(contract.name);
     const pascalName = toPascalCase(contract.name);
     return `${camelName}: get${pascalName}(simnet)`;
   }).join(`,
@@ -2231,9 +2067,8 @@ export {
   filterByOptions,
   createPlugin,
   clarinet,
-  actions,
   PluginManager
 };
 
-//# debugId=B22EAFB44071D00264756E2164756E21
+//# debugId=E6E6E78DF371674C64756E2164756E21
 //# sourceMappingURL=index.js.map