@openzeppelin/wizard 0.5.4 → 0.5.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openzeppelin/wizard",
-  "version": "0.5.4",
+  "version": "0.5.5",
   "description": "A boilerplate generator to get started with OpenZeppelin Contracts",
   "license": "AGPL-3.0-only",
   "repository": "https://github.com/OpenZeppelin/contracts-wizard",
@@ -19,17 +19,16 @@
     "test": "ava",
     "test:update-snapshots": "ava --update-snapshots",
     "test:watch": "ava --watch",
-    "version": "node ../../../scripts/bump-changelog.js",
     "update-env": "rm ./src/environments/hardhat/package-lock.json && npm install --package-lock-only --prefix ./src/environments/hardhat && rm ./src/environments/hardhat/upgradeable/package-lock.json && npm install --package-lock-only --prefix ./src/environments/hardhat/upgradeable"
   },
   "devDependencies": {
     "@openzeppelin/community-contracts": "https://github.com/OpenZeppelin/openzeppelin-community-contracts",
-    "@openzeppelin/contracts": "^5.1.0",
-    "@openzeppelin/contracts-upgradeable": "^5.1.0",
-    "@types/node": "^18.0.0",
+    "@openzeppelin/contracts": "^5.3.0",
+    "@openzeppelin/contracts-upgradeable": "^5.3.0",
+    "@types/node": "^20.0.0",
     "@types/semver": "^7.5.7",
     "ava": "^6.0.0",
-    "hardhat": "^2.1.1",
+    "hardhat": "^2.22.11",
     "jszip": "^3.6.0",
     "rimraf": "^5.0.0",
     "semver": "^7.6.0",
@@ -37,4 +36,4 @@
     "ts-node": "^10.4.0",
     "typescript": "^5.0.0"
   }
-}
+}

package/src/account.ts

@@ -0,0 +1,292 @@
+import { ContractBuilder } from './contract';
+import type { Contract } from './contract';
+import { defineFunctions } from './utils/define-functions';
+import { printContract } from './print';
+import { defaults as commonDefaults, withCommonDefaults, type CommonOptions } from './common-options';
+import { setInfo } from './set-info';
+import { addSigner, signerFunctions, signers, type SignerOptions } from './signer';
+
+export const defaults: Required<AccountOptions> = {
+  ...commonDefaults,
+  name: 'MyAccount',
+  signatureValidation: 'ERC7739',
+  ERC721Holder: true,
+  ERC1155Holder: true,
+  signer: 'ECDSA',
+  batchedExecution: false,
+  ERC7579Modules: false,
+} as const;
+
+export const SignatureValidationOptions = [false, 'ERC1271', 'ERC7739'] as const;
+export type SignatureValidationOptions = (typeof SignatureValidationOptions)[number];
+
+export const ERC7579ModulesOptions = [false, 'AccountERC7579', 'AccountERC7579Hooked'] as const;
+export type ERC7579ModulesOptions = (typeof ERC7579ModulesOptions)[number];
+
+export interface AccountOptions extends CommonOptions {
+  name: string;
+  signatureValidation?: SignatureValidationOptions;
+  ERC721Holder?: boolean;
+  ERC1155Holder?: boolean;
+  signer?: SignerOptions;
+  batchedExecution?: boolean;
+  ERC7579Modules?: ERC7579ModulesOptions;
+}
+
+function withDefaults(opts: AccountOptions): Required<AccountOptions> {
+  return {
+    ...withCommonDefaults(opts),
+    name: opts.name ?? defaults.name,
+    signatureValidation: opts.signatureValidation ?? defaults.signatureValidation,
+    ERC721Holder: opts.ERC721Holder ?? defaults.ERC721Holder,
+    ERC1155Holder: opts.ERC1155Holder ?? defaults.ERC1155Holder,
+    signer: opts.signer ?? defaults.signer,
+    batchedExecution: opts.batchedExecution ?? defaults.batchedExecution,
+    ERC7579Modules: opts.ERC7579Modules ?? defaults.ERC7579Modules,
+  };
+}
+
+export function printAccount(opts: AccountOptions = defaults): string {
+  return printContract(buildAccount(opts));
+}
+
+export function buildAccount(opts: AccountOptions): Contract {
+  const allOpts = withDefaults(opts);
+
+  allOpts.upgradeable = false; // Upgradeability is not yet available for the community contracts
+  allOpts.access = false; // Access control options are not used for Account
+
+  const c = new ContractBuilder(allOpts.name);
+
+  addParents(c, allOpts);
+  overrideRawSignatureValidation(c, allOpts);
+  setInfo(c, allOpts.info);
+
+  if (opts.ERC7579Modules) {
+    c.addImportOnly({
+      name: 'PackedUserOperation',
+      path: '@openzeppelin/contracts/interfaces/draft-IERC4337.sol',
+    });
+  }
+
+  return c;
+}
+
+function addParents(c: ContractBuilder, opts: AccountOptions): void {
+  // Base
+  c.addParent({
+    name: 'Account',
+    path: `@openzeppelin/community-contracts/account/Account.sol`,
+  });
+  c.addOverride({ name: 'Account' }, functions._validateUserOp);
+
+  if (opts.signatureValidation === 'ERC7739') addEIP712(c, opts);
+
+  // Extensions
+  addSignatureValidation(c, opts);
+  addERC7579Modules(c, opts);
+  addSigner(c, opts.signer ?? false);
+  addMultisigFunctions(c, opts);
+  addBatchedExecution(c, opts);
+  addERC721Holder(c, opts);
+  addERC1155Holder(c, opts);
+}
+
+function addSignatureValidation(c: ContractBuilder, opts: AccountOptions) {
+  switch (opts.signatureValidation) {
+    case 'ERC7739':
+      c.addParent({
+        name: 'ERC7739',
+        path: '@openzeppelin/community-contracts/utils/cryptography/ERC7739.sol',
+      });
+      break;
+    case 'ERC1271':
+      c.addParent({
+        name: 'IERC1271',
+        path: '@openzeppelin/contracts/interfaces/IERC1271.sol',
+      });
+      c.addOverride({ name: 'IERC1271' }, functions.isValidSignature);
+      if (!opts.ERC7579Modules) {
+        c.setFunctionBody(
+          [
+            'return _rawSignatureValidation(hash, signature) ? IERC1271.isValidSignature.selector : bytes4(0xffffffff);',
+          ],
+          functions.isValidSignature,
+        );
+      }
+      break;
+  }
+}
+
+function addERC721Holder(c: ContractBuilder, opts: AccountOptions): void {
+  if (!opts.ERC721Holder) return;
+  c.addParent({
+    name: 'ERC721Holder',
+    path: '@openzeppelin/contracts/token/ERC721/utils/ERC721Holder.sol',
+  });
+}
+
+function addERC1155Holder(c: ContractBuilder, opts: AccountOptions): void {
+  if (!opts.ERC1155Holder) return;
+  c.addParent({
+    name: 'ERC1155Holder',
+    path: '@openzeppelin/contracts/token/ERC1155/utils/ERC1155Holder.sol',
+  });
+}
+
+function addBatchedExecution(c: ContractBuilder, opts: AccountOptions): void {
+  // ERC-7579 is a superset of ERC-7821
+  if (!opts.batchedExecution || !!opts.ERC7579Modules) return;
+  c.addParent({
+    name: 'ERC7821',
+    path: '@openzeppelin/community-contracts/account/extensions/ERC7821.sol',
+  });
+  c.addOverride({ name: 'ERC7821' }, functions._erc7821AuthorizedExecutor);
+  c.setFunctionBody(
+    ['return caller == address(entryPoint()) || super._erc7821AuthorizedExecutor(caller, mode, executionData);'],
+    functions._erc7821AuthorizedExecutor,
+  );
+}
+
+function addERC7579Modules(c: ContractBuilder, opts: AccountOptions): void {
+  if (!opts.ERC7579Modules) return;
+  c.addParent({
+    name: opts.ERC7579Modules,
+    path: `@openzeppelin/community-contracts/account/extensions/${opts.ERC7579Modules}.sol`,
+  });
+  if (opts.ERC7579Modules !== 'AccountERC7579') {
+    c.addImportOnly({
+      name: 'AccountERC7579',
+      path: `@openzeppelin/community-contracts/account/extensions/AccountERC7579.sol`,
+    });
+  }
+  c.addOverride({ name: 'AccountERC7579' }, functions.isValidSignature);
+  c.addOverride({ name: 'AccountERC7579' }, functions._validateUserOp);
+
+  if (opts.signatureValidation !== 'ERC7739') return;
+  c.addOverride({ name: 'ERC7739' }, functions.isValidSignature);
+  c.setFunctionBody(
+    [
+      '// ERC-7739 can return the ERC-1271 magic value, 0xffffffff (invalid) or 0x77390001 (detection).',
+      '// If the returned value is 0xffffffff, fallback to ERC-7579 validation.',
+      'bytes4 erc7739magic = ERC7739.isValidSignature(hash, signature);',
+      'return erc7739magic == bytes4(0xffffffff) ? AccountERC7579.isValidSignature(hash, signature) : erc7739magic;',
+    ],
+    functions.isValidSignature,
+  );
+}
+
+function addMultisigFunctions(c: ContractBuilder, opts: AccountOptions): void {
+  switch (opts.signer) {
+    case 'MultisigWeighted':
+      c.addFunctionCode(
+        `_setSignerWeights(${functions.setSignerWeights.args.map(({ name }) => name).join(', ')});`,
+        functions.setSignerWeights,
+      );
+    // eslint-disable-next-line no-fallthrough
+    case 'Multisig':
+      c.addFunctionCode(`_addSigners(${functions.addSigners.args[0]!.name});`, functions.addSigners);
+      c.addFunctionCode(`_removeSigners(${functions.removeSigners.args[0]!.name});`, functions.removeSigners);
+      c.addFunctionCode(`_setThreshold(${functions.setThreshold.args[0]!.name});`, functions.setThreshold);
+      break;
+    default:
+  }
+}
+
+function addEIP712(c: ContractBuilder, opts: AccountOptions): void {
+  if (opts.signatureValidation != 'ERC7739') return;
+  c.addParent(
+    {
+      name: 'EIP712',
+      path: '@openzeppelin/contracts/utils/cryptography/EIP712.sol',
+    },
+    [opts.name, '1'],
+  );
+}
+
+function overrideRawSignatureValidation(c: ContractBuilder, opts: AccountOptions): void {
+  if (opts.signer && !opts.ERC7579Modules) return; // Signer implements _rawSignatureValidation alone
+  if (!opts.signer && opts.ERC7579Modules) return; // AccountERC7579 implements _rawSignatureValidation alone
+
+  // If no signer or ERC-7579 is used, we need to override the _rawSignatureValidation function
+  // to provide a custom validation logic
+  if (!opts.signer && !opts.ERC7579Modules) {
+    // Custom validation logic
+    c.addOverride({ name: 'Account' }, signerFunctions._rawSignatureValidation);
+    c.setFunctionBody(['// Custom validation logic', 'return false;'], signerFunctions._rawSignatureValidation);
+  }
+
+  // Dissambiguate between Signer and AccountERC7579
+  if (opts.signer && opts.ERC7579Modules) {
+    c.addImportOnly({
+      name: 'AbstractSigner',
+      path: '@openzeppelin/community-contracts/utils/cryptography/AbstractSigner.sol',
+    });
+    c.addOverride({ name: 'AbstractSigner' }, signerFunctions._rawSignatureValidation);
+    c.addOverride({ name: 'AccountERC7579' }, signerFunctions._rawSignatureValidation);
+    c.setFunctionComments(
+      [
+        `// IMPORTANT: Make sure Signer${opts.signer} is most derived than AccountERC7579`,
+        `// in the inheritance chain (i.e. contract ... is AccountERC7579, ..., Signer${opts.signer})`,
+        '// to ensure the correct order of function resolution.',
+        '// AccountERC7579 returns false for `_rawSignatureValidation`',
+      ],
+      signerFunctions._rawSignatureValidation,
+    );
+    // Base override for `_rawSignatureValidation` given MultiSignerERC7913Weighted is MultiSignerERC7913
+    if (opts.signer === 'MultisigWeighted') {
+      c.addImportOnly(signers.Multisig);
+    }
+  }
+}
+
+const functions = {
+  ...defineFunctions({
+    isValidSignature: {
+      kind: 'public' as const,
+      mutability: 'view' as const,
+      args: [
+        { name: 'hash', type: 'bytes32' },
+        { name: 'signature', type: 'bytes calldata' },
+      ],
+      returns: ['bytes4'],
+    },
+    _validateUserOp: {
+      kind: 'internal' as const,
+      args: [
+        { name: 'userOp', type: 'PackedUserOperation calldata' },
+        { name: 'userOpHash', type: 'bytes32' },
+      ],
+      returns: ['uint256'],
+    },
+    _erc7821AuthorizedExecutor: {
+      kind: 'internal' as const,
+      args: [
+        { name: 'caller', type: 'address' },
+        { name: 'mode', type: 'bytes32' },
+        { name: 'executionData', type: 'bytes calldata' },
+      ],
+      returns: ['bool'],
+      mutability: 'view' as const,
+    },
+    addSigners: {
+      kind: 'public' as const,
+      args: [{ name: 'signers', type: 'bytes[] memory' }],
+    },
+    removeSigners: {
+      kind: 'public' as const,
+      args: [{ name: 'signers', type: 'bytes[] memory' }],
+    },
+    setThreshold: {
+      kind: 'public' as const,
+      args: [{ name: 'threshold', type: 'uint256' }],
+    },
+    setSignerWeights: {
+      kind: 'public' as const,
+      args: [
+        { name: 'signers', type: 'bytes[] memory' },
+        { name: 'weights', type: 'uint256[] memory' },
+      ],
+    },
+  }),
+};

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

@@ -313,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/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/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);
   }
 }