@openzeppelin/wizard 0.5.3 → 0.5.5

package/src/api.ts

@@ -23,6 +23,8 @@ import {
   defaults as stablecoinDefaults,
   isAccessControlRequired as stablecoinIsAccessControlRequired,
 } from './stablecoin';
+import type { AccountOptions } from './account';
+import { printAccount, defaults as accountDefaults } from './account';
 import type { GovernorOptions } from './governor';
 import {
   printGovernor,
@@ -46,7 +48,9 @@ export interface WizardContractAPI<Options extends CommonOptions> {
    * The default options that are used for `print`.
    */
   defaults: Required<Options>;
+}
 
+export interface AccessControlAPI<Options extends CommonOptions> {
   /**
    * Whether any of the provided options require access control to be enabled. If this returns `true`, then calling `print` with the
    * same options would cause the `access` option to default to `'ownable'` if it was `undefined` or `false`.
@@ -54,13 +58,14 @@ export interface WizardContractAPI<Options extends CommonOptions> {
   isAccessControlRequired: (opts: Partial<Options>) => boolean;
 }
 
-export type ERC20 = WizardContractAPI<ERC20Options>;
-export type ERC721 = WizardContractAPI<ERC721Options>;
-export type ERC1155 = WizardContractAPI<ERC1155Options>;
-export type Stablecoin = WizardContractAPI<StablecoinOptions>;
-export type RealWorldAsset = WizardContractAPI<StablecoinOptions>;
-export type Governor = WizardContractAPI<GovernorOptions>;
-export type Custom = WizardContractAPI<CustomOptions>;
+export type ERC20 = WizardContractAPI<ERC20Options> & AccessControlAPI<ERC20Options>;
+export type ERC721 = WizardContractAPI<ERC721Options> & AccessControlAPI<ERC721Options>;
+export type ERC1155 = WizardContractAPI<ERC1155Options> & AccessControlAPI<ERC1155Options>;
+export type Stablecoin = WizardContractAPI<StablecoinOptions> & AccessControlAPI<StablecoinOptions>;
+export type RealWorldAsset = WizardContractAPI<StablecoinOptions> & AccessControlAPI<StablecoinOptions>;
+export type Account = WizardContractAPI<AccountOptions>;
+export type Governor = WizardContractAPI<GovernorOptions> & AccessControlAPI<GovernorOptions>;
+export type Custom = WizardContractAPI<CustomOptions> & AccessControlAPI<CustomOptions>;
 
 export const erc20: ERC20 = {
   print: printERC20,
@@ -82,6 +87,10 @@ export const stablecoin: Stablecoin = {
   defaults: stablecoinDefaults,
   isAccessControlRequired: stablecoinIsAccessControlRequired,
 };
+export const account: Account = {
+  print: printAccount,
+  defaults: accountDefaults,
+};
 export const realWorldAsset: RealWorldAsset = {
   print: printStablecoin,
   defaults: stablecoinDefaults,

package/src/build-generic.ts

@@ -11,6 +11,8 @@ import { buildStablecoin } from './stablecoin';
 import type { GovernorOptions } from './governor';
 import { buildGovernor } from './governor';
 import type { Contract } from './contract';
+import { buildAccount } from './account';
+import type { AccountOptions } from './account';
 
 export interface KindedOptions {
   ERC20: { kind: 'ERC20' } & ERC20Options;
@@ -18,6 +20,7 @@ export interface KindedOptions {
   ERC1155: { kind: 'ERC1155' } & ERC1155Options;
   Stablecoin: { kind: 'Stablecoin' } & StablecoinOptions;
   RealWorldAsset: { kind: 'RealWorldAsset' } & StablecoinOptions;
+  Account: { kind: 'Account' } & AccountOptions;
   Governor: { kind: 'Governor' } & GovernorOptions;
   Custom: { kind: 'Custom' } & CustomOptions;
 }
@@ -41,6 +44,9 @@ export function buildGeneric(opts: GenericOptions): Contract {
     case 'RealWorldAsset':
       return buildStablecoin(opts);
 
+    case 'Account':
+      return buildAccount(opts);
+
     case 'Governor':
       return buildGovernor(opts);
 

package/src/environments/hardhat/package-lock.json

@@ -1510,9 +1510,9 @@
       }
     },
     "node_modules/@openzeppelin/contracts": {
-      "version": "5.2.0",
-      "resolved": "https://registry.npmjs.org/@openzeppelin/contracts/-/contracts-5.2.0.tgz",
-      "integrity": "sha512-bxjNie5z89W1Ea0NZLZluFh8PrFNn9DH8DQlujEok2yjsOlraUPKID5p1Wk3qdNbf6XkQ1Os2RvfiHrrXLHWKA==",
+      "version": "5.3.0",
+      "resolved": "https://registry.npmjs.org/@openzeppelin/contracts/-/contracts-5.3.0.tgz",
+      "integrity": "sha512-zj/KGoW7zxWUE8qOI++rUM18v+VeLTTzKs/DJFkSzHpQFPD/jKKF0TrMxBfGLl3kpdELCNccvB3zmofSzm4nlA==",
       "dev": true,
       "license": "MIT"
     },

package/src/environments/hardhat/upgradeable/package-lock.json

@@ -2195,20 +2195,20 @@
       }
     },
     "node_modules/@openzeppelin/contracts": {
-      "version": "5.2.0",
-      "resolved": "https://registry.npmjs.org/@openzeppelin/contracts/-/contracts-5.2.0.tgz",
-      "integrity": "sha512-bxjNie5z89W1Ea0NZLZluFh8PrFNn9DH8DQlujEok2yjsOlraUPKID5p1Wk3qdNbf6XkQ1Os2RvfiHrrXLHWKA==",
+      "version": "5.3.0",
+      "resolved": "https://registry.npmjs.org/@openzeppelin/contracts/-/contracts-5.3.0.tgz",
+      "integrity": "sha512-zj/KGoW7zxWUE8qOI++rUM18v+VeLTTzKs/DJFkSzHpQFPD/jKKF0TrMxBfGLl3kpdELCNccvB3zmofSzm4nlA==",
       "dev": true,
       "license": "MIT"
     },
     "node_modules/@openzeppelin/contracts-upgradeable": {
-      "version": "5.2.0",
-      "resolved": "https://registry.npmjs.org/@openzeppelin/contracts-upgradeable/-/contracts-upgradeable-5.2.0.tgz",
-      "integrity": "sha512-mZIu9oa4tQTlGiOJHk6D3LdJlqFqF6oNOSn6S6UVJtzfs9UsY9/dhMEbAVTwElxUtJnjpf6yA062+oBp+eOyPg==",
+      "version": "5.3.0",
+      "resolved": "https://registry.npmjs.org/@openzeppelin/contracts-upgradeable/-/contracts-upgradeable-5.3.0.tgz",
+      "integrity": "sha512-yVzSSyTMWO6rapGI5tuqkcLpcGGXA0UA1vScyV5EhE5yw8By3Ewex9rDUw8lfVw0iTkvR/egjfcW5vpk03lqZg==",
       "dev": true,
       "license": "MIT",
       "peerDependencies": {
-        "@openzeppelin/contracts": "5.2.0"
+        "@openzeppelin/contracts": "5.3.0"
       }
     },
     "node_modules/@openzeppelin/defender-sdk-base-client": {

package/src/erc20.ts

@@ -13,6 +13,7 @@ import type { ClockMode } from './set-clock-mode';
 import { clockModeDefault, setClockMode } from './set-clock-mode';
 import { supportsInterface } from './common-functions';
 import { OptionsError } from './error';
+import { toUint256, UINT256_MAX } from './utils/convert-strings';
 
 export const crossChainBridgingOptions = [false, 'custom', 'superchain'] as const;
 export type CrossChainBridging = (typeof crossChainBridgingOptions)[number];
@@ -25,6 +26,7 @@ export interface ERC20Options extends CommonOptions {
   premint?: string;
   premintChainId?: string;
   mintable?: boolean;
+  callback?: boolean;
   permit?: boolean;
   /**
    * Whether to keep track of historical balances for voting in on-chain governance, and optionally specify the clock mode.
@@ -43,6 +45,7 @@ export const defaults: Required<ERC20Options> = {
   premint: '0',
   premintChainId: '',
   mintable: false,
+  callback: false,
   permit: true,
   votes: false,
   flashmint: false,
@@ -61,6 +64,7 @@ export function withDefaults(opts: ERC20Options): Required<ERC20Options> {
     premint: opts.premint || defaults.premint,
     premintChainId: opts.premintChainId || defaults.premintChainId,
     mintable: opts.mintable ?? defaults.mintable,
+    callback: opts.callback ?? defaults.callback,
     permit: opts.permit ?? defaults.permit,
     votes: opts.votes ?? defaults.votes,
     flashmint: opts.flashmint ?? defaults.flashmint,
@@ -105,6 +109,10 @@ export function buildERC20(opts: ERC20Options): ContractBuilder {
     addMintable(c, access);
   }
 
+  if (allOpts.callback) {
+    addCallback(c);
+  }
+
   // Note: Votes requires Permit
   if (allOpts.permit || allOpts.votes) {
     addPermit(c, allOpts.name);
@@ -163,6 +171,14 @@ export function isValidChainId(str: string): boolean {
   return chainIdPattern.test(str);
 }
 
+function scaleByPowerOfTen(base: bigint, exponent: number): bigint {
+  if (exponent < 0) {
+    return base / BigInt(10) ** BigInt(-exponent);
+  } else {
+    return base * BigInt(10) ** BigInt(exponent);
+  }
+}
+
 function addPremint(
   c: ContractBuilder,
   amount: string,
@@ -181,6 +197,9 @@ function addPremint(
       const units = integer + decimals + zeroes;
       const exp = decimalPlace <= 0 ? 'decimals()' : `(decimals() - ${decimalPlace})`;
 
+      const validatedBaseUnits = toUint256(units, 'premint');
+      checkPotentialPremintOverflow(validatedBaseUnits, decimalPlace);
+
       c.addConstructorArgument({ type: 'address', name: 'recipient' });
 
       const mintLine = `_mint(recipient, ${units} * 10 ** ${exp});`;
@@ -212,11 +231,38 @@ function addPremint(
   }
 }
 
+/**
+ * Check for potential premint overflow assuming the user's contract has decimals() = 18
+ *
+ * @param baseUnits The base units of the token, before applying power of 10
+ * @param decimalPlace If positive, the number of assumed decimal places in the least significant digits of `validatedBaseUnits`. Ignored if <= 0.
+ * @throws OptionsError if the calculated value would overflow uint256
+ */
+function checkPotentialPremintOverflow(baseUnits: bigint, decimalPlace: number) {
+  const assumedExp = decimalPlace <= 0 ? 18 : 18 - decimalPlace;
+  const calculatedValue = scaleByPowerOfTen(baseUnits, assumedExp);
+
+  if (calculatedValue > UINT256_MAX) {
+    throw new OptionsError({
+      premint: 'Amount would overflow uint256 after applying decimals',
+    });
+  }
+}
+
 function addMintable(c: ContractBuilder, access: Access) {
   requireAccessControl(c, functions.mint, access, 'MINTER', 'minter');
   c.addFunctionCode('_mint(to, amount);', functions.mint);
 }
 
+function addCallback(c: ContractBuilder) {
+  const ERC1363 = {
+    name: 'ERC1363',
+    path: '@openzeppelin/contracts/token/ERC20/extensions/ERC1363.sol',
+  };
+  c.addParent(ERC1363);
+  c.addOverride(ERC1363, supportsInterface);
+}
+
 function addPermit(c: ContractBuilder, name: string) {
   const ERC20Permit = {
     name: 'ERC20Permit',
@@ -267,7 +313,7 @@ function addCrossChainBridging(
 ) {
   const ERC20Bridgeable = {
     name: 'ERC20Bridgeable',
-    path: `@openzeppelin/community-contracts/contracts/token/ERC20/extensions/ERC20Bridgeable.sol`,
+    path: `@openzeppelin/community-contracts/token/ERC20/extensions/ERC20Bridgeable.sol`,
   };
 
   c.addParent(ERC20Bridgeable);

package/src/generate/account.ts

@@ -0,0 +1,20 @@
+import type { AccountOptions } from '../account';
+import { infoOptions } from '../set-info';
+import { generateAlternatives } from './alternatives';
+
+const account = {
+  name: ['MyAccount'],
+  signatureValidation: [false, 'ERC1271', 'ERC7739'] as const,
+  ERC721Holder: [false, true] as const,
+  ERC1155Holder: [false, true] as const,
+  signer: ['ERC7702', 'ECDSA', 'P256', 'RSA', 'Multisig', 'MultisigWeighted'] as const,
+  batchedExecution: [false, true] as const,
+  ERC7579Modules: [false, 'AccountERC7579', 'AccountERC7579Hooked'] as const,
+  access: [false] as const,
+  upgradeable: [false] as const,
+  info: infoOptions,
+};
+
+export function* generateAccountOptions(): Generator<Required<AccountOptions>> {
+  yield* generateAlternatives(account);
+}

package/src/generate/erc20.ts

@@ -13,6 +13,7 @@ const blueprint = {
   burnable: booleans,
   pausable: booleans,
   mintable: booleans,
+  callback: booleans,
   permit: booleans,
   votes: [...booleans, ...clockModeOptions] as const,
   flashmint: booleans,

package/src/generate/sources.ts

@@ -6,6 +6,7 @@ import { generateERC20Options } from './erc20';
 import { generateERC721Options } from './erc721';
 import { generateERC1155Options } from './erc1155';
 import { generateStablecoinOptions } from './stablecoin';
+import { generateAccountOptions } from './account';
 import { generateGovernorOptions } from './governor';
 import { generateCustomOptions } from './custom';
 import type { GenericOptions, KindedOptions } from '../build-generic';
@@ -50,6 +51,12 @@ export function* generateOptions(kind?: Kind): Generator<GenericOptions> {
     }
   }
 
+  if (!kind || kind === 'Account') {
+    for (const kindOpts of generateAccountOptions()) {
+      yield { kind: 'Account', ...kindOpts };
+    }
+  }
+
   if (!kind || kind === 'Governor') {
     for (const kindOpts of generateGovernorOptions()) {
       yield { kind: 'Governor', ...kindOpts };

package/src/generate/stablecoin.ts

@@ -12,6 +12,7 @@ const erc20Basic = {
   burnable: [false] as const,
   pausable: [false] as const,
   mintable: [false] as const,
+  callback: [false] as const,
   permit: [false] as const,
   votes: [false] as const,
   flashmint: [false] as const,
@@ -28,6 +29,7 @@ const erc20Full = {
   burnable: [true] as const,
   pausable: [true] as const,
   mintable: [true] as const,
+  callback: [true] as const,
   permit: [true] as const,
   votes: ['timestamp'] as const,
   flashmint: [true] as const,

package/src/governor.ts

@@ -1,7 +1,7 @@
 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 type { Contract, ImportContract } from './contract';
 import { ContractBuilder } from './contract';
 import { OptionsError } from './error';
 import { setAccessControl } from './set-access-control';
@@ -105,15 +105,13 @@ export function buildGovernor(opts: GovernorOptions): Contract {
   return c;
 }
 
+const Governor: ImportContract = {
+  name: 'Governor',
+  path: '@openzeppelin/contracts/governance/Governor.sol',
+};
+
 function addBase(c: ContractBuilder, { name }: GovernorOptions) {
-  const Governor = {
-    name: 'Governor',
-    path: '@openzeppelin/contracts/governance/Governor.sol',
-  };
   c.addParent(Governor, [name]);
-  c.addOverride(Governor, functions.votingDelay);
-  c.addOverride(Governor, functions.votingPeriod);
-  c.addOverride(Governor, functions.quorum);
   c.addOverride(Governor, functions.state);
   c.addOverride(Governor, functions.propose);
   c.addOverride(Governor, functions.proposalNeedsQueuing);
@@ -221,6 +219,7 @@ function setVotingParameters(c: ContractBuilder, opts: Required<GovernorOptions>
   } else {
     c.setFunctionBody([`return ${delayBlocks.value}; // ${delayBlocks.note}`], functions.votingDelay);
   }
+  c.addOverride(Governor, functions.votingDelay);
 
   const periodBlocks = getVotingPeriod(opts);
   if ('lit' in periodBlocks) {
@@ -228,6 +227,7 @@ function setVotingParameters(c: ContractBuilder, opts: Required<GovernorOptions>
   } else {
     c.setFunctionBody([`return ${periodBlocks.value}; // ${periodBlocks.note}`], functions.votingPeriod);
   }
+  c.addOverride(Governor, functions.votingPeriod);
 }
 
 function setProposalThreshold(c: ContractBuilder, opts: Required<GovernorOptions>) {
@@ -308,6 +308,7 @@ function addQuorum(c: ContractBuilder, opts: Required<GovernorOptions>) {
         : `return ${opts.quorumAbsolute}e${opts.decimals};`;
 
     c.setFunctionBody([returnStatement], functions.quorum, 'pure');
+    c.addOverride(Governor, functions.quorum);
   }
 }
 

package/src/index.ts

@@ -19,6 +19,6 @@ export { OptionsError } from './error';
 export type { Kind } from './kind';
 export { sanitizeKind } from './kind';
 
-export { erc20, erc721, erc1155, stablecoin, realWorldAsset, governor, custom } from './api';
+export { erc20, erc721, erc1155, stablecoin, realWorldAsset, account, governor, custom } from './api';
 
 export { compatibleContractsSemver } from './utils/version';

package/src/kind.ts

@@ -4,7 +4,7 @@ export type Kind = GenericOptions['kind'];
 
 export function sanitizeKind(kind: unknown): Kind {
   if (typeof kind === 'string') {
-    const sanitized = kind.replace(/^(ERC|.)/i, c => c.toUpperCase());
+    const sanitized = kind.replace(/^(ERC|.)/i, c => c.toUpperCase()).replace(/^(RealWorldAsset)$/i, 'RealWorldAsset');
     if (isKind(sanitized)) {
       return sanitized;
     }
@@ -19,6 +19,7 @@ function isKind<T>(value: Kind | T): value is Kind {
     case 'ERC721':
     case 'Stablecoin':
     case 'RealWorldAsset':
+    case 'Account':
     case 'Governor':
     case 'Custom':
       return true;

package/src/print.ts

@@ -16,6 +16,7 @@ import { mapValues } from './utils/map-values';
 import SOLIDITY_VERSION from './solidity-version.json';
 import { inferTranspiled } from './infer-transpiled';
 import { compatibleContractsSemver } from './utils/version';
+import { stringifyUnicodeSafe } from './utils/sanitize';
 
 export function printContract(contract: Contract, opts?: Options): string {
   const helpers = withHelpers(contract, opts);
@@ -148,7 +149,7 @@ export function printValue(value: Value): string {
       throw new Error(`Number not representable (${value})`);
     }
   } else {
-    return JSON.stringify(value);
+    return stringifyUnicodeSafe(value);
   }
 }
 

package/src/signer.ts

@@ -0,0 +1,124 @@
+import type { ContractBuilder } from './contract';
+import { defineFunctions } from './utils/define-functions';
+
+export const SignerOptions = [false, 'ERC7702', 'ECDSA', 'P256', 'RSA', 'Multisig', 'MultisigWeighted'] as const;
+export type SignerOptions = (typeof SignerOptions)[number];
+
+export function addSigner(c: ContractBuilder, signer: SignerOptions): void {
+  if (!signer) return;
+  const parent = signers[signer];
+  const name = parent.name;
+  c.addParent(parent);
+  c.addOverride(
+    { name: name === signers.MultisigWeighted.name ? signers.Multisig.name : name },
+    signerFunctions._rawSignatureValidation,
+  );
+
+  // ERC-7702 doesn't require initialization
+  if (signer === 'ERC7702') return;
+
+  c.addParent({
+    name: 'Initializable',
+    path: '@openzeppelin/contracts/proxy/utils/Initializable.sol',
+  });
+  const fn = signerFunctions[`initialize${signer}`];
+  c.addModifier('initializer', fn);
+
+  const args = fn.args;
+
+  switch (signer) {
+    case 'Multisig':
+      c.addFunctionCode(`_addSigners(${args[0]!.name});`, fn);
+      c.addFunctionCode(`_setThreshold(${args[1]!.name});`, fn);
+      break;
+    case 'MultisigWeighted':
+      c.addFunctionCode(`_addSigners(${args[0]!.name});`, fn);
+      c.addFunctionCode(`_setSignerWeights(${args[0]!.name}, ${args[1]!.name});`, fn);
+      c.addFunctionCode(`_setThreshold(${args[2]!.name});`, fn);
+      break;
+    case 'ECDSA':
+    case 'P256':
+    case 'RSA':
+      c.addFunctionCode(
+        `_setSigner(${fn.args
+          .map(({ name }) => name)
+          .join(', ')
+          .trimEnd()});`,
+        fn,
+      );
+  }
+}
+
+export const signers = {
+  ERC7702: {
+    name: 'SignerERC7702',
+    path: '@openzeppelin/community-contracts/utils/cryptography/SignerERC7702.sol',
+  },
+  ECDSA: {
+    name: 'SignerECDSA',
+    path: '@openzeppelin/community-contracts/utils/cryptography/SignerECDSA.sol',
+  },
+  P256: {
+    name: 'SignerP256',
+    path: '@openzeppelin/community-contracts/utils/cryptography/SignerP256.sol',
+  },
+  RSA: {
+    name: 'SignerRSA',
+    path: '@openzeppelin/community-contracts/utils/cryptography/SignerRSA.sol',
+  },
+  Multisig: {
+    name: 'MultiSignerERC7913',
+    path: '@openzeppelin/community-contracts/utils/cryptography/MultiSignerERC7913.sol',
+  },
+  MultisigWeighted: {
+    name: 'MultiSignerERC7913Weighted',
+    path: '@openzeppelin/community-contracts/utils/cryptography/MultiSignerERC7913Weighted.sol',
+  },
+};
+
+export const signerFunctions = {
+  ...defineFunctions({
+    initializeECDSA: {
+      kind: 'public' as const,
+      args: [{ name: 'signer', type: 'address' }],
+    },
+    initializeP256: {
+      kind: 'public' as const,
+      args: [
+        { name: 'qx', type: 'bytes32' },
+        { name: 'qy', type: 'bytes32' },
+      ],
+    },
+    initializeRSA: {
+      kind: 'public' as const,
+      args: [
+        { name: 'e', type: 'bytes memory' },
+        { name: 'n', type: 'bytes memory' },
+      ],
+    },
+    initializeMultisig: {
+      kind: 'public' as const,
+      args: [
+        { name: 'signers', type: 'bytes[] memory' },
+        { name: 'threshold', type: 'uint256' },
+      ],
+    },
+    initializeMultisigWeighted: {
+      kind: 'public' as const,
+      args: [
+        { name: 'signers', type: 'bytes[] memory' },
+        { name: 'weights', type: 'uint256[] memory' },
+        { name: 'threshold', type: 'uint256' },
+      ],
+    },
+    _rawSignatureValidation: {
+      kind: 'internal' as const,
+      args: [
+        { name: 'hash', type: 'bytes32' },
+        { name: 'signature', type: 'bytes calldata' },
+      ],
+      returns: ['bool'],
+      mutability: 'view' as const,
+    },
+  }),
+};

package/src/solidity-version.json

@@ -1 +1 @@
-"0.8.22"
+"0.8.27"

package/src/stablecoin.ts

@@ -65,7 +65,7 @@ function addLimitations(c: ContractBuilder, access: Access, mode: boolean | 'all
   const type = mode === 'allowlist';
   const ERC20Limitation = {
     name: type ? 'ERC20Allowlist' : 'ERC20Blocklist',
-    path: `@openzeppelin/community-contracts/contracts/token/ERC20/extensions/${type ? 'ERC20Allowlist' : 'ERC20Blocklist'}.sol`,
+    path: `@openzeppelin/community-contracts/token/ERC20/extensions/${type ? 'ERC20Allowlist' : 'ERC20Blocklist'}.sol`,
   };
 
   c.addParent(ERC20Limitation);
@@ -86,7 +86,7 @@ function addLimitations(c: ContractBuilder, access: Access, mode: boolean | 'all
 function addCustodian(c: ContractBuilder, access: Access) {
   const ERC20Custodian = {
     name: 'ERC20Custodian',
-    path: '@openzeppelin/community-contracts/contracts/token/ERC20/extensions/ERC20Custodian.sol',
+    path: '@openzeppelin/community-contracts/token/ERC20/extensions/ERC20Custodian.sol',
   };
 
   c.addParent(ERC20Custodian);

package/src/test.ts

@@ -30,6 +30,10 @@ test.serial('stablecoin result compiles', async t => {
   await testCompile(t, 'Stablecoin');
 });
 
+test.serial('account result compiles', async t => {
+  await testCompile(t, 'Account');
+});
+
 test.serial('governor result compiles', async t => {
   await testCompile(t, 'Governor');
 });
@@ -66,6 +70,8 @@ function isAccessControlRequired(opts: GenericOptions) {
       return stablecoin.isAccessControlRequired(opts);
     case 'RealWorldAsset':
       return stablecoin.isAccessControlRequired(opts);
+    case 'Account':
+      throw new Error(`Not applicable for ${opts.kind}`);
     case 'Governor':
       return governor.isAccessControlRequired(opts);
     case 'Custom':
@@ -79,11 +85,17 @@ test('is access control required', async t => {
   for (const contract of generateSources('all')) {
     const regexOwnable = /import.*Ownable(Upgradeable)?.sol.*/gm;
 
-    if (!contract.options.access) {
-      if (isAccessControlRequired(contract.options)) {
-        t.regex(contract.source, regexOwnable, JSON.stringify(contract.options));
-      } else {
-        t.notRegex(contract.source, regexOwnable, JSON.stringify(contract.options));
+    switch (contract.options.kind) {
+      case 'Account':
+        break;
+      default: {
+        if (!contract.options.access) {
+          if (isAccessControlRequired(contract.options)) {
+            t.regex(contract.source, regexOwnable, JSON.stringify(contract.options));
+          } else {
+            t.notRegex(contract.source, regexOwnable, JSON.stringify(contract.options));
+          }
+        }
       }
     }
   }

package/src/utils/convert-strings.ts

@@ -0,0 +1,27 @@
+import { OptionsError } from '../error';
+
+export const UINT256_MAX = BigInt(2) ** BigInt(256) - BigInt(1);
+
+/**
+ * Checks that a string is a valid `uint256` value and converts it to bigint.
+ *
+ * @param value The value to check.
+ * @param field The field name to use in the error if the value is invalid.
+ * @throws OptionsError if the value is not a valid number or is greater than the maximum value for `uint256`.
+ * @returns The value as a bigint.
+ */
+export function toUint256(value: string, field: string): bigint {
+  const isValidNumber = /^\d+$/.test(value);
+  if (!isValidNumber) {
+    throw new OptionsError({
+      [field]: 'Not a valid number',
+    });
+  }
+  const numValue = BigInt(value);
+  if (numValue > UINT256_MAX) {
+    throw new OptionsError({
+      [field]: 'Value is greater than uint256 max value',
+    });
+  }
+  return numValue;
+}

package/src/utils/sanitize.ts

@@ -0,0 +1,6 @@
+export function stringifyUnicodeSafe(str: string): string {
+  // eslint-disable-next-line no-control-regex
+  const containsUnicode = /[^\x00-\x7F]/.test(str);
+
+  return containsUnicode ? `unicode"${str.replace(/"/g, '\\"')}"` : JSON.stringify(str);
+}

package/src/zip-foundry.ts

@@ -202,18 +202,18 @@ then
   mv README.md README-oz.md
 
   # Initialize sample Foundry project
-  forge init --force --no-commit --quiet
+  forge init --force --quiet
 
 ${
   c.upgradeable
     ? `\
   # Install OpenZeppelin Contracts and Upgrades
-  forge install OpenZeppelin/openzeppelin-contracts-upgradeable@v${contracts.version} --no-commit --quiet
-  forge install OpenZeppelin/openzeppelin-foundry-upgrades --no-commit --quiet\
+  forge install OpenZeppelin/openzeppelin-contracts-upgradeable@v${contracts.version} --quiet
+  forge install OpenZeppelin/openzeppelin-foundry-upgrades --quiet\
 `
     : `\
   # Install OpenZeppelin Contracts
-  forge install OpenZeppelin/openzeppelin-contracts@v${contracts.version} --no-commit --quiet\
+  forge install OpenZeppelin/openzeppelin-contracts@v${contracts.version} --quiet\
 `
 }