@openzeppelin/wizard 0.1.0

package/src/erc20.ts

@@ -0,0 +1,250 @@
+import { Contract, ContractBuilder } from './contract';
+import { Access, setAccessControl } from './set-access-control';
+import { addPausable } from './add-pausable';
+import { defineFunctions } from './utils/define-functions';
+import { CommonOptions, withCommonDefaults, defaults as commonDefaults } from './common-options';
+import { setUpgradeable } from './set-upgradeable';
+import { setInfo } from './set-info';
+import { printContract } from './print';
+
+export interface ERC20Options extends CommonOptions {
+  name: string;
+  symbol: string;
+  burnable?: boolean;
+  snapshots?: boolean;
+  pausable?: boolean;
+  premint?: string;
+  mintable?: boolean;
+  permit?: boolean;
+  votes?: boolean;
+  flashmint?: boolean;
+}
+
+export const defaults: Required<ERC20Options> = {
+  name: 'MyToken',
+  symbol: 'MTK',
+  burnable: false,
+  snapshots: false,
+  pausable: false,
+  premint: '0',
+  mintable: false,
+  permit: false,
+  votes: false,
+  flashmint: false,
+  access: commonDefaults.access,
+  upgradeable: commonDefaults.upgradeable,
+  info: commonDefaults.info,
+} as const;
+
+function withDefaults(opts: ERC20Options): Required<ERC20Options> {
+  return {
+    ...opts,
+    ...withCommonDefaults(opts),
+    burnable: opts.burnable ?? defaults.burnable,
+    snapshots: opts.snapshots ?? defaults.snapshots,
+    pausable: opts.pausable ?? defaults.pausable,
+    premint: opts.premint || defaults.premint,
+    mintable: opts.mintable ?? defaults.mintable,
+    permit: opts.permit ?? defaults.permit,
+    votes: opts.votes ?? defaults.votes,
+    flashmint: opts.flashmint ?? defaults.flashmint,
+  };
+}
+
+export function printERC20(opts: ERC20Options = defaults): string {
+  return printContract(buildERC20(opts));
+}
+
+export function buildERC20(opts: ERC20Options): Contract {
+  const allOpts = withDefaults(opts);
+
+  const c = new ContractBuilder(allOpts.name);
+
+  const { access, upgradeable, info } = allOpts;
+
+  addBase(c, allOpts.name, allOpts.symbol);
+
+  if (allOpts.burnable) {
+    addBurnable(c);
+  }
+
+  if (allOpts.snapshots) {
+    addSnapshot(c, access);
+  }
+
+  if (allOpts.pausable) {
+    addPausable(c, access, [functions._beforeTokenTransfer]);
+  }
+
+  if (allOpts.premint) {
+    addPremint(c, allOpts.premint);
+  }
+
+  if (allOpts.mintable) {
+    addMintable(c, access);
+  }
+
+  // Note: Votes requires Permit
+  if (allOpts.permit || allOpts.votes) {
+    addPermit(c, allOpts.name);
+  }
+
+  if (allOpts.votes) {
+    addVotes(c);
+  }
+
+  if (allOpts.flashmint) {
+    addFlashMint(c);
+  }
+
+  setUpgradeable(c, upgradeable, access);
+  
+  setInfo(c, info);
+
+  return c;
+}
+
+function addBase(c: ContractBuilder, name: string, symbol: string) {
+  c.addParent(
+    {
+      name: 'ERC20',
+      path: '@openzeppelin/contracts/token/ERC20/ERC20.sol',
+    },
+    [name, symbol],
+  );
+
+  c.addOverride('ERC20', functions._beforeTokenTransfer);
+  c.addOverride('ERC20', functions._afterTokenTransfer);
+  c.addOverride('ERC20', functions._mint);
+  c.addOverride('ERC20', functions._burn);
+}
+
+function addBurnable(c: ContractBuilder) {
+  c.addParent({
+    name: 'ERC20Burnable',
+    path: '@openzeppelin/contracts/token/ERC20/extensions/ERC20Burnable.sol',
+  });
+}
+
+function addSnapshot(c: ContractBuilder, access: Access) {
+  c.addParent({
+    name: 'ERC20Snapshot',
+    path: '@openzeppelin/contracts/token/ERC20/extensions/ERC20Snapshot.sol',
+  });
+
+  c.addOverride('ERC20Snapshot', functions._beforeTokenTransfer);
+
+  setAccessControl(c, functions.snapshot, access, 'SNAPSHOT');
+  c.addFunctionCode('_snapshot();', functions.snapshot);
+}
+
+export const premintPattern = /^(\d*)(?:\.(\d+))?(?:e(\d+))?$/;
+
+function addPremint(c: ContractBuilder, amount: string) {
+  const m = amount.match(premintPattern);
+  if (m) {
+    const integer = m[1]?.replace(/^0+/, '') ?? '';
+    const decimals = m[2]?.replace(/0+$/, '') ?? '';
+    const exponent = Number(m[3] ?? 0);
+
+    if (Number(integer + decimals) > 0) {
+      const decimalPlace = decimals.length - exponent;
+      const zeroes = new Array(Math.max(0, -decimalPlace)).fill('0').join('');
+      const units = integer + decimals + zeroes;
+      const exp = decimalPlace <= 0 ? 'decimals()' : `(decimals() - ${decimalPlace})`;
+      c.addConstructorCode(`_mint(msg.sender, ${units} * 10 ** ${exp});`);
+    }
+  }
+}
+
+function addMintable(c: ContractBuilder, access: Access) {
+  setAccessControl(c, functions.mint, access, 'MINTER');
+  c.addFunctionCode('_mint(to, amount);', functions.mint);
+}
+
+function addPermit(c: ContractBuilder, name: string) {
+  c.addParent({
+    name: 'ERC20Permit',
+    path: '@openzeppelin/contracts/token/ERC20/extensions/draft-ERC20Permit.sol',
+  }, [name]);
+}
+
+function addVotes(c: ContractBuilder) {
+  if (!c.parents.some(p => p.contract.name === 'ERC20Permit')) {
+    throw new Error('Missing ERC20Permit requirement for ERC20Votes');
+  }
+
+  c.addParent({
+    name: 'ERC20Votes',
+    path: '@openzeppelin/contracts/token/ERC20/extensions/ERC20Votes.sol',
+  });
+  c.addOverride('ERC20Votes', functions._mint);
+  c.addOverride('ERC20Votes', functions._burn);
+  c.addOverride('ERC20Votes', functions._afterTokenTransfer);
+}
+
+function addFlashMint(c: ContractBuilder) {
+  c.addParent({
+    name: 'ERC20FlashMint',
+    path: '@openzeppelin/contracts/token/ERC20/extensions/ERC20FlashMint.sol',
+  });
+}
+
+const functions = defineFunctions({
+  _beforeTokenTransfer: {
+    kind: 'internal' as const,
+    args: [
+      { name: 'from', type: 'address' },
+      { name: 'to', type: 'address' },
+      { name: 'amount', type: 'uint256' },
+    ],
+  },
+
+  _afterTokenTransfer: {
+    kind: 'internal' as const,
+    args: [
+      { name: 'from', type: 'address' },
+      { name: 'to', type: 'address' },
+      { name: 'amount', type: 'uint256' },
+    ],
+  },
+
+  _burn: {
+    kind: 'internal' as const,
+    args: [
+      { name: 'account', type: 'address' },
+      { name: 'amount', type: 'uint256' },
+    ],
+  },
+
+  _mint: {
+    kind: 'internal' as const,
+    args: [
+      { name: 'to', type: 'address' },
+      { name: 'amount', type: 'uint256' },
+    ],
+  },
+
+  mint: {
+    kind: 'public' as const,
+    args: [
+      { name: 'to', type: 'address' },
+      { name: 'amount', type: 'uint256' },
+    ],
+  },
+
+  pause: {
+    kind: 'public' as const,
+    args: [],
+  },
+
+  unpause: {
+    kind: 'public' as const,
+    args: [],
+  },
+
+  snapshot: {
+    kind: 'public' as const,
+    args: [],
+  },
+});

package/src/erc721.test.ts

@@ -0,0 +1,122 @@
+import test from 'ava';
+import { erc721 } from '.';
+
+import { buildERC721, ERC721Options } from './erc721';
+import { printContract } from './print';
+
+function testERC721(title: string, opts: Partial<ERC721Options>) {
+  test(title, t => {
+    const c = buildERC721({
+      name: 'MyToken',
+      symbol: 'MTK',
+      ...opts,
+    });
+    t.snapshot(printContract(c));
+  });
+}
+
+/**
+ * Tests external API for equivalence with internal API
+ */
+ function testAPIEquivalence(title: string, opts?: ERC721Options) {
+  test(title, t => {
+    t.is(erc721.print(opts), printContract(buildERC721({
+      name: 'MyToken',
+      symbol: 'MTK',
+      ...opts,
+    })));
+  });
+}
+
+testERC721('basic', {});
+
+testERC721('base uri', {
+  baseUri: 'https://gateway.pinata.cloud/ipfs/QmcP9hxrnC1T5ATPmq2saFeAM1ypFX9BnAswCdHB9JCjLA/',
+});
+
+testERC721('enumerable', {
+  enumerable: true,
+});
+
+testERC721('uri storage', {
+  uriStorage: true,
+});
+
+testERC721('mintable + uri storage', {
+  mintable: true,
+  uriStorage: true,
+});
+
+testERC721('mintable + uri storage + incremental', {
+  mintable: true,
+  uriStorage: true,
+  incremental: true,
+});
+
+testERC721('burnable', {
+  burnable: true,
+});
+
+testERC721('burnable + uri storage', {
+  uriStorage: true,
+  burnable: true,
+});
+
+testERC721('pausable', {
+  pausable: true,
+});
+
+testERC721('mintable', {
+  mintable: true,
+});
+
+testERC721('mintable + roles', {
+  mintable: true,
+  access: 'roles',
+});
+
+testERC721('mintable + incremental', {
+  mintable: true,
+  incremental: true,
+});
+
+testERC721('votes', {
+  votes: true,
+});
+
+testERC721('full upgradeable transparent', {
+  mintable: true,
+  enumerable: true,
+  pausable: true,
+  burnable: true,
+  votes: true,
+  upgradeable: 'transparent',
+});
+
+testERC721('full upgradeable uups', {
+  mintable: true,
+  enumerable: true,
+  pausable: true,
+  burnable: true,
+  votes: true,
+  upgradeable: 'uups',
+});
+
+testAPIEquivalence('API default');
+
+testAPIEquivalence('API basic', { name: 'CustomToken', symbol: 'CTK' });
+
+testAPIEquivalence('API full upgradeable', {
+  name: 'CustomToken',
+  symbol: 'CTK',
+  mintable: true,
+  enumerable: true,
+  pausable: true,
+  burnable: true,
+  votes: true,
+  upgradeable: 'uups',
+});
+
+test('API assert defaults', async t => {
+  t.is(erc721.print(erc721.defaults), erc721.print());
+});