@openzeppelin/upgrades-core 1.9.1

package/src/error.ts

@@ -0,0 +1,26 @@
+import util from 'util';
+import chalk from 'chalk';
+
+interface ErrorDescriptor<E> {
+  msg: (e: E) => string;
+  hint?: (e: E) => string | undefined;
+  link?: string;
+}
+
+export type ErrorDescriptions<E extends { kind: string }> = {
+  [K in E['kind']]: ErrorDescriptor<E & { kind: K }>;
+};
+
+function noDetails() {
+  return '';
+}
+
+export class UpgradesError extends Error {
+  constructor(message: string, details = noDetails) {
+    super(message + '\n\n' + details());
+  }
+
+  [util.inspect.custom](): string {
+    return chalk.red.bold('Error:') + ' ' + this.message;
+  }
+}

package/src/impl-store.test.ts

@@ -0,0 +1,59 @@
+import test from 'ava';
+
+import { promises as fs } from 'fs';
+import rimrafAsync from 'rimraf';
+import util from 'util';
+import path from 'path';
+import os from 'os';
+
+import { fetchOrDeploy } from './impl-store';
+import { getVersion } from './version';
+import { stubProvider } from './stub-provider';
+
+const rimraf = util.promisify(rimrafAsync);
+
+test.before(async () => {
+  process.chdir(await fs.mkdtemp(path.join(os.tmpdir(), 'upgrades-core-test-')));
+});
+
+test.after(async () => {
+  await rimraf(process.cwd());
+});
+
+const version1 = getVersion('01');
+const version2 = getVersion('02', '02');
+
+test('deploys on cache miss', async t => {
+  const provider = stubProvider();
+  await fetchOrDeploy(version1, provider, provider.deploy);
+  t.is(provider.deployCount, 1);
+});
+
+test('reuses on cache hit', async t => {
+  const provider = stubProvider();
+  const cachedDeploy = () => fetchOrDeploy(version1, provider, provider.deploy);
+  const address1 = await cachedDeploy();
+  const address2 = await cachedDeploy();
+  t.is(provider.deployCount, 1);
+  t.is(address2, address1);
+});
+
+test('does not reuse unrelated version', async t => {
+  const provider = stubProvider();
+  const address1 = await fetchOrDeploy(version1, provider, provider.deploy);
+  const address2 = await fetchOrDeploy(version2, provider, provider.deploy);
+  t.is(provider.deployCount, 2);
+  t.not(address2, address1);
+});
+
+test('cleans up invalid deployment', async t => {
+  const chainId = 1234;
+  const provider1 = stubProvider(chainId);
+  // create a deployment on a network
+  await fetchOrDeploy(version1, provider1, provider1.deploy);
+  // try to fetch it on a different network with same chainId
+  const provider2 = stubProvider(chainId);
+  await t.throwsAsync(fetchOrDeploy(version1, provider2, provider2.deploy));
+  // the failed deployment has been cleaned up
+  await fetchOrDeploy(version1, provider2, provider2.deploy);
+});

package/src/impl-store.ts

@@ -0,0 +1,124 @@
+import debug from './utils/debug';
+import { Manifest, ManifestData, ImplDeployment } from './manifest';
+import { EthereumProvider, isDevelopmentNetwork } from './provider';
+import { Deployment, InvalidDeployment, resumeOrDeploy, waitAndValidateDeployment } from './deployment';
+import type { Version } from './version';
+
+interface ManifestLens<T> {
+  description: string;
+  (data: ManifestData): ManifestField<T>;
+}
+
+interface ManifestField<T> {
+  get(): T | undefined;
+  set(value: T | undefined): void;
+}
+
+async function fetchOrDeployGeneric<T extends Deployment>(
+  lens: ManifestLens<T>,
+  provider: EthereumProvider,
+  deploy: () => Promise<T>,
+): Promise<string> {
+  const manifest = await Manifest.forNetwork(provider);
+
+  try {
+    const deployment = await manifest.lockedRun(async () => {
+      debug('fetching deployment of', lens.description);
+      const data = await manifest.read();
+      const deployment = lens(data);
+      const stored = deployment.get();
+      if (stored === undefined) {
+        debug('deployment of', lens.description, 'not found');
+      }
+      const updated = await resumeOrDeploy(provider, stored, deploy);
+      if (updated !== stored) {
+        await checkForAddressClash(provider, data, updated);
+        deployment.set(updated);
+        await manifest.write(data);
+      }
+      return updated;
+    });
+
+    await waitAndValidateDeployment(provider, deployment);
+
+    return deployment.address;
+  } catch (e) {
+    // If we run into a deployment error, we remove it from the manifest.
+    if (e instanceof InvalidDeployment) {
+      await manifest.lockedRun(async () => {
+        const data = await manifest.read();
+        const deployment = lens(data);
+        const stored = deployment.get();
+        if (stored?.txHash === e.deployment.txHash) {
+          deployment.set(undefined);
+          await manifest.write(data);
+        }
+      });
+      e.removed = true;
+    }
+
+    throw e;
+  }
+}
+
+export async function fetchOrDeploy(
+  version: Version,
+  provider: EthereumProvider,
+  deploy: () => Promise<ImplDeployment>,
+): Promise<string> {
+  return fetchOrDeployGeneric(implLens(version.linkedWithoutMetadata), provider, deploy);
+}
+
+const implLens = (versionWithoutMetadata: string) =>
+  lens(`implementation ${versionWithoutMetadata}`, data => ({
+    get: () => data.impls[versionWithoutMetadata],
+    set: (value?: ImplDeployment) => (data.impls[versionWithoutMetadata] = value),
+  }));
+
+export async function fetchOrDeployAdmin(
+  provider: EthereumProvider,
+  deploy: () => Promise<Deployment>,
+): Promise<string> {
+  return fetchOrDeployGeneric(adminLens, provider, deploy);
+}
+
+const adminLens = lens('proxy admin', data => ({
+  get: () => data.admin,
+  set: (value?: Deployment) => (data.admin = value),
+}));
+
+function lens<T>(description: string, fn: (data: ManifestData) => ManifestField<T>): ManifestLens<T> {
+  return Object.assign(fn, { description });
+}
+
+async function checkForAddressClash(
+  provider: EthereumProvider,
+  data: ManifestData,
+  updated: Deployment,
+): Promise<void> {
+  const clash = lookupDeployment(data, updated.address);
+  if (clash !== undefined) {
+    if (await isDevelopmentNetwork(provider)) {
+      debug('deleting a previous deployment at address', updated.address);
+      clash.set(undefined);
+    } else {
+      throw new Error(
+        `The following deployment clashes with an existing one at ${updated.address}\n\n` +
+          JSON.stringify(updated, null, 2) +
+          `\n\n`,
+      );
+    }
+  }
+}
+
+function lookupDeployment(data: ManifestData, address: string): ManifestField<Deployment> | undefined {
+  if (data.admin?.address === address) {
+    return adminLens(data);
+  }
+
+  for (const versionWithoutMetadata in data.impls) {
+    if (data.impls[versionWithoutMetadata]?.address === address) {
+      return implLens(versionWithoutMetadata)(data);
+    }
+  }
+}

package/src/index.ts

@@ -0,0 +1,18 @@
+export * from './validate';
+export * from './impl-store';
+export * from './version';
+export * from './manifest';
+export * from './storage';
+export * from './eip-1967';
+export * from './provider';
+export * from './src-decoder';
+export * from './solc-api';
+export * from './deployment';
+export * from './link-refs';
+
+export { getStorageLayoutForAddress } from './manifest-storage-layout';
+
+export * from './scripts/migrate-oz-cli-project';
+
+export { logWarning } from './utils/log';
+export { setProxyKind } from './set-proxy-kind';

package/src/levenshtein.test.ts

@@ -0,0 +1,91 @@
+import test from 'ava';
+
+import { levenshtein } from './levenshtein';
+
+const match = <T>(a: T, b: T) => (a === b ? undefined : { kind: 'replace', original: a, updated: b });
+
+test('equal', t => {
+  const a = [...'abc'];
+  const b = [...'abc'];
+  const ops = levenshtein(a, b, match);
+  t.deepEqual(ops, []);
+});
+
+test('append', t => {
+  const a = [...'abc'];
+  const b = [...'abcd'];
+  const ops = levenshtein(a, b, match);
+  t.like(ops, {
+    length: 1,
+    0: {
+      kind: 'append',
+      updated: 'd',
+    },
+  });
+});
+
+test('delete from end', t => {
+  const a = [...'abcd'];
+  const b = [...'abc'];
+  const ops = levenshtein(a, b, match);
+  t.like(ops, {
+    length: 1,
+    0: {
+      kind: 'delete',
+      original: 'd',
+    },
+  });
+});
+
+test('delete from middle', t => {
+  const a = [...'abc'];
+  const b = [...'ac'];
+  const ops = levenshtein(a, b, match);
+  t.like(ops, {
+    length: 1,
+    0: {
+      kind: 'delete',
+      original: 'b',
+    },
+  });
+});
+
+test('delete from beginning', t => {
+  const a = [...'abc'];
+  const b = [...'bc'];
+  const ops = levenshtein(a, b, match);
+  t.like(ops, {
+    length: 1,
+    0: {
+      kind: 'delete',
+      original: 'a',
+    },
+  });
+});
+
+test('insert', t => {
+  const a = [...'abc'];
+  const b = [...'azbc'];
+  const ops = levenshtein(a, b, match);
+  t.like(ops, {
+    length: 1,
+    0: {
+      kind: 'insert',
+      updated: 'z',
+    },
+  });
+});
+
+test('replace', t => {
+  const a = [...'abc'];
+  const b = [...'axc'];
+  const ops = levenshtein(a, b, match);
+  t.like(ops, {
+    length: 1,
+    0: {
+      kind: 'replace',
+      original: 'b',
+      updated: 'x',
+    },
+  });
+});

package/src/levenshtein.ts

@@ -0,0 +1,116 @@
+export type BasicOperation<T> =
+  | {
+      kind: 'append' | 'insert';
+      updated: T;
+    }
+  | {
+      kind: 'delete';
+      original: T;
+    };
+
+export type Operation<T, C> = C | BasicOperation<T>;
+
+type GetChangeOp<T, C> = (a: T, b: T) => C | undefined;
+
+export function levenshtein<T, C>(a: T[], b: T[], getChangeOp: GetChangeOp<T, C>): Operation<T, C>[] {
+  const matrix = buildMatrix(a, b, getChangeOp);
+  return buildOps(matrix, a, b);
+}
+
+const CHANGE_COST = 3;
+const INSERTION_COST = 2;
+const DELETION_COST = 2;
+
+type MatrixOp<T, C> = BasicOperation<T> | { kind: 'change'; change: C } | { kind: 'nop' };
+type MatrixEntry<T, C> = MatrixOp<T, C> & { totalCost: number; predecessor?: MatrixEntry<T, C> };
+
+function buildMatrix<T, C>(a: T[], b: T[], getChangeOp: GetChangeOp<T, C>): MatrixEntry<T, C>[][] {
+  // matrix[i][j] will contain the last operation that takes a.slice(0, i) to b.slice(0, j)
+  // The list of operations can be recovered following the predecessors as in buildOps
+
+  const matrix: MatrixEntry<T, C>[][] = new Array(a.length + 1);
+
+  matrix[0] = new Array(b.length + 1);
+  matrix[0][0] = { kind: 'nop', totalCost: 0 };
+
+  // Populate first row
+  for (let j = 1; j <= b.length; j++) {
+    matrix[0][j] = insertion(0, j);
+  }
+
+  // Fill in the rest of the matrix
+  for (let i = 1; i <= a.length; i++) {
+    matrix[i] = new Array(b.length + 1);
+    matrix[i][0] = deletion(i, 0);
+    for (let j = 1; j <= b.length; j++) {
+      matrix[i][j] = minBy([change(i, j), insertion(i, j), deletion(i, j)], e => e.totalCost);
+    }
+  }
+
+  return matrix;
+
+  // The different kinds of matrix entries are built by these helpers
+
+  function insertion(i: number, j: number): MatrixEntry<T, C> {
+    const updated = b[j - 1];
+    const predecessor = matrix[i][j - 1];
+    const predCost = predecessor.totalCost;
+    if (j > a.length) {
+      return { kind: 'append', totalCost: predCost, predecessor, updated };
+    } else {
+      return { kind: 'insert', totalCost: predCost + INSERTION_COST, predecessor, updated };
+    }
+  }
+
+  function deletion(i: number, j: number): MatrixEntry<T, C> {
+    const original = a[i - 1];
+    const predecessor = matrix[i - 1][j];
+    const predCost = predecessor.totalCost;
+    return { kind: 'delete', totalCost: predCost + DELETION_COST, predecessor, original };
+  }
+
+  function change(i: number, j: number): MatrixEntry<T, C> {
+    const original = a[i - 1];
+    const updated = b[j - 1];
+    const predecessor = matrix[i - 1][j - 1];
+    const predCost = predecessor.totalCost;
+    const change = getChangeOp(original, updated);
+    if (change !== undefined) {
+      return { kind: 'change', totalCost: predCost + CHANGE_COST, predecessor, change };
+    } else {
+      return { kind: 'nop', totalCost: predCost, predecessor };
+    }
+  }
+}
+
+function minBy<T>(arr: [T, ...T[]], value: (item: T) => number): T {
+  let min = arr[0];
+  let minValue = value(min);
+
+  for (const item of arr) {
+    const itemValue = value(item);
+    if (itemValue < minValue) {
+      min = item;
+      minValue = itemValue;
+    }
+  }
+
+  return min;
+}
+
+function buildOps<T, C>(matrix: MatrixEntry<T, C>[][], a: T[], b: T[]): Operation<T, C>[] {
+  const ops: Operation<T, C>[] = [];
+
+  let entry: MatrixEntry<T, C> | undefined = matrix[a.length][b.length];
+
+  while (entry !== undefined) {
+    if (entry.kind === 'change') {
+      ops.unshift(entry.change);
+    } else if (entry.kind !== 'nop') {
+      ops.unshift(entry);
+    }
+    entry = entry.predecessor;
+  }
+
+  return ops;
+}

package/src/link-refs.test.ts

@@ -0,0 +1,77 @@
+import test from 'ava';
+import { SolcBytecode } from './solc-api';
+import { extractLinkReferences, unlinkBytecode, LinkReference } from './link-refs';
+
+const bytecodeSolc =
+  '0123456789__lib1____abcdef0123__lib2____4567890abcdef0123456__lib3______________789abcdef0123456789';
+const bytecodeArtifact = '0x' + bytecodeSolc;
+const bytecodeLink =
+  '0x01234567891ADDRLIB01abcdef01232ADDRLIB024567890abcdef01234563ADDRESSLIB030000000789abcdef0123456789';
+
+test('extractLinkReferences', t => {
+  const bytecode: SolcBytecode = {
+    linkReferences: {
+      'a.sol': {
+        lib1: [{ length: 5, start: 5 }],
+        lib2: [{ length: 5, start: 15 }],
+      },
+      'b.sol': {
+        lib3: [{ length: 10, start: 30 }],
+      },
+    },
+    object: bytecodeSolc,
+  };
+
+  const linkReferences: LinkReference[] = extractLinkReferences(bytecode);
+  t.is(linkReferences.length, 3);
+  t.deepEqual(linkReferences[0], {
+    src: 'a.sol',
+    name: 'lib1',
+    length: 5,
+    start: 5,
+    placeholder: '__lib1____',
+  });
+  t.deepEqual(linkReferences[1], {
+    src: 'a.sol',
+    name: 'lib2',
+    length: 5,
+    start: 15,
+    placeholder: '__lib2____',
+  });
+  t.deepEqual(linkReferences[2], {
+    src: 'b.sol',
+    name: 'lib3',
+    length: 10,
+    start: 30,
+    placeholder: '__lib3______________',
+  });
+});
+
+test('unlinkBytecode', t => {
+  const linkReferences: LinkReference[] = [
+    {
+      src: 'a.sol',
+      name: 'lib1',
+      length: 5,
+      start: 5,
+      placeholder: '__lib1____',
+    },
+    {
+      src: 'a.sol',
+      name: 'lib2',
+      length: 5,
+      start: 15,
+      placeholder: '__lib2____',
+    },
+    {
+      src: 'b.sol',
+      name: 'lib3',
+      length: 10,
+      start: 30,
+      placeholder: '__lib3______________',
+    },
+  ];
+  const unlinkedBytecode: string = unlinkBytecode(bytecodeLink, linkReferences);
+  t.is(unlinkedBytecode.length, bytecodeArtifact.length);
+  t.is(unlinkedBytecode, bytecodeArtifact);
+});