@elizaos/autonomous 2.0.0-alpha.21 → 2.0.0-alpha.23

package/test/contracts/lib/openzeppelin-contracts/scripts/generate/templates/SafeCast.js

@@ -0,0 +1,163 @@
+const assert = require('assert');
+const format = require('../format-lines');
+const { range } = require('../../helpers');
+
+const LENGTHS = range(8, 256, 8).reverse(); // 248 → 8 (in steps of 8)
+
+// Returns the version of OpenZeppelin Contracts in which a particular function was introduced.
+// This is used in the docs for each function.
+const version = (selector, length) => {
+  switch (selector) {
+    case 'toUint(uint)': {
+      switch (length) {
+        case 8:
+        case 16:
+        case 32:
+        case 64:
+        case 128:
+          return '2.5';
+        case 96:
+        case 224:
+          return '4.2';
+        default:
+          assert(LENGTHS.includes(length));
+          return '4.7';
+      }
+    }
+    case 'toInt(int)': {
+      switch (length) {
+        case 8:
+        case 16:
+        case 32:
+        case 64:
+        case 128:
+          return '3.1';
+        default:
+          assert(LENGTHS.includes(length));
+          return '4.7';
+      }
+    }
+    case 'toUint(int)': {
+      switch (length) {
+        case 256:
+          return '3.0';
+        default:
+          assert(false);
+          return;
+      }
+    }
+    case 'toInt(uint)': {
+      switch (length) {
+        case 256:
+          return '3.0';
+        default:
+          assert(false);
+          return;
+      }
+    }
+    default:
+      assert(false);
+  }
+};
+
+const header = `\
+pragma solidity ^0.8.0;
+
+/**
+ * @dev Wrappers over Solidity's uintXX/intXX casting operators with added overflow
+ * checks.
+ *
+ * Downcasting from uint256/int256 in Solidity does not revert on overflow. This can
+ * easily result in undesired exploitation or bugs, since developers usually
+ * assume that overflows raise errors. \`SafeCast\` restores this intuition by
+ * reverting the transaction when such an operation overflows.
+ *
+ * Using this library instead of the unchecked operations eliminates an entire
+ * class of bugs, so it's recommended to use it always.
+ *
+ * Can be combined with {SafeMath} and {SignedSafeMath} to extend it to smaller types, by performing
+ * all math on \`uint256\` and \`int256\` and then downcasting.
+ */
+`;
+
+const toUintDownCast = length => `\
+/**
+ * @dev Returns the downcasted uint${length} from uint256, reverting on
+ * overflow (when the input is greater than largest uint${length}).
+ *
+ * Counterpart to Solidity's \`uint${length}\` operator.
+ *
+ * Requirements:
+ *
+ * - input must fit into ${length} bits
+ *
+ * _Available since v${version('toUint(uint)', length)}._
+ */
+function toUint${length}(uint256 value) internal pure returns (uint${length}) {
+    require(value <= type(uint${length}).max, "SafeCast: value doesn't fit in ${length} bits");
+    return uint${length}(value);
+}
+`;
+
+/* eslint-disable max-len */
+const toIntDownCast = length => `\
+/**
+ * @dev Returns the downcasted int${length} from int256, reverting on
+ * overflow (when the input is less than smallest int${length} or
+ * greater than largest int${length}).
+ *
+ * Counterpart to Solidity's \`int${length}\` operator.
+ *
+ * Requirements:
+ *
+ * - input must fit into ${length} bits
+ *
+ * _Available since v${version('toInt(int)', length)}._
+ */
+function toInt${length}(int256 value) internal pure returns (int${length} downcasted) {
+    downcasted = int${length}(value);
+    require(downcasted == value, "SafeCast: value doesn't fit in ${length} bits");
+}
+`;
+/* eslint-enable max-len */
+
+const toInt = length => `\
+/**
+ * @dev Converts an unsigned uint${length} into a signed int${length}.
+ *
+ * Requirements:
+ *
+ * - input must be less than or equal to maxInt${length}.
+ *
+ * _Available since v${version('toInt(uint)', length)}._
+ */
+function toInt${length}(uint${length} value) internal pure returns (int${length}) {
+    // Note: Unsafe cast below is okay because \`type(int${length}).max\` is guaranteed to be positive
+    require(value <= uint${length}(type(int${length}).max), "SafeCast: value doesn't fit in an int${length}");
+    return int${length}(value);
+}
+`;
+
+const toUint = length => `\
+/**
+ * @dev Converts a signed int${length} into an unsigned uint${length}.
+ *
+ * Requirements:
+ *
+ * - input must be greater than or equal to 0.
+ *
+ * _Available since v${version('toUint(int)', length)}._
+ */
+function toUint${length}(int${length} value) internal pure returns (uint${length}) {
+    require(value >= 0, "SafeCast: value must be positive");
+    return uint${length}(value);
+}
+`;
+
+// GENERATE
+module.exports = format(
+  header.trimEnd(),
+  'library SafeCast {',
+  [...LENGTHS.map(toUintDownCast), toUint(256), ...LENGTHS.map(toIntDownCast), toInt(256)],
+  '}',
+);

package/test/contracts/lib/openzeppelin-contracts/scripts/generate/templates/StorageSlot.js

@@ -0,0 +1,87 @@
+const format = require('../format-lines');
+const { capitalize, unique } = require('../../helpers');
+
+const TYPES = [
+  { type: 'address', isValueType: true, version: '4.1' },
+  { type: 'bool', isValueType: true, name: 'Boolean', version: '4.1' },
+  { type: 'bytes32', isValueType: true, version: '4.1' },
+  { type: 'uint256', isValueType: true, version: '4.1' },
+  { type: 'string', isValueType: false, version: '4.9' },
+  { type: 'bytes', isValueType: false, version: '4.9' },
+].map(type => Object.assign(type, { struct: (type.name ?? capitalize(type.type)) + 'Slot' }));
+
+const VERSIONS = unique(TYPES.map(t => t.version)).map(
+  version =>
+    `_Available since v${version} for ${TYPES.filter(t => t.version == version)
+      .map(t => `\`${t.type}\``)
+      .join(', ')}._`,
+);
+
+const header = `\
+pragma solidity ^0.8.0;
+
+/**
+ * @dev Library for reading and writing primitive types to specific storage slots.
+ *
+ * Storage slots are often used to avoid storage conflict when dealing with upgradeable contracts.
+ * This library helps with reading and writing to such slots without the need for inline assembly.
+ *
+ * The functions in this library return Slot structs that contain a \`value\` member that can be used to read or write.
+ *
+ * Example usage to set ERC1967 implementation slot:
+ * \`\`\`solidity
+ * contract ERC1967 {
+ *     bytes32 internal constant _IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;
+ *
+ *     function _getImplementation() internal view returns (address) {
+ *         return StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value;
+ *     }
+ *
+ *     function _setImplementation(address newImplementation) internal {
+ *         require(Address.isContract(newImplementation), "ERC1967: new implementation is not a contract");
+ *         StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value = newImplementation;
+ *     }
+ * }
+ * \`\`\`
+ *
+${VERSIONS.map(s => ` * ${s}`).join('\n')}
+ */
+`;
+
+const struct = type => `\
+struct ${type.struct} {
+  ${type.type} value;
+}
+`;
+
+const get = type => `\
+/**
+ * @dev Returns an \`${type.struct}\` with member \`value\` located at \`slot\`.
+ */
+function get${type.struct}(bytes32 slot) internal pure returns (${type.struct} storage r) {
+  /// @solidity memory-safe-assembly
+  assembly {
+      r.slot := slot
+  }
+}
+`;
+
+const getStorage = type => `\
+/**
+ * @dev Returns an \`${type.struct}\` representation of the ${type.type} storage pointer \`store\`.
+ */
+function get${type.struct}(${type.type} storage store) internal pure returns (${type.struct} storage r) {
+  /// @solidity memory-safe-assembly
+  assembly {
+      r.slot := store.slot
+  }
+}
+`;
+
+// GENERATE
+module.exports = format(
+  header.trimEnd(),
+  'library StorageSlot {',
+  [...TYPES.map(struct), ...TYPES.flatMap(type => [get(type), type.isValueType ? '' : getStorage(type)])],
+  '}',
+);

package/test/contracts/lib/openzeppelin-contracts/scripts/generate/templates/conversion.js

@@ -0,0 +1,30 @@
+function toBytes32(type, value) {
+  switch (type) {
+    case 'bytes32':
+      return value;
+    case 'uint256':
+      return `bytes32(${value})`;
+    case 'address':
+      return `bytes32(uint256(uint160(${value})))`;
+    default:
+      throw new Error(`Conversion from ${type} to bytes32 not supported`);
+  }
+}
+
+function fromBytes32(type, value) {
+  switch (type) {
+    case 'bytes32':
+      return value;
+    case 'uint256':
+      return `uint256(${value})`;
+    case 'address':
+      return `address(uint160(uint256(${value})))`;
+    default:
+      throw new Error(`Conversion from bytes32 to ${type} not supported`);
+  }
+}
+
+module.exports = {
+  toBytes32,
+  fromBytes32,
+};

package/test/contracts/lib/openzeppelin-contracts/scripts/git-user-config.sh

@@ -0,0 +1,6 @@
+#!/usr/bin/env bash
+
+set -euo pipefail -x
+
+git config user.name 'github-actions'
+git config user.email '41898282+github-actions[bot]@users.noreply.github.com'

package/test/contracts/lib/openzeppelin-contracts/scripts/helpers.js

@@ -0,0 +1,37 @@
+function chunk(array, size = 1) {
+  return Array.range(Math.ceil(array.length / size)).map(i => array.slice(i * size, i * size + size));
+}
+
+function range(start, stop = undefined, step = 1) {
+  if (!stop) {
+    stop = start;
+    start = 0;
+  }
+  return start < stop
+    ? Array(Math.ceil((stop - start) / step))
+        .fill()
+        .map((_, i) => start + i * step)
+    : [];
+}
+
+function unique(array, op = x => x) {
+  return array.filter((obj, i) => array.findIndex(entry => op(obj) === op(entry)) === i);
+}
+
+function zip(...args) {
+  return Array(Math.max(...args.map(arg => arg.length)))
+    .fill(null)
+    .map((_, i) => args.map(arg => arg[i]));
+}
+
+function capitalize(str) {
+  return str.charAt(0).toUpperCase() + str.slice(1);
+}
+
+module.exports = {
+  chunk,
+  range,
+  unique,
+  zip,
+  capitalize,
+};

package/test/contracts/lib/openzeppelin-contracts/scripts/migrate-imports.js

@@ -0,0 +1,180 @@
+#!/usr/bin/env node
+
+const { promises: fs } = require('fs');
+const path = require('path');
+
+const pathUpdates = {
+  // 'access/AccessControl.sol': undefined,
+  // 'access/Ownable.sol': undefined,
+  'access/TimelockController.sol': 'governance/TimelockController.sol',
+  'cryptography/ECDSA.sol': 'utils/cryptography/ECDSA.sol',
+  'cryptography/MerkleProof.sol': 'utils/cryptography/MerkleProof.sol',
+  'drafts/EIP712.sol': 'utils/cryptography/EIP712.sol',
+  'drafts/ERC20Permit.sol': 'token/ERC20/extensions/ERC20Permit.sol',
+  'drafts/IERC20Permit.sol': 'token/ERC20/extensions/IERC20Permit.sol',
+  'GSN/Context.sol': 'utils/Context.sol',
+  // 'GSN/GSNRecipientERC20Fee.sol': undefined,
+  // 'GSN/GSNRecipientSignature.sol': undefined,
+  // 'GSN/GSNRecipient.sol': undefined,
+  // 'GSN/IRelayHub.sol': undefined,
+  // 'GSN/IRelayRecipient.sol': undefined,
+  'introspection/ERC165Checker.sol': 'utils/introspection/ERC165Checker.sol',
+  'introspection/ERC165.sol': 'utils/introspection/ERC165.sol',
+  'introspection/ERC1820Implementer.sol': 'utils/introspection/ERC1820Implementer.sol',
+  'introspection/IERC165.sol': 'utils/introspection/IERC165.sol',
+  'introspection/IERC1820Implementer.sol': 'utils/introspection/IERC1820Implementer.sol',
+  'introspection/IERC1820Registry.sol': 'utils/introspection/IERC1820Registry.sol',
+  'math/Math.sol': 'utils/math/Math.sol',
+  'math/SafeMath.sol': 'utils/math/SafeMath.sol',
+  'math/SignedSafeMath.sol': 'utils/math/SignedSafeMath.sol',
+  'payment/escrow/ConditionalEscrow.sol': 'utils/escrow/ConditionalEscrow.sol',
+  'payment/escrow/Escrow.sol': 'utils/escrow/Escrow.sol',
+  'payment/escrow/RefundEscrow.sol': 'utils/escrow/RefundEscrow.sol',
+  'payment/PaymentSplitter.sol': 'finance/PaymentSplitter.sol',
+  'utils/PaymentSplitter.sol': 'finance/PaymentSplitter.sol',
+  'payment/PullPayment.sol': 'security/PullPayment.sol',
+  'presets/ERC1155PresetMinterPauser.sol': 'token/ERC1155/presets/ERC1155PresetMinterPauser.sol',
+  'presets/ERC20PresetFixedSupply.sol': 'token/ERC20/presets/ERC20PresetFixedSupply.sol',
+  'presets/ERC20PresetMinterPauser.sol': 'token/ERC20/presets/ERC20PresetMinterPauser.sol',
+  'presets/ERC721PresetMinterPauserAutoId.sol': 'token/ERC721/presets/ERC721PresetMinterPauserAutoId.sol',
+  'presets/ERC777PresetFixedSupply.sol': 'token/ERC777/presets/ERC777PresetFixedSupply.sol',
+  'proxy/BeaconProxy.sol': 'proxy/beacon/BeaconProxy.sol',
+  // 'proxy/Clones.sol': undefined,
+  'proxy/IBeacon.sol': 'proxy/beacon/IBeacon.sol',
+  'proxy/Initializable.sol': 'proxy/utils/Initializable.sol',
+  'utils/Initializable.sol': 'proxy/utils/Initializable.sol',
+  'proxy/ProxyAdmin.sol': 'proxy/transparent/ProxyAdmin.sol',
+  // 'proxy/Proxy.sol': undefined,
+  'proxy/TransparentUpgradeableProxy.sol': 'proxy/transparent/TransparentUpgradeableProxy.sol',
+  'proxy/UpgradeableBeacon.sol': 'proxy/beacon/UpgradeableBeacon.sol',
+  'proxy/UpgradeableProxy.sol': 'proxy/ERC1967/ERC1967Proxy.sol',
+  'token/ERC1155/ERC1155Burnable.sol': 'token/ERC1155/extensions/ERC1155Burnable.sol',
+  'token/ERC1155/ERC1155Holder.sol': 'token/ERC1155/utils/ERC1155Holder.sol',
+  'token/ERC1155/ERC1155Pausable.sol': 'token/ERC1155/extensions/ERC1155Pausable.sol',
+  'token/ERC1155/ERC1155Receiver.sol': 'token/ERC1155/utils/ERC1155Receiver.sol',
+  // 'token/ERC1155/ERC1155.sol': undefined,
+  'token/ERC1155/IERC1155MetadataURI.sol': 'token/ERC1155/extensions/IERC1155MetadataURI.sol',
+  // 'token/ERC1155/IERC1155Receiver.sol': undefined,
+  // 'token/ERC1155/IERC1155.sol': undefined,
+  'token/ERC20/ERC20Burnable.sol': 'token/ERC20/extensions/ERC20Burnable.sol',
+  'token/ERC20/ERC20Capped.sol': 'token/ERC20/extensions/ERC20Capped.sol',
+  'token/ERC20/ERC20Pausable.sol': 'token/ERC20/extensions/ERC20Pausable.sol',
+  'token/ERC20/ERC20Snapshot.sol': 'token/ERC20/extensions/ERC20Snapshot.sol',
+  // 'token/ERC20/ERC20.sol': undefined,
+  // 'token/ERC20/IERC20.sol': undefined,
+  'token/ERC20/SafeERC20.sol': 'token/ERC20/utils/SafeERC20.sol',
+  'token/ERC20/TokenTimelock.sol': 'token/ERC20/utils/TokenTimelock.sol',
+  'token/ERC721/ERC721Burnable.sol': 'token/ERC721/extensions/ERC721Burnable.sol',
+  'token/ERC721/ERC721Holder.sol': 'token/ERC721/utils/ERC721Holder.sol',
+  'token/ERC721/ERC721Pausable.sol': 'token/ERC721/extensions/ERC721Pausable.sol',
+  // 'token/ERC721/ERC721.sol': undefined,
+  'token/ERC721/IERC721Enumerable.sol': 'token/ERC721/extensions/IERC721Enumerable.sol',
+  'token/ERC721/IERC721Metadata.sol': 'token/ERC721/extensions/IERC721Metadata.sol',
+  // 'token/ERC721/IERC721Receiver.sol': undefined,
+  // 'token/ERC721/IERC721.sol': undefined,
+  // 'token/ERC777/ERC777.sol': undefined,
+  // 'token/ERC777/IERC777Recipient.sol': undefined,
+  // 'token/ERC777/IERC777Sender.sol': undefined,
+  // 'token/ERC777/IERC777.sol': undefined,
+  // 'utils/Address.sol': undefined,
+  // 'utils/Arrays.sol': undefined,
+  // 'utils/Context.sol': undefined,
+  // 'utils/Counters.sol': undefined,
+  // 'utils/Create2.sol': undefined,
+  'utils/EnumerableMap.sol': 'utils/structs/EnumerableMap.sol',
+  'utils/EnumerableSet.sol': 'utils/structs/EnumerableSet.sol',
+  'utils/Pausable.sol': 'security/Pausable.sol',
+  'utils/ReentrancyGuard.sol': 'security/ReentrancyGuard.sol',
+  'utils/SafeCast.sol': 'utils/math/SafeCast.sol',
+  // 'utils/Strings.sol': undefined,
+  'utils/cryptography/draft-EIP712.sol': 'utils/cryptography/EIP712.sol',
+  'token/ERC20/extensions/draft-ERC20Permit.sol': 'token/ERC20/extensions/ERC20Permit.sol',
+  'token/ERC20/extensions/draft-IERC20Permit.sol': 'token/ERC20/extensions/IERC20Permit.sol',
+};
+
+async function main(paths = ['contracts']) {
+  const files = await listFilesRecursively(paths, /\.sol$/);
+
+  const updatedFiles = [];
+  for (const file of files) {
+    if (await updateFile(file, updateImportPaths)) {
+      updatedFiles.push(file);
+    }
+  }
+
+  if (updatedFiles.length > 0) {
+    console.log(`${updatedFiles.length} file(s) were updated`);
+    for (const c of updatedFiles) {
+      console.log('-', c);
+    }
+  } else {
+    console.log('No files were updated');
+  }
+}
+
+async function listFilesRecursively(paths, filter) {
+  const queue = paths;
+  const files = [];
+
+  while (queue.length > 0) {
+    const top = queue.shift();
+    const stat = await fs.stat(top);
+    if (stat.isFile()) {
+      if (top.match(filter)) {
+        files.push(top);
+      }
+    } else if (stat.isDirectory()) {
+      for (const name of await fs.readdir(top)) {
+        queue.push(path.join(top, name));
+      }
+    }
+  }
+
+  return files;
+}
+
+async function updateFile(file, update) {
+  const content = await fs.readFile(file, 'utf8');
+  const updatedContent = update(content);
+  if (updatedContent !== content) {
+    await fs.writeFile(file, updatedContent);
+    return true;
+  } else {
+    return false;
+  }
+}
+
+function updateImportPaths(source) {
+  for (const [oldPath, newPath] of Object.entries(pathUpdates)) {
+    source = source.replace(
+      path.join('@openzeppelin/contracts', oldPath),
+      path.join('@openzeppelin/contracts', newPath),
+    );
+    source = source.replace(
+      path.join('@openzeppelin/contracts-upgradeable', getUpgradeablePath(oldPath)),
+      path.join('@openzeppelin/contracts-upgradeable', getUpgradeablePath(newPath)),
+    );
+  }
+
+  return source;
+}
+
+function getUpgradeablePath(file) {
+  const { dir, name, ext } = path.parse(file);
+  const upgradeableName = name + 'Upgradeable';
+  return path.format({ dir, ext, name: upgradeableName });
+}
+
+module.exports = {
+  pathUpdates,
+  updateImportPaths,
+  getUpgradeablePath,
+};
+
+if (require.main === module) {
+  const args = process.argv.length > 2 ? process.argv.slice(2) : undefined;
+  main(args).catch(e => {
+    console.error(e);
+    process.exit(1);
+  });
+}

package/test/contracts/lib/openzeppelin-contracts/scripts/prepack.sh

@@ -0,0 +1,12 @@
+#!/usr/bin/env bash
+
+set -euo pipefail
+shopt -s globstar
+
+# cross platform `mkdir -p`
+node -e 'fs.mkdirSync("build/contracts", { recursive: true })'
+
+cp artifacts/contracts/**/*.json build/contracts
+rm build/contracts/*.dbg.json
+
+node scripts/remove-ignored-artifacts.js

package/test/contracts/lib/openzeppelin-contracts/scripts/prepare-contracts-package.sh

@@ -0,0 +1,15 @@
+#!/usr/bin/env bash
+
+# cd to the root of the repo
+cd "$(git rev-parse --show-toplevel)"
+
+# avoids re-compilation during publishing of both packages
+if [[ ! -v ALREADY_COMPILED ]]; then
+  npm run clean
+  npm run prepare
+  npm run prepack
+fi
+
+cp README.md contracts/
+mkdir contracts/build contracts/build/contracts
+cp -r build/contracts/*.json contracts/build/contracts

package/test/contracts/lib/openzeppelin-contracts/scripts/prepare-docs.sh

@@ -0,0 +1,26 @@
+#!/usr/bin/env bash
+
+set -euo pipefail
+shopt -s globstar
+
+OUTDIR="$(node -p 'require("./docs/config.js").outputDir')"
+
+if [ ! -d node_modules ]; then
+  npm ci
+fi
+
+rm -rf "$OUTDIR"
+
+hardhat docgen
+
+# copy examples and adjust imports
+examples_source_dir="contracts/mocks/docs"
+examples_target_dir="docs/modules/api/examples"
+
+for f in "$examples_source_dir"/**/*.sol; do
+  name="${f/#"$examples_source_dir/"/}"
+  mkdir -p "$examples_target_dir/$(dirname "$name")"
+  sed -Ee '/^import/s|"(\.\./)+|"@openzeppelin/contracts/|' "$f" > "$examples_target_dir/$name"
+done
+
+node scripts/gen-nav.js "$OUTDIR" > "$OUTDIR/../nav.adoc"

package/test/contracts/lib/openzeppelin-contracts/scripts/prepare.sh

@@ -0,0 +1,10 @@
+#!/usr/bin/env bash
+
+set -euo pipefail
+
+if [ "${SKIP_COMPILE:-}" == true ]; then
+  exit
+fi
+
+npm run clean
+env COMPILE_MODE=production npm run compile

package/test/contracts/lib/openzeppelin-contracts/scripts/release/format-changelog.js

@@ -0,0 +1,33 @@
+#!/usr/bin/env node
+
+// Adjusts the format of the changelog that changesets generates.
+// This is run automatically when npm version is run.
+
+const fs = require('fs');
+const changelog = fs.readFileSync('CHANGELOG.md', 'utf8');
+
+// Groups:
+//  - 1: Pull Request Number and URL
+//  - 2: Changeset entry
+const RELEASE_LINE_REGEX = /^- (\[#.*?\]\(.*?\))?.*?! - (.*)$/gm;
+
+// Captures vX.Y.Z or vX.Y.Z-rc.W
+const VERSION_TITLE_REGEX = /^## (\d+\.\d+\.\d+(-rc\.\d+)?)$/gm;
+
+const isPrerelease = process.env.PRERELEASE === 'true';
+
+const formatted = changelog
+  // Remove titles
+  .replace(/^### Major Changes\n\n/gm, '')
+  .replace(/^### Minor Changes\n\n/gm, '')
+  .replace(/^### Patch Changes\n\n/gm, '')
+  // Remove extra whitespace between items
+  .replace(/^(- \[.*\n)\n(?=-)/gm, '$1')
+  // Format each release line
+  .replace(RELEASE_LINE_REGEX, (_, pr, entry) => (pr ? `- ${entry} (${pr})` : `- ${entry}`))
+  // Add date to new version
+  .replace(VERSION_TITLE_REGEX, `\n## $1 (${new Date().toISOString().split('T')[0]})`)
+  // Conditionally allow vX.Y.Z.rc-.W sections only in prerelease
+  .replace(/^## \d\.\d\.\d-rc\S+[^]+?(?=^#)/gm, section => (isPrerelease ? section : ''));
+
+fs.writeFileSync('CHANGELOG.md', formatted);

package/test/contracts/lib/openzeppelin-contracts/scripts/release/synchronize-versions.js

@@ -0,0 +1,15 @@
+#!/usr/bin/env node
+
+// Synchronizes the version in contracts/package.json with the one in package.json.
+// This is run automatically when npm version is run.
+
+const fs = require('fs');
+
+setVersion('package.json', 'contracts/package.json');
+
+function setVersion(from, to) {
+  const fromJson = JSON.parse(fs.readFileSync(from));
+  const toJson = JSON.parse(fs.readFileSync(to));
+  toJson.version = fromJson.version;
+  fs.writeFileSync(to, JSON.stringify(toJson, null, 2) + '\n');
+}

package/test/contracts/lib/openzeppelin-contracts/scripts/release/update-comment.js

@@ -0,0 +1,34 @@
+#!/usr/bin/env node
+const fs = require('fs');
+const proc = require('child_process');
+const semver = require('semver');
+const run = (cmd, ...args) => proc.execFileSync(cmd, args, { encoding: 'utf8' }).trim();
+
+const gitStatus = run('git', 'status', '--porcelain', '-uno', 'contracts/**/*.sol');
+if (gitStatus.length > 0) {
+  console.error('Contracts directory is not clean');
+  process.exit(1);
+}
+
+const { version } = require('../../package.json');
+
+// Get latest tag according to semver.
+const [tag] = run('git', 'tag')
+  .split(/\r?\n/)
+  .filter(semver.coerce) // check version can be processed
+  .filter(v => semver.satisfies(v, `< ${version}`)) // ignores prereleases unless currently a prerelease
+  .sort(semver.rcompare);
+
+// Ordering tag → HEAD is important here.
+const files = run('git', 'diff', tag, 'HEAD', '--name-only', 'contracts/**/*.sol')
+  .split(/\r?\n/)
+  .filter(file => file && !file.match(/mock/i) && fs.existsSync(file));
+
+for (const file of files) {
+  const current = fs.readFileSync(file, 'utf8');
+  const updated = current.replace(
+    /(\/\/ SPDX-License-Identifier:.*)$(\n\/\/ OpenZeppelin Contracts .*$)?/m,
+    `$1\n// OpenZeppelin Contracts (last updated v${version}) (${file.replace('contracts/', '')})`,
+  );
+  fs.writeFileSync(file, updated);
+}

package/test/contracts/lib/openzeppelin-contracts/scripts/release/version.sh

@@ -0,0 +1,11 @@
+#!/usr/bin/env bash
+
+set -euo pipefail
+
+changeset version
+
+scripts/release/format-changelog.js
+scripts/release/synchronize-versions.js
+scripts/release/update-comment.js
+
+oz-docs update-version