@openzeppelin/wizard 0.5.2 → 0.5.4

package/src/erc1155.ts

@@ -1,9 +1,12 @@
-import { Contract, ContractBuilder } from './contract';
-import { Access, setAccessControl, requireAccessControl } from './set-access-control';
+import type { Contract } from './contract';
+import { ContractBuilder } from './contract';
+import type { Access } from './set-access-control';
+import { setAccessControl, requireAccessControl } from './set-access-control';
 import { addPauseFunctions } from './add-pausable';
 import { supportsInterface } from './common-functions';
 import { defineFunctions } from './utils/define-functions';
-import { CommonOptions, withCommonDefaults, defaults as commonDefaults } from './common-options';
+import type { CommonOptions } from './common-options';
+import { withCommonDefaults, defaults as commonDefaults } from './common-options';
 import { setUpgradeable } from './set-upgradeable';
 import { setInfo } from './set-info';
 import { printContract } from './print';
@@ -28,7 +31,7 @@ export const defaults: Required<ERC1155Options> = {
   updatableUri: true,
   access: commonDefaults.access,
   upgradeable: commonDefaults.upgradeable,
-  info: commonDefaults.info
+  info: commonDefaults.info,
 } as const;
 
 function withDefaults(opts: ERC1155Options): Required<ERC1155Options> {
@@ -150,9 +153,7 @@ const functions = defineFunctions({
 
   setURI: {
     kind: 'public' as const,
-    args: [
-      { name: 'newuri', type: 'string memory' },
-    ],
+    args: [{ name: 'newuri', type: 'string memory' }],
   },
 
   mint: {

package/src/erc20.ts

@@ -1,12 +1,22 @@
-import { Contract, ContractBuilder } from './contract';
-import { Access, setAccessControl, requireAccessControl } from './set-access-control';
+import { ContractBuilder } from './contract';
+import type { Access } from './set-access-control';
+import { setAccessControl, requireAccessControl } from './set-access-control';
 import { addPauseFunctions } from './add-pausable';
 import { defineFunctions } from './utils/define-functions';
-import { CommonOptions, withCommonDefaults, defaults as commonDefaults } from './common-options';
+import type { CommonOptions } from './common-options';
+import { withCommonDefaults, defaults as commonDefaults } from './common-options';
+import type { Upgradeable } from './set-upgradeable';
 import { setUpgradeable } from './set-upgradeable';
 import { setInfo } from './set-info';
 import { printContract } from './print';
-import { ClockMode, clockModeDefault, setClockMode } from './set-clock-mode';
+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];
 
 export interface ERC20Options extends CommonOptions {
   name: string;
@@ -14,7 +24,9 @@ export interface ERC20Options extends CommonOptions {
   burnable?: boolean;
   pausable?: boolean;
   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.
@@ -22,6 +34,7 @@ export interface ERC20Options extends CommonOptions {
    */
   votes?: boolean | ClockMode;
   flashmint?: boolean;
+  crossChainBridging?: CrossChainBridging;
 }
 
 export const defaults: Required<ERC20Options> = {
@@ -30,10 +43,13 @@ export const defaults: Required<ERC20Options> = {
   burnable: false,
   pausable: false,
   premint: '0',
+  premintChainId: '',
   mintable: false,
+  callback: false,
   permit: true,
   votes: false,
   flashmint: false,
+  crossChainBridging: false,
   access: commonDefaults.access,
   upgradeable: commonDefaults.upgradeable,
   info: commonDefaults.info,
@@ -46,10 +62,13 @@ export function withDefaults(opts: ERC20Options): Required<ERC20Options> {
     burnable: opts.burnable ?? defaults.burnable,
     pausable: opts.pausable ?? defaults.pausable,
     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,
+    crossChainBridging: opts.crossChainBridging ?? defaults.crossChainBridging,
   };
 }
 
@@ -70,6 +89,14 @@ export function buildERC20(opts: ERC20Options): ContractBuilder {
 
   addBase(c, allOpts.name, allOpts.symbol);
 
+  if (allOpts.crossChainBridging) {
+    addCrossChainBridging(c, allOpts.crossChainBridging, allOpts.upgradeable, access);
+  }
+
+  if (allOpts.premint) {
+    addPremint(c, allOpts.premint, allOpts.premintChainId, allOpts.crossChainBridging);
+  }
+
   if (allOpts.burnable) {
     addBurnable(c);
   }
@@ -78,14 +105,14 @@ export function buildERC20(opts: ERC20Options): ContractBuilder {
     addPausableExtension(c, access);
   }
 
-  if (allOpts.premint) {
-    addPremint(c, allOpts.premint);
-  }
-
   if (allOpts.mintable) {
     addMintable(c, access);
   }
 
+  if (allOpts.callback) {
+    addCallback(c);
+  }
+
   // Note: Votes requires Permit
   if (allOpts.permit || allOpts.votes) {
     addPermit(c, allOpts.name);
@@ -112,10 +139,7 @@ function addBase(c: ContractBuilder, name: string, symbol: string) {
     name: 'ERC20',
     path: '@openzeppelin/contracts/token/ERC20/ERC20.sol',
   };
-  c.addParent(
-    ERC20,
-    [name, symbol],
-  );
+  c.addParent(ERC20, [name, symbol]);
 
   c.addOverride(ERC20, functions._update);
   c.addOverride(ERC20, functions._approve); // allows override from stablecoin
@@ -141,7 +165,26 @@ function addBurnable(c: ContractBuilder) {
 
 export const premintPattern = /^(\d*)(?:\.(\d+))?(?:e(\d+))?$/;
 
-function addPremint(c: ContractBuilder, amount: string) {
+export const chainIdPattern = /^(?!$)[1-9]\d*$/;
+
+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,
+  premintChainId: string,
+  crossChainBridging: CrossChainBridging,
+) {
   const m = amount.match(premintPattern);
   if (m) {
     const integer = m[1]?.replace(/^0+/, '') ?? '';
@@ -153,9 +196,56 @@ function addPremint(c: ContractBuilder, amount: string) {
       const zeroes = new Array(Math.max(0, -decimalPlace)).fill('0').join('');
       const units = integer + decimals + zeroes;
       const exp = decimalPlace <= 0 ? 'decimals()' : `(decimals() - ${decimalPlace})`;
-      c.addConstructorArgument({type: 'address', name: 'recipient'});
-      c.addConstructorCode(`_mint(recipient, ${units} * 10 ** ${exp});`);
+
+      const validatedBaseUnits = toUint256(units, 'premint');
+      checkPotentialPremintOverflow(validatedBaseUnits, decimalPlace);
+
+      c.addConstructorArgument({ type: 'address', name: 'recipient' });
+
+      const mintLine = `_mint(recipient, ${units} * 10 ** ${exp});`;
+
+      if (crossChainBridging) {
+        if (premintChainId === '') {
+          throw new OptionsError({
+            premintChainId: 'Chain ID is required when using Premint with Cross-Chain Bridging',
+          });
+        }
+
+        if (!isValidChainId(premintChainId)) {
+          throw new OptionsError({
+            premintChainId: 'Not a valid chain ID',
+          });
+        }
+
+        c.addConstructorCode(`if (block.chainid == ${premintChainId}) {`);
+        c.addConstructorCode(`    ${mintLine}`);
+        c.addConstructorCode(`}`);
+      } else {
+        c.addConstructorCode(mintLine);
+      }
     }
+  } else {
+    throw new OptionsError({
+      premint: 'Not a valid number',
+    });
+  }
+}
+
+/**
+ * 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',
+    });
   }
 }
 
@@ -164,6 +254,15 @@ function addMintable(c: ContractBuilder, access: Access) {
   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',
@@ -171,7 +270,6 @@ function addPermit(c: ContractBuilder, name: string) {
   };
   c.addParent(ERC20Permit, [name]);
   c.addOverride(ERC20Permit, functions.nonces);
-
 }
 
 function addVotes(c: ContractBuilder, clockMode: ClockMode) {
@@ -190,9 +288,12 @@ function addVotes(c: ContractBuilder, clockMode: ClockMode) {
     name: 'Nonces',
     path: '@openzeppelin/contracts/utils/Nonces.sol',
   });
-  c.addOverride({
-    name: 'Nonces',
-  }, functions.nonces);
+  c.addOverride(
+    {
+      name: 'Nonces',
+    },
+    functions.nonces,
+  );
 
   setClockMode(c, ERC20Votes, clockMode);
 }
@@ -204,6 +305,113 @@ function addFlashMint(c: ContractBuilder) {
   });
 }
 
+function addCrossChainBridging(
+  c: ContractBuilder,
+  crossChainBridging: 'custom' | 'superchain',
+  upgradeable: Upgradeable,
+  access: Access,
+) {
+  const ERC20Bridgeable = {
+    name: 'ERC20Bridgeable',
+    path: `@openzeppelin/community-contracts/contracts/token/ERC20/extensions/ERC20Bridgeable.sol`,
+  };
+
+  c.addParent(ERC20Bridgeable);
+  c.addOverride(ERC20Bridgeable, supportsInterface);
+
+  if (upgradeable) {
+    throw new OptionsError({
+      crossChainBridging: 'Upgradeability is not currently supported with Cross-Chain Bridging',
+    });
+  }
+
+  c.addOverride(ERC20Bridgeable, functions._checkTokenBridge);
+  switch (crossChainBridging) {
+    case 'custom':
+      addCustomBridging(c, access);
+      break;
+    case 'superchain':
+      addSuperchainERC20(c);
+      break;
+    default: {
+      const _: never = crossChainBridging;
+      throw new Error('Unknown value for `crossChainBridging`');
+    }
+  }
+  c.addVariable('error Unauthorized();');
+}
+
+function addCustomBridging(c: ContractBuilder, access: Access) {
+  switch (access) {
+    case false:
+    case 'ownable': {
+      const addedBridgeImmutable = c.addVariable(`address public immutable TOKEN_BRIDGE;`);
+      if (addedBridgeImmutable) {
+        c.addConstructorArgument({ type: 'address', name: 'tokenBridge' });
+        c.addConstructorCode(`require(tokenBridge != address(0), "Invalid TOKEN_BRIDGE address");`);
+        c.addConstructorCode(`TOKEN_BRIDGE = tokenBridge;`);
+      }
+      c.setFunctionBody([`if (caller != TOKEN_BRIDGE) revert Unauthorized();`], functions._checkTokenBridge, 'view');
+      break;
+    }
+    case 'roles': {
+      setAccessControl(c, access);
+      const roleOwner = 'tokenBridge';
+      const roleId = 'TOKEN_BRIDGE_ROLE';
+      const addedRoleConstant = c.addVariable(`bytes32 public constant ${roleId} = keccak256("${roleId}");`);
+      if (addedRoleConstant) {
+        c.addConstructorArgument({ type: 'address', name: roleOwner });
+        c.addConstructorCode(`_grantRole(${roleId}, ${roleOwner});`);
+      }
+      c.setFunctionBody(
+        [`if (!hasRole(${roleId}, caller)) revert Unauthorized();`],
+        functions._checkTokenBridge,
+        'view',
+      );
+      break;
+    }
+    case 'managed': {
+      setAccessControl(c, access);
+      c.addImportOnly({
+        name: 'AuthorityUtils',
+        path: `@openzeppelin/contracts/access/manager/AuthorityUtils.sol`,
+      });
+      c.setFunctionBody(
+        [
+          `(bool immediate,) = AuthorityUtils.canCallWithDelay(authority(), caller, address(this), bytes4(_msgData()[0:4]));`,
+          `if (!immediate) revert Unauthorized();`,
+        ],
+        functions._checkTokenBridge,
+        'view',
+      );
+      break;
+    }
+    default: {
+      const _: never = access;
+      throw new Error('Unknown value for `access`');
+    }
+  }
+}
+
+function addSuperchainERC20(c: ContractBuilder) {
+  c.addVariable('address internal constant SUPERCHAIN_TOKEN_BRIDGE = 0x4200000000000000000000000000000000000028;');
+  c.setFunctionBody(
+    ['if (caller != SUPERCHAIN_TOKEN_BRIDGE) revert Unauthorized();'],
+    functions._checkTokenBridge,
+    'pure',
+  );
+  c.setFunctionComments(
+    [
+      '/**',
+      ' * @dev Checks if the caller is the predeployed SuperchainTokenBridge. Reverts otherwise.',
+      ' *',
+      ' * IMPORTANT: The predeployed SuperchainTokenBridge is only available on chains in the Superchain.',
+      ' */',
+    ],
+    functions._checkTokenBridge,
+  );
+}
+
 export const functions = defineFunctions({
   _update: {
     kind: 'internal' as const,
@@ -249,10 +457,13 @@ export const functions = defineFunctions({
 
   nonces: {
     kind: 'public' as const,
-    args: [
-      { name: 'owner', type: 'address' },
-    ],
+    args: [{ name: 'owner', type: 'address' }],
     returns: ['uint256'],
     mutability: 'view' as const,
-  }
+  },
+
+  _checkTokenBridge: {
+    kind: 'internal' as const,
+    args: [{ name: 'caller', type: 'address' }],
+  },
 });

package/src/erc721.ts

@@ -1,13 +1,17 @@
-import { BaseFunction, Contract, ContractBuilder } from './contract';
-import { Access, setAccessControl, requireAccessControl } from './set-access-control';
+import type { BaseFunction, Contract } from './contract';
+import { ContractBuilder } from './contract';
+import type { Access } from './set-access-control';
+import { setAccessControl, requireAccessControl } from './set-access-control';
 import { addPauseFunctions } from './add-pausable';
 import { supportsInterface } from './common-functions';
 import { defineFunctions } from './utils/define-functions';
-import { CommonOptions, withCommonDefaults, defaults as commonDefaults } from './common-options';
+import type { CommonOptions } from './common-options';
+import { withCommonDefaults, defaults as commonDefaults } from './common-options';
 import { setUpgradeable } from './set-upgradeable';
 import { setInfo } from './set-info';
 import { printContract } from './print';
-import { ClockMode, clockModeDefault, setClockMode } from './set-clock-mode';
+import type { ClockMode } from './set-clock-mode';
+import { clockModeDefault, setClockMode } from './set-clock-mode';
 
 export interface ERC721Options extends CommonOptions {
   name: string;

package/src/error.ts

@@ -2,6 +2,6 @@ export type OptionsErrorMessages = { [prop in string]?: string };
 
 export class OptionsError extends Error {
   constructor(readonly messages: OptionsErrorMessages) {
-    super("Invalid options for Governor");
+    super('Invalid options');
   }
 }

package/src/generate/alternatives.ts

@@ -1,14 +1,10 @@
-import { mapValues } from "../utils/map-values";
-
 type Blueprint = Record<string, readonly unknown[]>;
 
 type Alternatives<B extends Blueprint> = {
   [k in keyof B]: B[k][number];
 };
 
-export function* generateAlternatives<B extends Blueprint>(
-  blueprint: B,
-): Generator<Alternatives<B>> {
+export function* generateAlternatives<B extends Blueprint>(blueprint: B): Generator<Alternatives<B>> {
   const entries = Object.entries(blueprint).map(([key, values]) => ({
     key,
     values,
@@ -17,9 +13,7 @@ export function* generateAlternatives<B extends Blueprint>(
   }));
 
   for (; !done(); advance()) {
-    yield Object.fromEntries(
-      entries.map(e => [e.key, e.values[e.current % e.limit]]),
-    ) as Alternatives<B>;
+    yield Object.fromEntries(entries.map(e => [e.key, e.values[e.current % e.limit]])) as Alternatives<B>;
   }
 
   function done() {

package/src/generate/erc20.ts

@@ -1,4 +1,4 @@
-import type { ERC20Options } from '../erc20';
+import { crossChainBridgingOptions, type ERC20Options } from '../erc20';
 import { accessOptions } from '../set-access-control';
 import { clockModeOptions } from '../set-clock-mode';
 import { infoOptions } from '../set-info';
@@ -13,15 +13,23 @@ const blueprint = {
   burnable: booleans,
   pausable: booleans,
   mintable: booleans,
+  callback: booleans,
   permit: booleans,
-  votes: [ ...booleans, ...clockModeOptions ] as const,
+  votes: [...booleans, ...clockModeOptions] as const,
   flashmint: booleans,
   premint: ['1'],
+  premintChainId: ['10'],
+  crossChainBridging: crossChainBridgingOptions,
   access: accessOptions,
   upgradeable: upgradeableOptions,
   info: infoOptions,
 };
 
 export function* generateERC20Options(): Generator<Required<ERC20Options>> {
-  yield* generateAlternatives(blueprint);
+  for (const opts of generateAlternatives(blueprint)) {
+    // crossChainBridging does not currently support upgradeable
+    if (!(opts.crossChainBridging && opts.upgradeable)) {
+      yield opts;
+    }
+  }
 }

package/src/generate/erc721.ts

@@ -20,7 +20,7 @@ const blueprint = {
   access: accessOptions,
   upgradeable: upgradeableOptions,
   info: infoOptions,
-  votes: [ ...booleans, ...clockModeOptions ] as const,
+  votes: [...booleans, ...clockModeOptions] as const,
 };
 
 export function* generateERC721Options(): Generator<Required<ERC721Options>> {

package/src/generate/governor.ts

@@ -1,4 +1,5 @@
-import { defaults, GovernorOptions, timelockOptions, votesOptions } from '../governor';
+import type { GovernorOptions } from '../governor';
+import { defaults, timelockOptions, votesOptions } from '../governor';
 import { accessOptions } from '../set-access-control';
 import { clockModeOptions } from '../set-clock-mode';
 import { infoOptions } from '../set-info';

package/src/generate/sources.ts

@@ -8,7 +8,8 @@ import { generateERC1155Options } from './erc1155';
 import { generateStablecoinOptions } from './stablecoin';
 import { generateGovernorOptions } from './governor';
 import { generateCustomOptions } from './custom';
-import { buildGeneric, GenericOptions, KindedOptions } from '../build-generic';
+import type { GenericOptions, KindedOptions } from '../build-generic';
+import { buildGeneric } from '../build-generic';
 import { printContract } from '../print';
 import { OptionsError } from '../error';
 import { findCover } from '../utils/find-cover';
@@ -76,11 +77,7 @@ function generateContractSubset(subset: Subset, kind?: Kind): GeneratedContract[
   const contracts = [];
 
   for (const options of generateOptions(kind)) {
-    const id = crypto
-      .createHash('sha1')
-      .update(JSON.stringify(options))
-      .digest()
-      .toString('hex');
+    const id = crypto.createHash('sha1').update(JSON.stringify(options)).digest().toString('hex');
 
     try {
       const contract = buildGeneric(options);
@@ -99,8 +96,14 @@ function generateContractSubset(subset: Subset, kind?: Kind): GeneratedContract[
   } else {
     const getParents = (c: GeneratedContract) => c.contract.parents.map(p => p.contract.path);
     return [
-      ...findCover(contracts.filter(c => c.options.upgradeable), getParents),
-      ...findCover(contracts.filter(c => !c.options.upgradeable), getParents),
+      ...findCover(
+        contracts.filter(c => c.options.upgradeable),
+        getParents,
+      ),
+      ...findCover(
+        contracts.filter(c => !c.options.upgradeable),
+        getParents,
+      ),
     ];
   }
 }

package/src/generate/stablecoin.ts

@@ -1,31 +1,52 @@
-import type { StablecoinOptions } from '../stablecoin';
+import { crossChainBridgingOptions } from '../erc20';
 import { accessOptions } from '../set-access-control';
-import { clockModeOptions } from '../set-clock-mode';
 import { infoOptions } from '../set-info';
-import { upgradeableOptions } from '../set-upgradeable';
+import type { StablecoinOptions } from '../stablecoin';
 import { generateAlternatives } from './alternatives';
 
 const booleans = [true, false];
 
-const blueprint = {
+const erc20Basic = {
   name: ['MyStablecoin'],
   symbol: ['MST'],
-  burnable: booleans,
-  pausable: booleans,
-  mintable: booleans,
-  permit: booleans,
-  limitations: [false, 'allowlist', 'blocklist'] as const,
-  votes: [ ...booleans, ...clockModeOptions ] as const,
-  flashmint: booleans,
+  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,
   premint: ['1'],
-  custodian: booleans,
+  premintChainId: [''],
+  crossChainBridging: [false] as const,
+  access: [false] as const,
+  info: [{}] as const,
+};
+
+const erc20Full = {
+  name: ['MyStablecoin'],
+  symbol: ['MST'],
+  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,
+  premint: ['1'],
+  premintChainId: ['10'],
+  crossChainBridging: crossChainBridgingOptions,
   access: accessOptions,
-  upgradeable: upgradeableOptions,
   info: infoOptions,
 };
 
+const stablecoinExtensions = {
+  limitations: [false, 'allowlist', 'blocklist'] as const,
+  custodian: booleans,
+  upgradeable: [false] as const,
+};
+
 export function* generateStablecoinOptions(): Generator<Required<StablecoinOptions>> {
-  for (const opts of generateAlternatives(blueprint)) {
-    yield { ...opts, upgradeable: false };
-  }
+  yield* generateAlternatives({ ...erc20Basic, ...stablecoinExtensions });
+  yield* generateAlternatives({ ...erc20Full, ...stablecoinExtensions });
 }

package/src/get-imports.ts

@@ -11,10 +11,10 @@ export interface SolcInputSources {
 }
 
 /**
-* Gets the source code for all imports of a contract, including all transitive dependencies,
-* in a format compatible with the Solidity compiler input's `sources` field.
-*
-* Does not include the contract itself (use `printContract` for that if needed).
+ * Gets the source code for all imports of a contract, including all transitive dependencies,
+ * in a format compatible with the Solidity compiler input's `sources` field.
+ *
+ * Does not include the contract itself (use `printContract` for that if needed).
  *
  * @param c The contract to get imports for.
  * @returns A record of import paths to `content` that contains the source code for each contract.
@@ -42,4 +42,4 @@ export function getImports(c: Contract): SolcInputSources {
   }
 
   return result;
-}
+}