@openzeppelin/upgrades-core 1.15.0 → 1.17.0

package/src/impl-store.ts

@@ -26,17 +26,17 @@ export interface ManifestField<T> {
  * @param deploy the deploy function
  * @param opts options containing the timeout and pollingInterval parameters. If undefined, assumes the timeout is not configurable and will not mention those parameters in the error message for TransactionMinedTimeout.
  * @param merge if true, adds a deployment to existing deployment by merging their addresses. Defaults to false.
- * @returns the deployment address
+ * @returns the deployment
  * @throws {InvalidDeployment} if the deployment is invalid
  * @throws {TransactionMinedTimeout} if the transaction was not confirmed within the timeout period
  */
-async function fetchOrDeployGeneric<T extends Deployment>(
+async function fetchOrDeployGeneric<T extends Deployment, U extends T = T>(
   lens: ManifestLens<T>,
   provider: EthereumProvider,
-  deploy: () => Promise<T>,
+  deploy: () => Promise<U>,
   opts?: DeployOpts,
   merge?: boolean,
-): Promise<string> {
+): Promise<U | Deployment> {
   const manifest = await Manifest.forNetwork(provider);
 
   try {
@@ -69,7 +69,7 @@ async function fetchOrDeployGeneric<T extends Deployment>(
 
     await waitAndValidateDeployment(provider, deployment, lens.type, opts);
 
-    return deployment.address;
+    return deployment;
   } catch (e) {
     // If we run into a deployment error, we remove it from the manifest.
     if (e instanceof InvalidDeployment) {
@@ -105,6 +105,16 @@ export async function fetchOrDeploy(
   opts?: DeployOpts,
   merge?: boolean,
 ): Promise<string> {
+  return (await fetchOrDeployGeneric(implLens(version.linkedWithoutMetadata), provider, deploy, opts, merge)).address;
+}
+
+export async function fetchOrDeployGetDeployment<T extends ImplDeployment>(
+  version: Version,
+  provider: EthereumProvider,
+  deploy: () => Promise<T>,
+  opts?: DeployOpts,
+  merge?: boolean,
+): Promise<T | Deployment> {
   return fetchOrDeployGeneric(implLens(version.linkedWithoutMetadata), provider, deploy, opts, merge);
 }
 
@@ -146,7 +156,7 @@ export async function fetchOrDeployAdmin(
   deploy: () => Promise<Deployment>,
   opts?: DeployOpts,
 ): Promise<string> {
-  return fetchOrDeployGeneric(adminLens, provider, deploy, opts);
+  return (await fetchOrDeployGeneric(adminLens, provider, deploy, opts)).address;
 }
 
 const adminLens = lens('proxy admin', 'proxy admin', data => ({

package/src/index.ts

@@ -1,5 +1,5 @@
 export * from './validate';
-export { fetchOrDeploy, fetchOrDeployAdmin } from './impl-store';
+export { fetchOrDeploy, fetchOrDeployAdmin, fetchOrDeployGetDeployment } from './impl-store';
 export * from './version';
 export * from './storage';
 export {

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> {