@openzeppelin/upgrades-core 1.9.1

package/src/provider.test.ts

@@ -0,0 +1,43 @@
+import test from 'ava';
+import { EthereumProvider, getTransactionReceipt } from './provider';
+
+const hash = '0x1234';
+
+function makeProviderReturning(result: unknown): EthereumProvider {
+  return { send: (_method: string, _params: unknown[]) => Promise.resolve(result) } as EthereumProvider;
+}
+
+test('getTransactionReceipt returns null', async t => {
+  const provider = makeProviderReturning(null);
+  t.is(await getTransactionReceipt(provider, hash), null);
+});
+
+test('getTransactionReceipt status returns 0x0', async t => {
+  const provider = makeProviderReturning({ status: '0x0' });
+  const receipt = await getTransactionReceipt(provider, hash);
+  t.is(receipt?.status, '0x0');
+});
+
+test('getTransactionReceipt status returns 0x1', async t => {
+  const provider = makeProviderReturning({ status: '0x1' });
+  const receipt = await getTransactionReceipt(provider, hash);
+  t.is(receipt?.status, '0x1');
+});
+
+test('getTransactionReceipt status normalizes to 0x0', async t => {
+  const provider = makeProviderReturning({ status: '0x000000000000000000000000' });
+  const receipt = await getTransactionReceipt(provider, hash);
+  t.is(receipt?.status, '0x0');
+});
+
+test('getTransactionReceipt status normalizes to 0x1', async t => {
+  const provider = makeProviderReturning({ status: '0x000000000000000000000001' });
+  const receipt = await getTransactionReceipt(provider, hash);
+  t.is(receipt?.status, '0x1');
+});
+
+test('getTransactionReceipt status returns empty hex', async t => {
+  const provider = makeProviderReturning({ status: '0x' });
+  const receipt = await getTransactionReceipt(provider, hash);
+  t.is(receipt?.status, '0x');
+});

package/src/provider.ts

@@ -0,0 +1,103 @@
+import BN from 'bn.js';
+
+export interface EthereumProvider {
+  send(method: 'web3_clientVersion', params: []): Promise<string>;
+  send(method: 'net_version', params: []): Promise<string>;
+  send(method: 'eth_chainId', params: []): Promise<string>;
+  send(method: 'eth_getCode', params: [string, string]): Promise<string>;
+  send(method: 'eth_getStorageAt', params: [string, string, string]): Promise<string>;
+  send(method: 'eth_getTransactionByHash', params: [string]): Promise<null | EthereumTransaction>;
+  send(method: 'eth_getTransactionReceipt', params: [string]): Promise<null | EthereumTransactionReceipt>;
+  send(method: string, params: unknown[]): Promise<unknown>;
+}
+
+interface EthereumTransaction {
+  blockHash: string | null;
+}
+
+interface EthereumTransactionReceipt {
+  status: string;
+  to: string | null;
+  from: string;
+  blockHash: string;
+  blockNumber: string;
+  transactionHash: string;
+  transactionIndex: string;
+}
+
+export async function getNetworkId(provider: EthereumProvider): Promise<string> {
+  return provider.send('net_version', []);
+}
+
+export async function getChainId(provider: EthereumProvider): Promise<number> {
+  const id = await provider.send('eth_chainId', []);
+  return new BN(id.replace(/^0x/, ''), 'hex').toNumber();
+}
+
+export async function getClientVersion(provider: EthereumProvider): Promise<string> {
+  return provider.send('web3_clientVersion', []);
+}
+
+export async function getStorageAt(
+  provider: EthereumProvider,
+  address: string,
+  position: string,
+  block = 'latest',
+): Promise<string> {
+  const storage = await provider.send('eth_getStorageAt', [address, position, block]);
+  const padded = storage.replace(/^0x/, '').padStart(64, '0');
+  return '0x' + padded;
+}
+
+export async function getCode(provider: EthereumProvider, address: string, block = 'latest'): Promise<string> {
+  return provider.send('eth_getCode', [address, block]);
+}
+
+export async function hasCode(provider: EthereumProvider, address: string, block?: string): Promise<boolean> {
+  const code = await getCode(provider, address, block);
+  return code !== '0x';
+}
+
+export async function getTransactionByHash(
+  provider: EthereumProvider,
+  txHash: string,
+): Promise<EthereumTransaction | null> {
+  return provider.send('eth_getTransactionByHash', [txHash]);
+}
+
+export async function getTransactionReceipt(
+  provider: EthereumProvider,
+  txHash: string,
+): Promise<EthereumTransactionReceipt | null> {
+  const receipt = await provider.send('eth_getTransactionReceipt', [txHash]);
+  if (receipt?.status) {
+    receipt.status = receipt.status.match(/^0x0+$/) ? '0x0' : receipt.status.replace(/^0x0+/, '0x');
+  }
+  return receipt;
+}
+
+export const networkNames: { [chainId in number]?: string } = Object.freeze({
+  1: 'mainnet',
+  2: 'morden',
+  3: 'ropsten',
+  4: 'rinkeby',
+  5: 'goerli',
+  42: 'kovan',
+});
+
+export async function isDevelopmentNetwork(provider: EthereumProvider): Promise<boolean> {
+  const chainId = await getChainId(provider);
+  //  1337 => ganache and geth --dev
+  // 31337 => hardhat network
+  if (chainId === 1337 || chainId === 31337) {
+    return true;
+  } else {
+    const clientVersion = await getClientVersion(provider);
+    const [name] = clientVersion.split('/', 1);
+    return name === 'HardhatNetwork' || name === 'EthereumJS TestRPC';
+  }
+}
+
+export function isReceiptSuccessful(receipt: Pick<EthereumTransactionReceipt, 'status'>): boolean {
+  return receipt.status === '0x1';
+}

package/src/scripts/migratable-manifest.test.json

@@ -0,0 +1,175 @@
+{
+  "contracts": {
+    "Box": {
+      "address": "0xb682dEEf4f8e298d86bFc3e21f50c675151FB974",
+      "constructorCode": "608060405234801561001057600080fd5b506101a3806100206000396000f3fe",
+      "bodyBytecodeHash": "0e331fb885de0fa7c715c4819b6ded2449542cb3cce682718791be28ae0789e8",
+      "localBytecodeHash": "08100f44a71d905a66088b4c5d72f12417a580d454357e06dcc5ad12b3fa2cbc",
+      "deployedBytecodeHash": "08100f44a71d905a66088b4c5d72f12417a580d454357e06dcc5ad12b3fa2cbc",
+      "types": {
+        "t_uint256": {
+          "id": "t_uint256",
+          "kind": "elementary",
+          "label": "uint256"
+        },
+        "t_bool": {
+          "id": "t_bool",
+          "kind": "elementary",
+          "label": "bool"
+        },
+        "t_mapping<t_bool>": {
+          "id": "t_mapping<t_bool>",
+          "valueType": "t_bool",
+          "label": "mapping(key => bool)",
+          "kind": "mapping"
+        },
+        "t_struct<Box.MyStruct>": {
+          "id": "t_struct<Box.MyStruct>",
+          "kind": "struct",
+          "label": "Box.MyStruct",
+          "members": [
+            {
+              "label": "x",
+              "astId": 3,
+              "type": "t_bool",
+              "src": "124:6:0"
+            }
+          ]
+        },
+        "t_enum<Box.MyEnum>": {
+          "id": "t_enum<Box.MyEnum>",
+          "kind": "enum",
+          "label": "Box.MyEnum",
+          "members": [
+            "UP",
+            "DOWN"
+          ]
+        },
+        "t_array:dyn<t_uint256>": {
+          "id": "t_array:dyn<t_uint256>",
+          "valueType": "t_uint256",
+          "length": "dyn",
+          "kind": "array",
+          "label": "uint256[]"
+        },
+        "t_array:10<t_uint256>": {
+          "id": "t_array:10<t_uint256>",
+          "valueType": "t_uint256",
+          "length": "10",
+          "kind": "array",
+          "label": "uint256[10]"
+        },
+        "t_array:dyn<t_enum<Box.MyEnum>>": {
+          "id": "t_array:dyn<t_enum<Box.MyEnum>>",
+          "valueType": "t_enum<Box.MyEnum>",
+          "length": "dyn",
+          "kind": "array",
+          "label": "Box.MyEnum[]"
+        },
+        "t_bytes8": {
+          "id": "t_bytes8",
+          "kind": "elementary",
+          "label": "bytes8"
+        }
+      },
+      "storage": [
+        {
+          "contract": "Box",
+          "path": "contracts/Box.sol",
+          "label": "value",
+          "astId": 9,
+          "type": "t_uint256",
+          "src": "173:21:0"
+        },
+        {
+          "contract": "Box",
+          "path": "contracts/Box.sol",
+          "label": "flag",
+          "astId": 11,
+          "type": "t_bool",
+          "src": "200:17:0"
+        },
+        {
+          "contract": "Box",
+          "path": "contracts/Box.sol",
+          "label": "map",
+          "astId": 15,
+          "type": "t_mapping<t_bool>",
+          "src": "223:26:0"
+        },
+        {
+          "contract": "Box",
+          "path": "contracts/Box.sol",
+          "label": "foo",
+          "astId": 17,
+          "type": "t_struct<Box.MyStruct>",
+          "src": "255:20:0"
+        },
+        {
+          "contract": "Box",
+          "path": "contracts/Box.sol",
+          "label": "myEnum",
+          "astId": 19,
+          "type": "t_enum<Box.MyEnum>",
+          "src": "281:21:0"
+        },
+        {
+          "contract": "Box",
+          "path": "contracts/Box.sol",
+          "label": "dynArray",
+          "astId": 22,
+          "type": "t_array:dyn<t_uint256>",
+          "src": "308:23:0"
+        },
+        {
+          "contract": "Box",
+          "path": "contracts/Box.sol",
+          "label": "staticArray",
+          "astId": 26,
+          "type": "t_array:10<t_uint256>",
+          "src": "337:20:0"
+        },
+        {
+          "contract": "Box",
+          "path": "contracts/Box.sol",
+          "label": "enumArray",
+          "astId": 29,
+          "type": "t_array:dyn<t_enum<Box.MyEnum>>",
+          "src": "363:26:0"
+        },
+        {
+          "contract": "Box",
+          "path": "contracts/Box.sol",
+          "label": "byteArray",
+          "astId": 31,
+          "type": "t_bytes8",
+          "src": "395:16:0"
+        }
+      ],
+      "warnings": {
+        "hasConstructor": false,
+        "hasSelfDestruct": false,
+        "hasDelegateCall": false,
+        "hasInitialValuesInDeclarations": false,
+        "uninitializedBaseContracts": []
+      }
+    }
+  },
+  "solidityLibs": {},
+  "proxies": {
+    "my-project/Box": [
+      {
+        "address": "0xE4C10Db67595aF2Cb4166c8C274e0140f7E43059",
+        "version": "1.0.0",
+        "implementation": "0xb682dEEf4f8e298d86bFc3e21f50c675151FB974",
+        "admin": "0x1750499D05Ed1674d822430FB960d5F6731fDf64",
+        "kind": "Upgradeable"
+      }
+    ]
+  },
+  "manifestVersion": "2.2",
+  "version": "1.0.0",
+  "proxyAdmin": {
+    "address": "0x1750499D05Ed1674d822430FB960d5F6731fDf64"
+  }
+}

package/src/scripts/migrate-oz-cli-project.test.ts

@@ -0,0 +1,70 @@
+import os from 'os';
+import test from 'ava';
+import path from 'path';
+import util from 'util';
+import rimrafAsync from 'rimraf';
+import { promises as fs } from 'fs';
+import { compare as compareVersions } from 'compare-versions';
+import {
+  migrateManifestsData,
+  NetworkFileData,
+  ProjectFileData,
+  MigrationOutput,
+  migrateLegacyProject,
+} from './migrate-oz-cli-project';
+
+const rimraf = util.promisify(rimrafAsync);
+const BASE_PATH = 'src/scripts';
+const OPENZEPPELIN_FOLDER = '.openzeppelin';
+const PROJECT_FILE = path.join(OPENZEPPELIN_FOLDER, 'project.json');
+const EXPORT_FILE = 'openzeppelin-cli-export.json';
+const NETWORK_FILE = path.join(OPENZEPPELIN_FOLDER, 'rinkeby.json');
+
+let migratableData: NetworkFileData;
+let migrationOutput: MigrationOutput;
+let projectData: ProjectFileData;
+
+test.before(async () => {
+  migratableData = JSON.parse(await fs.readFile(path.join(BASE_PATH, 'migratable-manifest.test.json'), 'utf8'));
+  projectData = JSON.parse(await fs.readFile(path.join(BASE_PATH, 'project-file.test.json'), 'utf8'));
+  migrationOutput = migrateManifestsData({ rinkeby: migratableData });
+
+  process.chdir(await fs.mkdtemp(path.join(os.tmpdir(), 'migration-test-')));
+  await fs.mkdir(OPENZEPPELIN_FOLDER);
+  await fs.writeFile(PROJECT_FILE, JSON.stringify(projectData, null, 2));
+  await fs.writeFile(NETWORK_FILE, JSON.stringify(migratableData, null, 2));
+  await migrateLegacyProject();
+});
+
+test.after(async () => {
+  await rimraf(process.cwd());
+});
+
+test('transforms manifest data', async t => {
+  t.snapshot(migrationOutput.newManifestsData);
+});
+
+test('produces network export data', async t => {
+  t.snapshot(migrationOutput.networksExportData);
+});
+
+test('deletes project file', async t => {
+  const error = await t.throwsAsync(() => fs.access(PROJECT_FILE));
+  t.is(error.message, `ENOENT: no such file or directory, access '${PROJECT_FILE}'`);
+});
+
+test('export file contains networks and compiler data', async t => {
+  const actual = JSON.parse(await fs.readFile(EXPORT_FILE, 'utf8'));
+  const expected = {
+    networks: migrationOutput.networksExportData,
+    compiler: projectData.compiler,
+  };
+  t.deepEqual(actual, expected);
+});
+
+test('zosversion', t => {
+  const migratableDataZosVersion = { zosversion: '2.2', ...migratableData };
+  delete migratableDataZosVersion.manifestVersion;
+  const output = migrateManifestsData({ rinkeby: migratableDataZosVersion });
+  t.true(compareVersions(output.newManifestsData.rinkeby.manifestVersion, '3.0', '>='));
+});

package/src/scripts/migrate-oz-cli-project.test.ts.md

@@ -0,0 +1,146 @@
+# Snapshot report for `src/scripts/migrate-oz-cli-project.test.ts`
+
+The actual snapshot is saved in `migrate-oz-cli-project.test.ts.snap`.
+
+Generated by [AVA](https://avajs.dev).
+
+## transforms manifest data
+
+> Snapshot 1
+
+    {
+      rinkeby: {
+        admin: {
+          address: '0x1750499D05Ed1674d822430FB960d5F6731fDf64',
+        },
+        impls: {
+          '08100f44a71d905a66088b4c5d72f12417a580d454357e06dcc5ad12b3fa2cbc': {
+            address: '0xb682dEEf4f8e298d86bFc3e21f50c675151FB974',
+            layout: {
+              storage: [
+                {
+                  contract: 'Box',
+                  label: 'value',
+                  src: 'contracts/Box.sol',
+                  type: 't_uint256',
+                },
+                {
+                  contract: 'Box',
+                  label: 'flag',
+                  src: 'contracts/Box.sol',
+                  type: 't_bool',
+                },
+                {
+                  contract: 'Box',
+                  label: 'map',
+                  src: 'contracts/Box.sol',
+                  type: 't_mapping(unknown,t_bool)',
+                },
+                {
+                  contract: 'Box',
+                  label: 'foo',
+                  src: 'contracts/Box.sol',
+                  type: 't_struct(MyStruct)3_storage',
+                },
+                {
+                  contract: 'Box',
+                  label: 'myEnum',
+                  src: 'contracts/Box.sol',
+                  type: 't_enum(MyEnum)4',
+                },
+                {
+                  contract: 'Box',
+                  label: 'dynArray',
+                  src: 'contracts/Box.sol',
+                  type: 't_array(t_uint256)dyn_storage',
+                },
+                {
+                  contract: 'Box',
+                  label: 'staticArray',
+                  src: 'contracts/Box.sol',
+                  type: 't_array(t_uint256)10_storage',
+                },
+                {
+                  contract: 'Box',
+                  label: 'enumArray',
+                  src: 'contracts/Box.sol',
+                  type: 't_array(t_enum(MyEnum)4)dyn_storage',
+                },
+                {
+                  contract: 'Box',
+                  label: 'byteArray',
+                  src: 'contracts/Box.sol',
+                  type: 't_bytes8',
+                },
+              ],
+              types: {
+                't_array(t_enum(MyEnum)4)dyn_storage': {
+                  label: 'MyEnum[]',
+                },
+                't_array(t_uint256)10_storage': {
+                  label: 'uint256[10]',
+                },
+                't_array(t_uint256)dyn_storage': {
+                  label: 'uint256[]',
+                },
+                t_bool: {
+                  label: 'bool',
+                },
+                t_bytes8: {
+                  label: 'bytes8',
+                },
+                't_enum(MyEnum)4': {
+                  label: 'MyEnum',
+                  members: [
+                    'UP',
+                    'DOWN',
+                  ],
+                },
+                't_mapping(unknown,t_bool)': {
+                  label: 'mapping(key => bool)',
+                },
+                't_struct(MyStruct)3_storage': {
+                  label: 'MyStruct',
+                  members: [
+                    {
+                      label: 'x',
+                      type: 't_bool',
+                    },
+                  ],
+                },
+                t_uint256: {
+                  label: 'uint256',
+                },
+              },
+            },
+          },
+        },
+        manifestVersion: '3.2',
+        proxies: [
+          {
+            address: '0xE4C10Db67595aF2Cb4166c8C274e0140f7E43059',
+            kind: 'transparent',
+          },
+        ],
+      },
+    }
+
+## produces network export data
+
+> Snapshot 1
+
+    {
+      rinkeby: {
+        proxies: {
+          'my-project/Box': [
+            {
+              address: '0xE4C10Db67595aF2Cb4166c8C274e0140f7E43059',
+              admin: '0x1750499D05Ed1674d822430FB960d5F6731fDf64',
+              implementation: '0xb682dEEf4f8e298d86bFc3e21f50c675151FB974',
+              kind: 'Upgradeable',
+              version: '1.0.0',
+            },
+          ],
+        },
+      },
+    }