@openzeppelin/wizard 0.5.1 → 0.5.3

package/src/governor.ts

@@ -1,14 +1,16 @@
-import { supportsInterface } from "./common-functions";
-import { CommonOptions, withCommonDefaults, defaults as commonDefaults } from "./common-options";
-import { ContractBuilder, Contract, Value } from "./contract";
-import { OptionsError } from "./error";
-import { setAccessControl } from "./set-access-control";
-import { printContract } from "./print";
-import { setInfo } from "./set-info";
-import { setUpgradeable } from "./set-upgradeable";
+import { supportsInterface } from './common-functions';
+import type { CommonOptions } from './common-options';
+import { withCommonDefaults, defaults as commonDefaults } from './common-options';
+import type { Contract } from './contract';
+import { ContractBuilder } from './contract';
+import { OptionsError } from './error';
+import { setAccessControl } from './set-access-control';
+import { printContract } from './print';
+import { setInfo } from './set-info';
+import { setUpgradeable } from './set-upgradeable';
 import { defineFunctions } from './utils/define-functions';
-import { durationToBlocks, durationToTimestamp } from "./utils/duration";
-import { clockModeDefault, type ClockMode } from "./set-clock-mode";
+import { durationToBlocks, durationToTimestamp } from './utils/duration';
+import { clockModeDefault, type ClockMode } from './set-clock-mode';
 
 export const defaults: Required<GovernorOptions> = {
   name: 'MyGovernor',
@@ -26,17 +28,17 @@ export const defaults: Required<GovernorOptions> = {
   quorumAbsolute: '',
   storage: false,
   settings: true,
-  
+
   access: commonDefaults.access,
   upgradeable: commonDefaults.upgradeable,
-  info: commonDefaults.info
+  info: commonDefaults.info,
 } as const;
 
 export const votesOptions = ['erc20votes', 'erc721votes'] as const;
-export type VotesOptions = typeof votesOptions[number];
+export type VotesOptions = (typeof votesOptions)[number];
 
 export const timelockOptions = [false, 'openzeppelin', 'compound'] as const;
-export type TimelockOptions = typeof timelockOptions[number];
+export type TimelockOptions = (typeof timelockOptions)[number];
 
 export function printGovernor(opts: GovernorOptions = defaults): string {
   return printContract(buildGovernor(opts));
@@ -77,7 +79,7 @@ function withDefaults(opts: GovernorOptions): Required<GovernorOptions> {
     quorumMode: opts.quorumMode ?? defaults.quorumMode,
     votes: opts.votes ?? defaults.votes,
     clockMode: opts.clockMode ?? defaults.clockMode,
-    timelock: opts.timelock ?? defaults.timelock
+    timelock: opts.timelock ?? defaults.timelock,
   };
 }
 
@@ -130,14 +132,11 @@ function addSettings(c: ContractBuilder, allOpts: Required<GovernorOptions>) {
       name: 'GovernorSettings',
       path: '@openzeppelin/contracts/governance/extensions/GovernorSettings.sol',
     };
-    c.addParent(
-      GovernorSettings,
-      [
-        getVotingDelay(allOpts),
-        getVotingPeriod(allOpts),
-        { lit: getProposalThreshold(allOpts) },
-      ],
-    );
+    c.addParent(GovernorSettings, [
+      getVotingDelay(allOpts),
+      getVotingPeriod(allOpts),
+      { lit: getProposalThreshold(allOpts) },
+    ]);
     c.addOverride(GovernorSettings, functions.votingDelay, 'view');
     c.addOverride(GovernorSettings, functions.votingPeriod, 'view');
     c.addOverride(GovernorSettings, functions.proposalThreshold, 'view');
@@ -147,7 +146,7 @@ function addSettings(c: ContractBuilder, allOpts: Required<GovernorOptions>) {
   }
 }
 
-function getVotingDelay(opts: Required<GovernorOptions>): { lit: string } | { note: string, value: number } {
+function getVotingDelay(opts: Required<GovernorOptions>): { lit: string } | { note: string; value: number } {
   try {
     if (opts.clockMode === 'timestamp') {
       return {
@@ -156,7 +155,7 @@ function getVotingDelay(opts: Required<GovernorOptions>): { lit: string } | { no
     } else {
       return {
         value: durationToBlocks(opts.delay, opts.blockTime),
-        note: opts.delay
+        note: opts.delay,
       };
     }
   } catch (e) {
@@ -170,7 +169,7 @@ function getVotingDelay(opts: Required<GovernorOptions>): { lit: string } | { no
   }
 }
 
-function getVotingPeriod(opts: Required<GovernorOptions>): { lit: string } | { note: string, value: number } {
+function getVotingPeriod(opts: Required<GovernorOptions>): { lit: string } | { note: string; value: number } {
   try {
     if (opts.clockMode === 'timestamp') {
       return {
@@ -179,7 +178,7 @@ function getVotingPeriod(opts: Required<GovernorOptions>): { lit: string } | { n
     } else {
       return {
         value: durationToBlocks(opts.period, opts.blockTime),
-        note: opts.period
+        note: opts.period,
       };
     }
   } catch (e) {
@@ -263,10 +262,13 @@ function addVotes(c: ContractBuilder) {
     name: tokenArg,
   });
 
-  c.addParent({
-    name: 'GovernorVotes',
-    path: `@openzeppelin/contracts/governance/extensions/GovernorVotes.sol`,
-  }, [{ lit: tokenArg }]);
+  c.addParent(
+    {
+      name: 'GovernorVotes',
+      path: `@openzeppelin/contracts/governance/extensions/GovernorVotes.sol`,
+    },
+    [{ lit: tokenArg }],
+  );
 }
 
 export const numberPattern = /^(?!$)(\d*)(?:\.(\d+))?(?:e(\d+))?$/;
@@ -279,7 +281,7 @@ function addQuorum(c: ContractBuilder, opts: Required<GovernorOptions>) {
       });
     }
 
-    let { quorumFractionNumerator, quorumFractionDenominator } = getQuorumFractionComponents(opts.quorumPercent);
+    const { quorumFractionNumerator, quorumFractionDenominator } = getQuorumFractionComponents(opts.quorumPercent);
 
     const GovernorVotesQuorumFraction = {
       name: 'GovernorVotesQuorumFraction',
@@ -288,29 +290,24 @@ function addQuorum(c: ContractBuilder, opts: Required<GovernorOptions>) {
 
     if (quorumFractionDenominator !== undefined) {
       c.addOverride(GovernorVotesQuorumFraction, functions.quorumDenominator);
-      c.setFunctionBody([
-        `return ${quorumFractionDenominator};`
-      ], functions.quorumDenominator, 'pure');
+      c.setFunctionBody([`return ${quorumFractionDenominator};`], functions.quorumDenominator, 'pure');
     }
 
     c.addParent(GovernorVotesQuorumFraction, [quorumFractionNumerator]);
     c.addOverride(GovernorVotesQuorumFraction, functions.quorum);
-  }
-
-  else if (opts.quorumMode === 'absolute') {
+  } else if (opts.quorumMode === 'absolute') {
     if (!numberPattern.test(opts.quorumAbsolute)) {
       throw new OptionsError({
         quorumAbsolute: 'Not a valid number',
       });
     }
 
-    let returnStatement = (opts.decimals === 0 || opts.votes === 'erc721votes') ? 
-      `return ${opts.quorumAbsolute};` :
-      `return ${opts.quorumAbsolute}e${opts.decimals};`;
+    const returnStatement =
+      opts.decimals === 0 || opts.votes === 'erc721votes'
+        ? `return ${opts.quorumAbsolute};`
+        : `return ${opts.quorumAbsolute}e${opts.decimals};`;
 
-    c.setFunctionBody([
-      returnStatement,
-    ], functions.quorum, 'pure');
+    c.setFunctionBody([returnStatement], functions.quorum, 'pure');
   }
 }
 
@@ -323,7 +320,7 @@ const timelockModules = {
     timelockParent: {
       name: 'GovernorTimelockControl',
       path: `@openzeppelin/contracts/governance/extensions/GovernorTimelockControl.sol`,
-    }
+    },
   },
   compound: {
     timelockType: {
@@ -334,20 +331,27 @@ const timelockModules = {
     timelockParent: {
       name: 'GovernorTimelockCompound',
       path: `@openzeppelin/contracts/governance/extensions/GovernorTimelockCompound.sol`,
-    }
+    },
   },
 } as const;
 
-function getQuorumFractionComponents(quorumPercent: number): {quorumFractionNumerator: number, quorumFractionDenominator: string | undefined} {
+function getQuorumFractionComponents(quorumPercent: number): {
+  quorumFractionNumerator: number;
+  quorumFractionDenominator: string | undefined;
+} {
   let quorumFractionNumerator = quorumPercent;
   let quorumFractionDenominator = undefined;
 
-  const quorumPercentSegments = quorumPercent.toString().split(".");
+  const quorumPercentSegments = quorumPercent.toString().split('.');
   if (quorumPercentSegments.length > 2) {
     throw new OptionsError({
       quorumPercent: 'Invalid percentage',
     });
-  } else if (quorumPercentSegments.length == 2 && quorumPercentSegments[0] !== undefined && quorumPercentSegments[1] !== undefined) {
+  } else if (
+    quorumPercentSegments.length == 2 &&
+    quorumPercentSegments[0] !== undefined &&
+    quorumPercentSegments[1] !== undefined
+  ) {
     quorumFractionNumerator = parseInt(quorumPercentSegments[0].concat(quorumPercentSegments[1]));
     const decimals = quorumPercentSegments[1].length;
     quorumFractionDenominator = '100';
@@ -412,17 +416,13 @@ const functions = defineFunctions({
     mutability: 'pure',
   },
   proposalNeedsQueuing: {
-    args: [
-      { name: 'proposalId', type: 'uint256' },
-    ],
+    args: [{ name: 'proposalId', type: 'uint256' }],
     returns: ['bool'],
     kind: 'public',
     mutability: 'view',
   },
   quorum: {
-    args: [
-      { name: 'blockNumber', type: 'uint256' },
-    ],
+    args: [{ name: 'blockNumber', type: 'uint256' }],
     returns: ['uint256'],
     kind: 'public',
     mutability: 'view',
@@ -486,9 +486,7 @@ const functions = defineFunctions({
     kind: 'internal',
   },
   state: {
-    args: [
-      { name: 'proposalId', type: 'uint256' },
-    ],
+    args: [{ name: 'proposalId', type: 'uint256' }],
     returns: ['ProposalState'],
     kind: 'public',
     mutability: 'view',

package/src/index.ts

@@ -10,7 +10,7 @@ export type { Access } from './set-access-control';
 export type { Upgradeable } from './set-upgradeable';
 export type { Info } from './set-info';
 
-export { premintPattern } from './erc20';
+export { premintPattern, chainIdPattern } from './erc20';
 export { defaults as infoDefaults } from './set-info';
 
 export type { OptionsErrorMessages } from './error';
@@ -21,4 +21,4 @@ export { sanitizeKind } from './kind';
 
 export { erc20, erc721, erc1155, stablecoin, realWorldAsset, governor, custom } from './api';
 
-export { compatibleContractsSemver } from './utils/version';
+export { compatibleContractsSemver } from './utils/version';

package/src/infer-transpiled.ts

@@ -1,5 +1,5 @@
-import type { ReferencedContract } from "./contract";
+import type { ReferencedContract } from './contract';
 
 export function inferTranspiled(c: ReferencedContract): boolean {
   return c.transpiled ?? !/^I[A-Z]/.test(c.name);
-}
+}

package/src/kind.ts

@@ -30,4 +30,3 @@ function isKind<T>(value: Kind | T): value is Kind {
     }
   }
 }
-

package/src/options.ts

@@ -9,7 +9,7 @@ const upgradeableName = (n: string) => {
   } else {
     return n.replace(/(Upgradeable)?(?=\.|$)/, 'Upgradeable');
   }
-}
+};
 
 const upgradeableImport = (p: ImportContract): ImportContract => {
   const { dir, ext, name } = path.parse(p.path);
@@ -22,7 +22,7 @@ const upgradeableImport = (p: ImportContract): ImportContract => {
       dir: dir.replace(/^@openzeppelin\/contracts/, '@openzeppelin/contracts-upgradeable'),
       name: upgradeableName(name), // Solidity file name
     }),
-  }
+  };
 };
 
 export interface Options {
@@ -36,7 +36,8 @@ export interface Helpers extends Required<Options> {
 
 export function withHelpers(contract: Contract, opts: Options = {}): Helpers {
   const contractUpgradeable = contract.upgradeable;
-  const transformName = (n: ReferencedContract) => contractUpgradeable && inferTranspiled(n) ? upgradeableName(n.name) : n.name;
+  const transformName = (n: ReferencedContract) =>
+    contractUpgradeable && inferTranspiled(n) ? upgradeableName(n.name) : n.name;
   return {
     upgradeable: contractUpgradeable,
     transformName,

package/src/print-versioned.ts

@@ -1,6 +1,6 @@
 import contracts from '../openzeppelin-contracts';
-import type { Contract } from "./contract";
-import { printContract } from "./print";
+import type { Contract } from './contract';
+import { printContract } from './print';
 
 export function printContractVersioned(contract: Contract): string {
   return printContract(contract, {
@@ -8,9 +8,7 @@ export function printContractVersioned(contract: Contract): string {
       return {
         ...p,
         path: p.path.replace(/^@openzeppelin\/contracts(-upgradeable)?/, `$&@${contracts.version}`),
-      }
-    }
+      };
+    },
   });
 }
-
-

package/src/print.ts

@@ -1,7 +1,17 @@
-import type { Contract, Parent, ContractFunction, FunctionArgument, Value, NatspecTag, ImportContract } from './contract';
-import { Options, Helpers, withHelpers } from './options';
-
-import { formatLines, spaceBetween, Lines } from './utils/format-lines';
+import type {
+  Contract,
+  Parent,
+  ContractFunction,
+  FunctionArgument,
+  Value,
+  NatspecTag,
+  ImportContract,
+} from './contract';
+import type { Options, Helpers } from './options';
+import { withHelpers } from './options';
+
+import type { Lines } from './utils/format-lines';
+import { formatLines, spaceBetween } from './utils/format-lines';
 import { mapValues } from './utils/map-values';
 import SOLIDITY_VERSION from './solidity-version.json';
 import { inferTranspiled } from './infer-transpiled';
@@ -10,10 +20,7 @@ import { compatibleContractsSemver } from './utils/version';
 export function printContract(contract: Contract, opts?: Options): string {
   const helpers = withHelpers(contract, opts);
 
-  const fns = mapValues(
-    sortedFunctions(contract),
-    fns => fns.map(fn => printFunction(fn, helpers)),
-  );
+  const fns = mapValues(sortedFunctions(contract), fns => fns.map(fn => printFunction(fn, helpers)));
 
   const hasOverrides = fns.override.some(l => l.length > 0);
 
@@ -59,31 +66,21 @@ function printConstructor(contract: Contract, helpers: Helpers): Lines[] {
   const hasConstructorCode = contract.constructorCode.length > 0;
   const parentsWithInitializers = contract.parents.filter(hasInitializer);
   if (hasParentParams || hasConstructorCode || (helpers.upgradeable && parentsWithInitializers.length > 0)) {
-    const parents = parentsWithInitializers
-      .flatMap(p => printParentConstructor(p, helpers));
-    const modifiers = helpers.upgradeable ? ['initializer public'] : parents;
-    const args = contract.constructorArgs.map(a =>  printArgument(a, helpers));
+    const parents = parentsWithInitializers.flatMap(p => printParentConstructor(p, helpers));
+    const modifiers = helpers.upgradeable ? ['public initializer'] : parents;
+    const args = contract.constructorArgs.map(a => printArgument(a, helpers));
     const body = helpers.upgradeable
       ? spaceBetween(
-        parents.map(p => p + ';'),
-        contract.constructorCode,
-      )
+          parents.map(p => p + ';'),
+          contract.constructorCode,
+        )
       : contract.constructorCode;
     const head = helpers.upgradeable ? 'function initialize' : 'constructor';
-    const constructor = printFunction2(
-      [],
-      head,
-      args,
-      modifiers,
-      body,
-    );
+    const constructor = printFunction2([], head, args, modifiers, body);
     if (!helpers.upgradeable) {
       return constructor;
     } else {
-      return spaceBetween(
-        DISABLE_INITIALIZERS,
-        constructor,
-      );
+      return spaceBetween(DISABLE_INITIALIZERS, constructor);
     }
   } else if (!helpers.upgradeable) {
     return [];
@@ -92,14 +89,11 @@ function printConstructor(contract: Contract, helpers: Helpers): Lines[] {
   }
 }
 
-const DISABLE_INITIALIZERS = 
-[
+const DISABLE_INITIALIZERS = [
   '/// @custom:oz-upgrades-unsafe-allow constructor',
   'constructor() {',
-  [
-    '_disableInitializers();'
-  ],
-  '}'
+  ['_disableInitializers();'],
+  '}',
 ];
 
 function hasInitializer(parent: Parent) {
@@ -132,9 +126,7 @@ function printParentConstructor({ contract, params }: Parent, helpers: Helpers):
   const useTranspiled = helpers.upgradeable && inferTranspiled(contract);
   const fn = useTranspiled ? `__${contract.name}_init` : contract.name;
   if (useTranspiled || params.length > 0) {
-    return [
-      fn + '(' + params.map(printValue).join(', ') + ')',
-    ];
+    return [fn + '(' + params.map(printValue).join(', ') + ')'];
   } else {
     return [];
   }
@@ -164,13 +156,12 @@ function printFunction(fn: ContractFunction, helpers: Helpers): Lines[] {
   const { transformName } = helpers;
 
   if (fn.override.size <= 1 && fn.modifiers.length === 0 && fn.code.length === 0 && !fn.final) {
-    return []
+    return [];
   }
-
-  const modifiers: string[] = [fn.kind, ...fn.modifiers];
+  const modifiers: string[] = [fn.kind];
 
   if (fn.mutability !== 'nonpayable') {
-    modifiers.splice(1, 0, fn.mutability);
+    modifiers.push(fn.mutability);
   }
 
   if (fn.override.size === 1) {
@@ -179,6 +170,8 @@ function printFunction(fn: ContractFunction, helpers: Helpers): Lines[] {
     modifiers.push(`override(${[...fn.override].map(transformName).join(', ')})`);
   }
 
+  modifiers.push(...fn.modifiers);
+
   if (fn.returns?.length) {
     modifiers.push(`returns (${fn.returns.join(', ')})`);
   }
@@ -205,12 +198,16 @@ function printFunction(fn: ContractFunction, helpers: Helpers): Lines[] {
 
 // generic for functions and constructors
 // kindedName = 'function foo' or 'constructor'
-function printFunction2(comments: string[], kindedName: string, args: string[], modifiers: string[], code: Lines[]): Lines[] {
-  const fn: Lines[] = [ ...comments ];
+function printFunction2(
+  comments: string[],
+  kindedName: string,
+  args: string[],
+  modifiers: string[],
+  code: Lines[],
+): Lines[] {
+  const fn: Lines[] = [...comments];
 
-  const headingLength = [kindedName, ...args, ...modifiers]
-    .map(s => s.length)
-    .reduce((a, b) => a + b);
+  const headingLength = [kindedName, ...args, ...modifiers].map(s => s.length).reduce((a, b) => a + b);
 
   const braces = code.length > 0 ? '{' : '{}';
 
@@ -231,6 +228,7 @@ function printArgument(arg: FunctionArgument, { transformName }: Helpers): strin
   let type: string;
   if (typeof arg.type === 'string') {
     if (/^[A-Z]/.test(arg.type)) {
+      // eslint-disable-next-line @typescript-eslint/no-unused-expressions
       `Type ${arg.type} is not a primitive type. Define it as a ContractReference`;
     }
     type = arg.type;
@@ -260,4 +258,4 @@ function printImports(imports: ImportContract[], helpers: Helpers): string[] {
   });
 
   return lines;
-}
+}

package/src/scripts/prepare.ts

@@ -4,7 +4,7 @@ import hre from 'hardhat';
 import type { BuildInfo } from 'hardhat/types';
 import { findAll } from 'solidity-ast/utils';
 import { rimraf } from 'rimraf';
-import { version } from "@openzeppelin/contracts/package.json";
+import { version } from '@openzeppelin/contracts/package.json';
 
 import type { OpenZeppelinContracts } from '../../openzeppelin-contracts';
 import { writeGeneratedSources } from '../generate/sources';
@@ -21,12 +21,13 @@ async function main() {
   const sources: Record<string, string> = {};
 
   for (const buildInfoPath of await hre.artifacts.getBuildInfoPaths()) {
-    const buildInfo: BuildInfo = JSON.parse(
-      await fs.readFile(buildInfoPath, 'utf8'),
-    );
+    const buildInfo: BuildInfo = JSON.parse(await fs.readFile(buildInfoPath, 'utf8'));
 
     for (const [sourceFile, { ast }] of Object.entries(buildInfo.output.sources)) {
-      if (sourceFile.startsWith('@openzeppelin/contracts') || sourceFile.startsWith('@openzeppelin/community-contracts')) {
+      if (
+        sourceFile.startsWith('@openzeppelin/contracts') ||
+        sourceFile.startsWith('@openzeppelin/community-contracts')
+      ) {
         const sourceDependencies = (dependencies[sourceFile] ??= new Set());
         for (const imp of findAll('ImportDirective', ast)) {
           sourceDependencies.add(imp.absolutePath);
@@ -35,7 +36,10 @@ async function main() {
     }
 
     for (const [sourceFile, { content }] of Object.entries(buildInfo.input.sources)) {
-      if (sourceFile.startsWith('@openzeppelin/contracts') || sourceFile.startsWith('@openzeppelin/community-contracts')) {
+      if (
+        sourceFile.startsWith('@openzeppelin/contracts') ||
+        sourceFile.startsWith('@openzeppelin/community-contracts')
+      ) {
         sources[sourceFile] = content;
       }
     }

package/src/set-access-control.ts

@@ -3,7 +3,7 @@ import { supportsInterface } from './common-functions';
 
 export const accessOptions = [false, 'ownable', 'roles', 'managed'] as const;
 
-export type Access = typeof accessOptions[number];
+export type Access = (typeof accessOptions)[number];
 
 /**
  * Sets access control for the contract by adding inheritance.
@@ -11,10 +11,10 @@ export type Access = typeof accessOptions[number];
 export function setAccessControl(c: ContractBuilder, access: Access) {
   switch (access) {
     case 'ownable': {
-      if (c.addParent(parents.Ownable, [ {lit: 'initialOwner'} ])) {
+      if (c.addParent(parents.Ownable, [{ lit: 'initialOwner' }])) {
         c.addConstructorArgument({
           type: 'address',
-          name: 'initialOwner'
+          name: 'initialOwner',
         });
       }
       break;
@@ -23,7 +23,7 @@ export function setAccessControl(c: ContractBuilder, access: Access) {
       if (c.addParent(parents.AccessControl)) {
         c.addConstructorArgument({
           type: 'address',
-          name: 'defaultAdmin'
+          name: 'defaultAdmin',
         });
         c.addConstructorCode('_grantRole(DEFAULT_ADMIN_ROLE, defaultAdmin);');
       }
@@ -31,10 +31,10 @@ export function setAccessControl(c: ContractBuilder, access: Access) {
       break;
     }
     case 'managed': {
-      if (c.addParent(parents.AccessManaged, [ {lit: 'initialAuthority'} ])) {
+      if (c.addParent(parents.AccessManaged, [{ lit: 'initialAuthority' }])) {
         c.addConstructorArgument({
           type: 'address',
-          name: 'initialAuthority'
+          name: 'initialAuthority',
         });
       }
       break;
@@ -45,11 +45,17 @@ export function setAccessControl(c: ContractBuilder, access: Access) {
 /**
  * Enables access control for the contract and restricts the given function with access control.
  */
-export function requireAccessControl(c: ContractBuilder, fn: BaseFunction, access: Access, roleIdPrefix: string, roleOwner: string | undefined) {
+export function requireAccessControl(
+  c: ContractBuilder,
+  fn: BaseFunction,
+  access: Access,
+  roleIdPrefix: string,
+  roleOwner: string | undefined,
+) {
   if (access === false) {
     access = 'ownable';
   }
-  
+
   setAccessControl(c, access);
 
   switch (access) {
@@ -61,7 +67,7 @@ export function requireAccessControl(c: ContractBuilder, fn: BaseFunction, acces
       const roleId = roleIdPrefix + '_ROLE';
       const addedConstant = c.addVariable(`bytes32 public constant ${roleId} = keccak256("${roleId}");`);
       if (roleOwner && addedConstant) {
-        c.addConstructorArgument({type: 'address', name: roleOwner});
+        c.addConstructorArgument({ type: 'address', name: roleOwner });
         c.addConstructorCode(`_grantRole(${roleId}, ${roleOwner});`);
       }
       c.addModifier(`onlyRole(${roleId})`, fn);

package/src/set-clock-mode.ts

@@ -1,9 +1,9 @@
-import type { ContractBuilder, ReferencedContract } from "./contract";
-import { defineFunctions } from "./utils/define-functions";
+import type { ContractBuilder, ReferencedContract } from './contract';
+import { defineFunctions } from './utils/define-functions';
 
 export const clockModeOptions = ['blocknumber', 'timestamp'] as const;
 export const clockModeDefault = 'blocknumber' as const;
-export type ClockMode = typeof clockModeOptions[number];
+export type ClockMode = (typeof clockModeOptions)[number];
 
 const functions = defineFunctions({
   clock: {
@@ -18,7 +18,7 @@ const functions = defineFunctions({
     args: [],
     returns: ['string memory'],
     mutability: 'pure' as const,
-  }
+  },
 });
 
 export function setClockMode(c: ContractBuilder, parent: ReferencedContract, votes: ClockMode) {
@@ -30,4 +30,4 @@ export function setClockMode(c: ContractBuilder, parent: ReferencedContract, vot
     c.addOverride(parent, functions.CLOCK_MODE);
     c.setFunctionBody(['return "mode=timestamp";'], functions.CLOCK_MODE);
   }
-}
+}

package/src/set-info.ts

@@ -1,4 +1,4 @@
-import type { ContractBuilder } from "./contract";
+import type { ContractBuilder } from './contract';
 
 export const TAG_SECURITY_CONTACT = `@custom:security-contact`;
 
@@ -9,11 +9,11 @@ export const defaults: Info = { license: 'MIT' };
 export type Info = {
   securityContact?: string;
   license?: string;
-}
+};
 
 export function setInfo(c: ContractBuilder, info: Info) {
   const { securityContact, license } = info;
-  
+
   if (securityContact) {
     c.addNatspecTag(TAG_SECURITY_CONTACT, securityContact);
   }