@openzeppelin/upgrades-core 1.9.1

package/src/stub-provider.ts

@@ -0,0 +1,120 @@
+import crypto from 'crypto';
+
+import { ImplDeployment } from './manifest';
+
+const defaultClientVersion = 'unknown';
+
+function genChainId(): number {
+  return 100 + crypto.randomBytes(2).readUInt16BE(0);
+}
+
+// eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
+export function stubProvider(chainId = genChainId(), clientVersion = defaultClientVersion) {
+  const contracts = new Set<string>();
+  const pendingTxs = new Set<string>();
+  const failedTxs = new Set<string>();
+  const blocks = new Map<string, string[]>();
+  const txBlock = new Map<string, string>();
+  const methodCounters = new Map<string, number>();
+
+  function mine() {
+    const blockHash = '0x' + crypto.randomBytes(32).toString('hex');
+    blocks.set(blockHash, [...pendingTxs]);
+    for (const tx of pendingTxs) {
+      txBlock.set(tx, blockHash);
+    }
+    pendingTxs.clear();
+  }
+
+  async function deploy(immediate = true): Promise<ImplDeployment> {
+    const address = '0x' + crypto.randomBytes(20).toString('hex');
+    const txHash = '0x' + crypto.randomBytes(32).toString('hex');
+    contracts.add(address);
+    pendingTxs.add(txHash);
+    if (immediate) {
+      mine();
+    }
+    return {
+      address,
+      txHash,
+      layout: {
+        storage: [],
+        types: {},
+      },
+    };
+  }
+
+  const deployPending = () => deploy(false);
+
+  return {
+    mine,
+    deploy,
+    deployPending,
+    get deployCount() {
+      return contracts.size;
+    },
+    isContract(address: string) {
+      return contracts.has(address);
+    },
+    removeContract(address: string) {
+      return contracts.delete(address);
+    },
+    addContract(address: string) {
+      return contracts.add(address);
+    },
+    getMethodCount(method: string) {
+      return methodCounters.get(method) ?? 0;
+    },
+    failTx(txHash: string) {
+      return failedTxs.add(txHash);
+    },
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    async send(method: string, params?: unknown[]): Promise<any> {
+      methodCounters.set(method, 1 + (methodCounters.get(method) ?? 0));
+
+      if (method === 'eth_chainId') {
+        return '0x' + chainId.toString(16);
+      } else if (method === 'eth_getCode') {
+        const param = params?.[0];
+        if (typeof param !== 'string') {
+          throw new Error('Param must be string');
+        }
+        if (contracts.has(param)) {
+          return '0x1234';
+        } else {
+          return '0x';
+        }
+      } else if (method === 'eth_getTransactionByHash') {
+        const param = params?.[0];
+        if (typeof param !== 'string') {
+          throw new Error('Param must be string');
+        }
+        if (txBlock.has(param) || pendingTxs.has(param)) {
+          return {
+            blockHash: txBlock.get(param) || null,
+          };
+        } else {
+          return null;
+        }
+      } else if (method === 'web3_clientVersion') {
+        return clientVersion;
+      } else if (method === 'eth_getTransactionReceipt') {
+        const param = params?.[0];
+        if (typeof param !== 'string') {
+          throw new Error('Param must be string');
+        }
+        if (txBlock.has(param)) {
+          return {
+            transactionHash: param,
+            blockHash: txBlock.get(param),
+            status: failedTxs.has(param) ? '0x0' : '0x1',
+          };
+        } else {
+          return null;
+        }
+      } else {
+        throw new Error(`Method ${method} not stubbed`);
+      }
+    },
+  };
+}

package/src/utils/assert.ts

@@ -0,0 +1,9 @@
+export function assertUnreachable(_: never): never {
+  assert(false);
+}
+
+export function assert(p: unknown): asserts p {
+  if (!p) {
+    throw new Error('An unexpected condition occurred. Please report this at https://zpl.in/upgrades/report');
+  }
+}

package/src/utils/curry.ts

@@ -0,0 +1,17 @@
+export interface Curried<A, B, T> {
+  (a: A): (b: B) => T;
+  (a: A, b: B): T;
+}
+
+export function curry2<A, B, T>(fn: (a: A, b: B) => T): Curried<A, B, T> {
+  function curried(a: A): (b: B) => T;
+  function curried(a: A, b: B): T;
+  function curried(a: A, ...b: [] | [B]): T | ((b: B) => T) {
+    if (b.length === 0) {
+      return b => fn(a, b);
+    } else {
+      return fn(a, ...b);
+    }
+  }
+  return curried;
+}

package/src/utils/debug.ts

@@ -0,0 +1,3 @@
+import debug from 'debug';
+
+export default debug('@openzeppelin:upgrades:core');

package/src/utils/deep-array.test.ts

@@ -0,0 +1,21 @@
+import test from 'ava';
+
+import { deepEqual } from './deep-array';
+
+test('depth 0', t => {
+  t.true(deepEqual('a', 'a'));
+  t.false(deepEqual('a', 'b'));
+  t.false(deepEqual('a', ['a']));
+  t.false(deepEqual(['a'], 'a'));
+});
+
+test('depth 1', t => {
+  t.true(deepEqual(['a', 'b'], ['a', 'b']));
+  t.false(deepEqual(['a'], ['a', 'b']));
+  t.false(deepEqual(['a', 'b'], ['a', 'c']));
+});
+
+test('depth 2', t => {
+  t.true(deepEqual([['a'], ['b']], [['a'], ['b']]));
+  t.false(deepEqual([['a'], ['b']], [['a'], ['c']]));
+});

package/src/utils/deep-array.ts

@@ -0,0 +1,9 @@
+export type DeepArray<T> = T | DeepArray<T>[];
+
+export function deepEqual<T>(a: DeepArray<T>, b: DeepArray<T>): boolean {
+  if (Array.isArray(a) && Array.isArray(b)) {
+    return a.length === b.length && a.every((v, i) => deepEqual(v, b[i]));
+  } else {
+    return a === b;
+  }
+}

package/src/utils/function.test.ts

@@ -0,0 +1,37 @@
+import test from 'ava';
+import { artifacts } from 'hardhat';
+import { FunctionDefinition } from 'solidity-ast';
+import { findAll } from 'solidity-ast/utils';
+
+import { getFunctionSignature } from './function';
+import { SolcOutput } from '../solc-api';
+import { astDereferencer } from '../ast-dereferencer';
+
+testContract('ContractFunctionSignatures');
+testContract('LibraryFunctionSignatures');
+
+function testContract(contractName: string) {
+  test(contractName, async t => {
+    const fileName = 'contracts/test/FunctionSignatures.sol';
+    const buildInfo = await artifacts.getBuildInfo(`${fileName}:${contractName}`);
+    if (buildInfo === undefined) {
+      throw new Error('Build info not found');
+    }
+
+    const solcOutput: SolcOutput = buildInfo.output;
+
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+    const signatures = Object.keys(solcOutput.contracts[fileName][contractName].evm.methodIdentifiers!);
+
+    const functions: Record<string, FunctionDefinition> = {};
+    for (const def of findAll('FunctionDefinition', solcOutput.sources[fileName].ast)) {
+      functions[def.name] = def;
+    }
+    const deref = astDereferencer(solcOutput);
+
+    for (const signature of signatures) {
+      const name = signature.replace(/\(.*/, '');
+      t.is(getFunctionSignature(functions[name], deref), signature);
+    }
+  });
+}

package/src/utils/function.ts

@@ -0,0 +1,53 @@
+import type { FunctionDefinition, VariableDeclaration } from 'solidity-ast';
+import { ASTDereferencer } from '../ast-dereferencer';
+import { assert, assertUnreachable } from './assert';
+
+function serializeTypeName(parameter: VariableDeclaration, deref: ASTDereferencer): string {
+  const { typeName, storageLocation } = parameter;
+  assert(!!typeName);
+
+  if (storageLocation === 'storage') {
+    assert(typeof typeName.typeDescriptions.typeString === 'string');
+    return typeName.typeDescriptions.typeString.replace(/^struct /, '') + ' storage';
+  }
+
+  switch (typeName.nodeType) {
+    case 'ArrayTypeName':
+    case 'ElementaryTypeName': {
+      assert(typeof typeName.typeDescriptions.typeString === 'string');
+      return typeName.typeDescriptions.typeString;
+    }
+
+    case 'UserDefinedTypeName': {
+      const userDefinedType = deref(
+        ['StructDefinition', 'EnumDefinition', 'ContractDefinition'],
+        typeName.referencedDeclaration,
+      );
+      switch (userDefinedType.nodeType) {
+        case 'StructDefinition':
+          return '(' + userDefinedType.members.map(member => serializeTypeName(member, deref)) + ')';
+
+        case 'EnumDefinition':
+          assert(userDefinedType.members.length < 256);
+          return 'uint8';
+
+        case 'ContractDefinition':
+          return 'address';
+
+        default:
+          return assertUnreachable(userDefinedType);
+      }
+    }
+
+    case 'FunctionTypeName': {
+      return `function`;
+    }
+
+    default:
+      throw new Error(`Unsuported TypeName node type: ${typeName.nodeType}`);
+  }
+}
+
+export function getFunctionSignature(fnDef: FunctionDefinition, deref: ASTDereferencer): string {
+  return `${fnDef.name}(${fnDef.parameters.parameters.map(parameter => serializeTypeName(parameter, deref)).join()})`;
+}

package/src/utils/indent.ts

@@ -0,0 +1,3 @@
+export function indent(text: string, amount: number, amount0 = amount): string {
+  return text.replace(/^/gm, (_, i) => ' '.repeat(i === 0 ? amount0 : amount));
+}

package/src/utils/is-nullish.test.ts

@@ -0,0 +1,15 @@
+import test from 'ava';
+
+import { isNullish } from './is-nullish';
+
+test('null', t => {
+  t.true(isNullish(null));
+});
+
+test('undefined', t => {
+  t.true(isNullish(undefined));
+});
+
+test('number 5', t => {
+  t.false(isNullish(5));
+});

package/src/utils/is-nullish.ts

@@ -0,0 +1,3 @@
+export function isNullish(value: unknown): value is null | undefined {
+  return value === null || value === undefined;
+}

package/src/utils/is-value-type.ts

@@ -0,0 +1,5 @@
+import { ParsedTypeDetailed } from '../storage/layout';
+
+export function isValueType(type: ParsedTypeDetailed): boolean {
+  return type.args === undefined || ['t_contract', 't_enum'].includes(type.head);
+}

package/src/utils/itemize.ts

@@ -0,0 +1,16 @@
+// itemize returns a markdown-like list of the items
+
+// itemize['a\nb', 'c'] =
+// - a
+//   b
+// - c
+
+import { indent } from './indent';
+
+export function itemize(...items: string[]): string {
+  return itemizeWith('-', ...items);
+}
+
+export function itemizeWith(bullet: string, ...items: string[]): string {
+  return items.map(item => bullet + indent(item, 2, 1)).join('\n');
+}

package/src/utils/log.ts

@@ -0,0 +1,34 @@
+import chalk from 'chalk';
+
+import { indent } from './indent';
+
+let silenced = false;
+
+function log(prefix: string, title: string, lines: string[]): void {
+  if (silenced) {
+    return;
+  }
+
+  const parts = [chalk.yellow.bold(prefix + ':') + ' ' + title + '\n'];
+
+  if (lines.length > 0) {
+    parts.push(lines.map(l => indent(l, 4) + '\n').join(''));
+  }
+
+  console.error(parts.join('\n'));
+}
+
+export function logNote(title: string, lines: string[] = []): void {
+  log('Note', title, lines);
+}
+
+export function logWarning(title: string, lines: string[] = []): void {
+  log('Warning', title, lines);
+}
+
+export function silenceWarnings(): void {
+  logWarning(`All subsequent Upgrades warnings will be silenced.`, [
+    `Make sure you have manually checked all uses of unsafe flags.`,
+  ]);
+  silenced = true;
+}

package/src/utils/make-non-enumerable.ts

@@ -0,0 +1,4 @@
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function makeNonEnumerable<O extends any>(obj: O, key: keyof O): void {
+  Object.defineProperty(obj, key, { enumerable: false });
+}

package/src/utils/map-values.ts

@@ -0,0 +1,7 @@
+export function mapValues<V, W>(obj: Record<string, V>, fn: (value: V) => W): Record<string, W> {
+  const res: Partial<Record<string, W>> = {};
+  for (const k in obj) {
+    res[k] = fn(obj[k]);
+  }
+  return res as Record<string, W>;
+}

package/src/utils/parse-type-id.test.ts

@@ -0,0 +1,22 @@
+import test from 'ava';
+
+import { parseTypeId } from './parse-type-id';
+
+const fixtures = [
+  't_uint256',
+  't_enum(MyEnum)',
+  't_struct(MyComplexStruct)storage',
+  't_array(t_uint256)3_storage',
+  't_mapping(t_uint256,t_uint256)',
+  't_mapping(unknown,t_uint256)',
+  't_mapping(t_uint256,t_array(t_bool)dyn_storage)',
+  't_mapping(t_uint256,t_mapping(t_string_memory_ptr,t_address))',
+  't_function_internal_nonpayable(t_uint256)returns()',
+  't_array(t_function_internal_nonpayable(t_uint256)returns(t_address))10_storage',
+];
+
+for (const f of fixtures) {
+  test(f, t => {
+    t.snapshot(parseTypeId(f));
+  });
+}

package/src/utils/parse-type-id.test.ts.md

@@ -0,0 +1,264 @@
+# Snapshot report for `src/utils/parse-type-id.test.ts`
+
+The actual snapshot is saved in `parse-type-id.test.ts.snap`.
+
+Generated by [AVA](https://avajs.dev).
+
+## t_array(t_function_internal_nonpayable(t_uint256)returns(t_address))10_storage
+
+> Snapshot 1
+
+    {
+      args: [
+        {
+          args: [
+            {
+              args: undefined,
+              head: 't_uint256',
+              id: 't_uint256',
+              rets: undefined,
+              tail: undefined,
+            },
+          ],
+          head: 't_function_internal_nonpayable',
+          id: 't_function_internal_nonpayable(t_uint256)returns(t_address)',
+          rets: [
+            {
+              args: undefined,
+              head: 't_address',
+              id: 't_address',
+              rets: undefined,
+              tail: undefined,
+            },
+          ],
+          tail: undefined,
+        },
+      ],
+      head: 't_array',
+      id: 't_array(t_function_internal_nonpayable(t_uint256)returns(t_address))10_storage',
+      rets: undefined,
+      tail: '10_storage',
+    }
+
+## t_array(t_uint256)3_storage
+
+> Snapshot 1
+
+    {
+      args: [
+        {
+          args: undefined,
+          head: 't_uint256',
+          id: 't_uint256',
+          rets: undefined,
+          tail: undefined,
+        },
+      ],
+      head: 't_array',
+      id: 't_array(t_uint256)3_storage',
+      rets: undefined,
+      tail: '3_storage',
+    }
+
+## t_function_internal_nonpayable(t_uint256)returns()
+
+> Snapshot 1
+
+    {
+      args: [
+        {
+          args: undefined,
+          head: 't_uint256',
+          id: 't_uint256',
+          rets: undefined,
+          tail: undefined,
+        },
+      ],
+      head: 't_function_internal_nonpayable',
+      id: 't_function_internal_nonpayable(t_uint256)returns()',
+      rets: [],
+      tail: undefined,
+    }
+
+## t_mapping(t_uint256,t_array(t_bool)dyn_storage)
+
+> Snapshot 1
+
+    {
+      args: [
+        {
+          args: undefined,
+          head: 't_uint256',
+          id: 't_uint256',
+          rets: undefined,
+          tail: undefined,
+        },
+        {
+          args: [
+            {
+              args: undefined,
+              head: 't_bool',
+              id: 't_bool',
+              rets: undefined,
+              tail: undefined,
+            },
+          ],
+          head: 't_array',
+          id: 't_array(t_bool)dyn_storage',
+          rets: undefined,
+          tail: 'dyn_storage',
+        },
+      ],
+      head: 't_mapping',
+      id: 't_mapping(t_uint256,t_array(t_bool)dyn_storage)',
+      rets: undefined,
+      tail: undefined,
+    }
+
+## t_mapping(t_uint256,t_mapping(t_string_memory_ptr,t_address))
+
+> Snapshot 1
+
+    {
+      args: [
+        {
+          args: undefined,
+          head: 't_uint256',
+          id: 't_uint256',
+          rets: undefined,
+          tail: undefined,
+        },
+        {
+          args: [
+            {
+              args: undefined,
+              head: 't_string_memory_ptr',
+              id: 't_string_memory_ptr',
+              rets: undefined,
+              tail: undefined,
+            },
+            {
+              args: undefined,
+              head: 't_address',
+              id: 't_address',
+              rets: undefined,
+              tail: undefined,
+            },
+          ],
+          head: 't_mapping',
+          id: 't_mapping(t_string_memory_ptr,t_address)',
+          rets: undefined,
+          tail: undefined,
+        },
+      ],
+      head: 't_mapping',
+      id: 't_mapping(t_uint256,t_mapping(t_string_memory_ptr,t_address))',
+      rets: undefined,
+      tail: undefined,
+    }
+
+## t_mapping(t_uint256,t_uint256)
+
+> Snapshot 1
+
+    {
+      args: [
+        {
+          args: undefined,
+          head: 't_uint256',
+          id: 't_uint256',
+          rets: undefined,
+          tail: undefined,
+        },
+        {
+          args: undefined,
+          head: 't_uint256',
+          id: 't_uint256',
+          rets: undefined,
+          tail: undefined,
+        },
+      ],
+      head: 't_mapping',
+      id: 't_mapping(t_uint256,t_uint256)',
+      rets: undefined,
+      tail: undefined,
+    }
+
+## t_uint256
+
+> Snapshot 1
+
+    {
+      args: undefined,
+      head: 't_uint256',
+      id: 't_uint256',
+      rets: undefined,
+      tail: undefined,
+    }
+
+## t_mapping(unknown,t_uint256)
+
+> Snapshot 1
+
+    {
+      args: [
+        {
+          args: undefined,
+          head: 'unknown',
+          id: 'unknown',
+          rets: undefined,
+          tail: undefined,
+        },
+        {
+          args: undefined,
+          head: 't_uint256',
+          id: 't_uint256',
+          rets: undefined,
+          tail: undefined,
+        },
+      ],
+      head: 't_mapping',
+      id: 't_mapping(unknown,t_uint256)',
+      rets: undefined,
+      tail: undefined,
+    }
+
+## t_enum(MyEnum)
+
+> Snapshot 1
+
+    {
+      args: [
+        {
+          args: undefined,
+          head: 'MyEnum',
+          id: 'MyEnum',
+          rets: undefined,
+          tail: undefined,
+        },
+      ],
+      head: 't_enum',
+      id: 't_enum(MyEnum)',
+      rets: undefined,
+      tail: undefined,
+    }
+
+## t_struct(MyComplexStruct)storage
+
+> Snapshot 1
+
+    {
+      args: [
+        {
+          args: undefined,
+          head: 'MyComplexStruct',
+          id: 'MyComplexStruct',
+          rets: undefined,
+          tail: undefined,
+        },
+      ],
+      head: 't_struct',
+      id: 't_struct(MyComplexStruct)storage',
+      rets: undefined,
+      tail: 'storage',
+    }