web3gbit-cli 1.0.0

package/lib/openzeppelin-contracts/package.json

@@ -0,0 +1,108 @@
+{
+  "name": "openzeppelin-solidity",
+  "description": "Secure Smart Contract library for Solidity",
+  "version": "5.5.0",
+  "private": true,
+  "files": [
+    "/contracts/**/*.sol",
+    "!/contracts/mocks/**/*"
+  ],
+  "scripts": {
+    "compile": "hardhat compile",
+    "compile:harnesses": "env SRC=./fv/harnesses hardhat compile",
+    "coverage": "scripts/checks/coverage.sh",
+    "docs": "npm run prepare-docs && oz-docs",
+    "docs:watch": "oz-docs watch contracts docs/templates docs/config.js",
+    "prepare": "husky",
+    "prepare-docs": "scripts/prepare-docs.sh",
+    "lint": "npm run lint:js && npm run lint:sol",
+    "lint:fix": "npm run lint:js:fix && npm run lint:sol:fix",
+    "lint:js": "prettier --log-level warn --ignore-path .gitignore '**/*.{js,ts}' --check && eslint .",
+    "lint:js:fix": "prettier --log-level warn --ignore-path .gitignore '**/*.{js,ts}' --write && eslint . --fix",
+    "lint:sol": "prettier --log-level warn --ignore-path .gitignore '{contracts,test}/**/*.sol' --check && solhint --config solhint.config.js --noPoster '{contracts,test}/**/*.sol'",
+    "lint:sol:fix": "prettier --log-level warn --ignore-path .gitignore '{contracts,test}/**/*.sol' --write",
+    "clean": "hardhat clean && rimraf build contracts/build",
+    "prepack": "scripts/prepack.sh",
+    "generate": "scripts/generate/run.js",
+    "pragma": "npm run compile && scripts/minimize-pragma.js artifacts/build-info/*",
+    "version": "scripts/release/version.sh",
+    "test": ". scripts/set-max-old-space-size.sh && hardhat test",
+    "test:generation": "scripts/checks/generation.sh",
+    "test:inheritance": "npm run compile && scripts/checks/inheritance-ordering.js artifacts/build-info/*",
+    "test:pragma": "npm run compile && scripts/checks/pragma-validity.js artifacts/build-info/*",
+    "gas-report": "env ENABLE_GAS_REPORT=true npm run test",
+    "slither": "npm run clean && slither ."
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/OpenZeppelin/openzeppelin-contracts.git"
+  },
+  "keywords": [
+    "solidity",
+    "ethereum",
+    "smart",
+    "contracts",
+    "security",
+    "zeppelin"
+  ],
+  "author": "OpenZeppelin Community <maintainers@openzeppelin.org>",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/OpenZeppelin/openzeppelin-contracts/issues"
+  },
+  "homepage": "https://openzeppelin.com/contracts/",
+  "devDependencies": {
+    "@changesets/changelog-github": "^0.5.0",
+    "@changesets/cli": "^2.26.0",
+    "@changesets/pre": "^2.0.0",
+    "@changesets/read": "^0.6.0",
+    "@eslint/compat": "^1.2.1",
+    "@ethereumjs/mpt": "^10.1.0",
+    "@nomicfoundation/hardhat-chai-matchers": "^2.0.6",
+    "@nomicfoundation/hardhat-ethers": "^3.0.9",
+    "@nomicfoundation/hardhat-network-helpers": "^1.0.13",
+    "@openzeppelin/docs-utils": "^0.1.6",
+    "@openzeppelin/merkle-tree": "^1.0.7",
+    "@openzeppelin/upgrade-safe-transpiler": "^0.4.1",
+    "@openzeppelin/upgrades-core": "^1.20.6",
+    "chai": "^4.2.0",
+    "eslint": "^9.0.0",
+    "eslint-config-prettier": "^10.0.0",
+    "ethers": "^6.16.0",
+    "glob": "^13.0.0",
+    "globals": "^17.0.0",
+    "graphlib": "^2.1.8",
+    "hardhat": "^2.28.0",
+    "hardhat-exposed": "^0.3.15",
+    "hardhat-gas-reporter": "^2.1.0",
+    "hardhat-ignore-warnings": "^0.2.11",
+    "hardhat-predeploy": "^0.4.1",
+    "husky": "^9.1.7",
+    "interoperable-addresses": "^0.1.3",
+    "lint-staged": "^16.0.0",
+    "lodash.startcase": "^4.4.0",
+    "micromatch": "^4.0.2",
+    "p-limit": "^7.0.0",
+    "prettier": "^3.0.0",
+    "prettier-plugin-solidity": "^2.0.0",
+    "rimraf": "^6.0.0",
+    "semver": "^7.3.5",
+    "solhint": "^6.0.1",
+    "solhint-plugin-openzeppelin": "file:scripts/solhint-custom",
+    "solidity-ast": "^0.4.50",
+    "solidity-coverage": "^0.8.14",
+    "solidity-docgen": "^0.6.0-beta.29",
+    "undici": "^7.4.0",
+    "yargs": "^18.0.0"
+  },
+  "lint-staged": {
+    "**/*.{js,ts}": [
+      "prettier --log-level warn --ignore-path .gitignore --check",
+      "eslint"
+    ],
+    "{contracts,test}/**/*.sol": [
+      "prettier --log-level warn --ignore-path .gitignore --check",
+      "solhint --config solhint.config.js --noPoster"
+    ]
+  }
+}

package/lib/openzeppelin-contracts/remappings.txt

@@ -0,0 +1 @@
+@openzeppelin/contracts/=contracts/

package/lib/openzeppelin-contracts/renovate.json

@@ -0,0 +1,4 @@
+{
+  "extends": ["github>OpenZeppelin/configs"],
+  "labels": ["ignore-changeset"]
+}

package/lib/openzeppelin-contracts/scripts/checks/compare-layout.js

@@ -0,0 +1,28 @@
+#!/usr/bin/env node
+
+const fs = require('fs');
+const { getStorageUpgradeReport } = require('@openzeppelin/upgrades-core/dist/storage');
+
+const { hideBin } = require('yargs/helpers');
+const { argv } = require('yargs/yargs')(hideBin(process.argv))
+  .env('')
+  .options({
+    ref: { type: 'string', required: true },
+    head: { type: 'string', required: true },
+  });
+
+const oldLayout = JSON.parse(fs.readFileSync(argv.ref));
+const newLayout = JSON.parse(fs.readFileSync(argv.head));
+
+for (const name in oldLayout) {
+  if (name in newLayout) {
+    const report = getStorageUpgradeReport(oldLayout[name], newLayout[name], {});
+    if (!report.ok) {
+      console.log(`Storage layout incompatibility found in ${name}:`);
+      console.log(report.explain());
+      process.exitCode = 1;
+    }
+  } else {
+    console.log(`WARNING: ${name} is missing from the current branch`);
+  }
+}

package/lib/openzeppelin-contracts/scripts/checks/compareGasReports.js

@@ -0,0 +1,249 @@
+#!/usr/bin/env node
+
+const fs = require('fs');
+const chalk = require('chalk');
+
+const { hideBin } = require('yargs/helpers');
+const { argv } = require('yargs/yargs')(hideBin(process.argv))
+  .env('')
+  .options({
+    style: {
+      type: 'string',
+      choices: ['shell', 'markdown'],
+      default: 'shell',
+    },
+    hideEqual: {
+      type: 'boolean',
+      default: true,
+    },
+    strictTesting: {
+      type: 'boolean',
+      default: false,
+    },
+  });
+
+// Deduce base tx cost from the percentage denominator
+const BASE_TX_COST = 21000;
+
+// Utilities
+function sum(...args) {
+  return args.reduce((a, b) => a + b, 0);
+}
+
+function average(...args) {
+  return sum(...args) / args.length;
+}
+
+function variation(current, previous, offset = 0) {
+  return {
+    value: current,
+    delta: current - previous,
+    prcnt: (100 * (current - previous)) / (previous - offset),
+  };
+}
+
+// Report class
+class Report {
+  // Read report file
+  static load(filepath) {
+    return JSON.parse(fs.readFileSync(filepath, 'utf8'));
+  }
+
+  // Compare two reports
+  static compare(update, ref, opts = { hideEqual: true, strictTesting: false }) {
+    if (JSON.stringify(update.options?.solcInfo) !== JSON.stringify(ref.options?.solcInfo)) {
+      console.warn('WARNING: Reports produced with non matching metadata');
+    }
+
+    // gasReporter 1.0.0 uses ".info", but 2.0.0 uses ".data"
+    const updateInfo = update.info ?? update.data;
+    const refInfo = ref.info ?? ref.data;
+
+    const deployments = updateInfo.deployments
+      .map(contract =>
+        Object.assign(contract, { previousVersion: refInfo.deployments.find(({ name }) => name === contract.name) }),
+      )
+      .filter(contract => contract.gasData?.length && contract.previousVersion?.gasData?.length)
+      .flatMap(contract => [
+        {
+          contract: contract.name,
+          method: '[bytecode length]',
+          avg: variation(contract.bytecode.length / 2 - 1, contract.previousVersion.bytecode.length / 2 - 1),
+        },
+        {
+          contract: contract.name,
+          method: '[construction cost]',
+          avg: variation(
+            ...[contract.gasData, contract.previousVersion.gasData].map(x => Math.round(average(...x))),
+            BASE_TX_COST,
+          ),
+        },
+      ])
+      .sort((a, b) => `${a.contract}:${a.method}`.localeCompare(`${b.contract}:${b.method}`));
+
+    const methods = Object.keys(updateInfo.methods)
+      .filter(key => refInfo.methods[key])
+      .filter(key => updateInfo.methods[key].numberOfCalls > 0)
+      .filter(
+        key => !opts.strictTesting || updateInfo.methods[key].numberOfCalls === refInfo.methods[key].numberOfCalls,
+      )
+      .map(key => ({
+        contract: refInfo.methods[key].contract,
+        method: refInfo.methods[key].fnSig,
+        min: variation(...[updateInfo, refInfo].map(x => Math.min(...x.methods[key].gasData)), BASE_TX_COST),
+        max: variation(...[updateInfo, refInfo].map(x => Math.max(...x.methods[key].gasData)), BASE_TX_COST),
+        avg: variation(...[updateInfo, refInfo].map(x => Math.round(average(...x.methods[key].gasData))), BASE_TX_COST),
+      }))
+      .sort((a, b) => `${a.contract}:${a.method}`.localeCompare(`${b.contract}:${b.method}`));
+
+    return []
+      .concat(deployments, methods)
+      .filter(row => !opts.hideEqual || row.min?.delta || row.max?.delta || row.avg?.delta);
+  }
+}
+
+// Display
+function center(text, length) {
+  return text.padStart((text.length + length) / 2).padEnd(length);
+}
+
+function plusSign(num) {
+  return num > 0 ? '+' : '';
+}
+
+function formatCellShell(cell) {
+  const format = chalk[cell?.delta > 0 ? 'red' : cell?.delta < 0 ? 'green' : 'reset'];
+  return [
+    format((!isFinite(cell?.value) ? '-' : cell.value.toString()).padStart(8)),
+    format((!isFinite(cell?.delta) ? '-' : plusSign(cell.delta) + cell.delta.toString()).padStart(8)),
+    format((!isFinite(cell?.prcnt) ? '-' : plusSign(cell.prcnt) + cell.prcnt.toFixed(2) + '%').padStart(8)),
+  ];
+}
+
+function formatCmpShell(rows) {
+  const contractLength = Math.max(8, ...rows.map(({ contract }) => contract.length));
+  const methodLength = Math.max(7, ...rows.map(({ method }) => method.length));
+
+  const COLS = [
+    { txt: '', length: 0 },
+    { txt: 'Contract', length: contractLength },
+    { txt: 'Method', length: methodLength },
+    { txt: 'Min', length: 30 },
+    { txt: 'Max', length: 30 },
+    { txt: 'Avg', length: 30 },
+    { txt: '', length: 0 },
+  ];
+  const HEADER = COLS.map(entry => chalk.bold(center(entry.txt, entry.length || 0)))
+    .join(' | ')
+    .trim();
+  const SEPARATOR = COLS.map(({ length }) => (length > 0 ? '-'.repeat(length + 2) : ''))
+    .join('|')
+    .trim();
+
+  return [
+    '',
+    HEADER,
+    ...rows.map(entry =>
+      [
+        '',
+        chalk.grey(entry.contract.padEnd(contractLength)),
+        entry.method.padEnd(methodLength),
+        ...formatCellShell(entry.min),
+        ...formatCellShell(entry.max),
+        ...formatCellShell(entry.avg),
+        '',
+      ]
+        .join(' | ')
+        .trim(),
+    ),
+    '',
+  ]
+    .join(`\n${SEPARATOR}\n`)
+    .trim();
+}
+
+function alignPattern(align) {
+  switch (align) {
+    case 'left':
+    case undefined:
+      return ':-';
+    case 'right':
+      return '-:';
+    case 'center':
+      return ':-:';
+  }
+}
+
+function trend(value) {
+  return value > 0 ? ':x:' : value < 0 ? ':heavy_check_mark:' : ':heavy_minus_sign:';
+}
+
+function formatCellMarkdown(cell) {
+  return [
+    !isFinite(cell?.value) ? '-' : cell.value.toString(),
+    !isFinite(cell?.delta) ? '-' : plusSign(cell.delta) + cell.delta.toString(),
+    !isFinite(cell?.prcnt) ? '-' : plusSign(cell.prcnt) + cell.prcnt.toFixed(2) + '% ' + trend(cell.delta),
+  ];
+}
+
+function formatCmpMarkdown(rows) {
+  const COLS = [
+    { txt: '' },
+    { txt: 'Contract', align: 'left' },
+    { txt: 'Method', align: 'left' },
+    { txt: 'Min', align: 'right' },
+    { txt: '(+/-)', align: 'right' },
+    { txt: '%', align: 'right' },
+    { txt: 'Max', align: 'right' },
+    { txt: '(+/-)', align: 'right' },
+    { txt: '%', align: 'right' },
+    { txt: 'Avg', align: 'right' },
+    { txt: '(+/-)', align: 'right' },
+    { txt: '%', align: 'right' },
+    { txt: '' },
+  ];
+  const HEADER = COLS.map(entry => entry.txt)
+    .join(' | ')
+    .trim();
+  const SEPARATOR = COLS.map(entry => (entry.txt ? alignPattern(entry.align) : ''))
+    .join('|')
+    .trim();
+
+  return [
+    '# Changes to gas costs',
+    '',
+    HEADER,
+    SEPARATOR,
+    rows
+      .map(entry =>
+        [
+          '',
+          entry.contract,
+          entry.method,
+          ...formatCellMarkdown(entry.min),
+          ...formatCellMarkdown(entry.max),
+          ...formatCellMarkdown(entry.avg),
+          '',
+        ]
+          .join(' | ')
+          .trim(),
+      )
+      .join('\n'),
+    '',
+  ]
+    .join('\n')
+    .trim();
+}
+
+// MAIN
+const report = Report.compare(Report.load(argv._[0]), Report.load(argv._[1]), argv);
+
+switch (argv.style) {
+  case 'markdown':
+    console.log(formatCmpMarkdown(report));
+    break;
+  case 'shell':
+  default:
+    console.log(formatCmpShell(report));
+    break;
+}

package/lib/openzeppelin-contracts/scripts/checks/coverage.sh

@@ -0,0 +1,24 @@
+#!/usr/bin/env bash
+
+set -euo pipefail
+
+export COVERAGE=true
+export FOUNDRY_FUZZ_RUNS=10
+
+. scripts/set-max-old-space-size.sh
+
+# Hardhat coverage
+hardhat coverage
+
+if [ "${CI:-"false"}" == "true" ]; then
+  # Foundry coverage
+  forge coverage --report lcov --ir-minimum
+  # Remove zero hits
+  if [[ "$OSTYPE" == "darwin"* ]]; then
+    sed -i '' '/,0/d' lcov.info
+  else
+    sed -i '/,0/d' lcov.info
+  fi
+fi
+
+# Reports are then uploaded to Codecov automatically by workflow, and merged.

package/lib/openzeppelin-contracts/scripts/checks/extract-layout.js

@@ -0,0 +1,39 @@
+const fs = require('fs');
+const { findAll, astDereferencer, srcDecoder } = require('solidity-ast/utils');
+const { extractStorageLayout } = require('@openzeppelin/upgrades-core/dist/storage/extract');
+
+const { hideBin } = require('yargs/helpers');
+const { argv } = require('yargs/yargs')(hideBin(process.argv));
+
+const skipPath = ['contracts/mocks/', 'contracts-exposed/'];
+const skipKind = ['interface', 'library'];
+
+function extractLayouts(path) {
+  const layout = {};
+  const { input, output } = JSON.parse(fs.readFileSync(path));
+
+  const decoder = srcDecoder(input, output);
+  const deref = astDereferencer(output);
+
+  for (const src in output.contracts) {
+    if (skipPath.some(prefix => src.startsWith(prefix))) {
+      continue;
+    }
+
+    for (const contractDef of findAll('ContractDefinition', output.sources[src].ast)) {
+      if (skipKind.includes(contractDef.contractKind)) {
+        continue;
+      }
+
+      layout[contractDef.name] = extractStorageLayout(
+        contractDef,
+        decoder,
+        deref,
+        output.contracts[src][contractDef.name].storageLayout,
+      );
+    }
+  }
+  return layout;
+}
+
+console.log(JSON.stringify(Object.assign(...argv._.map(extractLayouts))));

package/lib/openzeppelin-contracts/scripts/checks/generation.sh

@@ -0,0 +1,6 @@
+#!/usr/bin/env bash
+
+set -euo pipefail
+
+npm run generate
+git diff -R --exit-code

package/lib/openzeppelin-contracts/scripts/checks/inheritance-ordering.js

@@ -0,0 +1,55 @@
+#!/usr/bin/env node
+
+const path = require('path');
+const graphlib = require('graphlib');
+const match = require('micromatch');
+const { findAll } = require('solidity-ast/utils');
+const { _: artifacts } = require('yargs/yargs')().argv;
+
+// files to skip
+const skipPatterns = ['contracts-exposed/**', 'contracts/mocks/**'];
+
+for (const artifact of artifacts) {
+  const { output: solcOutput } = require(path.resolve(__dirname, '../..', artifact));
+
+  const graph = new graphlib.Graph({ directed: true });
+  const names = {};
+  const linearized = [];
+
+  for (const source in solcOutput.contracts) {
+    if (match.any(source, skipPatterns)) continue;
+    for (const contractDef of findAll('ContractDefinition', solcOutput.sources[source].ast)) {
+      names[contractDef.id] = contractDef.name;
+      linearized.push(contractDef.linearizedBaseContracts);
+
+      contractDef.linearizedBaseContracts.forEach((c1, i, contracts) =>
+        contracts.slice(i + 1).forEach(c2 => {
+          graph.setEdge(c1, c2);
+        }),
+      );
+    }
+  }
+
+  /// graphlib.alg.findCycles will not find minimal cycles.
+  /// We are only interested in cycles of lengths 2 (needs proof)
+  graph.nodes().forEach((x, i, nodes) =>
+    nodes
+      .slice(i + 1)
+      .filter(y => graph.hasEdge(x, y) && graph.hasEdge(y, x))
+      .forEach(y => {
+        console.log(`Conflict between ${names[x]} and ${names[y]} detected in the following dependency chains:`);
+        linearized
+          .filter(chain => chain.includes(parseInt(x)) && chain.includes(parseInt(y)))
+          .forEach(chain => {
+            const comp = chain.indexOf(parseInt(x)) < chain.indexOf(parseInt(y)) ? '>' : '<';
+            console.log(`- ${names[x]} ${comp} ${names[y]} in ${names[chain.find(Boolean)]}`);
+            // console.log(`- ${names[x]} ${comp} ${names[y]}: ${chain.reverse().map(id => names[id]).join(', ')}`);
+          });
+        process.exitCode = 1;
+      }),
+  );
+}
+
+if (!process.exitCode) {
+  console.log('Contract ordering is consistent.');
+}

package/lib/openzeppelin-contracts/scripts/checks/pragma-validity.js

@@ -0,0 +1,45 @@
+#!/usr/bin/env node
+
+const semver = require('semver');
+const pLimit = require('p-limit').default;
+
+const { hideBin } = require('yargs/helpers');
+const yargs = require('yargs/yargs');
+
+const getContractsMetadata = require('../get-contracts-metadata');
+const { compile } = require('../solc-versions');
+
+const {
+  argv: { pattern, skipPatterns, verbose, concurrency, _: artifacts },
+} = yargs(hideBin(process.argv))
+  .env('')
+  .options({
+    pattern: { alias: 'p', type: 'string', default: 'contracts/**/*.sol' },
+    skipPatterns: { alias: 's', type: 'string', default: 'contracts/mocks/**/*.sol' },
+    concurrency: { alias: 'c', type: 'number', default: 8 },
+    verbose: { alias: 'v', type: 'count' },
+  });
+
+const limit = pLimit(concurrency);
+Promise.all(
+  Object.entries(getContractsMetadata(pattern, skipPatterns, artifacts)).map(([source, { pragma }]) =>
+    limit(
+      (file, version) =>
+        compile(file, version).then(
+          () => {
+            verbose && console.log(`Compile ${file} using solc ${version}: ok`);
+          },
+          error => {
+            console.error(`Failed to compile ${file} using solc ${version}\n${error}`);
+            process.exitCode = 1;
+          },
+        ),
+      source,
+      semver.minVersion(pragma),
+    ),
+  ),
+).finally(() => {
+  if (!process.exitCode) {
+    console.log('All files can be compiled with the specified pragma.');
+  }
+});

package/lib/openzeppelin-contracts/scripts/fetch-common-contracts.js

@@ -0,0 +1,50 @@
+#!/usr/bin/env node
+
+// This script snapshots the bytecode and ABI for the `hardhat/common-contracts.js` script.
+// - Bytecode is fetched directly from the blockchain by querying the provided client endpoint. If no endpoint is
+//   provided, ethers default provider is used instead.
+// - ABI is fetched from etherscan's API using the provided etherscan API key. If no API key is provided, ABI will not
+//   be fetched and saved.
+//
+// The produced artifacts are stored in the `output` folder ('test/bin' by default). For each contract, two files are
+// produced:
+// - `<name>.bytecode` containing the contract bytecode (in binary encoding)
+// - `<name>.abi` containing the ABI (in utf-8 encoding)
+
+const fs = require('fs');
+const path = require('path');
+const { ethers } = require('ethers');
+const { request } = require('undici');
+const { hideBin } = require('yargs/helpers');
+const { argv } = require('yargs/yargs')(hideBin(process.argv))
+  .env('')
+  .options({
+    output: { type: 'string', default: 'test/bin/' },
+    client: { type: 'string' },
+    etherscan: { type: 'string' },
+  });
+
+// List of contract names and addresses to fetch
+const config = {
+  EntryPoint070: '0x0000000071727De22E5E9d8BAf0edAc6f37da032',
+  SenderCreator070: '0xEFC2c1444eBCC4Db75e7613d20C6a62fF67A167C',
+  EntryPoint080: '0x4337084D9E255Ff0702461CF8895CE9E3b5Ff108',
+  SenderCreator080: '0x449ED7C3e6Fee6a97311d4b55475DF59C44AdD33',
+};
+
+Promise.all(
+  Object.entries(config).flatMap(([name, addr]) =>
+    Promise.all([
+      argv.etherscan &&
+        request(`https://api.etherscan.io/api?module=contract&action=getabi&address=${addr}&apikey=${argv.etherscan}`)
+          .then(({ body }) => body.json())
+          .then(({ result: abi }) => fs.writeFile(path.join(argv.output, `${name}.abi`), abi, 'utf-8', () => {})),
+      ethers
+        .getDefaultProvider(argv.client)
+        .getCode(addr)
+        .then(bytecode =>
+          fs.writeFile(path.join(argv.output, `${name}.bytecode`), ethers.getBytes(bytecode), 'binary', () => {}),
+        ),
+    ]),
+  ),
+);