@openzeppelin/upgrades-core 1.16.0 → 1.18.0

package/src/manifest.test.ts

@@ -1,5 +1,107 @@
-import test from 'ava';
+import test, { ExecutionContext } from 'ava';
 import { Manifest, ManifestData, normalizeManifestData } from './manifest';
+import { promises as fs } from 'fs';
+import path from 'path';
+
+async function writeTestManifest(file: string) {
+  const testManifest = {
+    manifestVersion: '3.2',
+    impls: {},
+    proxies: [
+      {
+        address: '0x123',
+        txHash: '0x0',
+        kind: 'uups',
+      },
+    ],
+  };
+  await fs.mkdir(path.dirname(file), { recursive: true });
+  await fs.writeFile(file, JSON.stringify(testManifest, null, 2) + '\n');
+}
+
+async function deleteFile(t: ExecutionContext, file: string) {
+  try {
+    await fs.unlink(file);
+  } catch (e: any) {
+    if (!e.message.includes('ENOENT')) {
+      t.fail(e);
+    }
+  }
+}
+
+async function assertOldName(t: ExecutionContext<unknown>, id: number) {
+  await fs.access(`.openzeppelin/unknown-${id}.json`);
+  t.throwsAsync(fs.access(`.openzeppelin/polygon-mumbai.json`));
+}
+
+async function assertNewName(t: ExecutionContext<unknown>, id: number) {
+  t.throwsAsync(fs.access(`.openzeppelin/unknown-${id}.json`));
+  await fs.access(`.openzeppelin/polygon-mumbai.json`);
+}
+
+async function deleteManifests(t: ExecutionContext<unknown>, id: number) {
+  await deleteFile(t, `.openzeppelin/unknown-${id}.json`);
+  await deleteFile(t, '.openzeppelin/polygon-mumbai.json');
+}
+
+test.serial('multiple manifests', async t => {
+  const id = 80001;
+  await deleteManifests(t, id);
+
+  await writeTestManifest(`.openzeppelin/unknown-${id}.json`);
+  await writeTestManifest(`.openzeppelin/polygon-mumbai.json`);
+
+  const manifest = new Manifest(id);
+  await manifest.lockedRun(async () => {
+    await t.throwsAsync(() => manifest.read(), {
+      message: new RegExp(
+        `Network files with different names .openzeppelin/unknown-${id}.json and .openzeppelin/polygon-mumbai.json were found for the same network.`,
+      ),
+    });
+  });
+
+  await deleteManifests(t, id);
+});
+
+test.serial('rename manifest', async t => {
+  const id = 80001;
+  await deleteManifests(t, id);
+
+  await writeTestManifest(`.openzeppelin/unknown-${id}.json`);
+
+  const manifest = new Manifest(id);
+  t.is(manifest.file, `.openzeppelin/polygon-mumbai.json`);
+
+  t.throwsAsync(fs.access(`.openzeppelin/chain-${id}.lock`));
+
+  await assertOldName(t, id);
+  await manifest.lockedRun(async () => {
+    await fs.access(`.openzeppelin/chain-${id}.lock`);
+    const data = await manifest.read();
+    data.proxies.push({
+      address: '0x456',
+      txHash: '0x0',
+      kind: 'uups',
+    });
+
+    await assertOldName(t, id);
+    await manifest.write(data);
+    await assertNewName(t, id);
+  });
+  await assertNewName(t, id);
+
+  t.throwsAsync(fs.access(`.openzeppelin/chain-${id}.lock`));
+
+  // check that the contents were persisted
+  const data = await new Manifest(id).read();
+  t.true(data.proxies[0].address === '0x123');
+  t.true(data.proxies[1].address === '0x456');
+  await assertNewName(t, id);
+
+  t.throwsAsync(fs.access(`.openzeppelin/chain-${id}.lock`));
+
+  await deleteManifests(t, id);
+});
 
 test('manifest name for a known network', t => {
   const manifest = new Manifest(1);

package/src/manifest.ts

@@ -8,6 +8,7 @@ import type { Deployment } from './deployment';
 import type { StorageLayout } from './storage';
 import { pick } from './utils/pick';
 import { mapValues } from './utils/map-values';
+import { UpgradesError } from './error';
 
 const currentManifestVersion = '3.2';
 
@@ -40,15 +41,23 @@ function defaultManifest(): ManifestData {
 const manifestDir = '.openzeppelin';
 
 export class Manifest {
+  readonly chainId: number;
   readonly file: string;
+  private readonly fallbackFile: string;
+
   private locked = false;
 
   static async forNetwork(provider: EthereumProvider): Promise<Manifest> {
     return new Manifest(await getChainId(provider));
   }
 
-  constructor(readonly chainId: number) {
-    const name = networkNames[chainId] ?? `unknown-${chainId}`;
+  constructor(chainId: number) {
+    this.chainId = chainId;
+
+    const fallbackName = `unknown-${this.chainId}`;
+    this.fallbackFile = path.join(manifestDir, `${fallbackName}.json`);
+
+    const name = networkNames[this.chainId] ?? fallbackName;
     this.file = path.join(manifestDir, `${name}.json`);
   }
 
@@ -89,10 +98,55 @@ export class Manifest {
     });
   }
 
+  private async exists(file: string): Promise<boolean> {
+    try {
+      await fs.access(file);
+      return true;
+    } catch (e: any) {
+      return false;
+    }
+  }
+
+  private async readFile(): Promise<string> {
+    if (this.file === this.fallbackFile) {
+      return await fs.readFile(this.file, 'utf8');
+    } else {
+      const fallbackExists = await this.exists(this.fallbackFile);
+      const fileExists = await this.exists(this.file);
+
+      if (fileExists && fallbackExists) {
+        throw new UpgradesError(
+          `Network files with different names ${this.fallbackFile} and ${this.file} were found for the same network.`,
+          () =>
+            `More than one network file was found for chain ID ${this.chainId}. Determine which file is the most up to date version, then take a backup of and delete the other file.`,
+        );
+      } else if (fallbackExists) {
+        return await fs.readFile(this.fallbackFile, 'utf8');
+      } else {
+        return await fs.readFile(this.file, 'utf8');
+      }
+    }
+  }
+
+  private async writeFile(content: string): Promise<void> {
+    await this.renameFileIfRequired();
+    await fs.writeFile(this.file, content);
+  }
+
+  private async renameFileIfRequired() {
+    if (this.file !== this.fallbackFile && (await this.exists(this.fallbackFile))) {
+      try {
+        await fs.rename(this.fallbackFile, this.file);
+      } catch (e: any) {
+        throw new Error(`Failed to rename network file from ${this.fallbackFile} to ${this.file}: ${e.message}`);
+      }
+    }
+  }
+
   async read(): Promise<ManifestData> {
     const release = this.locked ? undefined : await this.lock();
     try {
-      const data = JSON.parse(await fs.readFile(this.file, 'utf8')) as ManifestData;
+      const data = JSON.parse(await this.readFile()) as ManifestData;
       return validateOrUpdateManifestVersion(data);
     } catch (e: any) {
       if (e.code === 'ENOENT') {
@@ -110,7 +164,7 @@ export class Manifest {
       throw new Error('Manifest must be locked');
     }
     const normalized = normalizeManifestData(data);
-    await fs.writeFile(this.file, JSON.stringify(normalized, null, 2) + '\n');
+    await this.writeFile(JSON.stringify(normalized, null, 2) + '\n');
   }
 
   async lockedRun<T>(cb: () => Promise<T>): Promise<T> {
@@ -126,8 +180,10 @@ export class Manifest {
   }
 
   private async lock() {
-    await fs.mkdir(path.dirname(this.file), { recursive: true });
-    const release = await lockfile.lock(this.file, { retries: 3, realpath: false });
+    const lockfileName = path.join(manifestDir, `chain-${this.chainId}`);
+
+    await fs.mkdir(path.dirname(lockfileName), { recursive: true });
+    const release = await lockfile.lock(lockfileName, { retries: 3, realpath: false });
     this.locked = true;
     return async () => {
       await release();

package/src/provider.ts

@@ -1,5 +1,3 @@
-import BN from 'bn.js';
-
 export interface EthereumProvider {
   send(method: 'web3_clientVersion', params: []): Promise<string>;
   send(method: 'net_version', params: []): Promise<string>;
@@ -33,7 +31,7 @@ export async function getNetworkId(provider: EthereumProvider): Promise<string>
 
 export async function getChainId(provider: EthereumProvider): Promise<number> {
   const id = await provider.send('eth_chainId', []);
-  return new BN(id.replace(/^0x/, ''), 'hex').toNumber();
+  return parseInt(id.replace(/^0x/, ''), 16);
 }
 
 export async function getClientVersion(provider: EthereumProvider): Promise<string> {
@@ -104,6 +102,8 @@ export const networkNames: { [chainId in number]?: string } = Object.freeze({
   4: 'rinkeby',
   5: 'goerli',
   42: 'kovan',
+  137: 'polygon',
+  80001: 'polygon-mumbai',
 });
 
 export async function isDevelopmentNetwork(provider: EthereumProvider): Promise<boolean> {

package/src/usage-error.ts

@@ -51,6 +51,9 @@ export class PrepareUpgradeUnsupportedError extends UpgradesError {
   }
 }
 
+/**
+ * @deprecated No longer used since forceImport() supports importing any contract.
+ */
 export class ForceImportUnsupportedError extends UpgradesError {
   constructor(proxyOrBeaconAddress: string) {
     super(
@@ -60,6 +63,25 @@ export class ForceImportUnsupportedError extends UpgradesError {
   }
 }
 
+export class NoContractImportError extends UpgradesError {
+  constructor(address: string) {
+    super(
+      `No contract at address ${address}`,
+      () => `The address could not be imported because no contract was found at the address.`,
+    );
+  }
+}
+
+export class ValidateUpdateRequiresKindError extends UpgradesError {
+  constructor() {
+    super(
+      'The `kind` option must be provided',
+      () =>
+        'When validating an upgrade from an implementation address, pass in the `kind` option for the kind of proxy that you are using.',
+    );
+  }
+}
+
 export async function assertNotProxy(provider: EthereumProvider, address: string) {
   if (await isTransparentOrUUPSProxy(provider, address)) {
     throw new UpgradesError(

package/src/validate/index.ts

@@ -1,5 +1,5 @@
 export { validate, ValidationRunData, ContractValidation } from './run';
-export { ValidationOptions, withValidationDefaults } from './overrides';
+export { ProxyKindOption, StandaloneValidationOptions, ValidationOptions, withValidationDefaults } from './overrides';
 export { ValidationErrors } from './error';
 export { RunValidation, ValidationLog, Validation, ValidationResult } from './compat';
 export { ValidationData, ValidationDataCurrent, isCurrentValidationData, concatRunData } from './data';

package/src/validate/overrides.ts

@@ -5,13 +5,49 @@ import { logWarning } from '../utils/log';
 // Backwards compatibility
 export { silenceWarnings } from '../utils/log';
 
-export interface ValidationOptions {
+/**
+ * Option for the kind of proxy that will be used.
+ */
+export interface ProxyKindOption {
+  /**
+   * The kind of proxy to deploy, upgrade or import, or the kind of proxy that the implementation will be used with. Defaults to `"transparent"`.
+   */
+  kind?: ProxyDeployment['kind'];
+}
+
+/**
+ * Validation options in a standalone context (without storage layout comparisons with a previous implementation).
+ */
+export interface StandaloneValidationOptions extends ProxyKindOption {
+  /**
+   * @deprecated Equivalent to including "struct-definition" and "enum-definition" in unsafeAllow. No longer necessary.
+   */
   unsafeAllowCustomTypes?: boolean;
+
+  /**
+   * @deprecated Equivalent to including `"external-library-linking"` in {@link unsafeAllow}.
+   */
   unsafeAllowLinkedLibraries?: boolean;
+
+  /**
+   * Selectively disable one or more validation errors.
+   */
+  unsafeAllow?: ValidationError['kind'][];
+}
+
+/**
+ * Validation options in the context of an upgrade (with storage layout comparisions with a previous implementation).
+ */
+export interface ValidationOptions extends StandaloneValidationOptions {
+  /**
+   * Configure storage layout check to allow variable renaming.
+   */
   unsafeAllowRenames?: boolean;
+
+  /**
+   * Upgrades the proxy or beacon without first checking for storage layout compatibility errors. This is a dangerous option meant to be used as a last resort.
+   */
   unsafeSkipStorageCheck?: boolean;
-  unsafeAllow?: ValidationError['kind'][];
-  kind?: ProxyDeployment['kind'];
 }
 
 export const ValidationErrorUnsafeMessages: Record<ValidationError['kind'], string[]> = {