From 2a90488f1710d0177f311f3342948b510d3e3e6f Mon Sep 17 00:00:00 2001 From: johnpm-12 <39016062+johnpm-12@users.noreply.github.com> Date: Fri, 17 May 2024 15:15:17 -0700 Subject: [PATCH 01/18] fork from hardhat-chai-matchers for ethers --- .../hardhat-chai-matchers-viem/.eslintrc.js | 31 + .../hardhat-chai-matchers-viem/.gitignore | 92 ++ .../hardhat-chai-matchers-viem/.mocharc.json | 5 + .../.prettierignore | 13 + .../hardhat-chai-matchers-viem/CHANGELOG.md | 84 ++ packages/hardhat-chai-matchers-viem/LICENSE | 21 + packages/hardhat-chai-matchers-viem/README.md | 84 ++ .../hardhat-chai-matchers-viem/package.json | 80 ++ .../scripts/check-subpath-exports.js | 17 + .../hardhat-chai-matchers-viem/src/index.ts | 8 + .../src/internal/add-chai-matchers.ts | 8 + .../src/internal/addressable.ts | 77 ++ .../src/internal/bigNumber.ts | 258 ++++ .../src/internal/calledOnContract/utils.ts | 15 + .../src/internal/changeEtherBalance.ts | 130 ++ .../src/internal/changeEtherBalances.ts | 175 +++ .../src/internal/changeTokenBalance.ts | 275 ++++ .../src/internal/constants.ts | 13 + .../src/internal/emit.ts | 221 +++ .../src/internal/errors.ts | 33 + .../src/internal/hardhatChaiMatchers.ts | 38 + .../hardhatWaffleIncompatibilityCheck.ts | 11 + .../src/internal/hexEqual.ts | 29 + .../src/internal/misc/account.ts | 24 + .../src/internal/misc/balance.ts | 31 + .../src/internal/properAddress.ts | 12 + .../src/internal/properHex.ts | 29 + .../src/internal/properPrivateKey.ts | 12 + .../src/internal/reverted/panic.ts | 35 + .../src/internal/reverted/reverted.ts | 136 ++ .../src/internal/reverted/revertedWith.ts | 98 ++ .../reverted/revertedWithCustomError.ts | 235 ++++ .../internal/reverted/revertedWithPanic.ts | 117 ++ .../reverted/revertedWithoutReason.ts | 73 + .../src/internal/reverted/utils.ts | 127 ++ .../src/internal/typed.ts | 8 + .../src/internal/utils.ts | 170 +++ .../src/internal/withArgs.ts | 129 ++ .../hardhat-chai-matchers-viem/src/panic.ts | 2 + .../src/tsconfig.json | 19 + .../hardhat-chai-matchers-viem/src/types.ts | 66 + .../hardhat-chai-matchers-viem/src/utils.ts | 54 + .../src/withArgs.ts | 1 + .../test/.eslintrc.js | 16 + .../test/addressable.ts | 82 ++ .../test/bigNumber.ts | 1226 +++++++++++++++++ .../test/changeEtherBalance.ts | 630 +++++++++ .../test/changeEtherBalances.ts | 470 +++++++ .../test/changeTokenBalance.ts | 794 +++++++++++ .../test/contracts.ts | 133 ++ .../hardhat-chai-matchers-viem/test/events.ts | 876 ++++++++++++ .../test/fixture-projects/.gitignore | 2 + .../contracts/ChangeEtherBalance.sol | 14 + .../hardhat-project/contracts/Events.sol | 117 ++ .../hardhat-project/contracts/Matchers.sol | 137 ++ .../hardhat-project/contracts/Token.sol | 54 + .../hardhat-project/hardhat.config.js | 13 + .../hardhat-project/start-node.js | 14 + .../test/helpers.ts | 211 +++ .../test/hexEqual.ts | 79 ++ .../hardhat-chai-matchers-viem/test/panic.ts | 16 + .../test/properAddress.ts | 42 + .../test/properHex.ts | 54 + .../test/properPrivateKey.ts | 47 + .../test/reverted/reverted.ts | 430 ++++++ .../test/reverted/revertedWith.ts | 268 ++++ .../test/reverted/revertedWithCustomError.ts | 549 ++++++++ .../test/reverted/revertedWithPanic.ts | 335 +++++ .../test/reverted/revertedWithoutReason.ts | 204 +++ .../hardhat-chai-matchers-viem/tsconfig.json | 15 + 70 files changed, 9924 insertions(+) create mode 100644 packages/hardhat-chai-matchers-viem/.eslintrc.js create mode 100644 packages/hardhat-chai-matchers-viem/.gitignore create mode 100644 packages/hardhat-chai-matchers-viem/.mocharc.json create mode 100644 packages/hardhat-chai-matchers-viem/.prettierignore create mode 100644 packages/hardhat-chai-matchers-viem/CHANGELOG.md create mode 100644 packages/hardhat-chai-matchers-viem/LICENSE create mode 100644 packages/hardhat-chai-matchers-viem/README.md create mode 100644 packages/hardhat-chai-matchers-viem/package.json create mode 100644 packages/hardhat-chai-matchers-viem/scripts/check-subpath-exports.js create mode 100644 packages/hardhat-chai-matchers-viem/src/index.ts create mode 100644 packages/hardhat-chai-matchers-viem/src/internal/add-chai-matchers.ts create mode 100644 packages/hardhat-chai-matchers-viem/src/internal/addressable.ts create mode 100644 packages/hardhat-chai-matchers-viem/src/internal/bigNumber.ts create mode 100644 packages/hardhat-chai-matchers-viem/src/internal/calledOnContract/utils.ts create mode 100644 packages/hardhat-chai-matchers-viem/src/internal/changeEtherBalance.ts create mode 100644 packages/hardhat-chai-matchers-viem/src/internal/changeEtherBalances.ts create mode 100644 packages/hardhat-chai-matchers-viem/src/internal/changeTokenBalance.ts create mode 100644 packages/hardhat-chai-matchers-viem/src/internal/constants.ts create mode 100644 packages/hardhat-chai-matchers-viem/src/internal/emit.ts create mode 100644 packages/hardhat-chai-matchers-viem/src/internal/errors.ts create mode 100644 packages/hardhat-chai-matchers-viem/src/internal/hardhatChaiMatchers.ts create mode 100644 packages/hardhat-chai-matchers-viem/src/internal/hardhatWaffleIncompatibilityCheck.ts create mode 100644 packages/hardhat-chai-matchers-viem/src/internal/hexEqual.ts create mode 100644 packages/hardhat-chai-matchers-viem/src/internal/misc/account.ts create mode 100644 packages/hardhat-chai-matchers-viem/src/internal/misc/balance.ts create mode 100644 packages/hardhat-chai-matchers-viem/src/internal/properAddress.ts create mode 100644 packages/hardhat-chai-matchers-viem/src/internal/properHex.ts create mode 100644 packages/hardhat-chai-matchers-viem/src/internal/properPrivateKey.ts create mode 100644 packages/hardhat-chai-matchers-viem/src/internal/reverted/panic.ts create mode 100644 packages/hardhat-chai-matchers-viem/src/internal/reverted/reverted.ts create mode 100644 packages/hardhat-chai-matchers-viem/src/internal/reverted/revertedWith.ts create mode 100644 packages/hardhat-chai-matchers-viem/src/internal/reverted/revertedWithCustomError.ts create mode 100644 packages/hardhat-chai-matchers-viem/src/internal/reverted/revertedWithPanic.ts create mode 100644 packages/hardhat-chai-matchers-viem/src/internal/reverted/revertedWithoutReason.ts create mode 100644 packages/hardhat-chai-matchers-viem/src/internal/reverted/utils.ts create mode 100644 packages/hardhat-chai-matchers-viem/src/internal/typed.ts create mode 100644 packages/hardhat-chai-matchers-viem/src/internal/utils.ts create mode 100644 packages/hardhat-chai-matchers-viem/src/internal/withArgs.ts create mode 100644 packages/hardhat-chai-matchers-viem/src/panic.ts create mode 100644 packages/hardhat-chai-matchers-viem/src/tsconfig.json create mode 100644 packages/hardhat-chai-matchers-viem/src/types.ts create mode 100644 packages/hardhat-chai-matchers-viem/src/utils.ts create mode 100644 packages/hardhat-chai-matchers-viem/src/withArgs.ts create mode 100644 packages/hardhat-chai-matchers-viem/test/.eslintrc.js create mode 100644 packages/hardhat-chai-matchers-viem/test/addressable.ts create mode 100644 packages/hardhat-chai-matchers-viem/test/bigNumber.ts create mode 100644 packages/hardhat-chai-matchers-viem/test/changeEtherBalance.ts create mode 100644 packages/hardhat-chai-matchers-viem/test/changeEtherBalances.ts create mode 100644 packages/hardhat-chai-matchers-viem/test/changeTokenBalance.ts create mode 100644 packages/hardhat-chai-matchers-viem/test/contracts.ts create mode 100644 packages/hardhat-chai-matchers-viem/test/events.ts create mode 100644 packages/hardhat-chai-matchers-viem/test/fixture-projects/.gitignore create mode 100644 packages/hardhat-chai-matchers-viem/test/fixture-projects/hardhat-project/contracts/ChangeEtherBalance.sol create mode 100644 packages/hardhat-chai-matchers-viem/test/fixture-projects/hardhat-project/contracts/Events.sol create mode 100644 packages/hardhat-chai-matchers-viem/test/fixture-projects/hardhat-project/contracts/Matchers.sol create mode 100644 packages/hardhat-chai-matchers-viem/test/fixture-projects/hardhat-project/contracts/Token.sol create mode 100644 packages/hardhat-chai-matchers-viem/test/fixture-projects/hardhat-project/hardhat.config.js create mode 100644 packages/hardhat-chai-matchers-viem/test/fixture-projects/hardhat-project/start-node.js create mode 100644 packages/hardhat-chai-matchers-viem/test/helpers.ts create mode 100644 packages/hardhat-chai-matchers-viem/test/hexEqual.ts create mode 100644 packages/hardhat-chai-matchers-viem/test/panic.ts create mode 100644 packages/hardhat-chai-matchers-viem/test/properAddress.ts create mode 100644 packages/hardhat-chai-matchers-viem/test/properHex.ts create mode 100644 packages/hardhat-chai-matchers-viem/test/properPrivateKey.ts create mode 100644 packages/hardhat-chai-matchers-viem/test/reverted/reverted.ts create mode 100644 packages/hardhat-chai-matchers-viem/test/reverted/revertedWith.ts create mode 100644 packages/hardhat-chai-matchers-viem/test/reverted/revertedWithCustomError.ts create mode 100644 packages/hardhat-chai-matchers-viem/test/reverted/revertedWithPanic.ts create mode 100644 packages/hardhat-chai-matchers-viem/test/reverted/revertedWithoutReason.ts create mode 100644 packages/hardhat-chai-matchers-viem/tsconfig.json diff --git a/packages/hardhat-chai-matchers-viem/.eslintrc.js b/packages/hardhat-chai-matchers-viem/.eslintrc.js new file mode 100644 index 0000000000..fb4faa04b9 --- /dev/null +++ b/packages/hardhat-chai-matchers-viem/.eslintrc.js @@ -0,0 +1,31 @@ +const { + slowImportsCommonIgnoredModules, +} = require("../../config/eslint/constants"); + +module.exports = { + extends: [`${__dirname}/../../config/eslint/eslintrc.js`], + parserOptions: { + project: `${__dirname}/src/tsconfig.json`, + sourceType: "module", + }, + rules: { + "@typescript-eslint/no-non-null-assertion": "error", + }, + overrides: [ + { + files: ["src/index.ts"], + rules: { + "@nomicfoundation/slow-imports/no-top-level-external-import": [ + "error", + { + ignoreModules: [ + ...slowImportsCommonIgnoredModules, + "chai", + "chai-as-promised", + ], + }, + ], + }, + }, + ], +}; diff --git a/packages/hardhat-chai-matchers-viem/.gitignore b/packages/hardhat-chai-matchers-viem/.gitignore new file mode 100644 index 0000000000..8707b8ac84 --- /dev/null +++ b/packages/hardhat-chai-matchers-viem/.gitignore @@ -0,0 +1,92 @@ +# Node modules +/node_modules + +# Compilation output +/build-test/ +/dist +/internal +/types +/*.js +/*.js.map +/*.d.ts +/*.d.ts.map + +# Code coverage artifacts +/coverage +/.nyc_output + +# Below is Github's node gitignore template, +# ignoring the node_modules part, as it'd ignore every node_modules, and we have some for testing + +# Logs +logs +*.log + +# Diagnostic reports (https://nodejs.org/api/report.html) +report.[0-9]*.[0-9]*.[0-9]*.[0-9]*.json + +# Runtime data +pids +*.pid +*.seed +*.pid.lock + +# Directory for instrumented libs generated by jscoverage/JSCover +lib-cov + +# Coverage directory used by tools like istanbul +coverage + +# nyc test coverage +.nyc_output + +# Grunt intermediate storage (https://gruntjs.com/creating-plugins#storing-task-files) +.grunt + +# Bower dependency directory (https://bower.io/) +bower_components + +# node-waf configuration +.lock-wscript + +# Compiled binary addons (https://nodejs.org/api/addons.html) +build/Release + +# Dependency directories +#node_modules/ +jspm_packages/ + +# TypeScript v1 declaration files +typings/ + +# Optional eslint cache +.eslintcache + +# Optional REPL history +.node_repl_history + +# Output of 'pnpm pack' +*.tgz + +# parcel-bundler cache (https://parceljs.org/) +.cache + +# next.js build output +.next + +# nuxt.js build output +.nuxt + +# vuepress build output +.vuepress/dist + +# Serverless directories +.serverless/ + +# FuseBox cache +.fusebox/ + +# DynamoDB Local files +.dynamodb/ + +!.eslintrc.js diff --git a/packages/hardhat-chai-matchers-viem/.mocharc.json b/packages/hardhat-chai-matchers-viem/.mocharc.json new file mode 100644 index 0000000000..d00ceb4138 --- /dev/null +++ b/packages/hardhat-chai-matchers-viem/.mocharc.json @@ -0,0 +1,5 @@ +{ + "require": "ts-node/register/files", + "ignore": ["test/fixture-projects/**/*"], + "timeout": 10000 +} diff --git a/packages/hardhat-chai-matchers-viem/.prettierignore b/packages/hardhat-chai-matchers-viem/.prettierignore new file mode 100644 index 0000000000..2ef4541cbc --- /dev/null +++ b/packages/hardhat-chai-matchers-viem/.prettierignore @@ -0,0 +1,13 @@ +/node_modules +/dist +/internal +/types +/*.d.ts +/*.d.ts.map +/*.js +/*.js.map +/build-test +/test/fixture-projects/**/artifacts +/test/fixture-projects/**/cache +CHANGELOG.md +!.eslintrc.js diff --git a/packages/hardhat-chai-matchers-viem/CHANGELOG.md b/packages/hardhat-chai-matchers-viem/CHANGELOG.md new file mode 100644 index 0000000000..255f4a9c7a --- /dev/null +++ b/packages/hardhat-chai-matchers-viem/CHANGELOG.md @@ -0,0 +1,84 @@ +# @nomicfoundation/hardhat-chai-matchers + +## 2.0.6 + +### Patch Changes + +- 69fc3a4: Improved error messages of the `.withArgs` matcher (thanks @RenanSouza2!) + +## 2.0.5 + +### Patch Changes + +- 72bf9f6: Added support for Typed objects (thanks @RenanSouza2!) +- 82bc59d: Improved how `.revertedWithCustomError` handles wrong number of arguments (thanks @RenanSouza2!) + +## 2.0.4 + +### Patch Changes + +- ffb301f14: Improved loading performance + +## 2.0.3 + +### Patch Changes + +- dff8302aa: Added support for `Addressable` objects in `.withArgs` and `.equals` (thanks @Amxx!) + +## 2.0.2 + +### Patch Changes + +- f324b3a33: Forbid chaining incompatible chai matchers + +## 2.0.1 + +### Patch Changes + +- 70c2ccf12: Removed an unnecessary dependency + +## 2.0.0 + +### Major Changes + +- 523235b83: Added support for ethers v6 + +### Patch Changes + +- 06c4797a7: Fixed a problem when `.withArgs` was used with arrays with different length + +## 1.0.6 + +### Patch Changes + +- 8fa00c97c: Improved the warning shown when both `@nomicfoundation/hardhat-chai-matchers` and `@nomiclabs/hardhat-waffle` are used. + +## 1.0.5 + +### Patch Changes + +- 478c244a7: The `revertedWith` matcher now supports regular expressions (thanks @Dkdaniz!) + +## 1.0.4 + +### Patch Changes + +- 691f0cecb: Fixed the values matched by `properAddress` and `properPrivateKey` (thanks @olehmisar!) + +## 1.0.3 + +### Patch Changes + +- 616a78617: Failed assertions now show a more useful stack trace + +## 1.0.2 + +### Patch Changes + +- 857a56069: Fixed a bug where `changeTokenBalances` was sending the tx multiple times when used with a callback + +## 1.0.1 + +### Patch Changes + +- ed6222bf1: Fix an error in revertedWithCustomError's argument matching diff --git a/packages/hardhat-chai-matchers-viem/LICENSE b/packages/hardhat-chai-matchers-viem/LICENSE new file mode 100644 index 0000000000..3b7e8c7eab --- /dev/null +++ b/packages/hardhat-chai-matchers-viem/LICENSE @@ -0,0 +1,21 @@ +MIT License + +Copyright (c) 2023 Nomic Foundation + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. diff --git a/packages/hardhat-chai-matchers-viem/README.md b/packages/hardhat-chai-matchers-viem/README.md new file mode 100644 index 0000000000..60f879d0f4 --- /dev/null +++ b/packages/hardhat-chai-matchers-viem/README.md @@ -0,0 +1,84 @@ +[![npm](https://img.shields.io/npm/v/@nomicfoundation/hardhat-chai-matchers.svg)](https://www.npmjs.com/package/@nomicfoundation/hardhat-chai-matchers) + +# Hardhat Chai Matchers + +This plugin adds Ethereum-specific capabilities to the [Chai](https://chaijs.com/) assertion library, making your smart contract tests easy to write and read. + +Check [its documentation](https://hardhat.org/hardhat-chai-matchers/docs) to learn more. + +### Installation + +We recommend using npm 7 or later. If you do that, then you just need to install the plugin itself: + +```bash +npm install --save-dev @nomicfoundation/hardhat-chai-matchers +``` + +If you are using an older version of npm, you'll also need to install all the packages used by the plugin. + +```bash +npm install --save-dev @nomicfoundation/hardhat-chai-matchers chai@4 @nomicfoundation/hardhat-ethers ethers +``` + +That's also the case if you are using yarn: + +```bash +yarn add --dev @nomicfoundation/hardhat-chai-matchers chai@4 @nomicfoundation/hardhat-ethers ethers +``` + +### Usage + +After installing it, add the plugin to your Hardhat config: + +```js +require("@nomicfoundation/hardhat-chai-matchers"); +``` + +Then you'll be able to use the matchers in your tests: + +```js +expect(await token.totalSupply()).to.equal(1_000_000); + +await expect(token.transfer(token, 1000)).to.be.revertedWith( + "Cannot transfer to the contract itself" +); + +await expect(token.transfer(recipient, 1000)) + .to.emit(token, "Transfer") + .withArgs(owner, recipient, 1000); +``` + +### Known issues + +#### Chaining Async Matchers + +Currently, the following matchers do not support chaining: + +- `reverted` +- `revertedWith` +- `revertedWithCustomError` +- `revertedWithoutReason` +- `revertedWithPanic` +- `changeEtherBalance` +- `changeEtherBalances` +- `changeTokenBalance` +- `changeTokenBalances` +- `emit` (with the only exception of chaining multiple `emit` matchers) + +Which means you can't do: + +```js +await expect(contract.f(...)) + .to.changeEtherBalance(...) + .and.to.changeTokenBalance(...) +``` + +To work around this limitation, write separate assertions for each matcher: + +```js +const tx = contract.f(...); +await expect(tx).to.changeEtherBalance(...) +await expect(tx).to.changeTokenBalance(...) +``` + +If you are interested in seeing an implementation of chaining for async matchers, please visit the GitHub issue [#4235](https://github.com/NomicFoundation/hardhat/issues/4235) and leave an upvote or comment. diff --git a/packages/hardhat-chai-matchers-viem/package.json b/packages/hardhat-chai-matchers-viem/package.json new file mode 100644 index 0000000000..6397d86210 --- /dev/null +++ b/packages/hardhat-chai-matchers-viem/package.json @@ -0,0 +1,80 @@ +{ + "name": "@nomicfoundation/hardhat-chai-matchers", + "version": "2.0.6", + "description": "Hardhat utils for testing", + "homepage": "https://github.com/nomicfoundation/hardhat/tree/main/packages/hardhat-chai-matchers", + "repository": "github:nomicfoundation/hardhat", + "author": "Nomic Foundation", + "license": "MIT", + "main": "index.js", + "types": "index.d.ts", + "keywords": [ + "ethereum", + "smart-contracts", + "hardhat", + "testing" + ], + "scripts": { + "lint": "pnpm prettier --check && pnpm eslint", + "lint:fix": "pnpm prettier --write && pnpm eslint --fix", + "eslint": "eslint 'src/**/*.ts' 'test/**/*.ts'", + "prettier": "prettier \"**/*.{js,md,json}\"", + "pretest": "cd ../.. && pnpm build", + "test": "mocha --recursive \"test/**/*.ts\" --exit", + "test:ci": "pnpm test && node scripts/check-subpath-exports.js", + "build": "tsc --build .", + "prepublishOnly": "pnpm build", + "clean": "rimraf dist internal types *.{d.ts,js}{,.map} build-test tsconfig.tsbuildinfo" + }, + "files": [ + "src/", + "internal/", + "types/", + "*.d.ts", + "*.d.ts.map", + "*.js", + "*.js.map", + "LICENSE", + "README.md" + ], + "devDependencies": { + "@nomicfoundation/eslint-plugin-hardhat-internal-rules": "workspace:^", + "@nomicfoundation/eslint-plugin-slow-imports": "workspace:^", + "@nomicfoundation/hardhat-chai-matchers": "workspace:*", + "@nomicfoundation/hardhat-ethers": "workspace:^3.0.0", + "@types/bn.js": "^5.1.0", + "@types/chai": "^4.2.0", + "@types/mocha": ">=9.1.0", + "@types/node": "^18.0.0", + "@typescript-eslint/eslint-plugin": "5.61.0", + "@typescript-eslint/parser": "5.61.0", + "bignumber.js": "^9.0.2", + "bn.js": "^5.1.0", + "chai": "^4.2.0", + "eslint": "^8.44.0", + "eslint-config-prettier": "8.3.0", + "eslint-plugin-import": "2.27.5", + "eslint-plugin-mocha": "10.4.1", + "eslint-plugin-prettier": "3.4.0", + "ethers": "^6.1.0", + "get-port": "^5.1.1", + "hardhat": "workspace:^2.9.4", + "mocha": "^10.0.0", + "prettier": "2.4.1", + "rimraf": "^3.0.2", + "ts-node": "^10.8.0", + "typescript": "~5.0.0" + }, + "peerDependencies": { + "@nomicfoundation/hardhat-ethers": "workspace:^3.0.0", + "chai": "^4.2.0", + "ethers": "^6.1.0", + "hardhat": "workspace:^2.9.4" + }, + "dependencies": { + "@types/chai-as-promised": "^7.1.3", + "chai-as-promised": "^7.1.1", + "deep-eql": "^4.0.1", + "ordinal": "^1.0.3" + } +} diff --git a/packages/hardhat-chai-matchers-viem/scripts/check-subpath-exports.js b/packages/hardhat-chai-matchers-viem/scripts/check-subpath-exports.js new file mode 100644 index 0000000000..3270f86d51 --- /dev/null +++ b/packages/hardhat-chai-matchers-viem/scripts/check-subpath-exports.js @@ -0,0 +1,17 @@ +const assert = require("assert"); + +// This script checks that the subpath exports works as expected. +// This only works if the project was previously built, so this is not +// run as part of the "test" script to avoid having to build the project +// every time the tests are run. + +const { PANIC_CODES } = require("@nomicfoundation/hardhat-chai-matchers/panic"); + +assert(PANIC_CODES !== undefined); + +const { + anyUint, + anyValue, +} = require("@nomicfoundation/hardhat-chai-matchers/withArgs"); +assert(anyUint !== undefined); +assert(anyValue !== undefined); diff --git a/packages/hardhat-chai-matchers-viem/src/index.ts b/packages/hardhat-chai-matchers-viem/src/index.ts new file mode 100644 index 0000000000..d5fa986711 --- /dev/null +++ b/packages/hardhat-chai-matchers-viem/src/index.ts @@ -0,0 +1,8 @@ +import "@nomicfoundation/hardhat-ethers"; + +import "./types"; + +import { hardhatWaffleIncompatibilityCheck } from "./internal/hardhatWaffleIncompatibilityCheck"; +import "./internal/add-chai-matchers"; + +hardhatWaffleIncompatibilityCheck(); diff --git a/packages/hardhat-chai-matchers-viem/src/internal/add-chai-matchers.ts b/packages/hardhat-chai-matchers-viem/src/internal/add-chai-matchers.ts new file mode 100644 index 0000000000..5988ac6885 --- /dev/null +++ b/packages/hardhat-chai-matchers-viem/src/internal/add-chai-matchers.ts @@ -0,0 +1,8 @@ +import { use } from "chai"; +import chaiAsPromised from "chai-as-promised"; + +import "../types"; +import { hardhatChaiMatchers } from "./hardhatChaiMatchers"; + +use(hardhatChaiMatchers); +use(chaiAsPromised); diff --git a/packages/hardhat-chai-matchers-viem/src/internal/addressable.ts b/packages/hardhat-chai-matchers-viem/src/internal/addressable.ts new file mode 100644 index 0000000000..71ad0c85e1 --- /dev/null +++ b/packages/hardhat-chai-matchers-viem/src/internal/addressable.ts @@ -0,0 +1,77 @@ +import type EthersT from "ethers"; + +import { tryDereference } from "./typed"; + +export function supportAddressable( + Assertion: Chai.AssertionStatic, + chaiUtils: Chai.ChaiUtils +) { + const equalsFunction = override("eq", "equal", "not equal", chaiUtils); + Assertion.overwriteMethod("equals", equalsFunction); + Assertion.overwriteMethod("equal", equalsFunction); + Assertion.overwriteMethod("eq", equalsFunction); +} + +type Methods = "eq"; + +function override( + method: Methods, + name: string, + negativeName: string, + chaiUtils: Chai.ChaiUtils +) { + return (_super: (...args: any[]) => any) => + overwriteAddressableFunction(method, name, negativeName, _super, chaiUtils); +} + +// ethers's Addressable have a .getAddress() that returns a Promise. We don't want to deal with async here, +// so we are looking for a sync way of getting the address. If an address was recovered, it is returned as a string, +// otherwise undefined is returned. +function tryGetAddressSync(value: any): string | undefined { + const { isAddress, isAddressable } = require("ethers") as typeof EthersT; + + value = tryDereference(value, "address"); + if (isAddressable(value)) { + value = (value as any).address ?? (value as any).target; + } + if (isAddress(value)) { + return value; + } else { + return undefined; + } +} + +function overwriteAddressableFunction( + functionName: Methods, + readableName: string, + readableNegativeName: string, + _super: (...args: any[]) => any, + chaiUtils: Chai.ChaiUtils +) { + return function (this: Chai.AssertionStatic, ...args: any[]) { + const [actualArg, message] = args; + const expectedFlag = chaiUtils.flag(this, "object"); + + if (message !== undefined) { + chaiUtils.flag(this, "message", message); + } + + const actual = tryGetAddressSync(actualArg); + const expected = tryGetAddressSync(expectedFlag); + if ( + functionName === "eq" && + expected !== undefined && + actual !== undefined + ) { + this.assert( + expected === actual, + `expected '${expected}' to ${readableName} '${actual}'.`, + `expected '${expected}' to ${readableNegativeName} '${actual}'.`, + actual.toString(), + expected.toString() + ); + } else { + _super.apply(this, args); + } + }; +} diff --git a/packages/hardhat-chai-matchers-viem/src/internal/bigNumber.ts b/packages/hardhat-chai-matchers-viem/src/internal/bigNumber.ts new file mode 100644 index 0000000000..9a40443639 --- /dev/null +++ b/packages/hardhat-chai-matchers-viem/src/internal/bigNumber.ts @@ -0,0 +1,258 @@ +import { AssertionError } from "chai"; +import { isBigNumber, normalizeToBigInt } from "hardhat/common/bigInt"; +import util from "util"; + +export function supportBigNumber( + Assertion: Chai.AssertionStatic, + chaiUtils: Chai.ChaiUtils +) { + const equalsFunction = override("eq", "equal", "not equal", chaiUtils); + Assertion.overwriteMethod("equals", equalsFunction); + Assertion.overwriteMethod("equal", equalsFunction); + Assertion.overwriteMethod("eq", equalsFunction); + + const gtFunction = override("gt", "be above", "be at most", chaiUtils); + Assertion.overwriteMethod("above", gtFunction); + Assertion.overwriteMethod("gt", gtFunction); + Assertion.overwriteMethod("greaterThan", gtFunction); + + const ltFunction = override("lt", "be below", "be at least", chaiUtils); + Assertion.overwriteMethod("below", ltFunction); + Assertion.overwriteMethod("lt", ltFunction); + Assertion.overwriteMethod("lessThan", ltFunction); + + const gteFunction = override("gte", "be at least", "be below", chaiUtils); + Assertion.overwriteMethod("least", gteFunction); + Assertion.overwriteMethod("gte", gteFunction); + Assertion.overwriteMethod("greaterThanOrEqual", gteFunction); + + const lteFunction = override("lte", "be at most", "be above", chaiUtils); + Assertion.overwriteMethod("most", lteFunction); + Assertion.overwriteMethod("lte", lteFunction); + Assertion.overwriteMethod("lessThanOrEqual", lteFunction); + + Assertion.overwriteChainableMethod(...createLengthOverride("length")); + Assertion.overwriteChainableMethod(...createLengthOverride("lengthOf")); + + Assertion.overwriteMethod("within", overrideWithin(chaiUtils)); + + Assertion.overwriteMethod("closeTo", overrideCloseTo(chaiUtils)); + Assertion.overwriteMethod("approximately", overrideCloseTo(chaiUtils)); +} + +function createLengthOverride( + method: string +): [string, (...args: any[]) => any, (...args: any[]) => any] { + return [ + method, + function (_super: any) { + return function (this: Chai.AssertionPrototype, value: any) { + const actual = this._obj; + if (isBigNumber(value)) { + const sizeOrLength = + actual instanceof Map || actual instanceof Set ? "size" : "length"; + const actualLength = normalizeToBigInt(actual[sizeOrLength]); + const expectedLength = normalizeToBigInt(value); + this.assert( + actualLength === expectedLength, + `expected #{this} to have a ${sizeOrLength} of ${expectedLength.toString()} but got ${actualLength.toString()}`, + `expected #{this} not to have a ${sizeOrLength} of ${expectedLength.toString()} but got ${actualLength.toString()}`, + actualLength.toString(), + expectedLength.toString() + ); + } else { + _super.apply(this, arguments); + } + }; + }, + function (_super: any) { + return function (this: any) { + _super.apply(this, arguments); + }; + } as any, + ]; +} + +type Methods = "eq" | "gt" | "lt" | "gte" | "lte"; + +function override( + method: Methods, + name: string, + negativeName: string, + chaiUtils: Chai.ChaiUtils +) { + return (_super: (...args: any[]) => any) => + overwriteBigNumberFunction(method, name, negativeName, _super, chaiUtils); +} + +function overwriteBigNumberFunction( + functionName: Methods, + readableName: string, + readableNegativeName: string, + _super: (...args: any[]) => any, + chaiUtils: Chai.ChaiUtils +) { + return function (this: Chai.AssertionStatic, ...args: any[]) { + const [actualArg, message] = args; + const expectedFlag = chaiUtils.flag(this, "object"); + + if (message !== undefined) { + chaiUtils.flag(this, "message", message); + } + + function compare(method: Methods, lhs: bigint, rhs: bigint): boolean { + if (method === "eq") { + return lhs === rhs; + } else if (method === "gt") { + return lhs > rhs; + } else if (method === "lt") { + return lhs < rhs; + } else if (method === "gte") { + return lhs >= rhs; + } else if (method === "lte") { + return lhs <= rhs; + } else { + throw new Error(`Unknown comparison operation ${method as any}`); + } + } + if (Boolean(chaiUtils.flag(this, "doLength")) && isBigNumber(actualArg)) { + const sizeOrLength = + expectedFlag instanceof Map || expectedFlag instanceof Set + ? "size" + : "length"; + if (expectedFlag[sizeOrLength] === undefined) { + _super.apply(this, args); + return; + } + const expected = normalizeToBigInt(expectedFlag[sizeOrLength]); + const actual = normalizeToBigInt(actualArg); + this.assert( + compare(functionName, expected, actual), + `expected #{this} to have a ${sizeOrLength} ${readableName.replace( + "be ", + "" + )} ${actual.toString()} but got ${expected}`, + `expected #{this} to have a ${sizeOrLength} ${readableNegativeName} ${actual.toString()}`, + expected, + actual + ); + } else if (functionName === "eq" && Boolean(chaiUtils.flag(this, "deep"))) { + const deepEqual = require("deep-eql"); + // this is close enough to what chai itself does, except we compare + // numbers after normalizing them + const comparator = (a: any, b: any): boolean | null => { + try { + const normalizedA = normalizeToBigInt(a); + const normalizedB = normalizeToBigInt(b); + return normalizedA === normalizedB; + } catch (e) { + // use default comparator + return null; + } + }; + + // "ssfi" stands for "start stack function indicator", it's a chai concept + // used to control which frames are included in the stack trace + // this pattern here was taken from chai's implementation of .deep.equal + const prevLockSsfi = chaiUtils.flag(this, "lockSsfi"); + chaiUtils.flag(this, "lockSsfi", true); + this.assert( + deepEqual(actualArg, expectedFlag, { comparator }), + `expected ${util.inspect(expectedFlag)} to deeply equal ${util.inspect( + actualArg + )}`, + `expected ${util.inspect( + expectedFlag + )} to not deeply equal ${util.inspect(actualArg)}`, + null + ); + chaiUtils.flag(this, "lockSsfi", prevLockSsfi); + } else if (isBigNumber(expectedFlag) || isBigNumber(actualArg)) { + const expected = normalizeToBigInt(expectedFlag); + const actual = normalizeToBigInt(actualArg); + this.assert( + compare(functionName, expected, actual), + `expected ${expected} to ${readableName} ${actual}.`, + `expected ${expected} to ${readableNegativeName} ${actual}.`, + actual.toString(), + expected.toString() + ); + } else { + _super.apply(this, args); + } + }; +} + +function overrideWithin(chaiUtils: Chai.ChaiUtils) { + return (_super: (...args: any[]) => any) => + overwriteBigNumberWithin(_super, chaiUtils); +} + +function overwriteBigNumberWithin( + _super: (...args: any[]) => any, + chaiUtils: Chai.ChaiUtils +) { + return function (this: Chai.AssertionStatic, ...args: any[]) { + const [startArg, finishArg] = args; + const expectedFlag = chaiUtils.flag(this, "object"); + if ( + isBigNumber(expectedFlag) || + isBigNumber(startArg) || + isBigNumber(finishArg) + ) { + const expected = normalizeToBigInt(expectedFlag); + const start = normalizeToBigInt(startArg); + const finish = normalizeToBigInt(finishArg); + this.assert( + start <= expected && expected <= finish, + `expected ${expected} to be within ${start}..${finish}`, + `expected ${expected} to not be within ${start}..${finish}`, + expected, + [start, finish] + ); + } else { + _super.apply(this, args); + } + }; +} + +function overrideCloseTo(chaiUtils: Chai.ChaiUtils) { + return (_super: (...args: any[]) => any) => + overwriteBigNumberCloseTo(_super, chaiUtils); +} + +function overwriteBigNumberCloseTo( + _super: (...args: any[]) => any, + chaiUtils: Chai.ChaiUtils +) { + return function (this: Chai.AssertionStatic, ...args: any[]) { + const [actualArg, deltaArg] = args; + const expectedFlag = chaiUtils.flag(this, "object"); + if ( + isBigNumber(expectedFlag) || + isBigNumber(actualArg) || + isBigNumber(deltaArg) + ) { + if (deltaArg === undefined) { + throw new AssertionError( + "the arguments to closeTo or approximately must be numbers, and a delta is required" + ); + } + const expected = normalizeToBigInt(expectedFlag); + const actual = normalizeToBigInt(actualArg); + const delta = normalizeToBigInt(deltaArg); + function abs(i: bigint): bigint { + return i < 0 ? BigInt(-1) * i : i; + } + this.assert( + abs(expected - actual) <= delta, + `expected ${expected} to be close to ${actual} +/- ${delta}`, + `expected ${expected} not to be close to ${actual} +/- ${delta}`, + expected, + `A number between ${actual - delta} and ${actual + delta}` + ); + } else { + _super.apply(this, args); + } + }; +} diff --git a/packages/hardhat-chai-matchers-viem/src/internal/calledOnContract/utils.ts b/packages/hardhat-chai-matchers-viem/src/internal/calledOnContract/utils.ts new file mode 100644 index 0000000000..7c344bd8ff --- /dev/null +++ b/packages/hardhat-chai-matchers-viem/src/internal/calledOnContract/utils.ts @@ -0,0 +1,15 @@ +/* eslint-disable @typescript-eslint/prefer-function-type */ + +interface ErrorConstructor { + new (...args: T): Error; +} + +export function ensure( + condition: boolean, + ErrorToThrow: ErrorConstructor, + ...errorArgs: T +): asserts condition { + if (!condition) { + throw new ErrorToThrow(...errorArgs); + } +} diff --git a/packages/hardhat-chai-matchers-viem/src/internal/changeEtherBalance.ts b/packages/hardhat-chai-matchers-viem/src/internal/changeEtherBalance.ts new file mode 100644 index 0000000000..7aeb31c75c --- /dev/null +++ b/packages/hardhat-chai-matchers-viem/src/internal/changeEtherBalance.ts @@ -0,0 +1,130 @@ +import type { + Addressable, + BigNumberish, + TransactionResponse, + default as EthersT, +} from "ethers"; +import type { BalanceChangeOptions } from "./misc/balance"; + +import { buildAssert } from "../utils"; +import { ensure } from "./calledOnContract/utils"; +import { getAddressOf } from "./misc/account"; +import { CHANGE_ETHER_BALANCE_MATCHER } from "./constants"; +import { assertIsNotNull, preventAsyncMatcherChaining } from "./utils"; + +export function supportChangeEtherBalance( + Assertion: Chai.AssertionStatic, + chaiUtils: Chai.ChaiUtils +) { + Assertion.addMethod( + CHANGE_ETHER_BALANCE_MATCHER, + function ( + this: any, + account: Addressable | string, + balanceChange: BigNumberish | ((change: bigint) => boolean), + options?: BalanceChangeOptions + ) { + const { toBigInt } = require("ethers") as typeof EthersT; + // capture negated flag before async code executes; see buildAssert's jsdoc + const negated = this.__flags.negate; + const subject = this._obj; + + preventAsyncMatcherChaining( + this, + CHANGE_ETHER_BALANCE_MATCHER, + chaiUtils + ); + + const checkBalanceChange = ([actualChange, address]: [ + bigint, + string + ]) => { + const assert = buildAssert(negated, checkBalanceChange); + + if (typeof balanceChange === "function") { + assert( + balanceChange(actualChange), + `Expected the ether balance change of "${address}" to satisfy the predicate, but it didn't (balance change: ${actualChange.toString()} wei)`, + `Expected the ether balance change of "${address}" to NOT satisfy the predicate, but it did (balance change: ${actualChange.toString()} wei)` + ); + } else { + const expectedChange = toBigInt(balanceChange); + assert( + actualChange === expectedChange, + `Expected the ether balance of "${address}" to change by ${balanceChange.toString()} wei, but it changed by ${actualChange.toString()} wei`, + `Expected the ether balance of "${address}" NOT to change by ${balanceChange.toString()} wei, but it did` + ); + } + }; + + const derivedPromise = Promise.all([ + getBalanceChange(subject, account, options), + getAddressOf(account), + ]).then(checkBalanceChange); + this.then = derivedPromise.then.bind(derivedPromise); + this.catch = derivedPromise.catch.bind(derivedPromise); + this.promise = derivedPromise; + return this; + } + ); +} + +export async function getBalanceChange( + transaction: + | TransactionResponse + | Promise + | (() => Promise | TransactionResponse), + account: Addressable | string, + options?: BalanceChangeOptions +): Promise { + const hre = await import("hardhat"); + const provider = hre.network.provider; + + let txResponse: TransactionResponse; + + if (typeof transaction === "function") { + txResponse = await transaction(); + } else { + txResponse = await transaction; + } + + const txReceipt = await txResponse.wait(); + assertIsNotNull(txReceipt, "txReceipt"); + const txBlockNumber = txReceipt.blockNumber; + + const block = await provider.send("eth_getBlockByHash", [ + txReceipt.blockHash, + false, + ]); + + ensure( + block.transactions.length === 1, + Error, + "Multiple transactions found in block" + ); + + const address = await getAddressOf(account); + + const balanceAfterHex = await provider.send("eth_getBalance", [ + address, + `0x${txBlockNumber.toString(16)}`, + ]); + + const balanceBeforeHex = await provider.send("eth_getBalance", [ + address, + `0x${(txBlockNumber - 1).toString(16)}`, + ]); + + const balanceAfter = BigInt(balanceAfterHex); + const balanceBefore = BigInt(balanceBeforeHex); + + if (options?.includeFee !== true && address === txResponse.from) { + const gasPrice = txReceipt.gasPrice; + const gasUsed = txReceipt.gasUsed; + const txFee = gasPrice * gasUsed; + + return balanceAfter + txFee - balanceBefore; + } else { + return balanceAfter - balanceBefore; + } +} diff --git a/packages/hardhat-chai-matchers-viem/src/internal/changeEtherBalances.ts b/packages/hardhat-chai-matchers-viem/src/internal/changeEtherBalances.ts new file mode 100644 index 0000000000..4bbc58e8ea --- /dev/null +++ b/packages/hardhat-chai-matchers-viem/src/internal/changeEtherBalances.ts @@ -0,0 +1,175 @@ +import type EthersT from "ethers"; +import type { Addressable, BigNumberish, TransactionResponse } from "ethers"; +import type { BalanceChangeOptions } from "./misc/balance"; +import type OrdinalT from "ordinal"; + +import { buildAssert } from "../utils"; +import { getAddressOf } from "./misc/account"; +import { getAddresses, getBalances } from "./misc/balance"; +import { CHANGE_ETHER_BALANCES_MATCHER } from "./constants"; +import { assertIsNotNull, preventAsyncMatcherChaining } from "./utils"; + +export function supportChangeEtherBalances( + Assertion: Chai.AssertionStatic, + chaiUtils: Chai.ChaiUtils +) { + Assertion.addMethod( + CHANGE_ETHER_BALANCES_MATCHER, + function ( + this: any, + accounts: Array, + balanceChanges: BigNumberish[] | ((changes: bigint[]) => boolean), + options?: BalanceChangeOptions + ) { + const { toBigInt } = require("ethers") as typeof EthersT; + const ordinal = require("ordinal") as typeof OrdinalT; + // capture negated flag before async code executes; see buildAssert's jsdoc + const negated = this.__flags.negate; + + let subject = this._obj; + if (typeof subject === "function") { + subject = subject(); + } + + preventAsyncMatcherChaining( + this, + CHANGE_ETHER_BALANCES_MATCHER, + chaiUtils + ); + + validateInput(this._obj, accounts, balanceChanges); + + const checkBalanceChanges = ([actualChanges, accountAddresses]: [ + bigint[], + string[] + ]) => { + const assert = buildAssert(negated, checkBalanceChanges); + + if (typeof balanceChanges === "function") { + assert( + balanceChanges(actualChanges), + "Expected the balance changes of the accounts to satisfy the predicate, but they didn't", + "Expected the balance changes of the accounts to NOT satisfy the predicate, but they did" + ); + } else { + assert( + actualChanges.every( + (change, ind) => change === toBigInt(balanceChanges[ind]) + ), + () => { + const lines: string[] = []; + actualChanges.forEach((change: bigint, i) => { + if (change !== toBigInt(balanceChanges[i])) { + lines.push( + `Expected the ether balance of ${ + accountAddresses[i] + } (the ${ordinal( + i + 1 + )} address in the list) to change by ${balanceChanges[ + i + ].toString()} wei, but it changed by ${change.toString()} wei` + ); + } + }); + return lines.join("\n"); + }, + () => { + const lines: string[] = []; + actualChanges.forEach((change: bigint, i) => { + if (change === toBigInt(balanceChanges[i])) { + lines.push( + `Expected the ether balance of ${ + accountAddresses[i] + } (the ${ordinal( + i + 1 + )} address in the list) NOT to change by ${balanceChanges[ + i + ].toString()} wei, but it did` + ); + } + }); + return lines.join("\n"); + } + ); + } + }; + + const derivedPromise = Promise.all([ + getBalanceChanges(subject, accounts, options), + getAddresses(accounts), + ]).then(checkBalanceChanges); + this.then = derivedPromise.then.bind(derivedPromise); + this.catch = derivedPromise.catch.bind(derivedPromise); + this.promise = derivedPromise; + return this; + } + ); +} + +function validateInput( + obj: any, + accounts: Array, + balanceChanges: EthersT.BigNumberish[] | ((changes: bigint[]) => boolean) +) { + try { + if ( + Array.isArray(balanceChanges) && + accounts.length !== balanceChanges.length + ) { + throw new Error( + `The number of accounts (${accounts.length}) is different than the number of expected balance changes (${balanceChanges.length})` + ); + } + } catch (e) { + // if the input validation fails, we discard the subject since it could + // potentially be a rejected promise + Promise.resolve(obj).catch(() => {}); + throw e; + } +} + +export async function getBalanceChanges( + transaction: TransactionResponse | Promise, + accounts: Array, + options?: BalanceChangeOptions +): Promise { + const txResponse = await transaction; + + const txReceipt = await txResponse.wait(); + assertIsNotNull(txReceipt, "txReceipt"); + const txBlockNumber = txReceipt.blockNumber; + + const balancesAfter = await getBalances(accounts, txBlockNumber); + const balancesBefore = await getBalances(accounts, txBlockNumber - 1); + + const txFees = await getTxFees(accounts, txResponse, options); + + return balancesAfter.map( + (balance, ind) => balance + txFees[ind] - balancesBefore[ind] + ); +} + +async function getTxFees( + accounts: Array, + txResponse: TransactionResponse, + options?: BalanceChangeOptions +): Promise { + return Promise.all( + accounts.map(async (account) => { + if ( + options?.includeFee !== true && + (await getAddressOf(account)) === txResponse.from + ) { + const txReceipt = await txResponse.wait(); + assertIsNotNull(txReceipt, "txReceipt"); + const gasPrice = txReceipt.gasPrice ?? txResponse.gasPrice; + const gasUsed = txReceipt.gasUsed; + const txFee = gasPrice * gasUsed; + + return txFee; + } + + return 0n; + }) + ); +} diff --git a/packages/hardhat-chai-matchers-viem/src/internal/changeTokenBalance.ts b/packages/hardhat-chai-matchers-viem/src/internal/changeTokenBalance.ts new file mode 100644 index 0000000000..04bc60603f --- /dev/null +++ b/packages/hardhat-chai-matchers-viem/src/internal/changeTokenBalance.ts @@ -0,0 +1,275 @@ +import type EthersT from "ethers"; +import type { + Addressable, + BaseContract, + BaseContractMethod, + BigNumberish, + ContractTransactionResponse, +} from "ethers"; + +import { buildAssert } from "../utils"; +import { ensure } from "./calledOnContract/utils"; +import { getAddressOf } from "./misc/account"; +import { + CHANGE_TOKEN_BALANCES_MATCHER, + CHANGE_TOKEN_BALANCE_MATCHER, +} from "./constants"; +import { assertIsNotNull, preventAsyncMatcherChaining } from "./utils"; + +type TransactionResponse = EthersT.TransactionResponse; + +export type Token = BaseContract & { + balanceOf: BaseContractMethod<[string], bigint, bigint>; + name: BaseContractMethod<[], string, string>; + transfer: BaseContractMethod< + [string, BigNumberish], + boolean, + ContractTransactionResponse + >; + symbol: BaseContractMethod<[], string, string>; +}; + +export function supportChangeTokenBalance( + Assertion: Chai.AssertionStatic, + chaiUtils: Chai.ChaiUtils +) { + Assertion.addMethod( + CHANGE_TOKEN_BALANCE_MATCHER, + function ( + this: any, + token: Token, + account: Addressable | string, + balanceChange: EthersT.BigNumberish | ((change: bigint) => boolean) + ) { + const ethers = require("ethers") as typeof EthersT; + + // capture negated flag before async code executes; see buildAssert's jsdoc + const negated = this.__flags.negate; + + let subject = this._obj; + if (typeof subject === "function") { + subject = subject(); + } + + preventAsyncMatcherChaining( + this, + CHANGE_TOKEN_BALANCE_MATCHER, + chaiUtils + ); + + checkToken(token, CHANGE_TOKEN_BALANCE_MATCHER); + + const checkBalanceChange = ([actualChange, address, tokenDescription]: [ + bigint, + string, + string + ]) => { + const assert = buildAssert(negated, checkBalanceChange); + + if (typeof balanceChange === "function") { + assert( + balanceChange(actualChange), + `Expected the balance of ${tokenDescription} tokens for "${address}" to satisfy the predicate, but it didn't (token balance change: ${actualChange.toString()} wei)`, + `Expected the balance of ${tokenDescription} tokens for "${address}" to NOT satisfy the predicate, but it did (token balance change: ${actualChange.toString()} wei)` + ); + } else { + assert( + actualChange === ethers.toBigInt(balanceChange), + `Expected the balance of ${tokenDescription} tokens for "${address}" to change by ${balanceChange.toString()}, but it changed by ${actualChange.toString()}`, + `Expected the balance of ${tokenDescription} tokens for "${address}" NOT to change by ${balanceChange.toString()}, but it did` + ); + } + }; + + const derivedPromise = Promise.all([ + getBalanceChange(subject, token, account), + getAddressOf(account), + getTokenDescription(token), + ]).then(checkBalanceChange); + + this.then = derivedPromise.then.bind(derivedPromise); + this.catch = derivedPromise.catch.bind(derivedPromise); + + return this; + } + ); + + Assertion.addMethod( + CHANGE_TOKEN_BALANCES_MATCHER, + function ( + this: any, + token: Token, + accounts: Array, + balanceChanges: EthersT.BigNumberish[] | ((changes: bigint[]) => boolean) + ) { + const ethers = require("ethers") as typeof EthersT; + + // capture negated flag before async code executes; see buildAssert's jsdoc + const negated = this.__flags.negate; + + let subject = this._obj; + if (typeof subject === "function") { + subject = subject(); + } + + preventAsyncMatcherChaining( + this, + CHANGE_TOKEN_BALANCES_MATCHER, + chaiUtils + ); + + validateInput(this._obj, token, accounts, balanceChanges); + + const balanceChangesPromise = Promise.all( + accounts.map((account) => getBalanceChange(subject, token, account)) + ); + const addressesPromise = Promise.all(accounts.map(getAddressOf)); + + const checkBalanceChanges = ([ + actualChanges, + addresses, + tokenDescription, + ]: [bigint[], string[], string]) => { + const assert = buildAssert(negated, checkBalanceChanges); + + if (typeof balanceChanges === "function") { + assert( + balanceChanges(actualChanges), + `Expected the balance changes of ${tokenDescription} to satisfy the predicate, but they didn't`, + `Expected the balance changes of ${tokenDescription} to NOT satisfy the predicate, but they did` + ); + } else { + assert( + actualChanges.every( + (change, ind) => change === ethers.toBigInt(balanceChanges[ind]) + ), + `Expected the balances of ${tokenDescription} tokens for ${ + addresses as any + } to change by ${ + balanceChanges as any + }, respectively, but they changed by ${actualChanges as any}`, + `Expected the balances of ${tokenDescription} tokens for ${ + addresses as any + } NOT to change by ${ + balanceChanges as any + }, respectively, but they did` + ); + } + }; + + const derivedPromise = Promise.all([ + balanceChangesPromise, + addressesPromise, + getTokenDescription(token), + ]).then(checkBalanceChanges); + + this.then = derivedPromise.then.bind(derivedPromise); + this.catch = derivedPromise.catch.bind(derivedPromise); + + return this; + } + ); +} + +function validateInput( + obj: any, + token: Token, + accounts: Array, + balanceChanges: EthersT.BigNumberish[] | ((changes: bigint[]) => boolean) +) { + try { + checkToken(token, CHANGE_TOKEN_BALANCES_MATCHER); + + if ( + Array.isArray(balanceChanges) && + accounts.length !== balanceChanges.length + ) { + throw new Error( + `The number of accounts (${accounts.length}) is different than the number of expected balance changes (${balanceChanges.length})` + ); + } + } catch (e) { + // if the input validation fails, we discard the subject since it could + // potentially be a rejected promise + Promise.resolve(obj).catch(() => {}); + throw e; + } +} + +function checkToken(token: unknown, method: string) { + if (typeof token !== "object" || token === null || !("interface" in token)) { + throw new Error( + `The first argument of ${method} must be the contract instance of the token` + ); + } else if ((token as any).interface.getFunction("balanceOf") === null) { + throw new Error("The given contract instance is not an ERC20 token"); + } +} + +export async function getBalanceChange( + transaction: TransactionResponse | Promise, + token: Token, + account: Addressable | string +) { + const ethers = require("ethers") as typeof EthersT; + const hre = await import("hardhat"); + const provider = hre.network.provider; + + const txResponse = await transaction; + + const txReceipt = await txResponse.wait(); + assertIsNotNull(txReceipt, "txReceipt"); + const txBlockNumber = txReceipt.blockNumber; + + const block = await provider.send("eth_getBlockByHash", [ + txReceipt.blockHash, + false, + ]); + + ensure( + block.transactions.length === 1, + Error, + "Multiple transactions found in block" + ); + + const address = await getAddressOf(account); + + const balanceAfter = await token.balanceOf(address, { + blockTag: txBlockNumber, + }); + + const balanceBefore = await token.balanceOf(address, { + blockTag: txBlockNumber - 1, + }); + + return ethers.toBigInt(balanceAfter) - balanceBefore; +} + +let tokenDescriptionsCache: Record = {}; +/** + * Get a description for the given token. Use the symbol of the token if + * possible; if it doesn't exist, the name is used; if the name doesn't + * exist, the address of the token is used. + */ +async function getTokenDescription(token: Token): Promise { + const tokenAddress = await token.getAddress(); + if (tokenDescriptionsCache[tokenAddress] === undefined) { + let tokenDescription = ``; + try { + tokenDescription = await token.symbol(); + } catch (e) { + try { + tokenDescription = await token.name(); + } catch (e2) {} + } + + tokenDescriptionsCache[tokenAddress] = tokenDescription; + } + + return tokenDescriptionsCache[tokenAddress]; +} + +// only used by tests +export function clearTokenDescriptionsCache() { + tokenDescriptionsCache = {}; +} diff --git a/packages/hardhat-chai-matchers-viem/src/internal/constants.ts b/packages/hardhat-chai-matchers-viem/src/internal/constants.ts new file mode 100644 index 0000000000..481b77c834 --- /dev/null +++ b/packages/hardhat-chai-matchers-viem/src/internal/constants.ts @@ -0,0 +1,13 @@ +export const ASSERTION_ABORTED = "hh-chai-matchers-assertion-aborted"; +export const PREVIOUS_MATCHER_NAME = "previousMatcherName"; + +export const CHANGE_ETHER_BALANCE_MATCHER = "changeEtherBalance"; +export const CHANGE_ETHER_BALANCES_MATCHER = "changeEtherBalances"; +export const CHANGE_TOKEN_BALANCE_MATCHER = "changeTokenBalance"; +export const CHANGE_TOKEN_BALANCES_MATCHER = "changeTokenBalances"; +export const EMIT_MATCHER = "emit"; +export const REVERTED_MATCHER = "reverted"; +export const REVERTED_WITH_MATCHER = "revertedWith"; +export const REVERTED_WITH_CUSTOM_ERROR_MATCHER = "revertedWithCustomError"; +export const REVERTED_WITH_PANIC_MATCHER = "revertedWithPanic"; +export const REVERTED_WITHOUT_REASON_MATCHER = "revertedWithoutReason"; diff --git a/packages/hardhat-chai-matchers-viem/src/internal/emit.ts b/packages/hardhat-chai-matchers-viem/src/internal/emit.ts new file mode 100644 index 0000000000..5718861999 --- /dev/null +++ b/packages/hardhat-chai-matchers-viem/src/internal/emit.ts @@ -0,0 +1,221 @@ +import type EthersT from "ethers"; +import type { Contract, Interface, Transaction } from "ethers"; +import type { AssertWithSsfi, Ssfi } from "../utils"; + +import { AssertionError } from "chai"; +import util from "util"; + +import { buildAssert } from "../utils"; +import { ASSERTION_ABORTED, EMIT_MATCHER } from "./constants"; +import { HardhatChaiMatchersAssertionError } from "./errors"; +import { + assertArgsArraysEqual, + assertIsNotNull, + preventAsyncMatcherChaining, +} from "./utils"; + +type EventFragment = EthersT.EventFragment; +type Provider = EthersT.Provider; + +export const EMIT_CALLED = "emitAssertionCalled"; + +async function waitForPendingTransaction( + tx: Promise | Transaction | string, + provider: Provider +) { + let hash: string | null; + if (tx instanceof Promise) { + ({ hash } = await tx); + } else if (typeof tx === "string") { + hash = tx; + } else { + ({ hash } = tx); + } + if (hash === null) { + throw new Error(`${JSON.stringify(tx)} is not a valid transaction`); + } + return provider.getTransactionReceipt(hash); +} + +export function supportEmit( + Assertion: Chai.AssertionStatic, + chaiUtils: Chai.ChaiUtils +) { + Assertion.addMethod( + EMIT_MATCHER, + function ( + this: any, + contract: Contract, + eventName: string, + ...args: any[] + ) { + // capture negated flag before async code executes; see buildAssert's jsdoc + const negated = this.__flags.negate; + const tx = this._obj; + + preventAsyncMatcherChaining(this, EMIT_MATCHER, chaiUtils, true); + + const promise = this.then === undefined ? Promise.resolve() : this; + + const onSuccess = (receipt: EthersT.TransactionReceipt) => { + // abort if the assertion chain was aborted, for example because + // a `.not` was combined with a `.withArgs` + if (chaiUtils.flag(this, ASSERTION_ABORTED) === true) { + return; + } + + const assert = buildAssert(negated, onSuccess); + + let eventFragment: EventFragment | null = null; + try { + eventFragment = contract.interface.getEvent(eventName); + } catch (e) { + // ignore error + } + + if (eventFragment === null) { + throw new AssertionError( + `Event "${eventName}" doesn't exist in the contract` + ); + } + + const topic = eventFragment.topicHash; + const contractAddress = contract.target; + if (typeof contractAddress !== "string") { + throw new HardhatChaiMatchersAssertionError( + `The contract target should be a string` + ); + } + + if (args.length > 0) { + throw new Error( + "`.emit` expects only two arguments: the contract and the event name. Arguments should be asserted with the `.withArgs` helper." + ); + } + + this.logs = receipt.logs + .filter((log) => log.topics.includes(topic)) + .filter( + (log) => log.address.toLowerCase() === contractAddress.toLowerCase() + ); + + assert( + this.logs.length > 0, + `Expected event "${eventName}" to be emitted, but it wasn't`, + `Expected event "${eventName}" NOT to be emitted, but it was` + ); + chaiUtils.flag(this, "eventName", eventName); + chaiUtils.flag(this, "contract", contract); + }; + + const derivedPromise = promise.then(() => { + // abort if the assertion chain was aborted, for example because + // a `.not` was combined with a `.withArgs` + if (chaiUtils.flag(this, ASSERTION_ABORTED) === true) { + return; + } + + if (contract.runner === null || contract.runner.provider === null) { + throw new HardhatChaiMatchersAssertionError( + "contract.runner.provider shouldn't be null" + ); + } + + return waitForPendingTransaction(tx, contract.runner.provider).then( + (receipt) => { + assertIsNotNull(receipt, "receipt"); + return onSuccess(receipt); + } + ); + }); + + chaiUtils.flag(this, EMIT_CALLED, true); + + this.then = derivedPromise.then.bind(derivedPromise); + this.catch = derivedPromise.catch.bind(derivedPromise); + this.promise = derivedPromise; + return this; + } + ); +} + +export async function emitWithArgs( + context: any, + Assertion: Chai.AssertionStatic, + chaiUtils: Chai.ChaiUtils, + expectedArgs: any[], + ssfi: Ssfi +) { + const negated = false; // .withArgs cannot be negated + const assert = buildAssert(negated, ssfi); + + tryAssertArgsArraysEqual( + context, + Assertion, + chaiUtils, + expectedArgs, + context.logs, + assert, + ssfi + ); +} + +const tryAssertArgsArraysEqual = ( + context: any, + Assertion: Chai.AssertionStatic, + chaiUtils: Chai.ChaiUtils, + expectedArgs: any[], + logs: any[], + assert: AssertWithSsfi, + ssfi: Ssfi +) => { + const eventName = chaiUtils.flag(context, "eventName"); + if (logs.length === 1) { + const parsedLog = ( + chaiUtils.flag(context, "contract").interface as Interface + ).parseLog(logs[0]); + assertIsNotNull(parsedLog, "parsedLog"); + + return assertArgsArraysEqual( + Assertion, + expectedArgs, + parsedLog.args, + `"${eventName}" event`, + "event", + assert, + ssfi + ); + } + for (const index in logs) { + if (index === undefined) { + break; + } else { + try { + const parsedLog = ( + chaiUtils.flag(context, "contract").interface as Interface + ).parseLog(logs[index]); + assertIsNotNull(parsedLog, "parsedLog"); + + assertArgsArraysEqual( + Assertion, + expectedArgs, + parsedLog.args, + `"${eventName}" event`, + "event", + assert, + ssfi + ); + return; + } catch {} + } + } + + assert( + false, + `The specified arguments (${util.inspect( + expectedArgs + )}) were not included in any of the ${ + context.logs.length + } emitted "${eventName}" events` + ); +}; diff --git a/packages/hardhat-chai-matchers-viem/src/internal/errors.ts b/packages/hardhat-chai-matchers-viem/src/internal/errors.ts new file mode 100644 index 0000000000..c490c1d42a --- /dev/null +++ b/packages/hardhat-chai-matchers-viem/src/internal/errors.ts @@ -0,0 +1,33 @@ +import { NomicLabsHardhatPluginError } from "hardhat/plugins"; + +export class HardhatChaiMatchersError extends NomicLabsHardhatPluginError { + constructor(message: string, parent?: Error) { + super("@nomicfoundation/hardhat-chai-matchers", message, parent); + } +} + +export class HardhatChaiMatchersDecodingError extends HardhatChaiMatchersError { + constructor(encodedData: string, type: string, parent: Error) { + const message = `There was an error decoding '${encodedData}' as a ${type}`; + + super(message, parent); + } +} + +/** + * This class is used to assert assumptions in our implementation. Chai's + * AssertionError should be used for user assertions. + */ +export class HardhatChaiMatchersAssertionError extends HardhatChaiMatchersError { + constructor(message: string) { + super(`Assertion error: ${message}`); + } +} + +export class HardhatChaiMatchersNonChainableMatcherError extends HardhatChaiMatchersError { + constructor(matcherName: string, previousMatcherName: string) { + super( + `The matcher '${matcherName}' cannot be chained after '${previousMatcherName}'. For more information, please refer to the documentation at: https://hardhat.org/chaining-async-matchers.` + ); + } +} diff --git a/packages/hardhat-chai-matchers-viem/src/internal/hardhatChaiMatchers.ts b/packages/hardhat-chai-matchers-viem/src/internal/hardhatChaiMatchers.ts new file mode 100644 index 0000000000..90c0c8e1a6 --- /dev/null +++ b/packages/hardhat-chai-matchers-viem/src/internal/hardhatChaiMatchers.ts @@ -0,0 +1,38 @@ +import { supportAddressable } from "./addressable"; +import { supportBigNumber } from "./bigNumber"; +import { supportEmit } from "./emit"; +import { supportHexEqual } from "./hexEqual"; +import { supportProperAddress } from "./properAddress"; +import { supportProperHex } from "./properHex"; +import { supportProperPrivateKey } from "./properPrivateKey"; +import { supportChangeEtherBalance } from "./changeEtherBalance"; +import { supportChangeEtherBalances } from "./changeEtherBalances"; +import { supportChangeTokenBalance } from "./changeTokenBalance"; +import { supportReverted } from "./reverted/reverted"; +import { supportRevertedWith } from "./reverted/revertedWith"; +import { supportRevertedWithCustomError } from "./reverted/revertedWithCustomError"; +import { supportRevertedWithPanic } from "./reverted/revertedWithPanic"; +import { supportRevertedWithoutReason } from "./reverted/revertedWithoutReason"; +import { supportWithArgs } from "./withArgs"; + +export function hardhatChaiMatchers( + chai: Chai.ChaiStatic, + chaiUtils: Chai.ChaiUtils +) { + supportAddressable(chai.Assertion, chaiUtils); + supportBigNumber(chai.Assertion, chaiUtils); + supportEmit(chai.Assertion, chaiUtils); + supportHexEqual(chai.Assertion); + supportProperAddress(chai.Assertion); + supportProperHex(chai.Assertion); + supportProperPrivateKey(chai.Assertion); + supportChangeEtherBalance(chai.Assertion, chaiUtils); + supportChangeEtherBalances(chai.Assertion, chaiUtils); + supportChangeTokenBalance(chai.Assertion, chaiUtils); + supportReverted(chai.Assertion, chaiUtils); + supportRevertedWith(chai.Assertion, chaiUtils); + supportRevertedWithCustomError(chai.Assertion, chaiUtils); + supportRevertedWithPanic(chai.Assertion, chaiUtils); + supportRevertedWithoutReason(chai.Assertion, chaiUtils); + supportWithArgs(chai.Assertion, chaiUtils); +} diff --git a/packages/hardhat-chai-matchers-viem/src/internal/hardhatWaffleIncompatibilityCheck.ts b/packages/hardhat-chai-matchers-viem/src/internal/hardhatWaffleIncompatibilityCheck.ts new file mode 100644 index 0000000000..2f2638fb9d --- /dev/null +++ b/packages/hardhat-chai-matchers-viem/src/internal/hardhatWaffleIncompatibilityCheck.ts @@ -0,0 +1,11 @@ +export function hardhatWaffleIncompatibilityCheck() { + if ((global as any).__HARDHAT_WAFFLE_IS_LOADED === true) { + throw new Error( + `You are using both @nomicfoundation/hardhat-chai-matchers and @nomiclabs/hardhat-waffle. They don't work correctly together, so please make sure you only use one. + +We recommend you migrate to @nomicfoundation/hardhat-chai-matchers. Learn how to do it here: https://hardhat.org/migrate-from-waffle` + ); + } + + (global as any).__HARDHAT_CHAI_MATCHERS_IS_LOADED = true; +} diff --git a/packages/hardhat-chai-matchers-viem/src/internal/hexEqual.ts b/packages/hardhat-chai-matchers-viem/src/internal/hexEqual.ts new file mode 100644 index 0000000000..5e67433cfc --- /dev/null +++ b/packages/hardhat-chai-matchers-viem/src/internal/hexEqual.ts @@ -0,0 +1,29 @@ +export function supportHexEqual(Assertion: Chai.AssertionStatic) { + Assertion.addMethod("hexEqual", function (this: any, other: string) { + const subject = this._obj; + const isNegated = this.__flags.negate === true; + + // check that both values are proper hex strings + const isHex = (a: string) => /^0x[0-9a-fA-F]*$/.test(a); + for (const element of [subject, other]) { + if (!isHex(element)) { + this.assert( + isNegated, // trick to make this assertion always fail + `Expected "${subject}" to be a hex string equal to "${other}", but "${element}" is not a valid hex string`, + `Expected "${subject}" not to be a hex string equal to "${other}", but "${element}" is not a valid hex string` + ); + } + } + + // compare values + const extractNumeric = (hex: string) => hex.replace(/^0x0*/, ""); + this.assert( + extractNumeric(subject.toLowerCase()) === + extractNumeric(other.toLowerCase()), + `Expected "${subject}" to be a hex string equal to "${other}"`, + `Expected "${subject}" NOT to be a hex string equal to "${other}", but it was`, + `Hex string representing the same number as ${other}`, + subject + ); + }); +} diff --git a/packages/hardhat-chai-matchers-viem/src/internal/misc/account.ts b/packages/hardhat-chai-matchers-viem/src/internal/misc/account.ts new file mode 100644 index 0000000000..c4d7e536ce --- /dev/null +++ b/packages/hardhat-chai-matchers-viem/src/internal/misc/account.ts @@ -0,0 +1,24 @@ +import type { Addressable } from "ethers"; + +import assert from "assert"; + +import { HardhatChaiMatchersAssertionError } from "../errors"; + +export async function getAddressOf( + account: Addressable | string +): Promise { + const { isAddressable } = await import("ethers"); + + if (typeof account === "string") { + assert(/^0x[0-9a-fA-F]{40}$/.test(account), `Invalid address ${account}`); + return account; + } + + if (isAddressable(account)) { + return account.getAddress(); + } + + throw new HardhatChaiMatchersAssertionError( + `Expected string or addressable, got ${account as any}` + ); +} diff --git a/packages/hardhat-chai-matchers-viem/src/internal/misc/balance.ts b/packages/hardhat-chai-matchers-viem/src/internal/misc/balance.ts new file mode 100644 index 0000000000..9bd93f6827 --- /dev/null +++ b/packages/hardhat-chai-matchers-viem/src/internal/misc/balance.ts @@ -0,0 +1,31 @@ +import type { Addressable } from "ethers"; + +import { getAddressOf } from "./account"; + +export interface BalanceChangeOptions { + includeFee?: boolean; +} + +export function getAddresses(accounts: Array) { + return Promise.all(accounts.map((account) => getAddressOf(account))); +} + +export async function getBalances( + accounts: Array, + blockNumber?: number +): Promise { + const { toBigInt } = await import("ethers"); + const hre = await import("hardhat"); + const provider = hre.ethers.provider; + + return Promise.all( + accounts.map(async (account) => { + const address = await getAddressOf(account); + const result = await provider.send("eth_getBalance", [ + address, + `0x${blockNumber?.toString(16) ?? 0}`, + ]); + return toBigInt(result); + }) + ); +} diff --git a/packages/hardhat-chai-matchers-viem/src/internal/properAddress.ts b/packages/hardhat-chai-matchers-viem/src/internal/properAddress.ts new file mode 100644 index 0000000000..8d42e917b5 --- /dev/null +++ b/packages/hardhat-chai-matchers-viem/src/internal/properAddress.ts @@ -0,0 +1,12 @@ +export function supportProperAddress(Assertion: Chai.AssertionStatic) { + Assertion.addProperty("properAddress", function (this: any) { + const subject = this._obj; + this.assert( + /^0x[0-9a-fA-F]{40}$/.test(subject), + `Expected "${subject}" to be a proper address`, + `Expected "${subject}" NOT to be a proper address`, + "proper address (eg.: 0x1234567890123456789012345678901234567890)", + subject + ); + }); +} diff --git a/packages/hardhat-chai-matchers-viem/src/internal/properHex.ts b/packages/hardhat-chai-matchers-viem/src/internal/properHex.ts new file mode 100644 index 0000000000..8f90c77795 --- /dev/null +++ b/packages/hardhat-chai-matchers-viem/src/internal/properHex.ts @@ -0,0 +1,29 @@ +export function supportProperHex(Assertion: Chai.AssertionStatic) { + Assertion.addMethod("properHex", function (this: any, length: number) { + const subject = this._obj; + const isNegated = this.__flags.negate === true; + + const isHex = (a: string) => /^0x[0-9a-fA-F]*$/.test(a); + if (!isHex(subject)) { + this.assert( + isNegated, // trick to make this assertion always fail + `Expected "${subject}" to be a proper hex string, but it contains invalid (non-hex) characters`, + `Expected "${subject}" NOT to be a proper hex string, but it contains only valid hex characters` + ); + } + + this.assert( + subject.length === length + 2, + `Expected "${subject}" to be a hex string of length ${ + length + 2 + } (the provided ${length} plus 2 more for the "0x" prefix), but its length is ${ + subject.length + }`, + `Expected "${subject}" NOT to be a hex string of length ${ + length + 2 + } (the provided ${length} plus 2 more for the "0x" prefix), but its length is ${ + subject.length + }` + ); + }); +} diff --git a/packages/hardhat-chai-matchers-viem/src/internal/properPrivateKey.ts b/packages/hardhat-chai-matchers-viem/src/internal/properPrivateKey.ts new file mode 100644 index 0000000000..0d9fa2d8b3 --- /dev/null +++ b/packages/hardhat-chai-matchers-viem/src/internal/properPrivateKey.ts @@ -0,0 +1,12 @@ +export function supportProperPrivateKey(Assertion: Chai.AssertionStatic) { + Assertion.addProperty("properPrivateKey", function (this: any) { + const subject = this._obj; + this.assert( + /^0x[0-9a-fA-F]{64}$/.test(subject), + `Expected "${subject}" to be a proper private key`, + `Expected "${subject}" NOT to be a proper private key`, + "proper private key (eg.: 0x1010101010101010101010101010101010101010101010101010101010101010)", + subject + ); + }); +} diff --git a/packages/hardhat-chai-matchers-viem/src/internal/reverted/panic.ts b/packages/hardhat-chai-matchers-viem/src/internal/reverted/panic.ts new file mode 100644 index 0000000000..126f36ef4d --- /dev/null +++ b/packages/hardhat-chai-matchers-viem/src/internal/reverted/panic.ts @@ -0,0 +1,35 @@ +export const PANIC_CODES = { + ASSERTION_ERROR: 0x1, + ARITHMETIC_OVERFLOW: 0x11, + DIVISION_BY_ZERO: 0x12, + ENUM_CONVERSION_OUT_OF_BOUNDS: 0x21, + INCORRECTLY_ENCODED_STORAGE_BYTE_ARRAY: 0x22, + POP_ON_EMPTY_ARRAY: 0x31, + ARRAY_ACCESS_OUT_OF_BOUNDS: 0x32, + TOO_MUCH_MEMORY_ALLOCATED: 0x41, + ZERO_INITIALIZED_VARIABLE: 0x51, +}; + +// copied from hardhat-core +export function panicErrorCodeToReason(errorCode: bigint): string | undefined { + switch (errorCode) { + case 0x1n: + return "Assertion error"; + case 0x11n: + return "Arithmetic operation overflowed outside of an unchecked block"; + case 0x12n: + return "Division or modulo division by zero"; + case 0x21n: + return "Tried to convert a value into an enum, but the value was too big or negative"; + case 0x22n: + return "Incorrectly encoded storage byte array"; + case 0x31n: + return ".pop() was called on an empty array"; + case 0x32n: + return "Array accessed at an out-of-bounds or negative index"; + case 0x41n: + return "Too much memory was allocated, or an array was created that is too large"; + case 0x51n: + return "Called a zero-initialized variable of internal function type"; + } +} diff --git a/packages/hardhat-chai-matchers-viem/src/internal/reverted/reverted.ts b/packages/hardhat-chai-matchers-viem/src/internal/reverted/reverted.ts new file mode 100644 index 0000000000..77a3c74ea7 --- /dev/null +++ b/packages/hardhat-chai-matchers-viem/src/internal/reverted/reverted.ts @@ -0,0 +1,136 @@ +import type EthersT from "ethers"; + +import { buildAssert } from "../../utils"; +import { REVERTED_MATCHER } from "../constants"; +import { assertIsNotNull, preventAsyncMatcherChaining } from "../utils"; +import { decodeReturnData, getReturnDataFromError } from "./utils"; + +export function supportReverted( + Assertion: Chai.AssertionStatic, + chaiUtils: Chai.ChaiUtils +) { + Assertion.addProperty(REVERTED_MATCHER, function (this: any) { + // capture negated flag before async code executes; see buildAssert's jsdoc + const negated = this.__flags.negate; + + const subject: unknown = this._obj; + + preventAsyncMatcherChaining(this, REVERTED_MATCHER, chaiUtils); + + // Check if the received value can be linked to a transaction, and then + // get the receipt of that transaction and check its status. + // + // If the value doesn't correspond to a transaction, then the `reverted` + // assertion is false. + const onSuccess = async (value: unknown) => { + const assert = buildAssert(negated, onSuccess); + + if (isTransactionResponse(value) || typeof value === "string") { + const hash = typeof value === "string" ? value : value.hash; + + if (!isValidTransactionHash(hash)) { + throw new TypeError( + `Expected a valid transaction hash, but got '${hash}'` + ); + } + + const receipt = await getTransactionReceipt(hash); + + assertIsNotNull(receipt, "receipt"); + assert( + receipt.status === 0, + "Expected transaction to be reverted", + "Expected transaction NOT to be reverted" + ); + } else if (isTransactionReceipt(value)) { + const receipt = value; + + assert( + receipt.status === 0, + "Expected transaction to be reverted", + "Expected transaction NOT to be reverted" + ); + } else { + // If the subject of the assertion is not connected to a transaction + // (hash, receipt, etc.), then the assertion fails. + // Since we use `false` here, this means that `.not.to.be.reverted` + // assertions will pass instead of always throwing a validation error. + // This allows users to do things like: + // `expect(c.callStatic.f()).to.not.be.reverted` + assert(false, "Expected transaction to be reverted"); + } + }; + + const onError = (error: any) => { + const { toBeHex } = require("ethers") as typeof EthersT; + const assert = buildAssert(negated, onError); + const returnData = getReturnDataFromError(error); + const decodedReturnData = decodeReturnData(returnData); + + if ( + decodedReturnData.kind === "Empty" || + decodedReturnData.kind === "Custom" + ) { + // in the negated case, if we can't decode the reason, we just indicate + // that the transaction didn't revert + assert(true, undefined, `Expected transaction NOT to be reverted`); + } else if (decodedReturnData.kind === "Error") { + assert( + true, + undefined, + `Expected transaction NOT to be reverted, but it reverted with reason '${decodedReturnData.reason}'` + ); + } else if (decodedReturnData.kind === "Panic") { + assert( + true, + undefined, + `Expected transaction NOT to be reverted, but it reverted with panic code ${toBeHex( + decodedReturnData.code + )} (${decodedReturnData.description})` + ); + } else { + const _exhaustiveCheck: never = decodedReturnData; + } + }; + + // we use `Promise.resolve(subject)` so we can process both values and + // promises of values in the same way + const derivedPromise = Promise.resolve(subject).then(onSuccess, onError); + + this.then = derivedPromise.then.bind(derivedPromise); + this.catch = derivedPromise.catch.bind(derivedPromise); + + return this; + }); +} + +async function getTransactionReceipt(hash: string) { + const hre = await import("hardhat"); + + return hre.ethers.provider.getTransactionReceipt(hash); +} + +function isTransactionResponse(x: unknown): x is { hash: string } { + if (typeof x === "object" && x !== null) { + return "hash" in x; + } + + return false; +} + +function isTransactionReceipt(x: unknown): x is { status: number } { + if (typeof x === "object" && x !== null && "status" in x) { + const status = (x as any).status; + + // this means we only support ethers's receipts for now; adding support for + // raw receipts, where the status is an hexadecimal string, should be easy + // and we can do it if there's demand for that + return typeof status === "number"; + } + + return false; +} + +function isValidTransactionHash(x: string): boolean { + return /0x[0-9a-fA-F]{64}/.test(x); +} diff --git a/packages/hardhat-chai-matchers-viem/src/internal/reverted/revertedWith.ts b/packages/hardhat-chai-matchers-viem/src/internal/reverted/revertedWith.ts new file mode 100644 index 0000000000..442f24d6b0 --- /dev/null +++ b/packages/hardhat-chai-matchers-viem/src/internal/reverted/revertedWith.ts @@ -0,0 +1,98 @@ +import type EthersT from "ethers"; + +import { buildAssert } from "../../utils"; +import { REVERTED_WITH_MATCHER } from "../constants"; +import { preventAsyncMatcherChaining } from "../utils"; +import { decodeReturnData, getReturnDataFromError } from "./utils"; + +export function supportRevertedWith( + Assertion: Chai.AssertionStatic, + chaiUtils: Chai.ChaiUtils +) { + Assertion.addMethod( + REVERTED_WITH_MATCHER, + function (this: any, expectedReason: string | RegExp) { + // capture negated flag before async code executes; see buildAssert's jsdoc + const negated = this.__flags.negate; + + // validate expected reason + if ( + !(expectedReason instanceof RegExp) && + typeof expectedReason !== "string" + ) { + // if the input validation fails, we discard the subject since it could + // potentially be a rejected promise + Promise.resolve(this._obj).catch(() => {}); + throw new TypeError( + "Expected the revert reason to be a string or a regular expression" + ); + } + + const expectedReasonString = + expectedReason instanceof RegExp + ? expectedReason.source + : expectedReason; + + preventAsyncMatcherChaining(this, REVERTED_WITH_MATCHER, chaiUtils); + + const onSuccess = () => { + const assert = buildAssert(negated, onSuccess); + + assert( + false, + `Expected transaction to be reverted with reason '${expectedReasonString}', but it didn't revert` + ); + }; + + const onError = (error: any) => { + const { toBeHex } = require("ethers") as typeof EthersT; + const assert = buildAssert(negated, onError); + + const returnData = getReturnDataFromError(error); + const decodedReturnData = decodeReturnData(returnData); + + if (decodedReturnData.kind === "Empty") { + assert( + false, + `Expected transaction to be reverted with reason '${expectedReasonString}', but it reverted without a reason` + ); + } else if (decodedReturnData.kind === "Error") { + const matchesExpectedReason = + expectedReason instanceof RegExp + ? expectedReason.test(decodedReturnData.reason) + : decodedReturnData.reason === expectedReasonString; + + assert( + matchesExpectedReason, + `Expected transaction to be reverted with reason '${expectedReasonString}', but it reverted with reason '${decodedReturnData.reason}'`, + `Expected transaction NOT to be reverted with reason '${expectedReasonString}', but it was` + ); + } else if (decodedReturnData.kind === "Panic") { + assert( + false, + `Expected transaction to be reverted with reason '${expectedReasonString}', but it reverted with panic code ${toBeHex( + decodedReturnData.code + )} (${decodedReturnData.description})` + ); + } else if (decodedReturnData.kind === "Custom") { + assert( + false, + `Expected transaction to be reverted with reason '${expectedReasonString}', but it reverted with a custom error` + ); + } else { + const _exhaustiveCheck: never = decodedReturnData; + } + }; + + const derivedPromise = Promise.resolve(this._obj).then( + onSuccess, + onError + ); + + this.then = derivedPromise.then.bind(derivedPromise); + this.catch = derivedPromise.catch.bind(derivedPromise); + + return this; + } + ); +} diff --git a/packages/hardhat-chai-matchers-viem/src/internal/reverted/revertedWithCustomError.ts b/packages/hardhat-chai-matchers-viem/src/internal/reverted/revertedWithCustomError.ts new file mode 100644 index 0000000000..94dc79552c --- /dev/null +++ b/packages/hardhat-chai-matchers-viem/src/internal/reverted/revertedWithCustomError.ts @@ -0,0 +1,235 @@ +import type EthersT from "ethers"; + +import { + ASSERTION_ABORTED, + REVERTED_WITH_CUSTOM_ERROR_MATCHER, +} from "../constants"; +import { + assertArgsArraysEqual, + assertIsNotNull, + preventAsyncMatcherChaining, +} from "../utils"; +import { buildAssert, Ssfi } from "../../utils"; +import { + decodeReturnData, + getReturnDataFromError, + resultToArray, +} from "./utils"; + +export const REVERTED_WITH_CUSTOM_ERROR_CALLED = "customErrorAssertionCalled"; + +interface CustomErrorAssertionData { + contractInterface: EthersT.Interface; + returnData: string; + customError: EthersT.ErrorFragment; +} + +export function supportRevertedWithCustomError( + Assertion: Chai.AssertionStatic, + chaiUtils: Chai.ChaiUtils +) { + Assertion.addMethod( + REVERTED_WITH_CUSTOM_ERROR_MATCHER, + function ( + this: any, + contract: EthersT.BaseContract, + expectedCustomErrorName: string, + ...args: any[] + ) { + // capture negated flag before async code executes; see buildAssert's jsdoc + const negated = this.__flags.negate; + + const { iface, expectedCustomError } = validateInput( + this._obj, + contract, + expectedCustomErrorName, + args + ); + + preventAsyncMatcherChaining( + this, + REVERTED_WITH_CUSTOM_ERROR_MATCHER, + chaiUtils + ); + + const onSuccess = () => { + if (chaiUtils.flag(this, ASSERTION_ABORTED) === true) { + return; + } + + const assert = buildAssert(negated, onSuccess); + + assert( + false, + `Expected transaction to be reverted with custom error '${expectedCustomErrorName}', but it didn't revert` + ); + }; + + const onError = (error: any) => { + if (chaiUtils.flag(this, ASSERTION_ABORTED) === true) { + return; + } + + const { toBeHex } = require("ethers") as typeof EthersT; + + const assert = buildAssert(negated, onError); + + const returnData = getReturnDataFromError(error); + const decodedReturnData = decodeReturnData(returnData); + + if (decodedReturnData.kind === "Empty") { + assert( + false, + `Expected transaction to be reverted with custom error '${expectedCustomErrorName}', but it reverted without a reason` + ); + } else if (decodedReturnData.kind === "Error") { + assert( + false, + `Expected transaction to be reverted with custom error '${expectedCustomErrorName}', but it reverted with reason '${decodedReturnData.reason}'` + ); + } else if (decodedReturnData.kind === "Panic") { + assert( + false, + `Expected transaction to be reverted with custom error '${expectedCustomErrorName}', but it reverted with panic code ${toBeHex( + decodedReturnData.code + )} (${decodedReturnData.description})` + ); + } else if (decodedReturnData.kind === "Custom") { + if (decodedReturnData.id === expectedCustomError.selector) { + // add flag with the data needed for .withArgs + const customErrorAssertionData: CustomErrorAssertionData = { + contractInterface: iface, + customError: expectedCustomError, + returnData, + }; + this.customErrorData = customErrorAssertionData; + + assert( + true, + undefined, + `Expected transaction NOT to be reverted with custom error '${expectedCustomErrorName}', but it was` + ); + } else { + // try to decode the actual custom error + // this will only work when the error comes from the given contract + const actualCustomError = iface.getError(decodedReturnData.id); + + if (actualCustomError === null) { + assert( + false, + `Expected transaction to be reverted with custom error '${expectedCustomErrorName}', but it reverted with a different custom error` + ); + } else { + assert( + false, + `Expected transaction to be reverted with custom error '${expectedCustomErrorName}', but it reverted with custom error '${actualCustomError.name}'` + ); + } + } + } else { + const _exhaustiveCheck: never = decodedReturnData; + } + }; + + const derivedPromise = Promise.resolve(this._obj).then( + onSuccess, + onError + ); + + // needed for .withArgs + chaiUtils.flag(this, REVERTED_WITH_CUSTOM_ERROR_CALLED, true); + this.promise = derivedPromise; + + this.then = derivedPromise.then.bind(derivedPromise); + this.catch = derivedPromise.catch.bind(derivedPromise); + + return this; + } + ); +} + +function validateInput( + obj: any, + contract: EthersT.BaseContract, + expectedCustomErrorName: string, + args: any[] +): { iface: EthersT.Interface; expectedCustomError: EthersT.ErrorFragment } { + try { + // check the case where users forget to pass the contract as the first + // argument + if (typeof contract === "string" || contract?.interface === undefined) { + // discard subject since it could potentially be a rejected promise + throw new TypeError( + "The first argument of .revertedWithCustomError must be the contract that defines the custom error" + ); + } + + // validate custom error name + if (typeof expectedCustomErrorName !== "string") { + throw new TypeError("Expected the custom error name to be a string"); + } + + const iface = contract.interface; + const expectedCustomError = iface.getError(expectedCustomErrorName); + + // check that interface contains the given custom error + if (expectedCustomError === null) { + throw new Error( + `The given contract doesn't have a custom error named '${expectedCustomErrorName}'` + ); + } + + if (args.length > 0) { + throw new Error( + "`.revertedWithCustomError` expects only two arguments: the contract and the error name. Arguments should be asserted with the `.withArgs` helper." + ); + } + + return { iface, expectedCustomError }; + } catch (e) { + // if the input validation fails, we discard the subject since it could + // potentially be a rejected promise + Promise.resolve(obj).catch(() => {}); + throw e; + } +} + +export async function revertedWithCustomErrorWithArgs( + context: any, + Assertion: Chai.AssertionStatic, + chaiUtils: Chai.ChaiUtils, + expectedArgs: any[], + ssfi: Ssfi +) { + const negated = false; // .withArgs cannot be negated + const assert = buildAssert(negated, ssfi); + + const customErrorAssertionData: CustomErrorAssertionData = + context.customErrorData; + + if (customErrorAssertionData === undefined) { + throw new Error( + "[.withArgs] should never happen, please submit an issue to the Hardhat repository" + ); + } + + const { contractInterface, customError, returnData } = + customErrorAssertionData; + + const errorFragment = contractInterface.getError(customError.name); + assertIsNotNull(errorFragment, "errorFragment"); + // We transform ether's Array-like object into an actual array as it's safer + const actualArgs = resultToArray( + contractInterface.decodeErrorResult(errorFragment, returnData) + ); + + assertArgsArraysEqual( + Assertion, + expectedArgs, + actualArgs, + `"${customError.name}" custom error`, + "error", + assert, + ssfi + ); +} diff --git a/packages/hardhat-chai-matchers-viem/src/internal/reverted/revertedWithPanic.ts b/packages/hardhat-chai-matchers-viem/src/internal/reverted/revertedWithPanic.ts new file mode 100644 index 0000000000..04ed1467fa --- /dev/null +++ b/packages/hardhat-chai-matchers-viem/src/internal/reverted/revertedWithPanic.ts @@ -0,0 +1,117 @@ +import type EthersT from "ethers"; + +import { normalizeToBigInt } from "hardhat/common"; + +import { buildAssert } from "../../utils"; +import { REVERTED_WITH_PANIC_MATCHER } from "../constants"; +import { preventAsyncMatcherChaining } from "../utils"; +import { panicErrorCodeToReason } from "./panic"; +import { decodeReturnData, getReturnDataFromError } from "./utils"; + +export function supportRevertedWithPanic( + Assertion: Chai.AssertionStatic, + chaiUtils: Chai.ChaiUtils +) { + Assertion.addMethod( + REVERTED_WITH_PANIC_MATCHER, + function (this: any, expectedCodeArg: any) { + const ethers = require("ethers") as typeof EthersT; + + // capture negated flag before async code executes; see buildAssert's jsdoc + const negated = this.__flags.negate; + + let expectedCode: bigint | undefined; + try { + if (expectedCodeArg !== undefined) { + expectedCode = normalizeToBigInt(expectedCodeArg); + } + } catch { + // if the input validation fails, we discard the subject since it could + // potentially be a rejected promise + Promise.resolve(this._obj).catch(() => {}); + throw new TypeError( + `Expected the given panic code to be a number-like value, but got '${expectedCodeArg}'` + ); + } + + const code: bigint | undefined = expectedCode; + + let description: string | undefined; + let formattedPanicCode: string; + if (code === undefined) { + formattedPanicCode = "some panic code"; + } else { + const codeBN = ethers.toBigInt(code); + description = panicErrorCodeToReason(codeBN) ?? "unknown panic code"; + formattedPanicCode = `panic code ${ethers.toBeHex( + codeBN + )} (${description})`; + } + + preventAsyncMatcherChaining(this, REVERTED_WITH_PANIC_MATCHER, chaiUtils); + + const onSuccess = () => { + const assert = buildAssert(negated, onSuccess); + + assert( + false, + `Expected transaction to be reverted with ${formattedPanicCode}, but it didn't revert` + ); + }; + + const onError = (error: any) => { + const assert = buildAssert(negated, onError); + + const returnData = getReturnDataFromError(error); + const decodedReturnData = decodeReturnData(returnData); + + if (decodedReturnData.kind === "Empty") { + assert( + false, + `Expected transaction to be reverted with ${formattedPanicCode}, but it reverted without a reason` + ); + } else if (decodedReturnData.kind === "Error") { + assert( + false, + `Expected transaction to be reverted with ${formattedPanicCode}, but it reverted with reason '${decodedReturnData.reason}'` + ); + } else if (decodedReturnData.kind === "Panic") { + if (code !== undefined) { + assert( + decodedReturnData.code === code, + `Expected transaction to be reverted with ${formattedPanicCode}, but it reverted with panic code ${ethers.toBeHex( + decodedReturnData.code + )} (${decodedReturnData.description})`, + `Expected transaction NOT to be reverted with ${formattedPanicCode}, but it was` + ); + } else { + assert( + true, + undefined, + `Expected transaction NOT to be reverted with ${formattedPanicCode}, but it reverted with panic code ${ethers.toBeHex( + decodedReturnData.code + )} (${decodedReturnData.description})` + ); + } + } else if (decodedReturnData.kind === "Custom") { + assert( + false, + `Expected transaction to be reverted with ${formattedPanicCode}, but it reverted with a custom error` + ); + } else { + const _exhaustiveCheck: never = decodedReturnData; + } + }; + + const derivedPromise = Promise.resolve(this._obj).then( + onSuccess, + onError + ); + + this.then = derivedPromise.then.bind(derivedPromise); + this.catch = derivedPromise.catch.bind(derivedPromise); + + return this; + } + ); +} diff --git a/packages/hardhat-chai-matchers-viem/src/internal/reverted/revertedWithoutReason.ts b/packages/hardhat-chai-matchers-viem/src/internal/reverted/revertedWithoutReason.ts new file mode 100644 index 0000000000..1273aa969b --- /dev/null +++ b/packages/hardhat-chai-matchers-viem/src/internal/reverted/revertedWithoutReason.ts @@ -0,0 +1,73 @@ +import type EthersT from "ethers"; + +import { buildAssert } from "../../utils"; +import { REVERTED_WITHOUT_REASON_MATCHER } from "../constants"; +import { preventAsyncMatcherChaining } from "../utils"; +import { decodeReturnData, getReturnDataFromError } from "./utils"; + +export function supportRevertedWithoutReason( + Assertion: Chai.AssertionStatic, + chaiUtils: Chai.ChaiUtils +) { + Assertion.addMethod(REVERTED_WITHOUT_REASON_MATCHER, function (this: any) { + // capture negated flag before async code executes; see buildAssert's jsdoc + const negated = this.__flags.negate; + + preventAsyncMatcherChaining( + this, + REVERTED_WITHOUT_REASON_MATCHER, + chaiUtils + ); + + const onSuccess = () => { + const assert = buildAssert(negated, onSuccess); + + assert( + false, + `Expected transaction to be reverted without a reason, but it didn't revert` + ); + }; + + const onError = (error: any) => { + const { toBeHex } = require("ethers") as typeof EthersT; + const assert = buildAssert(negated, onError); + + const returnData = getReturnDataFromError(error); + const decodedReturnData = decodeReturnData(returnData); + + if (decodedReturnData.kind === "Error") { + assert( + false, + `Expected transaction to be reverted without a reason, but it reverted with reason '${decodedReturnData.reason}'` + ); + } else if (decodedReturnData.kind === "Empty") { + assert( + true, + undefined, + "Expected transaction NOT to be reverted without a reason, but it was" + ); + } else if (decodedReturnData.kind === "Panic") { + assert( + false, + `Expected transaction to be reverted without a reason, but it reverted with panic code ${toBeHex( + decodedReturnData.code + )} (${decodedReturnData.description})` + ); + } else if (decodedReturnData.kind === "Custom") { + assert( + false, + `Expected transaction to be reverted without a reason, but it reverted with a custom error` + ); + } else { + const _exhaustiveCheck: never = decodedReturnData; + } + }; + + const derivedPromise = Promise.resolve(this._obj).then(onSuccess, onError); + + this.then = derivedPromise.then.bind(derivedPromise); + this.catch = derivedPromise.catch.bind(derivedPromise); + + return this; + }); +} diff --git a/packages/hardhat-chai-matchers-viem/src/internal/reverted/utils.ts b/packages/hardhat-chai-matchers-viem/src/internal/reverted/utils.ts new file mode 100644 index 0000000000..253ed71562 --- /dev/null +++ b/packages/hardhat-chai-matchers-viem/src/internal/reverted/utils.ts @@ -0,0 +1,127 @@ +import type EthersT from "ethers"; + +import { AssertionError } from "chai"; + +import { HardhatChaiMatchersDecodingError } from "../errors"; +import { panicErrorCodeToReason } from "./panic"; + +// method id of 'Error(string)' +const ERROR_STRING_PREFIX = "0x08c379a0"; + +// method id of 'Panic(uint256)' +const PANIC_CODE_PREFIX = "0x4e487b71"; + +/** + * Try to obtain the return data of a transaction from the given value. + * + * If the value is an error but it doesn't have data, we assume it's not related + * to a reverted transaction and we re-throw it. + */ +export function getReturnDataFromError(error: any): string { + if (!(error instanceof Error)) { + throw new AssertionError("Expected an Error object"); + } + + // cast to any again so we don't have to cast it every time we access + // some property that doesn't exist on Error + error = error as any; + + const errorData = error.data ?? error.error?.data; + + if (errorData === undefined) { + throw error; + } + + const returnData = typeof errorData === "string" ? errorData : errorData.data; + + if (returnData === undefined || typeof returnData !== "string") { + throw error; + } + + return returnData; +} + +type DecodedReturnData = + | { + kind: "Error"; + reason: string; + } + | { + kind: "Empty"; + } + | { + kind: "Panic"; + code: bigint; + description: string; + } + | { + kind: "Custom"; + id: string; + data: string; + }; + +export function decodeReturnData(returnData: string): DecodedReturnData { + const { AbiCoder } = require("ethers") as typeof EthersT; + const abi = new AbiCoder(); + + if (returnData === "0x") { + return { kind: "Empty" }; + } else if (returnData.startsWith(ERROR_STRING_PREFIX)) { + const encodedReason = returnData.slice(ERROR_STRING_PREFIX.length); + let reason: string; + try { + reason = abi.decode(["string"], `0x${encodedReason}`)[0]; + } catch (e: any) { + throw new HardhatChaiMatchersDecodingError(encodedReason, "string", e); + } + + return { + kind: "Error", + reason, + }; + } else if (returnData.startsWith(PANIC_CODE_PREFIX)) { + const encodedReason = returnData.slice(PANIC_CODE_PREFIX.length); + let code: bigint; + try { + code = abi.decode(["uint256"], `0x${encodedReason}`)[0]; + } catch (e: any) { + throw new HardhatChaiMatchersDecodingError(encodedReason, "uint256", e); + } + + const description = panicErrorCodeToReason(code) ?? "unknown panic code"; + + return { + kind: "Panic", + code, + description, + }; + } + + return { + kind: "Custom", + id: returnData.slice(0, 10), + data: `0x${returnData.slice(10)}`, + }; +} + +/** + * Takes an ethers result object and converts it into a (potentially nested) array. + * + * For example, given this error: + * + * struct Point(uint x, uint y) + * error MyError(string, Point) + * + * revert MyError("foo", Point(1, 2)) + * + * The resulting array will be: ["foo", [1n, 2n]] + */ +export function resultToArray(result: EthersT.Result): any[] { + return result + .toArray() + .map((x) => + typeof x === "object" && x !== null && "toArray" in x + ? resultToArray(x) + : x + ); +} diff --git a/packages/hardhat-chai-matchers-viem/src/internal/typed.ts b/packages/hardhat-chai-matchers-viem/src/internal/typed.ts new file mode 100644 index 0000000000..cf331ac2d7 --- /dev/null +++ b/packages/hardhat-chai-matchers-viem/src/internal/typed.ts @@ -0,0 +1,8 @@ +export function tryDereference(value: any, type: string) { + const { Typed } = require("ethers") as typeof import("ethers"); + try { + return Typed.dereference(value, type); + } catch { + return undefined; + } +} diff --git a/packages/hardhat-chai-matchers-viem/src/internal/utils.ts b/packages/hardhat-chai-matchers-viem/src/internal/utils.ts new file mode 100644 index 0000000000..82c400d7b8 --- /dev/null +++ b/packages/hardhat-chai-matchers-viem/src/internal/utils.ts @@ -0,0 +1,170 @@ +import type EthersT from "ethers"; +import type OrdinalT from "ordinal"; + +import { AssertWithSsfi, Ssfi } from "../utils"; +import { PREVIOUS_MATCHER_NAME } from "./constants"; +import { + HardhatChaiMatchersAssertionError, + HardhatChaiMatchersNonChainableMatcherError, +} from "./errors"; + +export function assertIsNotNull( + value: T, + valueName: string +): asserts value is Exclude { + if (value === null) { + throw new HardhatChaiMatchersAssertionError( + `${valueName} should not be null` + ); + } +} + +export function preventAsyncMatcherChaining( + context: object, + matcherName: string, + chaiUtils: Chai.ChaiUtils, + allowSelfChaining: boolean = false +) { + const previousMatcherName: string | undefined = chaiUtils.flag( + context, + PREVIOUS_MATCHER_NAME + ); + + if (previousMatcherName === undefined) { + chaiUtils.flag(context, PREVIOUS_MATCHER_NAME, matcherName); + return; + } + + if (previousMatcherName === matcherName && allowSelfChaining) { + return; + } + + throw new HardhatChaiMatchersNonChainableMatcherError( + matcherName, + previousMatcherName + ); +} + +export function assertArgsArraysEqual( + Assertion: Chai.AssertionStatic, + expectedArgs: any[], + actualArgs: any[], + tag: string, + assertionType: "event" | "error", + assert: AssertWithSsfi, + ssfi: Ssfi +) { + try { + innerAssertArgsArraysEqual( + Assertion, + expectedArgs, + actualArgs, + assertionType, + assert, + ssfi + ); + } catch (err: any) { + err.message = `Error in ${tag}: ${err.message}`; + throw err; + } +} + +function innerAssertArgsArraysEqual( + Assertion: Chai.AssertionStatic, + expectedArgs: any[], + actualArgs: any[], + assertionType: "event" | "error", + assert: AssertWithSsfi, + ssfi: Ssfi +) { + assert( + actualArgs.length === expectedArgs.length, + `Expected arguments array to have length ${expectedArgs.length}, but it has ${actualArgs.length}` + ); + for (const [index, expectedArg] of expectedArgs.entries()) { + try { + innerAssertArgEqual( + Assertion, + expectedArg, + actualArgs[index], + assertionType, + assert, + ssfi + ); + } catch (err: any) { + const ordinal = require("ordinal") as typeof OrdinalT; + err.message = `Error in the ${ordinal(index + 1)} argument assertion: ${ + err.message + }`; + throw err; + } + } +} + +function innerAssertArgEqual( + Assertion: Chai.AssertionStatic, + expectedArg: any, + actualArg: any, + assertionType: "event" | "error", + assert: AssertWithSsfi, + ssfi: Ssfi +) { + const ethers = require("ethers") as typeof EthersT; + if (typeof expectedArg === "function") { + try { + if (expectedArg(actualArg) === true) return; + } catch (e: any) { + assert( + false, + `The predicate threw when called: ${e.message}` + // no need for a negated message, since we disallow mixing .not. with + // .withArgs + ); + } + assert( + false, + `The predicate did not return true` + // no need for a negated message, since we disallow mixing .not. with + // .withArgs + ); + } else if (expectedArg instanceof Uint8Array) { + new Assertion(actualArg, undefined, ssfi, true).equal( + ethers.hexlify(expectedArg) + ); + } else if ( + expectedArg?.length !== undefined && + typeof expectedArg !== "string" + ) { + innerAssertArgsArraysEqual( + Assertion, + expectedArg, + actualArg, + assertionType, + assert, + ssfi + ); + } else { + if (actualArg.hash !== undefined && actualArg._isIndexed === true) { + if (assertionType !== "event") { + throw new Error( + "Should not get an indexed event when the assertion type is not event. Please open an issue about this." + ); + } + + new Assertion(actualArg.hash, undefined, ssfi, true).to.not.equal( + expectedArg, + "The actual value was an indexed and hashed value of the event argument. The expected value provided to the assertion should be the actual event argument (the pre-image of the hash). You provided the hash itself. Please supply the actual event argument (the pre-image of the hash) instead." + ); + const expectedArgBytes = ethers.isHexString(expectedArg) + ? ethers.getBytes(expectedArg) + : ethers.toUtf8Bytes(expectedArg); + const expectedHash = ethers.keccak256(expectedArgBytes); + new Assertion(actualArg.hash, undefined, ssfi, true).to.equal( + expectedHash, + `The actual value was an indexed and hashed value of the event argument. The expected value provided to the assertion was hashed to produce ${expectedHash}. The actual hash and the expected hash ${actualArg.hash} did not match` + ); + } else { + new Assertion(actualArg, undefined, ssfi, true).equal(expectedArg); + } + } +} diff --git a/packages/hardhat-chai-matchers-viem/src/internal/withArgs.ts b/packages/hardhat-chai-matchers-viem/src/internal/withArgs.ts new file mode 100644 index 0000000000..1124b6535e --- /dev/null +++ b/packages/hardhat-chai-matchers-viem/src/internal/withArgs.ts @@ -0,0 +1,129 @@ +import type EthersT from "ethers"; +import { AssertionError } from "chai"; + +import { isBigNumber, normalizeToBigInt } from "hardhat/common"; +import { ASSERTION_ABORTED } from "./constants"; + +import { emitWithArgs, EMIT_CALLED } from "./emit"; +import { + revertedWithCustomErrorWithArgs, + REVERTED_WITH_CUSTOM_ERROR_CALLED, +} from "./reverted/revertedWithCustomError"; + +/** + * A predicate for use with .withArgs(...), to induce chai to accept any value + * as a positive match with the argument. + * + * Example: expect(contract.emitInt()).to.emit(contract, "Int").withArgs(anyValue) + */ +export function anyValue(): boolean { + return true; +} + +/** + * A predicate for use with .withArgs(...), to induce chai to accept any + * unsigned integer as a positive match with the argument. + * + * Example: expect(contract.emitUint()).to.emit(contract, "Uint").withArgs(anyUint) + */ +export function anyUint(i: any): boolean { + if (typeof i === "number") { + if (i < 0) { + throw new AssertionError( + `anyUint expected its argument to be an unsigned integer, but it was negative, with value ${i}` + ); + } + return true; + } else if (isBigNumber(i)) { + const bigInt = normalizeToBigInt(i); + if (bigInt < 0) { + throw new AssertionError( + `anyUint expected its argument to be an unsigned integer, but it was negative, with value ${bigInt}` + ); + } + return true; + } + throw new AssertionError( + `anyUint expected its argument to be an integer, but its type was '${typeof i}'` + ); +} + +export function supportWithArgs( + Assertion: Chai.AssertionStatic, + chaiUtils: Chai.ChaiUtils +) { + Assertion.addMethod("withArgs", function (this: any, ...expectedArgs: any[]) { + const { emitCalled } = validateInput.call(this, chaiUtils); + + const { isAddressable } = require("ethers") as typeof EthersT; + + // Resolve arguments to their canonical form: + // - Addressable → address + const resolveArgument = (arg: any) => + isAddressable(arg) ? arg.getAddress() : arg; + + const onSuccess = (resolvedExpectedArgs: any[]) => { + if (emitCalled) { + return emitWithArgs( + this, + Assertion, + chaiUtils, + resolvedExpectedArgs, + onSuccess + ); + } else { + return revertedWithCustomErrorWithArgs( + this, + Assertion, + chaiUtils, + resolvedExpectedArgs, + onSuccess + ); + } + }; + + const promise = (this.then === undefined ? Promise.resolve() : this) + .then(() => Promise.all(expectedArgs.map(resolveArgument))) + .then(onSuccess); + + this.then = promise.then.bind(promise); + this.catch = promise.catch.bind(promise); + return this; + }); +} + +function validateInput( + this: any, + chaiUtils: Chai.ChaiUtils +): { emitCalled: boolean } { + try { + if (Boolean(this.__flags.negate)) { + throw new Error("Do not combine .not. with .withArgs()"); + } + + const emitCalled = chaiUtils.flag(this, EMIT_CALLED) === true; + const revertedWithCustomErrorCalled = + chaiUtils.flag(this, REVERTED_WITH_CUSTOM_ERROR_CALLED) === true; + + if (!emitCalled && !revertedWithCustomErrorCalled) { + throw new Error( + "withArgs can only be used in combination with a previous .emit or .revertedWithCustomError assertion" + ); + } + if (emitCalled && revertedWithCustomErrorCalled) { + throw new Error( + "withArgs called with both .emit and .revertedWithCustomError, but these assertions cannot be combined" + ); + } + + return { emitCalled }; + } catch (e) { + // signal that validation failed to allow the matchers to finish early + chaiUtils.flag(this, ASSERTION_ABORTED, true); + + // discard subject since it could potentially be a rejected promise + Promise.resolve(this._obj).catch(() => {}); + + throw e; + } +} diff --git a/packages/hardhat-chai-matchers-viem/src/panic.ts b/packages/hardhat-chai-matchers-viem/src/panic.ts new file mode 100644 index 0000000000..be1b86a93c --- /dev/null +++ b/packages/hardhat-chai-matchers-viem/src/panic.ts @@ -0,0 +1,2 @@ +// re-export here so users can import from "@nomicfoundation/hardhat-chai-matchers/panic" +export { PANIC_CODES } from "./internal/reverted/panic"; diff --git a/packages/hardhat-chai-matchers-viem/src/tsconfig.json b/packages/hardhat-chai-matchers-viem/src/tsconfig.json new file mode 100644 index 0000000000..3fe5d00bcf --- /dev/null +++ b/packages/hardhat-chai-matchers-viem/src/tsconfig.json @@ -0,0 +1,19 @@ +{ + "extends": "../../../config/typescript/tsconfig.json", + "compilerOptions": { + "outDir": "../", + "rootDirs": ["."], + "composite": true, + "types": ["node", "chai"] + }, + "include": ["./**/*.ts"], + "exclude": [], + "references": [ + { + "path": "../../hardhat-core/src" + }, + { + "path": "../../hardhat-ethers/src" + } + ] +} diff --git a/packages/hardhat-chai-matchers-viem/src/types.ts b/packages/hardhat-chai-matchers-viem/src/types.ts new file mode 100644 index 0000000000..b4a2332c1d --- /dev/null +++ b/packages/hardhat-chai-matchers-viem/src/types.ts @@ -0,0 +1,66 @@ +// eslint-disable-next-line @typescript-eslint/no-namespace, @typescript-eslint/no-unused-vars +declare namespace Chai { + interface Assertion + extends LanguageChains, + NumericComparison, + TypeComparison { + emit(contract: any, eventName: string): EmitAssertion; + reverted: AsyncAssertion; + revertedWith(reason: string | RegExp): AsyncAssertion; + revertedWithoutReason(): AsyncAssertion; + revertedWithPanic(code?: any): AsyncAssertion; + revertedWithCustomError( + contract: { interface: any }, + customErrorName: string + ): CustomErrorAssertion; + hexEqual(other: string): void; + properPrivateKey: void; + properAddress: void; + properHex(length: number): void; + changeEtherBalance( + account: any, + balance: any, + options?: any + ): AsyncAssertion; + changeEtherBalances( + accounts: any[], + balances: any[] | ((changes: bigint[]) => boolean), + options?: any + ): AsyncAssertion; + changeTokenBalance(token: any, account: any, balance: any): AsyncAssertion; + changeTokenBalances( + token: any, + account: any[], + balance: any[] | ((changes: bigint[]) => boolean) + ): AsyncAssertion; + } + + interface NumericComparison { + within(start: any, finish: any, message?: string): Assertion; + } + + interface NumberComparer { + // eslint-disable-next-line + (value: any, message?: string): Assertion; + } + + interface CloseTo { + // eslint-disable-next-line + (expected: any, delta: any, message?: string): Assertion; + } + + interface Length extends Assertion { + // eslint-disable-next-line + (length: any, message?: string): Assertion; + } + + interface AsyncAssertion extends Assertion, Promise {} + + interface EmitAssertion extends AsyncAssertion { + withArgs(...args: any[]): AsyncAssertion; + } + + interface CustomErrorAssertion extends AsyncAssertion { + withArgs(...args: any[]): AsyncAssertion; + } +} diff --git a/packages/hardhat-chai-matchers-viem/src/utils.ts b/packages/hardhat-chai-matchers-viem/src/utils.ts new file mode 100644 index 0000000000..b5a1d508f0 --- /dev/null +++ b/packages/hardhat-chai-matchers-viem/src/utils.ts @@ -0,0 +1,54 @@ +import { AssertionError } from "chai"; + +// just a generic function type to avoid errors from the ban-types eslint rule +export type Ssfi = (...args: any[]) => any; + +/** + * This function is used by the matchers to obtain an `assert` function, which + * should be used instead of `this.assert`. + * + * The first parameter is the value of the `negated` flag. Keep in mind that + * this value should be captured at the beginning of the matcher's + * implementation, before any async code is executed. Otherwise things like + * `.to.emit().and.not.to.emit()` won't work, because by the time the async part + * of the first emit is executd, the `.not` (executed synchronously) has already + * modified the flag. + * + * The second parameter is what Chai calls the "start stack function indicator", + * a function that is used to build the stack trace. It's unclear to us what's + * the best way to use this value, so this needs some trial-and-error. Use the + * existing matchers for a reference of something that works well enough. + */ +export function buildAssert(negated: boolean, ssfi: Ssfi) { + return function ( + condition: boolean, + messageFalse?: string | (() => string), + messageTrue?: string | (() => string) + ) { + if (!negated && !condition) { + if (messageFalse === undefined) { + throw new Error( + "Assertion doesn't have an error message. Please open an issue to report this." + ); + } + + const message = + typeof messageFalse === "function" ? messageFalse() : messageFalse; + throw new AssertionError(message, undefined, ssfi); + } + + if (negated && condition) { + if (messageTrue === undefined) { + throw new Error( + "Assertion doesn't have an error message. Please open an issue to report this." + ); + } + + const message = + typeof messageTrue === "function" ? messageTrue() : messageTrue; + throw new AssertionError(message, undefined, ssfi); + } + }; +} + +export type AssertWithSsfi = ReturnType; diff --git a/packages/hardhat-chai-matchers-viem/src/withArgs.ts b/packages/hardhat-chai-matchers-viem/src/withArgs.ts new file mode 100644 index 0000000000..4e1245288a --- /dev/null +++ b/packages/hardhat-chai-matchers-viem/src/withArgs.ts @@ -0,0 +1 @@ +export { anyUint, anyValue } from "./internal/withArgs"; diff --git a/packages/hardhat-chai-matchers-viem/test/.eslintrc.js b/packages/hardhat-chai-matchers-viem/test/.eslintrc.js new file mode 100644 index 0000000000..d9238cab24 --- /dev/null +++ b/packages/hardhat-chai-matchers-viem/test/.eslintrc.js @@ -0,0 +1,16 @@ +module.exports = { + extends: [`${__dirname}/../.eslintrc.js`], + parserOptions: { + project: `${__dirname}/../tsconfig.json`, + sourceType: "module", + }, + rules: { + "@typescript-eslint/restrict-template-expressions": "off", + "import/no-extraneous-dependencies": [ + "error", + { + devDependencies: true, + }, + ], + }, +}; diff --git a/packages/hardhat-chai-matchers-viem/test/addressable.ts b/packages/hardhat-chai-matchers-viem/test/addressable.ts new file mode 100644 index 0000000000..5b1b146232 --- /dev/null +++ b/packages/hardhat-chai-matchers-viem/test/addressable.ts @@ -0,0 +1,82 @@ +import { ethers } from "ethers"; +import { AssertionError, expect } from "chai"; + +import "../src/internal/add-chai-matchers"; + +describe("Addressable matcher", () => { + const signer = ethers.Wallet.createRandom(); + const address = signer.address; + const contract = new ethers.Contract(address, []); + const typedAddress = ethers.Typed.address(address); + const typedSigner = ethers.Typed.address(signer); + const typedContract = ethers.Typed.address(contract); + + const otherSigner = ethers.Wallet.createRandom(); + const otherAddress = otherSigner.address; + const otherContract = new ethers.Contract(otherAddress, []); + const otherTypedAddress = ethers.Typed.address(otherAddress); + const otherTypedSigner = ethers.Typed.address(otherSigner); + const otherTypedContract = ethers.Typed.address(otherContract); + + const elements = [ + { name: "address", object: address, class: address }, + { name: "signer", object: signer, class: address }, + { name: "contract", object: contract, class: address }, + { name: "typed address", object: typedAddress, class: address }, + { name: "typed signer", object: typedSigner, class: address }, + { name: "typed contract", object: typedContract, class: address }, + { name: "other address", object: otherAddress, class: otherAddress }, + { name: "other signer", object: otherSigner, class: otherAddress }, + { name: "other contract", object: otherContract, class: otherAddress }, + { + name: "other typed address", + object: otherTypedAddress, + class: otherAddress, + }, + { + name: "other typed signer", + object: otherTypedSigner, + class: otherAddress, + }, + { + name: "other typed contract", + object: otherTypedContract, + class: otherAddress, + }, + ]; + + for (const el1 of elements) + for (const el2 of elements) { + const expectEqual = el1.class === el2.class; + + describe(`expect "${el1.name}" to equal "${el2.name}"`, () => { + if (expectEqual) { + it("should not revert", () => { + expect(el1.object).to.equal(el2.object); + }); + } else { + it("should revert", () => { + expect(() => expect(el1.object).to.equal(el2.object)).to.throw( + AssertionError, + `expected '${el1.class}' to equal '${el2.class}'.` + ); + }); + } + }); + + describe(`expect "${el1.name}" to not equal "${el1.name}"`, () => { + if (expectEqual) { + it("should revert", () => { + expect(() => expect(el1.object).to.not.equal(el2.object)).to.throw( + AssertionError, + `expected '${el1.class}' to not equal '${el2.class}'.` + ); + }); + } else { + it("should not revert", () => { + expect(el1.object).to.not.equal(el2.object); + }); + } + }); + } +}); diff --git a/packages/hardhat-chai-matchers-viem/test/bigNumber.ts b/packages/hardhat-chai-matchers-viem/test/bigNumber.ts new file mode 100644 index 0000000000..0353333c97 --- /dev/null +++ b/packages/hardhat-chai-matchers-viem/test/bigNumber.ts @@ -0,0 +1,1226 @@ +import { expect, AssertionError } from "chai"; +import { BigNumber as BigNumberJs } from "bignumber.js"; +import BN from "bn.js"; + +import { HardhatError } from "hardhat/internal/core/errors"; + +import "../src/internal/add-chai-matchers"; + +type SupportedNumber = number | bigint | BN | BigNumberJs; + +const numberToBigNumberConversions = [ + (n: number) => BigInt(n), + (n: number) => new BN(n), + (n: number) => new BigNumberJs(n), +]; + +describe("BigNumber matchers", function () { + function typestr(n: string | SupportedNumber): string { + if (typeof n === "object") { + if (n instanceof BN) { + return "BN"; + } else if (n instanceof BigNumberJs) { + return "bignumber.js"; + } + } + return typeof n; + } + + describe("length", function () { + const lengthFunctions: Array< + keyof Chai.Assertion & ("length" | "lengthOf") + > = ["length", "lengthOf"]; + + interface SuccessCase { + obj: object; + len: number; + } + + const positiveSuccessCases: SuccessCase[] = [ + { obj: [1, 2, 3], len: 3 }, + { + obj: new Map([ + [1, 2], + [3, 4], + ]), + len: 2, + }, + { obj: new Set([1, 2, 3]), len: 3 }, + ]; + describe("positive, successful assertions", function () { + for (const { obj, len } of positiveSuccessCases) { + for (const convert of [ + (n: number) => n, + ...numberToBigNumberConversions, + ]) { + const length = convert(len); + describe(`with object ${obj.toString()} and with length operand of type ${typestr( + length + )}`, function () { + for (const lenFunc of lengthFunctions) { + it(`.to.have.${lenFunc} should work`, function () { + expect(obj).to.have[lenFunc](length); + }); + } + }); + } + } + }); + + const negativeSuccessCases: SuccessCase[] = [ + { obj: [1, 2, 3], len: 2 }, + { + obj: new Map([ + [1, 2], + [3, 4], + ]), + len: 3, + }, + { obj: new Set([1, 2, 3]), len: 4 }, + ]; + describe("negative, successful assertions", function () { + for (const { obj, len } of negativeSuccessCases) { + for (const convert of [ + (n: number) => n, + ...numberToBigNumberConversions, + ]) { + const length = convert(len); + describe(`with object ${obj.toString()} and with length operand of type ${typestr( + length + )}`, function () { + for (const lenFunc of lengthFunctions) { + it(`should work with .not.to.have.${lenFunc}`, function () { + expect(obj).not.to.have[lenFunc](length); + }); + } + }); + } + } + }); + + interface FailureCase extends SuccessCase { + msg: string | RegExp; + } + + const positiveFailureCases: FailureCase[] = [ + { + obj: [1, 2, 3], + len: 2, + msg: "expected [ 1, 2, 3 ] to have a length of 2 but got 3", + }, + { + obj: new Set([1, 2, 3]), + len: 2, + msg: /expected .* to have a size of 2 but got 3/, + }, + { + obj: new Map([ + [1, 2], + [3, 4], + ]), + len: 3, + msg: /expected .* to have a size of 3 but got 2/, + }, + ]; + describe("positive, failing assertions should throw the proper error message", function () { + for (const { obj, len, msg } of positiveFailureCases) { + for (const convert of [ + (n: number) => n, + ...numberToBigNumberConversions, + ]) { + const length = convert(len); + describe(`with object ${obj.toString()} and with operand of type ${typestr( + length + )}`, function () { + for (const lenFunc of lengthFunctions) { + it(`should work with .to.have.${lenFunc}`, function () { + expect(() => expect(obj).to.have[lenFunc](length)).to.throw( + AssertionError, + msg + ); + }); + } + }); + } + } + }); + + const operators = [ + "above", + "below", + "gt", + "lt", + "greaterThan", + "lessThan", + "least", + "most", + "gte", + "lte", + "greaterThanOrEqual", + "lessThanOrEqual", + ] as const; + type Operator = typeof operators[number]; + + interface SuccessCaseWithOperator extends SuccessCase { + operator: Operator; + } + + const positiveSuccessCasesWithOperator: SuccessCaseWithOperator[] = [ + { operator: "lt", len: 4, obj: [1, 2, 3] }, + { operator: "lt", len: 4, obj: new Set([1, 2, 3]) }, + { + operator: "lt", + len: 4, + obj: new Map([ + [1, 2], + [3, 4], + [5, 6], + ]), + }, + { operator: "above", len: 2, obj: [1, 2, 3] }, + { operator: "above", len: 2, obj: new Set([1, 2, 3]) }, + { + operator: "above", + len: 2, + obj: new Map([ + [1, 2], + [3, 4], + [5, 6], + ]), + }, + { operator: "gt", len: 2, obj: [1, 2, 3] }, + { operator: "gt", len: 2, obj: new Set([1, 2, 3]) }, + { + operator: "gt", + len: 2, + obj: new Map([ + [1, 2], + [3, 4], + [5, 6], + ]), + }, + { operator: "greaterThan", len: 2, obj: [1, 2, 3] }, + { operator: "greaterThan", len: 2, obj: new Set([1, 2, 3]) }, + { + operator: "greaterThan", + len: 2, + obj: new Map([ + [1, 2], + [3, 4], + [5, 6], + ]), + }, + { operator: "least", len: 3, obj: [1, 2, 3] }, + { operator: "least", len: 3, obj: new Set([1, 2, 3]) }, + { + operator: "least", + len: 3, + obj: new Map([ + [1, 2], + [3, 4], + [5, 6], + ]), + }, + { operator: "most", len: 3, obj: [1, 2, 3] }, + { operator: "most", len: 3, obj: new Set([1, 2, 3]) }, + { + operator: "most", + len: 3, + obj: new Map([ + [1, 2], + [3, 4], + [5, 6], + ]), + }, + { operator: "gte", len: 3, obj: [1, 2, 3] }, + { operator: "gte", len: 3, obj: new Set([1, 2, 3]) }, + { + operator: "gte", + len: 3, + obj: new Map([ + [1, 2], + [3, 4], + [5, 6], + ]), + }, + { operator: "lte", len: 3, obj: [1, 2, 3] }, + { operator: "lte", len: 3, obj: new Set([1, 2, 3]) }, + { + operator: "lte", + len: 3, + obj: new Map([ + [1, 2], + [3, 4], + [5, 6], + ]), + }, + { operator: "greaterThanOrEqual", len: 3, obj: [1, 2, 3] }, + { operator: "greaterThanOrEqual", len: 3, obj: new Set([1, 2, 3]) }, + { + operator: "greaterThanOrEqual", + len: 3, + obj: new Map([ + [1, 2], + [3, 4], + [5, 6], + ]), + }, + { operator: "lessThanOrEqual", len: 3, obj: [1, 2, 3] }, + { operator: "lessThanOrEqual", len: 3, obj: new Set([1, 2, 3]) }, + { + operator: "lessThanOrEqual", + len: 3, + obj: new Map([ + [1, 2], + [3, 4], + [5, 6], + ]), + }, + ]; + describe("positive, successful assertions chained off of length", function () { + for (const { obj, operator, len } of positiveSuccessCasesWithOperator) { + describe(`with object ${obj} and operator "${operator}"`, function () { + for (const convert of [ + (n: number) => n, + ...numberToBigNumberConversions, + ]) { + const length = convert(len); + describe(`with an operand of type ${typestr(length)}`, function () { + for (const lenFunc of lengthFunctions) { + it(`should work with .to.have.${lenFunc}.${operator}`, function () { + expect(obj).to.have[lenFunc][operator](length); + }); + } + }); + } + }); + } + }); + + const negativeSuccessCasesWithOperator: SuccessCaseWithOperator[] = [ + { operator: "above", len: 3, obj: [1, 2, 3] }, + { operator: "above", len: 3, obj: new Set([1, 2, 3]) }, + { + operator: "above", + len: 3, + obj: new Map([ + [1, 2], + [3, 4], + [5, 6], + ]), + }, + { operator: "below", len: 3, obj: [1, 2, 3] }, + { operator: "below", len: 3, obj: new Set([1, 2, 3]) }, + { + operator: "below", + len: 3, + obj: new Map([ + [1, 2], + [3, 4], + [5, 6], + ]), + }, + { operator: "gt", len: 3, obj: [1, 2, 3] }, + { operator: "gt", len: 3, obj: new Set([1, 2, 3]) }, + { + operator: "gt", + len: 3, + obj: new Map([ + [1, 2], + [3, 4], + [5, 6], + ]), + }, + { operator: "lt", len: 3, obj: [1, 2, 3] }, + { operator: "lt", len: 3, obj: new Set([1, 2, 3]) }, + { + operator: "lt", + len: 3, + obj: new Map([ + [1, 2], + [3, 4], + [5, 6], + ]), + }, + { operator: "greaterThan", len: 3, obj: [1, 2, 3] }, + { operator: "greaterThan", len: 3, obj: new Set([1, 2, 3]) }, + { + operator: "greaterThan", + len: 3, + obj: new Map([ + [1, 2], + [3, 4], + [5, 6], + ]), + }, + { operator: "lessThan", len: 3, obj: [1, 2, 3] }, + { operator: "lessThan", len: 3, obj: new Set([1, 2, 3]) }, + { + operator: "lessThan", + len: 3, + obj: new Map([ + [1, 2], + [3, 4], + [5, 6], + ]), + }, + { operator: "least", len: 4, obj: [1, 2, 3] }, + { operator: "least", len: 4, obj: new Set([1, 2, 3]) }, + { + operator: "least", + len: 4, + obj: new Map([ + [1, 2], + [3, 4], + [5, 6], + ]), + }, + { operator: "most", len: 2, obj: [1, 2, 3] }, + { operator: "most", len: 2, obj: new Set([1, 2, 3]) }, + { + operator: "most", + len: 2, + obj: new Map([ + [1, 2], + [3, 4], + [5, 6], + ]), + }, + { operator: "gte", len: 4, obj: [1, 2, 3] }, + { operator: "gte", len: 4, obj: new Set([1, 2, 3]) }, + { + operator: "gte", + len: 4, + obj: new Map([ + [1, 2], + [3, 4], + [5, 6], + ]), + }, + { operator: "lte", len: 2, obj: [1, 2, 3] }, + { operator: "lte", len: 2, obj: new Set([1, 2, 3]) }, + { + operator: "lte", + len: 2, + obj: new Map([ + [1, 2], + [3, 4], + [5, 6], + ]), + }, + { operator: "greaterThanOrEqual", len: 4, obj: [1, 2, 3] }, + { operator: "greaterThanOrEqual", len: 4, obj: new Set([1, 2, 3]) }, + { + operator: "greaterThanOrEqual", + len: 4, + obj: new Map([ + [1, 2], + [3, 4], + [5, 6], + ]), + }, + { operator: "lessThanOrEqual", len: 2, obj: [1, 2, 3] }, + { operator: "lessThanOrEqual", len: 2, obj: new Set([1, 2, 3]) }, + { + operator: "lessThanOrEqual", + len: 2, + obj: new Map([ + [1, 2], + [3, 4], + [5, 6], + ]), + }, + ]; + describe("negative, successful assertions chained off of length", function () { + for (const { obj, operator, len } of negativeSuccessCasesWithOperator) { + describe(`with object ${obj} and operator "${operator}"`, function () { + for (const convert of [ + (n: number) => n, + ...numberToBigNumberConversions, + ]) { + const length = convert(len); + describe(`with an operand of type ${typestr(length)}`, function () { + for (const lenFunc of lengthFunctions) { + it(`should work with .not.to.have.${lenFunc}.${operator}`, function () { + expect(obj).not.to.have[lenFunc][operator](length); + }); + } + }); + } + }); + } + }); + + interface FailureCaseWithOperator extends SuccessCaseWithOperator { + msg: string; + } + + const positiveFailureCasesWithOperator: FailureCaseWithOperator[] = [ + { + obj: [1, 2, 3], + operator: "above", + len: 3, + msg: "expected [ 1, 2, 3 ] to have a length above 3 but got 3", + }, + { + obj: [1, 2, 3], + operator: "below", + len: 3, + msg: "expected [ 1, 2, 3 ] to have a length below 3 but got 3", + }, + { + obj: [1, 2, 3], + operator: "gt", + len: 3, + msg: "expected [ 1, 2, 3 ] to have a length above 3 but got 3", + }, + { + obj: [1, 2, 3], + operator: "lt", + len: 3, + msg: "expected [ 1, 2, 3 ] to have a length below 3 but got 3", + }, + { + obj: [1, 2, 3], + operator: "greaterThan", + len: 3, + msg: "expected [ 1, 2, 3 ] to have a length above 3 but got 3", + }, + { + obj: [1, 2, 3], + operator: "lessThan", + len: 3, + msg: "expected [ 1, 2, 3 ] to have a length below 3 but got 3", + }, + { + obj: [1, 2, 3], + operator: "least", + len: 4, + msg: "expected [ 1, 2, 3 ] to have a length at least 4 but got 3", + }, + { + obj: [1, 2, 3], + operator: "most", + len: 2, + msg: "expected [ 1, 2, 3 ] to have a length at most 2 but got 3", + }, + { + obj: [1, 2, 3], + operator: "gte", + len: 4, + msg: "expected [ 1, 2, 3 ] to have a length at least 4 but got 3", + }, + { + obj: [1, 2, 3], + operator: "lte", + len: 2, + msg: "expected [ 1, 2, 3 ] to have a length at most 2 but got 3", + }, + { + obj: [1, 2, 3], + operator: "greaterThanOrEqual", + len: 4, + msg: "expected [ 1, 2, 3 ] to have a length at least 4 but got 3", + }, + { + obj: [1, 2, 3], + operator: "lessThanOrEqual", + len: 2, + msg: "expected [ 1, 2, 3 ] to have a length at most 2 but got 3", + }, + ]; + describe("positive, failing assertions chained off of length should throw the proper error message", function () { + for (const { + obj, + operator, + len, + msg, + } of positiveFailureCasesWithOperator) { + describe(`with object ${obj} and operator "${operator}"`, function () { + for (const convert of [ + (n: number) => n, + ...numberToBigNumberConversions, + ]) { + const length = convert(len); + describe(`with an operand of type ${typestr(length)}`, function () { + for (const lenFunc of lengthFunctions) { + it(`should work with .to.have.${lenFunc}.${operator}`, function () { + expect(() => + expect(obj).to.have[lenFunc][operator](length) + ).to.throw(AssertionError, msg); + }); + } + }); + } + }); + } + }); + }); + + describe("with two arguments", function () { + function checkAll( + actual: number, + expected: number, + test: ( + actual: string | SupportedNumber, + expected: string | SupportedNumber + ) => void + ) { + const conversions = [ + (n: number) => n, + (n: number) => n.toString(), + ...numberToBigNumberConversions, + ]; + for (const convertActual of conversions) { + for (const convertExpected of conversions) { + const convertedActual = convertActual(actual); + const convertedExpected = convertExpected(expected); + // a few particular combinations of types don't work: + if ( + typeof convertedActual === "string" && + !BN.isBN(convertedExpected) && + !BigNumberJs.isBigNumber(convertedExpected) + ) { + continue; + } + if ( + typeof convertedActual === "number" && + typeof convertedExpected === "string" + ) { + continue; + } + test(convertedActual, convertedExpected); + } + } + } + + const operators = [ + "equals", + "equal", + "eq", + "above", + "below", + "gt", + "lt", + "greaterThan", + "lessThan", + "least", + "most", + "gte", + "lte", + "greaterThanOrEqual", + "lessThanOrEqual", + ] as const; + type Operator = typeof operators[number]; + + interface SuccessCase { + operator: Operator; + operands: [number, number]; + } + + interface FailureCase extends SuccessCase { + msg: string; + } + + const positiveSuccessCases: SuccessCase[] = [ + { operands: [10, 10], operator: "eq" }, + { operands: [10, 10], operator: "equal" }, + { operands: [10, 10], operator: "equals" }, + { operands: [10, 9], operator: "above" }, + { operands: [10, 9], operator: "gt" }, + { operands: [10, 9], operator: "greaterThan" }, + { operands: [10, 11], operator: "below" }, + { operands: [10, 11], operator: "lt" }, + { operands: [10, 11], operator: "lessThan" }, + { operands: [10, 10], operator: "least" }, + { operands: [10, 10], operator: "gte" }, + { operands: [10, 10], operator: "greaterThanOrEqual" }, + { operands: [10, 9], operator: "least" }, + { operands: [10, 9], operator: "gte" }, + { operands: [10, 9], operator: "greaterThanOrEqual" }, + { operands: [10, 10], operator: "most" }, + { operands: [10, 10], operator: "lte" }, + { operands: [10, 10], operator: "lessThanOrEqual" }, + { operands: [10, 11], operator: "most" }, + { operands: [10, 11], operator: "lte" }, + { operands: [10, 11], operator: "lessThanOrEqual" }, + ]; + for (const { operator, operands } of positiveSuccessCases) { + describe(`.to.${operator}`, function () { + checkAll(operands[0], operands[1], (a, b) => { + it(`should work with ${typestr(a)} and ${typestr(b)}`, function () { + expect(a).to[operator](b); + }); + }); + }); + } + + const eqPositiveFailureCase: Omit = { + operands: [10, 11], + msg: "expected 10 to equal 11", + }; + const gtPositiveFailureCase: Omit = { + operands: [10, 10], + msg: "expected 10 to be above 10", + }; + const ltPositiveFailureCase: Omit = { + operands: [11, 10], + msg: "expected 11 to be below 10", + }; + const gtePositiveFailureCase: Omit = { + operands: [10, 11], + msg: "expected 10 to be at least 11", + }; + const ltePositiveFailureCase: Omit = { + operands: [11, 10], + msg: "expected 11 to be at most 10", + }; + const positiveFailureCases: FailureCase[] = [ + { ...eqPositiveFailureCase, operator: "eq" }, + { ...eqPositiveFailureCase, operator: "equal" }, + { ...eqPositiveFailureCase, operator: "equals" }, + { ...gtPositiveFailureCase, operator: "above" }, + { ...gtPositiveFailureCase, operator: "gt" }, + { ...gtPositiveFailureCase, operator: "greaterThan" }, + { ...ltPositiveFailureCase, operator: "below" }, + { ...ltPositiveFailureCase, operator: "lt" }, + { ...ltPositiveFailureCase, operator: "lessThan" }, + { ...gtePositiveFailureCase, operator: "least" }, + { ...gtePositiveFailureCase, operator: "gte" }, + { ...gtePositiveFailureCase, operator: "greaterThanOrEqual" }, + { ...ltePositiveFailureCase, operator: "most" }, + { ...ltePositiveFailureCase, operator: "lte" }, + { ...ltePositiveFailureCase, operator: "lessThanOrEqual" }, + ]; + for (const { operator, operands, msg } of positiveFailureCases) { + describe(`.to.${operator} should throw the proper message on failure`, function () { + checkAll(operands[0], operands[1], (a, b) => { + it(`with ${typestr(a)} and ${typestr(b)}`, function () { + expect(() => expect(a).to[operator](b)).to.throw( + AssertionError, + msg + ); + }); + }); + }); + } + + const negativeSuccessCases: SuccessCase[] = [ + { operands: [11, 10], operator: "eq" }, + { operands: [11, 10], operator: "equal" }, + { operands: [11, 10], operator: "equals" }, + { operands: [10, 10], operator: "above" }, + { operands: [10, 10], operator: "gt" }, + { operands: [10, 10], operator: "greaterThan" }, + { operands: [10, 10], operator: "below" }, + { operands: [10, 10], operator: "lt" }, + { operands: [10, 10], operator: "lessThan" }, + { operands: [10, 9], operator: "below" }, + { operands: [10, 9], operator: "lt" }, + { operands: [10, 9], operator: "lessThan" }, + { operands: [10, 11], operator: "least" }, + { operands: [10, 11], operator: "gte" }, + { operands: [10, 11], operator: "greaterThanOrEqual" }, + { operands: [10, 9], operator: "most" }, + { operands: [10, 9], operator: "lte" }, + { operands: [10, 9], operator: "lessThanOrEqual" }, + ]; + for (const { operator, operands } of negativeSuccessCases) { + describe(`.not.to.${operator}`, function () { + checkAll(operands[0], operands[1], (a, b) => { + it(`should work with ${typestr(a)} and ${typestr(b)}`, function () { + expect(a).not.to[operator](b); + }); + }); + }); + } + + const gtNegativeFailureCase: Omit = { + operands: [11, 10], + msg: "expected 11 to be at most 10", + }; + const eqNegativeFailureCase: Omit = { + operands: [10, 10], + msg: "expected 10 to not equal 10", + }; + const ltNegativeFailureCase: Omit = { + operands: [10, 11], + msg: "expected 10 to be at least 11", + }; + const gteNegativeFailureCase: Omit = { + operands: [11, 10], + msg: "expected 11 to be below 10", + }; + const lteNegativeFailureCase: Omit = { + operands: [10, 11], + msg: "expected 10 to be above 11", + }; + const negativeFailureCases: FailureCase[] = [ + { ...eqNegativeFailureCase, operator: "eq" }, + { ...eqNegativeFailureCase, operator: "equal" }, + { ...eqNegativeFailureCase, operator: "equals" }, + { ...gtNegativeFailureCase, operator: "above" }, + { ...gtNegativeFailureCase, operator: "gt" }, + { ...gtNegativeFailureCase, operator: "greaterThan" }, + { ...ltNegativeFailureCase, operator: "below" }, + { ...ltNegativeFailureCase, operator: "lt" }, + { ...ltNegativeFailureCase, operator: "lessThan" }, + { ...gteNegativeFailureCase, operator: "least" }, + { ...gteNegativeFailureCase, operator: "gte" }, + { ...gteNegativeFailureCase, operator: "greaterThanOrEqual" }, + { ...lteNegativeFailureCase, operator: "most" }, + { ...lteNegativeFailureCase, operator: "lte" }, + { ...lteNegativeFailureCase, operator: "lessThanOrEqual" }, + ]; + for (const { operator, operands, msg } of negativeFailureCases) { + describe("should throw the proper message on failure", function () { + checkAll(operands[0], operands[1], (a, b) => { + it(`with ${typestr(a)} and ${typestr(b)}`, function () { + expect(() => expect(a).not.to[operator](b)).to.throw( + AssertionError, + msg + ); + }); + }); + }); + } + + operators.forEach((operator: Operator) => { + describe("should throw when comparing to a non-integral floating point literal", function () { + for (const convert of numberToBigNumberConversions) { + const converted = convert(1); + const msg = + "HH17: The input value cannot be normalized to a BigInt: 1.1 is not an integer"; + it(`with .to.${operator} comparing float vs ${typestr( + converted + )}`, function () { + expect(() => expect(1.1).to[operator](converted)).to.throw( + HardhatError, + msg + ); + }); + it(`with .to.${operator} comparing ${typestr( + converted + )} vs float`, function () { + expect(() => expect(converted).to[operator](1.1)).to.throw( + HardhatError, + msg + ); + }); + it(`with .not.to.${operator} comparing float vs ${typestr( + converted + )}`, function () { + expect(() => expect(1.1).not.to[operator](converted)).to.throw( + HardhatError, + msg + ); + }); + it(`with .not.to.${operator} comparing ${typestr( + converted + )} vs float`, function () { + expect(() => expect(converted).not.to[operator](1.1)).to.throw( + HardhatError, + msg + ); + }); + } + }); + + describe("should throw when comparing to an unsafe integer", function () { + const unsafeInt = 1e16; + const msg = `HH17: The input value cannot be normalized to a BigInt: Integer 10000000000000000 is unsafe. Consider using ${unsafeInt}n instead. For more details, see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/isSafeInteger`; + + describe(`when using .to.${operator}`, function () { + it("with an unsafe int as the first param", function () { + expect(() => expect(unsafeInt).to[operator](1n)).to.throw( + HardhatError, + msg + ); + }); + it("with an unsafe int as the second param", function () { + expect(() => expect(1n).to[operator](unsafeInt)).to.throw( + HardhatError, + msg + ); + }); + }); + + describe(`when using .not.to.${operator}`, function () { + it("with an unsafe int as the first param", function () { + expect(() => expect(unsafeInt).not.to[operator](1n)).to.throw( + HardhatError, + msg + ); + }); + it("with an unsafe int as the second param", function () { + expect(() => expect(1n).not.to[operator](unsafeInt)).to.throw( + HardhatError, + msg + ); + }); + }); + }); + }); + + describe("deep equal", function () { + checkAll(1, 1, (a, b) => { + it(`should work with ${typestr(a)} and ${typestr(b)}`, function () { + // successful assertions + expect([a]).to.deep.equal([b]); + expect([[a], [a]]).to.deep.equal([[b], [b]]); + expect({ x: a }).to.deep.equal({ x: b }); + expect({ x: { y: a } }).to.deep.equal({ x: { y: b } }); + expect({ x: [a] }).to.deep.equal({ x: [b] }); + + // failed assertions + + // We are not checking the content of the arrays/objects because + // it depends on the type of the numbers (plain numbers, native + // bigints) + // Ideally the output would be normalized and we could check the + // actual content more easily. + + expect(() => expect([a]).to.not.deep.equal([b])).to.throw( + AssertionError, + // the 's' modifier is used to make . match newlines too + /expected \[.*\] to not deeply equal \[.*\]/s + ); + expect(() => + expect([[a], [a]]).to.not.deep.equal([[b], [b]]) + ).to.throw( + AssertionError, + /expected \[.*\] to not deeply equal \[.*\]/s + ); + expect(() => expect({ x: a }).to.not.deep.equal({ x: b })).to.throw( + AssertionError, + /expected \{.*\} to not deeply equal \{.*\}/s + ); + expect(() => + expect({ x: { y: a } }).to.not.deep.equal({ x: { y: b } }) + ).to.throw( + AssertionError, + /expected \{.*\} to not deeply equal \{.*\}/s + ); + expect(() => + expect({ x: [a] }).to.not.deep.equal({ x: [b] }) + ).to.throw( + AssertionError, + /expected \{.*\} to not deeply equal \{.*\}/s + ); + }); + }); + + checkAll(1, 2, (a, b) => { + it(`should work with ${typestr(a)} and ${typestr( + b + )} (negative)`, function () { + // successful assertions + expect([a]).to.not.deep.equal([b]); + expect([[a], [a]]).to.not.deep.equal([[b], [b]]); + expect({ x: a }).to.not.deep.equal({ x: b }); + expect({ x: { y: a } }).to.not.deep.equal({ x: { y: b } }); + expect({ x: [a] }).to.not.deep.equal({ x: [b] }); + + // failed assertions + expect(() => expect([a]).to.deep.equal([b])).to.throw( + AssertionError, + // the 's' modifier is used to make . match newlines too + /expected \[.*\] to deeply equal \[.*\]/s + ); + expect(() => expect([[a], [a]]).to.deep.equal([[b], [b]])).to.throw( + AssertionError, + /expected \[.*\] to deeply equal \[.*\]/s + ); + expect(() => expect({ x: a }).to.deep.equal({ x: b })).to.throw( + AssertionError, + /expected \{.*\} to deeply equal \{.*\}/s + ); + expect(() => + expect({ x: { y: a } }).to.deep.equal({ x: { y: b } }) + ).to.throw(AssertionError, /expected \{.*\} to deeply equal \{.*\}/s); + expect(() => expect({ x: [a] }).to.deep.equal({ x: [b] })).to.throw( + AssertionError, + /expected \{.*\} to deeply equal \{.*\}/s + ); + }); + }); + }); + }); + + describe("with three arguments", function () { + function checkAll( + a: number, + b: number, + c: number, + test: (a: SupportedNumber, b: SupportedNumber, c: SupportedNumber) => void + ) { + const conversions = [(n: number) => n, ...numberToBigNumberConversions]; + for (const convertA of conversions) { + for (const convertB of conversions) { + for (const convertC of conversions) { + test(convertA(a), convertB(b), convertC(c)); + } + } + } + } + + const operators = ["within", "closeTo", "approximately"] as const; + type Operator = typeof operators[number]; + + interface SuccessCase { + operator: Operator; + operands: [number, number, number]; + } + + interface FailureCase extends SuccessCase { + msg: string; + } + + const positiveSuccessCases: SuccessCase[] = [ + { operator: "within", operands: [100, 99, 101] }, + { operator: "closeTo", operands: [101, 101, 10] }, + { operator: "approximately", operands: [101, 101, 10] }, + ]; + for (const { operator, operands } of positiveSuccessCases) { + describe(`.to.be.${operator}`, function () { + checkAll(operands[0], operands[1], operands[2], (a, b, c) => { + it(`should work with ${typestr(a)}, ${typestr(b)} and ${typestr( + c + )}`, function () { + expect(a).to.be[operator](b, c); + }); + }); + }); + } + + const positiveFailureCases: FailureCase[] = [ + { + operator: "within", + operands: [100, 80, 90], + msg: "expected 100 to be within 80..90", + }, + { + operator: "closeTo", + operands: [100, 111, 10], + msg: "expected 100 to be close to 111 +/- 10", + }, + { + operator: "approximately", + operands: [100, 111, 10], + msg: "expected 100 to be close to 111 +/- 10", + }, + ]; + for (const { operator, operands, msg } of positiveFailureCases) { + describe(`.to.be.${operator} should throw the proper message on failure`, function () { + checkAll(operands[0], operands[1], operands[2], (a, b, c) => { + it(`with ${typestr(a)}, ${typestr(b)} and ${typestr( + c + )}`, function () { + expect(() => expect(a).to.be[operator](b, c)).to.throw( + AssertionError, + msg + ); + }); + }); + }); + } + + const closeToAndApproximately: Operator[] = ["closeTo", "approximately"]; + for (const closeToOrApproximately of closeToAndApproximately) { + describe(`${closeToOrApproximately} with an undefined delta argument`, function () { + for (const convert of [ + (n: number) => n, + ...numberToBigNumberConversions, + ]) { + const one = convert(1); + it(`with a ${typestr( + one + )} actual should throw a helpful error message`, function () { + expect(() => + expect(one).to.be[closeToOrApproximately](100, undefined) + ).to.throw( + AssertionError, + "the arguments to closeTo or approximately must be numbers, and a delta is required" + ); + }); + } + }); + } + + const negativeSuccessCases: SuccessCase[] = [ + { operator: "within", operands: [100, 101, 102] }, + { operator: "within", operands: [100, 98, 99] }, + { operator: "closeTo", operands: [100, 111, 10] }, + { operator: "approximately", operands: [100, 111, 10] }, + ]; + for (const { operator, operands } of negativeSuccessCases) { + describe(`.not.to.be.${operator}`, function () { + checkAll(operands[0], operands[1], operands[2], (a, b, c) => { + it(`should work with ${typestr(a)}, ${typestr(b)} and ${typestr( + c + )}`, function () { + expect(a).not.to.be[operator](b, c); + }); + }); + }); + } + + const negativeFailureCases: FailureCase[] = [ + { + operator: "within", + operands: [100, 99, 101], + msg: "expected 100 to not be within 99..101", + }, + { + operator: "closeTo", + operands: [100, 101, 10], + msg: "expected 100 not to be close to 101 +/- 10", + }, + { + operator: "approximately", + operands: [100, 101, 10], + msg: "expected 100 not to be close to 101 +/- 10", + }, + ]; + for (const { operator, operands, msg } of negativeFailureCases) { + describe(`.not.to.be.${operator} should throw the proper message on failure`, function () { + checkAll(operands[0], operands[1], operands[2], (a, b, c) => { + it(`with ${typestr(a)}, ${typestr(b)} and ${typestr( + c + )}`, function () { + expect(() => expect(a).not.to.be[operator](b, c)).to.throw( + AssertionError, + msg + ); + }); + }); + }); + } + + operators.forEach((operator: Operator) => { + describe(`should throw when comparing to a non-integral floating point literal`, function () { + for (const convertA of numberToBigNumberConversions) { + for (const convertB of numberToBigNumberConversions) { + const a = convertA(1); + const b = convertB(1); + const msg = + "HH17: The input value cannot be normalized to a BigInt: 1.1 is not an integer"; + describe(`with .to.${operator}`, function () { + it(`with float, ${typestr(a)}, ${typestr(a)}`, function () { + expect(() => expect(1.1).to[operator](a, b)).to.throw( + HardhatError, + msg + ); + }); + it(`with ${typestr(a)}, float, ${typestr(b)}`, function () { + expect(() => expect(a).to[operator](1.1, b)).to.throw( + HardhatError, + msg + ); + }); + it(`with ${typestr(a)}, ${typestr(b)}, float`, function () { + expect(() => expect(a).to[operator](b, 1.1)).to.throw( + HardhatError, + msg + ); + }); + }); + describe(`with not.to.${operator}`, function () { + it(`with float, ${typestr(a)}, ${typestr(a)}`, function () { + expect(() => expect(1.1).not.to[operator](a, b)).to.throw( + HardhatError, + msg + ); + }); + it(`with ${typestr(a)}, float, ${typestr(b)}`, function () { + expect(() => expect(a).not.to[operator](1.1, b)).to.throw( + HardhatError, + msg + ); + }); + it(`with ${typestr(a)}, ${typestr(b)}, float`, function () { + expect(() => expect(a).not.to[operator](b, 1.1)).to.throw( + HardhatError, + msg + ); + }); + }); + } + } + }); + + describe("should throw when comparing to an unsafe integer", function () { + const unsafeInt = 1e16; + const msg = `HH17: The input value cannot be normalized to a BigInt: Integer 10000000000000000 is unsafe. Consider using ${unsafeInt}n instead. For more details, see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/isSafeInteger`; + + describe(`when using .to.${operator}`, function () { + it("with an unsafe int as the first param", function () { + expect(() => expect(unsafeInt).to[operator](1n, 1n)).to.throw( + HardhatError, + msg + ); + }); + it("with an unsafe int as the second param", function () { + expect(() => expect(1n).to[operator](unsafeInt, 1n)).to.throw( + HardhatError, + msg + ); + }); + it("with an unsafe int as the third param", function () { + expect(() => expect(1n).to[operator](1n, unsafeInt)).to.throw( + HardhatError, + msg + ); + }); + }); + + describe(`when using not.to.${operator}`, function () { + it("with an unsafe int as the first param", function () { + expect(() => expect(unsafeInt).not.to[operator](1n, 1n)).to.throw( + HardhatError, + msg + ); + }); + it("with an unsafe int as the second param", function () { + expect(() => expect(1n).not.to[operator](unsafeInt, 1n)).to.throw( + HardhatError, + msg + ); + }); + it("with an unsafe int as the third param", function () { + expect(() => expect(1n).not.to[operator](1n, unsafeInt)).to.throw( + HardhatError, + msg + ); + }); + }); + }); + }); + }); + + it("custom message is preserved", function () { + // normal numbers + expect(() => expect(1).to.equal(2, "custom message")).to.throw( + AssertionError, + "custom message" + ); + + // number and bigint + expect(() => expect(1).to.equal(2n, "custom message")).to.throw( + AssertionError, + "custom message" + ); + + // same but for deep comparisons + expect(() => expect([1]).to.equal([2], "custom message")).to.throw( + AssertionError, + "custom message" + ); + + // number and bigint + expect(() => expect([1]).to.equal([2n], "custom message")).to.throw( + AssertionError, + "custom message" + ); + }); +}); diff --git a/packages/hardhat-chai-matchers-viem/test/changeEtherBalance.ts b/packages/hardhat-chai-matchers-viem/test/changeEtherBalance.ts new file mode 100644 index 0000000000..f368d3e72b --- /dev/null +++ b/packages/hardhat-chai-matchers-viem/test/changeEtherBalance.ts @@ -0,0 +1,630 @@ +import type { Token } from "../src/internal/changeTokenBalance"; +import type { HardhatEthersSigner } from "@nomicfoundation/hardhat-ethers/signers"; +import type { ChangeEtherBalance } from "./contracts"; + +import { expect, AssertionError } from "chai"; +import path from "path"; +import util from "util"; + +import "../src/internal/add-chai-matchers"; +import { useEnvironment, useEnvironmentWithNode } from "./helpers"; + +describe("INTEGRATION: changeEtherBalance matcher", function () { + describe("with the in-process hardhat network", function () { + useEnvironment("hardhat-project"); + + runTests(); + }); + + // TODO re-enable this when + // https://github.com/ethers-io/ethers.js/issues/4014 is fixed + describe.skip("connected to a hardhat node", function () { + useEnvironmentWithNode("hardhat-project"); + + runTests(); + }); + + function runTests() { + let sender: HardhatEthersSigner; + let receiver: HardhatEthersSigner; + let contract: ChangeEtherBalance; + let txGasFees: number; + let mockToken: Token; + + beforeEach(async function () { + const wallets = await this.hre.ethers.getSigners(); + sender = wallets[0]; + receiver = wallets[1]; + contract = await ( + await this.hre.ethers.getContractFactory<[], ChangeEtherBalance>( + "ChangeEtherBalance" + ) + ).deploy(); + txGasFees = 1 * 21_000; + await this.hre.network.provider.send( + "hardhat_setNextBlockBaseFeePerGas", + ["0x0"] + ); + + const MockToken = await this.hre.ethers.getContractFactory<[], Token>( + "MockToken" + ); + mockToken = await MockToken.deploy(); + }); + + describe("Transaction Callback (legacy tx)", () => { + describe("Change balance, one account", () => { + it("Should pass when expected balance change is passed as string and is equal to an actual", async () => { + await expect(() => + sender.sendTransaction({ + to: receiver.address, + value: 200, + }) + ).to.changeEtherBalance(sender, "-200"); + }); + + it("Should fail when block contains more than one transaction", async function () { + await this.hre.network.provider.send("evm_setAutomine", [false]); + + // we set a gas limit to avoid using the whole block gas limit + await sender.sendTransaction({ + to: receiver.address, + value: 200, + gasLimit: 30_000, + }); + + await this.hre.network.provider.send("evm_setAutomine", [true]); + + await expect( + expect(() => + sender.sendTransaction({ + to: receiver.address, + value: 200, + gasLimit: 30_000, + }) + ).to.changeEtherBalance(sender, -200, { includeFee: true }) + ).to.be.eventually.rejectedWith( + Error, + "Multiple transactions found in block" + ); + }); + + it("Should pass when given an address as a string", async () => { + await expect(() => + sender.sendTransaction({ + to: receiver.address, + value: 200, + }) + ).to.changeEtherBalance(sender.address, "-200"); + }); + + it("Should pass when given a native bigint", async () => { + await expect(() => + sender.sendTransaction({ + to: receiver.address, + value: 200, + }) + ).to.changeEtherBalance(sender, -200n); + }); + + it("Should pass when given a predicate", async () => { + await expect(() => + sender.sendTransaction({ + to: receiver.address, + value: 200, + }) + ).to.changeEtherBalance(sender, (diff: bigint) => diff === -200n); + }); + + it("Should pass when expected balance change is passed as int and is equal to an actual", async () => { + await expect(() => + sender.sendTransaction({ + to: receiver.address, + value: 200, + }) + ).to.changeEtherBalance(receiver, 200); + }); + + it("Should take into account transaction fee", async () => { + await expect(() => + sender.sendTransaction({ + to: receiver.address, + gasPrice: 1, + value: 200, + }) + ).to.changeEtherBalance(sender, -(txGasFees + 200), { + includeFee: true, + }); + }); + + it("Should take into account transaction fee when given a predicate", async () => { + await expect(() => + sender.sendTransaction({ + to: receiver.address, + gasPrice: 1, + value: 200, + }) + ).to.changeEtherBalance( + sender, + (diff: bigint) => diff === -(BigInt(txGasFees) + 200n), + { + includeFee: true, + } + ); + }); + + it("Should ignore fee if receiver's wallet is being checked and includeFee was set", async () => { + await expect(() => + sender.sendTransaction({ + to: receiver.address, + gasPrice: 1, + value: 200, + }) + ).to.changeEtherBalance(receiver, 200, { includeFee: true }); + }); + + it("Should take into account transaction fee by default", async () => { + await expect(() => + sender.sendTransaction({ + to: receiver.address, + gasPrice: 1, + value: 200, + }) + ).to.changeEtherBalance(sender, -200); + }); + + it("Should pass on negative case when expected balance does not satisfy the predicate", async () => { + await expect(() => + sender.sendTransaction({ + to: receiver.address, + value: 200, + }) + ).to.not.changeEtherBalance( + receiver, + (diff: bigint) => diff === 300n + ); + }); + + it("Should throw when fee was not calculated correctly", async () => { + await expect( + expect(() => + sender.sendTransaction({ + to: receiver.address, + gasPrice: 1, + value: 200, + }) + ).to.changeEtherBalance(sender, -200, { includeFee: true }) + ).to.be.eventually.rejectedWith( + AssertionError, + `Expected the ether balance of "${ + sender.address + }" to change by -200 wei, but it changed by -${txGasFees + 200} wei` + ); + }); + + it("Should throw when expected balance change value was different from an actual", async () => { + await expect( + expect(() => + sender.sendTransaction({ + to: receiver.address, + value: 200, + }) + ).to.changeEtherBalance(sender, "-500") + ).to.be.eventually.rejectedWith( + AssertionError, + `Expected the ether balance of "${sender.address}" to change by -500 wei, but it changed by -200 wei` + ); + }); + + it("Should throw when actual balance change value does not satisfy the predicate", async () => { + await expect( + expect(() => + sender.sendTransaction({ + to: receiver.address, + value: 200, + }) + ).to.changeEtherBalance(sender, (diff: bigint) => diff === -500n) + ).to.be.eventually.rejectedWith( + AssertionError, + `Expected the ether balance change of "${sender.address}" to satisfy the predicate, but it didn't (balance change: -200 wei)` + ); + }); + + it("Should throw in negative case when expected balance change value was equal to an actual", async () => { + await expect( + expect(() => + sender.sendTransaction({ + to: receiver.address, + value: 200, + }) + ).to.not.changeEtherBalance(sender, "-200") + ).to.be.eventually.rejectedWith( + AssertionError, + `Expected the ether balance of "${sender.address}" NOT to change by -200 wei, but it did` + ); + }); + + it("Should throw in negative case when expected balance change value satisfies the predicate", async () => { + await expect( + expect(() => + sender.sendTransaction({ + to: receiver.address, + value: 200, + }) + ).to.not.changeEtherBalance( + sender, + (diff: bigint) => diff === -200n + ) + ).to.be.eventually.rejectedWith( + AssertionError, + `Expected the ether balance change of "${sender.address}" to NOT satisfy the predicate, but it did (balance change: -200 wei)` + ); + }); + + it("Should pass when given zero value tx", async () => { + await expect(() => + sender.sendTransaction({ to: receiver.address, value: 0 }) + ).to.changeEtherBalance(sender, 0); + }); + + it("shouldn't run the transaction twice", async function () { + const receiverBalanceBefore: bigint = + await this.hre.ethers.provider.getBalance(receiver); + + await expect(() => + sender.sendTransaction({ + to: receiver.address, + value: 200, + }) + ).to.changeEtherBalance(sender, -200); + + const receiverBalanceAfter: bigint = + await this.hre.ethers.provider.getBalance(receiver); + const receiverBalanceChange = + receiverBalanceAfter - receiverBalanceBefore; + + expect(receiverBalanceChange).to.equal(200n); + }); + }); + + describe("Change balance, one contract", () => { + it("Should pass when expected balance change is passed as int and is equal to an actual", async () => { + await expect(async () => + sender.sendTransaction({ + to: contract, + value: 200, + }) + ).to.changeEtherBalance(contract, 200); + }); + + it("should pass when calling function that returns half the sent ether", async () => { + await expect(async () => + contract.returnHalf({ value: 200 }) + ).to.changeEtherBalance(sender, -100); + }); + }); + }); + + describe("Transaction Callback (1559 tx)", () => { + describe("Change balance, one account", () => { + it("Should pass when expected balance change is passed as string and is equal to an actual", async () => { + await expect(() => + sender.sendTransaction({ + to: receiver.address, + maxFeePerGas: 2, + maxPriorityFeePerGas: 1, + value: 200, + }) + ).to.changeEtherBalance(sender, "-200"); + }); + + it("Should pass when expected balance change is passed as int and is equal to an actual", async () => { + await expect(() => + sender.sendTransaction({ + to: receiver.address, + maxFeePerGas: 2, + maxPriorityFeePerGas: 1, + value: 200, + }) + ).to.changeEtherBalance(receiver, 200); + }); + + it("Should take into account transaction fee", async () => { + await expect(() => + sender.sendTransaction({ + to: receiver.address, + maxFeePerGas: 2, + maxPriorityFeePerGas: 1, + value: 200, + }) + ).to.changeEtherBalance(sender, -(txGasFees + 200), { + includeFee: true, + }); + }); + + it("Should ignore fee if receiver's wallet is being checked and includeFee was set", async () => { + await expect(() => + sender.sendTransaction({ + to: receiver.address, + maxFeePerGas: 2, + maxPriorityFeePerGas: 1, + value: 200, + }) + ).to.changeEtherBalance(receiver, 200, { includeFee: true }); + }); + + it("Should take into account transaction fee by default", async () => { + await expect(() => + sender.sendTransaction({ + to: receiver.address, + maxFeePerGas: 2, + maxPriorityFeePerGas: 1, + value: 200, + }) + ).to.changeEtherBalance(sender, -200); + }); + + it("Should throw when fee was not calculated correctly", async () => { + await expect( + expect(() => + sender.sendTransaction({ + to: receiver.address, + maxFeePerGas: 2, + maxPriorityFeePerGas: 1, + value: 200, + }) + ).to.changeEtherBalance(sender, -200, { includeFee: true }) + ).to.be.eventually.rejectedWith( + AssertionError, + `Expected the ether balance of "${ + sender.address + }" to change by -200 wei, but it changed by -${txGasFees + 200} wei` + ); + }); + + it("Should throw when expected balance change value was different from an actual", async () => { + await expect( + expect(() => + sender.sendTransaction({ + to: receiver.address, + maxFeePerGas: 2, + maxPriorityFeePerGas: 1, + value: 200, + }) + ).to.changeEtherBalance(sender, "-500") + ).to.be.eventually.rejectedWith( + AssertionError, + `Expected the ether balance of "${sender.address}" to change by -500 wei, but it changed by -200 wei` + ); + }); + + it("Should throw in negative case when expected balance change value was equal to an actual", async () => { + await expect( + expect(() => + sender.sendTransaction({ + to: receiver.address, + maxFeePerGas: 2, + maxPriorityFeePerGas: 1, + value: 200, + }) + ).to.not.changeEtherBalance(sender, "-200") + ).to.be.eventually.rejectedWith( + AssertionError, + `Expected the ether balance of "${sender.address}" NOT to change by -200 wei, but it did` + ); + }); + }); + + describe("Change balance, one contract", () => { + it("Should pass when expected balance change is passed as int and is equal to an actual", async () => { + await expect(async () => + sender.sendTransaction({ + to: contract, + maxFeePerGas: 2, + maxPriorityFeePerGas: 1, + value: 200, + }) + ).to.changeEtherBalance(contract, 200); + }); + + it("Should take into account transaction fee", async function () { + const tx = { + to: contract, + maxFeePerGas: 2, + maxPriorityFeePerGas: 1, + value: 200, + }; + + const gas: bigint = await this.hre.ethers.provider.estimateGas(tx); + + await expect(() => sender.sendTransaction(tx)).to.changeEtherBalance( + sender, + -(gas + 200n), + { + includeFee: true, + } + ); + }); + + it("should pass when calling function that returns half the sent ether", async () => { + await expect(async () => + contract.returnHalf({ + value: 200, + maxFeePerGas: 2, + maxPriorityFeePerGas: 1, + }) + ).to.changeEtherBalance(sender, -100); + }); + }); + + it("shouldn't run the transaction twice", async function () { + const receiverBalanceBefore: bigint = + await this.hre.ethers.provider.getBalance(receiver); + + await expect(() => + sender.sendTransaction({ + to: receiver.address, + maxFeePerGas: 2, + maxPriorityFeePerGas: 1, + value: 200, + }) + ).to.changeEtherBalance(sender, -200); + + const receiverBalanceAfter: bigint = + await this.hre.ethers.provider.getBalance(receiver); + const receiverBalanceChange = + receiverBalanceAfter - receiverBalanceBefore; + + expect(receiverBalanceChange).to.equal(200n); + }); + }); + + describe("Transaction Response", () => { + describe("Change balance, one account", () => { + it("Should pass when expected balance change is passed as string and is equal to an actual", async () => { + await expect( + await sender.sendTransaction({ + to: receiver.address, + value: 200, + }) + ).to.changeEtherBalance(sender, "-200"); + }); + + it("Should pass when expected balance change is passed as int and is equal to an actual", async () => { + await expect( + await sender.sendTransaction({ + to: receiver.address, + value: 200, + }) + ).to.changeEtherBalance(receiver, 200); + }); + + it("Should throw when expected balance change value was different from an actual", async () => { + await expect( + expect( + await sender.sendTransaction({ + to: receiver.address, + value: 200, + }) + ).to.changeEtherBalance(sender, "-500") + ).to.be.eventually.rejectedWith( + AssertionError, + `Expected the ether balance of "${sender.address}" to change by -500 wei, but it changed by -200 wei` + ); + }); + + it("Should throw in negative case when expected balance change value was equal to an actual", async () => { + await expect( + expect( + await sender.sendTransaction({ + to: receiver.address, + value: 200, + }) + ).to.not.changeEtherBalance(sender, "-200") + ).to.be.eventually.rejectedWith( + AssertionError, + `Expected the ether balance of "${sender.address}" NOT to change by -200 wei, but it did` + ); + }); + }); + + describe("Change balance, one contract", () => { + it("Should pass when expected balance change is passed as int and is equal to an actual", async () => { + await expect( + await sender.sendTransaction({ + to: contract, + value: 200, + }) + ).to.changeEtherBalance(contract, 200); + }); + }); + }); + + describe("Transaction Promise", () => { + describe("Change balance, one account", () => { + it("Should pass when expected balance change is passed as string and is equal to an actual", async () => { + await expect( + sender.sendTransaction({ + to: receiver.address, + value: 200, + }) + ).to.changeEtherBalance(sender, "-200"); + }); + + it("Should pass when expected balance change is passed as int and is equal to an actual", async () => { + await expect( + sender.sendTransaction({ + to: receiver.address, + value: 200, + }) + ).to.changeEtherBalance(receiver, 200); + }); + + it("Should throw when expected balance change value was different from an actual", async () => { + await expect( + expect( + sender.sendTransaction({ + to: receiver.address, + value: 200, + }) + ).to.changeEtherBalance(sender, "-500") + ).to.be.eventually.rejectedWith( + AssertionError, + `Expected the ether balance of "${sender.address}" to change by -500 wei, but it changed by -200 wei` + ); + }); + + it("Should throw in negative case when expected balance change value was equal to an actual", async () => { + await expect( + expect( + sender.sendTransaction({ + to: receiver.address, + value: 200, + }) + ).to.not.changeEtherBalance(sender, "-200") + ).to.be.eventually.rejectedWith( + AssertionError, + `Expected the ether balance of "${sender.address}" NOT to change by -200 wei, but it did` + ); + }); + + it("Should throw if chained to another non-chainable method", () => { + expect(() => + expect( + sender.sendTransaction({ + to: receiver.address, + value: 200, + }) + ) + .to.changeTokenBalance(mockToken, receiver, 50) + .and.to.changeEtherBalance(sender, "-200") + ).to.throw( + /The matcher 'changeEtherBalance' cannot be chained after 'changeTokenBalance'./ + ); + }); + }); + }); + + describe("stack traces", function () { + // smoke test for stack traces + it("includes test file", async function () { + try { + await expect(() => + sender.sendTransaction({ + to: receiver.address, + value: 200, + }) + ).to.changeEtherBalance(sender, -100); + } catch (e: any) { + expect(util.inspect(e)).to.include( + path.join("test", "changeEtherBalance.ts") + ); + + return; + } + + expect.fail("Expected an exception but none was thrown"); + }); + }); + } +}); diff --git a/packages/hardhat-chai-matchers-viem/test/changeEtherBalances.ts b/packages/hardhat-chai-matchers-viem/test/changeEtherBalances.ts new file mode 100644 index 0000000000..f5a7a4156b --- /dev/null +++ b/packages/hardhat-chai-matchers-viem/test/changeEtherBalances.ts @@ -0,0 +1,470 @@ +import type { Token } from "../src/internal/changeTokenBalance"; +import type { HardhatEthersSigner } from "@nomicfoundation/hardhat-ethers/signers"; +import type { ChangeEtherBalance } from "./contracts"; + +import { expect, AssertionError } from "chai"; +import path from "path"; +import util from "util"; + +import "../src/internal/add-chai-matchers"; +import { useEnvironment, useEnvironmentWithNode } from "./helpers"; + +describe("INTEGRATION: changeEtherBalances matcher", function () { + describe("with the in-process hardhat network", function () { + useEnvironment("hardhat-project"); + + runTests(); + }); + + describe("connected to a hardhat node", function () { + process.env.CHAIN_ID = "12345"; + useEnvironmentWithNode("hardhat-project"); + + runTests(); + }); + + function runTests() { + let sender: HardhatEthersSigner; + let receiver: HardhatEthersSigner; + let contract: ChangeEtherBalance; + let txGasFees: number; + let mockToken: Token; + + beforeEach(async function () { + const wallets = await this.hre.ethers.getSigners(); + sender = wallets[0]; + receiver = wallets[1]; + contract = await ( + await this.hre.ethers.getContractFactory<[], ChangeEtherBalance>( + "ChangeEtherBalance" + ) + ).deploy(); + txGasFees = 1 * 21_000; + await this.hre.network.provider.send( + "hardhat_setNextBlockBaseFeePerGas", + ["0x0"] + ); + + const MockToken = await this.hre.ethers.getContractFactory<[], Token>( + "MockToken" + ); + mockToken = await MockToken.deploy(); + }); + + describe("Transaction Callback", () => { + describe("Change balances, one account, one contract", () => { + it("Should pass when all expected balance changes are equal to actual values", async () => { + await expect(() => + sender.sendTransaction({ + to: contract, + value: 200, + }) + ).to.changeEtherBalances([sender, contract], [-200, 200]); + }); + }); + + describe("Change balances, contract forwards ether sent", () => { + it("Should pass when contract function forwards all tx ether", async () => { + await expect(() => + contract.transferTo(receiver.address, { value: 200 }) + ).to.changeEtherBalances( + [sender, contract, receiver], + [-200, 0, 200] + ); + }); + }); + + describe("Change balance, multiple accounts", () => { + it("Should pass when all expected balance changes are equal to actual values", async () => { + await expect(() => + sender.sendTransaction({ + to: receiver.address, + gasPrice: 1, + value: 200, + }) + ).to.changeEtherBalances([sender, receiver], ["-200", 200]); + }); + + it("Should pass when given addresses as strings", async () => { + await expect(() => + sender.sendTransaction({ + to: receiver.address, + gasPrice: 1, + value: 200, + }) + ).to.changeEtherBalances( + [sender.address, receiver.address], + ["-200", 200] + ); + }); + + it("Should pass when given native BigInt", async () => { + await expect(() => + sender.sendTransaction({ + to: receiver.address, + gasPrice: 1, + value: 200, + }) + ).to.changeEtherBalances([sender, receiver], [-200n, 200n]); + }); + + it("Should pass when given a predicate", async () => { + await expect(() => + sender.sendTransaction({ + to: receiver.address, + gasPrice: 1, + value: 200, + }) + ).to.changeEtherBalances( + [sender, receiver], + ([senderDiff, receiverDiff]: bigint[]) => + senderDiff === -200n && receiverDiff === 200n + ); + }); + + it("Should fail when the predicate returns false", async () => { + await expect( + expect(() => + sender.sendTransaction({ + to: receiver.address, + gasPrice: 1, + value: 200, + }) + ).to.changeEtherBalances( + [sender, receiver], + ([senderDiff, receiverDiff]: bigint[]) => + senderDiff === -201n && receiverDiff === 200n + ) + ).to.be.eventually.rejectedWith( + AssertionError, + "Expected the balance changes of the accounts to satisfy the predicate, but they didn't" + ); + }); + + it("Should fail when the predicate returns true and the assertion is negated", async () => { + await expect( + expect(() => + sender.sendTransaction({ + to: receiver.address, + gasPrice: 1, + value: 200, + }) + ).to.not.changeEtherBalances( + [sender, receiver], + ([senderDiff, receiverDiff]: bigint[]) => + senderDiff === -200n && receiverDiff === 200n + ) + ).to.be.eventually.rejectedWith( + AssertionError, + "Expected the balance changes of the accounts to NOT satisfy the predicate, but they did" + ); + }); + + it("Should take into account transaction fee (legacy tx)", async () => { + await expect(() => + sender.sendTransaction({ + to: receiver.address, + gasPrice: 1, + value: 200, + }) + ).to.changeEtherBalances( + [sender, receiver, contract], + [-(txGasFees + 200), 200, 0], + { includeFee: true } + ); + }); + + it("Should take into account transaction fee (1559 tx)", async () => { + await expect(() => + sender.sendTransaction({ + to: receiver.address, + maxFeePerGas: 1, + maxPriorityFeePerGas: 1, + value: 200, + }) + ).to.changeEtherBalances( + [sender, receiver, contract], + [-(txGasFees + 200), 200, 0], + { includeFee: true } + ); + }); + + it("Should pass when given a single address", async () => { + await expect(() => + sender.sendTransaction({ to: receiver.address, value: 200 }) + ).to.changeEtherBalances([sender], [-200]); + }); + + it("Should pass when negated and numbers don't match", async () => { + await expect(() => + sender.sendTransaction({ + to: receiver.address, + gasPrice: 1, + value: 200, + }) + ).to.not.changeEtherBalances( + [sender, receiver], + [-(txGasFees + 201), 200] + ); + await expect(() => + sender.sendTransaction({ + to: receiver.address, + value: 200, + }) + ).to.not.changeEtherBalances([sender, receiver], [-200, 201], { + includeFee: true, + }); + }); + + it("Should throw when expected balance change value was different from an actual for any wallet", async () => { + await expect( + expect(() => + sender.sendTransaction({ + to: receiver.address, + gasPrice: 1, + value: 200, + }) + ).to.changeEtherBalances([sender, receiver], [-200, 201]) + ).to.be.eventually.rejectedWith( + AssertionError, + `Expected the ether balance of ${receiver.address} (the 2nd address in the list) to change by 201 wei, but it changed by 200 wei` + ); + await expect( + expect(() => + sender.sendTransaction({ + to: receiver.address, + gasPrice: 1, + value: 200, + }) + ).to.changeEtherBalances([sender, receiver], [-201, 200]) + ).to.be.eventually.rejectedWith( + AssertionError, + `Expected the ether balance of ${sender.address} (the 1st address in the list) to change by -201 wei, but it changed by -200 wei` + ); + }); + + it("Should throw in negative case when expected balance changes value were equal to an actual", async () => { + await expect( + expect(() => + sender.sendTransaction({ + to: receiver.address, + gasPrice: 1, + value: 200, + }) + ).to.not.changeEtherBalances([sender, receiver], [-200, 200]) + ).to.be.eventually.rejectedWith( + AssertionError, + `Expected the ether balance of ${sender.address} (the 1st address in the list) NOT to change by -200 wei` + ); + }); + + it("arrays have different length", async function () { + expect(() => + expect( + sender.sendTransaction({ + to: receiver.address, + gasPrice: 1, + value: 200, + }) + ).to.changeEtherBalances([sender], ["-200", 200]) + ).to.throw( + Error, + "The number of accounts (1) is different than the number of expected balance changes (2)" + ); + + expect(() => + expect( + sender.sendTransaction({ + to: receiver.address, + gasPrice: 1, + value: 200, + }) + ).to.changeEtherBalances([sender, receiver], ["-200"]) + ).to.throw( + Error, + "The number of accounts (2) is different than the number of expected balance changes (1)" + ); + }); + }); + + it("shouldn't run the transaction twice", async function () { + const receiverBalanceBefore = await this.hre.ethers.provider.getBalance( + receiver + ); + + await expect(() => + sender.sendTransaction({ + to: receiver.address, + gasPrice: 1, + value: 200, + }) + ).to.changeEtherBalances([sender, receiver], [-200, 200]); + + const receiverBalanceAfter = await this.hre.ethers.provider.getBalance( + receiver + ); + const receiverBalanceChange = + receiverBalanceAfter - receiverBalanceBefore; + + expect(receiverBalanceChange).to.equal(200n); + }); + }); + + describe("Transaction Response", () => { + describe("Change balances, one account, one contract", () => { + it("Should pass when all expected balance changes are equal to actual values", async () => { + await expect( + await sender.sendTransaction({ + to: contract, + value: 200, + }) + ).to.changeEtherBalances([sender, contract], [-200, 200]); + }); + }); + + it("Should throw if chained to another non-chainable method", () => { + expect(() => + expect( + sender.sendTransaction({ + to: contract, + value: 200, + }) + ) + .to.changeTokenBalances(mockToken, [sender, receiver], [-50, 100]) + .and.to.changeEtherBalances([sender, contract], [-200, 200]) + ).to.throw( + /The matcher 'changeEtherBalances' cannot be chained after 'changeTokenBalances'./ + ); + }); + + describe("Change balance, multiple accounts", () => { + it("Should pass when all expected balance changes are equal to actual values", async () => { + await expect( + await sender.sendTransaction({ + to: receiver.address, + gasPrice: 1, + value: 200, + }) + ).to.changeEtherBalances( + [sender, receiver], + [(-(txGasFees + 200)).toString(), 200], + { includeFee: true } + ); + }); + + it("Should take into account transaction fee", async () => { + await expect( + await sender.sendTransaction({ + to: receiver.address, + gasPrice: 1, + value: 200, + }) + ).to.changeEtherBalances( + [sender, receiver, contract], + [-(txGasFees + 200), 200, 0], + { includeFee: true } + ); + }); + + it("Should pass when negated and numbers don't match", async () => { + await expect( + await sender.sendTransaction({ + to: receiver.address, + value: 200, + }) + ).to.not.changeEtherBalances([sender, receiver], [-201, 200]); + + await expect( + await sender.sendTransaction({ + to: receiver.address, + value: 200, + }) + ).to.not.changeEtherBalances([sender, receiver], [-200, 201]); + }); + + it("Should throw when fee was not calculated correctly", async () => { + await expect( + expect( + await sender.sendTransaction({ + to: receiver.address, + gasPrice: 1, + value: 200, + }) + ).to.changeEtherBalances([sender, receiver], [-200, 200], { + includeFee: true, + }) + ).to.be.eventually.rejectedWith( + AssertionError, + `Expected the ether balance of ${ + sender.address + } (the 1st address in the list) to change by -200 wei, but it changed by -${ + txGasFees + 200 + } wei` + ); + }); + + it("Should throw when expected balance change value was different from an actual for any wallet", async () => { + await expect( + expect( + await sender.sendTransaction({ + to: receiver.address, + value: 200, + }) + ).to.changeEtherBalances([sender, receiver], [-200, 201]) + ).to.be.eventually.rejectedWith( + AssertionError, + `Expected the ether balance of ${receiver.address} (the 2nd address in the list) to change by 201 wei, but it changed by 200 wei` + ); + + await expect( + expect( + await sender.sendTransaction({ + to: receiver.address, + value: 200, + }) + ).to.changeEtherBalances([sender, receiver], [-201, 200]) + ).to.be.eventually.rejectedWith( + AssertionError, + `Expected the ether balance of ${sender.address} (the 1st address in the list) to change by -201 wei, but it changed by -200 wei` + ); + }); + + it("Should throw in negative case when expected balance changes value were equal to an actual", async () => { + await expect( + expect( + await sender.sendTransaction({ + to: receiver.address, + value: 200, + }) + ).to.not.changeEtherBalances([sender, receiver], [-200, 200]) + ).to.be.eventually.rejectedWith( + AssertionError, + `Expected the ether balance of ${sender.address} (the 1st address in the list) NOT to change by -200` + ); + }); + }); + }); + + describe("stack traces", function () { + // smoke test for stack traces + it("includes test file", async function () { + try { + await expect(() => + sender.sendTransaction({ + to: receiver.address, + value: 200, + }) + ).to.changeEtherBalances([sender, receiver], [-100, 100]); + } catch (e: any) { + expect(util.inspect(e)).to.include( + path.join("test", "changeEtherBalances.ts") + ); + + return; + } + + expect.fail("Expected an exception but none was thrown"); + }); + }); + } +}); diff --git a/packages/hardhat-chai-matchers-viem/test/changeTokenBalance.ts b/packages/hardhat-chai-matchers-viem/test/changeTokenBalance.ts new file mode 100644 index 0000000000..e05cba67a1 --- /dev/null +++ b/packages/hardhat-chai-matchers-viem/test/changeTokenBalance.ts @@ -0,0 +1,794 @@ +import type { TransactionResponse } from "ethers"; +import type { HardhatEthersSigner } from "@nomicfoundation/hardhat-ethers/signers"; +import type { Token } from "../src/internal/changeTokenBalance"; +import type { MatchersContract } from "./contracts"; + +import assert from "assert"; +import { AssertionError, expect } from "chai"; +import path from "path"; +import util from "util"; + +import "../src/internal/add-chai-matchers"; +import { clearTokenDescriptionsCache } from "../src/internal/changeTokenBalance"; +import { + CHANGE_TOKEN_BALANCE_MATCHER, + CHANGE_TOKEN_BALANCES_MATCHER, +} from "../src/internal/constants"; +import { useEnvironment, useEnvironmentWithNode } from "./helpers"; + +describe("INTEGRATION: changeTokenBalance and changeTokenBalances matchers", function () { + describe("with the in-process hardhat network", function () { + useEnvironment("hardhat-project"); + + runTests(); + }); + + describe("connected to a hardhat node", function () { + useEnvironmentWithNode("hardhat-project"); + + runTests(); + }); + + afterEach(function () { + clearTokenDescriptionsCache(); + }); + + function runTests() { + let sender: HardhatEthersSigner; + let receiver: HardhatEthersSigner; + let mockToken: Token; + let matchers: MatchersContract; + + beforeEach(async function () { + const wallets = await this.hre.ethers.getSigners(); + sender = wallets[0]; + receiver = wallets[1]; + + const MockToken = await this.hre.ethers.getContractFactory<[], Token>( + "MockToken" + ); + mockToken = await MockToken.deploy(); + + const Matchers = await this.hre.ethers.getContractFactory< + [], + MatchersContract + >("Matchers"); + matchers = await Matchers.deploy(); + }); + + describe("transaction that doesn't move tokens", () => { + it("with a promise of a TxResponse", async function () { + const transactionResponse = sender.sendTransaction({ + to: receiver.address, + }); + await runAllAsserts( + transactionResponse, + mockToken, + [sender, receiver], + [0, 0] + ); + }); + + it("with a TxResponse", async function () { + await runAllAsserts( + await sender.sendTransaction({ + to: receiver.address, + }), + mockToken, + [sender, receiver], + [0, 0] + ); + }); + + it("with a function that returns a promise of a TxResponse", async function () { + await runAllAsserts( + () => sender.sendTransaction({ to: receiver.address }), + mockToken, + [sender, receiver], + [0, 0] + ); + }); + + it("with a function that returns a TxResponse", async function () { + const txResponse = await sender.sendTransaction({ + to: receiver.address, + }); + await runAllAsserts( + () => txResponse, + mockToken, + [sender, receiver], + [0, 0] + ); + }); + + it("accepts addresses", async function () { + await expect( + sender.sendTransaction({ to: receiver.address }) + ).to.changeTokenBalance(mockToken, sender.address, 0); + + await expect(() => + sender.sendTransaction({ to: receiver.address }) + ).to.changeTokenBalances( + mockToken, + [sender.address, receiver.address], + [0, 0] + ); + + // mixing signers and addresses + await expect(() => + sender.sendTransaction({ to: receiver.address }) + ).to.changeTokenBalances(mockToken, [sender.address, receiver], [0, 0]); + }); + + it("negated", async function () { + await expect( + sender.sendTransaction({ to: receiver.address }) + ).to.not.changeTokenBalance(mockToken, sender, 1); + + await expect( + sender.sendTransaction({ to: receiver.address }) + ).to.not.changeTokenBalance( + mockToken, + sender, + (diff: bigint) => diff > 0n + ); + + await expect(() => + sender.sendTransaction({ to: receiver.address }) + ).to.not.changeTokenBalances(mockToken, [sender, receiver], [0, 1]); + + await expect(() => + sender.sendTransaction({ to: receiver.address }) + ).to.not.changeTokenBalances(mockToken, [sender, receiver], [1, 0]); + + await expect(() => + sender.sendTransaction({ to: receiver.address }) + ).to.not.changeTokenBalances(mockToken, [sender, receiver], [1, 1]); + }); + + describe("assertion failures", function () { + it("doesn't change balance as expected", async function () { + await expect( + expect( + sender.sendTransaction({ to: receiver.address }) + ).to.changeTokenBalance(mockToken, sender, 1) + ).to.be.rejectedWith( + AssertionError, + /Expected the balance of MCK tokens for "0x\w{40}" to change by 1, but it changed by 0/ + ); + }); + + it("change balance doesn't satisfies the predicate", async function () { + await expect( + expect( + sender.sendTransaction({ to: receiver.address }) + ).to.changeTokenBalance( + mockToken, + sender, + (diff: bigint) => diff > 0n + ) + ).to.be.rejectedWith( + AssertionError, + /Expected the balance of MCK tokens for "0x\w{40}" to satisfy the predicate, but it didn't \(token balance change: 0 wei\)/ + ); + }); + + it("changes balance in the way it was not expected", async function () { + await expect( + expect( + sender.sendTransaction({ to: receiver.address }) + ).to.not.changeTokenBalance(mockToken, sender, 0) + ).to.be.rejectedWith( + AssertionError, + /Expected the balance of MCK tokens for "0x\w{40}" NOT to change by 0, but it did/ + ); + }); + + it("changes balance doesn't have to satisfy the predicate, but it did", async function () { + await expect( + expect( + sender.sendTransaction({ to: receiver.address }) + ).to.not.changeTokenBalance( + mockToken, + sender, + (diff: bigint) => diff < 1n + ) + ).to.be.rejectedWith( + AssertionError, + /Expected the balance of MCK tokens for "0x\w{40}" to NOT satisfy the predicate, but it did \(token balance change: 0 wei\)/ + ); + }); + + it("the first account doesn't change its balance as expected", async function () { + await expect( + expect( + sender.sendTransaction({ to: receiver.address }) + ).to.changeTokenBalances(mockToken, [sender, receiver], [1, 0]) + ).to.be.rejectedWith(AssertionError); + }); + + it("the second account doesn't change its balance as expected", async function () { + await expect( + expect( + sender.sendTransaction({ to: receiver.address }) + ).to.changeTokenBalances(mockToken, [sender, receiver], [0, 1]) + ).to.be.rejectedWith(AssertionError); + }); + + it("neither account changes its balance as expected", async function () { + await expect( + expect( + sender.sendTransaction({ to: receiver.address }) + ).to.changeTokenBalances(mockToken, [sender, receiver], [1, 1]) + ).to.be.rejectedWith(AssertionError); + }); + + it("accounts change their balance in the way it was not expected", async function () { + await expect( + expect( + sender.sendTransaction({ to: receiver.address }) + ).to.not.changeTokenBalances(mockToken, [sender, receiver], [0, 0]) + ).to.be.rejectedWith(AssertionError); + }); + }); + }); + + describe("Transaction Callback", function () { + it("Should pass when given predicate", async () => { + await expect(() => + mockToken.transfer(receiver.address, 75) + ).to.changeTokenBalances( + mockToken, + [sender, receiver], + ([senderDiff, receiverDiff]: bigint[]) => + senderDiff === -75n && receiverDiff === 75n + ); + }); + + it("Should fail when the predicate returns false", async () => { + await expect( + expect( + mockToken.transfer(receiver.address, 75) + ).to.changeTokenBalances( + mockToken, + [sender, receiver], + ([senderDiff, receiverDiff]: bigint[]) => + senderDiff === -74n && receiverDiff === 75n + ) + ).to.be.eventually.rejectedWith( + AssertionError, + "Expected the balance changes of MCK to satisfy the predicate, but they didn't" + ); + }); + + it("Should fail when the predicate returns true and the assertion is negated", async () => { + await expect( + expect( + mockToken.transfer(receiver.address, 75) + ).to.not.changeTokenBalances( + mockToken, + [sender, receiver], + ([senderDiff, receiverDiff]: bigint[]) => + senderDiff === -75n && receiverDiff === 75n + ) + ).to.be.eventually.rejectedWith( + AssertionError, + "Expected the balance changes of MCK to NOT satisfy the predicate, but they did" + ); + }); + }); + + describe("transaction that transfers some tokens", function () { + it("with a promise of a TxResponse", async function () { + await runAllAsserts( + mockToken.transfer(receiver.address, 50), + mockToken, + [sender, receiver], + [-50, 50] + ); + + await runAllAsserts( + mockToken.transfer(receiver.address, 100), + mockToken, + [sender, receiver], + [-100, 100] + ); + }); + + it("with a TxResponse", async function () { + await runAllAsserts( + await mockToken.transfer(receiver.address, 150), + mockToken, + [sender, receiver], + [-150, 150] + ); + }); + + it("with a function that returns a promise of a TxResponse", async function () { + await runAllAsserts( + () => mockToken.transfer(receiver.address, 200), + mockToken, + [sender, receiver], + [-200, 200] + ); + }); + + it("with a function that returns a TxResponse", async function () { + const txResponse = await mockToken.transfer(receiver.address, 300); + await runAllAsserts( + () => txResponse, + mockToken, + [sender, receiver], + [-300, 300] + ); + }); + + it("changeTokenBalance shouldn't run the transaction twice", async function () { + const receiverBalanceBefore = await mockToken.balanceOf( + receiver.address + ); + + await expect(() => + mockToken.transfer(receiver.address, 50) + ).to.changeTokenBalance(mockToken, receiver, 50); + + const receiverBalanceChange = + (await mockToken.balanceOf(receiver.address)) - receiverBalanceBefore; + + expect(receiverBalanceChange).to.equal(50n); + }); + + it("changeTokenBalances shouldn't run the transaction twice", async function () { + const receiverBalanceBefore = await mockToken.balanceOf( + receiver.address + ); + + await expect(() => + mockToken.transfer(receiver.address, 50) + ).to.changeTokenBalances(mockToken, [sender, receiver], [-50, 50]); + + const receiverBalanceChange = + (await mockToken.balanceOf(receiver.address)) - receiverBalanceBefore; + + expect(receiverBalanceChange).to.equal(50n); + }); + + it("negated", async function () { + await expect( + mockToken.transfer(receiver.address, 50) + ).to.not.changeTokenBalance(mockToken, sender, 0); + await expect( + mockToken.transfer(receiver.address, 50) + ).to.not.changeTokenBalance(mockToken, sender, 1); + + await expect( + mockToken.transfer(receiver.address, 50) + ).to.not.changeTokenBalances(mockToken, [sender, receiver], [0, 0]); + await expect( + mockToken.transfer(receiver.address, 50) + ).to.not.changeTokenBalances(mockToken, [sender, receiver], [-50, 0]); + await expect( + mockToken.transfer(receiver.address, 50) + ).to.not.changeTokenBalances(mockToken, [sender, receiver], [0, 50]); + }); + + describe("assertion failures", function () { + it("doesn't change balance as expected", async function () { + await expect( + expect( + mockToken.transfer(receiver.address, 50) + ).to.changeTokenBalance(mockToken, receiver, 500) + ).to.be.rejectedWith( + AssertionError, + /Expected the balance of MCK tokens for "0x\w{40}" to change by 500, but it changed by 50/ + ); + }); + + it("change balance doesn't satisfies the predicate", async function () { + await expect( + expect( + mockToken.transfer(receiver.address, 50) + ).to.changeTokenBalance( + mockToken, + receiver, + (diff: bigint) => diff === 500n + ) + ).to.be.rejectedWith( + AssertionError, + /Expected the balance of MCK tokens for "0x\w{40}" to satisfy the predicate, but it didn't \(token balance change: 50 wei\)/ + ); + }); + + it("changes balance in the way it was not expected", async function () { + await expect( + expect( + mockToken.transfer(receiver.address, 50) + ).to.not.changeTokenBalance(mockToken, receiver, 50) + ).to.be.rejectedWith( + AssertionError, + /Expected the balance of MCK tokens for "0x\w{40}" NOT to change by 50, but it did/ + ); + }); + + it("changes balance doesn't have to satisfy the predicate, but it did", async function () { + await expect( + expect( + mockToken.transfer(receiver.address, 50) + ).to.not.changeTokenBalance( + mockToken, + receiver, + (diff: bigint) => diff === 50n + ) + ).to.be.rejectedWith( + AssertionError, + /Expected the balance of MCK tokens for "0x\w{40}" to NOT satisfy the predicate, but it did \(token balance change: 50 wei\)/ + ); + }); + + it("the first account doesn't change its balance as expected", async function () { + await expect( + expect( + mockToken.transfer(receiver.address, 50) + ).to.changeTokenBalances(mockToken, [sender, receiver], [-100, 50]) + ).to.be.rejectedWith(AssertionError); + }); + + it("the second account doesn't change its balance as expected", async function () { + await expect( + expect( + mockToken.transfer(receiver.address, 50) + ).to.changeTokenBalances(mockToken, [sender, receiver], [-50, 100]) + ).to.be.rejectedWith(AssertionError); + }); + + it("neither account changes its balance as expected", async function () { + await expect( + expect( + mockToken.transfer(receiver.address, 50) + ).to.changeTokenBalances(mockToken, [sender, receiver], [0, 0]) + ).to.be.rejectedWith(AssertionError); + }); + + it("accounts change their balance in the way it was not expected", async function () { + await expect( + expect( + mockToken.transfer(receiver.address, 50) + ).to.not.changeTokenBalances( + mockToken, + [sender, receiver], + [-50, 50] + ) + ).to.be.rejectedWith(AssertionError); + }); + + it("uses the token name if the contract doesn't have a symbol", async function () { + const TokenWithOnlyName = await this.hre.ethers.getContractFactory< + [], + Token + >("TokenWithOnlyName"); + const tokenWithOnlyName = await TokenWithOnlyName.deploy(); + + await expect( + expect( + tokenWithOnlyName.transfer(receiver.address, 50) + ).to.changeTokenBalance(tokenWithOnlyName, receiver, 500) + ).to.be.rejectedWith( + AssertionError, + /Expected the balance of MockToken tokens for "0x\w{40}" to change by 500, but it changed by 50/ + ); + + await expect( + expect( + tokenWithOnlyName.transfer(receiver.address, 50) + ).to.not.changeTokenBalance(tokenWithOnlyName, receiver, 50) + ).to.be.rejectedWith( + AssertionError, + /Expected the balance of MockToken tokens for "0x\w{40}" NOT to change by 50, but it did/ + ); + }); + + it("uses the contract address if the contract doesn't have name or symbol", async function () { + const TokenWithoutNameNorSymbol = + await this.hre.ethers.getContractFactory<[], Token>( + "TokenWithoutNameNorSymbol" + ); + const tokenWithoutNameNorSymbol = + await TokenWithoutNameNorSymbol.deploy(); + + await expect( + expect( + tokenWithoutNameNorSymbol.transfer(receiver.address, 50) + ).to.changeTokenBalance(tokenWithoutNameNorSymbol, receiver, 500) + ).to.be.rejectedWith( + AssertionError, + /Expected the balance of tokens for "0x\w{40}" to change by 500, but it changed by 50/ + ); + + await expect( + expect( + tokenWithoutNameNorSymbol.transfer(receiver.address, 50) + ).to.not.changeTokenBalance(tokenWithoutNameNorSymbol, receiver, 50) + ).to.be.rejectedWith( + AssertionError, + /Expected the balance of tokens for "0x\w{40}" NOT to change by 50, but it did/ + ); + }); + + it("changeTokenBalance: Should throw if chained to another non-chainable method", () => { + expect(() => + expect(mockToken.transfer(receiver.address, 50)) + .to.emit(mockToken, "SomeEvent") + .and.to.changeTokenBalance(mockToken, receiver, 50) + ).to.throw( + /The matcher 'changeTokenBalance' cannot be chained after 'emit'./ + ); + }); + + it("changeTokenBalances: should throw if chained to another non-chainable method", () => { + expect(() => + expect( + mockToken.transfer(receiver.address, 50) + ).to.be.reverted.and.to.changeTokenBalances( + mockToken, + [sender, receiver], + [-50, 100] + ) + ).to.throw( + /The matcher 'changeTokenBalances' cannot be chained after 'reverted'./ + ); + }); + }); + }); + + describe("validation errors", function () { + describe(CHANGE_TOKEN_BALANCE_MATCHER, function () { + it("token is not specified", async function () { + expect(() => + expect(mockToken.transfer(receiver.address, 50)) + .to // @ts-expect-error + .changeTokenBalance(receiver, 50) + ).to.throw( + Error, + "The first argument of changeTokenBalance must be the contract instance of the token" + ); + + // if an address is used + expect(() => + expect(mockToken.transfer(receiver.address, 50)) + .to // @ts-expect-error + .changeTokenBalance(receiver.address, 50) + ).to.throw( + Error, + "The first argument of changeTokenBalance must be the contract instance of the token" + ); + }); + + it("contract is not a token", async function () { + const NotAToken = await this.hre.ethers.getContractFactory( + "NotAToken" + ); + const notAToken = await NotAToken.deploy(); + + expect(() => + expect( + mockToken.transfer(receiver.address, 50) + ).to.changeTokenBalance(notAToken, sender, -50) + ).to.throw( + Error, + "The given contract instance is not an ERC20 token" + ); + }); + + it("tx is not the only one in the block", async function () { + await this.hre.network.provider.send("evm_setAutomine", [false]); + + // we set a gas limit to avoid using the whole block gas limit + await sender.sendTransaction({ + to: receiver.address, + gasLimit: 30_000, + }); + + await this.hre.network.provider.send("evm_setAutomine", [true]); + + await expect( + expect( + mockToken.transfer(receiver.address, 50, { gasLimit: 100_000 }) + ).to.changeTokenBalance(mockToken, sender, -50) + ).to.be.rejectedWith(Error, "Multiple transactions found in block"); + }); + + it("tx reverts", async function () { + await expect( + expect( + mockToken.transfer(receiver.address, 0) + ).to.changeTokenBalance(mockToken, sender, -50) + ).to.be.rejectedWith( + Error, + // check that the error message includes the revert reason + "Transferred value is zero" + ); + }); + }); + + describe(CHANGE_TOKEN_BALANCES_MATCHER, function () { + it("token is not specified", async function () { + expect(() => + expect(mockToken.transfer(receiver.address, 50)) + .to // @ts-expect-error + .changeTokenBalances([sender, receiver], [-50, 50]) + ).to.throw( + Error, + "The first argument of changeTokenBalances must be the contract instance of the token" + ); + }); + + it("contract is not a token", async function () { + const NotAToken = await this.hre.ethers.getContractFactory( + "NotAToken" + ); + const notAToken = await NotAToken.deploy(); + + expect(() => + expect( + mockToken.transfer(receiver.address, 50) + ).to.changeTokenBalances(notAToken, [sender, receiver], [-50, 50]) + ).to.throw( + Error, + "The given contract instance is not an ERC20 token" + ); + }); + + it("arrays have different length", async function () { + expect(() => + expect( + mockToken.transfer(receiver.address, 50) + ).to.changeTokenBalances(mockToken, [sender], [-50, 50]) + ).to.throw( + Error, + "The number of accounts (1) is different than the number of expected balance changes (2)" + ); + + expect(() => + expect( + mockToken.transfer(receiver.address, 50) + ).to.changeTokenBalances(mockToken, [sender, receiver], [-50]) + ).to.throw( + Error, + "The number of accounts (2) is different than the number of expected balance changes (1)" + ); + }); + + it("arrays have different length, subject is a rejected promise", async function () { + expect(() => + expect(matchers.revertsWithoutReason()).to.changeTokenBalances( + mockToken, + [sender], + [-50, 50] + ) + ).to.throw( + Error, + "The number of accounts (1) is different than the number of expected balance changes (2)" + ); + }); + + it("tx is not the only one in the block", async function () { + await this.hre.network.provider.send("evm_setAutomine", [false]); + + // we set a gas limit to avoid using the whole block gas limit + await sender.sendTransaction({ + to: receiver.address, + gasLimit: 30_000, + }); + + await this.hre.network.provider.send("evm_setAutomine", [true]); + + await expect( + expect( + mockToken.transfer(receiver.address, 50, { gasLimit: 100_000 }) + ).to.changeTokenBalances(mockToken, [sender, receiver], [-50, 50]) + ).to.be.rejectedWith(Error, "Multiple transactions found in block"); + }); + + it("tx reverts", async function () { + await expect( + expect( + mockToken.transfer(receiver.address, 0) + ).to.changeTokenBalances(mockToken, [sender, receiver], [-50, 50]) + ).to.be.rejectedWith( + Error, + // check that the error message includes the revert reason + "Transferred value is zero" + ); + }); + }); + }); + + describe("accepted number types", function () { + it("native bigints are accepted", async function () { + await expect( + mockToken.transfer(receiver.address, 50) + ).to.changeTokenBalance(mockToken, sender, -50n); + + await expect( + mockToken.transfer(receiver.address, 50) + ).to.changeTokenBalances(mockToken, [sender, receiver], [-50n, 50n]); + }); + }); + + // smoke tests for stack traces + describe("stack traces", function () { + describe(CHANGE_TOKEN_BALANCE_MATCHER, function () { + it("includes test file", async function () { + let hasProperStackTrace = false; + try { + await expect( + mockToken.transfer(receiver.address, 50) + ).to.changeTokenBalance(mockToken, sender, -100); + } catch (e: any) { + hasProperStackTrace = util + .inspect(e) + .includes(path.join("test", "changeTokenBalance.ts")); + } + + expect(hasProperStackTrace).to.equal(true); + }); + }); + + describe(CHANGE_TOKEN_BALANCES_MATCHER, function () { + it("includes test file", async function () { + try { + await expect( + mockToken.transfer(receiver.address, 50) + ).to.changeTokenBalances( + mockToken, + [sender, receiver], + [-100, 100] + ); + } catch (e: any) { + expect(util.inspect(e)).to.include( + path.join("test", "changeTokenBalance.ts") + ); + + return; + } + + expect.fail("Expected an exception but none was thrown"); + }); + }); + }); + } +}); + +function zip(a: T[], b: U[]): Array<[T, U]> { + assert(a.length === b.length); + + return a.map((x, i) => [x, b[i]]); +} + +/** + * Given an expression `expr`, a token, and a pair of arrays, check that + * `changeTokenBalance` and `changeTokenBalances` behave correctly in different + * scenarios. + */ +async function runAllAsserts( + expr: + | TransactionResponse + | Promise + | (() => TransactionResponse) + | (() => Promise), + token: Token, + accounts: Array, + balances: Array +) { + // changeTokenBalances works for the given arrays + await expect(expr).to.changeTokenBalances(token, accounts, balances); + + // changeTokenBalances works for empty arrays + await expect(expr).to.changeTokenBalances(token, [], []); + + // for each given pair of account and balance, check that changeTokenBalance + // works correctly + for (const [account, balance] of zip(accounts, balances)) { + await expect(expr).to.changeTokenBalance(token, account, balance); + } +} diff --git a/packages/hardhat-chai-matchers-viem/test/contracts.ts b/packages/hardhat-chai-matchers-viem/test/contracts.ts new file mode 100644 index 0000000000..451bf646c4 --- /dev/null +++ b/packages/hardhat-chai-matchers-viem/test/contracts.ts @@ -0,0 +1,133 @@ +import { + BaseContract, + BaseContractMethod, + ContractTransactionResponse, + BigNumberish, + AddressLike, +} from "ethers"; + +export type MatchersContract = BaseContract & { + panicAssert: BaseContractMethod<[], void, ContractTransactionResponse>; + revertWithCustomErrorWithInt: BaseContractMethod< + [BigNumberish], + void, + ContractTransactionResponse + >; + revertWithCustomErrorWithPair: BaseContractMethod< + [BigNumberish, BigNumberish], + void, + ContractTransactionResponse + >; + revertWithCustomErrorWithUint: BaseContractMethod< + [BigNumberish], + void, + ContractTransactionResponse + >; + revertWithCustomErrorWithUintAndString: BaseContractMethod< + [BigNumberish, string], + void, + ContractTransactionResponse + >; + revertWithSomeCustomError: BaseContractMethod< + [], + void, + ContractTransactionResponse + >; + revertsWith: BaseContractMethod<[string], void, ContractTransactionResponse>; + revertsWithoutReason: BaseContractMethod< + [], + void, + ContractTransactionResponse + >; + succeeds: BaseContractMethod<[], void, ContractTransactionResponse>; +}; + +export type ChangeEtherBalance = BaseContract & { + returnHalf: BaseContractMethod<[], void, ContractTransactionResponse>; + transferTo: BaseContractMethod<[string], void, ContractTransactionResponse>; +}; + +export type EventsContract = BaseContract & { + doNotEmit: BaseContractMethod<[], void, ContractTransactionResponse>; + emitBytes32: BaseContractMethod<[string], void, ContractTransactionResponse>; + emitBytes32Array: BaseContractMethod< + [string, string], + void, + ContractTransactionResponse + >; + emitBytes: BaseContractMethod<[string], void, ContractTransactionResponse>; + emitIndexedBytes32: BaseContractMethod< + [string], + void, + ContractTransactionResponse + >; + emitIndexedBytes: BaseContractMethod< + [string], + void, + ContractTransactionResponse + >; + emitIndexedString: BaseContractMethod< + [string], + void, + ContractTransactionResponse + >; + emitInt: BaseContractMethod< + [BigNumberish], + void, + ContractTransactionResponse + >; + emitAddress: BaseContractMethod< + [AddressLike], + void, + ContractTransactionResponse + >; + emitNestedUintFromAnotherContract: BaseContractMethod< + [BigNumberish], + void, + ContractTransactionResponse + >; + emitNestedUintFromSameContract: BaseContractMethod< + [BigNumberish], + void, + ContractTransactionResponse + >; + emitString: BaseContractMethod<[string], void, ContractTransactionResponse>; + emitStruct: BaseContractMethod< + [BigNumberish, BigNumberish], + void, + ContractTransactionResponse + >; + emitTwoUints: BaseContractMethod< + [BigNumberish, BigNumberish], + void, + ContractTransactionResponse + >; + emitTwoUintsAndTwoStrings: BaseContractMethod< + [BigNumberish, BigNumberish, string, string], + void, + ContractTransactionResponse + >; + emitUint: BaseContractMethod< + [BigNumberish], + void, + ContractTransactionResponse + >; + emitUintAndString: BaseContractMethod< + [BigNumberish, string], + void, + ContractTransactionResponse + >; + emitUintArray: BaseContractMethod< + [BigNumberish, BigNumberish], + void, + ContractTransactionResponse + >; + emitUintTwice: BaseContractMethod< + [BigNumberish, BigNumberish], + void, + ContractTransactionResponse + >; + emitWithoutArgs: BaseContractMethod<[], void, ContractTransactionResponse>; +}; + +export type AnotherContract = BaseContract & {}; diff --git a/packages/hardhat-chai-matchers-viem/test/events.ts b/packages/hardhat-chai-matchers-viem/test/events.ts new file mode 100644 index 0000000000..e9f9d00a18 --- /dev/null +++ b/packages/hardhat-chai-matchers-viem/test/events.ts @@ -0,0 +1,876 @@ +import type { + AnotherContract, + EventsContract, + MatchersContract, +} from "./contracts"; + +import { expect, AssertionError } from "chai"; +import { ethers } from "ethers"; + +import "../src/internal/add-chai-matchers"; +import { anyUint, anyValue } from "../src/withArgs"; +import { useEnvironment, useEnvironmentWithNode } from "./helpers"; + +describe(".to.emit (contract events)", () => { + let contract: EventsContract; + let otherContract: AnotherContract; + let matchers: MatchersContract; + + describe("with the in-process hardhat network", function () { + useEnvironment("hardhat-project"); + + runTests(); + }); + + describe("connected to a hardhat node", function () { + useEnvironmentWithNode("hardhat-project"); + + runTests(); + }); + + function runTests() { + beforeEach(async function () { + otherContract = await this.hre.ethers.deployContract("AnotherContract"); + + contract = await ( + await this.hre.ethers.getContractFactory<[string], EventsContract>( + "Events" + ) + ).deploy(await otherContract.getAddress()); + + const Matchers = await this.hre.ethers.getContractFactory< + [], + MatchersContract + >("Matchers"); + matchers = await Matchers.deploy(); + }); + + it("Should fail when expecting an event that's not in the contract", async function () { + await expect( + expect(contract.doNotEmit()).to.emit(contract, "NonexistentEvent") + ).to.be.eventually.rejectedWith( + AssertionError, + 'Event "NonexistentEvent" doesn\'t exist in the contract' + ); + }); + + it("Should fail when expecting an event that's not in the contract to NOT be emitted", async function () { + await expect( + expect(contract.doNotEmit()).not.to.emit(contract, "NonexistentEvent") + ).to.be.eventually.rejectedWith( + AssertionError, + 'Event "NonexistentEvent" doesn\'t exist in the contract' + ); + }); + + it("Should fail when matcher is called with too many arguments", async function () { + await expect( + // @ts-expect-error + expect(contract.emitUint(1)).not.to.emit(contract, "WithoutArgs", 1) + ).to.be.eventually.rejectedWith( + Error, + "`.emit` expects only two arguments: the contract and the event name. Arguments should be asserted with the `.withArgs` helper." + ); + }); + + it("Should detect events without arguments", async function () { + await expect(contract.emitWithoutArgs()).to.emit(contract, "WithoutArgs"); + }); + + it("Should fail when expecting an event that wasn't emitted", async function () { + await expect( + expect(contract.doNotEmit()).to.emit(contract, "WithoutArgs") + ).to.be.eventually.rejectedWith( + AssertionError, + 'Expected event "WithoutArgs" to be emitted, but it wasn\'t' + ); + }); + + it("Should fail when expecting a specific event NOT to be emitted but it WAS", async function () { + await expect( + expect(contract.emitWithoutArgs()).to.not.emit(contract, "WithoutArgs") + ).to.be.eventually.rejectedWith( + AssertionError, + 'Expected event "WithoutArgs" NOT to be emitted, but it was' + ); + }); + + describe(".withArgs", function () { + it("Should fail when used with .not.", async function () { + expect(() => + expect(contract.emitUint(1)) + .not.to.emit(contract, "WithUintArg") + .withArgs(1) + ).to.throw(Error, "Do not combine .not. with .withArgs()"); + }); + + it("Should fail when used with .not, subject is a rejected promise", async function () { + expect(() => + expect(matchers.revertsWithoutReason()) + .not.to.emit(contract, "WithUintArg") + .withArgs(1) + ).to.throw(Error, "Do not combine .not. with .withArgs()"); + }); + + it("should fail if withArgs is called on its own", async function () { + expect(() => + expect(contract.emitUint(1)) + // @ts-expect-error + .withArgs(1) + ).to.throw( + Error, + "withArgs can only be used in combination with a previous .emit or .revertedWithCustomError assertion" + ); + }); + + it("Should verify zero arguments", async function () { + await expect(contract.emitWithoutArgs()) + .to.emit(contract, "WithoutArgs") + .withArgs(); + }); + + describe("with a uint argument", function () { + it("Should match the argument", async function () { + await expect(contract.emitUint(1)) + .to.emit(contract, "WithUintArg") + .withArgs(1); + }); + + it("Should fail when the input argument doesn't match the event argument", async function () { + await expect( + expect(contract.emitUint(1)) + .to.emit(contract, "WithUintArg") + .withArgs(2) + ).to.be.eventually.rejectedWith( + AssertionError, + 'Error in "WithUintArg" event: Error in the 1st argument assertion: expected 1 to equal 2.' + ); + }); + + it("Should fail when too many arguments are given", async function () { + await expect( + expect(contract.emitUint(1)) + .to.emit(contract, "WithUintArg") + .withArgs(1, 3) + ).to.be.eventually.rejectedWith( + AssertionError, + 'Error in "WithUintArg" event: Expected arguments array to have length 2, but it has 1' + ); + }); + }); + + describe("with an address argument", function () { + const addressable = ethers.Wallet.createRandom(); + const { address } = addressable; + const otherAddressable = ethers.Wallet.createRandom(); + const { address: otherAddress } = otherAddressable; + + it("Should match the argument", async function () { + await expect(contract.emitAddress(addressable)) + .to.emit(contract, "WithAddressArg") + .withArgs(address); + }); + + it("Should match addressable arguments", async function () { + await expect(contract.emitAddress(addressable)) + .to.emit(contract, "WithAddressArg") + .withArgs(addressable); + }); + + it("Should fail when the input argument doesn't match the addressable event argument", async function () { + await expect( + expect(contract.emitAddress(addressable)) + .to.emit(contract, "WithAddressArg") + .withArgs(otherAddressable) + ).to.be.eventually.rejectedWith( + AssertionError, + `Error in "WithAddressArg" event: Error in the 1st argument assertion: expected '${address}' to equal '${otherAddress}'` + ); + }); + + it("Should fail when the input argument doesn't match the address event argument", async function () { + await expect( + expect(contract.emitAddress(addressable)) + .to.emit(contract, "WithAddressArg") + .withArgs(otherAddress) + ).to.be.eventually.rejectedWith( + AssertionError, + `Error in "WithAddressArg" event: Error in the 1st argument assertion: expected '${address}' to equal '${otherAddress}'` + ); + }); + + it("Should fail when too many arguments are given", async function () { + await expect( + expect(contract.emitAddress(addressable)) + .to.emit(contract, "WithAddressArg") + .withArgs(address, otherAddress) + ).to.be.eventually.rejectedWith( + AssertionError, + 'Error in "WithAddressArg" event: Expected arguments array to have length 2, but it has 1' + ); + }); + }); + + // for abbreviating long strings in diff views like chai does: + function abbrev(longString: string): string { + return `${longString.substring(0, 37)}…`; + } + + function formatHash(str: string, hashFn = ethers.id) { + const hash = hashFn(str); + return { + str, + hash, + abbrev: abbrev(hash), + }; + } + + function formatBytes(str: string) { + const bytes = ethers.hexlify(ethers.toUtf8Bytes(str)); + const bytes32 = ethers.zeroPadValue(bytes, 32); + return { + ...formatHash(str), + bytes, + bytes32, + abbrev32: abbrev(ethers.hexlify(bytes32)), + }; + } + + const str1 = formatBytes("string1"); + const str2 = formatBytes("string2"); + + describe("with a string argument", function () { + it("Should match the argument", async function () { + await expect(contract.emitString("string")) + .to.emit(contract, "WithStringArg") + .withArgs("string"); + }); + + it("Should fail when the input argument doesn't match the event argument", async function () { + await expect( + expect(contract.emitString(str1.str)) + .to.emit(contract, "WithStringArg") + .withArgs(str2.str) + ).to.be.eventually.rejectedWith( + AssertionError, + `expected '${str1.str}' to equal '${str2.str}'` + ); + }); + }); + + describe("with an indexed string argument", function () { + it("Should match the argument", async function () { + await expect(contract.emitIndexedString(str1.str)) + .to.emit(contract, "WithIndexedStringArg") + .withArgs(str1.str); + }); + + it("Should fail when the input argument doesn't match the event argument", async function () { + await expect( + expect(contract.emitIndexedString(str1.str)) + .to.emit(contract, "WithIndexedStringArg") + .withArgs(str2.str) + ).to.be.eventually.rejectedWith( + AssertionError, + `Error in "WithIndexedStringArg" event: Error in the 1st argument assertion: The actual value was an indexed and hashed value of the event argument. The expected value provided to the assertion was hashed to produce ${str2.hash}. The actual hash and the expected hash ${str1.hash} did not match: expected '${str1.abbrev}' to equal '${str2.abbrev}'` + ); + }); + + it("Should fail if expected argument is the hash not the pre-image", async function () { + await expect( + expect(contract.emitIndexedString(str1.str)) + .to.emit(contract, "WithIndexedStringArg") + .withArgs(str1.hash) + ).to.be.eventually.rejectedWith( + AssertionError, + "The actual value was an indexed and hashed value of the event argument. The expected value provided to the assertion should be the actual event argument (the pre-image of the hash). You provided the hash itself. Please supply the actual event argument (the pre-image of the hash) instead" + ); + }); + + it("Should fail when trying to match the event argument with an incorrect hash value", async function () { + const incorrect = formatHash(str2.hash, ethers.keccak256); + await expect( + expect(contract.emitIndexedString(str1.str)) + .to.emit(contract, "WithIndexedStringArg") + .withArgs(incorrect.str) + ).to.be.eventually.rejectedWith( + AssertionError, + `Error in "WithIndexedStringArg" event: Error in the 1st argument assertion: The actual value was an indexed and hashed value of the event argument. The expected value provided to the assertion was hashed to produce ${incorrect.hash}. The actual hash and the expected hash ${str1.hash} did not match: expected '${str1.abbrev}' to equal '${incorrect.abbrev}` + ); + }); + }); + + describe("with a bytes argument", function () { + it("Should match the argument", async function () { + await expect(contract.emitBytes(str1.bytes)) + .to.emit(contract, "WithBytesArg") + .withArgs(str1.bytes); + }); + + it("Should fail when the input argument doesn't match the event argument", async function () { + await expect( + expect(contract.emitBytes(str2.bytes)) + .to.emit(contract, "WithBytesArg") + .withArgs(str1.str) + ).to.be.eventually.rejectedWith( + AssertionError, + `Error in "WithBytesArg" event: Error in the 1st argument assertion: expected '${str2.bytes}' to equal '${str1.str}'` + ); + }); + }); + + describe("with an indexed bytes argument", function () { + it("Should match the argument", async function () { + await expect(contract.emitIndexedBytes(str1.bytes)) + .to.emit(contract, "WithIndexedBytesArg") + .withArgs(str1.str); + }); + + it("Should fail when the input argument doesn't match the event argument", async function () { + await expect( + expect(contract.emitIndexedBytes(str2.bytes)) + .to.emit(contract, "WithIndexedBytesArg") + .withArgs(str1.str) + ).to.be.eventually.rejectedWith( + AssertionError, + `Error in "WithIndexedBytesArg" event: Error in the 1st argument assertion: The actual value was an indexed and hashed value of the event argument. The expected value provided to the assertion was hashed to produce ${str1.hash}. The actual hash and the expected hash ${str2.hash} did not match: expected '${str2.abbrev}' to equal '${str1.abbrev}'` + ); + }); + + it("Should fail the passerd argument is the hash, not the pre-image", async function () { + await expect( + expect(contract.emitIndexedBytes(str1.bytes)) + .to.emit(contract, "WithIndexedBytesArg") + .withArgs(str1.hash) + ).to.be.eventually.rejectedWith( + AssertionError, + "The actual value was an indexed and hashed value of the event argument. The expected value provided to the assertion should be the actual event argument (the pre-image of the hash). You provided the hash itself. Please supply the actual event argument (the pre-image of the hash) instead." + ); + }); + }); + + describe("with a bytes32 argument", function () { + it("Should match the argument", async function () { + await expect(contract.emitBytes32(str1.bytes32)) + .to.emit(contract, "WithBytes32Arg") + .withArgs(str1.bytes32); + }); + + it("Should fail when the input argument doesn't match the event argument", async function () { + await expect( + expect(contract.emitBytes32(str2.bytes32)) + .to.emit(contract, "WithBytes32Arg") + .withArgs(str1.bytes32) + ).to.be.eventually.rejectedWith( + AssertionError, + `Error in "WithBytes32Arg" event: Error in the 1st argument assertion: expected '${str2.abbrev32}' to equal '${str1.abbrev32}'` + ); + }); + }); + + describe("with an indexed bytes32 argument", function () { + it("Should match the argument", async function () { + await expect(contract.emitIndexedBytes32(str1.bytes32)) + .to.emit(contract, "WithIndexedBytes32Arg") + .withArgs(str1.bytes32); + }); + + it("Should fail when the input argument doesn't match the event argument", async function () { + await expect( + expect(contract.emitIndexedBytes32(str2.bytes32)) + .to.emit(contract, "WithIndexedBytes32Arg") + .withArgs(str1.bytes32) + ).to.be.eventually.rejectedWith( + AssertionError, + `Error in "WithIndexedBytes32Arg" event: Error in the 1st argument assertion: expected '${str2.abbrev32}' to equal '${str1.abbrev32}'` + ); + }); + }); + + describe("with a uint array argument", function () { + it("Should succeed when expectations are met", async function () { + await expect(contract.emitUintArray(1, 2)) + .to.emit(contract, "WithUintArray") + .withArgs([1, 2]); + }); + + it("Should fail when expectations are not met", async function () { + await expect( + expect(contract.emitUintArray(1, 2)) + .to.emit(contract, "WithUintArray") + .withArgs([3, 4]) + ).to.be.eventually.rejectedWith( + AssertionError, + `Error in "WithUintArray" event: Error in the 1st argument assertion: Error in the 1st argument assertion: expected 1 to equal 3.` + ); + }); + + describe("nested predicate", function () { + it("Should succeed when predicate passes", async function () { + await expect(contract.emitUintArray(1, 2)) + .to.emit(contract, "WithUintArray") + .withArgs([anyValue, 2]); + }); + + it("Should fail when predicate returns false", async function () { + await expect( + expect(contract.emitUintArray(1, 2)) + .to.emit(contract, "WithUintArray") + .withArgs([() => false, 4]) + ).to.be.eventually.rejectedWith( + AssertionError, + `Error in "WithUintArray" event: Error in the 1st argument assertion: Error in the 1st argument assertion: The predicate did not return true` + ); + }); + + it("Should fail when predicate reverts", async function () { + await expect( + expect(contract.emitUintArray(1, 2)) + .to.emit(contract, "WithUintArray") + .withArgs([ + () => { + throw new Error("user error"); + }, + 4, + ]) + ).to.be.eventually.rejectedWith( + AssertionError, + `Error in "WithUintArray" event: Error in the 1st argument assertion: Error in the 1st argument assertion: The predicate threw when called: user error` + ); + }); + }); + + describe("arrays different length", function () { + it("Should fail when the array is shorter", async function () { + await expect( + expect(contract.emitUintArray(1, 2)) + .to.emit(contract, "WithUintArray") + .withArgs([1]) + ).to.be.eventually.rejectedWith( + AssertionError, + 'Error in "WithUintArray" event: Error in the 1st argument assertion: Expected arguments array to have length 1, but it has 2' + ); + }); + + it("Should fail when the array is longer", async function () { + await expect( + expect(contract.emitUintArray(1, 2)) + .to.emit(contract, "WithUintArray") + .withArgs([1, 2, 3]) + ).to.be.eventually.rejectedWith( + AssertionError, + 'Error in "WithUintArray" event: Error in the 1st argument assertion: Expected arguments array to have length 3, but it has 2' + ); + }); + }); + }); + + describe("with a bytes32 array argument", function () { + const aa = `0x${"aa".repeat(32)}`; + const bb = `0x${"bb".repeat(32)}`; + const cc = `0x${"cc".repeat(32)}`; + const dd = `0x${"dd".repeat(32)}`; + + it("Should succeed when expectations are met", async function () { + await expect(contract.emitBytes32Array(aa, bb)) + .to.emit(contract, "WithBytes32Array") + .withArgs([aa, bb]); + }); + + it("Should fail when expectations are not met", async function () { + await expect( + expect(contract.emitBytes32Array(aa, bb)) + .to.emit(contract, "WithBytes32Array") + .withArgs([cc, dd]) + ).to.be.eventually.rejectedWith( + AssertionError, + `Error in "WithBytes32Array" event: Error in the 1st argument assertion: Error in the 1st argument assertion: expected '${abbrev( + aa + )}' to equal '${abbrev(cc)}'` + ); + }); + }); + + describe("with a struct argument", function () { + it("Should succeed when expectations are met", async function () { + await expect(contract.emitStruct(1, 2)) + .to.emit(contract, "WithStructArg") + .withArgs([1, 2]); + }); + + it("Should fail when expectations are not met", async function () { + await expect( + expect(contract.emitStruct(1, 2)) + .to.emit(contract, "WithStructArg") + .withArgs([3, 4]) + ).to.be.eventually.rejectedWith( + AssertionError, + 'Error in "WithStructArg" event: Error in the 1st argument assertion: Error in the 1st argument assertion: expected 1 to equal 3.' + ); + }); + }); + + describe("with multiple arguments", function () { + it("Should successfully match the arguments", async function () { + await expect(contract.emitTwoUints(1, 2)) + .to.emit(contract, "WithTwoUintArgs") + .withArgs(1, 2); + }); + + it("Should fail when the first argument isn't matched", async function () { + await expect( + expect(contract.emitTwoUints(1, 2)) + .to.emit(contract, "WithTwoUintArgs") + .withArgs(2, 2) + ).to.be.eventually.rejectedWith( + AssertionError, + 'Error in "WithTwoUintArgs" event: Error in the 1st argument assertion: expected 1 to equal 2' + ); + }); + + it("Should fail when the second argument isn't matched", async function () { + await expect( + expect(contract.emitTwoUints(1, 2)) + .to.emit(contract, "WithTwoUintArgs") + .withArgs(1, 1) + ).to.be.eventually.rejectedWith( + AssertionError, + 'Error in "WithTwoUintArgs" event: Error in the 2nd argument assertion: expected 2 to equal 1.' + ); + }); + + it("Should fail when too many arguments are supplied", async function () { + await expect( + expect(contract.emitTwoUints(1, 2)) + .to.emit(contract, "WithTwoUintArgs") + .withArgs(1, 2, 3, 4) + ).to.be.eventually.rejectedWith( + AssertionError, + 'Error in "WithTwoUintArgs" event: Expected arguments array to have length 4, but it has 2' + ); + }); + + it("Should fail when too few arguments are supplied", async function () { + await expect( + expect(contract.emitTwoUints(1, 2)) + .to.emit(contract, "WithTwoUintArgs") + .withArgs(1) + ).to.be.eventually.rejectedWith( + AssertionError, + 'Error in "WithTwoUintArgs" event: Expected arguments array to have length 1, but it has 2' + ); + }); + + describe("Should handle argument predicates", function () { + it("Should pass when a predicate argument returns true", async function () { + await expect(contract.emitTwoUints(1, 2)) + .to.emit(contract, "WithTwoUintArgs") + .withArgs(anyValue, anyUint); + }); + + it("Should fail when a predicate argument returns false", async function () { + await expect( + expect(contract.emitTwoUints(1, 2)) + .to.emit(contract, "WithTwoUintArgs") + .withArgs(1, () => false) + ).to.be.rejectedWith( + AssertionError, + 'Error in "WithTwoUintArgs" event: Error in the 2nd argument assertion: The predicate did not return true' + ); + }); + + it("Should fail when a predicate argument throws an error", async function () { + await expect( + expect(contract.emitTwoUints(1, 2)) + .to.emit(contract, "WithTwoUintArgs") + .withArgs(() => { + throw new Error("user-defined error"); + }, "foo") + ).to.be.rejectedWith( + Error, + 'Error in "WithTwoUintArgs" event: Error in the 1st argument assertion: The predicate threw when called: user-defined error' + ); + }); + + describe("with predicate anyUint", function () { + it("Should fail when the event argument is a string", async function () { + await expect( + expect(contract.emitString("a string")) + .to.emit(contract, "WithStringArg") + .withArgs(anyUint) + ).to.be.rejectedWith( + AssertionError, + "Error in \"WithStringArg\" event: Error in the 1st argument assertion: The predicate threw when called: anyUint expected its argument to be an integer, but its type was 'string'" + ); + }); + + it("Should fail when the event argument is negative", async function () { + await expect( + expect(contract.emitInt(-1)) + .to.emit(contract, "WithIntArg") + .withArgs(anyUint) + ).to.be.rejectedWith( + AssertionError, + 'Error in "WithIntArg" event: Error in the 1st argument assertion: The predicate threw when called: anyUint expected its argument to be an unsigned integer, but it was negative, with value -1' + ); + }); + }); + }); + }); + }); + + describe("With one call that emits two separate events", function () { + it("Should successfully catch each event independently", async function () { + await expect(contract.emitUintAndString(1, "a string")).to.emit( + contract, + "WithUintArg" + ); + await expect(contract.emitUintAndString(1, "a string")).to.emit( + contract, + "WithStringArg" + ); + }); + describe("When detecting two events from one call (chaining)", function () { + it("Should succeed when both expected events are indeed emitted", async function () { + await expect(contract.emitUintAndString(1, "a string")) + .to.emit(contract, "WithUintArg") + .and.to.emit(contract, "WithStringArg"); + }); + it("Should succeed when the expected event is emitted and the unexpected event is not", async function () { + await expect(contract.emitWithoutArgs()) + .to.emit(contract, "WithoutArgs") + .and.not.to.emit(otherContract, "WithUintArg"); + }); + describe("When one of the expected events is emitted and the other is not", function () { + it("Should fail when the first expected event is emitted but the second is not", async function () { + await expect( + expect(contract.emitUint(1)) + .to.emit(contract, "WithUintArg") + .and.to.emit(contract, "WithStringArg") + ).to.be.eventually.rejectedWith( + AssertionError, + 'Expected event "WithStringArg" to be emitted, but it wasn\'t' + ); + }); + it("Should fail when the second expected event is emitted but the first is not", async function () { + await expect( + expect(contract.emitUint(1)) + .to.emit(contract, "WithStringArg") + .and.to.emit(contract, "WithUintArg") + ).to.be.eventually.rejectedWith( + AssertionError, + 'Expected event "WithStringArg" to be emitted, but it wasn\'t' + ); + }); + }); + describe("When specifying .withArgs()", function () { + it("Should pass when expecting the correct args from the first event", async function () { + await expect(contract.emitUintAndString(1, "a string")) + .to.emit(contract, "WithUintArg") + .withArgs(1) + .and.to.emit(contract, "WithStringArg"); + }); + + it("Should pass when expecting the correct args from the second event", async function () { + await expect(contract.emitUintAndString(1, "a string")) + .to.emit(contract, "WithUintArg") + .and.to.emit(contract, "WithStringArg") + .withArgs("a string"); + }); + + it("Should pass when expecting the correct args from both events", async function () { + await expect(contract.emitUintAndString(1, "a string")) + .to.emit(contract, "WithUintArg") + .withArgs(1) + .and.to.emit(contract, "WithStringArg") + .withArgs("a string"); + }); + + it("Should fail when expecting the wrong argument value for the first event", async function () { + await expect( + expect(contract.emitUintAndString(1, "a string")) + .to.emit(contract, "WithUintArg") + .withArgs(2) + .and.to.emit(contract, "WithStringArg") + ).to.be.eventually.rejectedWith( + AssertionError, + 'Error in "WithUintArg" event: Error in the 1st argument assertion: expected 1 to equal 2.' + ); + }); + + it("Should fail when expecting the wrong argument value for the second event", async function () { + await expect( + expect(contract.emitUintAndString(1, "a string")) + .to.emit(contract, "WithUintArg") + .and.to.emit(contract, "WithStringArg") + .withArgs("a different string") + ).to.be.eventually.rejectedWith( + AssertionError, + "Error in \"WithStringArg\" event: Error in the 1st argument assertion: expected 'a string' to equal 'a different string'" + ); + }); + + it("Should fail when expecting too many arguments from the first event", async function () { + await expect( + expect(contract.emitUintAndString(1, "a string")) + .to.emit(contract, "WithUintArg") + .withArgs(1, 2) + .and.to.emit(contract, "WithStringArg") + ).to.be.eventually.rejectedWith( + AssertionError, + 'Error in "WithUintArg" event: Expected arguments array to have length 2, but it has 1' + ); + }); + + it("Should fail when expecting too many arguments from the second event", async function () { + await expect( + expect(contract.emitUintAndString(1, "a string")) + .to.emit(contract, "WithUintArg") + .and.to.emit(contract, "WithStringArg") + .withArgs("a different string", "yet another string") + ).to.be.eventually.rejectedWith( + AssertionError, + 'Error in "WithStringArg" event: Expected arguments array to have length 2, but it has 1' + ); + }); + + it("Should fail when expecting too few arguments from the first event", async function () { + await expect( + expect( + contract.emitTwoUintsAndTwoStrings( + 1, + 2, + "a string", + "another string" + ) + ) + .to.emit(contract, "WithTwoUintArgs") + .withArgs(1) + .and.to.emit(contract, "WithTwoStringArgs") + ).to.be.eventually.rejectedWith( + AssertionError, + 'Error in "WithTwoUintArgs" event: Expected arguments array to have length 1, but it has 2' + ); + }); + + it("Should fail when expecting too few arguments from the second event", async function () { + await expect( + expect( + contract.emitTwoUintsAndTwoStrings( + 1, + 2, + "a string", + "another string" + ) + ) + .to.emit(contract, "WithTwoUintArgs") + .and.to.emit(contract, "WithTwoStringArgs") + .withArgs("a string") + ).to.be.eventually.rejectedWith( + AssertionError, + 'Error in "WithTwoStringArgs" event: Expected arguments array to have length 1, but it has 2' + ); + }); + }); + + describe("With a contract that emits the same event twice but with different arguments", function () { + it("Should pass when expectations are met", async function () { + await expect(contract.emitUintTwice(1, 2)) + .to.emit(contract, "WithUintArg") + .withArgs(1) + .and.to.emit(contract, "WithUintArg") + .withArgs(2); + }); + + it("Should fail when the first event's argument is not matched", async function () { + await expect( + expect(contract.emitUintTwice(1, 2)) + .to.emit(contract, "WithUintArg") + .withArgs(3) + .and.to.emit(contract, "WithUintArg") + .withArgs(2) + ).to.be.eventually.rejectedWith( + AssertionError, + 'The specified arguments ([ 3 ]) were not included in any of the 2 emitted "WithUintArg" events' + ); + }); + + it("Should fail when the second event's argument is not matched", async function () { + await expect( + expect(contract.emitUintTwice(1, 2)) + .to.emit(contract, "WithUintArg") + .withArgs(1) + .and.to.emit(contract, "WithUintArg") + .withArgs(3) + ).to.be.eventually.rejectedWith( + AssertionError, + 'The specified arguments ([ 3 ]) were not included in any of the 2 emitted "WithUintArg" events' + ); + }); + + it("Should fail when none of the emitted events match the given argument", async function () { + await expect( + expect(contract.emitUintTwice(1, 2)) + .to.emit(contract, "WithUintArg") + .withArgs(3) + ).to.be.eventually.rejectedWith( + AssertionError, + 'The specified arguments ([ 3 ]) were not included in any of the 2 emitted "WithUintArg" events' + ); + }); + }); + }); + }); + + describe("When nested events are emitted", function () { + describe("With the nested event emitted from the same contract", function () { + it("Should pass when the expected event is emitted", async function () { + await expect(contract.emitNestedUintFromSameContract(1)) + .to.emit(contract, "WithUintArg") + .withArgs(1); + }); + + it("Should fail when the expected event is not emitted", async function () { + await expect( + expect(contract.emitNestedUintFromSameContract(1)).to.emit( + contract, + "WithStringArg" + ) + ).to.be.eventually.rejectedWith( + AssertionError, + 'Expected event "WithStringArg" to be emitted, but it wasn\'t' + ); + }); + }); + + describe("With the nested event emitted from a different contract", function () { + it("Should pass when the expected event is emitted", async function () { + await expect(contract.emitNestedUintFromAnotherContract(1)) + .to.emit(otherContract, "WithUintArg") + .withArgs(1); + }); + + it("Should fail when the expected event is emitted but not by the contract that was passed", async function () { + await expect( + expect(contract.emitNestedUintFromAnotherContract(1)) + .to.emit(contract, "WithUintArg") + .withArgs(1) + ).to.be.eventually.rejectedWith( + AssertionError, + 'Expected event "WithUintArg" to be emitted, but it wasn\'t' + ); + }); + }); + }); + + it("With executed transaction", async () => { + const tx = await contract.emitWithoutArgs(); + await expect(tx).to.emit(contract, "WithoutArgs"); + }); + + it("With transaction hash", async () => { + const tx = await contract.emitWithoutArgs(); + await expect(tx.hash).to.emit(contract, "WithoutArgs"); + }); + } +}); diff --git a/packages/hardhat-chai-matchers-viem/test/fixture-projects/.gitignore b/packages/hardhat-chai-matchers-viem/test/fixture-projects/.gitignore new file mode 100644 index 0000000000..e7f801166c --- /dev/null +++ b/packages/hardhat-chai-matchers-viem/test/fixture-projects/.gitignore @@ -0,0 +1,2 @@ +artifacts/ +cache/ diff --git a/packages/hardhat-chai-matchers-viem/test/fixture-projects/hardhat-project/contracts/ChangeEtherBalance.sol b/packages/hardhat-chai-matchers-viem/test/fixture-projects/hardhat-project/contracts/ChangeEtherBalance.sol new file mode 100644 index 0000000000..c86c18e4c4 --- /dev/null +++ b/packages/hardhat-chai-matchers-viem/test/fixture-projects/hardhat-project/contracts/ChangeEtherBalance.sol @@ -0,0 +1,14 @@ +// SPDX-License-Identifier: MIT +pragma solidity ^0.8.0; + +contract ChangeEtherBalance { + function returnHalf() public payable { + payable(msg.sender).transfer(msg.value / 2); + } + + function transferTo(address addr) public payable { + payable(addr).transfer(msg.value); + } + + receive() external payable {} +} \ No newline at end of file diff --git a/packages/hardhat-chai-matchers-viem/test/fixture-projects/hardhat-project/contracts/Events.sol b/packages/hardhat-chai-matchers-viem/test/fixture-projects/hardhat-project/contracts/Events.sol new file mode 100644 index 0000000000..2e3131db88 --- /dev/null +++ b/packages/hardhat-chai-matchers-viem/test/fixture-projects/hardhat-project/contracts/Events.sol @@ -0,0 +1,117 @@ +// SPDX-License-Identifier: MIT +pragma solidity ^0.8.0; + +contract Events { + AnotherContract anotherContract; + + struct Struct { uint u; uint v; } + + event WithoutArgs(); + event WithUintArg(uint u); + event WithIntArg(int i); + event WithAddressArg(address a); + event WithTwoUintArgs(uint u, uint v); + event WithStringArg(string s); + event WithTwoStringArgs(string s, string t); + event WithIndexedStringArg(string indexed s); + event WithBytesArg(bytes b); + event WithIndexedBytesArg(bytes indexed b); + event WithBytes32Arg(bytes32 b); + event WithStructArg(Struct s); + event WithIndexedBytes32Arg(bytes32 indexed b); + event WithUintArray(uint[2] a); + event WithBytes32Array(bytes32[2] a); + + constructor (AnotherContract c) { + anotherContract = c; + } + + function doNotEmit() public {} + + function emitWithoutArgs() public { + emit WithoutArgs(); + } + + function emitUint(uint u) public { + emit WithUintArg(u); + } + + function emitInt(int i) public { + emit WithIntArg(i); + } + + function emitAddress(address a) public { + emit WithAddressArg(a); + } + + function emitUintTwice(uint u, uint v) public { + emit WithUintArg(u); + emit WithUintArg(v); + } + + function emitTwoUints(uint u, uint v) public { + emit WithTwoUintArgs(u, v); + } + + function emitString(string memory s) public { + emit WithStringArg(s); + } + + function emitIndexedString(string memory s) public { + emit WithIndexedStringArg(s); + } + + function emitBytes(bytes memory b) public { + emit WithBytesArg(b); + } + + function emitIndexedBytes(bytes memory b) public { + emit WithIndexedBytesArg(b); + } + + function emitBytes32(bytes32 b) public { + emit WithBytes32Arg(b); + } + + function emitIndexedBytes32(bytes32 b) public { + emit WithIndexedBytes32Arg(b); + } + + function emitUintAndString(uint u, string memory s) public { + emit WithStringArg(s); + emit WithUintArg(u); + } + + function emitTwoUintsAndTwoStrings(uint u, uint v, string memory s, string memory t) public { + emit WithTwoUintArgs(u, v); + emit WithTwoStringArgs(s, t); + } + + function emitStruct(uint u, uint v) public { + emit WithStructArg(Struct(u, v)); + } + + function emitUintArray(uint u, uint v) public { + emit WithUintArray([u, v]); + } + + function emitBytes32Array(bytes32 b, bytes32 c) public { + emit WithBytes32Array([b, c]); + } + + function emitNestedUintFromSameContract(uint u) public { + emitUint(u); + } + + function emitNestedUintFromAnotherContract(uint u) public { + anotherContract.emitUint(u); + } +} + +contract AnotherContract { + event WithUintArg(uint u); + + function emitUint(uint u) public { + emit WithUintArg(u); + } +} diff --git a/packages/hardhat-chai-matchers-viem/test/fixture-projects/hardhat-project/contracts/Matchers.sol b/packages/hardhat-chai-matchers-viem/test/fixture-projects/hardhat-project/contracts/Matchers.sol new file mode 100644 index 0000000000..be1e6047a1 --- /dev/null +++ b/packages/hardhat-chai-matchers-viem/test/fixture-projects/hardhat-project/contracts/Matchers.sol @@ -0,0 +1,137 @@ +// SPDX-License-Identifier: UNLICENSED + +pragma solidity ^0.8.0; + +contract Matchers { + uint x; + + event SomeEvent(); + + AnotherMatchersContract anotherContract; + + struct Pair { uint a; uint b; } + + error SomeCustomError(); + error AnotherCustomError(); + error CustomErrorWithInt(int); + error CustomErrorWithUint(uint nameToForceEthersToUseAnArrayLikeWithNamedProperties); + error CustomErrorWithUintAndString(uint, string); + error CustomErrorWithPair(Pair); + + constructor () { + anotherContract = new AnotherMatchersContract(); + } + + function succeeds() public { + x++; // just to avoid compiler warnings + } + + function succeedsView() public view returns (uint) { + return x; + } + + function revertsWith(string memory reason) public { + x++; + require(false, reason); + } + + function revertsWithView(string memory reason) public pure { + require(false, reason); + } + + function revertsWithoutReason() public { + x++; + require(false); + } + + function revertsWithoutReasonView() public pure { + require(false); + } + + function panicAssert() public { + x++; + assert(false); + } + + function panicAssertView() public pure { + assert(false); + } + + function revertWithSomeCustomError() public { + x++; + revert SomeCustomError(); + } + + function revertWithSomeCustomErrorView() public pure { + revert SomeCustomError(); + } + + function revertWithAnotherCustomError() public { + x++; + revert AnotherCustomError(); + } + + function revertWithAnotherCustomErrorView() public pure { + revert AnotherCustomError(); + } + + function revertWithAnotherContractCustomError() public { + x++; + anotherContract.revertWithYetAnotherCustomError(); + } + + function revertWithAnotherContractCustomErrorView() public view { + anotherContract.revertWithYetAnotherCustomErrorView(); + } + + function revertWithCustomErrorWithUint(uint n) public { + x++; + revert CustomErrorWithUint(n); + } + + function revertWithCustomErrorWithUintView(uint n) public pure { + revert CustomErrorWithUint(n); + } + + function revertWithCustomErrorWithInt(int i) public { + x++; + revert CustomErrorWithInt(i); + } + + function revertWithCustomErrorWithIntView(int i) public pure { + revert CustomErrorWithInt(i); + } + + function revertWithCustomErrorWithUintAndString(uint n, string memory s) public { + x++; + revert CustomErrorWithUintAndString(n, s); + } + + function revertWithCustomErrorWithUintAndStringView(uint n, string memory s) public pure { + revert CustomErrorWithUintAndString(n, s); + } + + function revertWithCustomErrorWithPair(uint a, uint b) public { + x++; + revert CustomErrorWithPair(Pair(a, b)); + } + + function revertWithCustomErrorWithPairView(uint a, uint b) public pure { + revert CustomErrorWithPair(Pair(a, b)); + } +} + +contract AnotherMatchersContract { + uint x; + + error YetAnotherCustomError(); + + function revertWithYetAnotherCustomError() public { + x++; + revert YetAnotherCustomError(); + } + + function revertWithYetAnotherCustomErrorView() public pure { + revert YetAnotherCustomError(); + } +} diff --git a/packages/hardhat-chai-matchers-viem/test/fixture-projects/hardhat-project/contracts/Token.sol b/packages/hardhat-chai-matchers-viem/test/fixture-projects/hardhat-project/contracts/Token.sol new file mode 100644 index 0000000000..0d9d3842c7 --- /dev/null +++ b/packages/hardhat-chai-matchers-viem/test/fixture-projects/hardhat-project/contracts/Token.sol @@ -0,0 +1,54 @@ +// SPDX-License-Identifier: MIT +pragma solidity ^0.8.0; + +contract TokenWithoutNameNorSymbol { + uint public decimals = 1; + + uint public totalSupply; + mapping(address => uint) public balanceOf; + mapping(address => mapping(address => uint)) allowances; + + constructor () { + totalSupply = 1_000_000_000; + balanceOf[msg.sender] = totalSupply; + } + + function transfer(address to, uint value) public returns (bool) { + require(value > 0, "Transferred value is zero"); + + balanceOf[msg.sender] -= value; + balanceOf[to] += value; + + return true; + } + + function allowance(address owner, address spender) public view returns (uint256 remaining) { + return allowances[owner][spender]; + } + + function approve(address spender, uint256 value) public returns (bool success) { + allowances[msg.sender][spender] = value; + return true; + } + + function transferFrom(address from, address to, uint256 value) public returns (bool) { + require(allowance(from, msg.sender) >= value, "Insufficient allowance"); + + allowances[from][msg.sender] -= value; + balanceOf[from] -= value; + balanceOf[to] += value; + + return true; + } +} + +contract TokenWithOnlyName is TokenWithoutNameNorSymbol { + string public name = "MockToken"; +} + +contract MockToken is TokenWithoutNameNorSymbol { + string public name = "MockToken"; + string public symbol = "MCK"; +} + +contract NotAToken {} diff --git a/packages/hardhat-chai-matchers-viem/test/fixture-projects/hardhat-project/hardhat.config.js b/packages/hardhat-chai-matchers-viem/test/fixture-projects/hardhat-project/hardhat.config.js new file mode 100644 index 0000000000..d8edfc19ae --- /dev/null +++ b/packages/hardhat-chai-matchers-viem/test/fixture-projects/hardhat-project/hardhat.config.js @@ -0,0 +1,13 @@ +require("@nomicfoundation/hardhat-ethers"); + +module.exports = { + solidity: "0.8.4", + networks: { + hardhat: { + chainId: Number(process.env.CHAIN_ID ?? "31337"), + }, + localhost: { + url: `http://127.0.0.1:${process.env.HARDHAT_NODE_PORT}`, + }, + }, +}; diff --git a/packages/hardhat-chai-matchers-viem/test/fixture-projects/hardhat-project/start-node.js b/packages/hardhat-chai-matchers-viem/test/fixture-projects/hardhat-project/start-node.js new file mode 100644 index 0000000000..4a470dfae2 --- /dev/null +++ b/packages/hardhat-chai-matchers-viem/test/fixture-projects/hardhat-project/start-node.js @@ -0,0 +1,14 @@ +const hre = require("hardhat"); + +async function main() { + await hre.run("node", { + port: +process.env.HARDHAT_NODE_PORT, + }); +} + +main() + .then(() => process.exit(0)) + .catch((error) => { + console.error(error); + process.exit(1); + }); diff --git a/packages/hardhat-chai-matchers-viem/test/helpers.ts b/packages/hardhat-chai-matchers-viem/test/helpers.ts new file mode 100644 index 0000000000..09dc304b8b --- /dev/null +++ b/packages/hardhat-chai-matchers-viem/test/helpers.ts @@ -0,0 +1,211 @@ +import type { HardhatRuntimeEnvironment } from "hardhat/types"; +import type { MatchersContract } from "./contracts"; + +import { AssertionError, expect } from "chai"; +import { fork } from "child_process"; +import getPort from "get-port"; +import { resetHardhatContext } from "hardhat/plugins-testing"; +import path from "path"; + +// we assume that all the fixture projects use the hardhat-ethers plugin +import "@nomicfoundation/hardhat-ethers/internal/type-extensions"; + +declare module "mocha" { + interface Context { + hre: HardhatRuntimeEnvironment; + } +} + +/** + * Starts a HRE with the in-process hardhat network. + */ +export function useEnvironment(fixtureProjectName: string) { + before("start hardhat in-process", async function () { + process.chdir( + path.resolve(__dirname, "fixture-projects", fixtureProjectName) + ); + + process.env.HARDHAT_NETWORK = "hardhat"; + + this.hre = require("hardhat"); + await this.hre.run("compile", { quiet: true }); + }); + + after(async function () { + resetHardhatContext(); + delete process.env.HARDHAT_NETWORK; + }); +} + +/** + * Start a Hardhat node in a separate process, and then in this process starts a + * HRE connected via http to that node. + */ +export function useEnvironmentWithNode(fixtureProjectName: string) { + const fixtureProjectDir = path.resolve( + __dirname, + "fixture-projects", + fixtureProjectName + ); + + // we start a shared node in a `before` hook to make tests run faster + before("start a hardhat node", async function () { + process.chdir(fixtureProjectDir); + + // this env var will be used both by the script that starts the hh node and + // by the configuration of the 'localhost' network in the fixture project + process.env.HARDHAT_NODE_PORT = String(await getPort()); + + this.hhNodeProcess = fork( + path.resolve(fixtureProjectDir, "start-node.js"), + { + cwd: fixtureProjectDir, + // pipe stdout so we can check when the node it's ready + stdio: "pipe", + } + ); + + // start hardhat connected to the node + process.env.HARDHAT_NETWORK = "localhost"; + + this.hre = require("hardhat"); + await this.hre.run("compile", { quiet: true }); + + // wait until the node is ready + return new Promise((resolve) => { + this.hhNodeProcess.stdout.on("data", (data: any) => { + const nodeStarted = data + .toString() + .includes("Started HTTP and WebSocket JSON-RPC server at"); + if (Boolean(nodeStarted)) { + resolve(); + } + }); + }); + }); + + after(async function () { + resetHardhatContext(); + + delete process.env.HARDHAT_NETWORK; + delete process.env.HARDHAT_NODE_PORT; + + this.hhNodeProcess.kill(); + return new Promise((resolve) => { + this.hhNodeProcess.on("exit", resolve); + }); + }); +} + +/** + * Call `method` as: + * - A write transaction + * - A view method + * - A gas estimation + * - A static call + * And run the `successfulAssert` function with the result of each of these + * calls. Since we expect this assertion to be successful, we just await its + * result; if any of them fails, an error will be thrown. + */ +export async function runSuccessfulAsserts({ + matchers, + method, + args = [], + successfulAssert, +}: { + matchers: any; + method: string; + args?: any[]; + successfulAssert: (x: any) => Promise; +}) { + await successfulAssert(matchers[method](...args)); + await successfulAssert(matchers[`${method}View`](...args)); + await successfulAssert(matchers[method].estimateGas(...args)); + await successfulAssert(matchers[method].staticCall(...args)); +} + +/** + * Similar to runSuccessfulAsserts, but check that the result of the assertion + * is an AssertionError with the given reason. + */ +export async function runFailedAsserts({ + matchers, + method, + args = [], + failedAssert, + failedAssertReason, +}: { + matchers: any; + method: string; + args?: any[]; + failedAssert: (x: any) => Promise; + failedAssertReason: string; +}) { + await expect(failedAssert(matchers[method](...args))).to.be.rejectedWith( + AssertionError, + failedAssertReason + ); + await expect( + failedAssert(matchers[`${method}View`](...args)) + ).to.be.rejectedWith(AssertionError, failedAssertReason); + await expect( + failedAssert(matchers[method].estimateGas(...args)) + ).to.be.rejectedWith(AssertionError, failedAssertReason); + await expect( + failedAssert(matchers[method].staticCall(...args)) + ).to.be.rejectedWith(AssertionError, failedAssertReason); +} + +export async function mineSuccessfulTransaction( + hre: HardhatRuntimeEnvironment +) { + await hre.network.provider.send("evm_setAutomine", [false]); + + const [signer] = await hre.ethers.getSigners(); + const tx = await signer.sendTransaction({ to: signer.address }); + + await mineBlocksUntilTxIsIncluded(hre, tx.hash); + + await hre.network.provider.send("evm_setAutomine", [true]); + + return tx; +} + +export async function mineRevertedTransaction( + hre: HardhatRuntimeEnvironment, + matchers: MatchersContract +) { + await hre.network.provider.send("evm_setAutomine", [false]); + + const tx = await matchers.revertsWithoutReason({ + gasLimit: 1_000_000, + }); + + await mineBlocksUntilTxIsIncluded(hre, tx.hash); + + await hre.network.provider.send("evm_setAutomine", [true]); + + return tx; +} + +async function mineBlocksUntilTxIsIncluded( + hre: HardhatRuntimeEnvironment, + txHash: string +) { + let i = 0; + + while (true) { + const receipt = await hre.ethers.provider.getTransactionReceipt(txHash); + + if (receipt !== null) { + return; + } + + await hre.network.provider.send("hardhat_mine", []); + + i++; + if (i > 100) { + throw new Error(`Transaction was not mined after mining ${i} blocks`); + } + } +} diff --git a/packages/hardhat-chai-matchers-viem/test/hexEqual.ts b/packages/hardhat-chai-matchers-viem/test/hexEqual.ts new file mode 100644 index 0000000000..f84d15c26a --- /dev/null +++ b/packages/hardhat-chai-matchers-viem/test/hexEqual.ts @@ -0,0 +1,79 @@ +import { AssertionError, expect } from "chai"; + +import "../src/internal/add-chai-matchers"; + +describe("UNIT: hexEqual", () => { + it("0xAB equals 0xab", () => { + expect("0xAB").to.hexEqual("0xab"); + }); + + it("0xAB does not equal 0xabc", () => { + expect("0xAB").to.not.hexEqual("0xabc"); + }); + + it("0x0010ab equals 0x000010ab", () => { + expect("0x0010ab").to.hexEqual("0x000010ab"); + }); + + it("0x0000010AB does not equal 0x0010abc", () => { + expect("0x0000010AB").to.not.hexEqual("0x0010abc"); + }); + + it("0x edge case", () => { + expect("0x").to.hexEqual("0x000000"); + }); + + it("abc is not a hex string", () => { + expect(() => expect("abc").to.hexEqual("0xabc")).to.throw( + AssertionError, + 'Expected "abc" to be a hex string equal to "0xabc", but "abc" is not a valid hex string' + ); + expect(() => expect("0xabc").to.hexEqual("abc")).to.throw( + AssertionError, + 'Expected "0xabc" to be a hex string equal to "abc", but "abc" is not a valid hex string' + ); + expect(() => expect("abc").to.not.hexEqual("0xabc")).to.throw( + AssertionError, + 'Expected "abc" not to be a hex string equal to "0xabc", but "abc" is not a valid hex string' + ); + expect(() => expect("0xabc").to.not.hexEqual("abc")).to.throw( + AssertionError, + 'Expected "0xabc" not to be a hex string equal to "abc", but "abc" is not a valid hex string' + ); + }); + + it("xyz is not a hex string", () => { + expect(() => expect("xyz").to.hexEqual("0x1A4")).to.throw( + AssertionError, + 'Expected "xyz" to be a hex string equal to "0x1A4", but "xyz" is not a valid hex string' + ); + }); + + it("0xyz is not a hex string", () => { + expect(() => expect("0xyz").to.hexEqual("0x1A4")).to.throw( + AssertionError, + 'Expected "0xyz" to be a hex string equal to "0x1A4", but "0xyz" is not a valid hex string' + ); + }); + + it("empty string is not a hex string", () => { + expect(() => expect("").to.hexEqual("0x0")).to.throw( + AssertionError, + 'Expected "" to be a hex string equal to "0x0", but "" is not a valid hex string' + ); + }); + + it("correct error when strings are not equal", async function () { + expect(() => expect("0xa").to.hexEqual("0xb")).to.throw( + AssertionError, + 'Expected "0xa" to be a hex string equal to "0xb"' + ); + }); + + it("correct error when strings are equal but expected not to", async function () { + expect(() => expect("0xa").not.to.hexEqual("0xa")).to.throw( + AssertionError, + 'Expected "0xa" NOT to be a hex string equal to "0xa", but it was' + ); + }); +}); diff --git a/packages/hardhat-chai-matchers-viem/test/panic.ts b/packages/hardhat-chai-matchers-viem/test/panic.ts new file mode 100644 index 0000000000..efb6549161 --- /dev/null +++ b/packages/hardhat-chai-matchers-viem/test/panic.ts @@ -0,0 +1,16 @@ +import { assert } from "chai"; +import { toBigInt } from "ethers"; + +import { + PANIC_CODES, + panicErrorCodeToReason, +} from "../src/internal/reverted/panic"; + +describe("panic codes", function () { + it("all exported panic codes should have a description", async function () { + for (const [key, code] of Object.entries(PANIC_CODES)) { + const description = panicErrorCodeToReason(toBigInt(code)); + assert.isDefined(description, `No description for panic code ${key}`); + } + }); +}); diff --git a/packages/hardhat-chai-matchers-viem/test/properAddress.ts b/packages/hardhat-chai-matchers-viem/test/properAddress.ts new file mode 100644 index 0000000000..c029f22890 --- /dev/null +++ b/packages/hardhat-chai-matchers-viem/test/properAddress.ts @@ -0,0 +1,42 @@ +import { expect, AssertionError } from "chai"; + +import "../src/internal/add-chai-matchers"; + +/* eslint-disable @typescript-eslint/no-unused-expressions */ + +describe("Proper address", () => { + it("Expect to be proper address", async () => { + expect("0x28FAA621c3348823D6c6548981a19716bcDc740e").to.be.properAddress; + expect("0x846C66cf71C43f80403B51fE3906B3599D63336f").to.be.properAddress; + }); + + it("Expect not to be proper address", async () => { + expect("28FAA621c3348823D6c6548981a19716bcDc740e").not.to.be.properAddress; + expect("0x28FAA621c3348823D6c6548981a19716bcDc740").to.not.be.properAddress; + expect("0x846C66cf71C43f80403B51fE3906B3599D63336g").to.not.be + .properAddress; + expect("0x846C66cf71C43f80403B51fE3906B3599D6333-f").to.not.be + .properAddress; + }); + + it("Expect to throw if invalid address", async () => { + expect( + () => + expect("0x28FAA621c3348823D6c6548981a19716bcDc740").to.be.properAddress + ).to.throw( + AssertionError, + 'Expected "0x28FAA621c3348823D6c6548981a19716bcDc740" to be a proper address' + ); + }); + + it("Expect to throw if negation with proper address)", async () => { + expect( + () => + expect("0x28FAA621c3348823D6c6548981a19716bcDc740e").not.to.be + .properAddress + ).to.throw( + AssertionError, + 'Expected "0x28FAA621c3348823D6c6548981a19716bcDc740e" NOT to be a proper address' + ); + }); +}); diff --git a/packages/hardhat-chai-matchers-viem/test/properHex.ts b/packages/hardhat-chai-matchers-viem/test/properHex.ts new file mode 100644 index 0000000000..3fd9ef9092 --- /dev/null +++ b/packages/hardhat-chai-matchers-viem/test/properHex.ts @@ -0,0 +1,54 @@ +import { AssertionError, expect } from "chai"; + +import "../src/internal/add-chai-matchers"; + +describe("properHex", function () { + it("should handle a successful positive case", function () { + expect("0xAB").to.be.properHex(2); + }); + + it("should handle a successful negative case", function () { + expect("0xab").to.not.be.properHex(3); + }); + + it("should handle a positive case failing because of an invalid length", function () { + const input = "0xABCDEF"; + const length = 99; + expect(() => expect(input).to.be.properHex(length)).to.throw( + AssertionError, + `Expected "${input}" to be a hex string of length ${ + length + 2 + } (the provided ${length} plus 2 more for the "0x" prefix), but its length is ${ + input.length + }` + ); + }); + + it("should handle a positive case failing because of an invalid hex value", function () { + expect(() => expect("0xABCDEFG").to.be.properHex(8)).to.throw( + AssertionError, + 'Expected "0xABCDEFG" to be a proper hex string, but it contains invalid (non-hex) characters' + ); + }); + + it("should handle a negative case failing because of a valid length", function () { + const input = "0xab"; + const length = 2; + expect(() => expect(input).to.not.be.properHex(length)).to.throw( + AssertionError, + `Expected "${input}" NOT to be a hex string of length ${ + length + 2 + } (the provided ${length} plus 2 more for the "0x" prefix), but its length is ${ + input.length + }` + ); + }); + + it("should handle a negative case failing because of an invalid hex value", function () { + const input = "0xabcdefg"; + expect(() => expect(input).to.not.be.properHex(8)).to.throw( + AssertionError, + `Expected "${input}" NOT to be a proper hex string, but it contains only valid hex characters` + ); + }); +}); diff --git a/packages/hardhat-chai-matchers-viem/test/properPrivateKey.ts b/packages/hardhat-chai-matchers-viem/test/properPrivateKey.ts new file mode 100644 index 0000000000..916c308eb5 --- /dev/null +++ b/packages/hardhat-chai-matchers-viem/test/properPrivateKey.ts @@ -0,0 +1,47 @@ +import { expect, AssertionError } from "chai"; + +import "../src/internal/add-chai-matchers"; + +/* eslint-disable @typescript-eslint/no-unused-expressions */ + +describe("Proper private key", () => { + it("Expect to be proper private key", async () => { + expect("0x706618637b8ca922f6290ce1ecd4c31247e9ab75cf0530a0ac95c0332173d7c5") + .to.be.properPrivateKey; + expect("0x03c909455dcef4e1e981a21ffb14c1c51214906ce19e8e7541921b758221b5ae") + .to.be.properPrivateKey; + }); + + it("Expect not to be proper private key", async () => { + expect("0x28FAA621c3348823D6c6548981a19716bcDc740").to.not.be + .properPrivateKey; + expect("0x706618637b8ca922f6290ce1ecd4c31247e9ab75cf0530a0ac95c0332173d7cw") + .to.not.be.properPrivateKey; + expect("0x03c909455dcef4e1e981a21ffb14c1c51214906ce19e8e7541921b758221b5-e") + .to.not.be.properPrivateKey; + }); + + it("Expect to throw if invalid private key", async () => { + expect( + () => + expect( + "0x706618637b8ca922f6290ce1ecd4c31247e9ab75cf0530a0ac95c0332173d7c" + ).to.be.properPrivateKey + ).to.throw( + AssertionError, + 'Expected "0x706618637b8ca922f6290ce1ecd4c31247e9ab75cf0530a0ac95c0332173d7c" to be a proper private key' + ); + }); + + it("Expect to throw if negation with proper private key)", async () => { + expect( + () => + expect( + "0x706618637b8ca922f6290ce1ecd4c31247e9ab75cf0530a0ac95c0332173d7c5" + ).not.to.be.properPrivateKey + ).to.throw( + AssertionError, + 'Expected "0x706618637b8ca922f6290ce1ecd4c31247e9ab75cf0530a0ac95c0332173d7c5" NOT to be a proper private key' + ); + }); +}); diff --git a/packages/hardhat-chai-matchers-viem/test/reverted/reverted.ts b/packages/hardhat-chai-matchers-viem/test/reverted/reverted.ts new file mode 100644 index 0000000000..7d32cb391b --- /dev/null +++ b/packages/hardhat-chai-matchers-viem/test/reverted/reverted.ts @@ -0,0 +1,430 @@ +import type { MatchersContract } from "../contracts"; + +import { AssertionError, expect } from "chai"; +import { ProviderError } from "hardhat/internal/core/providers/errors"; +import path from "path"; +import util from "util"; + +import "../../src/internal/add-chai-matchers"; +import { + runSuccessfulAsserts, + runFailedAsserts, + useEnvironment, + useEnvironmentWithNode, + mineSuccessfulTransaction, + mineRevertedTransaction, +} from "../helpers"; + +describe("INTEGRATION: Reverted", function () { + describe("with the in-process hardhat network", function () { + useEnvironment("hardhat-project"); + + runTests(); + }); + + describe("connected to a hardhat node", function () { + useEnvironmentWithNode("hardhat-project"); + + runTests(); + }); + + function runTests() { + // deploy Matchers contract before each test + let matchers: MatchersContract; + beforeEach("deploy matchers contract", async function () { + const Matchers = await this.hre.ethers.getContractFactory< + [], + MatchersContract + >("Matchers"); + matchers = await Matchers.deploy(); + }); + + // helpers + const expectAssertionError = async (x: Promise, message: string) => { + return expect(x).to.be.eventually.rejectedWith(AssertionError, message); + }; + + describe("with a string as its subject", function () { + it("hash of a successful transaction", async function () { + const { hash } = await mineSuccessfulTransaction(this.hre); + + await expectAssertionError( + expect(hash).to.be.reverted, + "Expected transaction to be reverted" + ); + await expect(hash).to.not.be.reverted; + }); + + it("hash of a reverted transaction", async function () { + const { hash } = await mineRevertedTransaction(this.hre, matchers); + + await expect(hash).to.be.reverted; + await expectAssertionError( + expect(hash).to.not.be.reverted, + "Expected transaction NOT to be reverted" + ); + }); + + it("invalid string", async function () { + await expect(expect("0x123").to.be.reverted).to.be.rejectedWith( + TypeError, + "Expected a valid transaction hash, but got '0x123'" + ); + + await expect(expect("0x123").to.not.be.reverted).to.be.rejectedWith( + TypeError, + "Expected a valid transaction hash, but got '0x123'" + ); + }); + + it("promise of a hash of a successful transaction", async function () { + const { hash } = await mineSuccessfulTransaction(this.hre); + + await expectAssertionError( + expect(Promise.resolve(hash)).to.be.reverted, + "Expected transaction to be reverted" + ); + await expect(Promise.resolve(hash)).to.not.be.reverted; + }); + + it("promise of a hash of a reverted transaction", async function () { + const { hash } = await mineRevertedTransaction(this.hre, matchers); + + await expect(Promise.resolve(hash)).to.be.reverted; + await expectAssertionError( + expect(Promise.resolve(hash)).to.not.be.reverted, + "Expected transaction NOT to be reverted" + ); + }); + + it("promise of an invalid string", async function () { + await expect( + expect(Promise.resolve("0x123")).to.be.reverted + ).to.be.rejectedWith( + TypeError, + "Expected a valid transaction hash, but got '0x123'" + ); + + await expect( + expect(Promise.resolve("0x123")).to.not.be.reverted + ).to.be.rejectedWith( + TypeError, + "Expected a valid transaction hash, but got '0x123'" + ); + }); + }); + + describe("with a TxResponse as its subject", function () { + it("TxResponse of a successful transaction", async function () { + const tx = await mineSuccessfulTransaction(this.hre); + + await expectAssertionError( + expect(tx).to.be.reverted, + "Expected transaction to be reverted" + ); + await expect(tx).to.not.be.reverted; + }); + + it("TxResponse of a reverted transaction", async function () { + const tx = await mineRevertedTransaction(this.hre, matchers); + + await expect(tx).to.be.reverted; + await expectAssertionError( + expect(tx).to.not.be.reverted, + "Expected transaction NOT to be reverted" + ); + }); + + it("promise of a TxResponse of a successful transaction", async function () { + const txPromise = mineSuccessfulTransaction(this.hre); + + await expectAssertionError( + expect(txPromise).to.be.reverted, + "Expected transaction to be reverted" + ); + await expect(txPromise).to.not.be.reverted; + }); + + it("promise of a TxResponse of a reverted transaction", async function () { + const txPromise = mineRevertedTransaction(this.hre, matchers); + + await expect(txPromise).to.be.reverted; + await expectAssertionError( + expect(txPromise).to.not.be.reverted, + "Expected transaction NOT to be reverted" + ); + }); + + it("reverted: should throw if chained to another non-chainable method", function () { + const txPromise = mineRevertedTransaction(this.hre, matchers); + expect( + () => + expect(txPromise).to.be.revertedWith("an error message").and.to.be + .reverted + ).to.throw( + /The matcher 'reverted' cannot be chained after 'revertedWith'./ + ); + }); + + it("revertedWith: should throw if chained to another non-chainable method", function () { + const txPromise = mineRevertedTransaction(this.hre, matchers); + expect(() => + expect(txPromise) + .to.be.revertedWithCustomError(matchers, "SomeCustomError") + .and.to.be.revertedWith("an error message") + ).to.throw( + /The matcher 'revertedWith' cannot be chained after 'revertedWithCustomError'./ + ); + }); + + it("revertedWithCustomError: should throw if chained to another non-chainable method", function () { + const txPromise = mineRevertedTransaction(this.hre, matchers); + expect(() => + expect(txPromise) + .to.be.revertedWithoutReason() + .and.to.be.revertedWithCustomError(matchers, "SomeCustomError") + ).to.throw( + /The matcher 'revertedWithCustomError' cannot be chained after 'revertedWithoutReason'./ + ); + }); + + it("revertedWithoutReason: should throw if chained to another non-chainable method", function () { + const txPromise = mineRevertedTransaction(this.hre, matchers); + expect(() => + expect(txPromise) + .to.be.revertedWithPanic() + .and.to.be.revertedWithoutReason() + ).to.throw( + /The matcher 'revertedWithoutReason' cannot be chained after 'revertedWithPanic'./ + ); + }); + + it("revertedWithPanic: should throw if chained to another non-chainable method", async function () { + const [sender] = await this.hre.ethers.getSigners(); + const txPromise = mineRevertedTransaction(this.hre, matchers); + expect(() => + expect(txPromise) + .to.changeEtherBalance(sender, "-200") + .and.to.be.revertedWithPanic() + ).to.throw( + /The matcher 'revertedWithPanic' cannot be chained after 'changeEtherBalance'./ + ); + }); + }); + + describe("with a TxReceipt as its subject", function () { + it("TxReceipt of a successful transaction", async function () { + const tx = await mineSuccessfulTransaction(this.hre); + const receipt = await tx.wait(); + + await expectAssertionError( + expect(receipt).to.be.reverted, + "Expected transaction to be reverted" + ); + await expect(receipt).to.not.be.reverted; + }); + + it("TxReceipt of a reverted transaction", async function () { + const tx = await mineRevertedTransaction(this.hre, matchers); + const receipt = await this.hre.ethers.provider.getTransactionReceipt( + tx.hash + ); // tx.wait rejects, so we use provider.getTransactionReceipt + + await expect(receipt).to.be.reverted; + await expectAssertionError( + expect(receipt).to.not.be.reverted, + "Expected transaction NOT to be reverted" + ); + }); + + it("promise of a TxReceipt of a successful transaction", async function () { + const tx = await mineSuccessfulTransaction(this.hre); + const receiptPromise = tx.wait(); + + await expectAssertionError( + expect(receiptPromise).to.be.reverted, + "Expected transaction to be reverted" + ); + await expect(receiptPromise).to.not.be.reverted; + }); + + it("promise of a TxReceipt of a reverted transaction", async function () { + const tx = await mineRevertedTransaction(this.hre, matchers); + const receiptPromise = this.hre.ethers.provider.getTransactionReceipt( + tx.hash + ); // tx.wait rejects, so we use provider.getTransactionReceipt + + await expect(receiptPromise).to.be.reverted; + await expectAssertionError( + expect(receiptPromise).to.not.be.reverted, + "Expected transaction NOT to be reverted" + ); + }); + }); + + describe("calling a contract method that succeeds", function () { + it("successful asserts", async function () { + await runSuccessfulAsserts({ + matchers, + method: "succeeds", + args: [], + successfulAssert: (x) => expect(x).to.not.be.reverted, + }); + }); + + it("failed asserts", async function () { + await runFailedAsserts({ + matchers, + method: "succeeds", + args: [], + failedAssert: (x) => expect(x).to.be.reverted, + failedAssertReason: "Expected transaction to be reverted", + }); + }); + }); + + describe("calling a method that reverts without a reason", function () { + // depends on a bug being fixed on ethers.js + // see https://github.com/NomicFoundation/hardhat/issues/3446 + it.skip("successful asserts", async function () { + await runSuccessfulAsserts({ + matchers, + method: "revertsWithoutReason", + args: [], + successfulAssert: (x) => expect(x).to.be.reverted, + }); + }); + + // depends on a bug being fixed on ethers.js + // see https://github.com/NomicFoundation/hardhat/issues/3446 + it.skip("failed asserts", async function () { + await runFailedAsserts({ + matchers, + method: "revertsWithoutReason", + args: [], + failedAssert: (x) => expect(x).not.to.be.reverted, + failedAssertReason: "Expected transaction NOT to be reverted", + }); + }); + }); + + describe("calling a method that reverts with a reason string", function () { + it("successful asserts", async function () { + await runSuccessfulAsserts({ + matchers, + method: "revertsWith", + args: ["some reason"], + successfulAssert: (x) => expect(x).to.be.reverted, + }); + }); + + it("failed asserts", async function () { + await runFailedAsserts({ + matchers, + method: "revertsWith", + args: ["some reason"], + failedAssert: (x) => expect(x).not.to.be.reverted, + failedAssertReason: + "Expected transaction NOT to be reverted, but it reverted with reason 'some reason'", + }); + }); + }); + + describe("calling a method that reverts with a panic code", function () { + it("successful asserts", async function () { + await runSuccessfulAsserts({ + matchers, + method: "panicAssert", + args: [], + successfulAssert: (x) => expect(x).to.be.reverted, + }); + }); + + it("failed asserts", async function () { + await runFailedAsserts({ + matchers, + method: "panicAssert", + args: [], + failedAssert: (x) => expect(x).not.to.be.reverted, + failedAssertReason: + "Expected transaction NOT to be reverted, but it reverted with panic code 0x01 (Assertion error)", + }); + }); + }); + + describe("calling a method that reverts with a custom error", function () { + it("successful asserts", async function () { + await runSuccessfulAsserts({ + matchers, + method: "revertWithSomeCustomError", + args: [], + successfulAssert: (x) => expect(x).to.be.reverted, + }); + }); + + it("failed asserts", async function () { + await runFailedAsserts({ + matchers, + method: "revertWithSomeCustomError", + args: [], + failedAssert: (x) => expect(x).not.to.be.reverted, + failedAssertReason: "Expected transaction NOT to be reverted", + }); + }); + }); + + describe("invalid rejection values", function () { + it("non-errors", async function () { + await expectAssertionError( + expect(Promise.reject({})).to.be.reverted, + "Expected an Error object" + ); + }); + + it("errors that are not related to a reverted transaction", async function () { + // use an address that almost surely doesn't have balance + const randomPrivateKey = + "0xc5c587cc6e48e9692aee0bf07474118e6d830c11905f7ec7ff32c09c99eba5f9"; + const signer = new this.hre.ethers.Wallet( + randomPrivateKey, + this.hre.ethers.provider + ); + const matchersFromSenderWithoutFunds = matchers.connect( + signer + ) as MatchersContract; + + // this transaction will fail because of lack of funds, not because of a + // revert + await expect( + expect( + matchersFromSenderWithoutFunds.revertsWithoutReason({ + gasLimit: 1_000_000, + }) + ).to.not.be.reverted + ).to.be.eventually.rejectedWith( + ProviderError, + "Sender doesn't have enough funds to send tx" + ); + }); + }); + + describe("stack traces", function () { + // smoke test for stack traces + it("includes test file", async function () { + try { + await expect(matchers.succeeds()).to.be.reverted; + } catch (e: any) { + const errorString = util.inspect(e); + expect(errorString).to.include("Expected transaction to be reverted"); + expect(errorString).to.include( + path.join("test", "reverted", "reverted.ts") + ); + + return; + } + + expect.fail("Expected an exception but none was thrown"); + }); + }); + } +}); diff --git a/packages/hardhat-chai-matchers-viem/test/reverted/revertedWith.ts b/packages/hardhat-chai-matchers-viem/test/reverted/revertedWith.ts new file mode 100644 index 0000000000..a4c2a85dbe --- /dev/null +++ b/packages/hardhat-chai-matchers-viem/test/reverted/revertedWith.ts @@ -0,0 +1,268 @@ +import { AssertionError, expect } from "chai"; +import { ProviderError } from "hardhat/internal/core/providers/errors"; +import path from "path"; +import util from "util"; + +import { + runSuccessfulAsserts, + runFailedAsserts, + useEnvironment, + useEnvironmentWithNode, + mineSuccessfulTransaction, +} from "../helpers"; + +import "../../src/internal/add-chai-matchers"; +import { MatchersContract } from "../contracts"; + +describe("INTEGRATION: Reverted with", function () { + describe("with the in-process hardhat network", function () { + useEnvironment("hardhat-project"); + + runTests(); + }); + + describe("connected to a hardhat node", function () { + useEnvironmentWithNode("hardhat-project"); + + runTests(); + }); + + function runTests() { + // deploy Matchers contract before each test + let matchers: MatchersContract; + + beforeEach("deploy matchers contract", async function () { + const Matchers = await this.hre.ethers.getContractFactory< + [], + MatchersContract + >("Matchers"); + matchers = await Matchers.deploy(); + }); + + describe("calling a method that succeeds", function () { + it("successful asserts", async function () { + await runSuccessfulAsserts({ + matchers, + method: "succeeds", + successfulAssert: (x) => + expect(x).not.to.be.revertedWith("some reason"), + }); + }); + + it("failed asserts", async function () { + await runFailedAsserts({ + matchers, + method: "succeeds", + failedAssert: (x) => expect(x).to.be.revertedWith("some reason"), + failedAssertReason: + "Expected transaction to be reverted with reason 'some reason', but it didn't revert", + }); + }); + }); + + describe("calling a method that reverts without a reason", function () { + it("successful asserts", async function () { + await runSuccessfulAsserts({ + matchers, + method: "revertsWithoutReason", + successfulAssert: (x) => + expect(x).to.not.be.revertedWith("some reason"), + }); + }); + + // depends on a bug being fixed on ethers.js + // see https://github.com/NomicFoundation/hardhat/issues/3446 + it.skip("failed asserts", async function () { + await runFailedAsserts({ + matchers, + method: "revertsWithoutReason", + failedAssert: (x) => expect(x).to.be.revertedWith("some reason"), + failedAssertReason: + "Expected transaction to be reverted with reason 'some reason', but it reverted without a reason", + }); + }); + }); + + describe("calling a method that reverts with a reason string", function () { + it("successful asserts", async function () { + await runSuccessfulAsserts({ + matchers, + method: "revertsWith", + args: ["some reason"], + successfulAssert: (x) => expect(x).to.be.revertedWith("some reason"), + }); + + await runSuccessfulAsserts({ + matchers, + method: "revertsWith", + args: ["regular expression reason"], + successfulAssert: (x) => + expect(x).to.be.revertedWith(/regular .* reason/), + }); + + await runSuccessfulAsserts({ + matchers, + method: "revertsWith", + args: ["some reason"], + successfulAssert: (x) => + expect(x).to.not.be.revertedWith("another reason"), + }); + }); + + it("failed asserts: expected reason not to match", async function () { + await runFailedAsserts({ + matchers, + method: "revertsWith", + args: ["some reason"], + failedAssert: (x) => expect(x).to.not.be.revertedWith("some reason"), + failedAssertReason: + "Expected transaction NOT to be reverted with reason 'some reason', but it was", + }); + }); + + it("failed asserts: expected a different reason", async function () { + await runFailedAsserts({ + matchers, + method: "revertsWith", + args: ["another reason"], + failedAssert: (x) => expect(x).to.be.revertedWith("some reason"), + failedAssertReason: + "Expected transaction to be reverted with reason 'some reason', but it reverted with reason 'another reason'", + }); + }); + + it("failed asserts: expected a different regular expression reason ", async function () { + await runFailedAsserts({ + matchers, + method: "revertsWith", + args: ["another regular expression reason"], + failedAssert: (x) => + expect(x).to.be.revertedWith(/some regular .* reason/), + failedAssertReason: + "Expected transaction to be reverted with reason 'some regular .* reason', but it reverted with reason 'another regular expression reason'", + }); + }); + }); + + describe("calling a method that reverts with a panic code", function () { + it("successful asserts", async function () { + await runSuccessfulAsserts({ + matchers, + method: "panicAssert", + successfulAssert: (x) => + expect(x).to.not.be.revertedWith("some reason"), + }); + }); + + it("failed asserts", async function () { + await runFailedAsserts({ + matchers, + method: "panicAssert", + failedAssert: (x) => expect(x).to.be.revertedWith("some reason"), + failedAssertReason: + "Expected transaction to be reverted with reason 'some reason', but it reverted with panic code 0x01 (Assertion error)", + }); + }); + }); + + describe("calling a method that reverts with a custom error", function () { + it("successful asserts", async function () { + await runSuccessfulAsserts({ + matchers, + method: "revertWithSomeCustomError", + successfulAssert: (x) => + expect(x).to.not.be.revertedWith("some reason"), + }); + }); + + it("failed asserts", async function () { + await runFailedAsserts({ + matchers, + method: "revertWithSomeCustomError", + failedAssert: (x) => expect(x).to.be.revertedWith("some reason"), + failedAssertReason: + "Expected transaction to be reverted with reason 'some reason', but it reverted with a custom error", + }); + }); + }); + + describe("invalid values", function () { + it("non-errors as subject", async function () { + await expect( + expect(Promise.reject({})).to.be.revertedWith("some reason") + ).to.be.rejectedWith(AssertionError, "Expected an Error object"); + }); + + it("non-string as expectation", async function () { + const { hash } = await mineSuccessfulTransaction(this.hre); + + expect(() => + // @ts-expect-error + expect(hash).to.be.revertedWith(10) + ).to.throw( + TypeError, + "Expected the revert reason to be a string or a regular expression" + ); + }); + + it("non-string as expectation, subject is a rejected promise", async function () { + const tx = matchers.revertsWithoutReason(); + + expect(() => + // @ts-expect-error + expect(tx).to.be.revertedWith(10) + ).to.throw( + TypeError, + "Expected the revert reason to be a string or a regular expression" + ); + }); + + it("errors that are not related to a reverted transaction", async function () { + // use an address that almost surely doesn't have balance + const randomPrivateKey = + "0xc5c587cc6e48e9692aee0bf07474118e6d830c11905f7ec7ff32c09c99eba5f9"; + const signer = new this.hre.ethers.Wallet( + randomPrivateKey, + this.hre.ethers.provider + ); + const matchersFromSenderWithoutFunds = matchers.connect( + signer + ) as MatchersContract; + + // this transaction will fail because of lack of funds, not because of a + // revert + await expect( + expect( + matchersFromSenderWithoutFunds.revertsWithoutReason({ + gasLimit: 1_000_000, + }) + ).to.not.be.revertedWith("some reason") + ).to.be.eventually.rejectedWith( + ProviderError, + "Sender doesn't have enough funds to send tx" + ); + }); + }); + + describe("stack traces", function () { + // smoke test for stack traces + it("includes test file", async function () { + try { + await expect(matchers.revertsWith("bar")).to.be.revertedWith("foo"); + } catch (e: any) { + const errorString = util.inspect(e); + expect(errorString).to.include( + "Expected transaction to be reverted with reason 'foo', but it reverted with reason 'bar'" + ); + expect(errorString).to.include( + path.join("test", "reverted", "revertedWith.ts") + ); + + return; + } + + expect.fail("Expected an exception but none was thrown"); + }); + }); + } +}); diff --git a/packages/hardhat-chai-matchers-viem/test/reverted/revertedWithCustomError.ts b/packages/hardhat-chai-matchers-viem/test/reverted/revertedWithCustomError.ts new file mode 100644 index 0000000000..c09f8101fd --- /dev/null +++ b/packages/hardhat-chai-matchers-viem/test/reverted/revertedWithCustomError.ts @@ -0,0 +1,549 @@ +import { AssertionError, expect } from "chai"; +import { ProviderError } from "hardhat/internal/core/providers/errors"; +import path from "path"; +import util from "util"; + +import { + runSuccessfulAsserts, + runFailedAsserts, + useEnvironment, + useEnvironmentWithNode, + mineSuccessfulTransaction, +} from "../helpers"; + +import "../../src/internal/add-chai-matchers"; +import { anyUint, anyValue } from "../../src/withArgs"; +import { MatchersContract } from "../contracts"; + +describe("INTEGRATION: Reverted with custom error", function () { + describe("with the in-process hardhat network", function () { + useEnvironment("hardhat-project"); + + runTests(); + }); + + describe("connected to a hardhat node", function () { + useEnvironmentWithNode("hardhat-project"); + + runTests(); + }); + + function runTests() { + // deploy Matchers contract before each test + let matchers: MatchersContract; + beforeEach("deploy matchers contract", async function () { + const Matchers = await this.hre.ethers.getContractFactory< + [], + MatchersContract + >("Matchers"); + + matchers = await Matchers.deploy(); + }); + + describe("calling a method that succeeds", function () { + it("successful asserts", async function () { + await runSuccessfulAsserts({ + matchers, + method: "succeeds", + successfulAssert: (x) => + expect(x).not.to.be.revertedWithCustomError( + matchers, + "SomeCustomError" + ), + }); + }); + + it("failed asserts", async function () { + await runFailedAsserts({ + matchers, + method: "succeeds", + failedAssert: (x) => + expect(x).to.be.revertedWithCustomError( + matchers, + "SomeCustomError" + ), + failedAssertReason: + "Expected transaction to be reverted with custom error 'SomeCustomError', but it didn't revert", + }); + }); + }); + + describe("calling a method that reverts without a reason", function () { + it("successful asserts", async function () { + await runSuccessfulAsserts({ + matchers, + method: "revertsWithoutReason", + successfulAssert: (x) => + expect(x).to.not.be.revertedWithCustomError( + matchers, + "SomeCustomError" + ), + }); + }); + + // depends on a bug being fixed on ethers.js + // see https://github.com/NomicFoundation/hardhat/issues/3446 + it.skip("failed asserts", async function () { + await runFailedAsserts({ + matchers, + method: "revertsWithoutReason", + failedAssert: (x) => + expect(x).to.be.revertedWithCustomError( + matchers, + "SomeCustomError" + ), + failedAssertReason: + "Expected transaction to be reverted with custom error 'SomeCustomError', but it reverted without a reason", + }); + }); + }); + + describe("calling a method that reverts with a reason string", function () { + it("successful asserts", async function () { + await runSuccessfulAsserts({ + matchers, + method: "revertsWith", + args: ["some reason"], + successfulAssert: (x) => + expect(x).to.not.be.revertedWithCustomError( + matchers, + "SomeCustomError" + ), + }); + }); + + it("failed asserts", async function () { + await runFailedAsserts({ + matchers, + method: "revertsWith", + args: ["some reason"], + failedAssert: (x) => + expect(x).to.be.revertedWithCustomError( + matchers, + "SomeCustomError" + ), + failedAssertReason: + "Expected transaction to be reverted with custom error 'SomeCustomError', but it reverted with reason 'some reason'", + }); + }); + }); + + describe("calling a method that reverts with a panic code", function () { + it("successful asserts", async function () { + await runSuccessfulAsserts({ + matchers, + method: "panicAssert", + successfulAssert: (x) => + expect(x).to.not.be.revertedWithCustomError( + matchers, + "SomeCustomError" + ), + }); + }); + + it("failed asserts", async function () { + await runFailedAsserts({ + matchers, + method: "panicAssert", + failedAssert: (x) => + expect(x).to.be.revertedWithCustomError( + matchers, + "SomeCustomError" + ), + failedAssertReason: + "Expected transaction to be reverted with custom error 'SomeCustomError', but it reverted with panic code 0x01 (Assertion error)", + }); + }); + }); + + describe("calling a method that reverts with a custom error", function () { + it("successful asserts", async function () { + await runSuccessfulAsserts({ + matchers, + method: "revertWithSomeCustomError", + successfulAssert: (x) => + expect(x).to.be.revertedWithCustomError( + matchers, + "SomeCustomError" + ), + }); + + await runSuccessfulAsserts({ + matchers, + method: "revertWithAnotherCustomError", + successfulAssert: (x) => + expect(x).to.not.be.revertedWithCustomError( + matchers, + "SomeCustomError" + ), + }); + }); + + it("failed asserts: expected custom error not to match", async function () { + await runFailedAsserts({ + matchers, + method: "revertWithSomeCustomError", + failedAssert: (x) => + expect(x).to.not.be.revertedWithCustomError( + matchers, + "SomeCustomError" + ), + failedAssertReason: + "Expected transaction NOT to be reverted with custom error 'SomeCustomError', but it was", + }); + }); + + it("failed asserts: reverts with another custom error of the same contract", async function () { + await runFailedAsserts({ + matchers, + method: "revertWithAnotherCustomError", + failedAssert: (x) => + expect(x).to.be.revertedWithCustomError( + matchers, + "SomeCustomError" + ), + failedAssertReason: + "Expected transaction to be reverted with custom error 'SomeCustomError', but it reverted with custom error 'AnotherCustomError'", + }); + }); + + it("failed asserts: reverts with another custom error of another contract", async function () { + await runFailedAsserts({ + matchers, + method: "revertWithAnotherContractCustomError", + failedAssert: (x) => + expect(x).to.be.revertedWithCustomError( + matchers, + "SomeCustomError" + ), + failedAssertReason: + "Expected transaction to be reverted with custom error 'SomeCustomError', but it reverted with a different custom error", + }); + }); + }); + + describe("with args", function () { + describe("one argument", function () { + it("Should match correct argument", async function () { + await expect(matchers.revertWithCustomErrorWithUint(1)) + .to.be.revertedWithCustomError(matchers, "CustomErrorWithUint") + .withArgs(1); + }); + + it("Should fail if wrong argument", async function () { + await expect( + expect(matchers.revertWithCustomErrorWithUint(1)) + .to.be.revertedWithCustomError(matchers, "CustomErrorWithUint") + .withArgs(2) + ).to.be.rejectedWith( + AssertionError, + 'Error in "CustomErrorWithUint" custom error: Error in the 1st argument assertion: expected 1 to equal 2.' + ); + }); + }); + + describe("two arguments", function () { + it("Should match correct values", async function () { + await expect( + matchers.revertWithCustomErrorWithUintAndString(1, "foo") + ) + .to.be.revertedWithCustomError( + matchers, + "CustomErrorWithUintAndString" + ) + .withArgs(1, "foo"); + }); + + it("Should fail if uint is wrong", async function () { + await expect( + expect(matchers.revertWithCustomErrorWithUintAndString(1, "foo")) + .to.be.revertedWithCustomError( + matchers, + "CustomErrorWithUintAndString" + ) + .withArgs(2, "foo") + ).to.be.rejectedWith( + AssertionError, + 'Error in "CustomErrorWithUintAndString" custom error: Error in the 1st argument assertion: expected 1 to equal 2.' + ); + }); + + it("Should fail if string is wrong", async function () { + await expect( + expect(matchers.revertWithCustomErrorWithUintAndString(1, "foo")) + .to.be.revertedWithCustomError( + matchers, + "CustomErrorWithUintAndString" + ) + .withArgs(1, "bar") + ).to.be.rejectedWith( + AssertionError, + "Error in \"CustomErrorWithUintAndString\" custom error: Error in the 2nd argument assertion: expected 'foo' to equal 'bar'" + ); + }); + + it("Should fail if first predicate throws", async function () { + await expect( + expect(matchers.revertWithCustomErrorWithUintAndString(1, "foo")) + .to.be.revertedWithCustomError( + matchers, + "CustomErrorWithUintAndString" + ) + .withArgs(() => { + throw new Error("user-defined error"); + }, "foo") + ).to.be.rejectedWith( + Error, + 'Error in "CustomErrorWithUintAndString" custom error: Error in the 1st argument assertion: The predicate threw when called: user-defined error' + ); + }); + }); + + describe("different number of arguments", function () { + it("Should reject if expected fewer arguments", async function () { + await expect( + expect(matchers.revertWithCustomErrorWithUintAndString(1, "s")) + .to.be.revertedWithCustomError( + matchers, + "CustomErrorWithUintAndString" + ) + .withArgs(1) + ).to.be.rejectedWith( + AssertionError, + 'Error in "CustomErrorWithUintAndString" custom error: Expected arguments array to have length 1, but it has 2' + ); + }); + + it("Should reject if expected more arguments", async function () { + await expect( + expect(matchers.revertWithCustomErrorWithUintAndString(1, "s")) + .to.be.revertedWithCustomError( + matchers, + "CustomErrorWithUintAndString" + ) + .withArgs(1, "s", 3) + ).to.be.rejectedWith( + AssertionError, + 'Error in "CustomErrorWithUintAndString" custom error: Expected arguments array to have length 3, but it has 2' + ); + }); + }); + + describe("nested arguments", function () { + it("should match correct arguments", async function () { + await expect(matchers.revertWithCustomErrorWithPair(1, 2)) + .to.be.revertedWithCustomError(matchers, "CustomErrorWithPair") + .withArgs([1, 2]); + }); + + it("should reject different arguments", async function () { + await expect( + expect(matchers.revertWithCustomErrorWithPair(1, 2)) + .to.be.revertedWithCustomError(matchers, "CustomErrorWithPair") + .withArgs([3, 2]) + ).to.be.rejectedWith( + AssertionError, + 'Error in "CustomErrorWithPair" custom error: Error in the 1st argument assertion: Error in the 1st argument assertion: expected 1 to equal 3.' + ); + }); + }); + + describe("array of different lengths", function () { + it("Should fail if the expected array is bigger", async function () { + await expect( + expect(matchers.revertWithCustomErrorWithPair(1, 2)) + .to.be.revertedWithCustomError(matchers, "CustomErrorWithPair") + .withArgs([1]) + ).to.be.rejectedWith( + AssertionError, + 'Error in "CustomErrorWithPair" custom error: Error in the 1st argument assertion: Expected arguments array to have length 1, but it has 2' + ); + }); + + it("Should fail if the expected array is smaller", async function () { + await expect( + expect(matchers.revertWithCustomErrorWithPair(1, 2)) + .to.be.revertedWithCustomError(matchers, "CustomErrorWithPair") + .withArgs([1, 2, 3]) + ).to.be.rejectedWith( + AssertionError, + 'Error in "CustomErrorWithPair" custom error: Error in the 1st argument assertion: Expected arguments array to have length 3, but it has 2' + ); + }); + }); + + it("Should fail when used with .not.", async function () { + expect(() => + expect(matchers.revertWithSomeCustomError()) + .to.not.be.revertedWithCustomError(matchers, "SomeCustomError") + .withArgs(1) + ).to.throw(Error, "Do not combine .not. with .withArgs()"); + }); + + it("should fail if withArgs is called on its own", async function () { + expect(() => + expect(matchers.revertWithCustomErrorWithUint(1)) + // @ts-expect-error + .withArgs(1) + ).to.throw( + Error, + "withArgs can only be used in combination with a previous .emit or .revertedWithCustomError assertion" + ); + }); + + // TODO: re-enable this test when proper async chaining is implemented. + // See https://github.com/NomicFoundation/hardhat/issues/4235 + it.skip("should fail if both emit and revertedWithCustomError are called", async function () { + expect(() => + expect(matchers.revertWithSomeCustomError()) + .to.emit(matchers, "SomeEvent") + .and.to.be.revertedWithCustomError(matchers, "SomeCustomError") + .withArgs(1) + ).to.throw( + Error, + "withArgs called with both .emit and .revertedWithCustomError, but these assertions cannot be combined" + ); + }); + + describe("Should handle argument predicates", function () { + it("Should pass when a predicate argument returns true", async function () { + await expect(matchers.revertWithCustomErrorWithUint(1)) + .to.be.revertedWithCustomError(matchers, "CustomErrorWithUint") + .withArgs(anyValue); + await expect(matchers.revertWithCustomErrorWithUint(1)) + .to.be.revertedWithCustomError(matchers, "CustomErrorWithUint") + .withArgs(anyUint); + }); + + it("Should fail when a predicate argument returns false", async function () { + await expect( + expect(matchers.revertWithCustomErrorWithUint(1)) + .to.be.revertedWithCustomError(matchers, "CustomErrorWithUint") + .withArgs(() => false) + ).to.be.rejectedWith( + AssertionError, + 'Error in "CustomErrorWithUint" custom error: Error in the 1st argument assertion: The predicate did not return true' + ); + }); + + it("Should fail when a predicate argument throws an error", async function () { + await expect( + expect(matchers.revertWithCustomErrorWithInt(-1)) + .to.be.revertedWithCustomError(matchers, "CustomErrorWithInt") + .withArgs(anyUint) + ).to.be.rejectedWith( + AssertionError, + 'Error in "CustomErrorWithInt" custom error: Error in the 1st argument assertion: The predicate threw when called: anyUint expected its argument to be an unsigned integer, but it was negative, with value -1' + ); + }); + }); + }); + + describe("invalid values", function () { + it("non-errors as subject", async function () { + await expect( + expect(Promise.reject({})).to.be.revertedWithCustomError( + matchers, + "SomeCustomError" + ) + ).to.be.rejectedWith(AssertionError, "Expected an Error object"); + }); + + it("non-string as expectation", async function () { + const { hash } = await mineSuccessfulTransaction(this.hre); + + expect(() => + // @ts-expect-error + expect(hash).to.be.revertedWith(10) + ).to.throw(TypeError, "Expected the revert reason to be a string"); + }); + + it("the contract is not specified", async function () { + expect(() => + expect(matchers.revertWithSomeCustomError()) + .to.be // @ts-expect-error + .revertedWithCustomError("SomeCustomError") + ).to.throw( + TypeError, + "The first argument of .revertedWithCustomError must be the contract that defines the custom error" + ); + }); + + it("the contract doesn't have a custom error with that name", async function () { + expect(() => + expect( + matchers.revertWithSomeCustomError() + ).to.be.revertedWithCustomError(matchers, "SomeCustmError") + ).to.throw( + Error, + "The given contract doesn't have a custom error named 'SomeCustmError'" + ); + }); + + it("errors that are not related to a reverted transaction", async function () { + // use an address that almost surely doesn't have balance + const randomPrivateKey = + "0xc5c587cc6e48e9692aee0bf07474118e6d830c11905f7ec7ff32c09c99eba5f9"; + const signer = new this.hre.ethers.Wallet( + randomPrivateKey, + this.hre.ethers.provider + ); + const matchersFromSenderWithoutFunds = matchers.connect( + signer + ) as MatchersContract; + + // this transaction will fail because of lack of funds, not because of a + // revert + await expect( + expect( + matchersFromSenderWithoutFunds.revertsWithoutReason({ + gasLimit: 1_000_000, + }) + ).to.not.be.revertedWithCustomError(matchers, "SomeCustomError") + ).to.be.eventually.rejectedWith( + ProviderError, + "Sender doesn't have enough funds to send tx" + ); + }); + + it("extra arguments", async function () { + expect(() => + expect( + matchers.revertWithSomeCustomError() + ).to.be.revertedWithCustomError( + matchers, + "SomeCustomError", + // @ts-expect-error + "extraArgument" + ) + ).to.throw( + Error, + "`.revertedWithCustomError` expects only two arguments: the contract and the error name. Arguments should be asserted with the `.withArgs` helper." + ); + }); + }); + + describe("stack traces", function () { + // smoke test for stack traces + it("includes test file", async function () { + try { + await expect( + matchers.revertsWith("some reason") + ).to.be.revertedWithCustomError(matchers, "SomeCustomError"); + } catch (e: any) { + const errorString = util.inspect(e); + expect(errorString).to.include( + "Expected transaction to be reverted with custom error 'SomeCustomError', but it reverted with reason 'some reason'" + ); + expect(errorString).to.include( + path.join("test", "reverted", "revertedWithCustomError.ts") + ); + + return; + } + + expect.fail("Expected an exception but none was thrown"); + }); + }); + } +}); diff --git a/packages/hardhat-chai-matchers-viem/test/reverted/revertedWithPanic.ts b/packages/hardhat-chai-matchers-viem/test/reverted/revertedWithPanic.ts new file mode 100644 index 0000000000..23ff116b7a --- /dev/null +++ b/packages/hardhat-chai-matchers-viem/test/reverted/revertedWithPanic.ts @@ -0,0 +1,335 @@ +import { AssertionError, expect } from "chai"; +import { ProviderError } from "hardhat/internal/core/providers/errors"; +import path from "path"; +import util from "util"; + +import "../../src/internal/add-chai-matchers"; +import { PANIC_CODES } from "../../src/panic"; +import { MatchersContract } from "../contracts"; +import { + runSuccessfulAsserts, + runFailedAsserts, + useEnvironment, + useEnvironmentWithNode, + mineSuccessfulTransaction, +} from "../helpers"; + +describe("INTEGRATION: Reverted with panic", function () { + describe("with the in-process hardhat network", function () { + useEnvironment("hardhat-project"); + + runTests(); + }); + + describe("connected to a hardhat node", function () { + useEnvironmentWithNode("hardhat-project"); + + runTests(); + }); + + function runTests() { + // deploy Matchers contract before each test + let matchers: MatchersContract; + beforeEach("deploy matchers contract", async function () { + const Matchers = await this.hre.ethers.getContractFactory< + [], + MatchersContract + >("Matchers"); + matchers = await Matchers.deploy(); + }); + + describe("calling a method that succeeds", function () { + it("successful asserts", async function () { + await runSuccessfulAsserts({ + matchers, + method: "succeeds", + successfulAssert: (x) => expect(x).not.to.be.revertedWithPanic(), + }); + + await runSuccessfulAsserts({ + matchers, + method: "succeeds", + successfulAssert: (x) => + expect(x).not.to.be.revertedWithPanic(PANIC_CODES.ASSERTION_ERROR), + }); + }); + + it("failed asserts", async function () { + await runFailedAsserts({ + matchers, + method: "succeeds", + failedAssert: (x) => expect(x).to.be.revertedWithPanic(), + failedAssertReason: + "Expected transaction to be reverted with some panic code, but it didn't revert", + }); + + await runFailedAsserts({ + matchers, + method: "succeeds", + failedAssert: (x) => + expect(x).to.be.revertedWithPanic(PANIC_CODES.ASSERTION_ERROR), + failedAssertReason: + "Expected transaction to be reverted with panic code 0x01 (Assertion error), but it didn't revert", + }); + }); + }); + + describe("calling a method that reverts without a reason", function () { + it("successful asserts", async function () { + await runSuccessfulAsserts({ + matchers, + method: "revertsWithoutReason", + successfulAssert: (x) => expect(x).to.not.be.revertedWithPanic(), + }); + + await runSuccessfulAsserts({ + matchers, + method: "revertsWithoutReason", + successfulAssert: (x) => + expect(x).to.not.be.revertedWithPanic(PANIC_CODES.ASSERTION_ERROR), + }); + }); + + // depends on a bug being fixed on ethers.js + // see https://github.com/NomicFoundation/hardhat/issues/3446 + it.skip("failed asserts", async function () { + await runFailedAsserts({ + matchers, + method: "revertsWithoutReason", + failedAssert: (x) => expect(x).to.be.revertedWithPanic(), + failedAssertReason: + "Expected transaction to be reverted with some panic code, but it reverted without a reason", + }); + + await runFailedAsserts({ + matchers, + method: "revertsWithoutReason", + failedAssert: (x) => + expect(x).to.be.revertedWithPanic(PANIC_CODES.ASSERTION_ERROR), + failedAssertReason: + "Expected transaction to be reverted with panic code 0x01 (Assertion error), but it reverted without a reason", + }); + }); + }); + + describe("calling a method that reverts with a reason string", function () { + it("successful asserts", async function () { + await runSuccessfulAsserts({ + matchers, + method: "revertsWith", + args: ["some reason"], + successfulAssert: (x) => expect(x).to.not.be.revertedWithPanic(), + }); + + await runSuccessfulAsserts({ + matchers, + method: "revertsWith", + args: ["some reason"], + successfulAssert: (x) => + expect(x).to.not.be.revertedWithPanic(PANIC_CODES.ASSERTION_ERROR), + }); + }); + + it("failed asserts", async function () { + await runFailedAsserts({ + matchers, + method: "revertsWith", + args: ["some reason"], + failedAssert: (x) => expect(x).to.be.revertedWithPanic(), + failedAssertReason: + "Expected transaction to be reverted with some panic code, but it reverted with reason 'some reason'", + }); + + await runFailedAsserts({ + matchers, + method: "revertsWith", + args: ["some reason"], + failedAssert: (x) => + expect(x).to.be.revertedWithPanic(PANIC_CODES.ASSERTION_ERROR), + failedAssertReason: + "Expected transaction to be reverted with panic code 0x01 (Assertion error), but it reverted with reason 'some reason'", + }); + }); + }); + + describe("calling a method that reverts with a panic code", function () { + it("successful asserts", async function () { + await runSuccessfulAsserts({ + matchers, + method: "panicAssert", + successfulAssert: (x) => expect(x).to.be.revertedWithPanic(), + }); + + await runSuccessfulAsserts({ + matchers, + method: "panicAssert", + successfulAssert: (x) => + expect(x).to.be.revertedWithPanic(PANIC_CODES.ASSERTION_ERROR), + }); + }); + + it("failed asserts", async function () { + await runFailedAsserts({ + matchers, + method: "panicAssert", + failedAssert: (x) => expect(x).to.not.be.revertedWithPanic(), + failedAssertReason: + "Expected transaction NOT to be reverted with some panic code, but it reverted with panic code 0x01 (Assertion error)", + }); + + await runFailedAsserts({ + matchers, + method: "panicAssert", + failedAssert: (x) => + expect(x).to.not.be.revertedWithPanic(PANIC_CODES.ASSERTION_ERROR), + failedAssertReason: + "Expected transaction NOT to be reverted with panic code 0x01 (Assertion error), but it was", + }); + + await runFailedAsserts({ + matchers, + method: "panicAssert", + failedAssert: (x) => + expect(x).to.be.revertedWithPanic(PANIC_CODES.ARITHMETIC_OVERFLOW), + failedAssertReason: + "Expected transaction to be reverted with panic code 0x11 (Arithmetic operation overflowed outside of an unchecked block), but it reverted with panic code 0x01 (Assertion error)", + }); + }); + }); + + describe("calling a method that reverts with a custom error", function () { + it("successful asserts", async function () { + await runSuccessfulAsserts({ + matchers, + method: "revertWithSomeCustomError", + successfulAssert: (x) => expect(x).to.not.be.revertedWithPanic(), + }); + + await runSuccessfulAsserts({ + matchers, + method: "revertWithSomeCustomError", + successfulAssert: (x) => + expect(x).to.not.be.revertedWithPanic(PANIC_CODES.ASSERTION_ERROR), + }); + }); + + it("failed asserts", async function () { + await runFailedAsserts({ + matchers, + method: "revertWithSomeCustomError", + failedAssert: (x) => expect(x).to.be.revertedWithPanic(), + failedAssertReason: + "Expected transaction to be reverted with some panic code, but it reverted with a custom error", + }); + + await runFailedAsserts({ + matchers, + method: "revertWithSomeCustomError", + failedAssert: (x) => + expect(x).to.be.revertedWithPanic(PANIC_CODES.ASSERTION_ERROR), + failedAssertReason: + "Expected transaction to be reverted with panic code 0x01 (Assertion error), but it reverted with a custom error", + }); + }); + }); + + describe("accepted panic code values", function () { + it("number", async function () { + await runSuccessfulAsserts({ + matchers, + method: "succeeds", + successfulAssert: (x) => expect(x).not.to.be.revertedWithPanic(1), + }); + }); + + it("bigint", async function () { + await runSuccessfulAsserts({ + matchers, + method: "succeeds", + successfulAssert: (x) => expect(x).not.to.be.revertedWithPanic(1n), + }); + }); + + it("string", async function () { + await runSuccessfulAsserts({ + matchers, + method: "succeeds", + successfulAssert: (x) => expect(x).not.to.be.revertedWithPanic("1"), + }); + }); + }); + + describe("invalid values", function () { + it("non-errors as subject", async function () { + await expect( + expect(Promise.reject({})).to.be.revertedWithPanic(1) + ).to.be.rejectedWith(AssertionError, "Expected an Error object"); + }); + + it("non-number as expectation", async function () { + const { hash } = await mineSuccessfulTransaction(this.hre); + + expect(() => expect(hash).to.be.revertedWithPanic("invalid")).to.throw( + TypeError, + "Expected the given panic code to be a number-like value, but got 'invalid'" + ); + }); + + it("non-number as expectation, subject is a rejected promise", async function () { + const tx = matchers.revertsWithoutReason(); + + expect(() => expect(tx).to.be.revertedWithPanic("invalid")).to.throw( + TypeError, + "Expected the given panic code to be a number-like value, but got 'invalid'" + ); + }); + + it("errors that are not related to a reverted transaction", async function () { + // use an address that almost surely doesn't have balance + const randomPrivateKey = + "0xc5c587cc6e48e9692aee0bf07474118e6d830c11905f7ec7ff32c09c99eba5f9"; + const signer = new this.hre.ethers.Wallet( + randomPrivateKey, + this.hre.ethers.provider + ); + const matchersFromSenderWithoutFunds = matchers.connect( + signer + ) as MatchersContract; + + // this transaction will fail because of lack of funds, not because of a + // revert + await expect( + expect( + matchersFromSenderWithoutFunds.revertsWithoutReason({ + gasLimit: 1_000_000, + }) + ).to.not.be.revertedWithPanic() + ).to.be.eventually.rejectedWith( + ProviderError, + "Sender doesn't have enough funds to send tx" + ); + }); + }); + + describe("stack traces", function () { + // smoke test for stack traces + it("includes test file", async function () { + try { + await expect(matchers.panicAssert()).to.not.be.revertedWithPanic(); + } catch (e: any) { + const errorString = util.inspect(e); + expect(errorString).to.include( + "Expected transaction NOT to be reverted with some panic code, but it reverted with panic code 0x01 (Assertion error)" + ); + expect(errorString).to.include( + path.join("test", "reverted", "revertedWithPanic.ts") + ); + + return; + } + + expect.fail("Expected an exception but none was thrown"); + }); + }); + } +}); diff --git a/packages/hardhat-chai-matchers-viem/test/reverted/revertedWithoutReason.ts b/packages/hardhat-chai-matchers-viem/test/reverted/revertedWithoutReason.ts new file mode 100644 index 0000000000..263a682735 --- /dev/null +++ b/packages/hardhat-chai-matchers-viem/test/reverted/revertedWithoutReason.ts @@ -0,0 +1,204 @@ +import { AssertionError, expect } from "chai"; +import { ProviderError } from "hardhat/internal/core/providers/errors"; +import path from "path"; +import util from "util"; + +import { + runSuccessfulAsserts, + runFailedAsserts, + useEnvironment, + useEnvironmentWithNode, +} from "../helpers"; + +import "../../src/internal/add-chai-matchers"; +import { MatchersContract } from "../contracts"; + +describe("INTEGRATION: Reverted without reason", function () { + describe("with the in-process hardhat network", function () { + useEnvironment("hardhat-project"); + + runTests(); + }); + + describe("connected to a hardhat node", function () { + useEnvironmentWithNode("hardhat-project"); + + runTests(); + }); + + function runTests() { + // deploy Matchers contract before each test + let matchers: MatchersContract; + beforeEach("deploy matchers contract", async function () { + const Matchers = await this.hre.ethers.getContractFactory< + [], + MatchersContract + >("Matchers"); + matchers = await Matchers.deploy(); + }); + + // helpers + describe("calling a method that succeeds", function () { + it("successful asserts", async function () { + await runSuccessfulAsserts({ + matchers, + method: "succeeds", + successfulAssert: (x) => expect(x).not.to.be.revertedWithoutReason(), + }); + }); + + it("failed asserts", async function () { + await runFailedAsserts({ + matchers, + method: "succeeds", + failedAssert: (x) => expect(x).to.be.revertedWithoutReason(), + failedAssertReason: + "Expected transaction to be reverted without a reason, but it didn't revert", + }); + }); + }); + + // depends on a bug being fixed on ethers.js + // see https://github.com/NomicFoundation/hardhat/issues/3446 + describe.skip("calling a method that reverts without a reason", function () { + it("successful asserts", async function () { + await runSuccessfulAsserts({ + matchers, + method: "revertsWithoutReason", + args: [], + successfulAssert: (x) => expect(x).to.be.revertedWithoutReason(), + }); + }); + + it("failed asserts", async function () { + await runFailedAsserts({ + matchers, + method: "revertsWithoutReason", + args: [], + failedAssert: (x) => expect(x).to.not.be.revertedWithoutReason(), + failedAssertReason: + "Expected transaction NOT to be reverted without a reason, but it was", + }); + }); + }); + + describe("calling a method that reverts with a reason", function () { + it("successful asserts", async function () { + await runSuccessfulAsserts({ + matchers, + method: "revertsWith", + args: ["some reason"], + successfulAssert: (x) => expect(x).to.not.be.revertedWithoutReason(), + }); + }); + + it("failed asserts", async function () { + await runFailedAsserts({ + matchers, + method: "revertsWith", + args: ["some reason"], + failedAssert: (x) => expect(x).to.be.revertedWithoutReason(), + failedAssertReason: + "Expected transaction to be reverted without a reason, but it reverted with reason 'some reason'", + }); + }); + }); + + describe("calling a method that reverts with a panic code", function () { + it("successful asserts", async function () { + await runSuccessfulAsserts({ + matchers, + method: "panicAssert", + successfulAssert: (x) => expect(x).to.not.be.revertedWithoutReason(), + }); + }); + + it("failed asserts", async function () { + await runFailedAsserts({ + matchers, + method: "panicAssert", + failedAssert: (x) => expect(x).to.be.revertedWithoutReason(), + failedAssertReason: + "Expected transaction to be reverted without a reason, but it reverted with panic code 0x01 (Assertion error)", + }); + }); + }); + + describe("calling a method that reverts with a custom error", function () { + it("successful asserts", async function () { + await runSuccessfulAsserts({ + matchers, + method: "revertWithSomeCustomError", + successfulAssert: (x) => expect(x).to.not.be.revertedWithoutReason(), + }); + }); + + it("failed asserts", async function () { + await runFailedAsserts({ + matchers, + method: "revertWithSomeCustomError", + failedAssert: (x) => expect(x).to.be.revertedWithoutReason(), + failedAssertReason: + "Expected transaction to be reverted without a reason, but it reverted with a custom error", + }); + }); + }); + + describe("invalid values", function () { + it("non-errors as subject", async function () { + await expect( + expect(Promise.reject({})).to.be.revertedWithoutReason() + ).to.be.rejectedWith(AssertionError, "Expected an Error object"); + }); + + it("errors that are not related to a reverted transaction", async function () { + // use an address that almost surely doesn't have balance + const randomPrivateKey = + "0xc5c587cc6e48e9692aee0bf07474118e6d830c11905f7ec7ff32c09c99eba5f9"; + const signer = new this.hre.ethers.Wallet( + randomPrivateKey, + this.hre.ethers.provider + ); + const matchersFromSenderWithoutFunds = matchers.connect( + signer + ) as MatchersContract; + + // this transaction will fail because of lack of funds, not because of a + // revert + await expect( + expect( + matchersFromSenderWithoutFunds.revertsWithoutReason({ + gasLimit: 1_000_000, + }) + ).to.not.be.revertedWithoutReason() + ).to.be.eventually.rejectedWith( + ProviderError, + "Sender doesn't have enough funds to send tx" + ); + }); + }); + + describe("stack traces", function () { + // smoke test for stack traces + it("includes test file", async function () { + try { + await expect( + matchers.revertsWithoutReason() + ).to.not.be.revertedWithoutReason(); + } catch (e: any) { + const errorString = util.inspect(e); + expect(errorString).to.include( + "Expected transaction NOT to be reverted without a reason, but it was" + ); + expect(errorString).to.include( + path.join("test", "reverted", "revertedWithoutReason.ts") + ); + + return; + } + + expect.fail("Expected an exception but none was thrown"); + }); + }); + } +}); diff --git a/packages/hardhat-chai-matchers-viem/tsconfig.json b/packages/hardhat-chai-matchers-viem/tsconfig.json new file mode 100644 index 0000000000..65ecfc33b9 --- /dev/null +++ b/packages/hardhat-chai-matchers-viem/tsconfig.json @@ -0,0 +1,15 @@ +{ + "extends": "../../config/typescript/tsconfig.json", + "compilerOptions": { + "outDir": "./build-test", + "rootDirs": ["./test"], + "composite": true + }, + "include": ["./test/**/*.ts"], + "exclude": ["./node_modules", "./test/**/hardhat.config.ts"], + "references": [ + { + "path": "./src" + } + ] +} From da01eddd850f2b45459a1e9ea2f405c226fd1987 Mon Sep 17 00:00:00 2001 From: johnpm-12 <39016062+johnpm-12@users.noreply.github.com> Date: Fri, 17 May 2024 16:53:57 -0700 Subject: [PATCH 02/18] save progress --- package.json | 4 +- .../hardhat-chai-matchers-viem/CHANGELOG.md | 83 +--- packages/hardhat-chai-matchers-viem/README.md | 20 +- .../hardhat-chai-matchers-viem/package.json | 23 +- .../scripts/check-subpath-exports.js | 4 +- .../hardhat-chai-matchers-viem/src/index.ts | 2 +- .../src/internal/addressable.ts | 15 +- .../src/internal/changeEtherBalance.ts | 68 ++-- .../src/internal/changeEtherBalances.ts | 151 +++----- .../src/internal/changeTokenBalance.ts | 168 ++++---- .../src/internal/emit.ts | 101 ++--- .../src/internal/errors.ts | 2 +- .../hardhatWaffleIncompatibilityCheck.ts | 4 +- .../src/internal/misc/account.ts | 35 +- .../src/internal/misc/balance.ts | 18 +- .../src/internal/reverted/reverted.ts | 51 +-- .../src/internal/reverted/revertedWith.ts | 5 +- .../reverted/revertedWithCustomError.ts | 30 +- .../internal/reverted/revertedWithPanic.ts | 17 +- .../reverted/revertedWithoutReason.ts | 5 +- .../src/internal/reverted/utils.ts | 62 ++- .../src/internal/utils.ts | 34 +- .../src/internal/withArgs.ts | 13 +- .../hardhat-chai-matchers-viem/src/panic.ts | 2 +- .../src/tsconfig.json | 2 +- .../hardhat-chai-matchers-viem/src/types.ts | 6 +- .../test/addressable.ts | 56 ++- .../test/bigNumber.ts | 87 ++--- .../test/changeEtherBalance.ts | 358 +++++++----------- .../test/changeEtherBalances.ts | 261 +++++-------- .../test/changeTokenBalance.ts | 356 ++++++----------- .../test/contracts.ts | 145 +------ .../hardhat-chai-matchers-viem/test/events.ts | 283 ++++++++------ .../hardhat-project/hardhat.config.js | 2 +- .../test/helpers.ts | 58 +-- .../hardhat-chai-matchers-viem/test/panic.ts | 3 +- .../test/reverted/revertedWithCustomError.ts | 86 +++-- 37 files changed, 1061 insertions(+), 1559 deletions(-) diff --git a/package.json b/package.json index ba750b37d2..1fcbb89507 100644 --- a/package.json +++ b/package.json @@ -14,8 +14,8 @@ }, "scripts": { "postbuild": "cp packages/hardhat-core/src/internal/solidity/compiler/solcjs-runner.js packages/hardhat-core/internal/solidity/compiler/solcjs-runner.js", - "build": "tsc --build packages/hardhat-core packages/hardhat-ethers packages/hardhat-verify packages/hardhat-solhint packages/hardhat-solpp packages/hardhat-truffle4 packages/hardhat-truffle5 packages/hardhat-vyper packages/hardhat-web3 packages/hardhat-web3-v4 packages/hardhat-web3-legacy packages/hardhat-chai-matchers packages/hardhat-network-helpers packages/hardhat-toolbox packages/hardhat-foundry packages/hardhat-ledger packages/hardhat-viem packages/hardhat-toolbox-viem", - "watch": "tsc --build --watch packages/hardhat-core/src packages/hardhat-ethers packages/hardhat-verify packages/hardhat-solhint packages/hardhat-solpp packages/hardhat-truffle4 packages/hardhat-truffle5 packages/hardhat-vyper packages/hardhat-web3 packages/hardhat-web3-v4 packages/hardhat-web3-legacy packages/hardhat-chai-matchers packages/hardhat-network-helpers packages/hardhat-toolbox packages/hardhat-foundry packages/hardhat-ledger packages/hardhat-viem packages/hardhat-toolbox-viem", + "build": "tsc --build packages/hardhat-core packages/hardhat-ethers packages/hardhat-verify packages/hardhat-solhint packages/hardhat-solpp packages/hardhat-truffle4 packages/hardhat-truffle5 packages/hardhat-vyper packages/hardhat-web3 packages/hardhat-web3-v4 packages/hardhat-web3-legacy packages/hardhat-chai-matchers packages/hardhat-chai-matchers-viem packages/hardhat-network-helpers packages/hardhat-toolbox packages/hardhat-foundry packages/hardhat-ledger packages/hardhat-viem packages/hardhat-toolbox-viem", + "watch": "tsc --build --watch packages/hardhat-core/src packages/hardhat-ethers packages/hardhat-verify packages/hardhat-solhint packages/hardhat-solpp packages/hardhat-truffle4 packages/hardhat-truffle5 packages/hardhat-vyper packages/hardhat-web3 packages/hardhat-web3-v4 packages/hardhat-web3-legacy packages/hardhat-chai-matchers packages/hardhat-chai-matchers-viem packages/hardhat-network-helpers packages/hardhat-toolbox packages/hardhat-foundry packages/hardhat-ledger packages/hardhat-viem packages/hardhat-toolbox-viem", "clean": "pnpm run --recursive clean", "test": "node scripts/run-tests.js", "lint": "pnpm run --recursive lint && pnpm prettier --check", diff --git a/packages/hardhat-chai-matchers-viem/CHANGELOG.md b/packages/hardhat-chai-matchers-viem/CHANGELOG.md index 255f4a9c7a..4875b2a0be 100644 --- a/packages/hardhat-chai-matchers-viem/CHANGELOG.md +++ b/packages/hardhat-chai-matchers-viem/CHANGELOG.md @@ -1,84 +1,7 @@ -# @nomicfoundation/hardhat-chai-matchers +# @nomicfoundation/hardhat-chai-matchers-viem -## 2.0.6 - -### Patch Changes - -- 69fc3a4: Improved error messages of the `.withArgs` matcher (thanks @RenanSouza2!) - -## 2.0.5 - -### Patch Changes - -- 72bf9f6: Added support for Typed objects (thanks @RenanSouza2!) -- 82bc59d: Improved how `.revertedWithCustomError` handles wrong number of arguments (thanks @RenanSouza2!) - -## 2.0.4 - -### Patch Changes - -- ffb301f14: Improved loading performance - -## 2.0.3 - -### Patch Changes - -- dff8302aa: Added support for `Addressable` objects in `.withArgs` and `.equals` (thanks @Amxx!) - -## 2.0.2 - -### Patch Changes - -- f324b3a33: Forbid chaining incompatible chai matchers - -## 2.0.1 - -### Patch Changes - -- 70c2ccf12: Removed an unnecessary dependency - -## 2.0.0 +## 3.0.0 ### Major Changes -- 523235b83: Added support for ethers v6 - -### Patch Changes - -- 06c4797a7: Fixed a problem when `.withArgs` was used with arrays with different length - -## 1.0.6 - -### Patch Changes - -- 8fa00c97c: Improved the warning shown when both `@nomicfoundation/hardhat-chai-matchers` and `@nomiclabs/hardhat-waffle` are used. - -## 1.0.5 - -### Patch Changes - -- 478c244a7: The `revertedWith` matcher now supports regular expressions (thanks @Dkdaniz!) - -## 1.0.4 - -### Patch Changes - -- 691f0cecb: Fixed the values matched by `properAddress` and `properPrivateKey` (thanks @olehmisar!) - -## 1.0.3 - -### Patch Changes - -- 616a78617: Failed assertions now show a more useful stack trace - -## 1.0.2 - -### Patch Changes - -- 857a56069: Fixed a bug where `changeTokenBalances` was sending the tx multiple times when used with a callback - -## 1.0.1 - -### Patch Changes - -- ed6222bf1: Fix an error in revertedWithCustomError's argument matching +- : Initial release, forked from @nomicfoundation/hardhat-chai-matchers diff --git a/packages/hardhat-chai-matchers-viem/README.md b/packages/hardhat-chai-matchers-viem/README.md index 60f879d0f4..31572d51ff 100644 --- a/packages/hardhat-chai-matchers-viem/README.md +++ b/packages/hardhat-chai-matchers-viem/README.md @@ -1,29 +1,29 @@ -[![npm](https://img.shields.io/npm/v/@nomicfoundation/hardhat-chai-matchers.svg)](https://www.npmjs.com/package/@nomicfoundation/hardhat-chai-matchers) +[![npm](https://img.shields.io/npm/v/@nomicfoundation/hardhat-chai-matchers-viem.svg)](https://www.npmjs.com/package/@nomicfoundation/hardhat-chai-matchers-viem) -# Hardhat Chai Matchers +# Hardhat Chai Matchers Viem This plugin adds Ethereum-specific capabilities to the [Chai](https://chaijs.com/) assertion library, making your smart contract tests easy to write and read. -Check [its documentation](https://hardhat.org/hardhat-chai-matchers/docs) to learn more. +It is based on @nomicfoundation/hardhat-chai-matchers which is for ethers. Check [its documentation](https://hardhat.org/hardhat-chai-matchers/docs) to learn more. ### Installation We recommend using npm 7 or later. If you do that, then you just need to install the plugin itself: ```bash -npm install --save-dev @nomicfoundation/hardhat-chai-matchers +npm install --save-dev @nomicfoundation/hardhat-chai-matchers-viem ``` If you are using an older version of npm, you'll also need to install all the packages used by the plugin. ```bash -npm install --save-dev @nomicfoundation/hardhat-chai-matchers chai@4 @nomicfoundation/hardhat-ethers ethers +npm install --save-dev @nomicfoundation/hardhat-chai-matchers-viem chai@4 @nomicfoundation/hardhat-viem viem ``` That's also the case if you are using yarn: ```bash -yarn add --dev @nomicfoundation/hardhat-chai-matchers chai@4 @nomicfoundation/hardhat-ethers ethers +yarn add --dev @nomicfoundation/hardhat-chai-matchers-viem chai@4 @nomicfoundation/hardhat-viem viem ``` ### Usage @@ -31,19 +31,19 @@ yarn add --dev @nomicfoundation/hardhat-chai-matchers chai@4 @nomicfoundation/ha After installing it, add the plugin to your Hardhat config: ```js -require("@nomicfoundation/hardhat-chai-matchers"); +require("@nomicfoundation/hardhat-chai-matchers-viem"); ``` Then you'll be able to use the matchers in your tests: ```js -expect(await token.totalSupply()).to.equal(1_000_000); +expect(await token.read.totalSupply()).to.equal(1_000_000); -await expect(token.transfer(token, 1000)).to.be.revertedWith( +await expect(token.write.transfer([token, 1000n])).to.be.revertedWith( "Cannot transfer to the contract itself" ); -await expect(token.transfer(recipient, 1000)) +await expect(token.write.transfer([recipient, 1000n])) .to.emit(token, "Transfer") .withArgs(owner, recipient, 1000); ``` diff --git a/packages/hardhat-chai-matchers-viem/package.json b/packages/hardhat-chai-matchers-viem/package.json index 6397d86210..a4d5eda20d 100644 --- a/packages/hardhat-chai-matchers-viem/package.json +++ b/packages/hardhat-chai-matchers-viem/package.json @@ -1,8 +1,8 @@ { - "name": "@nomicfoundation/hardhat-chai-matchers", - "version": "2.0.6", + "name": "@nomicfoundation/hardhat-chai-matchers-viem", + "version": "3.0.0", "description": "Hardhat utils for testing", - "homepage": "https://github.com/nomicfoundation/hardhat/tree/main/packages/hardhat-chai-matchers", + "homepage": "https://github.com/nomicfoundation/hardhat/tree/main/packages/hardhat-chai-matchers-viem", "repository": "github:nomicfoundation/hardhat", "author": "Nomic Foundation", "license": "MIT", @@ -40,16 +40,13 @@ "devDependencies": { "@nomicfoundation/eslint-plugin-hardhat-internal-rules": "workspace:^", "@nomicfoundation/eslint-plugin-slow-imports": "workspace:^", - "@nomicfoundation/hardhat-chai-matchers": "workspace:*", - "@nomicfoundation/hardhat-ethers": "workspace:^3.0.0", - "@types/bn.js": "^5.1.0", + "@nomicfoundation/hardhat-chai-matchers-viem": "workspace:*", + "@nomicfoundation/hardhat-viem": "workspace:^2.0.0", "@types/chai": "^4.2.0", "@types/mocha": ">=9.1.0", "@types/node": "^18.0.0", "@typescript-eslint/eslint-plugin": "5.61.0", "@typescript-eslint/parser": "5.61.0", - "bignumber.js": "^9.0.2", - "bn.js": "^5.1.0", "chai": "^4.2.0", "eslint": "^8.44.0", "eslint-config-prettier": "8.3.0", @@ -58,18 +55,20 @@ "eslint-plugin-prettier": "3.4.0", "ethers": "^6.1.0", "get-port": "^5.1.1", - "hardhat": "workspace:^2.9.4", + "hardhat": "workspace:^2.11.0", "mocha": "^10.0.0", "prettier": "2.4.1", "rimraf": "^3.0.2", "ts-node": "^10.8.0", - "typescript": "~5.0.0" + "typescript": "~5.0.4", + "viem": "^2.7.6" }, "peerDependencies": { - "@nomicfoundation/hardhat-ethers": "workspace:^3.0.0", + "@nomicfoundation/hardhat-viem": "workspace:^2.0.0", "chai": "^4.2.0", "ethers": "^6.1.0", - "hardhat": "workspace:^2.9.4" + "hardhat": "workspace:^2.11.0", + "viem": "^2.7.6" }, "dependencies": { "@types/chai-as-promised": "^7.1.3", diff --git a/packages/hardhat-chai-matchers-viem/scripts/check-subpath-exports.js b/packages/hardhat-chai-matchers-viem/scripts/check-subpath-exports.js index 3270f86d51..e28c0794f4 100644 --- a/packages/hardhat-chai-matchers-viem/scripts/check-subpath-exports.js +++ b/packages/hardhat-chai-matchers-viem/scripts/check-subpath-exports.js @@ -5,13 +5,13 @@ const assert = require("assert"); // run as part of the "test" script to avoid having to build the project // every time the tests are run. -const { PANIC_CODES } = require("@nomicfoundation/hardhat-chai-matchers/panic"); +const { PANIC_CODES } = require("@nomicfoundation/hardhat-chai-matchers-viem/panic"); assert(PANIC_CODES !== undefined); const { anyUint, anyValue, -} = require("@nomicfoundation/hardhat-chai-matchers/withArgs"); +} = require("@nomicfoundation/hardhat-chai-matchers-viem/withArgs"); assert(anyUint !== undefined); assert(anyValue !== undefined); diff --git a/packages/hardhat-chai-matchers-viem/src/index.ts b/packages/hardhat-chai-matchers-viem/src/index.ts index d5fa986711..969849afd4 100644 --- a/packages/hardhat-chai-matchers-viem/src/index.ts +++ b/packages/hardhat-chai-matchers-viem/src/index.ts @@ -1,4 +1,4 @@ -import "@nomicfoundation/hardhat-ethers"; +import "@nomicfoundation/hardhat-viem"; import "./types"; diff --git a/packages/hardhat-chai-matchers-viem/src/internal/addressable.ts b/packages/hardhat-chai-matchers-viem/src/internal/addressable.ts index 71ad0c85e1..fd31a72b01 100644 --- a/packages/hardhat-chai-matchers-viem/src/internal/addressable.ts +++ b/packages/hardhat-chai-matchers-viem/src/internal/addressable.ts @@ -1,6 +1,4 @@ -import type EthersT from "ethers"; - -import { tryDereference } from "./typed"; +import type ViemT from "viem"; export function supportAddressable( Assertion: Chai.AssertionStatic, @@ -24,15 +22,16 @@ function override( overwriteAddressableFunction(method, name, negativeName, _super, chaiUtils); } -// ethers's Addressable have a .getAddress() that returns a Promise. We don't want to deal with async here, +// We don't want to deal with async here, // so we are looking for a sync way of getting the address. If an address was recovered, it is returned as a string, // otherwise undefined is returned. function tryGetAddressSync(value: any): string | undefined { - const { isAddress, isAddressable } = require("ethers") as typeof EthersT; + const { isAddress } = require("viem") as typeof ViemT; - value = tryDereference(value, "address"); - if (isAddressable(value)) { - value = (value as any).address ?? (value as any).target; + if (value?.address) { + value = value.address; + } else if (value?.account?.address) { + value = value.account.address; } if (isAddress(value)) { return value; diff --git a/packages/hardhat-chai-matchers-viem/src/internal/changeEtherBalance.ts b/packages/hardhat-chai-matchers-viem/src/internal/changeEtherBalance.ts index 7aeb31c75c..d00f42e07d 100644 --- a/packages/hardhat-chai-matchers-viem/src/internal/changeEtherBalance.ts +++ b/packages/hardhat-chai-matchers-viem/src/internal/changeEtherBalance.ts @@ -1,16 +1,16 @@ -import type { - Addressable, - BigNumberish, - TransactionResponse, - default as EthersT, -} from "ethers"; +import type { WalletClient } from "viem"; + import type { BalanceChangeOptions } from "./misc/balance"; import { buildAssert } from "../utils"; import { ensure } from "./calledOnContract/utils"; import { getAddressOf } from "./misc/account"; import { CHANGE_ETHER_BALANCE_MATCHER } from "./constants"; -import { assertIsNotNull, preventAsyncMatcherChaining } from "./utils"; +import { + assertIsNotNull, + getTransactionReceipt, + preventAsyncMatcherChaining, +} from "./utils"; export function supportChangeEtherBalance( Assertion: Chai.AssertionStatic, @@ -20,11 +20,10 @@ export function supportChangeEtherBalance( CHANGE_ETHER_BALANCE_MATCHER, function ( this: any, - account: Addressable | string, - balanceChange: BigNumberish | ((change: bigint) => boolean), + account: WalletClient | { address: `0x${string}` } | `0x${string}`, + balanceChange: bigint | number | string, options?: BalanceChangeOptions ) { - const { toBigInt } = require("ethers") as typeof EthersT; // capture negated flag before async code executes; see buildAssert's jsdoc const negated = this.__flags.negate; const subject = this._obj; @@ -41,20 +40,11 @@ export function supportChangeEtherBalance( ]) => { const assert = buildAssert(negated, checkBalanceChange); - if (typeof balanceChange === "function") { - assert( - balanceChange(actualChange), - `Expected the ether balance change of "${address}" to satisfy the predicate, but it didn't (balance change: ${actualChange.toString()} wei)`, - `Expected the ether balance change of "${address}" to NOT satisfy the predicate, but it did (balance change: ${actualChange.toString()} wei)` - ); - } else { - const expectedChange = toBigInt(balanceChange); - assert( - actualChange === expectedChange, - `Expected the ether balance of "${address}" to change by ${balanceChange.toString()} wei, but it changed by ${actualChange.toString()} wei`, - `Expected the ether balance of "${address}" NOT to change by ${balanceChange.toString()} wei, but it did` - ); - } + assert( + actualChange === BigInt(balanceChange), + `Expected the ether balance of "${address}" to change by ${balanceChange.toString()} wei, but it changed by ${actualChange.toString()} wei`, + `Expected the ether balance of "${address}" NOT to change by ${balanceChange.toString()} wei, but it did` + ); }; const derivedPromise = Promise.all([ @@ -71,24 +61,25 @@ export function supportChangeEtherBalance( export async function getBalanceChange( transaction: - | TransactionResponse - | Promise - | (() => Promise | TransactionResponse), - account: Addressable | string, + | `0x${string}` + | Promise<`0x${string}`> + | (() => Promise<`0x${string}`> | `0x${string}`), + account: WalletClient | { address: `0x${string}` } | `0x${string}`, options?: BalanceChangeOptions ): Promise { - const hre = await import("hardhat"); - const provider = hre.network.provider; + const { network, viem } = await import("hardhat"); + const provider = network.provider; - let txResponse: TransactionResponse; + let hash: `0x${string}`; if (typeof transaction === "function") { - txResponse = await transaction(); + hash = await transaction(); } else { - txResponse = await transaction; + hash = await transaction; } - const txReceipt = await txResponse.wait(); + const txReceipt = await getTransactionReceipt(hash); + assertIsNotNull(txReceipt, "txReceipt"); const txBlockNumber = txReceipt.blockNumber; @@ -112,14 +103,17 @@ export async function getBalanceChange( const balanceBeforeHex = await provider.send("eth_getBalance", [ address, - `0x${(txBlockNumber - 1).toString(16)}`, + `0x${(txBlockNumber - 1n).toString(16)}`, ]); const balanceAfter = BigInt(balanceAfterHex); const balanceBefore = BigInt(balanceBeforeHex); - if (options?.includeFee !== true && address === txResponse.from) { - const gasPrice = txReceipt.gasPrice; + if ( + options?.includeFee !== true && + address.toLowerCase() === txReceipt.from.toLowerCase() + ) { + const gasPrice = txReceipt.effectiveGasPrice; const gasUsed = txReceipt.gasUsed; const txFee = gasPrice * gasUsed; diff --git a/packages/hardhat-chai-matchers-viem/src/internal/changeEtherBalances.ts b/packages/hardhat-chai-matchers-viem/src/internal/changeEtherBalances.ts index 4bbc58e8ea..6ac17f9af1 100644 --- a/packages/hardhat-chai-matchers-viem/src/internal/changeEtherBalances.ts +++ b/packages/hardhat-chai-matchers-viem/src/internal/changeEtherBalances.ts @@ -1,5 +1,5 @@ -import type EthersT from "ethers"; -import type { Addressable, BigNumberish, TransactionResponse } from "ethers"; +import type { WalletClient, TransactionReceipt } from "viem"; + import type { BalanceChangeOptions } from "./misc/balance"; import type OrdinalT from "ordinal"; @@ -7,7 +7,11 @@ import { buildAssert } from "../utils"; import { getAddressOf } from "./misc/account"; import { getAddresses, getBalances } from "./misc/balance"; import { CHANGE_ETHER_BALANCES_MATCHER } from "./constants"; -import { assertIsNotNull, preventAsyncMatcherChaining } from "./utils"; +import { + assertIsNotNull, + getTransactionReceipt, + preventAsyncMatcherChaining, +} from "./utils"; export function supportChangeEtherBalances( Assertion: Chai.AssertionStatic, @@ -17,11 +21,12 @@ export function supportChangeEtherBalances( CHANGE_ETHER_BALANCES_MATCHER, function ( this: any, - accounts: Array, - balanceChanges: BigNumberish[] | ((changes: bigint[]) => boolean), + accounts: Array< + WalletClient | { address: `0x${string}` } | `0x${string}` + >, + balanceChanges: Array, options?: BalanceChangeOptions ) { - const { toBigInt } = require("ethers") as typeof EthersT; const ordinal = require("ordinal") as typeof OrdinalT; // capture negated flag before async code executes; see buildAssert's jsdoc const negated = this.__flags.negate; @@ -37,61 +42,51 @@ export function supportChangeEtherBalances( chaiUtils ); - validateInput(this._obj, accounts, balanceChanges); - const checkBalanceChanges = ([actualChanges, accountAddresses]: [ bigint[], string[] ]) => { const assert = buildAssert(negated, checkBalanceChanges); - if (typeof balanceChanges === "function") { - assert( - balanceChanges(actualChanges), - "Expected the balance changes of the accounts to satisfy the predicate, but they didn't", - "Expected the balance changes of the accounts to NOT satisfy the predicate, but they did" - ); - } else { - assert( - actualChanges.every( - (change, ind) => change === toBigInt(balanceChanges[ind]) - ), - () => { - const lines: string[] = []; - actualChanges.forEach((change: bigint, i) => { - if (change !== toBigInt(balanceChanges[i])) { - lines.push( - `Expected the ether balance of ${ - accountAddresses[i] - } (the ${ordinal( - i + 1 - )} address in the list) to change by ${balanceChanges[ - i - ].toString()} wei, but it changed by ${change.toString()} wei` - ); - } - }); - return lines.join("\n"); - }, - () => { - const lines: string[] = []; - actualChanges.forEach((change: bigint, i) => { - if (change === toBigInt(balanceChanges[i])) { - lines.push( - `Expected the ether balance of ${ - accountAddresses[i] - } (the ${ordinal( - i + 1 - )} address in the list) NOT to change by ${balanceChanges[ - i - ].toString()} wei, but it did` - ); - } - }); - return lines.join("\n"); - } - ); - } + assert( + actualChanges.every( + (change, ind) => change === BigInt(balanceChanges[ind]) + ), + () => { + const lines: string[] = []; + actualChanges.forEach((change: bigint, i) => { + if (change !== BigInt(balanceChanges[i])) { + lines.push( + `Expected the ether balance of ${ + accountAddresses[i] + } (the ${ordinal( + i + 1 + )} address in the list) to change by ${balanceChanges[ + i + ].toString()} wei, but it changed by ${change.toString()} wei` + ); + } + }); + return lines.join("\n"); + }, + () => { + const lines: string[] = []; + actualChanges.forEach((change: bigint, i) => { + if (change === BigInt(balanceChanges[i])) { + lines.push( + `Expected the ether balance of ${ + accountAddresses[i] + } (the ${ordinal( + i + 1 + )} address in the list) NOT to change by ${balanceChanges[ + i + ].toString()} wei, but it did` + ); + } + }); + return lines.join("\n"); + } + ); }; const derivedPromise = Promise.all([ @@ -106,43 +101,22 @@ export function supportChangeEtherBalances( ); } -function validateInput( - obj: any, - accounts: Array, - balanceChanges: EthersT.BigNumberish[] | ((changes: bigint[]) => boolean) -) { - try { - if ( - Array.isArray(balanceChanges) && - accounts.length !== balanceChanges.length - ) { - throw new Error( - `The number of accounts (${accounts.length}) is different than the number of expected balance changes (${balanceChanges.length})` - ); - } - } catch (e) { - // if the input validation fails, we discard the subject since it could - // potentially be a rejected promise - Promise.resolve(obj).catch(() => {}); - throw e; - } -} - export async function getBalanceChanges( - transaction: TransactionResponse | Promise, - accounts: Array, + transaction: `0x${string}` | Promise<`0x${string}`>, + accounts: Array, options?: BalanceChangeOptions ): Promise { - const txResponse = await transaction; + const hash = await transaction; + + const txReceipt = await getTransactionReceipt(hash); - const txReceipt = await txResponse.wait(); assertIsNotNull(txReceipt, "txReceipt"); const txBlockNumber = txReceipt.blockNumber; const balancesAfter = await getBalances(accounts, txBlockNumber); - const balancesBefore = await getBalances(accounts, txBlockNumber - 1); + const balancesBefore = await getBalances(accounts, txBlockNumber - 1n); - const txFees = await getTxFees(accounts, txResponse, options); + const txFees = await getTxFees(accounts, txReceipt, options); return balancesAfter.map( (balance, ind) => balance + txFees[ind] - balancesBefore[ind] @@ -150,19 +124,18 @@ export async function getBalanceChanges( } async function getTxFees( - accounts: Array, - txResponse: TransactionResponse, + accounts: Array, + txReceipt: TransactionReceipt, options?: BalanceChangeOptions ): Promise { return Promise.all( accounts.map(async (account) => { if ( options?.includeFee !== true && - (await getAddressOf(account)) === txResponse.from + (await getAddressOf(account)).toLowerCase() === + txReceipt.from.toLowerCase() ) { - const txReceipt = await txResponse.wait(); - assertIsNotNull(txReceipt, "txReceipt"); - const gasPrice = txReceipt.gasPrice ?? txResponse.gasPrice; + const gasPrice = txReceipt.effectiveGasPrice; const gasUsed = txReceipt.gasUsed; const txFee = gasPrice * gasUsed; diff --git a/packages/hardhat-chai-matchers-viem/src/internal/changeTokenBalance.ts b/packages/hardhat-chai-matchers-viem/src/internal/changeTokenBalance.ts index 04bc60603f..7271bf79a7 100644 --- a/packages/hardhat-chai-matchers-viem/src/internal/changeTokenBalance.ts +++ b/packages/hardhat-chai-matchers-viem/src/internal/changeTokenBalance.ts @@ -1,11 +1,9 @@ -import type EthersT from "ethers"; import type { - Addressable, - BaseContract, - BaseContractMethod, - BigNumberish, - ContractTransactionResponse, -} from "ethers"; + WalletClient, + GetContractReturnType, + erc20Abi, + PublicClient, +} from "viem"; import { buildAssert } from "../utils"; import { ensure } from "./calledOnContract/utils"; @@ -14,20 +12,13 @@ import { CHANGE_TOKEN_BALANCES_MATCHER, CHANGE_TOKEN_BALANCE_MATCHER, } from "./constants"; -import { assertIsNotNull, preventAsyncMatcherChaining } from "./utils"; - -type TransactionResponse = EthersT.TransactionResponse; +import { + assertIsNotNull, + getTransactionReceipt, + preventAsyncMatcherChaining, +} from "./utils"; -export type Token = BaseContract & { - balanceOf: BaseContractMethod<[string], bigint, bigint>; - name: BaseContractMethod<[], string, string>; - transfer: BaseContractMethod< - [string, BigNumberish], - boolean, - ContractTransactionResponse - >; - symbol: BaseContractMethod<[], string, string>; -}; +type TokenContract = GetContractReturnType; export function supportChangeTokenBalance( Assertion: Chai.AssertionStatic, @@ -37,12 +28,10 @@ export function supportChangeTokenBalance( CHANGE_TOKEN_BALANCE_MATCHER, function ( this: any, - token: Token, - account: Addressable | string, - balanceChange: EthersT.BigNumberish | ((change: bigint) => boolean) + token: TokenContract, + account: WalletClient | { address: `0x${string}` } | `0x${string}`, + balanceChange: bigint | number | string ) { - const ethers = require("ethers") as typeof EthersT; - // capture negated flag before async code executes; see buildAssert's jsdoc const negated = this.__flags.negate; @@ -66,19 +55,11 @@ export function supportChangeTokenBalance( ]) => { const assert = buildAssert(negated, checkBalanceChange); - if (typeof balanceChange === "function") { - assert( - balanceChange(actualChange), - `Expected the balance of ${tokenDescription} tokens for "${address}" to satisfy the predicate, but it didn't (token balance change: ${actualChange.toString()} wei)`, - `Expected the balance of ${tokenDescription} tokens for "${address}" to NOT satisfy the predicate, but it did (token balance change: ${actualChange.toString()} wei)` - ); - } else { - assert( - actualChange === ethers.toBigInt(balanceChange), - `Expected the balance of ${tokenDescription} tokens for "${address}" to change by ${balanceChange.toString()}, but it changed by ${actualChange.toString()}`, - `Expected the balance of ${tokenDescription} tokens for "${address}" NOT to change by ${balanceChange.toString()}, but it did` - ); - } + assert( + actualChange === BigInt(balanceChange), + `Expected the balance of ${tokenDescription} tokens for "${address}" to change by ${balanceChange.toString()}, but it changed by ${actualChange.toString()}`, + `Expected the balance of ${tokenDescription} tokens for "${address}" NOT to change by ${balanceChange.toString()}, but it did` + ); }; const derivedPromise = Promise.all([ @@ -98,12 +79,12 @@ export function supportChangeTokenBalance( CHANGE_TOKEN_BALANCES_MATCHER, function ( this: any, - token: Token, - accounts: Array, - balanceChanges: EthersT.BigNumberish[] | ((changes: bigint[]) => boolean) + token: TokenContract, + accounts: Array< + WalletClient | { address: `0x${string}` } | `0x${string}` + >, + balanceChanges: Array ) { - const ethers = require("ethers") as typeof EthersT; - // capture negated flag before async code executes; see buildAssert's jsdoc const negated = this.__flags.negate; @@ -132,29 +113,21 @@ export function supportChangeTokenBalance( ]: [bigint[], string[], string]) => { const assert = buildAssert(negated, checkBalanceChanges); - if (typeof balanceChanges === "function") { - assert( - balanceChanges(actualChanges), - `Expected the balance changes of ${tokenDescription} to satisfy the predicate, but they didn't`, - `Expected the balance changes of ${tokenDescription} to NOT satisfy the predicate, but they did` - ); - } else { - assert( - actualChanges.every( - (change, ind) => change === ethers.toBigInt(balanceChanges[ind]) - ), - `Expected the balances of ${tokenDescription} tokens for ${ - addresses as any - } to change by ${ - balanceChanges as any - }, respectively, but they changed by ${actualChanges as any}`, - `Expected the balances of ${tokenDescription} tokens for ${ - addresses as any - } NOT to change by ${ - balanceChanges as any - }, respectively, but they did` - ); - } + assert( + actualChanges.every( + (change, ind) => change === BigInt(balanceChanges[ind]) + ), + `Expected the balances of ${tokenDescription} tokens for ${ + addresses as any + } to change by ${ + balanceChanges as any + }, respectively, but they changed by ${actualChanges as any}`, + `Expected the balances of ${tokenDescription} tokens for ${ + addresses as any + } NOT to change by ${ + balanceChanges as any + }, respectively, but they did` + ); }; const derivedPromise = Promise.all([ @@ -173,17 +146,14 @@ export function supportChangeTokenBalance( function validateInput( obj: any, - token: Token, - accounts: Array, - balanceChanges: EthersT.BigNumberish[] | ((changes: bigint[]) => boolean) + token: TokenContract, + accounts: Array, + balanceChanges: Array ) { try { checkToken(token, CHANGE_TOKEN_BALANCES_MATCHER); - if ( - Array.isArray(balanceChanges) && - accounts.length !== balanceChanges.length - ) { + if (accounts.length !== balanceChanges.length) { throw new Error( `The number of accounts (${accounts.length}) is different than the number of expected balance changes (${balanceChanges.length})` ); @@ -197,52 +167,44 @@ function validateInput( } function checkToken(token: unknown, method: string) { - if (typeof token !== "object" || token === null || !("interface" in token)) { + if (typeof token !== "object" || token === null || !("abi" in token)) { throw new Error( `The first argument of ${method} must be the contract instance of the token` ); - } else if ((token as any).interface.getFunction("balanceOf") === null) { + } else if (typeof (token as any)?.read?.balanceOf !== "function") { throw new Error("The given contract instance is not an ERC20 token"); } } export async function getBalanceChange( - transaction: TransactionResponse | Promise, - token: Token, - account: Addressable | string + transaction: `0x${string}` | Promise<`0x${string}`>, + token: TokenContract, + account: WalletClient | { address: `0x${string}` } | `0x${string}` ) { - const ethers = require("ethers") as typeof EthersT; - const hre = await import("hardhat"); - const provider = hre.network.provider; + const { viem } = await import("hardhat"); + const publicClient = await viem.getPublicClient(); - const txResponse = await transaction; - - const txReceipt = await txResponse.wait(); + const hash = await transaction; + const txReceipt = await getTransactionReceipt(hash); assertIsNotNull(txReceipt, "txReceipt"); const txBlockNumber = txReceipt.blockNumber; + const transactionCount = await publicClient.getBlockTransactionCount({ + blockHash: txReceipt.blockHash, + }); - const block = await provider.send("eth_getBlockByHash", [ - txReceipt.blockHash, - false, - ]); - - ensure( - block.transactions.length === 1, - Error, - "Multiple transactions found in block" - ); + ensure(transactionCount === 1, Error, "Multiple transactions found in block"); const address = await getAddressOf(account); - const balanceAfter = await token.balanceOf(address, { - blockTag: txBlockNumber, + const balanceAfter = await token.read.balanceOf([address], { + blockNumber: txBlockNumber, }); - const balanceBefore = await token.balanceOf(address, { - blockTag: txBlockNumber - 1, + const balanceBefore = await token.read.balanceOf([address], { + blockNumber: txBlockNumber - 1n, }); - return ethers.toBigInt(balanceAfter) - balanceBefore; + return balanceAfter - balanceBefore; } let tokenDescriptionsCache: Record = {}; @@ -251,15 +213,15 @@ let tokenDescriptionsCache: Record = {}; * possible; if it doesn't exist, the name is used; if the name doesn't * exist, the address of the token is used. */ -async function getTokenDescription(token: Token): Promise { - const tokenAddress = await token.getAddress(); +async function getTokenDescription(token: TokenContract): Promise { + const tokenAddress = token.address; if (tokenDescriptionsCache[tokenAddress] === undefined) { let tokenDescription = ``; try { - tokenDescription = await token.symbol(); + tokenDescription = await token.read.symbol(); } catch (e) { try { - tokenDescription = await token.name(); + tokenDescription = await token.read.name(); } catch (e2) {} } diff --git a/packages/hardhat-chai-matchers-viem/src/internal/emit.ts b/packages/hardhat-chai-matchers-viem/src/internal/emit.ts index 5718861999..5a883ffd1f 100644 --- a/packages/hardhat-chai-matchers-viem/src/internal/emit.ts +++ b/packages/hardhat-chai-matchers-viem/src/internal/emit.ts @@ -1,5 +1,5 @@ -import type EthersT from "ethers"; -import type { Contract, Interface, Transaction } from "ethers"; +import type { EventFragment, JsonFragment, Interface } from "ethers"; +import type { TransactionReceipt, GetContractReturnType, Abi, Log } from "viem"; import type { AssertWithSsfi, Ssfi } from "../utils"; import { AssertionError } from "chai"; @@ -12,31 +12,27 @@ import { assertArgsArraysEqual, assertIsNotNull, preventAsyncMatcherChaining, + getTransactionReceipt, } from "./utils"; -type EventFragment = EthersT.EventFragment; -type Provider = EthersT.Provider; - export const EMIT_CALLED = "emitAssertionCalled"; async function waitForPendingTransaction( - tx: Promise | Transaction | string, - provider: Provider + tx: Promise<`0x${string}`> | `0x${string}` ) { - let hash: string | null; + let hash: `0x${string}`; if (tx instanceof Promise) { - ({ hash } = await tx); + hash = await tx; } else if (typeof tx === "string") { hash = tx; } else { - ({ hash } = tx); - } - if (hash === null) { throw new Error(`${JSON.stringify(tx)} is not a valid transaction`); } - return provider.getTransactionReceipt(hash); + return getTransactionReceipt(hash); } +type Contract = GetContractReturnType; + export function supportEmit( Assertion: Chai.AssertionStatic, chaiUtils: Chai.ChaiUtils @@ -57,7 +53,7 @@ export function supportEmit( const promise = this.then === undefined ? Promise.resolve() : this; - const onSuccess = (receipt: EthersT.TransactionReceipt) => { + const onSuccess = async (receipt: TransactionReceipt) => { // abort if the assertion chain was aborted, for example because // a `.not` was combined with a `.withArgs` if (chaiUtils.flag(this, ASSERTION_ABORTED) === true) { @@ -66,9 +62,11 @@ export function supportEmit( const assert = buildAssert(negated, onSuccess); + const { ethers } = await import("ethers"); + const iface = new ethers.Interface(contract.abi as JsonFragment[]); let eventFragment: EventFragment | null = null; try { - eventFragment = contract.interface.getEvent(eventName); + eventFragment = iface.getEvent(eventName); } catch (e) { // ignore error } @@ -80,10 +78,10 @@ export function supportEmit( } const topic = eventFragment.topicHash; - const contractAddress = contract.target; + const contractAddress = contract.address; if (typeof contractAddress !== "string") { throw new HardhatChaiMatchersAssertionError( - `The contract target should be a string` + `The contract address should be a string` ); } @@ -94,7 +92,7 @@ export function supportEmit( } this.logs = receipt.logs - .filter((log) => log.topics.includes(topic)) + .filter((log) => (log.topics as string[]).includes(topic)) .filter( (log) => log.address.toLowerCase() === contractAddress.toLowerCase() ); @@ -105,7 +103,7 @@ export function supportEmit( `Expected event "${eventName}" NOT to be emitted, but it was` ); chaiUtils.flag(this, "eventName", eventName); - chaiUtils.flag(this, "contract", contract); + chaiUtils.flag(this, "iface", iface); }; const derivedPromise = promise.then(() => { @@ -115,18 +113,10 @@ export function supportEmit( return; } - if (contract.runner === null || contract.runner.provider === null) { - throw new HardhatChaiMatchersAssertionError( - "contract.runner.provider shouldn't be null" - ); - } - - return waitForPendingTransaction(tx, contract.runner.provider).then( - (receipt) => { - assertIsNotNull(receipt, "receipt"); - return onSuccess(receipt); - } - ); + return waitForPendingTransaction(tx).then((receipt) => { + assertIsNotNull(receipt, "receipt"); + return onSuccess(receipt); + }); }); chaiUtils.flag(this, EMIT_CALLED, true); @@ -165,15 +155,14 @@ const tryAssertArgsArraysEqual = ( Assertion: Chai.AssertionStatic, chaiUtils: Chai.ChaiUtils, expectedArgs: any[], - logs: any[], + logs: Log[], assert: AssertWithSsfi, ssfi: Ssfi ) => { - const eventName = chaiUtils.flag(context, "eventName"); + const eventName: string = chaiUtils.flag(context, "eventName"); + const iface: Interface = chaiUtils.flag(context, "iface"); if (logs.length === 1) { - const parsedLog = ( - chaiUtils.flag(context, "contract").interface as Interface - ).parseLog(logs[0]); + const parsedLog = iface.parseLog(logs[0]); assertIsNotNull(parsedLog, "parsedLog"); return assertArgsArraysEqual( @@ -186,28 +175,22 @@ const tryAssertArgsArraysEqual = ( ssfi ); } - for (const index in logs) { - if (index === undefined) { - break; - } else { - try { - const parsedLog = ( - chaiUtils.flag(context, "contract").interface as Interface - ).parseLog(logs[index]); - assertIsNotNull(parsedLog, "parsedLog"); - - assertArgsArraysEqual( - Assertion, - expectedArgs, - parsedLog.args, - `"${eventName}" event`, - "event", - assert, - ssfi - ); - return; - } catch {} - } + for (const log of logs) { + const parsedLog = iface.parseLog(log); + assertIsNotNull(parsedLog, "parsedLog"); + try { + // assert and return if successful, otherwise keep looping + assertArgsArraysEqual( + Assertion, + expectedArgs, + parsedLog.args, + `"${eventName}" event`, + "event", + assert, + ssfi + ); + return; + } catch {} } assert( @@ -215,7 +198,7 @@ const tryAssertArgsArraysEqual = ( `The specified arguments (${util.inspect( expectedArgs )}) were not included in any of the ${ - context.logs.length + logs.length } emitted "${eventName}" events` ); }; diff --git a/packages/hardhat-chai-matchers-viem/src/internal/errors.ts b/packages/hardhat-chai-matchers-viem/src/internal/errors.ts index c490c1d42a..9cc5760edd 100644 --- a/packages/hardhat-chai-matchers-viem/src/internal/errors.ts +++ b/packages/hardhat-chai-matchers-viem/src/internal/errors.ts @@ -2,7 +2,7 @@ import { NomicLabsHardhatPluginError } from "hardhat/plugins"; export class HardhatChaiMatchersError extends NomicLabsHardhatPluginError { constructor(message: string, parent?: Error) { - super("@nomicfoundation/hardhat-chai-matchers", message, parent); + super("@nomicfoundation/hardhat-chai-matchers-viem", message, parent); } } diff --git a/packages/hardhat-chai-matchers-viem/src/internal/hardhatWaffleIncompatibilityCheck.ts b/packages/hardhat-chai-matchers-viem/src/internal/hardhatWaffleIncompatibilityCheck.ts index 2f2638fb9d..3e044e8601 100644 --- a/packages/hardhat-chai-matchers-viem/src/internal/hardhatWaffleIncompatibilityCheck.ts +++ b/packages/hardhat-chai-matchers-viem/src/internal/hardhatWaffleIncompatibilityCheck.ts @@ -1,9 +1,9 @@ export function hardhatWaffleIncompatibilityCheck() { if ((global as any).__HARDHAT_WAFFLE_IS_LOADED === true) { throw new Error( - `You are using both @nomicfoundation/hardhat-chai-matchers and @nomiclabs/hardhat-waffle. They don't work correctly together, so please make sure you only use one. + `You are using both @nomicfoundation/hardhat-chai-matchers-viem and @nomiclabs/hardhat-waffle. They don't work correctly together, so please make sure you only use one. -We recommend you migrate to @nomicfoundation/hardhat-chai-matchers. Learn how to do it here: https://hardhat.org/migrate-from-waffle` +We recommend you migrate to @nomicfoundation/hardhat-chai-matchers-viem. Learn how to do it here: https://hardhat.org/migrate-from-waffle` ); } diff --git a/packages/hardhat-chai-matchers-viem/src/internal/misc/account.ts b/packages/hardhat-chai-matchers-viem/src/internal/misc/account.ts index c4d7e536ce..bccf33fe30 100644 --- a/packages/hardhat-chai-matchers-viem/src/internal/misc/account.ts +++ b/packages/hardhat-chai-matchers-viem/src/internal/misc/account.ts @@ -1,24 +1,41 @@ -import type { Addressable } from "ethers"; - +import type { WalletClient } from "viem"; import assert from "assert"; import { HardhatChaiMatchersAssertionError } from "../errors"; export async function getAddressOf( - account: Addressable | string -): Promise { - const { isAddressable } = await import("ethers"); - + account: WalletClient | { address: `0x${string}` } | `0x${string}` +): Promise<`0x${string}`> { if (typeof account === "string") { assert(/^0x[0-9a-fA-F]{40}$/.test(account), `Invalid address ${account}`); return account; } - if (isAddressable(account)) { - return account.getAddress(); + if ("account" in account && account.account?.address) { + assert( + /^0x[0-9a-fA-F]{40}$/.test(account.account.address), + `Invalid address ${account.account.address}` + ); + return account.account.address; + } + + if ("address" in account && account.address) { + assert( + /^0x[0-9a-fA-F]{40}$/.test(account.address), + `Invalid address ${account.address}` + ); + return account.address; + } + + if ("getAddresses" in account && typeof account.getAddresses === "function") { + const [address] = await account.getAddresses(); + assert(/^0x[0-9a-fA-F]{40}$/.test(address), `Invalid address ${address}`); + return address; } throw new HardhatChaiMatchersAssertionError( - `Expected string or addressable, got ${account as any}` + `Expected \`0x\${string}\`, WalletClient, or contract, got ${ + account as any + }` ); } diff --git a/packages/hardhat-chai-matchers-viem/src/internal/misc/balance.ts b/packages/hardhat-chai-matchers-viem/src/internal/misc/balance.ts index 9bd93f6827..134f4247f4 100644 --- a/packages/hardhat-chai-matchers-viem/src/internal/misc/balance.ts +++ b/packages/hardhat-chai-matchers-viem/src/internal/misc/balance.ts @@ -1,4 +1,4 @@ -import type { Addressable } from "ethers"; +import type { WalletClient } from "viem"; import { getAddressOf } from "./account"; @@ -6,17 +6,19 @@ export interface BalanceChangeOptions { includeFee?: boolean; } -export function getAddresses(accounts: Array) { +export function getAddresses( + accounts: Array +) { return Promise.all(accounts.map((account) => getAddressOf(account))); } export async function getBalances( - accounts: Array, - blockNumber?: number + accounts: Array, + blockNumber?: bigint ): Promise { - const { toBigInt } = await import("ethers"); - const hre = await import("hardhat"); - const provider = hre.ethers.provider; + const { network } = await import("hardhat"); + const { hexToBigInt } = await import("viem"); + const provider = network.provider; return Promise.all( accounts.map(async (account) => { @@ -25,7 +27,7 @@ export async function getBalances( address, `0x${blockNumber?.toString(16) ?? 0}`, ]); - return toBigInt(result); + return hexToBigInt(result); }) ); } diff --git a/packages/hardhat-chai-matchers-viem/src/internal/reverted/reverted.ts b/packages/hardhat-chai-matchers-viem/src/internal/reverted/reverted.ts index 77a3c74ea7..2e81dfe73c 100644 --- a/packages/hardhat-chai-matchers-viem/src/internal/reverted/reverted.ts +++ b/packages/hardhat-chai-matchers-viem/src/internal/reverted/reverted.ts @@ -1,9 +1,11 @@ -import type EthersT from "ethers"; - import { buildAssert } from "../../utils"; import { REVERTED_MATCHER } from "../constants"; -import { assertIsNotNull, preventAsyncMatcherChaining } from "../utils"; -import { decodeReturnData, getReturnDataFromError } from "./utils"; +import { + assertIsNotNull, + preventAsyncMatcherChaining, + getTransactionReceipt, +} from "../utils"; +import { decodeReturnData, getReturnDataFromError, toBeHex } from "./utils"; export function supportReverted( Assertion: Chai.AssertionStatic, @@ -25,28 +27,24 @@ export function supportReverted( const onSuccess = async (value: unknown) => { const assert = buildAssert(negated, onSuccess); - if (isTransactionResponse(value) || typeof value === "string") { - const hash = typeof value === "string" ? value : value.hash; - - if (!isValidTransactionHash(hash)) { + if (typeof value === "string") { + if (!isValidTransactionHash(value)) { throw new TypeError( - `Expected a valid transaction hash, but got '${hash}'` + `Expected a valid transaction hash, but got '${value}'` ); } - const receipt = await getTransactionReceipt(hash); + const receipt = await getTransactionReceipt(value); assertIsNotNull(receipt, "receipt"); assert( - receipt.status === 0, + receipt.status === "reverted", "Expected transaction to be reverted", "Expected transaction NOT to be reverted" ); } else if (isTransactionReceipt(value)) { - const receipt = value; - assert( - receipt.status === 0, + value.status === "reverted", "Expected transaction to be reverted", "Expected transaction NOT to be reverted" ); @@ -62,7 +60,6 @@ export function supportReverted( }; const onError = (error: any) => { - const { toBeHex } = require("ethers") as typeof EthersT; const assert = buildAssert(negated, onError); const returnData = getReturnDataFromError(error); const decodedReturnData = decodeReturnData(returnData); @@ -104,33 +101,21 @@ export function supportReverted( }); } -async function getTransactionReceipt(hash: string) { - const hre = await import("hardhat"); - - return hre.ethers.provider.getTransactionReceipt(hash); -} - -function isTransactionResponse(x: unknown): x is { hash: string } { - if (typeof x === "object" && x !== null) { - return "hash" in x; - } - - return false; -} - -function isTransactionReceipt(x: unknown): x is { status: number } { +function isTransactionReceipt( + x: unknown +): x is { status: "reverted" | "success" } { if (typeof x === "object" && x !== null && "status" in x) { const status = (x as any).status; - // this means we only support ethers's receipts for now; adding support for + // this means we only support viem's receipts for now; adding support for // raw receipts, where the status is an hexadecimal string, should be easy // and we can do it if there's demand for that - return typeof status === "number"; + return status === "reverted" || status === "success"; } return false; } -function isValidTransactionHash(x: string): boolean { +function isValidTransactionHash(x: string): x is `0x${string}` { return /0x[0-9a-fA-F]{64}/.test(x); } diff --git a/packages/hardhat-chai-matchers-viem/src/internal/reverted/revertedWith.ts b/packages/hardhat-chai-matchers-viem/src/internal/reverted/revertedWith.ts index 442f24d6b0..df4a9a4d6c 100644 --- a/packages/hardhat-chai-matchers-viem/src/internal/reverted/revertedWith.ts +++ b/packages/hardhat-chai-matchers-viem/src/internal/reverted/revertedWith.ts @@ -1,9 +1,7 @@ -import type EthersT from "ethers"; - import { buildAssert } from "../../utils"; import { REVERTED_WITH_MATCHER } from "../constants"; import { preventAsyncMatcherChaining } from "../utils"; -import { decodeReturnData, getReturnDataFromError } from "./utils"; +import { decodeReturnData, getReturnDataFromError, toBeHex } from "./utils"; export function supportRevertedWith( Assertion: Chai.AssertionStatic, @@ -45,7 +43,6 @@ export function supportRevertedWith( }; const onError = (error: any) => { - const { toBeHex } = require("ethers") as typeof EthersT; const assert = buildAssert(negated, onError); const returnData = getReturnDataFromError(error); diff --git a/packages/hardhat-chai-matchers-viem/src/internal/reverted/revertedWithCustomError.ts b/packages/hardhat-chai-matchers-viem/src/internal/reverted/revertedWithCustomError.ts index 94dc79552c..b79f4c6e7b 100644 --- a/packages/hardhat-chai-matchers-viem/src/internal/reverted/revertedWithCustomError.ts +++ b/packages/hardhat-chai-matchers-viem/src/internal/reverted/revertedWithCustomError.ts @@ -1,4 +1,10 @@ -import type EthersT from "ethers"; +import type { + default as EthersT, + Interface, + ErrorFragment, + JsonFragment, +} from "ethers"; +import type { GetContractReturnType } from "viem"; import { ASSERTION_ABORTED, @@ -14,16 +20,19 @@ import { decodeReturnData, getReturnDataFromError, resultToArray, + toBeHex, } from "./utils"; export const REVERTED_WITH_CUSTOM_ERROR_CALLED = "customErrorAssertionCalled"; interface CustomErrorAssertionData { - contractInterface: EthersT.Interface; - returnData: string; - customError: EthersT.ErrorFragment; + contractInterface: Interface; + returnData: `0x${string}`; + customError: ErrorFragment; } +type Contract = GetContractReturnType; + export function supportRevertedWithCustomError( Assertion: Chai.AssertionStatic, chaiUtils: Chai.ChaiUtils @@ -32,7 +41,7 @@ export function supportRevertedWithCustomError( REVERTED_WITH_CUSTOM_ERROR_MATCHER, function ( this: any, - contract: EthersT.BaseContract, + contract: Contract, expectedCustomErrorName: string, ...args: any[] ) { @@ -70,8 +79,6 @@ export function supportRevertedWithCustomError( return; } - const { toBeHex } = require("ethers") as typeof EthersT; - const assert = buildAssert(negated, onError); const returnData = getReturnDataFromError(error); @@ -150,14 +157,14 @@ export function supportRevertedWithCustomError( function validateInput( obj: any, - contract: EthersT.BaseContract, + contract: Contract, expectedCustomErrorName: string, args: any[] -): { iface: EthersT.Interface; expectedCustomError: EthersT.ErrorFragment } { +): { iface: Interface; expectedCustomError: ErrorFragment } { try { // check the case where users forget to pass the contract as the first // argument - if (typeof contract === "string" || contract?.interface === undefined) { + if (typeof contract === "string" || contract?.abi === undefined) { // discard subject since it could potentially be a rejected promise throw new TypeError( "The first argument of .revertedWithCustomError must be the contract that defines the custom error" @@ -169,7 +176,8 @@ function validateInput( throw new TypeError("Expected the custom error name to be a string"); } - const iface = contract.interface; + const { ethers } = require("ethers") as typeof EthersT; + const iface = new ethers.Interface(contract.abi as JsonFragment[]); const expectedCustomError = iface.getError(expectedCustomErrorName); // check that interface contains the given custom error diff --git a/packages/hardhat-chai-matchers-viem/src/internal/reverted/revertedWithPanic.ts b/packages/hardhat-chai-matchers-viem/src/internal/reverted/revertedWithPanic.ts index 04ed1467fa..10eef293aa 100644 --- a/packages/hardhat-chai-matchers-viem/src/internal/reverted/revertedWithPanic.ts +++ b/packages/hardhat-chai-matchers-viem/src/internal/reverted/revertedWithPanic.ts @@ -1,12 +1,10 @@ -import type EthersT from "ethers"; - import { normalizeToBigInt } from "hardhat/common"; import { buildAssert } from "../../utils"; import { REVERTED_WITH_PANIC_MATCHER } from "../constants"; import { preventAsyncMatcherChaining } from "../utils"; import { panicErrorCodeToReason } from "./panic"; -import { decodeReturnData, getReturnDataFromError } from "./utils"; +import { decodeReturnData, getReturnDataFromError, toBeHex } from "./utils"; export function supportRevertedWithPanic( Assertion: Chai.AssertionStatic, @@ -15,8 +13,6 @@ export function supportRevertedWithPanic( Assertion.addMethod( REVERTED_WITH_PANIC_MATCHER, function (this: any, expectedCodeArg: any) { - const ethers = require("ethers") as typeof EthersT; - // capture negated flag before async code executes; see buildAssert's jsdoc const negated = this.__flags.negate; @@ -41,11 +37,8 @@ export function supportRevertedWithPanic( if (code === undefined) { formattedPanicCode = "some panic code"; } else { - const codeBN = ethers.toBigInt(code); - description = panicErrorCodeToReason(codeBN) ?? "unknown panic code"; - formattedPanicCode = `panic code ${ethers.toBeHex( - codeBN - )} (${description})`; + description = panicErrorCodeToReason(code) ?? "unknown panic code"; + formattedPanicCode = `panic code ${toBeHex(code)} (${description})`; } preventAsyncMatcherChaining(this, REVERTED_WITH_PANIC_MATCHER, chaiUtils); @@ -79,7 +72,7 @@ export function supportRevertedWithPanic( if (code !== undefined) { assert( decodedReturnData.code === code, - `Expected transaction to be reverted with ${formattedPanicCode}, but it reverted with panic code ${ethers.toBeHex( + `Expected transaction to be reverted with ${formattedPanicCode}, but it reverted with panic code ${toBeHex( decodedReturnData.code )} (${decodedReturnData.description})`, `Expected transaction NOT to be reverted with ${formattedPanicCode}, but it was` @@ -88,7 +81,7 @@ export function supportRevertedWithPanic( assert( true, undefined, - `Expected transaction NOT to be reverted with ${formattedPanicCode}, but it reverted with panic code ${ethers.toBeHex( + `Expected transaction NOT to be reverted with ${formattedPanicCode}, but it reverted with panic code ${toBeHex( decodedReturnData.code )} (${decodedReturnData.description})` ); diff --git a/packages/hardhat-chai-matchers-viem/src/internal/reverted/revertedWithoutReason.ts b/packages/hardhat-chai-matchers-viem/src/internal/reverted/revertedWithoutReason.ts index 1273aa969b..40cf0f81a8 100644 --- a/packages/hardhat-chai-matchers-viem/src/internal/reverted/revertedWithoutReason.ts +++ b/packages/hardhat-chai-matchers-viem/src/internal/reverted/revertedWithoutReason.ts @@ -1,9 +1,7 @@ -import type EthersT from "ethers"; - import { buildAssert } from "../../utils"; import { REVERTED_WITHOUT_REASON_MATCHER } from "../constants"; import { preventAsyncMatcherChaining } from "../utils"; -import { decodeReturnData, getReturnDataFromError } from "./utils"; +import { decodeReturnData, getReturnDataFromError, toBeHex } from "./utils"; export function supportRevertedWithoutReason( Assertion: Chai.AssertionStatic, @@ -29,7 +27,6 @@ export function supportRevertedWithoutReason( }; const onError = (error: any) => { - const { toBeHex } = require("ethers") as typeof EthersT; const assert = buildAssert(negated, onError); const returnData = getReturnDataFromError(error); diff --git a/packages/hardhat-chai-matchers-viem/src/internal/reverted/utils.ts b/packages/hardhat-chai-matchers-viem/src/internal/reverted/utils.ts index 253ed71562..26a1ea906b 100644 --- a/packages/hardhat-chai-matchers-viem/src/internal/reverted/utils.ts +++ b/packages/hardhat-chai-matchers-viem/src/internal/reverted/utils.ts @@ -1,4 +1,5 @@ -import type EthersT from "ethers"; +import type { Result } from "ethers"; +import type ViemT from "viem"; import { AssertionError } from "chai"; @@ -17,7 +18,7 @@ const PANIC_CODE_PREFIX = "0x4e487b71"; * If the value is an error but it doesn't have data, we assume it's not related * to a reverted transaction and we re-throw it. */ -export function getReturnDataFromError(error: any): string { +export function getReturnDataFromError(error: any): `0x${string}` { if (!(error instanceof Error)) { throw new AssertionError("Expected an Error object"); } @@ -26,15 +27,29 @@ export function getReturnDataFromError(error: any): string { // some property that doesn't exist on Error error = error as any; - const errorData = error.data ?? error.error?.data; - - if (errorData === undefined) { - throw error; - } - - const returnData = typeof errorData === "string" ? errorData : errorData.data; - - if (returnData === undefined || typeof returnData !== "string") { + // a list of the possible locations for error return data + // it varies based on a number of things: + // 1. internal hardhat network or external + // 2. read or write contract interation type + // 3. ethers or viem + // 4. probably a lot more + const returnData: `0x${string}` | undefined = [ + error?.data, + error?.error?.data, + error?.data?.data, + error?.error?.data?.data, + error?.cause?.cause?.data, + error?.cause?.cause?.data?.data, + error?.cause?.cause?.cause?.data, + error?.cause?.cause?.cause?.data?.data, + ].find( + (returnData: any) => + typeof returnData === "string" && returnData.startsWith("0x") + ); + console.log(returnData); + + if (typeof returnData !== "string") { + console.log(JSON.stringify(error, undefined, 2)); throw error; } @@ -61,8 +76,8 @@ type DecodedReturnData = }; export function decodeReturnData(returnData: string): DecodedReturnData { - const { AbiCoder } = require("ethers") as typeof EthersT; - const abi = new AbiCoder(); + const { decodeAbiParameters, parseAbiParameters } = + require("viem") as typeof ViemT; if (returnData === "0x") { return { kind: "Empty" }; @@ -70,7 +85,10 @@ export function decodeReturnData(returnData: string): DecodedReturnData { const encodedReason = returnData.slice(ERROR_STRING_PREFIX.length); let reason: string; try { - reason = abi.decode(["string"], `0x${encodedReason}`)[0]; + reason = decodeAbiParameters( + parseAbiParameters("string"), + `0x${encodedReason}` + )[0]; } catch (e: any) { throw new HardhatChaiMatchersDecodingError(encodedReason, "string", e); } @@ -83,7 +101,10 @@ export function decodeReturnData(returnData: string): DecodedReturnData { const encodedReason = returnData.slice(PANIC_CODE_PREFIX.length); let code: bigint; try { - code = abi.decode(["uint256"], `0x${encodedReason}`)[0]; + code = decodeAbiParameters( + parseAbiParameters("uint256"), + `0x${encodedReason}` + )[0]; } catch (e: any) { throw new HardhatChaiMatchersDecodingError(encodedReason, "uint256", e); } @@ -116,7 +137,7 @@ export function decodeReturnData(returnData: string): DecodedReturnData { * * The resulting array will be: ["foo", [1n, 2n]] */ -export function resultToArray(result: EthersT.Result): any[] { +export function resultToArray(result: Result): any[] { return result .toArray() .map((x) => @@ -125,3 +146,12 @@ export function resultToArray(result: EthersT.Result): any[] { : x ); } + +export function toBeHex(value: bigint) { + let result = value.toString(16); + // Ensure the value is of even length + if (result.length % 2) { + result = `0${result}`; + } + return `0x${result}`; +} diff --git a/packages/hardhat-chai-matchers-viem/src/internal/utils.ts b/packages/hardhat-chai-matchers-viem/src/internal/utils.ts index 82c400d7b8..6a9d9e600e 100644 --- a/packages/hardhat-chai-matchers-viem/src/internal/utils.ts +++ b/packages/hardhat-chai-matchers-viem/src/internal/utils.ts @@ -1,4 +1,4 @@ -import type EthersT from "ethers"; +import type ViemT from "viem"; import type OrdinalT from "ordinal"; import { AssertWithSsfi, Ssfi } from "../utils"; @@ -19,6 +19,17 @@ export function assertIsNotNull( } } +export function assertIsNotUndefined( + value: T, + valueName: string +): asserts value is Exclude { + if (typeof value === "undefined") { + throw new HardhatChaiMatchersAssertionError( + `${valueName} should not be undefined` + ); + } +} + export function preventAsyncMatcherChaining( context: object, matcherName: string, @@ -109,7 +120,8 @@ function innerAssertArgEqual( assert: AssertWithSsfi, ssfi: Ssfi ) { - const ethers = require("ethers") as typeof EthersT; + const { toHex, isHex, hexToBytes, stringToBytes, keccak256 } = + require("viem") as typeof ViemT; if (typeof expectedArg === "function") { try { if (expectedArg(actualArg) === true) return; @@ -128,9 +140,7 @@ function innerAssertArgEqual( // .withArgs ); } else if (expectedArg instanceof Uint8Array) { - new Assertion(actualArg, undefined, ssfi, true).equal( - ethers.hexlify(expectedArg) - ); + new Assertion(actualArg, undefined, ssfi, true).equal(toHex(expectedArg)); } else if ( expectedArg?.length !== undefined && typeof expectedArg !== "string" @@ -155,10 +165,10 @@ function innerAssertArgEqual( expectedArg, "The actual value was an indexed and hashed value of the event argument. The expected value provided to the assertion should be the actual event argument (the pre-image of the hash). You provided the hash itself. Please supply the actual event argument (the pre-image of the hash) instead." ); - const expectedArgBytes = ethers.isHexString(expectedArg) - ? ethers.getBytes(expectedArg) - : ethers.toUtf8Bytes(expectedArg); - const expectedHash = ethers.keccak256(expectedArgBytes); + const expectedArgBytes = isHex(expectedArg) + ? hexToBytes(expectedArg) + : stringToBytes(expectedArg); + const expectedHash = keccak256(expectedArgBytes); new Assertion(actualArg.hash, undefined, ssfi, true).to.equal( expectedHash, `The actual value was an indexed and hashed value of the event argument. The expected value provided to the assertion was hashed to produce ${expectedHash}. The actual hash and the expected hash ${actualArg.hash} did not match` @@ -168,3 +178,9 @@ function innerAssertArgEqual( } } } + +export async function getTransactionReceipt(hash: `0x${string}`) { + const { viem } = await import("hardhat"); + const publicClient = await viem.getPublicClient(); + return publicClient.waitForTransactionReceipt({ hash }); +} diff --git a/packages/hardhat-chai-matchers-viem/src/internal/withArgs.ts b/packages/hardhat-chai-matchers-viem/src/internal/withArgs.ts index 1124b6535e..ab5f5aa3ae 100644 --- a/packages/hardhat-chai-matchers-viem/src/internal/withArgs.ts +++ b/packages/hardhat-chai-matchers-viem/src/internal/withArgs.ts @@ -1,4 +1,3 @@ -import type EthersT from "ethers"; import { AssertionError } from "chai"; import { isBigNumber, normalizeToBigInt } from "hardhat/common"; @@ -55,12 +54,16 @@ export function supportWithArgs( Assertion.addMethod("withArgs", function (this: any, ...expectedArgs: any[]) { const { emitCalled } = validateInput.call(this, chaiUtils); - const { isAddressable } = require("ethers") as typeof EthersT; - // Resolve arguments to their canonical form: - // - Addressable → address + // - WalletClient or contract → address const resolveArgument = (arg: any) => - isAddressable(arg) ? arg.getAddress() : arg; + arg?.account?.address + ? arg.account.address + : arg?.address + ? arg.address + : typeof arg.getAddresses === "function" + ? arg.getAddresses() + : arg; const onSuccess = (resolvedExpectedArgs: any[]) => { if (emitCalled) { diff --git a/packages/hardhat-chai-matchers-viem/src/panic.ts b/packages/hardhat-chai-matchers-viem/src/panic.ts index be1b86a93c..04c7c33447 100644 --- a/packages/hardhat-chai-matchers-viem/src/panic.ts +++ b/packages/hardhat-chai-matchers-viem/src/panic.ts @@ -1,2 +1,2 @@ -// re-export here so users can import from "@nomicfoundation/hardhat-chai-matchers/panic" +// re-export here so users can import from "@nomicfoundation/hardhat-chai-matchers-viem/panic" export { PANIC_CODES } from "./internal/reverted/panic"; diff --git a/packages/hardhat-chai-matchers-viem/src/tsconfig.json b/packages/hardhat-chai-matchers-viem/src/tsconfig.json index 3fe5d00bcf..f9bb9d3f1a 100644 --- a/packages/hardhat-chai-matchers-viem/src/tsconfig.json +++ b/packages/hardhat-chai-matchers-viem/src/tsconfig.json @@ -13,7 +13,7 @@ "path": "../../hardhat-core/src" }, { - "path": "../../hardhat-ethers/src" + "path": "../../hardhat-viem/src" } ] } diff --git a/packages/hardhat-chai-matchers-viem/src/types.ts b/packages/hardhat-chai-matchers-viem/src/types.ts index b4a2332c1d..4b8d6f7ada 100644 --- a/packages/hardhat-chai-matchers-viem/src/types.ts +++ b/packages/hardhat-chai-matchers-viem/src/types.ts @@ -10,7 +10,7 @@ declare namespace Chai { revertedWithoutReason(): AsyncAssertion; revertedWithPanic(code?: any): AsyncAssertion; revertedWithCustomError( - contract: { interface: any }, + contract: { abi: any }, customErrorName: string ): CustomErrorAssertion; hexEqual(other: string): void; @@ -24,14 +24,14 @@ declare namespace Chai { ): AsyncAssertion; changeEtherBalances( accounts: any[], - balances: any[] | ((changes: bigint[]) => boolean), + balances: any[], options?: any ): AsyncAssertion; changeTokenBalance(token: any, account: any, balance: any): AsyncAssertion; changeTokenBalances( token: any, account: any[], - balance: any[] | ((changes: bigint[]) => boolean) + balance: any[] ): AsyncAssertion; } diff --git a/packages/hardhat-chai-matchers-viem/test/addressable.ts b/packages/hardhat-chai-matchers-viem/test/addressable.ts index 5b1b146232..ca1637a194 100644 --- a/packages/hardhat-chai-matchers-viem/test/addressable.ts +++ b/packages/hardhat-chai-matchers-viem/test/addressable.ts @@ -1,48 +1,38 @@ -import { ethers } from "ethers"; +import { generatePrivateKey, privateKeyToAccount } from "viem/accounts"; +import { getContract, createWalletClient, custom } from "viem"; import { AssertionError, expect } from "chai"; import "../src/internal/add-chai-matchers"; describe("Addressable matcher", () => { - const signer = ethers.Wallet.createRandom(); - const address = signer.address; - const contract = new ethers.Contract(address, []); - const typedAddress = ethers.Typed.address(address); - const typedSigner = ethers.Typed.address(signer); - const typedContract = ethers.Typed.address(contract); + // create dummy transport so we can create wallets and get contracts + const transport = custom({ + async request() {}, + }); - const otherSigner = ethers.Wallet.createRandom(); - const otherAddress = otherSigner.address; - const otherContract = new ethers.Contract(otherAddress, []); - const otherTypedAddress = ethers.Typed.address(otherAddress); - const otherTypedSigner = ethers.Typed.address(otherSigner); - const otherTypedContract = ethers.Typed.address(otherContract); + const account = privateKeyToAccount(generatePrivateKey()); + const address = account.address; + const wallet = createWalletClient({ account, transport }); + const contract = getContract({ abi: [], address, client: wallet }); + + const otherAccount = privateKeyToAccount(generatePrivateKey()); + const otherAddress = otherAccount.address; + const otherWallet = createWalletClient({ account: otherAccount, transport }); + const otherContract = getContract({ + abi: [], + address: otherAddress, + client: otherWallet, + }); const elements = [ { name: "address", object: address, class: address }, - { name: "signer", object: signer, class: address }, + { name: "account", object: account, class: address }, + { name: "wallet", object: wallet, class: address }, { name: "contract", object: contract, class: address }, - { name: "typed address", object: typedAddress, class: address }, - { name: "typed signer", object: typedSigner, class: address }, - { name: "typed contract", object: typedContract, class: address }, { name: "other address", object: otherAddress, class: otherAddress }, - { name: "other signer", object: otherSigner, class: otherAddress }, + { name: "other account", object: otherAccount, class: otherAddress }, + { name: "other wallet", object: otherWallet, class: otherAddress }, { name: "other contract", object: otherContract, class: otherAddress }, - { - name: "other typed address", - object: otherTypedAddress, - class: otherAddress, - }, - { - name: "other typed signer", - object: otherTypedSigner, - class: otherAddress, - }, - { - name: "other typed contract", - object: otherTypedContract, - class: otherAddress, - }, ]; for (const el1 of elements) diff --git a/packages/hardhat-chai-matchers-viem/test/bigNumber.ts b/packages/hardhat-chai-matchers-viem/test/bigNumber.ts index 0353333c97..c80ab0d328 100644 --- a/packages/hardhat-chai-matchers-viem/test/bigNumber.ts +++ b/packages/hardhat-chai-matchers-viem/test/bigNumber.ts @@ -1,28 +1,15 @@ import { expect, AssertionError } from "chai"; -import { BigNumber as BigNumberJs } from "bignumber.js"; -import BN from "bn.js"; import { HardhatError } from "hardhat/internal/core/errors"; import "../src/internal/add-chai-matchers"; -type SupportedNumber = number | bigint | BN | BigNumberJs; +type SupportedNumber = number | bigint; -const numberToBigNumberConversions = [ - (n: number) => BigInt(n), - (n: number) => new BN(n), - (n: number) => new BigNumberJs(n), -]; +const numberToBigNumberConversions = [(n: number) => BigInt(n)]; describe("BigNumber matchers", function () { function typestr(n: string | SupportedNumber): string { - if (typeof n === "object") { - if (n instanceof BN) { - return "BN"; - } else if (n instanceof BigNumberJs) { - return "bignumber.js"; - } - } return typeof n; } @@ -576,11 +563,7 @@ describe("BigNumber matchers", function () { const convertedActual = convertActual(actual); const convertedExpected = convertExpected(expected); // a few particular combinations of types don't work: - if ( - typeof convertedActual === "string" && - !BN.isBN(convertedExpected) && - !BigNumberJs.isBigNumber(convertedExpected) - ) { + if (typeof convertedActual === "string") { continue; } if ( @@ -832,13 +815,13 @@ describe("BigNumber matchers", function () { describe(`when using .to.${operator}`, function () { it("with an unsafe int as the first param", function () { - expect(() => expect(unsafeInt).to[operator](1n)).to.throw( + expect(() => expect(unsafeInt).to[operator](BigInt(1))).to.throw( HardhatError, msg ); }); it("with an unsafe int as the second param", function () { - expect(() => expect(1n).to[operator](unsafeInt)).to.throw( + expect(() => expect(BigInt(1)).to[operator](unsafeInt)).to.throw( HardhatError, msg ); @@ -847,16 +830,14 @@ describe("BigNumber matchers", function () { describe(`when using .not.to.${operator}`, function () { it("with an unsafe int as the first param", function () { - expect(() => expect(unsafeInt).not.to[operator](1n)).to.throw( - HardhatError, - msg - ); + expect(() => + expect(unsafeInt).not.to[operator](BigInt(1)) + ).to.throw(HardhatError, msg); }); it("with an unsafe int as the second param", function () { - expect(() => expect(1n).not.to[operator](unsafeInt)).to.throw( - HardhatError, - msg - ); + expect(() => + expect(BigInt(1)).not.to[operator](unsafeInt) + ).to.throw(HardhatError, msg); }); }); }); @@ -1155,43 +1136,37 @@ describe("BigNumber matchers", function () { describe(`when using .to.${operator}`, function () { it("with an unsafe int as the first param", function () { - expect(() => expect(unsafeInt).to[operator](1n, 1n)).to.throw( - HardhatError, - msg - ); + expect(() => + expect(unsafeInt).to[operator](BigInt(1), BigInt(1)) + ).to.throw(HardhatError, msg); }); it("with an unsafe int as the second param", function () { - expect(() => expect(1n).to[operator](unsafeInt, 1n)).to.throw( - HardhatError, - msg - ); + expect(() => + expect(BigInt(1)).to[operator](unsafeInt, BigInt(1)) + ).to.throw(HardhatError, msg); }); it("with an unsafe int as the third param", function () { - expect(() => expect(1n).to[operator](1n, unsafeInt)).to.throw( - HardhatError, - msg - ); + expect(() => + expect(BigInt(1)).to[operator](BigInt(1), unsafeInt) + ).to.throw(HardhatError, msg); }); }); describe(`when using not.to.${operator}`, function () { it("with an unsafe int as the first param", function () { - expect(() => expect(unsafeInt).not.to[operator](1n, 1n)).to.throw( - HardhatError, - msg - ); + expect(() => + expect(unsafeInt).not.to[operator](BigInt(1), BigInt(1)) + ).to.throw(HardhatError, msg); }); it("with an unsafe int as the second param", function () { - expect(() => expect(1n).not.to[operator](unsafeInt, 1n)).to.throw( - HardhatError, - msg - ); + expect(() => + expect(BigInt(1)).not.to[operator](unsafeInt, BigInt(1)) + ).to.throw(HardhatError, msg); }); it("with an unsafe int as the third param", function () { - expect(() => expect(1n).not.to[operator](1n, unsafeInt)).to.throw( - HardhatError, - msg - ); + expect(() => + expect(BigInt(1)).not.to[operator](BigInt(1), unsafeInt) + ).to.throw(HardhatError, msg); }); }); }); @@ -1206,7 +1181,7 @@ describe("BigNumber matchers", function () { ); // number and bigint - expect(() => expect(1).to.equal(2n, "custom message")).to.throw( + expect(() => expect(1).to.equal(BigInt(2), "custom message")).to.throw( AssertionError, "custom message" ); @@ -1218,7 +1193,7 @@ describe("BigNumber matchers", function () { ); // number and bigint - expect(() => expect([1]).to.equal([2n], "custom message")).to.throw( + expect(() => expect([1]).to.equal([BigInt(2)], "custom message")).to.throw( AssertionError, "custom message" ); diff --git a/packages/hardhat-chai-matchers-viem/test/changeEtherBalance.ts b/packages/hardhat-chai-matchers-viem/test/changeEtherBalance.ts index f368d3e72b..0b116708d2 100644 --- a/packages/hardhat-chai-matchers-viem/test/changeEtherBalance.ts +++ b/packages/hardhat-chai-matchers-viem/test/changeEtherBalance.ts @@ -1,7 +1,5 @@ -import type { Token } from "../src/internal/changeTokenBalance"; -import type { HardhatEthersSigner } from "@nomicfoundation/hardhat-ethers/signers"; -import type { ChangeEtherBalance } from "./contracts"; - +import type { WalletClient } from "@nomicfoundation/hardhat-viem/types"; +import type { ChangeEtherBalance, Token } from "./contracts"; import { expect, AssertionError } from "chai"; import path from "path"; import util from "util"; @@ -16,40 +14,29 @@ describe("INTEGRATION: changeEtherBalance matcher", function () { runTests(); }); - // TODO re-enable this when - // https://github.com/ethers-io/ethers.js/issues/4014 is fixed - describe.skip("connected to a hardhat node", function () { + describe("connected to a hardhat node", function () { useEnvironmentWithNode("hardhat-project"); runTests(); }); function runTests() { - let sender: HardhatEthersSigner; - let receiver: HardhatEthersSigner; + let sender: WalletClient; + let receiver: WalletClient; let contract: ChangeEtherBalance; let txGasFees: number; let mockToken: Token; beforeEach(async function () { - const wallets = await this.hre.ethers.getSigners(); - sender = wallets[0]; - receiver = wallets[1]; - contract = await ( - await this.hre.ethers.getContractFactory<[], ChangeEtherBalance>( - "ChangeEtherBalance" - ) - ).deploy(); + [sender, receiver] = await this.hre.viem.getWalletClients(); + contract = await this.hre.viem.deployContract("ChangeEtherBalance"); txGasFees = 1 * 21_000; await this.hre.network.provider.send( "hardhat_setNextBlockBaseFeePerGas", ["0x0"] ); - const MockToken = await this.hre.ethers.getContractFactory<[], Token>( - "MockToken" - ); - mockToken = await MockToken.deploy(); + mockToken = await this.hre.viem.deployContract("MockToken"); }); describe("Transaction Callback (legacy tx)", () => { @@ -57,8 +44,8 @@ describe("INTEGRATION: changeEtherBalance matcher", function () { it("Should pass when expected balance change is passed as string and is equal to an actual", async () => { await expect(() => sender.sendTransaction({ - to: receiver.address, - value: 200, + to: receiver.account.address, + value: 200n, }) ).to.changeEtherBalance(sender, "-200"); }); @@ -68,9 +55,9 @@ describe("INTEGRATION: changeEtherBalance matcher", function () { // we set a gas limit to avoid using the whole block gas limit await sender.sendTransaction({ - to: receiver.address, - value: 200, - gasLimit: 30_000, + to: receiver.account.address, + value: 200n, + gas: 30_000n, }); await this.hre.network.provider.send("evm_setAutomine", [true]); @@ -78,9 +65,9 @@ describe("INTEGRATION: changeEtherBalance matcher", function () { await expect( expect(() => sender.sendTransaction({ - to: receiver.address, - value: 200, - gasLimit: 30_000, + to: receiver.account.address, + value: 200n, + gas: 30_000n, }) ).to.changeEtherBalance(sender, -200, { includeFee: true }) ).to.be.eventually.rejectedWith( @@ -92,35 +79,26 @@ describe("INTEGRATION: changeEtherBalance matcher", function () { it("Should pass when given an address as a string", async () => { await expect(() => sender.sendTransaction({ - to: receiver.address, - value: 200, + to: receiver.account.address, + value: 200n, }) - ).to.changeEtherBalance(sender.address, "-200"); + ).to.changeEtherBalance(sender.account.address, -200); }); it("Should pass when given a native bigint", async () => { await expect(() => sender.sendTransaction({ - to: receiver.address, - value: 200, - }) - ).to.changeEtherBalance(sender, -200n); - }); - - it("Should pass when given a predicate", async () => { - await expect(() => - sender.sendTransaction({ - to: receiver.address, - value: 200, + to: receiver.account.address, + value: 200n, }) - ).to.changeEtherBalance(sender, (diff: bigint) => diff === -200n); + ).to.changeEtherBalance(sender, BigInt("-200")); }); it("Should pass when expected balance change is passed as int and is equal to an actual", async () => { await expect(() => sender.sendTransaction({ - to: receiver.address, - value: 200, + to: receiver.account.address, + value: 200n, }) ).to.changeEtherBalance(receiver, 200); }); @@ -128,37 +106,21 @@ describe("INTEGRATION: changeEtherBalance matcher", function () { it("Should take into account transaction fee", async () => { await expect(() => sender.sendTransaction({ - to: receiver.address, - gasPrice: 1, - value: 200, + to: receiver.account.address, + gasPrice: 1n, + value: 200n, }) ).to.changeEtherBalance(sender, -(txGasFees + 200), { includeFee: true, }); }); - it("Should take into account transaction fee when given a predicate", async () => { - await expect(() => - sender.sendTransaction({ - to: receiver.address, - gasPrice: 1, - value: 200, - }) - ).to.changeEtherBalance( - sender, - (diff: bigint) => diff === -(BigInt(txGasFees) + 200n), - { - includeFee: true, - } - ); - }); - it("Should ignore fee if receiver's wallet is being checked and includeFee was set", async () => { await expect(() => sender.sendTransaction({ - to: receiver.address, - gasPrice: 1, - value: 200, + to: receiver.account.address, + gasPrice: 1n, + value: 200n, }) ).to.changeEtherBalance(receiver, 200, { includeFee: true }); }); @@ -166,38 +128,26 @@ describe("INTEGRATION: changeEtherBalance matcher", function () { it("Should take into account transaction fee by default", async () => { await expect(() => sender.sendTransaction({ - to: receiver.address, - gasPrice: 1, - value: 200, + to: receiver.account.address, + gasPrice: 1n, + value: 200n, }) ).to.changeEtherBalance(sender, -200); }); - it("Should pass on negative case when expected balance does not satisfy the predicate", async () => { - await expect(() => - sender.sendTransaction({ - to: receiver.address, - value: 200, - }) - ).to.not.changeEtherBalance( - receiver, - (diff: bigint) => diff === 300n - ); - }); - it("Should throw when fee was not calculated correctly", async () => { await expect( expect(() => sender.sendTransaction({ - to: receiver.address, - gasPrice: 1, - value: 200, + to: receiver.account.address, + gasPrice: 1n, + value: 200n, }) ).to.changeEtherBalance(sender, -200, { includeFee: true }) ).to.be.eventually.rejectedWith( AssertionError, `Expected the ether balance of "${ - sender.address + sender.account.address }" to change by -200 wei, but it changed by -${txGasFees + 200} wei` ); }); @@ -206,27 +156,13 @@ describe("INTEGRATION: changeEtherBalance matcher", function () { await expect( expect(() => sender.sendTransaction({ - to: receiver.address, - value: 200, + to: receiver.account.address, + value: 200n, }) ).to.changeEtherBalance(sender, "-500") ).to.be.eventually.rejectedWith( AssertionError, - `Expected the ether balance of "${sender.address}" to change by -500 wei, but it changed by -200 wei` - ); - }); - - it("Should throw when actual balance change value does not satisfy the predicate", async () => { - await expect( - expect(() => - sender.sendTransaction({ - to: receiver.address, - value: 200, - }) - ).to.changeEtherBalance(sender, (diff: bigint) => diff === -500n) - ).to.be.eventually.rejectedWith( - AssertionError, - `Expected the ether balance change of "${sender.address}" to satisfy the predicate, but it didn't (balance change: -200 wei)` + `Expected the ether balance of "${sender.account.address}" to change by -500 wei, but it changed by -200 wei` ); }); @@ -234,52 +170,38 @@ describe("INTEGRATION: changeEtherBalance matcher", function () { await expect( expect(() => sender.sendTransaction({ - to: receiver.address, - value: 200, + to: receiver.account.address, + value: 200n, }) ).to.not.changeEtherBalance(sender, "-200") ).to.be.eventually.rejectedWith( AssertionError, - `Expected the ether balance of "${sender.address}" NOT to change by -200 wei, but it did` - ); - }); - - it("Should throw in negative case when expected balance change value satisfies the predicate", async () => { - await expect( - expect(() => - sender.sendTransaction({ - to: receiver.address, - value: 200, - }) - ).to.not.changeEtherBalance( - sender, - (diff: bigint) => diff === -200n - ) - ).to.be.eventually.rejectedWith( - AssertionError, - `Expected the ether balance change of "${sender.address}" to NOT satisfy the predicate, but it did (balance change: -200 wei)` + `Expected the ether balance of "${sender.account.address}" NOT to change by -200 wei, but it did` ); }); it("Should pass when given zero value tx", async () => { await expect(() => - sender.sendTransaction({ to: receiver.address, value: 0 }) + sender.sendTransaction({ to: receiver.account.address, value: 0n }) ).to.changeEtherBalance(sender, 0); }); it("shouldn't run the transaction twice", async function () { - const receiverBalanceBefore: bigint = - await this.hre.ethers.provider.getBalance(receiver); + const publicClient = await this.hre.viem.getPublicClient(); + const receiverBalanceBefore = await publicClient.getBalance({ + address: receiver.account.address, + }); await expect(() => sender.sendTransaction({ - to: receiver.address, - value: 200, + to: receiver.account.address, + value: 200n, }) ).to.changeEtherBalance(sender, -200); - const receiverBalanceAfter: bigint = - await this.hre.ethers.provider.getBalance(receiver); + const receiverBalanceAfter = await publicClient.getBalance({ + address: receiver.account.address, + }); const receiverBalanceChange = receiverBalanceAfter - receiverBalanceBefore; @@ -291,15 +213,15 @@ describe("INTEGRATION: changeEtherBalance matcher", function () { it("Should pass when expected balance change is passed as int and is equal to an actual", async () => { await expect(async () => sender.sendTransaction({ - to: contract, - value: 200, + to: contract.address, + value: 200n, }) ).to.changeEtherBalance(contract, 200); }); it("should pass when calling function that returns half the sent ether", async () => { await expect(async () => - contract.returnHalf({ value: 200 }) + contract.write.returnHalf({ value: 200n }) ).to.changeEtherBalance(sender, -100); }); }); @@ -310,10 +232,10 @@ describe("INTEGRATION: changeEtherBalance matcher", function () { it("Should pass when expected balance change is passed as string and is equal to an actual", async () => { await expect(() => sender.sendTransaction({ - to: receiver.address, - maxFeePerGas: 2, - maxPriorityFeePerGas: 1, - value: 200, + to: receiver.account.address, + maxFeePerGas: 2n, + maxPriorityFeePerGas: 1n, + value: 200n, }) ).to.changeEtherBalance(sender, "-200"); }); @@ -321,10 +243,10 @@ describe("INTEGRATION: changeEtherBalance matcher", function () { it("Should pass when expected balance change is passed as int and is equal to an actual", async () => { await expect(() => sender.sendTransaction({ - to: receiver.address, - maxFeePerGas: 2, - maxPriorityFeePerGas: 1, - value: 200, + to: receiver.account.address, + maxFeePerGas: 2n, + maxPriorityFeePerGas: 1n, + value: 200n, }) ).to.changeEtherBalance(receiver, 200); }); @@ -332,10 +254,10 @@ describe("INTEGRATION: changeEtherBalance matcher", function () { it("Should take into account transaction fee", async () => { await expect(() => sender.sendTransaction({ - to: receiver.address, - maxFeePerGas: 2, - maxPriorityFeePerGas: 1, - value: 200, + to: receiver.account.address, + maxFeePerGas: 2n, + maxPriorityFeePerGas: 1n, + value: 200n, }) ).to.changeEtherBalance(sender, -(txGasFees + 200), { includeFee: true, @@ -345,10 +267,10 @@ describe("INTEGRATION: changeEtherBalance matcher", function () { it("Should ignore fee if receiver's wallet is being checked and includeFee was set", async () => { await expect(() => sender.sendTransaction({ - to: receiver.address, - maxFeePerGas: 2, - maxPriorityFeePerGas: 1, - value: 200, + to: receiver.account.address, + maxFeePerGas: 2n, + maxPriorityFeePerGas: 1n, + value: 200n, }) ).to.changeEtherBalance(receiver, 200, { includeFee: true }); }); @@ -356,10 +278,10 @@ describe("INTEGRATION: changeEtherBalance matcher", function () { it("Should take into account transaction fee by default", async () => { await expect(() => sender.sendTransaction({ - to: receiver.address, - maxFeePerGas: 2, - maxPriorityFeePerGas: 1, - value: 200, + to: receiver.account.address, + maxFeePerGas: 2n, + maxPriorityFeePerGas: 1n, + value: 200n, }) ).to.changeEtherBalance(sender, -200); }); @@ -368,16 +290,16 @@ describe("INTEGRATION: changeEtherBalance matcher", function () { await expect( expect(() => sender.sendTransaction({ - to: receiver.address, - maxFeePerGas: 2, - maxPriorityFeePerGas: 1, - value: 200, + to: receiver.account.address, + maxFeePerGas: 2n, + maxPriorityFeePerGas: 1n, + value: 200n, }) ).to.changeEtherBalance(sender, -200, { includeFee: true }) ).to.be.eventually.rejectedWith( AssertionError, `Expected the ether balance of "${ - sender.address + sender.account.address }" to change by -200 wei, but it changed by -${txGasFees + 200} wei` ); }); @@ -386,15 +308,15 @@ describe("INTEGRATION: changeEtherBalance matcher", function () { await expect( expect(() => sender.sendTransaction({ - to: receiver.address, - maxFeePerGas: 2, - maxPriorityFeePerGas: 1, - value: 200, + to: receiver.account.address, + maxFeePerGas: 2n, + maxPriorityFeePerGas: 1n, + value: 200n, }) ).to.changeEtherBalance(sender, "-500") ).to.be.eventually.rejectedWith( AssertionError, - `Expected the ether balance of "${sender.address}" to change by -500 wei, but it changed by -200 wei` + `Expected the ether balance of "${sender.account.address}" to change by -500 wei, but it changed by -200 wei` ); }); @@ -402,15 +324,15 @@ describe("INTEGRATION: changeEtherBalance matcher", function () { await expect( expect(() => sender.sendTransaction({ - to: receiver.address, - maxFeePerGas: 2, - maxPriorityFeePerGas: 1, - value: 200, + to: receiver.account.address, + maxFeePerGas: 2n, + maxPriorityFeePerGas: 1n, + value: 200n, }) ).to.not.changeEtherBalance(sender, "-200") ).to.be.eventually.rejectedWith( AssertionError, - `Expected the ether balance of "${sender.address}" NOT to change by -200 wei, but it did` + `Expected the ether balance of "${sender.account.address}" NOT to change by -200 wei, but it did` ); }); }); @@ -419,23 +341,24 @@ describe("INTEGRATION: changeEtherBalance matcher", function () { it("Should pass when expected balance change is passed as int and is equal to an actual", async () => { await expect(async () => sender.sendTransaction({ - to: contract, - maxFeePerGas: 2, - maxPriorityFeePerGas: 1, - value: 200, + to: contract.address, + maxFeePerGas: 2n, + maxPriorityFeePerGas: 1n, + value: 200n, }) ).to.changeEtherBalance(contract, 200); }); it("Should take into account transaction fee", async function () { const tx = { - to: contract, - maxFeePerGas: 2, - maxPriorityFeePerGas: 1, - value: 200, + to: contract.address, + maxFeePerGas: 2n, + maxPriorityFeePerGas: 1n, + value: 200n, }; - const gas: bigint = await this.hre.ethers.provider.estimateGas(tx); + const publicClient = await this.hre.viem.getPublicClient(); + const gas = await publicClient.estimateGas(tx); await expect(() => sender.sendTransaction(tx)).to.changeEtherBalance( sender, @@ -448,30 +371,33 @@ describe("INTEGRATION: changeEtherBalance matcher", function () { it("should pass when calling function that returns half the sent ether", async () => { await expect(async () => - contract.returnHalf({ - value: 200, - maxFeePerGas: 2, - maxPriorityFeePerGas: 1, + contract.write.returnHalf({ + value: 200n, + maxFeePerGas: 2n, + maxPriorityFeePerGas: 1n, }) ).to.changeEtherBalance(sender, -100); }); }); it("shouldn't run the transaction twice", async function () { - const receiverBalanceBefore: bigint = - await this.hre.ethers.provider.getBalance(receiver); + const publicClient = await this.hre.viem.getPublicClient(); + const receiverBalanceBefore = await publicClient.getBalance({ + address: receiver.account.address, + }); await expect(() => sender.sendTransaction({ - to: receiver.address, - maxFeePerGas: 2, - maxPriorityFeePerGas: 1, - value: 200, + to: receiver.account.address, + maxFeePerGas: 2n, + maxPriorityFeePerGas: 1n, + value: 200n, }) ).to.changeEtherBalance(sender, -200); - const receiverBalanceAfter: bigint = - await this.hre.ethers.provider.getBalance(receiver); + const receiverBalanceAfter = await publicClient.getBalance({ + address: receiver.account.address, + }); const receiverBalanceChange = receiverBalanceAfter - receiverBalanceBefore; @@ -484,8 +410,8 @@ describe("INTEGRATION: changeEtherBalance matcher", function () { it("Should pass when expected balance change is passed as string and is equal to an actual", async () => { await expect( await sender.sendTransaction({ - to: receiver.address, - value: 200, + to: receiver.account.address, + value: 200n, }) ).to.changeEtherBalance(sender, "-200"); }); @@ -493,8 +419,8 @@ describe("INTEGRATION: changeEtherBalance matcher", function () { it("Should pass when expected balance change is passed as int and is equal to an actual", async () => { await expect( await sender.sendTransaction({ - to: receiver.address, - value: 200, + to: receiver.account.address, + value: 200n, }) ).to.changeEtherBalance(receiver, 200); }); @@ -503,13 +429,13 @@ describe("INTEGRATION: changeEtherBalance matcher", function () { await expect( expect( await sender.sendTransaction({ - to: receiver.address, - value: 200, + to: receiver.account.address, + value: 200n, }) ).to.changeEtherBalance(sender, "-500") ).to.be.eventually.rejectedWith( AssertionError, - `Expected the ether balance of "${sender.address}" to change by -500 wei, but it changed by -200 wei` + `Expected the ether balance of "${sender.account.address}" to change by -500 wei, but it changed by -200 wei` ); }); @@ -517,13 +443,13 @@ describe("INTEGRATION: changeEtherBalance matcher", function () { await expect( expect( await sender.sendTransaction({ - to: receiver.address, - value: 200, + to: receiver.account.address, + value: 200n, }) ).to.not.changeEtherBalance(sender, "-200") ).to.be.eventually.rejectedWith( AssertionError, - `Expected the ether balance of "${sender.address}" NOT to change by -200 wei, but it did` + `Expected the ether balance of "${sender.account.address}" NOT to change by -200 wei, but it did` ); }); }); @@ -532,8 +458,8 @@ describe("INTEGRATION: changeEtherBalance matcher", function () { it("Should pass when expected balance change is passed as int and is equal to an actual", async () => { await expect( await sender.sendTransaction({ - to: contract, - value: 200, + to: contract.address, + value: 200n, }) ).to.changeEtherBalance(contract, 200); }); @@ -545,8 +471,8 @@ describe("INTEGRATION: changeEtherBalance matcher", function () { it("Should pass when expected balance change is passed as string and is equal to an actual", async () => { await expect( sender.sendTransaction({ - to: receiver.address, - value: 200, + to: receiver.account.address, + value: 200n, }) ).to.changeEtherBalance(sender, "-200"); }); @@ -554,8 +480,8 @@ describe("INTEGRATION: changeEtherBalance matcher", function () { it("Should pass when expected balance change is passed as int and is equal to an actual", async () => { await expect( sender.sendTransaction({ - to: receiver.address, - value: 200, + to: receiver.account.address, + value: 200n, }) ).to.changeEtherBalance(receiver, 200); }); @@ -564,13 +490,13 @@ describe("INTEGRATION: changeEtherBalance matcher", function () { await expect( expect( sender.sendTransaction({ - to: receiver.address, - value: 200, + to: receiver.account.address, + value: 200n, }) ).to.changeEtherBalance(sender, "-500") ).to.be.eventually.rejectedWith( AssertionError, - `Expected the ether balance of "${sender.address}" to change by -500 wei, but it changed by -200 wei` + `Expected the ether balance of "${sender.account.address}" to change by -500 wei, but it changed by -200 wei` ); }); @@ -578,13 +504,13 @@ describe("INTEGRATION: changeEtherBalance matcher", function () { await expect( expect( sender.sendTransaction({ - to: receiver.address, - value: 200, + to: receiver.account.address, + value: 200n, }) ).to.not.changeEtherBalance(sender, "-200") ).to.be.eventually.rejectedWith( AssertionError, - `Expected the ether balance of "${sender.address}" NOT to change by -200 wei, but it did` + `Expected the ether balance of "${sender.account.address}" NOT to change by -200 wei, but it did` ); }); @@ -592,8 +518,8 @@ describe("INTEGRATION: changeEtherBalance matcher", function () { expect(() => expect( sender.sendTransaction({ - to: receiver.address, - value: 200, + to: receiver.account.address, + value: 200n, }) ) .to.changeTokenBalance(mockToken, receiver, 50) @@ -611,8 +537,8 @@ describe("INTEGRATION: changeEtherBalance matcher", function () { try { await expect(() => sender.sendTransaction({ - to: receiver.address, - value: 200, + to: receiver.account.address, + value: 200n, }) ).to.changeEtherBalance(sender, -100); } catch (e: any) { diff --git a/packages/hardhat-chai-matchers-viem/test/changeEtherBalances.ts b/packages/hardhat-chai-matchers-viem/test/changeEtherBalances.ts index f5a7a4156b..2e3bafaac9 100644 --- a/packages/hardhat-chai-matchers-viem/test/changeEtherBalances.ts +++ b/packages/hardhat-chai-matchers-viem/test/changeEtherBalances.ts @@ -1,6 +1,5 @@ -import type { Token } from "../src/internal/changeTokenBalance"; -import type { HardhatEthersSigner } from "@nomicfoundation/hardhat-ethers/signers"; -import type { ChangeEtherBalance } from "./contracts"; +import type { WalletClient } from "@nomicfoundation/hardhat-viem/types"; +import type { ChangeEtherBalance, Token } from "./contracts"; import { expect, AssertionError } from "chai"; import path from "path"; @@ -24,31 +23,22 @@ describe("INTEGRATION: changeEtherBalances matcher", function () { }); function runTests() { - let sender: HardhatEthersSigner; - let receiver: HardhatEthersSigner; + let sender: WalletClient; + let receiver: WalletClient; let contract: ChangeEtherBalance; let txGasFees: number; let mockToken: Token; beforeEach(async function () { - const wallets = await this.hre.ethers.getSigners(); - sender = wallets[0]; - receiver = wallets[1]; - contract = await ( - await this.hre.ethers.getContractFactory<[], ChangeEtherBalance>( - "ChangeEtherBalance" - ) - ).deploy(); + [sender, receiver] = await this.hre.viem.getWalletClients(); + contract = await this.hre.viem.deployContract("ChangeEtherBalance"); txGasFees = 1 * 21_000; await this.hre.network.provider.send( "hardhat_setNextBlockBaseFeePerGas", ["0x0"] ); - const MockToken = await this.hre.ethers.getContractFactory<[], Token>( - "MockToken" - ); - mockToken = await MockToken.deploy(); + mockToken = await this.hre.viem.deployContract("MockToken"); }); describe("Transaction Callback", () => { @@ -56,8 +46,8 @@ describe("INTEGRATION: changeEtherBalances matcher", function () { it("Should pass when all expected balance changes are equal to actual values", async () => { await expect(() => sender.sendTransaction({ - to: contract, - value: 200, + to: contract.address, + value: 200n, }) ).to.changeEtherBalances([sender, contract], [-200, 200]); }); @@ -66,7 +56,9 @@ describe("INTEGRATION: changeEtherBalances matcher", function () { describe("Change balances, contract forwards ether sent", () => { it("Should pass when contract function forwards all tx ether", async () => { await expect(() => - contract.transferTo(receiver.address, { value: 200 }) + contract.write.transferTo([receiver.account.address], { + value: 200n, + }) ).to.changeEtherBalances( [sender, contract, receiver], [-200, 0, 200] @@ -78,9 +70,9 @@ describe("INTEGRATION: changeEtherBalances matcher", function () { it("Should pass when all expected balance changes are equal to actual values", async () => { await expect(() => sender.sendTransaction({ - to: receiver.address, - gasPrice: 1, - value: 200, + to: receiver.account.address, + gasPrice: 1n, + value: 200n, }) ).to.changeEtherBalances([sender, receiver], ["-200", 200]); }); @@ -88,12 +80,12 @@ describe("INTEGRATION: changeEtherBalances matcher", function () { it("Should pass when given addresses as strings", async () => { await expect(() => sender.sendTransaction({ - to: receiver.address, - gasPrice: 1, - value: 200, + to: receiver.account.address, + gasPrice: 1n, + value: 200n, }) ).to.changeEtherBalances( - [sender.address, receiver.address], + [sender.account.address, receiver.account.address], ["-200", 200] ); }); @@ -101,71 +93,22 @@ describe("INTEGRATION: changeEtherBalances matcher", function () { it("Should pass when given native BigInt", async () => { await expect(() => sender.sendTransaction({ - to: receiver.address, - gasPrice: 1, - value: 200, - }) - ).to.changeEtherBalances([sender, receiver], [-200n, 200n]); - }); - - it("Should pass when given a predicate", async () => { - await expect(() => - sender.sendTransaction({ - to: receiver.address, - gasPrice: 1, - value: 200, + to: receiver.account.address, + gasPrice: 1n, + value: 200n, }) ).to.changeEtherBalances( [sender, receiver], - ([senderDiff, receiverDiff]: bigint[]) => - senderDiff === -200n && receiverDiff === 200n - ); - }); - - it("Should fail when the predicate returns false", async () => { - await expect( - expect(() => - sender.sendTransaction({ - to: receiver.address, - gasPrice: 1, - value: 200, - }) - ).to.changeEtherBalances( - [sender, receiver], - ([senderDiff, receiverDiff]: bigint[]) => - senderDiff === -201n && receiverDiff === 200n - ) - ).to.be.eventually.rejectedWith( - AssertionError, - "Expected the balance changes of the accounts to satisfy the predicate, but they didn't" - ); - }); - - it("Should fail when the predicate returns true and the assertion is negated", async () => { - await expect( - expect(() => - sender.sendTransaction({ - to: receiver.address, - gasPrice: 1, - value: 200, - }) - ).to.not.changeEtherBalances( - [sender, receiver], - ([senderDiff, receiverDiff]: bigint[]) => - senderDiff === -200n && receiverDiff === 200n - ) - ).to.be.eventually.rejectedWith( - AssertionError, - "Expected the balance changes of the accounts to NOT satisfy the predicate, but they did" + [BigInt("-200"), BigInt(200)] ); }); it("Should take into account transaction fee (legacy tx)", async () => { await expect(() => sender.sendTransaction({ - to: receiver.address, - gasPrice: 1, - value: 200, + to: receiver.account.address, + gasPrice: 1n, + value: 200n, }) ).to.changeEtherBalances( [sender, receiver, contract], @@ -177,10 +120,10 @@ describe("INTEGRATION: changeEtherBalances matcher", function () { it("Should take into account transaction fee (1559 tx)", async () => { await expect(() => sender.sendTransaction({ - to: receiver.address, - maxFeePerGas: 1, - maxPriorityFeePerGas: 1, - value: 200, + to: receiver.account.address, + maxFeePerGas: 1n, + maxPriorityFeePerGas: 1n, + value: 200n, }) ).to.changeEtherBalances( [sender, receiver, contract], @@ -191,16 +134,19 @@ describe("INTEGRATION: changeEtherBalances matcher", function () { it("Should pass when given a single address", async () => { await expect(() => - sender.sendTransaction({ to: receiver.address, value: 200 }) + sender.sendTransaction({ + to: receiver.account.address, + value: 200n, + }) ).to.changeEtherBalances([sender], [-200]); }); it("Should pass when negated and numbers don't match", async () => { await expect(() => sender.sendTransaction({ - to: receiver.address, - gasPrice: 1, - value: 200, + to: receiver.account.address, + gasPrice: 1n, + value: 200n, }) ).to.not.changeEtherBalances( [sender, receiver], @@ -208,8 +154,8 @@ describe("INTEGRATION: changeEtherBalances matcher", function () { ); await expect(() => sender.sendTransaction({ - to: receiver.address, - value: 200, + to: receiver.account.address, + value: 200n, }) ).to.not.changeEtherBalances([sender, receiver], [-200, 201], { includeFee: true, @@ -220,26 +166,26 @@ describe("INTEGRATION: changeEtherBalances matcher", function () { await expect( expect(() => sender.sendTransaction({ - to: receiver.address, - gasPrice: 1, - value: 200, + to: receiver.account.address, + gasPrice: 1n, + value: 200n, }) ).to.changeEtherBalances([sender, receiver], [-200, 201]) ).to.be.eventually.rejectedWith( AssertionError, - `Expected the ether balance of ${receiver.address} (the 2nd address in the list) to change by 201 wei, but it changed by 200 wei` + `Expected the ether balance of ${receiver.account.address} (the 2nd address in the list) to change by 201 wei, but it changed by 200 wei` ); await expect( expect(() => sender.sendTransaction({ - to: receiver.address, - gasPrice: 1, - value: 200, + to: receiver.account.address, + gasPrice: 1n, + value: 200n, }) ).to.changeEtherBalances([sender, receiver], [-201, 200]) ).to.be.eventually.rejectedWith( AssertionError, - `Expected the ether balance of ${sender.address} (the 1st address in the list) to change by -201 wei, but it changed by -200 wei` + `Expected the ether balance of ${sender.account.address} (the 1st address in the list) to change by -201 wei, but it changed by -200 wei` ); }); @@ -247,62 +193,35 @@ describe("INTEGRATION: changeEtherBalances matcher", function () { await expect( expect(() => sender.sendTransaction({ - to: receiver.address, - gasPrice: 1, - value: 200, + to: receiver.account.address, + gasPrice: 1n, + value: 200n, }) ).to.not.changeEtherBalances([sender, receiver], [-200, 200]) ).to.be.eventually.rejectedWith( AssertionError, - `Expected the ether balance of ${sender.address} (the 1st address in the list) NOT to change by -200 wei` - ); - }); - - it("arrays have different length", async function () { - expect(() => - expect( - sender.sendTransaction({ - to: receiver.address, - gasPrice: 1, - value: 200, - }) - ).to.changeEtherBalances([sender], ["-200", 200]) - ).to.throw( - Error, - "The number of accounts (1) is different than the number of expected balance changes (2)" - ); - - expect(() => - expect( - sender.sendTransaction({ - to: receiver.address, - gasPrice: 1, - value: 200, - }) - ).to.changeEtherBalances([sender, receiver], ["-200"]) - ).to.throw( - Error, - "The number of accounts (2) is different than the number of expected balance changes (1)" + `Expected the ether balance of ${sender.account.address} (the 1st address in the list) NOT to change by -200 wei` ); }); }); it("shouldn't run the transaction twice", async function () { - const receiverBalanceBefore = await this.hre.ethers.provider.getBalance( - receiver - ); + const publicClient = await this.hre.viem.getPublicClient(); + const receiverBalanceBefore = await publicClient.getBalance({ + address: receiver.account.address, + }); await expect(() => sender.sendTransaction({ - to: receiver.address, - gasPrice: 1, - value: 200, + to: receiver.account.address, + gasPrice: 1n, + value: 200n, }) ).to.changeEtherBalances([sender, receiver], [-200, 200]); - const receiverBalanceAfter = await this.hre.ethers.provider.getBalance( - receiver - ); + const receiverBalanceAfter = await publicClient.getBalance({ + address: receiver.account.address, + }); const receiverBalanceChange = receiverBalanceAfter - receiverBalanceBefore; @@ -315,8 +234,8 @@ describe("INTEGRATION: changeEtherBalances matcher", function () { it("Should pass when all expected balance changes are equal to actual values", async () => { await expect( await sender.sendTransaction({ - to: contract, - value: 200, + to: contract.address, + value: 200n, }) ).to.changeEtherBalances([sender, contract], [-200, 200]); }); @@ -326,8 +245,8 @@ describe("INTEGRATION: changeEtherBalances matcher", function () { expect(() => expect( sender.sendTransaction({ - to: contract, - value: 200, + to: contract.address, + value: 200n, }) ) .to.changeTokenBalances(mockToken, [sender, receiver], [-50, 100]) @@ -341,9 +260,9 @@ describe("INTEGRATION: changeEtherBalances matcher", function () { it("Should pass when all expected balance changes are equal to actual values", async () => { await expect( await sender.sendTransaction({ - to: receiver.address, - gasPrice: 1, - value: 200, + to: receiver.account.address, + gasPrice: 1n, + value: 200n, }) ).to.changeEtherBalances( [sender, receiver], @@ -355,9 +274,9 @@ describe("INTEGRATION: changeEtherBalances matcher", function () { it("Should take into account transaction fee", async () => { await expect( await sender.sendTransaction({ - to: receiver.address, - gasPrice: 1, - value: 200, + to: receiver.account.address, + gasPrice: 1n, + value: 200n, }) ).to.changeEtherBalances( [sender, receiver, contract], @@ -369,15 +288,15 @@ describe("INTEGRATION: changeEtherBalances matcher", function () { it("Should pass when negated and numbers don't match", async () => { await expect( await sender.sendTransaction({ - to: receiver.address, - value: 200, + to: receiver.account.address, + value: 200n, }) ).to.not.changeEtherBalances([sender, receiver], [-201, 200]); await expect( await sender.sendTransaction({ - to: receiver.address, - value: 200, + to: receiver.account.address, + value: 200n, }) ).to.not.changeEtherBalances([sender, receiver], [-200, 201]); }); @@ -386,9 +305,9 @@ describe("INTEGRATION: changeEtherBalances matcher", function () { await expect( expect( await sender.sendTransaction({ - to: receiver.address, - gasPrice: 1, - value: 200, + to: receiver.account.address, + gasPrice: 1n, + value: 200n, }) ).to.changeEtherBalances([sender, receiver], [-200, 200], { includeFee: true, @@ -396,7 +315,7 @@ describe("INTEGRATION: changeEtherBalances matcher", function () { ).to.be.eventually.rejectedWith( AssertionError, `Expected the ether balance of ${ - sender.address + sender.account.address } (the 1st address in the list) to change by -200 wei, but it changed by -${ txGasFees + 200 } wei` @@ -407,25 +326,25 @@ describe("INTEGRATION: changeEtherBalances matcher", function () { await expect( expect( await sender.sendTransaction({ - to: receiver.address, - value: 200, + to: receiver.account.address, + value: 200n, }) ).to.changeEtherBalances([sender, receiver], [-200, 201]) ).to.be.eventually.rejectedWith( AssertionError, - `Expected the ether balance of ${receiver.address} (the 2nd address in the list) to change by 201 wei, but it changed by 200 wei` + `Expected the ether balance of ${receiver.account.address} (the 2nd address in the list) to change by 201 wei, but it changed by 200 wei` ); await expect( expect( await sender.sendTransaction({ - to: receiver.address, - value: 200, + to: receiver.account.address, + value: 200n, }) ).to.changeEtherBalances([sender, receiver], [-201, 200]) ).to.be.eventually.rejectedWith( AssertionError, - `Expected the ether balance of ${sender.address} (the 1st address in the list) to change by -201 wei, but it changed by -200 wei` + `Expected the ether balance of ${sender.account.address} (the 1st address in the list) to change by -201 wei, but it changed by -200 wei` ); }); @@ -433,13 +352,13 @@ describe("INTEGRATION: changeEtherBalances matcher", function () { await expect( expect( await sender.sendTransaction({ - to: receiver.address, - value: 200, + to: receiver.account.address, + value: 200n, }) ).to.not.changeEtherBalances([sender, receiver], [-200, 200]) ).to.be.eventually.rejectedWith( AssertionError, - `Expected the ether balance of ${sender.address} (the 1st address in the list) NOT to change by -200` + `Expected the ether balance of ${sender.account.address} (the 1st address in the list) NOT to change by -200` ); }); }); @@ -451,8 +370,8 @@ describe("INTEGRATION: changeEtherBalances matcher", function () { try { await expect(() => sender.sendTransaction({ - to: receiver.address, - value: 200, + to: receiver.account.address, + value: 200n, }) ).to.changeEtherBalances([sender, receiver], [-100, 100]); } catch (e: any) { diff --git a/packages/hardhat-chai-matchers-viem/test/changeTokenBalance.ts b/packages/hardhat-chai-matchers-viem/test/changeTokenBalance.ts index e05cba67a1..bf2f396d2d 100644 --- a/packages/hardhat-chai-matchers-viem/test/changeTokenBalance.ts +++ b/packages/hardhat-chai-matchers-viem/test/changeTokenBalance.ts @@ -1,7 +1,5 @@ -import type { TransactionResponse } from "ethers"; -import type { HardhatEthersSigner } from "@nomicfoundation/hardhat-ethers/signers"; -import type { Token } from "../src/internal/changeTokenBalance"; -import type { MatchersContract } from "./contracts"; +import type { WalletClient } from "@nomicfoundation/hardhat-viem/types"; +import type { Token, MatchersContract } from "./contracts"; import assert from "assert"; import { AssertionError, expect } from "chai"; @@ -34,32 +32,23 @@ describe("INTEGRATION: changeTokenBalance and changeTokenBalances matchers", fun }); function runTests() { - let sender: HardhatEthersSigner; - let receiver: HardhatEthersSigner; + let sender: WalletClient; + let receiver: WalletClient; let mockToken: Token; let matchers: MatchersContract; beforeEach(async function () { - const wallets = await this.hre.ethers.getSigners(); - sender = wallets[0]; - receiver = wallets[1]; - - const MockToken = await this.hre.ethers.getContractFactory<[], Token>( - "MockToken" - ); - mockToken = await MockToken.deploy(); - - const Matchers = await this.hre.ethers.getContractFactory< - [], - MatchersContract - >("Matchers"); - matchers = await Matchers.deploy(); + [sender, receiver] = await this.hre.viem.getWalletClients(); + + mockToken = await this.hre.viem.deployContract("MockToken"); + + matchers = await this.hre.viem.deployContract("Matchers"); }); describe("transaction that doesn't move tokens", () => { it("with a promise of a TxResponse", async function () { const transactionResponse = sender.sendTransaction({ - to: receiver.address, + to: receiver.account.address, }); await runAllAsserts( transactionResponse, @@ -72,7 +61,7 @@ describe("INTEGRATION: changeTokenBalance and changeTokenBalances matchers", fun it("with a TxResponse", async function () { await runAllAsserts( await sender.sendTransaction({ - to: receiver.address, + to: receiver.account.address, }), mockToken, [sender, receiver], @@ -82,7 +71,7 @@ describe("INTEGRATION: changeTokenBalance and changeTokenBalances matchers", fun it("with a function that returns a promise of a TxResponse", async function () { await runAllAsserts( - () => sender.sendTransaction({ to: receiver.address }), + () => sender.sendTransaction({ to: receiver.account.address }), mockToken, [sender, receiver], [0, 0] @@ -91,7 +80,7 @@ describe("INTEGRATION: changeTokenBalance and changeTokenBalances matchers", fun it("with a function that returns a TxResponse", async function () { const txResponse = await sender.sendTransaction({ - to: receiver.address, + to: receiver.account.address, }); await runAllAsserts( () => txResponse, @@ -103,46 +92,42 @@ describe("INTEGRATION: changeTokenBalance and changeTokenBalances matchers", fun it("accepts addresses", async function () { await expect( - sender.sendTransaction({ to: receiver.address }) - ).to.changeTokenBalance(mockToken, sender.address, 0); + sender.sendTransaction({ to: receiver.account.address }) + ).to.changeTokenBalance(mockToken, sender.account.address, 0); await expect(() => - sender.sendTransaction({ to: receiver.address }) + sender.sendTransaction({ to: receiver.account.address }) ).to.changeTokenBalances( mockToken, - [sender.address, receiver.address], + [sender.account.address, receiver.account.address], [0, 0] ); // mixing signers and addresses await expect(() => - sender.sendTransaction({ to: receiver.address }) - ).to.changeTokenBalances(mockToken, [sender.address, receiver], [0, 0]); + sender.sendTransaction({ to: receiver.account.address }) + ).to.changeTokenBalances( + mockToken, + [sender.account.address, receiver], + [0, 0] + ); }); it("negated", async function () { await expect( - sender.sendTransaction({ to: receiver.address }) + sender.sendTransaction({ to: receiver.account.address }) ).to.not.changeTokenBalance(mockToken, sender, 1); - await expect( - sender.sendTransaction({ to: receiver.address }) - ).to.not.changeTokenBalance( - mockToken, - sender, - (diff: bigint) => diff > 0n - ); - await expect(() => - sender.sendTransaction({ to: receiver.address }) + sender.sendTransaction({ to: receiver.account.address }) ).to.not.changeTokenBalances(mockToken, [sender, receiver], [0, 1]); await expect(() => - sender.sendTransaction({ to: receiver.address }) + sender.sendTransaction({ to: receiver.account.address }) ).to.not.changeTokenBalances(mockToken, [sender, receiver], [1, 0]); await expect(() => - sender.sendTransaction({ to: receiver.address }) + sender.sendTransaction({ to: receiver.account.address }) ).to.not.changeTokenBalances(mockToken, [sender, receiver], [1, 1]); }); @@ -150,7 +135,7 @@ describe("INTEGRATION: changeTokenBalance and changeTokenBalances matchers", fun it("doesn't change balance as expected", async function () { await expect( expect( - sender.sendTransaction({ to: receiver.address }) + sender.sendTransaction({ to: receiver.account.address }) ).to.changeTokenBalance(mockToken, sender, 1) ).to.be.rejectedWith( AssertionError, @@ -158,25 +143,10 @@ describe("INTEGRATION: changeTokenBalance and changeTokenBalances matchers", fun ); }); - it("change balance doesn't satisfies the predicate", async function () { - await expect( - expect( - sender.sendTransaction({ to: receiver.address }) - ).to.changeTokenBalance( - mockToken, - sender, - (diff: bigint) => diff > 0n - ) - ).to.be.rejectedWith( - AssertionError, - /Expected the balance of MCK tokens for "0x\w{40}" to satisfy the predicate, but it didn't \(token balance change: 0 wei\)/ - ); - }); - it("changes balance in the way it was not expected", async function () { await expect( expect( - sender.sendTransaction({ to: receiver.address }) + sender.sendTransaction({ to: receiver.account.address }) ).to.not.changeTokenBalance(mockToken, sender, 0) ).to.be.rejectedWith( AssertionError, @@ -184,25 +154,10 @@ describe("INTEGRATION: changeTokenBalance and changeTokenBalances matchers", fun ); }); - it("changes balance doesn't have to satisfy the predicate, but it did", async function () { - await expect( - expect( - sender.sendTransaction({ to: receiver.address }) - ).to.not.changeTokenBalance( - mockToken, - sender, - (diff: bigint) => diff < 1n - ) - ).to.be.rejectedWith( - AssertionError, - /Expected the balance of MCK tokens for "0x\w{40}" to NOT satisfy the predicate, but it did \(token balance change: 0 wei\)/ - ); - }); - it("the first account doesn't change its balance as expected", async function () { await expect( expect( - sender.sendTransaction({ to: receiver.address }) + sender.sendTransaction({ to: receiver.account.address }) ).to.changeTokenBalances(mockToken, [sender, receiver], [1, 0]) ).to.be.rejectedWith(AssertionError); }); @@ -210,7 +165,7 @@ describe("INTEGRATION: changeTokenBalance and changeTokenBalances matchers", fun it("the second account doesn't change its balance as expected", async function () { await expect( expect( - sender.sendTransaction({ to: receiver.address }) + sender.sendTransaction({ to: receiver.account.address }) ).to.changeTokenBalances(mockToken, [sender, receiver], [0, 1]) ).to.be.rejectedWith(AssertionError); }); @@ -218,7 +173,7 @@ describe("INTEGRATION: changeTokenBalance and changeTokenBalances matchers", fun it("neither account changes its balance as expected", async function () { await expect( expect( - sender.sendTransaction({ to: receiver.address }) + sender.sendTransaction({ to: receiver.account.address }) ).to.changeTokenBalances(mockToken, [sender, receiver], [1, 1]) ).to.be.rejectedWith(AssertionError); }); @@ -226,69 +181,24 @@ describe("INTEGRATION: changeTokenBalance and changeTokenBalances matchers", fun it("accounts change their balance in the way it was not expected", async function () { await expect( expect( - sender.sendTransaction({ to: receiver.address }) + sender.sendTransaction({ to: receiver.account.address }) ).to.not.changeTokenBalances(mockToken, [sender, receiver], [0, 0]) ).to.be.rejectedWith(AssertionError); }); }); }); - describe("Transaction Callback", function () { - it("Should pass when given predicate", async () => { - await expect(() => - mockToken.transfer(receiver.address, 75) - ).to.changeTokenBalances( - mockToken, - [sender, receiver], - ([senderDiff, receiverDiff]: bigint[]) => - senderDiff === -75n && receiverDiff === 75n - ); - }); - - it("Should fail when the predicate returns false", async () => { - await expect( - expect( - mockToken.transfer(receiver.address, 75) - ).to.changeTokenBalances( - mockToken, - [sender, receiver], - ([senderDiff, receiverDiff]: bigint[]) => - senderDiff === -74n && receiverDiff === 75n - ) - ).to.be.eventually.rejectedWith( - AssertionError, - "Expected the balance changes of MCK to satisfy the predicate, but they didn't" - ); - }); - - it("Should fail when the predicate returns true and the assertion is negated", async () => { - await expect( - expect( - mockToken.transfer(receiver.address, 75) - ).to.not.changeTokenBalances( - mockToken, - [sender, receiver], - ([senderDiff, receiverDiff]: bigint[]) => - senderDiff === -75n && receiverDiff === 75n - ) - ).to.be.eventually.rejectedWith( - AssertionError, - "Expected the balance changes of MCK to NOT satisfy the predicate, but they did" - ); - }); - }); - describe("transaction that transfers some tokens", function () { it("with a promise of a TxResponse", async function () { await runAllAsserts( - mockToken.transfer(receiver.address, 50), + mockToken.write.transfer([receiver.account.address, 50n]), mockToken, [sender, receiver], [-50, 50] ); await runAllAsserts( - mockToken.transfer(receiver.address, 100), + mockToken.write.transfer([receiver.account.address, 100n]), mockToken, [sender, receiver], [-100, 100] @@ -297,7 +207,7 @@ describe("INTEGRATION: changeTokenBalance and changeTokenBalances matchers", fun it("with a TxResponse", async function () { await runAllAsserts( - await mockToken.transfer(receiver.address, 150), + await mockToken.write.transfer([receiver.account.address, 150n]), mockToken, [sender, receiver], [-150, 150] @@ -306,7 +216,7 @@ describe("INTEGRATION: changeTokenBalance and changeTokenBalances matchers", fun it("with a function that returns a promise of a TxResponse", async function () { await runAllAsserts( - () => mockToken.transfer(receiver.address, 200), + () => mockToken.write.transfer([receiver.account.address, 200n]), mockToken, [sender, receiver], [-200, 200] @@ -314,7 +224,10 @@ describe("INTEGRATION: changeTokenBalance and changeTokenBalances matchers", fun }); it("with a function that returns a TxResponse", async function () { - const txResponse = await mockToken.transfer(receiver.address, 300); + const txResponse = await mockToken.write.transfer([ + receiver.account.address, + 300n, + ]); await runAllAsserts( () => txResponse, mockToken, @@ -324,51 +237,53 @@ describe("INTEGRATION: changeTokenBalance and changeTokenBalances matchers", fun }); it("changeTokenBalance shouldn't run the transaction twice", async function () { - const receiverBalanceBefore = await mockToken.balanceOf( - receiver.address - ); + const receiverBalanceBefore = await mockToken.read.balanceOf([ + receiver.account.address, + ]); await expect(() => - mockToken.transfer(receiver.address, 50) + mockToken.write.transfer([receiver.account.address, 50n]) ).to.changeTokenBalance(mockToken, receiver, 50); const receiverBalanceChange = - (await mockToken.balanceOf(receiver.address)) - receiverBalanceBefore; + (await mockToken.read.balanceOf([receiver.account.address])) - + receiverBalanceBefore; expect(receiverBalanceChange).to.equal(50n); }); it("changeTokenBalances shouldn't run the transaction twice", async function () { - const receiverBalanceBefore = await mockToken.balanceOf( - receiver.address - ); + const receiverBalanceBefore = await mockToken.read.balanceOf([ + receiver.account.address, + ]); await expect(() => - mockToken.transfer(receiver.address, 50) + mockToken.write.transfer([receiver.account.address, 50n]) ).to.changeTokenBalances(mockToken, [sender, receiver], [-50, 50]); const receiverBalanceChange = - (await mockToken.balanceOf(receiver.address)) - receiverBalanceBefore; + (await mockToken.read.balanceOf([receiver.account.address])) - + receiverBalanceBefore; expect(receiverBalanceChange).to.equal(50n); }); it("negated", async function () { await expect( - mockToken.transfer(receiver.address, 50) + mockToken.write.transfer([receiver.account.address, 50n]) ).to.not.changeTokenBalance(mockToken, sender, 0); await expect( - mockToken.transfer(receiver.address, 50) + mockToken.write.transfer([receiver.account.address, 50n]) ).to.not.changeTokenBalance(mockToken, sender, 1); await expect( - mockToken.transfer(receiver.address, 50) + mockToken.write.transfer([receiver.account.address, 50n]) ).to.not.changeTokenBalances(mockToken, [sender, receiver], [0, 0]); await expect( - mockToken.transfer(receiver.address, 50) + mockToken.write.transfer([receiver.account.address, 50n]) ).to.not.changeTokenBalances(mockToken, [sender, receiver], [-50, 0]); await expect( - mockToken.transfer(receiver.address, 50) + mockToken.write.transfer([receiver.account.address, 50n]) ).to.not.changeTokenBalances(mockToken, [sender, receiver], [0, 50]); }); @@ -376,7 +291,7 @@ describe("INTEGRATION: changeTokenBalance and changeTokenBalances matchers", fun it("doesn't change balance as expected", async function () { await expect( expect( - mockToken.transfer(receiver.address, 50) + mockToken.write.transfer([receiver.account.address, 50n]) ).to.changeTokenBalance(mockToken, receiver, 500) ).to.be.rejectedWith( AssertionError, @@ -384,25 +299,10 @@ describe("INTEGRATION: changeTokenBalance and changeTokenBalances matchers", fun ); }); - it("change balance doesn't satisfies the predicate", async function () { - await expect( - expect( - mockToken.transfer(receiver.address, 50) - ).to.changeTokenBalance( - mockToken, - receiver, - (diff: bigint) => diff === 500n - ) - ).to.be.rejectedWith( - AssertionError, - /Expected the balance of MCK tokens for "0x\w{40}" to satisfy the predicate, but it didn't \(token balance change: 50 wei\)/ - ); - }); - it("changes balance in the way it was not expected", async function () { await expect( expect( - mockToken.transfer(receiver.address, 50) + mockToken.write.transfer([receiver.account.address, 50n]) ).to.not.changeTokenBalance(mockToken, receiver, 50) ).to.be.rejectedWith( AssertionError, @@ -410,25 +310,10 @@ describe("INTEGRATION: changeTokenBalance and changeTokenBalances matchers", fun ); }); - it("changes balance doesn't have to satisfy the predicate, but it did", async function () { - await expect( - expect( - mockToken.transfer(receiver.address, 50) - ).to.not.changeTokenBalance( - mockToken, - receiver, - (diff: bigint) => diff === 50n - ) - ).to.be.rejectedWith( - AssertionError, - /Expected the balance of MCK tokens for "0x\w{40}" to NOT satisfy the predicate, but it did \(token balance change: 50 wei\)/ - ); - }); - it("the first account doesn't change its balance as expected", async function () { await expect( expect( - mockToken.transfer(receiver.address, 50) + mockToken.write.transfer([receiver.account.address, 50n]) ).to.changeTokenBalances(mockToken, [sender, receiver], [-100, 50]) ).to.be.rejectedWith(AssertionError); }); @@ -436,7 +321,7 @@ describe("INTEGRATION: changeTokenBalance and changeTokenBalances matchers", fun it("the second account doesn't change its balance as expected", async function () { await expect( expect( - mockToken.transfer(receiver.address, 50) + mockToken.write.transfer([receiver.account.address, 50n]) ).to.changeTokenBalances(mockToken, [sender, receiver], [-50, 100]) ).to.be.rejectedWith(AssertionError); }); @@ -444,7 +329,7 @@ describe("INTEGRATION: changeTokenBalance and changeTokenBalances matchers", fun it("neither account changes its balance as expected", async function () { await expect( expect( - mockToken.transfer(receiver.address, 50) + mockToken.write.transfer([receiver.account.address, 50n]) ).to.changeTokenBalances(mockToken, [sender, receiver], [0, 0]) ).to.be.rejectedWith(AssertionError); }); @@ -452,7 +337,7 @@ describe("INTEGRATION: changeTokenBalance and changeTokenBalances matchers", fun it("accounts change their balance in the way it was not expected", async function () { await expect( expect( - mockToken.transfer(receiver.address, 50) + mockToken.write.transfer([receiver.account.address, 50n]) ).to.not.changeTokenBalances( mockToken, [sender, receiver], @@ -462,15 +347,13 @@ describe("INTEGRATION: changeTokenBalance and changeTokenBalances matchers", fun }); it("uses the token name if the contract doesn't have a symbol", async function () { - const TokenWithOnlyName = await this.hre.ethers.getContractFactory< - [], - Token - >("TokenWithOnlyName"); - const tokenWithOnlyName = await TokenWithOnlyName.deploy(); + const tokenWithOnlyName = await this.hre.viem.deployContract( + "TokenWithOnlyName" + ); await expect( expect( - tokenWithOnlyName.transfer(receiver.address, 50) + tokenWithOnlyName.write.transfer([receiver.account.address, 50n]) ).to.changeTokenBalance(tokenWithOnlyName, receiver, 500) ).to.be.rejectedWith( AssertionError, @@ -479,7 +362,7 @@ describe("INTEGRATION: changeTokenBalance and changeTokenBalances matchers", fun await expect( expect( - tokenWithOnlyName.transfer(receiver.address, 50) + tokenWithOnlyName.write.transfer([receiver.account.address, 50n]) ).to.not.changeTokenBalance(tokenWithOnlyName, receiver, 50) ).to.be.rejectedWith( AssertionError, @@ -488,16 +371,16 @@ describe("INTEGRATION: changeTokenBalance and changeTokenBalances matchers", fun }); it("uses the contract address if the contract doesn't have name or symbol", async function () { - const TokenWithoutNameNorSymbol = - await this.hre.ethers.getContractFactory<[], Token>( - "TokenWithoutNameNorSymbol" - ); - const tokenWithoutNameNorSymbol = - await TokenWithoutNameNorSymbol.deploy(); + const tokenWithoutNameNorSymbol = await this.hre.viem.deployContract( + "TokenWithoutNameNorSymbol" + ); await expect( expect( - tokenWithoutNameNorSymbol.transfer(receiver.address, 50) + tokenWithoutNameNorSymbol.write.transfer([ + receiver.account.address, + 50n, + ]) ).to.changeTokenBalance(tokenWithoutNameNorSymbol, receiver, 500) ).to.be.rejectedWith( AssertionError, @@ -506,7 +389,10 @@ describe("INTEGRATION: changeTokenBalance and changeTokenBalances matchers", fun await expect( expect( - tokenWithoutNameNorSymbol.transfer(receiver.address, 50) + tokenWithoutNameNorSymbol.write.transfer([ + receiver.account.address, + 50n, + ]) ).to.not.changeTokenBalance(tokenWithoutNameNorSymbol, receiver, 50) ).to.be.rejectedWith( AssertionError, @@ -516,7 +402,7 @@ describe("INTEGRATION: changeTokenBalance and changeTokenBalances matchers", fun it("changeTokenBalance: Should throw if chained to another non-chainable method", () => { expect(() => - expect(mockToken.transfer(receiver.address, 50)) + expect(mockToken.write.transfer([receiver.account.address, 50n])) .to.emit(mockToken, "SomeEvent") .and.to.changeTokenBalance(mockToken, receiver, 50) ).to.throw( @@ -527,7 +413,7 @@ describe("INTEGRATION: changeTokenBalance and changeTokenBalances matchers", fun it("changeTokenBalances: should throw if chained to another non-chainable method", () => { expect(() => expect( - mockToken.transfer(receiver.address, 50) + mockToken.write.transfer([receiver.account.address, 50n]) ).to.be.reverted.and.to.changeTokenBalances( mockToken, [sender, receiver], @@ -544,7 +430,7 @@ describe("INTEGRATION: changeTokenBalance and changeTokenBalances matchers", fun describe(CHANGE_TOKEN_BALANCE_MATCHER, function () { it("token is not specified", async function () { expect(() => - expect(mockToken.transfer(receiver.address, 50)) + expect(mockToken.write.transfer([receiver.account.address, 50n])) .to // @ts-expect-error .changeTokenBalance(receiver, 50) ).to.throw( @@ -554,7 +440,7 @@ describe("INTEGRATION: changeTokenBalance and changeTokenBalances matchers", fun // if an address is used expect(() => - expect(mockToken.transfer(receiver.address, 50)) + expect(mockToken.write.transfer([receiver.account.address, 50n])) .to // @ts-expect-error .changeTokenBalance(receiver.address, 50) ).to.throw( @@ -564,14 +450,11 @@ describe("INTEGRATION: changeTokenBalance and changeTokenBalances matchers", fun }); it("contract is not a token", async function () { - const NotAToken = await this.hre.ethers.getContractFactory( - "NotAToken" - ); - const notAToken = await NotAToken.deploy(); + const notAToken = await this.hre.viem.deployContract("NotAToken"); expect(() => expect( - mockToken.transfer(receiver.address, 50) + mockToken.write.transfer([receiver.account.address, 50n]) ).to.changeTokenBalance(notAToken, sender, -50) ).to.throw( Error, @@ -584,15 +467,17 @@ describe("INTEGRATION: changeTokenBalance and changeTokenBalances matchers", fun // we set a gas limit to avoid using the whole block gas limit await sender.sendTransaction({ - to: receiver.address, - gasLimit: 30_000, + to: receiver.account.address, + gas: 30_000n, }); await this.hre.network.provider.send("evm_setAutomine", [true]); await expect( expect( - mockToken.transfer(receiver.address, 50, { gasLimit: 100_000 }) + mockToken.write.transfer([receiver.account.address, 50n], { + gas: 100_000n, + }) ).to.changeTokenBalance(mockToken, sender, -50) ).to.be.rejectedWith(Error, "Multiple transactions found in block"); }); @@ -600,7 +485,7 @@ describe("INTEGRATION: changeTokenBalance and changeTokenBalances matchers", fun it("tx reverts", async function () { await expect( expect( - mockToken.transfer(receiver.address, 0) + mockToken.write.transfer([receiver.account.address, 0n]) ).to.changeTokenBalance(mockToken, sender, -50) ).to.be.rejectedWith( Error, @@ -613,7 +498,7 @@ describe("INTEGRATION: changeTokenBalance and changeTokenBalances matchers", fun describe(CHANGE_TOKEN_BALANCES_MATCHER, function () { it("token is not specified", async function () { expect(() => - expect(mockToken.transfer(receiver.address, 50)) + expect(mockToken.write.transfer([receiver.account.address, 50n])) .to // @ts-expect-error .changeTokenBalances([sender, receiver], [-50, 50]) ).to.throw( @@ -623,14 +508,11 @@ describe("INTEGRATION: changeTokenBalance and changeTokenBalances matchers", fun }); it("contract is not a token", async function () { - const NotAToken = await this.hre.ethers.getContractFactory( - "NotAToken" - ); - const notAToken = await NotAToken.deploy(); + const notAToken = await this.hre.viem.deployContract("NotAToken"); expect(() => expect( - mockToken.transfer(receiver.address, 50) + mockToken.write.transfer([receiver.account.address, 50n]) ).to.changeTokenBalances(notAToken, [sender, receiver], [-50, 50]) ).to.throw( Error, @@ -641,7 +523,7 @@ describe("INTEGRATION: changeTokenBalance and changeTokenBalances matchers", fun it("arrays have different length", async function () { expect(() => expect( - mockToken.transfer(receiver.address, 50) + mockToken.write.transfer([receiver.account.address, 50n]) ).to.changeTokenBalances(mockToken, [sender], [-50, 50]) ).to.throw( Error, @@ -650,7 +532,7 @@ describe("INTEGRATION: changeTokenBalance and changeTokenBalances matchers", fun expect(() => expect( - mockToken.transfer(receiver.address, 50) + mockToken.write.transfer([receiver.account.address, 50n]) ).to.changeTokenBalances(mockToken, [sender, receiver], [-50]) ).to.throw( Error, @@ -660,11 +542,9 @@ describe("INTEGRATION: changeTokenBalance and changeTokenBalances matchers", fun it("arrays have different length, subject is a rejected promise", async function () { expect(() => - expect(matchers.revertsWithoutReason()).to.changeTokenBalances( - mockToken, - [sender], - [-50, 50] - ) + expect( + matchers.write.revertsWithoutReason() + ).to.changeTokenBalances(mockToken, [sender], [-50, 50]) ).to.throw( Error, "The number of accounts (1) is different than the number of expected balance changes (2)" @@ -676,15 +556,17 @@ describe("INTEGRATION: changeTokenBalance and changeTokenBalances matchers", fun // we set a gas limit to avoid using the whole block gas limit await sender.sendTransaction({ - to: receiver.address, - gasLimit: 30_000, + to: receiver.account.address, + gas: 30_000n, }); await this.hre.network.provider.send("evm_setAutomine", [true]); await expect( expect( - mockToken.transfer(receiver.address, 50, { gasLimit: 100_000 }) + mockToken.write.transfer([receiver.account.address, 50n], { + gas: 100_000n, + }) ).to.changeTokenBalances(mockToken, [sender, receiver], [-50, 50]) ).to.be.rejectedWith(Error, "Multiple transactions found in block"); }); @@ -692,7 +574,7 @@ describe("INTEGRATION: changeTokenBalance and changeTokenBalances matchers", fun it("tx reverts", async function () { await expect( expect( - mockToken.transfer(receiver.address, 0) + mockToken.write.transfer([receiver.account.address, 0n]) ).to.changeTokenBalances(mockToken, [sender, receiver], [-50, 50]) ).to.be.rejectedWith( Error, @@ -706,12 +588,16 @@ describe("INTEGRATION: changeTokenBalance and changeTokenBalances matchers", fun describe("accepted number types", function () { it("native bigints are accepted", async function () { await expect( - mockToken.transfer(receiver.address, 50) - ).to.changeTokenBalance(mockToken, sender, -50n); + mockToken.write.transfer([receiver.account.address, 50n]) + ).to.changeTokenBalance(mockToken, sender, BigInt(-50)); await expect( - mockToken.transfer(receiver.address, 50) - ).to.changeTokenBalances(mockToken, [sender, receiver], [-50n, 50n]); + mockToken.write.transfer([receiver.account.address, 50n]) + ).to.changeTokenBalances( + mockToken, + [sender, receiver], + [BigInt(-50), BigInt(50)] + ); }); }); @@ -722,7 +608,7 @@ describe("INTEGRATION: changeTokenBalance and changeTokenBalances matchers", fun let hasProperStackTrace = false; try { await expect( - mockToken.transfer(receiver.address, 50) + mockToken.write.transfer([receiver.account.address, 50n]) ).to.changeTokenBalance(mockToken, sender, -100); } catch (e: any) { hasProperStackTrace = util @@ -738,7 +624,7 @@ describe("INTEGRATION: changeTokenBalance and changeTokenBalances matchers", fun it("includes test file", async function () { try { await expect( - mockToken.transfer(receiver.address, 50) + mockToken.write.transfer([receiver.account.address, 50n]) ).to.changeTokenBalances( mockToken, [sender, receiver], @@ -772,12 +658,12 @@ function zip(a: T[], b: U[]): Array<[T, U]> { */ async function runAllAsserts( expr: - | TransactionResponse - | Promise - | (() => TransactionResponse) - | (() => Promise), + | `0x${string}` + | Promise<`0x${string}`> + | (() => `0x${string}`) + | (() => Promise<`0x${string}`>), token: Token, - accounts: Array, + accounts: Array<`0x${string}` | WalletClient>, balances: Array ) { // changeTokenBalances works for the given arrays diff --git a/packages/hardhat-chai-matchers-viem/test/contracts.ts b/packages/hardhat-chai-matchers-viem/test/contracts.ts index 451bf646c4..0a1d14ba58 100644 --- a/packages/hardhat-chai-matchers-viem/test/contracts.ts +++ b/packages/hardhat-chai-matchers-viem/test/contracts.ts @@ -1,133 +1,20 @@ -import { - BaseContract, - BaseContractMethod, - ContractTransactionResponse, - BigNumberish, - AddressLike, -} from "ethers"; +import type { GetContractReturnType } from "@nomicfoundation/hardhat-viem/types"; +import type { ArtifactsMap } from "hardhat/types/artifacts"; -export type MatchersContract = BaseContract & { - panicAssert: BaseContractMethod<[], void, ContractTransactionResponse>; - revertWithCustomErrorWithInt: BaseContractMethod< - [BigNumberish], - void, - ContractTransactionResponse - >; - revertWithCustomErrorWithPair: BaseContractMethod< - [BigNumberish, BigNumberish], - void, - ContractTransactionResponse - >; - revertWithCustomErrorWithUint: BaseContractMethod< - [BigNumberish], - void, - ContractTransactionResponse - >; - revertWithCustomErrorWithUintAndString: BaseContractMethod< - [BigNumberish, string], - void, - ContractTransactionResponse - >; - revertWithSomeCustomError: BaseContractMethod< - [], - void, - ContractTransactionResponse - >; - revertsWith: BaseContractMethod<[string], void, ContractTransactionResponse>; - revertsWithoutReason: BaseContractMethod< - [], - void, - ContractTransactionResponse - >; - succeeds: BaseContractMethod<[], void, ContractTransactionResponse>; -}; +export type Token = GetContractReturnType; -export type ChangeEtherBalance = BaseContract & { - returnHalf: BaseContractMethod<[], void, ContractTransactionResponse>; - transferTo: BaseContractMethod<[string], void, ContractTransactionResponse>; -}; +export type MatchersContract = GetContractReturnType< + ArtifactsMap["Matchers"]["abi"] +>; -export type EventsContract = BaseContract & { - doNotEmit: BaseContractMethod<[], void, ContractTransactionResponse>; - emitBytes32: BaseContractMethod<[string], void, ContractTransactionResponse>; - emitBytes32Array: BaseContractMethod< - [string, string], - void, - ContractTransactionResponse - >; - emitBytes: BaseContractMethod<[string], void, ContractTransactionResponse>; - emitIndexedBytes32: BaseContractMethod< - [string], - void, - ContractTransactionResponse - >; - emitIndexedBytes: BaseContractMethod< - [string], - void, - ContractTransactionResponse - >; - emitIndexedString: BaseContractMethod< - [string], - void, - ContractTransactionResponse - >; - emitInt: BaseContractMethod< - [BigNumberish], - void, - ContractTransactionResponse - >; - emitAddress: BaseContractMethod< - [AddressLike], - void, - ContractTransactionResponse - >; - emitNestedUintFromAnotherContract: BaseContractMethod< - [BigNumberish], - void, - ContractTransactionResponse - >; - emitNestedUintFromSameContract: BaseContractMethod< - [BigNumberish], - void, - ContractTransactionResponse - >; - emitString: BaseContractMethod<[string], void, ContractTransactionResponse>; - emitStruct: BaseContractMethod< - [BigNumberish, BigNumberish], - void, - ContractTransactionResponse - >; - emitTwoUints: BaseContractMethod< - [BigNumberish, BigNumberish], - void, - ContractTransactionResponse - >; - emitTwoUintsAndTwoStrings: BaseContractMethod< - [BigNumberish, BigNumberish, string, string], - void, - ContractTransactionResponse - >; - emitUint: BaseContractMethod< - [BigNumberish], - void, - ContractTransactionResponse - >; - emitUintAndString: BaseContractMethod< - [BigNumberish, string], - void, - ContractTransactionResponse - >; - emitUintArray: BaseContractMethod< - [BigNumberish, BigNumberish], - void, - ContractTransactionResponse - >; - emitUintTwice: BaseContractMethod< - [BigNumberish, BigNumberish], - void, - ContractTransactionResponse - >; - emitWithoutArgs: BaseContractMethod<[], void, ContractTransactionResponse>; -}; +export type ChangeEtherBalance = GetContractReturnType< + ArtifactsMap["ChangeEtherBalance"]["abi"] +>; -export type AnotherContract = BaseContract & {}; +export type EventsContract = GetContractReturnType< + ArtifactsMap["Events"]["abi"] +>; + +export type AnotherContract = GetContractReturnType< + ArtifactsMap["AnotherContract"]["abi"] +>; diff --git a/packages/hardhat-chai-matchers-viem/test/events.ts b/packages/hardhat-chai-matchers-viem/test/events.ts index e9f9d00a18..0fef2abead 100644 --- a/packages/hardhat-chai-matchers-viem/test/events.ts +++ b/packages/hardhat-chai-matchers-viem/test/events.ts @@ -3,9 +3,16 @@ import type { EventsContract, MatchersContract, } from "./contracts"; - +import { generatePrivateKey, privateKeyToAccount } from "viem/accounts"; +import { + createWalletClient, + custom, + keccak256, + toHex, + stringToBytes, + pad, +} from "viem"; import { expect, AssertionError } from "chai"; -import { ethers } from "ethers"; import "../src/internal/add-chai-matchers"; import { anyUint, anyValue } from "../src/withArgs"; @@ -30,24 +37,18 @@ describe(".to.emit (contract events)", () => { function runTests() { beforeEach(async function () { - otherContract = await this.hre.ethers.deployContract("AnotherContract"); + otherContract = await this.hre.viem.deployContract("AnotherContract"); - contract = await ( - await this.hre.ethers.getContractFactory<[string], EventsContract>( - "Events" - ) - ).deploy(await otherContract.getAddress()); + contract = await this.hre.viem.deployContract("Events", [ + otherContract.address, + ]); - const Matchers = await this.hre.ethers.getContractFactory< - [], - MatchersContract - >("Matchers"); - matchers = await Matchers.deploy(); + matchers = await this.hre.viem.deployContract("Matchers"); }); it("Should fail when expecting an event that's not in the contract", async function () { await expect( - expect(contract.doNotEmit()).to.emit(contract, "NonexistentEvent") + expect(contract.write.doNotEmit()).to.emit(contract, "NonexistentEvent") ).to.be.eventually.rejectedWith( AssertionError, 'Event "NonexistentEvent" doesn\'t exist in the contract' @@ -56,7 +57,10 @@ describe(".to.emit (contract events)", () => { it("Should fail when expecting an event that's not in the contract to NOT be emitted", async function () { await expect( - expect(contract.doNotEmit()).not.to.emit(contract, "NonexistentEvent") + expect(contract.write.doNotEmit()).not.to.emit( + contract, + "NonexistentEvent" + ) ).to.be.eventually.rejectedWith( AssertionError, 'Event "NonexistentEvent" doesn\'t exist in the contract' @@ -65,8 +69,12 @@ describe(".to.emit (contract events)", () => { it("Should fail when matcher is called with too many arguments", async function () { await expect( - // @ts-expect-error - expect(contract.emitUint(1)).not.to.emit(contract, "WithoutArgs", 1) + expect(contract.write.emitUint([1n])).not.to.emit( + contract, + "WithoutArgs", + // @ts-expect-error + 1 + ) ).to.be.eventually.rejectedWith( Error, "`.emit` expects only two arguments: the contract and the event name. Arguments should be asserted with the `.withArgs` helper." @@ -74,12 +82,15 @@ describe(".to.emit (contract events)", () => { }); it("Should detect events without arguments", async function () { - await expect(contract.emitWithoutArgs()).to.emit(contract, "WithoutArgs"); + await expect(contract.write.emitWithoutArgs()).to.emit( + contract, + "WithoutArgs" + ); }); it("Should fail when expecting an event that wasn't emitted", async function () { await expect( - expect(contract.doNotEmit()).to.emit(contract, "WithoutArgs") + expect(contract.write.doNotEmit()).to.emit(contract, "WithoutArgs") ).to.be.eventually.rejectedWith( AssertionError, 'Expected event "WithoutArgs" to be emitted, but it wasn\'t' @@ -88,7 +99,10 @@ describe(".to.emit (contract events)", () => { it("Should fail when expecting a specific event NOT to be emitted but it WAS", async function () { await expect( - expect(contract.emitWithoutArgs()).to.not.emit(contract, "WithoutArgs") + expect(contract.write.emitWithoutArgs()).to.not.emit( + contract, + "WithoutArgs" + ) ).to.be.eventually.rejectedWith( AssertionError, 'Expected event "WithoutArgs" NOT to be emitted, but it was' @@ -98,7 +112,7 @@ describe(".to.emit (contract events)", () => { describe(".withArgs", function () { it("Should fail when used with .not.", async function () { expect(() => - expect(contract.emitUint(1)) + expect(contract.write.emitUint([1n])) .not.to.emit(contract, "WithUintArg") .withArgs(1) ).to.throw(Error, "Do not combine .not. with .withArgs()"); @@ -106,7 +120,7 @@ describe(".to.emit (contract events)", () => { it("Should fail when used with .not, subject is a rejected promise", async function () { expect(() => - expect(matchers.revertsWithoutReason()) + expect(matchers.write.revertsWithoutReason()) .not.to.emit(contract, "WithUintArg") .withArgs(1) ).to.throw(Error, "Do not combine .not. with .withArgs()"); @@ -114,7 +128,7 @@ describe(".to.emit (contract events)", () => { it("should fail if withArgs is called on its own", async function () { expect(() => - expect(contract.emitUint(1)) + expect(contract.write.emitUint([1n])) // @ts-expect-error .withArgs(1) ).to.throw( @@ -124,21 +138,21 @@ describe(".to.emit (contract events)", () => { }); it("Should verify zero arguments", async function () { - await expect(contract.emitWithoutArgs()) + await expect(contract.write.emitWithoutArgs()) .to.emit(contract, "WithoutArgs") .withArgs(); }); describe("with a uint argument", function () { it("Should match the argument", async function () { - await expect(contract.emitUint(1)) + await expect(contract.write.emitUint([1n])) .to.emit(contract, "WithUintArg") .withArgs(1); }); it("Should fail when the input argument doesn't match the event argument", async function () { await expect( - expect(contract.emitUint(1)) + expect(contract.write.emitUint([1n])) .to.emit(contract, "WithUintArg") .withArgs(2) ).to.be.eventually.rejectedWith( @@ -149,7 +163,7 @@ describe(".to.emit (contract events)", () => { it("Should fail when too many arguments are given", async function () { await expect( - expect(contract.emitUint(1)) + expect(contract.write.emitUint([1n])) .to.emit(contract, "WithUintArg") .withArgs(1, 3) ).to.be.eventually.rejectedWith( @@ -160,28 +174,40 @@ describe(".to.emit (contract events)", () => { }); describe("with an address argument", function () { - const addressable = ethers.Wallet.createRandom(); - const { address } = addressable; - const otherAddressable = ethers.Wallet.createRandom(); - const { address: otherAddress } = otherAddressable; + // create dummy transport so we can create wallets + const transport = custom({ + async request() {}, + }); + + const wallet = createWalletClient({ + account: privateKeyToAccount(generatePrivateKey()), + transport, + }); + const address = wallet.account.address; + + const otherWallet = createWalletClient({ + account: privateKeyToAccount(generatePrivateKey()), + transport, + }); + const otherAddress = otherWallet.account.address; it("Should match the argument", async function () { - await expect(contract.emitAddress(addressable)) + await expect(contract.write.emitAddress([address])) .to.emit(contract, "WithAddressArg") .withArgs(address); }); it("Should match addressable arguments", async function () { - await expect(contract.emitAddress(addressable)) + await expect(contract.write.emitAddress([address])) .to.emit(contract, "WithAddressArg") - .withArgs(addressable); + .withArgs(wallet); }); it("Should fail when the input argument doesn't match the addressable event argument", async function () { await expect( - expect(contract.emitAddress(addressable)) + expect(contract.write.emitAddress([address])) .to.emit(contract, "WithAddressArg") - .withArgs(otherAddressable) + .withArgs(otherWallet) ).to.be.eventually.rejectedWith( AssertionError, `Error in "WithAddressArg" event: Error in the 1st argument assertion: expected '${address}' to equal '${otherAddress}'` @@ -190,7 +216,7 @@ describe(".to.emit (contract events)", () => { it("Should fail when the input argument doesn't match the address event argument", async function () { await expect( - expect(contract.emitAddress(addressable)) + expect(contract.write.emitAddress([address])) .to.emit(contract, "WithAddressArg") .withArgs(otherAddress) ).to.be.eventually.rejectedWith( @@ -201,7 +227,7 @@ describe(".to.emit (contract events)", () => { it("Should fail when too many arguments are given", async function () { await expect( - expect(contract.emitAddress(addressable)) + expect(contract.write.emitAddress([address])) .to.emit(contract, "WithAddressArg") .withArgs(address, otherAddress) ).to.be.eventually.rejectedWith( @@ -212,11 +238,15 @@ describe(".to.emit (contract events)", () => { }); // for abbreviating long strings in diff views like chai does: - function abbrev(longString: string): string { + function abbrev(longString: `0x${string}`): string { return `${longString.substring(0, 37)}…`; } - function formatHash(str: string, hashFn = ethers.id) { + function defaultHashFunction(str: string): `0x${string}` { + return keccak256(toHex(str)); + } + + function formatHash(str: string, hashFn = defaultHashFunction) { const hash = hashFn(str); return { str, @@ -226,13 +256,13 @@ describe(".to.emit (contract events)", () => { } function formatBytes(str: string) { - const bytes = ethers.hexlify(ethers.toUtf8Bytes(str)); - const bytes32 = ethers.zeroPadValue(bytes, 32); + const bytes = toHex(stringToBytes(str)); + const bytes32 = pad(bytes, { size: 32 }); return { ...formatHash(str), bytes, bytes32, - abbrev32: abbrev(ethers.hexlify(bytes32)), + abbrev32: abbrev(bytes32), }; } @@ -241,14 +271,14 @@ describe(".to.emit (contract events)", () => { describe("with a string argument", function () { it("Should match the argument", async function () { - await expect(contract.emitString("string")) + await expect(contract.write.emitString(["string"])) .to.emit(contract, "WithStringArg") .withArgs("string"); }); it("Should fail when the input argument doesn't match the event argument", async function () { await expect( - expect(contract.emitString(str1.str)) + expect(contract.write.emitString([str1.str])) .to.emit(contract, "WithStringArg") .withArgs(str2.str) ).to.be.eventually.rejectedWith( @@ -260,14 +290,14 @@ describe(".to.emit (contract events)", () => { describe("with an indexed string argument", function () { it("Should match the argument", async function () { - await expect(contract.emitIndexedString(str1.str)) + await expect(contract.write.emitIndexedString([str1.str])) .to.emit(contract, "WithIndexedStringArg") .withArgs(str1.str); }); it("Should fail when the input argument doesn't match the event argument", async function () { await expect( - expect(contract.emitIndexedString(str1.str)) + expect(contract.write.emitIndexedString([str1.str])) .to.emit(contract, "WithIndexedStringArg") .withArgs(str2.str) ).to.be.eventually.rejectedWith( @@ -278,7 +308,7 @@ describe(".to.emit (contract events)", () => { it("Should fail if expected argument is the hash not the pre-image", async function () { await expect( - expect(contract.emitIndexedString(str1.str)) + expect(contract.write.emitIndexedString([str1.str])) .to.emit(contract, "WithIndexedStringArg") .withArgs(str1.hash) ).to.be.eventually.rejectedWith( @@ -288,9 +318,12 @@ describe(".to.emit (contract events)", () => { }); it("Should fail when trying to match the event argument with an incorrect hash value", async function () { - const incorrect = formatHash(str2.hash, ethers.keccak256); + const incorrect = formatHash( + str2.hash, + keccak256 as (str: string) => `0x${string}` + ); await expect( - expect(contract.emitIndexedString(str1.str)) + expect(contract.write.emitIndexedString([str1.str])) .to.emit(contract, "WithIndexedStringArg") .withArgs(incorrect.str) ).to.be.eventually.rejectedWith( @@ -302,14 +335,14 @@ describe(".to.emit (contract events)", () => { describe("with a bytes argument", function () { it("Should match the argument", async function () { - await expect(contract.emitBytes(str1.bytes)) + await expect(contract.write.emitBytes([str1.bytes])) .to.emit(contract, "WithBytesArg") .withArgs(str1.bytes); }); it("Should fail when the input argument doesn't match the event argument", async function () { await expect( - expect(contract.emitBytes(str2.bytes)) + expect(contract.write.emitBytes([str2.bytes])) .to.emit(contract, "WithBytesArg") .withArgs(str1.str) ).to.be.eventually.rejectedWith( @@ -321,14 +354,14 @@ describe(".to.emit (contract events)", () => { describe("with an indexed bytes argument", function () { it("Should match the argument", async function () { - await expect(contract.emitIndexedBytes(str1.bytes)) + await expect(contract.write.emitIndexedBytes([str1.bytes])) .to.emit(contract, "WithIndexedBytesArg") .withArgs(str1.str); }); it("Should fail when the input argument doesn't match the event argument", async function () { await expect( - expect(contract.emitIndexedBytes(str2.bytes)) + expect(contract.write.emitIndexedBytes([str2.bytes])) .to.emit(contract, "WithIndexedBytesArg") .withArgs(str1.str) ).to.be.eventually.rejectedWith( @@ -339,7 +372,7 @@ describe(".to.emit (contract events)", () => { it("Should fail the passerd argument is the hash, not the pre-image", async function () { await expect( - expect(contract.emitIndexedBytes(str1.bytes)) + expect(contract.write.emitIndexedBytes([str1.bytes])) .to.emit(contract, "WithIndexedBytesArg") .withArgs(str1.hash) ).to.be.eventually.rejectedWith( @@ -351,14 +384,14 @@ describe(".to.emit (contract events)", () => { describe("with a bytes32 argument", function () { it("Should match the argument", async function () { - await expect(contract.emitBytes32(str1.bytes32)) + await expect(contract.write.emitBytes32([str1.bytes32])) .to.emit(contract, "WithBytes32Arg") .withArgs(str1.bytes32); }); it("Should fail when the input argument doesn't match the event argument", async function () { await expect( - expect(contract.emitBytes32(str2.bytes32)) + expect(contract.write.emitBytes32([str2.bytes32])) .to.emit(contract, "WithBytes32Arg") .withArgs(str1.bytes32) ).to.be.eventually.rejectedWith( @@ -370,14 +403,14 @@ describe(".to.emit (contract events)", () => { describe("with an indexed bytes32 argument", function () { it("Should match the argument", async function () { - await expect(contract.emitIndexedBytes32(str1.bytes32)) + await expect(contract.write.emitIndexedBytes32([str1.bytes32])) .to.emit(contract, "WithIndexedBytes32Arg") .withArgs(str1.bytes32); }); it("Should fail when the input argument doesn't match the event argument", async function () { await expect( - expect(contract.emitIndexedBytes32(str2.bytes32)) + expect(contract.write.emitIndexedBytes32([str2.bytes32])) .to.emit(contract, "WithIndexedBytes32Arg") .withArgs(str1.bytes32) ).to.be.eventually.rejectedWith( @@ -389,14 +422,14 @@ describe(".to.emit (contract events)", () => { describe("with a uint array argument", function () { it("Should succeed when expectations are met", async function () { - await expect(contract.emitUintArray(1, 2)) + await expect(contract.write.emitUintArray([1n, 2n])) .to.emit(contract, "WithUintArray") .withArgs([1, 2]); }); it("Should fail when expectations are not met", async function () { await expect( - expect(contract.emitUintArray(1, 2)) + expect(contract.write.emitUintArray([1n, 2n])) .to.emit(contract, "WithUintArray") .withArgs([3, 4]) ).to.be.eventually.rejectedWith( @@ -407,14 +440,14 @@ describe(".to.emit (contract events)", () => { describe("nested predicate", function () { it("Should succeed when predicate passes", async function () { - await expect(contract.emitUintArray(1, 2)) + await expect(contract.write.emitUintArray([1n, 2n])) .to.emit(contract, "WithUintArray") .withArgs([anyValue, 2]); }); it("Should fail when predicate returns false", async function () { await expect( - expect(contract.emitUintArray(1, 2)) + expect(contract.write.emitUintArray([1n, 2n])) .to.emit(contract, "WithUintArray") .withArgs([() => false, 4]) ).to.be.eventually.rejectedWith( @@ -425,7 +458,7 @@ describe(".to.emit (contract events)", () => { it("Should fail when predicate reverts", async function () { await expect( - expect(contract.emitUintArray(1, 2)) + expect(contract.write.emitUintArray([1n, 2n])) .to.emit(contract, "WithUintArray") .withArgs([ () => { @@ -443,7 +476,7 @@ describe(".to.emit (contract events)", () => { describe("arrays different length", function () { it("Should fail when the array is shorter", async function () { await expect( - expect(contract.emitUintArray(1, 2)) + expect(contract.write.emitUintArray([1n, 2n])) .to.emit(contract, "WithUintArray") .withArgs([1]) ).to.be.eventually.rejectedWith( @@ -454,7 +487,7 @@ describe(".to.emit (contract events)", () => { it("Should fail when the array is longer", async function () { await expect( - expect(contract.emitUintArray(1, 2)) + expect(contract.write.emitUintArray([1n, 2n])) .to.emit(contract, "WithUintArray") .withArgs([1, 2, 3]) ).to.be.eventually.rejectedWith( @@ -466,20 +499,20 @@ describe(".to.emit (contract events)", () => { }); describe("with a bytes32 array argument", function () { - const aa = `0x${"aa".repeat(32)}`; - const bb = `0x${"bb".repeat(32)}`; - const cc = `0x${"cc".repeat(32)}`; - const dd = `0x${"dd".repeat(32)}`; + const aa: `0x${string}` = `0x${"aa".repeat(32)}`; + const bb: `0x${string}` = `0x${"bb".repeat(32)}`; + const cc: `0x${string}` = `0x${"cc".repeat(32)}`; + const dd: `0x${string}` = `0x${"dd".repeat(32)}`; it("Should succeed when expectations are met", async function () { - await expect(contract.emitBytes32Array(aa, bb)) + await expect(contract.write.emitBytes32Array([aa, bb])) .to.emit(contract, "WithBytes32Array") .withArgs([aa, bb]); }); it("Should fail when expectations are not met", async function () { await expect( - expect(contract.emitBytes32Array(aa, bb)) + expect(contract.write.emitBytes32Array([aa, bb])) .to.emit(contract, "WithBytes32Array") .withArgs([cc, dd]) ).to.be.eventually.rejectedWith( @@ -493,14 +526,14 @@ describe(".to.emit (contract events)", () => { describe("with a struct argument", function () { it("Should succeed when expectations are met", async function () { - await expect(contract.emitStruct(1, 2)) + await expect(contract.write.emitStruct([1n, 2n])) .to.emit(contract, "WithStructArg") .withArgs([1, 2]); }); it("Should fail when expectations are not met", async function () { await expect( - expect(contract.emitStruct(1, 2)) + expect(contract.write.emitStruct([1n, 2n])) .to.emit(contract, "WithStructArg") .withArgs([3, 4]) ).to.be.eventually.rejectedWith( @@ -512,14 +545,14 @@ describe(".to.emit (contract events)", () => { describe("with multiple arguments", function () { it("Should successfully match the arguments", async function () { - await expect(contract.emitTwoUints(1, 2)) + await expect(contract.write.emitTwoUints([1n, 2n])) .to.emit(contract, "WithTwoUintArgs") .withArgs(1, 2); }); it("Should fail when the first argument isn't matched", async function () { await expect( - expect(contract.emitTwoUints(1, 2)) + expect(contract.write.emitTwoUints([1n, 2n])) .to.emit(contract, "WithTwoUintArgs") .withArgs(2, 2) ).to.be.eventually.rejectedWith( @@ -530,7 +563,7 @@ describe(".to.emit (contract events)", () => { it("Should fail when the second argument isn't matched", async function () { await expect( - expect(contract.emitTwoUints(1, 2)) + expect(contract.write.emitTwoUints([1n, 2n])) .to.emit(contract, "WithTwoUintArgs") .withArgs(1, 1) ).to.be.eventually.rejectedWith( @@ -541,7 +574,7 @@ describe(".to.emit (contract events)", () => { it("Should fail when too many arguments are supplied", async function () { await expect( - expect(contract.emitTwoUints(1, 2)) + expect(contract.write.emitTwoUints([1n, 2n])) .to.emit(contract, "WithTwoUintArgs") .withArgs(1, 2, 3, 4) ).to.be.eventually.rejectedWith( @@ -552,7 +585,7 @@ describe(".to.emit (contract events)", () => { it("Should fail when too few arguments are supplied", async function () { await expect( - expect(contract.emitTwoUints(1, 2)) + expect(contract.write.emitTwoUints([1n, 2n])) .to.emit(contract, "WithTwoUintArgs") .withArgs(1) ).to.be.eventually.rejectedWith( @@ -563,14 +596,14 @@ describe(".to.emit (contract events)", () => { describe("Should handle argument predicates", function () { it("Should pass when a predicate argument returns true", async function () { - await expect(contract.emitTwoUints(1, 2)) + await expect(contract.write.emitTwoUints([1n, 2n])) .to.emit(contract, "WithTwoUintArgs") .withArgs(anyValue, anyUint); }); it("Should fail when a predicate argument returns false", async function () { await expect( - expect(contract.emitTwoUints(1, 2)) + expect(contract.write.emitTwoUints([1n, 2n])) .to.emit(contract, "WithTwoUintArgs") .withArgs(1, () => false) ).to.be.rejectedWith( @@ -581,7 +614,7 @@ describe(".to.emit (contract events)", () => { it("Should fail when a predicate argument throws an error", async function () { await expect( - expect(contract.emitTwoUints(1, 2)) + expect(contract.write.emitTwoUints([1n, 2n])) .to.emit(contract, "WithTwoUintArgs") .withArgs(() => { throw new Error("user-defined error"); @@ -595,7 +628,7 @@ describe(".to.emit (contract events)", () => { describe("with predicate anyUint", function () { it("Should fail when the event argument is a string", async function () { await expect( - expect(contract.emitString("a string")) + expect(contract.write.emitString(["a string"])) .to.emit(contract, "WithStringArg") .withArgs(anyUint) ).to.be.rejectedWith( @@ -606,7 +639,7 @@ describe(".to.emit (contract events)", () => { it("Should fail when the event argument is negative", async function () { await expect( - expect(contract.emitInt(-1)) + expect(contract.write.emitInt([-1n])) .to.emit(contract, "WithIntArg") .withArgs(anyUint) ).to.be.rejectedWith( @@ -621,30 +654,28 @@ describe(".to.emit (contract events)", () => { describe("With one call that emits two separate events", function () { it("Should successfully catch each event independently", async function () { - await expect(contract.emitUintAndString(1, "a string")).to.emit( - contract, - "WithUintArg" - ); - await expect(contract.emitUintAndString(1, "a string")).to.emit( - contract, - "WithStringArg" - ); + await expect( + contract.write.emitUintAndString([1n, "a string"]) + ).to.emit(contract, "WithUintArg"); + await expect( + contract.write.emitUintAndString([1n, "a string"]) + ).to.emit(contract, "WithStringArg"); }); describe("When detecting two events from one call (chaining)", function () { it("Should succeed when both expected events are indeed emitted", async function () { - await expect(contract.emitUintAndString(1, "a string")) + await expect(contract.write.emitUintAndString([1n, "a string"])) .to.emit(contract, "WithUintArg") .and.to.emit(contract, "WithStringArg"); }); it("Should succeed when the expected event is emitted and the unexpected event is not", async function () { - await expect(contract.emitWithoutArgs()) + await expect(contract.write.emitWithoutArgs()) .to.emit(contract, "WithoutArgs") .and.not.to.emit(otherContract, "WithUintArg"); }); describe("When one of the expected events is emitted and the other is not", function () { it("Should fail when the first expected event is emitted but the second is not", async function () { await expect( - expect(contract.emitUint(1)) + expect(contract.write.emitUint([1n])) .to.emit(contract, "WithUintArg") .and.to.emit(contract, "WithStringArg") ).to.be.eventually.rejectedWith( @@ -654,7 +685,7 @@ describe(".to.emit (contract events)", () => { }); it("Should fail when the second expected event is emitted but the first is not", async function () { await expect( - expect(contract.emitUint(1)) + expect(contract.write.emitUint([1n])) .to.emit(contract, "WithStringArg") .and.to.emit(contract, "WithUintArg") ).to.be.eventually.rejectedWith( @@ -665,21 +696,21 @@ describe(".to.emit (contract events)", () => { }); describe("When specifying .withArgs()", function () { it("Should pass when expecting the correct args from the first event", async function () { - await expect(contract.emitUintAndString(1, "a string")) + await expect(contract.write.emitUintAndString([1n, "a string"])) .to.emit(contract, "WithUintArg") .withArgs(1) .and.to.emit(contract, "WithStringArg"); }); it("Should pass when expecting the correct args from the second event", async function () { - await expect(contract.emitUintAndString(1, "a string")) + await expect(contract.write.emitUintAndString([1n, "a string"])) .to.emit(contract, "WithUintArg") .and.to.emit(contract, "WithStringArg") .withArgs("a string"); }); it("Should pass when expecting the correct args from both events", async function () { - await expect(contract.emitUintAndString(1, "a string")) + await expect(contract.write.emitUintAndString([1n, "a string"])) .to.emit(contract, "WithUintArg") .withArgs(1) .and.to.emit(contract, "WithStringArg") @@ -688,7 +719,7 @@ describe(".to.emit (contract events)", () => { it("Should fail when expecting the wrong argument value for the first event", async function () { await expect( - expect(contract.emitUintAndString(1, "a string")) + expect(contract.write.emitUintAndString([1n, "a string"])) .to.emit(contract, "WithUintArg") .withArgs(2) .and.to.emit(contract, "WithStringArg") @@ -700,7 +731,7 @@ describe(".to.emit (contract events)", () => { it("Should fail when expecting the wrong argument value for the second event", async function () { await expect( - expect(contract.emitUintAndString(1, "a string")) + expect(contract.write.emitUintAndString([1n, "a string"])) .to.emit(contract, "WithUintArg") .and.to.emit(contract, "WithStringArg") .withArgs("a different string") @@ -712,7 +743,7 @@ describe(".to.emit (contract events)", () => { it("Should fail when expecting too many arguments from the first event", async function () { await expect( - expect(contract.emitUintAndString(1, "a string")) + expect(contract.write.emitUintAndString([1n, "a string"])) .to.emit(contract, "WithUintArg") .withArgs(1, 2) .and.to.emit(contract, "WithStringArg") @@ -724,7 +755,7 @@ describe(".to.emit (contract events)", () => { it("Should fail when expecting too many arguments from the second event", async function () { await expect( - expect(contract.emitUintAndString(1, "a string")) + expect(contract.write.emitUintAndString([1n, "a string"])) .to.emit(contract, "WithUintArg") .and.to.emit(contract, "WithStringArg") .withArgs("a different string", "yet another string") @@ -737,12 +768,12 @@ describe(".to.emit (contract events)", () => { it("Should fail when expecting too few arguments from the first event", async function () { await expect( expect( - contract.emitTwoUintsAndTwoStrings( - 1, - 2, + contract.write.emitTwoUintsAndTwoStrings([ + 1n, + 2n, "a string", - "another string" - ) + "another string", + ]) ) .to.emit(contract, "WithTwoUintArgs") .withArgs(1) @@ -756,12 +787,12 @@ describe(".to.emit (contract events)", () => { it("Should fail when expecting too few arguments from the second event", async function () { await expect( expect( - contract.emitTwoUintsAndTwoStrings( - 1, - 2, + contract.write.emitTwoUintsAndTwoStrings([ + 1n, + 2n, "a string", - "another string" - ) + "another string", + ]) ) .to.emit(contract, "WithTwoUintArgs") .and.to.emit(contract, "WithTwoStringArgs") @@ -775,7 +806,7 @@ describe(".to.emit (contract events)", () => { describe("With a contract that emits the same event twice but with different arguments", function () { it("Should pass when expectations are met", async function () { - await expect(contract.emitUintTwice(1, 2)) + await expect(contract.write.emitUintTwice([1n, 2n])) .to.emit(contract, "WithUintArg") .withArgs(1) .and.to.emit(contract, "WithUintArg") @@ -784,7 +815,7 @@ describe(".to.emit (contract events)", () => { it("Should fail when the first event's argument is not matched", async function () { await expect( - expect(contract.emitUintTwice(1, 2)) + expect(contract.write.emitUintTwice([1n, 2n])) .to.emit(contract, "WithUintArg") .withArgs(3) .and.to.emit(contract, "WithUintArg") @@ -797,7 +828,7 @@ describe(".to.emit (contract events)", () => { it("Should fail when the second event's argument is not matched", async function () { await expect( - expect(contract.emitUintTwice(1, 2)) + expect(contract.write.emitUintTwice([1n, 2n])) .to.emit(contract, "WithUintArg") .withArgs(1) .and.to.emit(contract, "WithUintArg") @@ -810,7 +841,7 @@ describe(".to.emit (contract events)", () => { it("Should fail when none of the emitted events match the given argument", async function () { await expect( - expect(contract.emitUintTwice(1, 2)) + expect(contract.write.emitUintTwice([1n, 2n])) .to.emit(contract, "WithUintArg") .withArgs(3) ).to.be.eventually.rejectedWith( @@ -825,14 +856,14 @@ describe(".to.emit (contract events)", () => { describe("When nested events are emitted", function () { describe("With the nested event emitted from the same contract", function () { it("Should pass when the expected event is emitted", async function () { - await expect(contract.emitNestedUintFromSameContract(1)) + await expect(contract.write.emitNestedUintFromSameContract([1n])) .to.emit(contract, "WithUintArg") .withArgs(1); }); it("Should fail when the expected event is not emitted", async function () { await expect( - expect(contract.emitNestedUintFromSameContract(1)).to.emit( + expect(contract.write.emitNestedUintFromSameContract([1n])).to.emit( contract, "WithStringArg" ) @@ -845,14 +876,14 @@ describe(".to.emit (contract events)", () => { describe("With the nested event emitted from a different contract", function () { it("Should pass when the expected event is emitted", async function () { - await expect(contract.emitNestedUintFromAnotherContract(1)) + await expect(contract.write.emitNestedUintFromAnotherContract([1n])) .to.emit(otherContract, "WithUintArg") .withArgs(1); }); it("Should fail when the expected event is emitted but not by the contract that was passed", async function () { await expect( - expect(contract.emitNestedUintFromAnotherContract(1)) + expect(contract.write.emitNestedUintFromAnotherContract([1n])) .to.emit(contract, "WithUintArg") .withArgs(1) ).to.be.eventually.rejectedWith( @@ -864,13 +895,15 @@ describe(".to.emit (contract events)", () => { }); it("With executed transaction", async () => { - const tx = await contract.emitWithoutArgs(); - await expect(tx).to.emit(contract, "WithoutArgs"); + await expect(contract.write.emitWithoutArgs()).to.emit( + contract, + "WithoutArgs" + ); }); it("With transaction hash", async () => { - const tx = await contract.emitWithoutArgs(); - await expect(tx.hash).to.emit(contract, "WithoutArgs"); + const txHash = await contract.write.emitWithoutArgs(); + await expect(txHash).to.emit(contract, "WithoutArgs"); }); } }); diff --git a/packages/hardhat-chai-matchers-viem/test/fixture-projects/hardhat-project/hardhat.config.js b/packages/hardhat-chai-matchers-viem/test/fixture-projects/hardhat-project/hardhat.config.js index d8edfc19ae..676ea8a4a5 100644 --- a/packages/hardhat-chai-matchers-viem/test/fixture-projects/hardhat-project/hardhat.config.js +++ b/packages/hardhat-chai-matchers-viem/test/fixture-projects/hardhat-project/hardhat.config.js @@ -1,4 +1,4 @@ -require("@nomicfoundation/hardhat-ethers"); +require("@nomicfoundation/hardhat-viem"); module.exports = { solidity: "0.8.4", diff --git a/packages/hardhat-chai-matchers-viem/test/helpers.ts b/packages/hardhat-chai-matchers-viem/test/helpers.ts index 09dc304b8b..bb8aa2f60c 100644 --- a/packages/hardhat-chai-matchers-viem/test/helpers.ts +++ b/packages/hardhat-chai-matchers-viem/test/helpers.ts @@ -1,14 +1,15 @@ import type { HardhatRuntimeEnvironment } from "hardhat/types"; import type { MatchersContract } from "./contracts"; +import { TransactionReceiptNotFoundError } from "viem"; import { AssertionError, expect } from "chai"; import { fork } from "child_process"; import getPort from "get-port"; import { resetHardhatContext } from "hardhat/plugins-testing"; import path from "path"; -// we assume that all the fixture projects use the hardhat-ethers plugin -import "@nomicfoundation/hardhat-ethers/internal/type-extensions"; +// we assume that all the fixture projects use the hardhat-viem plugin +import "@nomicfoundation/hardhat-viem/internal/type-extensions"; declare module "mocha" { interface Context { @@ -102,7 +103,6 @@ export function useEnvironmentWithNode(fixtureProjectName: string) { * - A write transaction * - A view method * - A gas estimation - * - A static call * And run the `successfulAssert` function with the result of each of these * calls. Since we expect this assertion to be successful, we just await its * result; if any of them fails, an error will be thrown. @@ -118,10 +118,9 @@ export async function runSuccessfulAsserts({ args?: any[]; successfulAssert: (x: any) => Promise; }) { - await successfulAssert(matchers[method](...args)); - await successfulAssert(matchers[`${method}View`](...args)); - await successfulAssert(matchers[method].estimateGas(...args)); - await successfulAssert(matchers[method].staticCall(...args)); + await successfulAssert(matchers.write[method](...args)); + await successfulAssert(matchers.read[method](...args)); + await successfulAssert(matchers.estimateGas[method](...args)); } /** @@ -141,18 +140,15 @@ export async function runFailedAsserts({ failedAssert: (x: any) => Promise; failedAssertReason: string; }) { - await expect(failedAssert(matchers[method](...args))).to.be.rejectedWith( + await expect( + failedAssert(matchers.write[method](...args)) + ).to.be.rejectedWith(AssertionError, failedAssertReason); + await expect(failedAssert(matchers.read[method](...args))).to.be.rejectedWith( AssertionError, failedAssertReason ); await expect( - failedAssert(matchers[`${method}View`](...args)) - ).to.be.rejectedWith(AssertionError, failedAssertReason); - await expect( - failedAssert(matchers[method].estimateGas(...args)) - ).to.be.rejectedWith(AssertionError, failedAssertReason); - await expect( - failedAssert(matchers[method].staticCall(...args)) + failedAssert(matchers.estimateGas[method](...args)) ).to.be.rejectedWith(AssertionError, failedAssertReason); } @@ -161,14 +157,14 @@ export async function mineSuccessfulTransaction( ) { await hre.network.provider.send("evm_setAutomine", [false]); - const [signer] = await hre.ethers.getSigners(); - const tx = await signer.sendTransaction({ to: signer.address }); + const [signer] = await hre.viem.getWalletClients(); + const txHash = await signer.sendTransaction({ to: signer.account.address }); - await mineBlocksUntilTxIsIncluded(hre, tx.hash); + await mineBlocksUntilTxIsIncluded(hre, txHash); await hre.network.provider.send("evm_setAutomine", [true]); - return tx; + return txHash; } export async function mineRevertedTransaction( @@ -177,31 +173,37 @@ export async function mineRevertedTransaction( ) { await hre.network.provider.send("evm_setAutomine", [false]); - const tx = await matchers.revertsWithoutReason({ - gasLimit: 1_000_000, + const txHash = await matchers.write.revertsWithoutReason({ + gas: 1_000_000n, }); - await mineBlocksUntilTxIsIncluded(hre, tx.hash); + await mineBlocksUntilTxIsIncluded(hre, txHash); await hre.network.provider.send("evm_setAutomine", [true]); - return tx; + return txHash; } async function mineBlocksUntilTxIsIncluded( hre: HardhatRuntimeEnvironment, - txHash: string + txHash: `0x${string}` ) { let i = 0; while (true) { - const receipt = await hre.ethers.provider.getTransactionReceipt(txHash); - - if (receipt !== null) { + try { + const publicClient = await hre.viem.getPublicClient(); + await publicClient.getTransactionReceipt({ + hash: txHash, + }); return; + } catch (e) { + if (!(e instanceof TransactionReceiptNotFoundError)) { + throw e; + } } - await hre.network.provider.send("hardhat_mine", []); + await hre.network.provider.send("evm_mine", []); i++; if (i > 100) { diff --git a/packages/hardhat-chai-matchers-viem/test/panic.ts b/packages/hardhat-chai-matchers-viem/test/panic.ts index efb6549161..fe7a65deb2 100644 --- a/packages/hardhat-chai-matchers-viem/test/panic.ts +++ b/packages/hardhat-chai-matchers-viem/test/panic.ts @@ -1,5 +1,4 @@ import { assert } from "chai"; -import { toBigInt } from "ethers"; import { PANIC_CODES, @@ -9,7 +8,7 @@ import { describe("panic codes", function () { it("all exported panic codes should have a description", async function () { for (const [key, code] of Object.entries(PANIC_CODES)) { - const description = panicErrorCodeToReason(toBigInt(code)); + const description = panicErrorCodeToReason(BigInt(code)); assert.isDefined(description, `No description for panic code ${key}`); } }); diff --git a/packages/hardhat-chai-matchers-viem/test/reverted/revertedWithCustomError.ts b/packages/hardhat-chai-matchers-viem/test/reverted/revertedWithCustomError.ts index c09f8101fd..da63d569b0 100644 --- a/packages/hardhat-chai-matchers-viem/test/reverted/revertedWithCustomError.ts +++ b/packages/hardhat-chai-matchers-viem/test/reverted/revertedWithCustomError.ts @@ -1,3 +1,4 @@ +import { privateKeyToAccount } from "viem/accounts"; import { AssertionError, expect } from "chai"; import { ProviderError } from "hardhat/internal/core/providers/errors"; import path from "path"; @@ -15,7 +16,7 @@ import "../../src/internal/add-chai-matchers"; import { anyUint, anyValue } from "../../src/withArgs"; import { MatchersContract } from "../contracts"; -describe("INTEGRATION: Reverted with custom error", function () { +describe.only("INTEGRATION: Reverted with custom error", function () { describe("with the in-process hardhat network", function () { useEnvironment("hardhat-project"); @@ -32,12 +33,7 @@ describe("INTEGRATION: Reverted with custom error", function () { // deploy Matchers contract before each test let matchers: MatchersContract; beforeEach("deploy matchers contract", async function () { - const Matchers = await this.hre.ethers.getContractFactory< - [], - MatchersContract - >("Matchers"); - - matchers = await Matchers.deploy(); + matchers = await this.hre.viem.deployContract("Matchers"); }); describe("calling a method that succeeds", function () { @@ -69,7 +65,7 @@ describe("INTEGRATION: Reverted with custom error", function () { }); describe("calling a method that reverts without a reason", function () { - it("successful asserts", async function () { + it.only("successful asserts", async function () { await runSuccessfulAsserts({ matchers, method: "revertsWithoutReason", @@ -225,14 +221,14 @@ describe("INTEGRATION: Reverted with custom error", function () { describe("with args", function () { describe("one argument", function () { it("Should match correct argument", async function () { - await expect(matchers.revertWithCustomErrorWithUint(1)) + await expect(matchers.write.revertWithCustomErrorWithUint([1n])) .to.be.revertedWithCustomError(matchers, "CustomErrorWithUint") .withArgs(1); }); it("Should fail if wrong argument", async function () { await expect( - expect(matchers.revertWithCustomErrorWithUint(1)) + expect(matchers.write.revertWithCustomErrorWithUint([1n])) .to.be.revertedWithCustomError(matchers, "CustomErrorWithUint") .withArgs(2) ).to.be.rejectedWith( @@ -245,7 +241,7 @@ describe("INTEGRATION: Reverted with custom error", function () { describe("two arguments", function () { it("Should match correct values", async function () { await expect( - matchers.revertWithCustomErrorWithUintAndString(1, "foo") + matchers.write.revertWithCustomErrorWithUintAndString([1n, "foo"]) ) .to.be.revertedWithCustomError( matchers, @@ -256,7 +252,9 @@ describe("INTEGRATION: Reverted with custom error", function () { it("Should fail if uint is wrong", async function () { await expect( - expect(matchers.revertWithCustomErrorWithUintAndString(1, "foo")) + expect( + matchers.write.revertWithCustomErrorWithUintAndString([1n, "foo"]) + ) .to.be.revertedWithCustomError( matchers, "CustomErrorWithUintAndString" @@ -270,7 +268,9 @@ describe("INTEGRATION: Reverted with custom error", function () { it("Should fail if string is wrong", async function () { await expect( - expect(matchers.revertWithCustomErrorWithUintAndString(1, "foo")) + expect( + matchers.write.revertWithCustomErrorWithUintAndString([1n, "foo"]) + ) .to.be.revertedWithCustomError( matchers, "CustomErrorWithUintAndString" @@ -284,7 +284,9 @@ describe("INTEGRATION: Reverted with custom error", function () { it("Should fail if first predicate throws", async function () { await expect( - expect(matchers.revertWithCustomErrorWithUintAndString(1, "foo")) + expect( + matchers.write.revertWithCustomErrorWithUintAndString([1n, "foo"]) + ) .to.be.revertedWithCustomError( matchers, "CustomErrorWithUintAndString" @@ -302,7 +304,9 @@ describe("INTEGRATION: Reverted with custom error", function () { describe("different number of arguments", function () { it("Should reject if expected fewer arguments", async function () { await expect( - expect(matchers.revertWithCustomErrorWithUintAndString(1, "s")) + expect( + matchers.write.revertWithCustomErrorWithUintAndString([1n, "s"]) + ) .to.be.revertedWithCustomError( matchers, "CustomErrorWithUintAndString" @@ -316,7 +320,9 @@ describe("INTEGRATION: Reverted with custom error", function () { it("Should reject if expected more arguments", async function () { await expect( - expect(matchers.revertWithCustomErrorWithUintAndString(1, "s")) + expect( + matchers.write.revertWithCustomErrorWithUintAndString([1n, "s"]) + ) .to.be.revertedWithCustomError( matchers, "CustomErrorWithUintAndString" @@ -331,14 +337,14 @@ describe("INTEGRATION: Reverted with custom error", function () { describe("nested arguments", function () { it("should match correct arguments", async function () { - await expect(matchers.revertWithCustomErrorWithPair(1, 2)) + await expect(matchers.write.revertWithCustomErrorWithPair([1n, 2n])) .to.be.revertedWithCustomError(matchers, "CustomErrorWithPair") .withArgs([1, 2]); }); it("should reject different arguments", async function () { await expect( - expect(matchers.revertWithCustomErrorWithPair(1, 2)) + expect(matchers.write.revertWithCustomErrorWithPair([1n, 2n])) .to.be.revertedWithCustomError(matchers, "CustomErrorWithPair") .withArgs([3, 2]) ).to.be.rejectedWith( @@ -351,7 +357,7 @@ describe("INTEGRATION: Reverted with custom error", function () { describe("array of different lengths", function () { it("Should fail if the expected array is bigger", async function () { await expect( - expect(matchers.revertWithCustomErrorWithPair(1, 2)) + expect(matchers.write.revertWithCustomErrorWithPair([1n, 2n])) .to.be.revertedWithCustomError(matchers, "CustomErrorWithPair") .withArgs([1]) ).to.be.rejectedWith( @@ -362,7 +368,7 @@ describe("INTEGRATION: Reverted with custom error", function () { it("Should fail if the expected array is smaller", async function () { await expect( - expect(matchers.revertWithCustomErrorWithPair(1, 2)) + expect(matchers.write.revertWithCustomErrorWithPair([1n, 2n])) .to.be.revertedWithCustomError(matchers, "CustomErrorWithPair") .withArgs([1, 2, 3]) ).to.be.rejectedWith( @@ -374,7 +380,7 @@ describe("INTEGRATION: Reverted with custom error", function () { it("Should fail when used with .not.", async function () { expect(() => - expect(matchers.revertWithSomeCustomError()) + expect(matchers.write.revertWithSomeCustomError()) .to.not.be.revertedWithCustomError(matchers, "SomeCustomError") .withArgs(1) ).to.throw(Error, "Do not combine .not. with .withArgs()"); @@ -382,7 +388,7 @@ describe("INTEGRATION: Reverted with custom error", function () { it("should fail if withArgs is called on its own", async function () { expect(() => - expect(matchers.revertWithCustomErrorWithUint(1)) + expect(matchers.write.revertWithCustomErrorWithUint([1n])) // @ts-expect-error .withArgs(1) ).to.throw( @@ -395,7 +401,7 @@ describe("INTEGRATION: Reverted with custom error", function () { // See https://github.com/NomicFoundation/hardhat/issues/4235 it.skip("should fail if both emit and revertedWithCustomError are called", async function () { expect(() => - expect(matchers.revertWithSomeCustomError()) + expect(matchers.write.revertWithSomeCustomError()) .to.emit(matchers, "SomeEvent") .and.to.be.revertedWithCustomError(matchers, "SomeCustomError") .withArgs(1) @@ -407,17 +413,17 @@ describe("INTEGRATION: Reverted with custom error", function () { describe("Should handle argument predicates", function () { it("Should pass when a predicate argument returns true", async function () { - await expect(matchers.revertWithCustomErrorWithUint(1)) + await expect(matchers.write.revertWithCustomErrorWithUint([1n])) .to.be.revertedWithCustomError(matchers, "CustomErrorWithUint") .withArgs(anyValue); - await expect(matchers.revertWithCustomErrorWithUint(1)) + await expect(matchers.write.revertWithCustomErrorWithUint([1n])) .to.be.revertedWithCustomError(matchers, "CustomErrorWithUint") .withArgs(anyUint); }); it("Should fail when a predicate argument returns false", async function () { await expect( - expect(matchers.revertWithCustomErrorWithUint(1)) + expect(matchers.write.revertWithCustomErrorWithUint([1n])) .to.be.revertedWithCustomError(matchers, "CustomErrorWithUint") .withArgs(() => false) ).to.be.rejectedWith( @@ -428,7 +434,7 @@ describe("INTEGRATION: Reverted with custom error", function () { it("Should fail when a predicate argument throws an error", async function () { await expect( - expect(matchers.revertWithCustomErrorWithInt(-1)) + expect(matchers.write.revertWithCustomErrorWithInt([-1n])) .to.be.revertedWithCustomError(matchers, "CustomErrorWithInt") .withArgs(anyUint) ).to.be.rejectedWith( @@ -450,7 +456,7 @@ describe("INTEGRATION: Reverted with custom error", function () { }); it("non-string as expectation", async function () { - const { hash } = await mineSuccessfulTransaction(this.hre); + const hash = await mineSuccessfulTransaction(this.hre); expect(() => // @ts-expect-error @@ -460,7 +466,7 @@ describe("INTEGRATION: Reverted with custom error", function () { it("the contract is not specified", async function () { expect(() => - expect(matchers.revertWithSomeCustomError()) + expect(matchers.write.revertWithSomeCustomError()) .to.be // @ts-expect-error .revertedWithCustomError("SomeCustomError") ).to.throw( @@ -472,7 +478,7 @@ describe("INTEGRATION: Reverted with custom error", function () { it("the contract doesn't have a custom error with that name", async function () { expect(() => expect( - matchers.revertWithSomeCustomError() + matchers.write.revertWithSomeCustomError() ).to.be.revertedWithCustomError(matchers, "SomeCustmError") ).to.throw( Error, @@ -484,20 +490,18 @@ describe("INTEGRATION: Reverted with custom error", function () { // use an address that almost surely doesn't have balance const randomPrivateKey = "0xc5c587cc6e48e9692aee0bf07474118e6d830c11905f7ec7ff32c09c99eba5f9"; - const signer = new this.hre.ethers.Wallet( - randomPrivateKey, - this.hre.ethers.provider - ); - const matchersFromSenderWithoutFunds = matchers.connect( - signer - ) as MatchersContract; + const account = privateKeyToAccount(randomPrivateKey); + const wallet = await this.hre.viem.getWalletClient(account.address, { + account, + }); // this transaction will fail because of lack of funds, not because of a // revert await expect( expect( - matchersFromSenderWithoutFunds.revertsWithoutReason({ - gasLimit: 1_000_000, + matchers.write.revertsWithoutReason({ + gas: 1_000_000n, + account: wallet.account, }) ).to.not.be.revertedWithCustomError(matchers, "SomeCustomError") ).to.be.eventually.rejectedWith( @@ -509,7 +513,7 @@ describe("INTEGRATION: Reverted with custom error", function () { it("extra arguments", async function () { expect(() => expect( - matchers.revertWithSomeCustomError() + matchers.write.revertWithSomeCustomError() ).to.be.revertedWithCustomError( matchers, "SomeCustomError", @@ -528,7 +532,7 @@ describe("INTEGRATION: Reverted with custom error", function () { it("includes test file", async function () { try { await expect( - matchers.revertsWith("some reason") + matchers.write.revertsWith(["some reason"]) ).to.be.revertedWithCustomError(matchers, "SomeCustomError"); } catch (e: any) { const errorString = util.inspect(e); From 8b8bbcc0015738e16c6082b5bad8757f286071d4 Mon Sep 17 00:00:00 2001 From: johnpm-12 <39016062+johnpm-12@users.noreply.github.com> Date: Fri, 17 May 2024 20:40:49 -0700 Subject: [PATCH 03/18] fix reverted with custom errors test --- .../src/internal/reverted/utils.ts | 2 - .../test/helpers.ts | 20 +- .../test/reverted/revertedWithCustomError.ts | 13 +- pnpm-lock.yaml | 12315 +++++++++------- 4 files changed, 7233 insertions(+), 5117 deletions(-) diff --git a/packages/hardhat-chai-matchers-viem/src/internal/reverted/utils.ts b/packages/hardhat-chai-matchers-viem/src/internal/reverted/utils.ts index 26a1ea906b..21a4f5f99a 100644 --- a/packages/hardhat-chai-matchers-viem/src/internal/reverted/utils.ts +++ b/packages/hardhat-chai-matchers-viem/src/internal/reverted/utils.ts @@ -46,10 +46,8 @@ export function getReturnDataFromError(error: any): `0x${string}` { (returnData: any) => typeof returnData === "string" && returnData.startsWith("0x") ); - console.log(returnData); if (typeof returnData !== "string") { - console.log(JSON.stringify(error, undefined, 2)); throw error; } diff --git a/packages/hardhat-chai-matchers-viem/test/helpers.ts b/packages/hardhat-chai-matchers-viem/test/helpers.ts index bb8aa2f60c..565cbd5c5e 100644 --- a/packages/hardhat-chai-matchers-viem/test/helpers.ts +++ b/packages/hardhat-chai-matchers-viem/test/helpers.ts @@ -110,7 +110,7 @@ export function useEnvironmentWithNode(fixtureProjectName: string) { export async function runSuccessfulAsserts({ matchers, method, - args = [], + args, successfulAssert, }: { matchers: any; @@ -118,9 +118,9 @@ export async function runSuccessfulAsserts({ args?: any[]; successfulAssert: (x: any) => Promise; }) { - await successfulAssert(matchers.write[method](...args)); - await successfulAssert(matchers.read[method](...args)); - await successfulAssert(matchers.estimateGas[method](...args)); + await successfulAssert(matchers.write[method](args)); + await successfulAssert(matchers.read[`${method}View`](args)); + await successfulAssert(matchers.estimateGas[method](args)); } /** @@ -130,7 +130,7 @@ export async function runSuccessfulAsserts({ export async function runFailedAsserts({ matchers, method, - args = [], + args, failedAssert, failedAssertReason, }: { @@ -140,15 +140,15 @@ export async function runFailedAsserts({ failedAssert: (x: any) => Promise; failedAssertReason: string; }) { - await expect( - failedAssert(matchers.write[method](...args)) - ).to.be.rejectedWith(AssertionError, failedAssertReason); - await expect(failedAssert(matchers.read[method](...args))).to.be.rejectedWith( + await expect(failedAssert(matchers.write[method](args))).to.be.rejectedWith( AssertionError, failedAssertReason ); await expect( - failedAssert(matchers.estimateGas[method](...args)) + failedAssert(matchers.read[`${method}View`](args)) + ).to.be.rejectedWith(AssertionError, failedAssertReason); + await expect( + failedAssert(matchers.estimateGas[method](args)) ).to.be.rejectedWith(AssertionError, failedAssertReason); } diff --git a/packages/hardhat-chai-matchers-viem/test/reverted/revertedWithCustomError.ts b/packages/hardhat-chai-matchers-viem/test/reverted/revertedWithCustomError.ts index da63d569b0..d16dc928e0 100644 --- a/packages/hardhat-chai-matchers-viem/test/reverted/revertedWithCustomError.ts +++ b/packages/hardhat-chai-matchers-viem/test/reverted/revertedWithCustomError.ts @@ -1,6 +1,6 @@ import { privateKeyToAccount } from "viem/accounts"; import { AssertionError, expect } from "chai"; -import { ProviderError } from "hardhat/internal/core/providers/errors"; +import { TransactionExecutionError } from "viem"; import path from "path"; import util from "util"; @@ -23,7 +23,8 @@ describe.only("INTEGRATION: Reverted with custom error", function () { runTests(); }); - describe("connected to a hardhat node", function () { + // external hardhat node with viem does not include error data in many cases + describe.skip("connected to a hardhat node", function () { useEnvironmentWithNode("hardhat-project"); runTests(); @@ -65,7 +66,7 @@ describe.only("INTEGRATION: Reverted with custom error", function () { }); describe("calling a method that reverts without a reason", function () { - it.only("successful asserts", async function () { + it("successful asserts", async function () { await runSuccessfulAsserts({ matchers, method: "revertsWithoutReason", @@ -77,9 +78,7 @@ describe.only("INTEGRATION: Reverted with custom error", function () { }); }); - // depends on a bug being fixed on ethers.js - // see https://github.com/NomicFoundation/hardhat/issues/3446 - it.skip("failed asserts", async function () { + it("failed asserts", async function () { await runFailedAsserts({ matchers, method: "revertsWithoutReason", @@ -505,7 +504,7 @@ describe.only("INTEGRATION: Reverted with custom error", function () { }) ).to.not.be.revertedWithCustomError(matchers, "SomeCustomError") ).to.be.eventually.rejectedWith( - ProviderError, + TransactionExecutionError, "Sender doesn't have enough funds to send tx" ); }); diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml index 00991b0782..6bcdfdd20d 100644 --- a/pnpm-lock.yaml +++ b/pnpm-lock.yaml @@ -1,4 +1,4 @@ -lockfileVersion: '6.0' +lockfileVersion: '9.0' settings: autoInstallPeers: true @@ -65,7 +65,7 @@ importers: version: 16.6.2(eslint@8.57.0) eslint-plugin-prettier: specifier: 3.4.0 - version: 3.4.0(eslint-config-prettier@8.3.0)(eslint@8.57.0)(prettier@2.4.1) + version: 3.4.0(eslint-config-prettier@8.3.0(eslint@8.57.0))(eslint@8.57.0)(prettier@2.8.8) mocha: specifier: ^10.0.0 version: 10.4.0 @@ -74,7 +74,7 @@ importers: dependencies: eslint-module-utils: specifier: ^2.8.0 - version: 2.8.1(@typescript-eslint/parser@5.61.0)(eslint-import-resolver-node@0.3.9)(eslint@8.57.0) + version: 2.8.1(@typescript-eslint/parser@5.61.0(eslint@8.57.0)(typescript@5.0.4))(eslint-import-resolver-node@0.3.9)(eslint@8.57.0) requireindex: specifier: ^1.2.0 version: 1.2.0 @@ -139,7 +139,7 @@ importers: version: 18.19.33 '@typescript-eslint/eslint-plugin': specifier: 5.61.0 - version: 5.61.0(@typescript-eslint/parser@5.61.0)(eslint@8.57.0)(typescript@5.0.4) + version: 5.61.0(@typescript-eslint/parser@5.61.0(eslint@8.57.0)(typescript@5.0.4))(eslint@8.57.0)(typescript@5.0.4) '@typescript-eslint/parser': specifier: 5.61.0 version: 5.61.0(eslint@8.57.0)(typescript@5.0.4) @@ -160,16 +160,16 @@ importers: version: 8.3.0(eslint@8.57.0) eslint-plugin-import: specifier: 2.27.5 - version: 2.27.5(@typescript-eslint/parser@5.61.0)(eslint@8.57.0) + version: 2.27.5(@typescript-eslint/parser@5.61.0(eslint@8.57.0)(typescript@5.0.4))(eslint@8.57.0) eslint-plugin-mocha: specifier: 10.4.1 version: 10.4.1(eslint@8.57.0) eslint-plugin-prettier: specifier: 3.4.0 - version: 3.4.0(eslint-config-prettier@8.3.0)(eslint@8.57.0)(prettier@2.4.1) + version: 3.4.0(eslint-config-prettier@8.3.0(eslint@8.57.0))(eslint@8.57.0)(prettier@2.4.1) ethers: specifier: ^6.1.0 - version: 6.12.1 + version: 6.12.1(bufferutil@4.0.8)(utf-8-validate@5.0.10) get-port: specifier: ^5.1.1 version: 5.1.1 @@ -192,6 +192,94 @@ importers: specifier: ~5.0.0 version: 5.0.4 + packages/hardhat-chai-matchers-viem: + dependencies: + '@types/chai-as-promised': + specifier: ^7.1.3 + version: 7.1.8 + chai-as-promised: + specifier: ^7.1.1 + version: 7.1.1(chai@4.4.1) + deep-eql: + specifier: ^4.0.1 + version: 4.1.3 + ordinal: + specifier: ^1.0.3 + version: 1.0.3 + devDependencies: + '@nomicfoundation/eslint-plugin-hardhat-internal-rules': + specifier: workspace:^ + version: link:../eslint-plugin-hardhat-internal-rules + '@nomicfoundation/eslint-plugin-slow-imports': + specifier: workspace:^ + version: link:../eslint-plugin-slow-imports + '@nomicfoundation/hardhat-chai-matchers-viem': + specifier: workspace:* + version: 'link:' + '@nomicfoundation/hardhat-viem': + specifier: workspace:^2.0.0 + version: link:../hardhat-viem + '@types/chai': + specifier: ^4.2.0 + version: 4.3.16 + '@types/mocha': + specifier: '>=9.1.0' + version: 10.0.6 + '@types/node': + specifier: ^18.0.0 + version: 18.19.33 + '@typescript-eslint/eslint-plugin': + specifier: 5.61.0 + version: 5.61.0(@typescript-eslint/parser@5.61.0(eslint@8.57.0)(typescript@5.0.4))(eslint@8.57.0)(typescript@5.0.4) + '@typescript-eslint/parser': + specifier: 5.61.0 + version: 5.61.0(eslint@8.57.0)(typescript@5.0.4) + chai: + specifier: ^4.2.0 + version: 4.4.1 + eslint: + specifier: ^8.44.0 + version: 8.57.0 + eslint-config-prettier: + specifier: 8.3.0 + version: 8.3.0(eslint@8.57.0) + eslint-plugin-import: + specifier: 2.27.5 + version: 2.27.5(@typescript-eslint/parser@5.61.0(eslint@8.57.0)(typescript@5.0.4))(eslint@8.57.0) + eslint-plugin-mocha: + specifier: 10.4.1 + version: 10.4.1(eslint@8.57.0) + eslint-plugin-prettier: + specifier: 3.4.0 + version: 3.4.0(eslint-config-prettier@8.3.0(eslint@8.57.0))(eslint@8.57.0)(prettier@2.4.1) + ethers: + specifier: ^6.1.0 + version: 6.12.1(bufferutil@4.0.8)(utf-8-validate@5.0.10) + get-port: + specifier: ^5.1.1 + version: 5.1.1 + hardhat: + specifier: workspace:^2.11.0 + version: link:../hardhat-core + mocha: + specifier: ^10.0.0 + version: 10.4.0 + prettier: + specifier: 2.4.1 + version: 2.4.1 + rimraf: + specifier: ^3.0.2 + version: 3.0.2 + ts-node: + specifier: ^10.8.0 + version: 10.9.2(@types/node@18.19.33)(typescript@5.0.4) + typescript: + specifier: ~5.0.4 + version: 5.0.4 + viem: + specifier: ^2.7.6 + version: 2.10.3(bufferutil@4.0.8)(typescript@5.0.4)(utf-8-validate@5.0.10)(zod@3.23.8) + packages/hardhat-core: dependencies: '@ethersproject/abi': @@ -322,7 +410,7 @@ importers: version: 8.3.2 ws: specifier: ^7.4.6 - version: 7.5.9 + version: 7.5.9(bufferutil@4.0.8)(utf-8-validate@5.0.10) devDependencies: '@nomicfoundation/eslint-plugin-hardhat-internal-rules': specifier: workspace:^ @@ -386,7 +474,7 @@ importers: version: 7.4.7 '@typescript-eslint/eslint-plugin': specifier: 5.61.0 - version: 5.61.0(@typescript-eslint/parser@5.61.0)(eslint@8.57.0)(typescript@5.0.4) + version: 5.61.0(@typescript-eslint/parser@5.61.0(eslint@8.57.0)(typescript@5.0.4))(eslint@8.57.0)(typescript@5.0.4) '@typescript-eslint/parser': specifier: 5.61.0 version: 5.61.0(eslint@8.57.0)(typescript@5.0.4) @@ -410,19 +498,19 @@ importers: version: 8.3.0(eslint@8.57.0) eslint-plugin-import: specifier: 2.27.5 - version: 2.27.5(@typescript-eslint/parser@5.61.0)(eslint@8.57.0) + version: 2.27.5(@typescript-eslint/parser@5.61.0(eslint@8.57.0)(typescript@5.0.4))(eslint@8.57.0) eslint-plugin-mocha: specifier: 10.4.1 version: 10.4.1(eslint@8.57.0) eslint-plugin-prettier: specifier: 3.4.0 - version: 3.4.0(eslint-config-prettier@8.3.0)(eslint@8.57.0)(prettier@2.4.1) + version: 3.4.0(eslint-config-prettier@8.3.0(eslint@8.57.0))(eslint@8.57.0)(prettier@2.4.1) ethers: specifier: ^6.1.0 - version: 6.12.1 + version: 6.12.1(bufferutil@4.0.8)(utf-8-validate@5.0.10) ethers-v5: specifier: npm:ethers@5 - version: /ethers@5.7.2 + version: ethers@5.7.2(bufferutil@4.0.8)(utf-8-validate@5.0.10) prettier: specifier: 2.4.1 version: 2.4.1 @@ -480,7 +568,7 @@ importers: version: 9.0.11 '@typescript-eslint/eslint-plugin': specifier: 5.61.0 - version: 5.61.0(@typescript-eslint/parser@5.61.0)(eslint@8.57.0)(typescript@5.0.4) + version: 5.61.0(@typescript-eslint/parser@5.61.0(eslint@8.57.0)(typescript@5.0.4))(eslint@8.57.0)(typescript@5.0.4) '@typescript-eslint/parser': specifier: 5.61.0 version: 5.61.0(eslint@8.57.0)(typescript@5.0.4) @@ -501,16 +589,16 @@ importers: version: 8.3.0(eslint@8.57.0) eslint-plugin-import: specifier: 2.27.5 - version: 2.27.5(@typescript-eslint/parser@5.61.0)(eslint@8.57.0) + version: 2.27.5(@typescript-eslint/parser@5.61.0(eslint@8.57.0)(typescript@5.0.4))(eslint@8.57.0) eslint-plugin-mocha: specifier: 10.4.1 version: 10.4.1(eslint@8.57.0) eslint-plugin-prettier: specifier: 3.4.0 - version: 3.4.0(eslint-config-prettier@8.3.0)(eslint@8.57.0)(prettier@2.4.1) + version: 3.4.0(eslint-config-prettier@8.3.0(eslint@8.57.0))(eslint@8.57.0)(prettier@2.4.1) ethers: specifier: ^6.1.0 - version: 6.12.1 + version: 6.12.1(bufferutil@4.0.8)(utf-8-validate@5.0.10) hardhat: specifier: workspace:^2.0.0 version: link:../hardhat-core @@ -556,7 +644,7 @@ importers: version: 18.19.33 '@typescript-eslint/eslint-plugin': specifier: 5.61.0 - version: 5.61.0(@typescript-eslint/parser@5.61.0)(eslint@8.57.0)(typescript@5.0.4) + version: 5.61.0(@typescript-eslint/parser@5.61.0(eslint@8.57.0)(typescript@5.0.4))(eslint@8.57.0)(typescript@5.0.4) '@typescript-eslint/parser': specifier: 5.61.0 version: 5.61.0(eslint@8.57.0)(typescript@5.0.4) @@ -571,13 +659,13 @@ importers: version: 8.3.0(eslint@8.57.0) eslint-plugin-import: specifier: 2.27.5 - version: 2.27.5(@typescript-eslint/parser@5.61.0)(eslint@8.57.0) + version: 2.27.5(@typescript-eslint/parser@5.61.0(eslint@8.57.0)(typescript@5.0.4))(eslint@8.57.0) eslint-plugin-mocha: specifier: 10.4.1 version: 10.4.1(eslint@8.57.0) eslint-plugin-prettier: specifier: 3.4.0 - version: 3.4.0(eslint-config-prettier@8.3.0)(eslint@8.57.0)(prettier@2.4.1) + version: 3.4.0(eslint-config-prettier@8.3.0(eslint@8.57.0))(eslint@8.57.0)(prettier@2.4.1) hardhat: specifier: workspace:^2.17.2 version: link:../hardhat-core @@ -625,7 +713,7 @@ importers: version: 2.2.1 ethers: specifier: ^6.1.0 - version: 6.12.1 + version: 6.12.1(bufferutil@4.0.8)(utf-8-validate@5.0.10) fs-extra: specifier: ^7.0.1 version: 7.0.1 @@ -659,7 +747,7 @@ importers: version: 9.0.11 '@typescript-eslint/eslint-plugin': specifier: 5.61.0 - version: 5.61.0(@typescript-eslint/parser@5.61.0)(eslint@8.57.0)(typescript@5.0.4) + version: 5.61.0(@typescript-eslint/parser@5.61.0(eslint@8.57.0)(typescript@5.0.4))(eslint@8.57.0)(typescript@5.0.4) '@typescript-eslint/parser': specifier: 5.61.0 version: 5.61.0(eslint@8.57.0)(typescript@5.0.4) @@ -674,13 +762,13 @@ importers: version: 8.3.0(eslint@8.57.0) eslint-plugin-import: specifier: 2.27.5 - version: 2.27.5(@typescript-eslint/parser@5.61.0)(eslint@8.57.0) + version: 2.27.5(@typescript-eslint/parser@5.61.0(eslint@8.57.0)(typescript@5.0.4))(eslint@8.57.0) eslint-plugin-mocha: specifier: 10.4.1 version: 10.4.1(eslint@8.57.0) eslint-plugin-prettier: specifier: 3.4.0 - version: 3.4.0(eslint-config-prettier@8.3.0)(eslint@8.57.0)(prettier@2.4.1) + version: 3.4.0(eslint-config-prettier@8.3.0(eslint@8.57.0))(eslint@8.57.0)(prettier@2.4.1) hardhat: specifier: workspace:^2.16.0 version: link:../hardhat-core @@ -732,7 +820,7 @@ importers: version: 18.19.33 '@typescript-eslint/eslint-plugin': specifier: 5.61.0 - version: 5.61.0(@typescript-eslint/parser@5.61.0)(eslint@8.57.0)(typescript@5.0.4) + version: 5.61.0(@typescript-eslint/parser@5.61.0(eslint@8.57.0)(typescript@5.0.4))(eslint@8.57.0)(typescript@5.0.4) '@typescript-eslint/parser': specifier: 5.61.0 version: 5.61.0(eslint@8.57.0)(typescript@5.0.4) @@ -750,16 +838,16 @@ importers: version: 8.3.0(eslint@8.57.0) eslint-plugin-import: specifier: 2.27.5 - version: 2.27.5(@typescript-eslint/parser@5.61.0)(eslint@8.57.0) + version: 2.27.5(@typescript-eslint/parser@5.61.0(eslint@8.57.0)(typescript@5.0.4))(eslint@8.57.0) eslint-plugin-mocha: specifier: 10.4.1 version: 10.4.1(eslint@8.57.0) eslint-plugin-prettier: specifier: 3.4.0 - version: 3.4.0(eslint-config-prettier@8.3.0)(eslint@8.57.0)(prettier@2.4.1) + version: 3.4.0(eslint-config-prettier@8.3.0(eslint@8.57.0))(eslint@8.57.0)(prettier@2.4.1) ethers-v5: specifier: npm:ethers@5 - version: /ethers@5.7.2 + version: ethers@5.7.2(bufferutil@4.0.8)(utf-8-validate@5.0.10) hardhat: specifier: workspace:^2.9.5 version: link:../hardhat-core @@ -817,7 +905,7 @@ importers: version: 6.2.7 '@typescript-eslint/eslint-plugin': specifier: 5.61.0 - version: 5.61.0(@typescript-eslint/parser@5.61.0)(eslint@8.57.0)(typescript@5.0.4) + version: 5.61.0(@typescript-eslint/parser@5.61.0(eslint@8.57.0)(typescript@5.0.4))(eslint@8.57.0)(typescript@5.0.4) '@typescript-eslint/parser': specifier: 5.61.0 version: 5.61.0(eslint@8.57.0)(typescript@5.0.4) @@ -832,13 +920,13 @@ importers: version: 8.3.0(eslint@8.57.0) eslint-plugin-import: specifier: 2.27.5 - version: 2.27.5(@typescript-eslint/parser@5.61.0)(eslint@8.57.0) + version: 2.27.5(@typescript-eslint/parser@5.61.0(eslint@8.57.0)(typescript@5.0.4))(eslint@8.57.0) eslint-plugin-mocha: specifier: 10.4.1 version: 10.4.1(eslint@8.57.0) eslint-plugin-prettier: specifier: 3.4.0 - version: 3.4.0(eslint-config-prettier@8.3.0)(eslint@8.57.0)(prettier@2.4.1) + version: 3.4.0(eslint-config-prettier@8.3.0(eslint@8.57.0))(eslint@8.57.0)(prettier@2.4.1) hardhat: specifier: workspace:^2.0.0 version: link:../hardhat-core @@ -887,7 +975,7 @@ importers: version: 9.0.11 '@typescript-eslint/eslint-plugin': specifier: 5.61.0 - version: 5.61.0(@typescript-eslint/parser@5.61.0)(eslint@8.57.0)(typescript@5.0.4) + version: 5.61.0(@typescript-eslint/parser@5.61.0(eslint@8.57.0)(typescript@5.0.4))(eslint@8.57.0)(typescript@5.0.4) '@typescript-eslint/parser': specifier: 5.61.0 version: 5.61.0(eslint@8.57.0)(typescript@5.0.4) @@ -902,13 +990,13 @@ importers: version: 8.3.0(eslint@8.57.0) eslint-plugin-import: specifier: 2.27.5 - version: 2.27.5(@typescript-eslint/parser@5.61.0)(eslint@8.57.0) + version: 2.27.5(@typescript-eslint/parser@5.61.0(eslint@8.57.0)(typescript@5.0.4))(eslint@8.57.0) eslint-plugin-mocha: specifier: 10.4.1 version: 10.4.1(eslint@8.57.0) eslint-plugin-prettier: specifier: 3.4.0 - version: 3.4.0(eslint-config-prettier@8.3.0)(eslint@8.57.0)(prettier@2.4.1) + version: 3.4.0(eslint-config-prettier@8.3.0(eslint@8.57.0))(eslint@8.57.0)(prettier@2.4.1) fs-extra: specifier: ^7.0.1 version: 7.0.1 @@ -963,7 +1051,7 @@ importers: version: 18.19.33 '@typescript-eslint/eslint-plugin': specifier: 5.61.0 - version: 5.61.0(@typescript-eslint/parser@5.61.0)(eslint@8.57.0)(typescript@5.0.4) + version: 5.61.0(@typescript-eslint/parser@5.61.0(eslint@8.57.0)(typescript@5.0.4))(eslint@8.57.0)(typescript@5.0.4) '@typescript-eslint/parser': specifier: 5.61.0 version: 5.61.0(eslint@8.57.0)(typescript@5.0.4) @@ -978,13 +1066,13 @@ importers: version: 8.3.0(eslint@8.57.0) eslint-plugin-import: specifier: 2.27.5 - version: 2.27.5(@typescript-eslint/parser@5.61.0)(eslint@8.57.0) + version: 2.27.5(@typescript-eslint/parser@5.61.0(eslint@8.57.0)(typescript@5.0.4))(eslint@8.57.0) eslint-plugin-mocha: specifier: 10.4.1 version: 10.4.1(eslint@8.57.0) eslint-plugin-prettier: specifier: 3.4.0 - version: 3.4.0(eslint-config-prettier@8.3.0)(eslint@8.57.0)(prettier@2.4.1) + version: 3.4.0(eslint-config-prettier@8.3.0(eslint@8.57.0))(eslint@8.57.0)(prettier@2.4.1) hardhat: specifier: workspace:^2.0.0 version: link:../hardhat-core @@ -1020,7 +1108,7 @@ importers: version: link:../hardhat-ethers '@nomicfoundation/hardhat-ignition-ethers': specifier: ^0.15.0 - version: 0.15.2(@nomicfoundation/hardhat-ethers@packages+hardhat-ethers)(@nomicfoundation/hardhat-ignition@0.15.2)(@nomicfoundation/ignition-core@0.15.2)(ethers@6.12.1)(hardhat@packages+hardhat-core) + version: 0.15.2(@nomicfoundation/hardhat-ethers@packages+hardhat-ethers)(@nomicfoundation/hardhat-ignition@0.15.2(@nomicfoundation/hardhat-verify@packages+hardhat-verify)(bufferutil@4.0.8)(hardhat@packages+hardhat-core)(utf-8-validate@5.0.10))(@nomicfoundation/ignition-core@0.15.2(bufferutil@4.0.8)(utf-8-validate@5.0.10))(ethers@6.12.1(bufferutil@4.0.8)(utf-8-validate@5.0.10))(hardhat@packages+hardhat-core) '@nomicfoundation/hardhat-network-helpers': specifier: workspace:^1.0.0 version: link:../hardhat-network-helpers @@ -1029,10 +1117,10 @@ importers: version: link:../hardhat-verify '@typechain/ethers-v6': specifier: ^0.5.0 - version: 0.5.1(ethers@6.12.1)(typechain@8.3.2)(typescript@5.0.4) + version: 0.5.1(ethers@6.12.1(bufferutil@4.0.8)(utf-8-validate@5.0.10))(typechain@8.3.2(typescript@5.0.4))(typescript@5.0.4) '@typechain/hardhat': specifier: ^9.0.0 - version: 9.1.0(@typechain/ethers-v6@0.5.1)(ethers@6.12.1)(hardhat@packages+hardhat-core)(typechain@8.3.2) + version: 9.1.0(@typechain/ethers-v6@0.5.1(ethers@6.12.1(bufferutil@4.0.8)(utf-8-validate@5.0.10))(typechain@8.3.2(typescript@5.0.4))(typescript@5.0.4))(ethers@6.12.1(bufferutil@4.0.8)(utf-8-validate@5.0.10))(hardhat@packages+hardhat-core)(typechain@8.3.2(typescript@5.0.4)) '@types/chai': specifier: ^4.2.0 version: 4.3.16 @@ -1044,7 +1132,7 @@ importers: version: 18.19.33 '@typescript-eslint/eslint-plugin': specifier: 5.61.0 - version: 5.61.0(@typescript-eslint/parser@5.61.0)(eslint@8.57.0)(typescript@5.0.4) + version: 5.61.0(@typescript-eslint/parser@5.61.0(eslint@8.57.0)(typescript@5.0.4))(eslint@8.57.0)(typescript@5.0.4) '@typescript-eslint/parser': specifier: 5.61.0 version: 5.61.0(eslint@8.57.0)(typescript@5.0.4) @@ -1059,22 +1147,22 @@ importers: version: 8.3.0(eslint@8.57.0) eslint-plugin-import: specifier: 2.27.5 - version: 2.27.5(@typescript-eslint/parser@5.61.0)(eslint@8.57.0) + version: 2.27.5(@typescript-eslint/parser@5.61.0(eslint@8.57.0)(typescript@5.0.4))(eslint@8.57.0) eslint-plugin-mocha: specifier: 10.4.1 version: 10.4.1(eslint@8.57.0) eslint-plugin-prettier: specifier: 3.4.0 - version: 3.4.0(eslint-config-prettier@8.3.0)(eslint@8.57.0)(prettier@2.4.1) + version: 3.4.0(eslint-config-prettier@8.3.0(eslint@8.57.0))(eslint@8.57.0)(prettier@2.4.1) ethers: specifier: ^6.4.0 - version: 6.12.1 + version: 6.12.1(bufferutil@4.0.8)(utf-8-validate@5.0.10) hardhat: specifier: workspace:^2.11.0 version: link:../hardhat-core hardhat-gas-reporter: specifier: ^1.0.8 - version: 1.0.10(hardhat@packages+hardhat-core) + version: 1.0.10(bufferutil@4.0.8)(hardhat@packages+hardhat-core)(utf-8-validate@5.0.10) mocha: specifier: ^10.0.0 version: 10.4.0 @@ -1111,7 +1199,7 @@ importers: version: link:../eslint-plugin-slow-imports '@nomicfoundation/hardhat-ignition-viem': specifier: ^0.15.0 - version: 0.15.2(@nomicfoundation/hardhat-ignition@0.15.2)(@nomicfoundation/hardhat-viem@packages+hardhat-viem)(@nomicfoundation/ignition-core@0.15.2)(hardhat@packages+hardhat-core)(viem@2.10.3) + version: 0.15.2(@nomicfoundation/hardhat-ignition@0.15.2(@nomicfoundation/hardhat-verify@packages+hardhat-verify)(bufferutil@4.0.8)(hardhat@packages+hardhat-core)(utf-8-validate@5.0.10))(@nomicfoundation/hardhat-viem@packages+hardhat-viem)(@nomicfoundation/ignition-core@0.15.2(bufferutil@4.0.8)(utf-8-validate@5.0.10))(hardhat@packages+hardhat-core)(viem@2.10.3(bufferutil@4.0.8)(typescript@5.0.4)(utf-8-validate@5.0.10)(zod@3.23.8)) '@nomicfoundation/hardhat-network-helpers': specifier: workspace:^1.0.0 version: link:../hardhat-network-helpers @@ -1135,7 +1223,7 @@ importers: version: 18.19.33 '@typescript-eslint/eslint-plugin': specifier: 5.61.0 - version: 5.61.0(@typescript-eslint/parser@5.61.0)(eslint@8.57.0)(typescript@5.0.4) + version: 5.61.0(@typescript-eslint/parser@5.61.0(eslint@8.57.0)(typescript@5.0.4))(eslint@8.57.0)(typescript@5.0.4) '@typescript-eslint/parser': specifier: 5.61.0 version: 5.61.0(eslint@8.57.0)(typescript@5.0.4) @@ -1150,19 +1238,19 @@ importers: version: 8.3.0(eslint@8.57.0) eslint-plugin-import: specifier: 2.27.5 - version: 2.27.5(@typescript-eslint/parser@5.61.0)(eslint@8.57.0) + version: 2.27.5(@typescript-eslint/parser@5.61.0(eslint@8.57.0)(typescript@5.0.4))(eslint@8.57.0) eslint-plugin-mocha: specifier: 10.4.1 version: 10.4.1(eslint@8.57.0) eslint-plugin-prettier: specifier: 3.4.0 - version: 3.4.0(eslint-config-prettier@8.3.0)(eslint@8.57.0)(prettier@2.4.1) + version: 3.4.0(eslint-config-prettier@8.3.0(eslint@8.57.0))(eslint@8.57.0)(prettier@2.4.1) hardhat: specifier: workspace:^2.11.0 version: link:../hardhat-core hardhat-gas-reporter: specifier: ^1.0.8 - version: 1.0.10(hardhat@packages+hardhat-core) + version: 1.0.10(bufferutil@4.0.8)(hardhat@packages+hardhat-core)(utf-8-validate@5.0.10) mocha: specifier: ^10.0.0 version: 10.4.0 @@ -1183,7 +1271,7 @@ importers: version: 5.0.4 viem: specifier: ^2.7.6 - version: 2.10.3(typescript@5.0.4) + version: 2.10.3(bufferutil@4.0.8)(typescript@5.0.4)(utf-8-validate@5.0.10)(zod@3.23.8) packages/hardhat-truffle4: dependencies: @@ -1226,7 +1314,7 @@ importers: version: 18.19.33 '@typescript-eslint/eslint-plugin': specifier: 5.61.0 - version: 5.61.0(@typescript-eslint/parser@5.61.0)(eslint@8.57.0)(typescript@5.0.4) + version: 5.61.0(@typescript-eslint/parser@5.61.0(eslint@8.57.0)(typescript@5.0.4))(eslint@8.57.0)(typescript@5.0.4) '@typescript-eslint/parser': specifier: 5.61.0 version: 5.61.0(eslint@8.57.0)(typescript@5.0.4) @@ -1238,13 +1326,13 @@ importers: version: 8.3.0(eslint@8.57.0) eslint-plugin-import: specifier: 2.27.5 - version: 2.27.5(@typescript-eslint/parser@5.61.0)(eslint@8.57.0) + version: 2.27.5(@typescript-eslint/parser@5.61.0(eslint@8.57.0)(typescript@5.0.4))(eslint@8.57.0) eslint-plugin-mocha: specifier: 10.4.1 version: 10.4.1(eslint@8.57.0) eslint-plugin-prettier: specifier: 3.4.0 - version: 3.4.0(eslint-config-prettier@8.3.0)(eslint@8.57.0)(prettier@2.4.1) + version: 3.4.0(eslint-config-prettier@8.3.0(eslint@8.57.0))(eslint@8.57.0)(prettier@2.4.1) hardhat: specifier: workspace:^2.6.4 version: link:../hardhat-core @@ -1271,7 +1359,7 @@ importers: dependencies: '@nomiclabs/truffle-contract': specifier: ^4.2.23 - version: 4.5.10(web3-core-helpers@1.10.3)(web3-core-promievent@1.10.3)(web3-eth-abi@1.10.4)(web3-utils@1.10.4)(web3@1.10.4) + version: 4.5.10(bufferutil@4.0.8)(utf-8-validate@5.0.10)(web3-core-helpers@1.10.4)(web3-core-promievent@1.10.4)(web3-eth-abi@4.2.1(typescript@5.0.4)(zod@3.23.8))(web3-utils@4.2.3)(web3@1.10.4(bufferutil@4.0.8)(utf-8-validate@5.0.10)) '@types/chai': specifier: ^4.2.0 version: 4.3.16 @@ -1308,7 +1396,7 @@ importers: version: 18.19.33 '@typescript-eslint/eslint-plugin': specifier: 5.61.0 - version: 5.61.0(@typescript-eslint/parser@5.61.0)(eslint@8.57.0)(typescript@5.0.4) + version: 5.61.0(@typescript-eslint/parser@5.61.0(eslint@8.57.0)(typescript@5.0.4))(eslint@8.57.0)(typescript@5.0.4) '@typescript-eslint/parser': specifier: 5.61.0 version: 5.61.0(eslint@8.57.0)(typescript@5.0.4) @@ -1320,13 +1408,13 @@ importers: version: 8.3.0(eslint@8.57.0) eslint-plugin-import: specifier: 2.27.5 - version: 2.27.5(@typescript-eslint/parser@5.61.0)(eslint@8.57.0) + version: 2.27.5(@typescript-eslint/parser@5.61.0(eslint@8.57.0)(typescript@5.0.4))(eslint@8.57.0) eslint-plugin-mocha: specifier: 10.4.1 version: 10.4.1(eslint@8.57.0) eslint-plugin-prettier: specifier: 3.4.0 - version: 3.4.0(eslint-config-prettier@8.3.0)(eslint@8.57.0)(prettier@2.4.1) + version: 3.4.0(eslint-config-prettier@8.3.0(eslint@8.57.0))(eslint@8.57.0)(prettier@2.4.1) hardhat: specifier: workspace:^2.6.4 version: link:../hardhat-core @@ -1347,7 +1435,7 @@ importers: version: 5.0.4 web3: specifier: ^1.0.0-beta.36 - version: 1.10.4 + version: 1.10.4(bufferutil@4.0.8)(utf-8-validate@5.0.10) packages/hardhat-verify: dependencies: @@ -1417,7 +1505,7 @@ importers: version: 3.2.12 '@typescript-eslint/eslint-plugin': specifier: 5.61.0 - version: 5.61.0(@typescript-eslint/parser@5.61.0)(eslint@8.57.0)(typescript@5.0.4) + version: 5.61.0(@typescript-eslint/parser@5.61.0(eslint@8.57.0)(typescript@5.0.4))(eslint@8.57.0)(typescript@5.0.4) '@typescript-eslint/parser': specifier: 5.61.0 version: 5.61.0(eslint@8.57.0)(typescript@5.0.4) @@ -1435,16 +1523,16 @@ importers: version: 8.3.0(eslint@8.57.0) eslint-plugin-import: specifier: 2.27.5 - version: 2.27.5(@typescript-eslint/parser@5.61.0)(eslint@8.57.0) + version: 2.27.5(@typescript-eslint/parser@5.61.0(eslint@8.57.0)(typescript@5.0.4))(eslint@8.57.0) eslint-plugin-mocha: specifier: 10.4.1 version: 10.4.1(eslint@8.57.0) eslint-plugin-prettier: specifier: 3.4.0 - version: 3.4.0(eslint-config-prettier@8.3.0)(eslint@8.57.0)(prettier@2.4.1) + version: 3.4.0(eslint-config-prettier@8.3.0(eslint@8.57.0))(eslint@8.57.0)(prettier@2.4.1) ethers: specifier: ^5.0.0 - version: 5.7.2 + version: 5.7.2(bufferutil@4.0.8)(utf-8-validate@5.0.10) hardhat: specifier: workspace:^2.0.4 version: link:../hardhat-core @@ -1477,7 +1565,7 @@ importers: dependencies: abitype: specifier: ^0.9.8 - version: 0.9.10(typescript@5.0.4) + version: 0.9.10(typescript@5.0.4)(zod@3.23.8) lodash.memoize: specifier: ^4.1.2 version: 4.1.2 @@ -1511,7 +1599,7 @@ importers: version: 9.0.11 '@typescript-eslint/eslint-plugin': specifier: 5.61.0 - version: 5.61.0(@typescript-eslint/parser@5.61.0)(eslint@8.57.0)(typescript@5.0.4) + version: 5.61.0(@typescript-eslint/parser@5.61.0(eslint@8.57.0)(typescript@5.0.4))(eslint@8.57.0)(typescript@5.0.4) '@typescript-eslint/parser': specifier: 5.61.0 version: 5.61.0(eslint@8.57.0)(typescript@5.0.4) @@ -1529,13 +1617,13 @@ importers: version: 8.3.0(eslint@8.57.0) eslint-plugin-import: specifier: 2.27.5 - version: 2.27.5(@typescript-eslint/parser@5.61.0)(eslint@8.57.0) + version: 2.27.5(@typescript-eslint/parser@5.61.0(eslint@8.57.0)(typescript@5.0.4))(eslint@8.57.0) eslint-plugin-mocha: specifier: 10.4.1 version: 10.4.1(eslint@8.57.0) eslint-plugin-prettier: specifier: 3.4.0 - version: 3.4.0(eslint-config-prettier@8.3.0)(eslint@8.57.0)(prettier@2.4.1) + version: 3.4.0(eslint-config-prettier@8.3.0(eslint@8.57.0))(eslint@8.57.0)(prettier@2.4.1) hardhat: specifier: workspace:^2.17.0 version: link:../hardhat-core @@ -1565,7 +1653,7 @@ importers: version: 5.0.4 viem: specifier: ^2.7.6 - version: 2.10.3(typescript@5.0.4) + version: 2.10.3(bufferutil@4.0.8)(typescript@5.0.4)(utf-8-validate@5.0.10)(zod@3.23.8) packages/hardhat-vyper: dependencies: @@ -1617,7 +1705,7 @@ importers: version: 6.2.7 '@typescript-eslint/eslint-plugin': specifier: 5.61.0 - version: 5.61.0(@typescript-eslint/parser@5.61.0)(eslint@8.57.0)(typescript@5.0.4) + version: 5.61.0(@typescript-eslint/parser@5.61.0(eslint@8.57.0)(typescript@5.0.4))(eslint@8.57.0)(typescript@5.0.4) '@typescript-eslint/parser': specifier: 5.61.0 version: 5.61.0(eslint@8.57.0)(typescript@5.0.4) @@ -1635,13 +1723,13 @@ importers: version: 8.3.0(eslint@8.57.0) eslint-plugin-import: specifier: 2.27.5 - version: 2.27.5(@typescript-eslint/parser@5.61.0)(eslint@8.57.0) + version: 2.27.5(@typescript-eslint/parser@5.61.0(eslint@8.57.0)(typescript@5.0.4))(eslint@8.57.0) eslint-plugin-mocha: specifier: 10.4.1 version: 10.4.1(eslint@8.57.0) eslint-plugin-prettier: specifier: 3.4.0 - version: 3.4.0(eslint-config-prettier@8.3.0)(eslint@8.57.0)(prettier@2.4.1) + version: 3.4.0(eslint-config-prettier@8.3.0(eslint@8.57.0))(eslint@8.57.0)(prettier@2.4.1) hardhat: specifier: workspace:^2.8.3 version: link:../hardhat-core @@ -1684,7 +1772,7 @@ importers: version: 18.19.33 '@typescript-eslint/eslint-plugin': specifier: 5.61.0 - version: 5.61.0(@typescript-eslint/parser@5.61.0)(eslint@8.57.0)(typescript@5.0.4) + version: 5.61.0(@typescript-eslint/parser@5.61.0(eslint@8.57.0)(typescript@5.0.4))(eslint@8.57.0)(typescript@5.0.4) '@typescript-eslint/parser': specifier: 5.61.0 version: 5.61.0(eslint@8.57.0)(typescript@5.0.4) @@ -1699,13 +1787,13 @@ importers: version: 8.3.0(eslint@8.57.0) eslint-plugin-import: specifier: 2.27.5 - version: 2.27.5(@typescript-eslint/parser@5.61.0)(eslint@8.57.0) + version: 2.27.5(@typescript-eslint/parser@5.61.0(eslint@8.57.0)(typescript@5.0.4))(eslint@8.57.0) eslint-plugin-mocha: specifier: 10.4.1 version: 10.4.1(eslint@8.57.0) eslint-plugin-prettier: specifier: 3.4.0 - version: 3.4.0(eslint-config-prettier@8.3.0)(eslint@8.57.0)(prettier@2.4.1) + version: 3.4.0(eslint-config-prettier@8.3.0(eslint@8.57.0))(eslint@8.57.0)(prettier@2.4.1) hardhat: specifier: workspace:^2.0.0 version: link:../hardhat-core @@ -1729,7 +1817,7 @@ importers: version: 5.0.4 web3: specifier: ^1.0.0-beta.36 - version: 1.10.4 + version: 1.10.4(bufferutil@4.0.8)(utf-8-validate@5.0.10) packages/hardhat-web3-legacy: devDependencies: @@ -1750,7 +1838,7 @@ importers: version: 18.19.33 '@typescript-eslint/eslint-plugin': specifier: 5.61.0 - version: 5.61.0(@typescript-eslint/parser@5.61.0)(eslint@8.57.0)(typescript@5.0.4) + version: 5.61.0(@typescript-eslint/parser@5.61.0(eslint@8.57.0)(typescript@5.0.4))(eslint@8.57.0)(typescript@5.0.4) '@typescript-eslint/parser': specifier: 5.61.0 version: 5.61.0(eslint@8.57.0)(typescript@5.0.4) @@ -1765,13 +1853,13 @@ importers: version: 8.3.0(eslint@8.57.0) eslint-plugin-import: specifier: 2.27.5 - version: 2.27.5(@typescript-eslint/parser@5.61.0)(eslint@8.57.0) + version: 2.27.5(@typescript-eslint/parser@5.61.0(eslint@8.57.0)(typescript@5.0.4))(eslint@8.57.0) eslint-plugin-mocha: specifier: 10.4.1 version: 10.4.1(eslint@8.57.0) eslint-plugin-prettier: specifier: 3.4.0 - version: 3.4.0(eslint-config-prettier@8.3.0)(eslint@8.57.0)(prettier@2.4.1) + version: 3.4.0(eslint-config-prettier@8.3.0(eslint@8.57.0))(eslint@8.57.0)(prettier@2.4.1) hardhat: specifier: workspace:^2.0.0 version: link:../hardhat-core @@ -1816,7 +1904,7 @@ importers: version: 18.19.33 '@typescript-eslint/eslint-plugin': specifier: 5.61.0 - version: 5.61.0(@typescript-eslint/parser@5.61.0)(eslint@8.57.0)(typescript@5.0.4) + version: 5.61.0(@typescript-eslint/parser@5.61.0(eslint@8.57.0)(typescript@5.0.4))(eslint@8.57.0)(typescript@5.0.4) '@typescript-eslint/parser': specifier: 5.61.0 version: 5.61.0(eslint@8.57.0)(typescript@5.0.4) @@ -1834,13 +1922,13 @@ importers: version: 8.3.0(eslint@8.57.0) eslint-plugin-import: specifier: 2.27.5 - version: 2.27.5(@typescript-eslint/parser@5.61.0)(eslint@8.57.0) + version: 2.27.5(@typescript-eslint/parser@5.61.0(eslint@8.57.0)(typescript@5.0.4))(eslint@8.57.0) eslint-plugin-mocha: specifier: 10.4.1 version: 10.4.1(eslint@8.57.0) eslint-plugin-prettier: specifier: 3.4.0 - version: 3.4.0(eslint-config-prettier@8.3.0)(eslint@8.57.0)(prettier@2.4.1) + version: 3.4.0(eslint-config-prettier@8.3.0(eslint@8.57.0))(eslint@8.57.0)(prettier@2.4.1) hardhat: specifier: workspace:^2.0.0 version: link:../hardhat-core @@ -1861,374 +1949,5668 @@ importers: version: 5.0.4 web3: specifier: ^4.0.1 - version: 4.8.0(typescript@5.0.4) + version: 4.8.0(bufferutil@4.0.8)(typescript@5.0.4)(utf-8-validate@5.0.10)(zod@3.23.8) packages: - /@adraffy/ens-normalize@1.10.0: + '@adraffy/ens-normalize@1.10.0': resolution: {integrity: sha512-nA9XHtlAkYfJxY7bce8DcN7eKxWWCWkU+1GR9d+U6MbNpfwQp8TI7vqOsBsMcHoT4mBu2kypKoSKnghEzOOq5Q==} - dev: true - /@adraffy/ens-normalize@1.10.1: + '@adraffy/ens-normalize@1.10.1': resolution: {integrity: sha512-96Z2IP3mYmF1Xg2cDm8f1gWGf/HUVedQ3FMifV4kG/PQ4yEP51xDtRAEfhVNt5f/uzpNkZHwWQuUcu6D6K+Ekw==} - /@ampproject/remapping@2.3.0: + '@ampproject/remapping@2.3.0': resolution: {integrity: sha512-30iZtAPgz+LTIYoeivqYo853f02jBYSd5uGnGpkFV0M3xOt9aN73erkgYAmZU43x4VfqcnLxW9Kpg3R5LC4YYw==} engines: {node: '>=6.0.0'} - dependencies: - '@jridgewell/gen-mapping': 0.3.5 - '@jridgewell/trace-mapping': 0.3.25 - dev: true - /@babel/code-frame@7.24.2: + '@babel/code-frame@7.24.2': resolution: {integrity: sha512-y5+tLQyV8pg3fsiln67BVLD1P13Eg4lh5RW9mF0zUuvLrv9uIQ4MCL+CRT+FTsBlBjcIan6PGsLcBN0m3ClUyQ==} engines: {node: '>=6.9.0'} - dependencies: - '@babel/highlight': 7.24.5 - picocolors: 1.0.0 - /@babel/compat-data@7.24.4: + '@babel/compat-data@7.24.4': resolution: {integrity: sha512-vg8Gih2MLK+kOkHJp4gBEIkyaIi00jgWot2D9QOmmfLC8jINSOzmCLta6Bvz/JSBCqnegV0L80jhxkol5GWNfQ==} engines: {node: '>=6.9.0'} - dev: true - /@babel/core@7.24.5: + '@babel/core@7.24.5': resolution: {integrity: sha512-tVQRucExLQ02Boi4vdPp49svNGcfL2GhdTCT9aldhXgCJVAI21EtRfBettiuLUwce/7r6bFdgs6JFkcdTiFttA==} engines: {node: '>=6.9.0'} - dependencies: - '@ampproject/remapping': 2.3.0 - '@babel/code-frame': 7.24.2 - '@babel/generator': 7.24.5 - '@babel/helper-compilation-targets': 7.23.6 - '@babel/helper-module-transforms': 7.24.5(@babel/core@7.24.5) - '@babel/helpers': 7.24.5 - '@babel/parser': 7.24.5 - '@babel/template': 7.24.0 - '@babel/traverse': 7.24.5 - '@babel/types': 7.24.5 - convert-source-map: 2.0.0 - debug: 4.3.4(supports-color@8.1.1) - gensync: 1.0.0-beta.2 - json5: 2.2.3 - semver: 6.3.1 - transitivePeerDependencies: - - supports-color - dev: true - /@babel/generator@7.24.5: + '@babel/generator@7.24.5': resolution: {integrity: sha512-x32i4hEXvr+iI0NEoEfDKzlemF8AmtOP8CcrRaEcpzysWuoEb1KknpcvMsHKPONoKZiDuItklgWhB18xEhr9PA==} engines: {node: '>=6.9.0'} - dependencies: - '@babel/types': 7.24.5 - '@jridgewell/gen-mapping': 0.3.5 - '@jridgewell/trace-mapping': 0.3.25 - jsesc: 2.5.2 - dev: true - /@babel/helper-compilation-targets@7.23.6: + '@babel/helper-compilation-targets@7.23.6': resolution: {integrity: sha512-9JB548GZoQVmzrFgp8o7KxdgkTGm6xs9DW0o/Pim72UDjzr5ObUQ6ZzYPqA+g9OTS2bBQoctLJrky0RDCAWRgQ==} engines: {node: '>=6.9.0'} - dependencies: - '@babel/compat-data': 7.24.4 - '@babel/helper-validator-option': 7.23.5 - browserslist: 4.23.0 - lru-cache: 5.1.1 - semver: 6.3.1 - dev: true - /@babel/helper-environment-visitor@7.22.20: + '@babel/helper-environment-visitor@7.22.20': resolution: {integrity: sha512-zfedSIzFhat/gFhWfHtgWvlec0nqB9YEIVrpuwjruLlXfUSnA8cJB0miHKwqDnQ7d32aKo2xt88/xZptwxbfhA==} engines: {node: '>=6.9.0'} - dev: true - /@babel/helper-function-name@7.23.0: + '@babel/helper-function-name@7.23.0': resolution: {integrity: sha512-OErEqsrxjZTJciZ4Oo+eoZqeW9UIiOcuYKRJA4ZAgV9myA+pOXhhmpfNCKjEH/auVfEYVFJ6y1Tc4r0eIApqiw==} engines: {node: '>=6.9.0'} - dependencies: - '@babel/template': 7.24.0 - '@babel/types': 7.24.5 - dev: true - /@babel/helper-hoist-variables@7.22.5: + '@babel/helper-hoist-variables@7.22.5': resolution: {integrity: sha512-wGjk9QZVzvknA6yKIUURb8zY3grXCcOZt+/7Wcy8O2uctxhplmUPkOdlgoNhmdVee2c92JXbf1xpMtVNbfoxRw==} engines: {node: '>=6.9.0'} - dependencies: - '@babel/types': 7.24.5 - dev: true - /@babel/helper-module-imports@7.24.3: + '@babel/helper-module-imports@7.24.3': resolution: {integrity: sha512-viKb0F9f2s0BCS22QSF308z/+1YWKV/76mwt61NBzS5izMzDPwdq1pTrzf+Li3npBWX9KdQbkeCt1jSAM7lZqg==} engines: {node: '>=6.9.0'} - dependencies: - '@babel/types': 7.24.5 - dev: true - /@babel/helper-module-transforms@7.24.5(@babel/core@7.24.5): + '@babel/helper-module-transforms@7.24.5': resolution: {integrity: sha512-9GxeY8c2d2mdQUP1Dye0ks3VDyIMS98kt/llQ2nUId8IsWqTF0l1LkSX0/uP7l7MCDrzXS009Hyhe2gzTiGW8A==} engines: {node: '>=6.9.0'} peerDependencies: '@babel/core': ^7.0.0 - dependencies: - '@babel/core': 7.24.5 - '@babel/helper-environment-visitor': 7.22.20 - '@babel/helper-module-imports': 7.24.3 - '@babel/helper-simple-access': 7.24.5 - '@babel/helper-split-export-declaration': 7.24.5 - '@babel/helper-validator-identifier': 7.24.5 - dev: true - /@babel/helper-simple-access@7.24.5: + '@babel/helper-simple-access@7.24.5': resolution: {integrity: sha512-uH3Hmf5q5n7n8mz7arjUlDOCbttY/DW4DYhE6FUsjKJ/oYC1kQQUvwEQWxRwUpX9qQKRXeqLwWxrqilMrf32sQ==} engines: {node: '>=6.9.0'} - dependencies: - '@babel/types': 7.24.5 - dev: true - /@babel/helper-split-export-declaration@7.24.5: + '@babel/helper-split-export-declaration@7.24.5': resolution: {integrity: sha512-5CHncttXohrHk8GWOFCcCl4oRD9fKosWlIRgWm4ql9VYioKm52Mk2xsmoohvm7f3JoiLSM5ZgJuRaf5QZZYd3Q==} engines: {node: '>=6.9.0'} - dependencies: - '@babel/types': 7.24.5 - dev: true - /@babel/helper-string-parser@7.24.1: + '@babel/helper-string-parser@7.24.1': resolution: {integrity: sha512-2ofRCjnnA9y+wk8b9IAREroeUP02KHp431N2mhKniy2yKIDKpbrHv9eXwm8cBeWQYcJmzv5qKCu65P47eCF7CQ==} engines: {node: '>=6.9.0'} - dev: true - /@babel/helper-validator-identifier@7.24.5: + '@babel/helper-validator-identifier@7.24.5': resolution: {integrity: sha512-3q93SSKX2TWCG30M2G2kwaKeTYgEUp5Snjuj8qm729SObL6nbtUldAi37qbxkD5gg3xnBio+f9nqpSepGZMvxA==} engines: {node: '>=6.9.0'} - /@babel/helper-validator-option@7.23.5: + '@babel/helper-validator-option@7.23.5': resolution: {integrity: sha512-85ttAOMLsr53VgXkTbkx8oA6YTfT4q7/HzXSLEYmjcSTJPMPQtvq1BD79Byep5xMUYbGRzEpDsjUf3dyp54IKw==} engines: {node: '>=6.9.0'} - dev: true - /@babel/helpers@7.24.5: + '@babel/helpers@7.24.5': resolution: {integrity: sha512-CiQmBMMpMQHwM5m01YnrM6imUG1ebgYJ+fAIW4FZe6m4qHTPaRHti+R8cggAwkdz4oXhtO4/K9JWlh+8hIfR2Q==} engines: {node: '>=6.9.0'} - dependencies: - '@babel/template': 7.24.0 - '@babel/traverse': 7.24.5 - '@babel/types': 7.24.5 - transitivePeerDependencies: - - supports-color - dev: true - /@babel/highlight@7.24.5: + '@babel/highlight@7.24.5': resolution: {integrity: sha512-8lLmua6AVh/8SLJRRVD6V8p73Hir9w5mJrhE+IPpILG31KKlI9iz5zmBYKcWPS59qSfgP9RaSBQSHHE81WKuEw==} engines: {node: '>=6.9.0'} - dependencies: - '@babel/helper-validator-identifier': 7.24.5 - chalk: 2.4.2 - js-tokens: 4.0.0 - picocolors: 1.0.0 - /@babel/parser@7.24.5: + '@babel/parser@7.24.5': resolution: {integrity: sha512-EOv5IK8arwh3LI47dz1b0tKUb/1uhHAnHJOrjgtQMIpu1uXd9mlFrJg9IUgGUgZ41Ch0K8REPTYpO7B76b4vJg==} engines: {node: '>=6.0.0'} hasBin: true - dependencies: - '@babel/types': 7.24.5 - dev: true - /@babel/runtime@7.24.5: + '@babel/runtime@7.24.5': resolution: {integrity: sha512-Nms86NXrsaeU9vbBJKni6gXiEXZ4CVpYVzEjDH9Sb8vmZ3UljyA1GSOJl/6LGPO8EHLuSF9H+IxNXHPX8QHJ4g==} engines: {node: '>=6.9.0'} - dependencies: - regenerator-runtime: 0.14.1 - /@babel/template@7.24.0: + '@babel/template@7.24.0': resolution: {integrity: sha512-Bkf2q8lMB0AFpX0NFEqSbx1OkTHf0f+0j82mkw+ZpzBnkk7e9Ql0891vlfgi+kHwOk8tQjiQHpqh4LaSa0fKEA==} engines: {node: '>=6.9.0'} - dependencies: - '@babel/code-frame': 7.24.2 - '@babel/parser': 7.24.5 - '@babel/types': 7.24.5 - dev: true - /@babel/traverse@7.24.5: + '@babel/traverse@7.24.5': resolution: {integrity: sha512-7aaBLeDQ4zYcUFDUD41lJc1fG8+5IU9DaNSJAgal866FGvmD5EbWQgnEC6kO1gGLsX0esNkfnJSndbTXA3r7UA==} engines: {node: '>=6.9.0'} - dependencies: - '@babel/code-frame': 7.24.2 - '@babel/generator': 7.24.5 - '@babel/helper-environment-visitor': 7.22.20 - '@babel/helper-function-name': 7.23.0 - '@babel/helper-hoist-variables': 7.22.5 - '@babel/helper-split-export-declaration': 7.24.5 - '@babel/parser': 7.24.5 - '@babel/types': 7.24.5 - debug: 4.3.4(supports-color@8.1.1) - globals: 11.12.0 - transitivePeerDependencies: - - supports-color - dev: true - /@babel/types@7.24.5: + '@babel/types@7.24.5': resolution: {integrity: sha512-6mQNsaLeXTw0nxYUYu+NSa4Hx4BlF1x1x8/PMFbiR+GBSr+2DkECc69b8hgy2frEodNcvPffeH8YfWd3LI6jhQ==} engines: {node: '>=6.9.0'} - dependencies: - '@babel/helper-string-parser': 7.24.1 - '@babel/helper-validator-identifier': 7.24.5 - to-fast-properties: 2.0.0 - dev: true - /@changesets/apply-release-plan@7.0.0: + '@changesets/apply-release-plan@7.0.0': resolution: {integrity: sha512-vfi69JR416qC9hWmFGSxj7N6wA5J222XNBmezSVATPWDVPIF7gkd4d8CpbEbXmRWbVrkoli3oerGS6dcL/BGsQ==} - dependencies: - '@babel/runtime': 7.24.5 - '@changesets/config': 3.0.0 - '@changesets/get-version-range-type': 0.4.0 - '@changesets/git': 3.0.0 - '@changesets/types': 6.0.0 - '@manypkg/get-packages': 1.1.3 - detect-indent: 6.1.0 - fs-extra: 7.0.1 - lodash.startcase: 4.4.0 - outdent: 0.5.0 - prettier: 2.8.8 - resolve-from: 5.0.0 - semver: 7.6.2 - dev: true - /@changesets/assemble-release-plan@6.0.0: + '@changesets/assemble-release-plan@6.0.0': resolution: {integrity: sha512-4QG7NuisAjisbW4hkLCmGW2lRYdPrKzro+fCtZaILX+3zdUELSvYjpL4GTv0E4aM9Mef3PuIQp89VmHJ4y2bfw==} - dependencies: - '@babel/runtime': 7.24.5 - '@changesets/errors': 0.2.0 - '@changesets/get-dependents-graph': 2.0.0 - '@changesets/types': 6.0.0 - '@manypkg/get-packages': 1.1.3 - semver: 7.6.2 - dev: true - /@changesets/changelog-git@0.2.0: + '@changesets/changelog-git@0.2.0': resolution: {integrity: sha512-bHOx97iFI4OClIT35Lok3sJAwM31VbUM++gnMBV16fdbtBhgYu4dxsphBF/0AZZsyAHMrnM0yFcj5gZM1py6uQ==} - dependencies: - '@changesets/types': 6.0.0 - dev: true - /@changesets/cli@2.27.1: + '@changesets/cli@2.27.1': resolution: {integrity: sha512-iJ91xlvRnnrJnELTp4eJJEOPjgpF3NOh4qeQehM6Ugiz9gJPRZ2t+TsXun6E3AMN4hScZKjqVXl0TX+C7AB3ZQ==} hasBin: true - dependencies: - '@babel/runtime': 7.24.5 - '@changesets/apply-release-plan': 7.0.0 - '@changesets/assemble-release-plan': 6.0.0 - '@changesets/changelog-git': 0.2.0 - '@changesets/config': 3.0.0 - '@changesets/errors': 0.2.0 - '@changesets/get-dependents-graph': 2.0.0 - '@changesets/get-release-plan': 4.0.0 - '@changesets/git': 3.0.0 - '@changesets/logger': 0.1.0 - '@changesets/pre': 2.0.0 - '@changesets/read': 0.6.0 - '@changesets/types': 6.0.0 - '@changesets/write': 0.3.0 - '@manypkg/get-packages': 1.1.3 - '@types/semver': 7.5.8 - ansi-colors: 4.1.3 - chalk: 2.4.2 - ci-info: 3.9.0 - enquirer: 2.4.1 - external-editor: 3.1.0 - fs-extra: 7.0.1 - human-id: 1.0.2 - meow: 6.1.1 - outdent: 0.5.0 - p-limit: 2.3.0 - preferred-pm: 3.1.3 - resolve-from: 5.0.0 - semver: 7.6.2 - spawndamnit: 2.0.0 - term-size: 2.2.1 - tty-table: 4.2.3 - dev: true - /@changesets/config@3.0.0: + '@changesets/config@3.0.0': resolution: {integrity: sha512-o/rwLNnAo/+j9Yvw9mkBQOZySDYyOr/q+wptRLcAVGlU6djOeP9v1nlalbL9MFsobuBVQbZCTp+dIzdq+CLQUA==} - dependencies: - '@changesets/errors': 0.2.0 - '@changesets/get-dependents-graph': 2.0.0 - '@changesets/logger': 0.1.0 - '@changesets/types': 6.0.0 - '@manypkg/get-packages': 1.1.3 - fs-extra: 7.0.1 - micromatch: 4.0.5 - dev: true - /@changesets/errors@0.2.0: + '@changesets/errors@0.2.0': resolution: {integrity: sha512-6BLOQUscTpZeGljvyQXlWOItQyU71kCdGz7Pi8H8zdw6BI0g3m43iL4xKUVPWtG+qrrL9DTjpdn8eYuCQSRpow==} - dependencies: - extendable-error: 0.1.7 - dev: true - /@changesets/get-dependents-graph@2.0.0: + '@changesets/get-dependents-graph@2.0.0': resolution: {integrity: sha512-cafUXponivK4vBgZ3yLu944mTvam06XEn2IZGjjKc0antpenkYANXiiE6GExV/yKdsCnE8dXVZ25yGqLYZmScA==} - dependencies: - '@changesets/types': 6.0.0 - '@manypkg/get-packages': 1.1.3 - chalk: 2.4.2 - fs-extra: 7.0.1 - semver: 7.6.2 - dev: true - /@changesets/get-release-plan@4.0.0: + '@changesets/get-release-plan@4.0.0': resolution: {integrity: sha512-9L9xCUeD/Tb6L/oKmpm8nyzsOzhdNBBbt/ZNcjynbHC07WW4E1eX8NMGC5g5SbM5z/V+MOrYsJ4lRW41GCbg3w==} - dependencies: - '@babel/runtime': 7.24.5 - '@changesets/assemble-release-plan': 6.0.0 - '@changesets/config': 3.0.0 - '@changesets/pre': 2.0.0 - '@changesets/read': 0.6.0 - '@changesets/types': 6.0.0 - '@manypkg/get-packages': 1.1.3 - dev: true - /@changesets/get-version-range-type@0.4.0: + '@changesets/get-version-range-type@0.4.0': resolution: {integrity: sha512-hwawtob9DryoGTpixy1D3ZXbGgJu1Rhr+ySH2PvTLHvkZuQ7sRT4oQwMh0hbqZH1weAooedEjRsbrWcGLCeyVQ==} - dev: true - /@changesets/git@3.0.0: + '@changesets/git@3.0.0': resolution: {integrity: sha512-vvhnZDHe2eiBNRFHEgMiGd2CT+164dfYyrJDhwwxTVD/OW0FUD6G7+4DIx1dNwkwjHyzisxGAU96q0sVNBns0w==} - dependencies: - '@babel/runtime': 7.24.5 - '@changesets/errors': 0.2.0 - '@changesets/types': 6.0.0 + + '@changesets/logger@0.1.0': + resolution: {integrity: sha512-pBrJm4CQm9VqFVwWnSqKEfsS2ESnwqwH+xR7jETxIErZcfd1u2zBSqrHbRHR7xjhSgep9x2PSKFKY//FAshA3g==} + + '@changesets/parse@0.4.0': + resolution: {integrity: sha512-TS/9KG2CdGXS27S+QxbZXgr8uPsP4yNJYb4BC2/NeFUj80Rni3TeD2qwWmabymxmrLo7JEsytXH1FbpKTbvivw==} + + '@changesets/pre@2.0.0': + resolution: {integrity: sha512-HLTNYX/A4jZxc+Sq8D1AMBsv+1qD6rmmJtjsCJa/9MSRybdxh0mjbTvE6JYZQ/ZiQ0mMlDOlGPXTm9KLTU3jyw==} + + '@changesets/read@0.6.0': + resolution: {integrity: sha512-ZypqX8+/im1Fm98K4YcZtmLKgjs1kDQ5zHpc2U1qdtNBmZZfo/IBiG162RoP0CUF05tvp2y4IspH11PLnPxuuw==} + + '@changesets/types@4.1.0': + resolution: {integrity: sha512-LDQvVDv5Kb50ny2s25Fhm3d9QSZimsoUGBsUioj6MC3qbMUCuC8GPIvk/M6IvXx3lYhAs0lwWUQLb+VIEUCECw==} + + '@changesets/types@6.0.0': + resolution: {integrity: sha512-b1UkfNulgKoWfqyHtzKS5fOZYSJO+77adgL7DLRDr+/7jhChN+QcHnbjiQVOz/U+Ts3PGNySq7diAItzDgugfQ==} + + '@changesets/write@0.3.0': + resolution: {integrity: sha512-slGLb21fxZVUYbyea+94uFiD6ntQW0M2hIKNznFizDhZPDgn2c/fv1UzzlW43RVzh1BEDuIqW6hzlJ1OflNmcw==} + + '@cspotcode/source-map-support@0.8.1': + resolution: {integrity: sha512-IchNf6dN4tHoMFIn/7OE8LWZ19Y6q/67Bmf6vnGREv8RSbBVb9LPJxEcnwrcwX6ixSvaiGoomAUvu4YSxXrVgw==} + engines: {node: '>=12'} + + '@ensdomains/address-encoder@0.1.9': + resolution: {integrity: sha512-E2d2gP4uxJQnDu2Kfg1tHNspefzbLT8Tyjrm5sEuim32UkU2sm5xL4VXtgc2X33fmPEw9+jUMpGs4veMbf+PYg==} + + '@ensdomains/ens@0.4.5': + resolution: {integrity: sha512-JSvpj1iNMFjK6K+uVl4unqMoa9rf5jopb8cya5UGBWz23Nw8hSNT7efgUx4BTlAPAgpNlEioUfeTyQ6J9ZvTVw==} + deprecated: Please use @ensdomains/ens-contracts + + '@ensdomains/ensjs@2.1.0': + resolution: {integrity: sha512-GRbGPT8Z/OJMDuxs75U/jUNEC0tbL0aj7/L/QQznGYKm/tiasp+ndLOaoULy9kKJFC0TBByqfFliEHDgoLhyog==} + + '@ensdomains/resolver@0.2.4': + resolution: {integrity: sha512-bvaTH34PMCbv6anRa9I/0zjLJgY4EuznbEMgbV77JBCQ9KNC46rzi0avuxpOfu+xDjPEtSFGqVEOr5GlUSGudA==} + deprecated: Please use @ensdomains/ens-contracts + + '@eslint-community/eslint-utils@4.4.0': + resolution: {integrity: sha512-1/sA4dwrzBAyeUoQ6oxahHKmrZvsnLCg4RfxW3ZFGGmQkSNQPFNLV9CUEFQP1x9EYXHTo5p6xdhZM1Ne9p/AfA==} + engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0} + peerDependencies: + eslint: ^6.0.0 || ^7.0.0 || >=8.0.0 + + '@eslint-community/regexpp@4.10.0': + resolution: {integrity: sha512-Cu96Sd2By9mCNTx2iyKOmq10v22jUVQv0lQnlGNy16oE9589yE+QADPbrMGCkA51cKZSg3Pu/aTJVTGfL/qjUA==} + engines: {node: ^12.0.0 || ^14.0.0 || >=16.0.0} + + '@eslint/eslintrc@2.1.4': + resolution: {integrity: sha512-269Z39MS6wVJtsoUl10L60WdkhJVdPG24Q4eZTH3nnF6lpvSShEK3wQjDX9JRWAUPvPh7COouPpU9IrqaZFvtQ==} + engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0} + + '@eslint/js@8.57.0': + resolution: {integrity: sha512-Ys+3g2TaW7gADOJzPt83SJtCDhMjndcDMFVQ/Tj9iA1BfJzFKD9mAUXT3OenpuPHbI6P/myECxRJrofUsDx/5g==} + engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0} + + '@ethereumjs/common@2.5.0': + resolution: {integrity: sha512-DEHjW6e38o+JmB/NO3GZBpW4lpaiBpkFgXF6jLcJ6gETBYpEyaA5nTimsWBUJR3Vmtm/didUEbNjajskugZORg==} + + '@ethereumjs/common@2.6.5': + resolution: {integrity: sha512-lRyVQOeCDaIVtgfbowla32pzeDv2Obr8oR8Put5RdUBNRGr1VGPGQNGP6elWIpgK3YdpzqTOh4GyUGOureVeeA==} + + '@ethereumjs/rlp@4.0.1': + resolution: {integrity: sha512-tqsQiBQDQdmPWE1xkkBq4rlSW5QZpLOUJ5RJh2/9fug+q9tnUhuZoVLk7s0scUIKTOzEtR72DFBXI4WiZcMpvw==} + engines: {node: '>=14'} + hasBin: true + + '@ethereumjs/tx@3.3.2': + resolution: {integrity: sha512-6AaJhwg4ucmwTvw/1qLaZUX5miWrwZ4nLOUsKyb/HtzS3BMw/CasKhdi1ims9mBKeK9sOJCH4qGKOBGyJCeeog==} + + '@ethereumjs/tx@3.5.2': + resolution: {integrity: sha512-gQDNJWKrSDGu2w7w0PzVXVBNMzb7wwdDOmOqczmhNjqFxFuIbhVJDwiGEnxFNC2/b8ifcZzY7MLcluizohRzNw==} + + '@ethereumjs/util@8.1.0': + resolution: {integrity: sha512-zQ0IqbdX8FZ9aw11vP+dZkKDkS+kgIvQPHnSAXzP9pLu+Rfu3D3XEeLbicvoXJTYnhZiPmsZUxgdzXwNKxRPbA==} + engines: {node: '>=14'} + + '@ethersproject/abi@5.7.0': + resolution: {integrity: sha512-351ktp42TiRcYB3H1OP8yajPeAQstMW/yCFokj/AthP9bLHzQFPlOrxOcwYEDkUAICmOHljvN4K39OMTMUa9RA==} + + '@ethersproject/abstract-provider@5.7.0': + resolution: {integrity: sha512-R41c9UkchKCpAqStMYUpdunjo3pkEvZC3FAwZn5S5MGbXoMQOHIdHItezTETxAO5bevtMApSyEhn9+CHcDsWBw==} + + '@ethersproject/abstract-signer@5.7.0': + resolution: {integrity: sha512-a16V8bq1/Cz+TGCkE2OPMTOUDLS3grCpdjoJCYNnVBbdYEMSgKrU0+B90s8b6H+ByYTBZN7a3g76jdIJi7UfKQ==} + + '@ethersproject/address@5.6.1': + resolution: {integrity: sha512-uOgF0kS5MJv9ZvCz7x6T2EXJSzotiybApn4XlOgoTX0xdtyVIJ7pF+6cGPxiEq/dpBiTfMiw7Yc81JcwhSYA0Q==} + + '@ethersproject/address@5.7.0': + resolution: {integrity: sha512-9wYhYt7aghVGo758POM5nqcOMaE168Q6aRLJZwUmiqSrAungkG74gSSeKEIR7ukixesdRZGPgVqme6vmxs1fkA==} + + '@ethersproject/base64@5.7.0': + resolution: {integrity: sha512-Dr8tcHt2mEbsZr/mwTPIQAf3Ai0Bks/7gTw9dSqk1mQvhW3XvRlmDJr/4n+wg1JmCl16NZue17CDh8xb/vZ0sQ==} + + '@ethersproject/basex@5.7.0': + resolution: {integrity: sha512-ywlh43GwZLv2Voc2gQVTKBoVQ1mti3d8HK5aMxsfu/nRDnMmNqaSJ3r3n85HBByT8OpoY96SXM1FogC533T4zw==} + + '@ethersproject/bignumber@5.7.0': + resolution: {integrity: sha512-n1CAdIHRWjSucQO3MC1zPSVgV/6dy/fjL9pMrPP9peL+QxEg9wOsVqwD4+818B6LUEtaXzVHQiuivzRoxPxUGw==} + + '@ethersproject/bytes@5.7.0': + resolution: {integrity: sha512-nsbxwgFXWh9NyYWo+U8atvmMsSdKJprTcICAkvbBffT75qDocbuggBU0SJiVK2MuTrp0q+xvLkTnGMPK1+uA9A==} + + '@ethersproject/constants@5.7.0': + resolution: {integrity: sha512-DHI+y5dBNvkpYUMiRQyxRBYBefZkJfo70VUkUAsRjcPs47muV9evftfZ0PJVCXYbAiCgght0DtcF9srFQmIgWA==} + + '@ethersproject/contracts@5.7.0': + resolution: {integrity: sha512-5GJbzEU3X+d33CdfPhcyS+z8MzsTrBGk/sc+G+59+tPa9yFkl6HQ9D6L0QMgNTA9q8dT0XKxxkyp883XsQvbbg==} + + '@ethersproject/hash@5.7.0': + resolution: {integrity: sha512-qX5WrQfnah1EFnO5zJv1v46a8HW0+E5xuBBDTwMFZLuVTx0tbU2kkx15NqdjxecrLGatQN9FGQKpb1FKdHCt+g==} + + '@ethersproject/hdnode@5.7.0': + resolution: {integrity: sha512-OmyYo9EENBPPf4ERhR7oj6uAtUAhYGqOnIS+jE5pTXvdKBS99ikzq1E7Iv0ZQZ5V36Lqx1qZLeak0Ra16qpeOg==} + + '@ethersproject/json-wallets@5.7.0': + resolution: {integrity: sha512-8oee5Xgu6+RKgJTkvEMl2wDgSPSAQ9MB/3JYjFV9jlKvcYHUXZC+cQp0njgmxdHkYWn8s6/IqIZYm0YWCjO/0g==} + + '@ethersproject/keccak256@5.7.0': + resolution: {integrity: sha512-2UcPboeL/iW+pSg6vZ6ydF8tCnv3Iu/8tUmLLzWWGzxWKFFqOBQFLo6uLUv6BDrLgCDfN28RJ/wtByx+jZ4KBg==} + + '@ethersproject/logger@5.7.0': + resolution: {integrity: sha512-0odtFdXu/XHtjQXJYA3u9G0G8btm0ND5Cu8M7i5vhEcE8/HmF4Lbdqanwyv4uQTr2tx6b7fQRmgLrsnpQlmnig==} + + '@ethersproject/networks@5.7.1': + resolution: {integrity: sha512-n/MufjFYv3yFcUyfhnXotyDlNdFb7onmkSy8aQERi2PjNcnWQ66xXxa3XlS8nCcA8aJKJjIIMNJTC7tu80GwpQ==} + + '@ethersproject/pbkdf2@5.7.0': + resolution: {integrity: sha512-oR/dBRZR6GTyaofd86DehG72hY6NpAjhabkhxgr3X2FpJtJuodEl2auADWBZfhDHgVCbu3/H/Ocq2uC6dpNjjw==} + + '@ethersproject/properties@5.7.0': + resolution: {integrity: sha512-J87jy8suntrAkIZtecpxEPxY//szqr1mlBaYlQ0r4RCaiD2hjheqF9s1LVE8vVuJCXisjIP+JgtK/Do54ej4Sw==} + + '@ethersproject/providers@5.7.2': + resolution: {integrity: sha512-g34EWZ1WWAVgr4aptGlVBF8mhl3VWjv+8hoAnzStu8Ah22VHBsuGzP17eb6xDVRzw895G4W7vvx60lFFur/1Rg==} + + '@ethersproject/random@5.7.0': + resolution: {integrity: sha512-19WjScqRA8IIeWclFme75VMXSBvi4e6InrUNuaR4s5pTF2qNhcGdCUwdxUVGtDDqC00sDLCO93jPQoDUH4HVmQ==} + + '@ethersproject/rlp@5.7.0': + resolution: {integrity: sha512-rBxzX2vK8mVF7b0Tol44t5Tb8gomOHkj5guL+HhzQ1yBh/ydjGnpw6at+X6Iw0Kp3OzzzkcKp8N9r0W4kYSs9w==} + + '@ethersproject/sha2@5.7.0': + resolution: {integrity: sha512-gKlH42riwb3KYp0reLsFTokByAKoJdgFCwI+CCiX/k+Jm2mbNs6oOaCjYQSlI1+XBVejwH2KrmCbMAT/GnRDQw==} + + '@ethersproject/signing-key@5.7.0': + resolution: {integrity: sha512-MZdy2nL3wO0u7gkB4nA/pEf8lu1TlFswPNmy8AiYkfKTdO6eXBJyUdmHO/ehm/htHw9K/qF8ujnTyUAD+Ry54Q==} + + '@ethersproject/solidity@5.7.0': + resolution: {integrity: sha512-HmabMd2Dt/raavyaGukF4XxizWKhKQ24DoLtdNbBmNKUOPqwjsKQSdV9GQtj9CBEea9DlzETlVER1gYeXXBGaA==} + + '@ethersproject/strings@5.7.0': + resolution: {integrity: sha512-/9nu+lj0YswRNSH0NXYqrh8775XNyEdUQAuf3f+SmOrnVewcJ5SBNAjF7lpgehKi4abvNNXyf+HX86czCdJ8Mg==} + + '@ethersproject/transactions@5.7.0': + resolution: {integrity: sha512-kmcNicCp1lp8qanMTC3RIikGgoJ80ztTyvtsFvCYpSCfkjhD0jZ2LOrnbcuxuToLIUYYf+4XwD1rP+B/erDIhQ==} + + '@ethersproject/units@5.7.0': + resolution: {integrity: sha512-pD3xLMy3SJu9kG5xDGI7+xhTEmGXlEqXU4OfNapmfnxLVY4EMSSRp7j1k7eezutBPH7RBN/7QPnwR7hzNlEFeg==} + + '@ethersproject/wallet@5.7.0': + resolution: {integrity: sha512-MhmXlJXEJFBFVKrDLB4ZdDzxcBxQ3rLyCkhNqVu3CDYvR97E+8r01UgrI+TI99Le+aYm/in/0vp86guJuM7FCA==} + + '@ethersproject/web@5.7.1': + resolution: {integrity: sha512-Gueu8lSvyjBWL4cYsWsjh6MtMwM0+H4HvqFPZfB6dV8ctbP9zFAO73VG1cMWae0FLPCtz0peKPpZY8/ugJJX2w==} + + '@ethersproject/wordlists@5.7.0': + resolution: {integrity: sha512-S2TFNJNfHWVHNE6cNDjbVlZ6MgE17MIxMbMg2zv3wn+3XSJGosL1m9ZVv3GXCf/2ymSsQ+hRI5IzoMJTG6aoVA==} + + '@fastify/busboy@2.1.1': + resolution: {integrity: sha512-vBZP4NlzfOlerQTnba4aqZoMhE/a9HY7HRqoOPaETQcSQuWEIyZMHGfVu6w9wGtGK5fED5qRs2DteVCjOH60sA==} + engines: {node: '>=14'} + + '@fvictorio/tabtab@0.0.3': + resolution: {integrity: sha512-bT/BSy8MJThrTebqTCjXRnGSgZWthHLigZ4k2AvfNtC79vPyBS1myaxw8gRU6RxIcdDD3HBtm7pOsOoyC086Zg==} + engines: {node: '>=10'} + + '@humanwhocodes/config-array@0.11.14': + resolution: {integrity: sha512-3T8LkOmg45BV5FICb15QQMsyUSWrQ8AygVfC7ZG32zOalnqrilm018ZVCw0eapXux8FtA33q8PSRSstjee3jSg==} + engines: {node: '>=10.10.0'} + + '@humanwhocodes/module-importer@1.0.1': + resolution: {integrity: sha512-bxveV4V8v5Yb4ncFTT3rPSgZBOpCkjfK0y4oVVVJwIuDVBRMDXrPyXRL988i5ap9m9bnyEEjWfm5WkBmtffLfA==} + engines: {node: '>=12.22'} + + '@humanwhocodes/object-schema@2.0.3': + resolution: {integrity: sha512-93zYdMES/c1D69yZiKDBj0V24vqNzB/koF26KPaagAfd3P/4gUlh3Dys5ogAK+Exi9QyzlD8x/08Zt7wIKcDcA==} + + '@istanbuljs/load-nyc-config@1.1.0': + resolution: {integrity: sha512-VjeHSlIzpv/NyD3N0YuHfXOPDIixcA1q2ZV98wsMqcYlPmv2n3Yb2lYP9XMElnaFVXg5A7YLTeLu6V84uQDjmQ==} + engines: {node: '>=8'} + + '@istanbuljs/schema@0.1.3': + resolution: {integrity: sha512-ZXRY4jNvVgSVQ8DL3LTcakaAtXwTVUxE81hslsyD2AtoXW/wVob10HkOJ1X/pAlcI7D+2YoZKg5do8G/w6RYgA==} + engines: {node: '>=8'} + + '@jest/schemas@29.6.3': + resolution: {integrity: sha512-mo5j5X+jIZmJQveBKeS/clAueipV7KgiX1vMgCxam1RNYiqE1w62n0/tJJnHtjW8ZHcQco5gY85jA3mi0L+nSA==} + engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0} + + '@jridgewell/gen-mapping@0.3.5': + resolution: {integrity: sha512-IzL8ZoEDIBRWEzlCcRhOaCupYyN5gdIK+Q6fbFdPDg6HqX6jpkItn7DFIpW9LQzXG6Df9sA7+OKnq0qlz/GaQg==} + engines: {node: '>=6.0.0'} + + '@jridgewell/resolve-uri@3.1.2': + resolution: {integrity: sha512-bRISgCIjP20/tbWSPWMEi54QVPRZExkuD9lJL+UIxUKtwVJA8wW1Trb1jMs1RFXo1CBTNZ/5hpC9QvmKWdopKw==} + engines: {node: '>=6.0.0'} + + '@jridgewell/set-array@1.2.1': + resolution: {integrity: sha512-R8gLRTZeyp03ymzP/6Lil/28tGeGEzhx1q2k703KGWRAI1VdvPIXdG70VJc2pAMw3NA6JKL5hhFu1sJX0Mnn/A==} + engines: {node: '>=6.0.0'} + + '@jridgewell/sourcemap-codec@1.4.15': + resolution: {integrity: sha512-eF2rxCRulEKXHTRiDrDy6erMYWqNw4LPdQ8UQA4huuxaQsVeRPFl2oM8oDGxMFhJUWZf9McpLtJasDDZb/Bpeg==} + + '@jridgewell/trace-mapping@0.3.25': + resolution: {integrity: sha512-vNk6aEwybGtawWmy/PzwnGDOjCkLWSD2wqvjGGAgOAwCGWySYXfYoxt00IJkTF+8Lb57DwOb3Aa0o9CApepiYQ==} + + '@jridgewell/trace-mapping@0.3.9': + resolution: {integrity: sha512-3Belt6tdc8bPgAtbcmdtNJlirVoTmEb5e2gC94PnkwEW9jI6CAHUeoG85tjWP5WquqfavoMtMwiG4P926ZKKuQ==} + + '@json-schema-spec/json-pointer@0.1.2': + resolution: {integrity: sha512-BYY7IavBjwsWWSmVcMz2A9mKiDD9RvacnsItgmy1xV8cmgbtxFfKmKMtkVpD7pYtkx4mIW4800yZBXueVFIWPw==} + + '@json-schema-tools/dereferencer@1.5.4': + resolution: {integrity: sha512-4cmEdRPIG7WrcSWGRV6HBDCLXEOXGkaOZnopqBxoG24mKYuCHWg4M6N9nioTQyNfKqlPkOPvT4lStQqkPnhLgA==} + + '@json-schema-tools/meta-schema@1.6.19': + resolution: {integrity: sha512-55zuWFW7tr4tf/G5AYmybcPdGOkVAreQbt2JdnogX4I2r/zkxZiimYPJESDf5je9BI2oRveak2p296HzDppeaA==} + + '@json-schema-tools/reference-resolver@1.2.4': + resolution: {integrity: sha512-Oag20zDuapO6nBQp00k8Rd5sDTb8Gfz9uH43Tf7dHKNx7nHDK/WdeTe7OxkOmLQCL6aS+mCJx1Zv+fZBCD+tzQ==} + + '@json-schema-tools/referencer@1.1.3': + resolution: {integrity: sha512-p2JU7GpHn1kMyP7gnB2Wnki+OnifsSi75Uj5PxqIg2pT4fqh+BM3rEEZKpaET4xv0ZszG46CCI9eEvs68v2rXg==} + + '@json-schema-tools/titleizer@1.0.8': + resolution: {integrity: sha512-xgsg7ghVhd+9ZrhpmakNJUMmp+R+1mB6n4zn4iRg6P47GTfN04L/GR7mjC8LvO+XaZxbIzE6EzvHeZ5+nmhjJA==} + + '@json-schema-tools/titleizer@1.0.9': + resolution: {integrity: sha512-Gwg3YTP5P+3Q+OnvEcthTnsup3AsEkxZCrRLXoWppdjtSzRnsWxtvmpKdGLbVcocPC7Sh3aqJ7Arp85Ii6q2GA==} + + '@json-schema-tools/transpiler@1.10.5': + resolution: {integrity: sha512-uRm43U8wKWQV8czvvkJYwcUERpQC+azKmqbd7RhV1gWx7s1t0frLtrWqGbXh9xMcgdtF7+Tkiwex48nW5EnX1w==} + + '@json-schema-tools/traverse@1.10.4': + resolution: {integrity: sha512-9e42zjhLIxzBONroNC4SGsTqdB877tzwH2S6lqgTav9K24kWJR9vNieeMVSuyqnY8FlclH21D8wsm/tuD9WA9Q==} + + '@ledgerhq/cryptoassets@9.13.0': + resolution: {integrity: sha512-MzGJyc48OGU/FLYGYwEJyfOgbJzlR8XJ9Oo6XpNpNUM1/E5NDqvD72V0D+0uWIJYN3e2NtyqHXShLZDu7P95YA==} + + '@ledgerhq/devices@8.3.0': + resolution: {integrity: sha512-h5Scr+yIae8yjPOViCHLdMjpqn4oC2Whrsq8LinRxe48LEGMdPqSV1yY7+3Ch827wtzNpMv+/ilKnd8rY+rTlg==} + + '@ledgerhq/domain-service@1.1.20': + resolution: {integrity: sha512-+o1cEZj9HkJeIz2eL3r52tzkOiEKMs9w5aXF+Gy4mrmBjQ3Tw0OY9b69b3jz6PjlEHwAZsDRmcvF1/hSW6ITjw==} + + '@ledgerhq/errors@6.16.4': + resolution: {integrity: sha512-M57yFaLYSN+fZCX0E0zUqOmrV6eipK+s5RhijHoUNlHUqrsvUz7iRQgpd5gRgHB5VkIjav7KdaZjKiWGcHovaQ==} + + '@ledgerhq/hw-app-eth@6.33.6': + resolution: {integrity: sha512-QzYvr5FNEWWd70Vg04A2i8CY0mtPgJrrX7/KePabjXrR8NjDyJ5Ej8qSQPBTp2dkR4TGiz5Y7+HIcWpdgYzjzg==} + + '@ledgerhq/hw-transport-mocker@6.28.6': + resolution: {integrity: sha512-JDO2kqMOTRCQWNZr1KVlyX1AqE6WBzHjJDS3FnSI8Z/Bj2KSc2/1H/4lW6+Ap64yLtlmOW3GchdafFmLgYAgqw==} + + '@ledgerhq/hw-transport-node-hid-noevents@6.29.6': + resolution: {integrity: sha512-H1cGC4TLwSCxve3rbV7qfPJBZfy7VD7k9Czc9HOMDwQ9zHFtaoeiIotIMGjzHjfPtAGauMpAYvrpmEdBBX5sHg==} + + '@ledgerhq/hw-transport-node-hid@6.28.6': + resolution: {integrity: sha512-USSTOO0zv9XtguWismP7/StnNS/s7Rz0JOGGaBhKe3Bzl7d5XPncUlmOvoNFzzY/QdasEoFs2QId1+ibJG71Vw==} + + '@ledgerhq/hw-transport@6.30.6': + resolution: {integrity: sha512-fT0Z4IywiuJuZrZE/+W0blkV5UCotDPFTYKLkKCLzYzuE6javva7D/ajRaIeR+hZ4kTmKF4EqnsmDCXwElez+w==} + + '@ledgerhq/logs@6.12.0': + resolution: {integrity: sha512-ExDoj1QV5eC6TEbMdLUMMk9cfvNKhhv5gXol4SmULRVCx/3iyCPhJ74nsb3S0Vb+/f+XujBEj3vQn5+cwS0fNA==} + + '@ledgerhq/types-live@6.46.0': + resolution: {integrity: sha512-UtI4qm13wJIv9FB/0g6Hi1NijU7PuJEGetqGQxELlKEOmjubXa52EfKVA9IVOngL25m6U8i7jzluwLsHiN2uQQ==} + + '@manypkg/find-root@1.1.0': + resolution: {integrity: sha512-mki5uBvhHzO8kYYix/WRy2WX8S3B5wdVSc9D6KcU5lQNglP2yt58/VfLuAK49glRXChosY8ap2oJ1qgma3GUVA==} + + '@manypkg/get-packages@1.1.3': + resolution: {integrity: sha512-fo+QhuU3qE/2TQMQmbVMqaQ6EWbMhi4ABWP+O4AM1NqPBuy0OrApV5LO6BrrgnhtAHS2NH6RrVk9OL181tTi8A==} + + '@metamask/eth-sig-util@4.0.1': + resolution: {integrity: sha512-tghyZKLHZjcdlDqCA3gNZmLeR0XvOE9U1qoQO9ohyAZT6Pya+H9vkBPcsyXytmYLNgVoin7CKCmweo/R43V+tQ==} + engines: {node: '>=12.0.0'} + + '@noble/curves@1.2.0': + resolution: {integrity: sha512-oYclrNgRaM9SsBUBVbb8M6DTV7ZHRTKugureoYEncY5c65HOmRzvSiTE3y5CYaPYJA/GVkrhXEoF0M3Ya9PMnw==} + + '@noble/curves@1.3.0': + resolution: {integrity: sha512-t01iSXPuN+Eqzb4eBX0S5oubSqXbK/xXa1Ne18Hj8f9pStxztHCE2gfboSp/dZRLSqfuLpRK2nDXDK+W9puocA==} + + '@noble/hashes@1.2.0': + resolution: {integrity: sha512-FZfhjEDbT5GRswV3C6uvLPHMiVD6lQBmpoX5+eSiPaMTXte/IKqI5dykDxzZB/WBeK/CDuQRBWarPdi3FNY2zQ==} + + '@noble/hashes@1.3.2': + resolution: {integrity: sha512-MVC8EAQp7MvEcm30KWENFjgR+Mkmf+D189XJTkFIlwohU5hcBbn1ZkKq7KVTi2Hme3PMGF390DaL52beVrIihQ==} + engines: {node: '>= 16'} + + '@noble/hashes@1.3.3': + resolution: {integrity: sha512-V7/fPHgl+jsVPXqqeOzT8egNj2iBIVt+ECeMMG8TdcnTikP3oaBtUVqpT/gYCR68aEBJSF+XbYUxStjbFMqIIA==} + engines: {node: '>= 16'} + + '@noble/hashes@1.4.0': + resolution: {integrity: sha512-V1JJ1WTRUqHHrOSh597hURcMqVKVGL/ea3kv0gSnEdsEZ0/+VyPghM1lMNGc00z7CIQorSvbKpuJkxvuHbvdbg==} + engines: {node: '>= 16'} + + '@noble/secp256k1@1.7.1': + resolution: {integrity: sha512-hOUk6AyBFmqVrv7k5WAw/LpszxVbj9gGN4JRkIX52fdFAj1UA61KXmZDvqVEm+pOyec3+fIeZB02LYa/pWOArw==} + + '@nodelib/fs.scandir@2.1.5': + resolution: {integrity: sha512-vq24Bq3ym5HEQm2NKCr3yXDwjc7vTsEThRDnkp2DK9p1uqLR+DHurm/NOTo0KG7HYHU7eppKZj3MyqYuMBf62g==} + engines: {node: '>= 8'} + + '@nodelib/fs.stat@2.0.5': + resolution: {integrity: sha512-RkhPPp2zrqDAQA/2jNhnztcPAlv64XdhIp7a7454A5ovI7Bukxgt7MX7udwAu3zg1DcpPU0rz3VV1SeaqvY4+A==} + engines: {node: '>= 8'} + + '@nodelib/fs.walk@1.2.8': + resolution: {integrity: sha512-oGB+UxlgWcgQkgwo8GcEGwemoTFt3FIO9ababBmaGwXIoBKZ+GTy0pP185beGg7Llih/NSHSV2XAs1lnznocSg==} + engines: {node: '>= 8'} + + '@nomicfoundation/edr-darwin-arm64@0.3.8': + resolution: {integrity: sha512-eB0leCexS8sQEmfyD72cdvLj9djkBzQGP4wSQw6SNf2I4Sw4Cnzb3d45caG2FqFFjbvfqL0t+badUUIceqQuMw==} + engines: {node: '>= 18'} + + '@nomicfoundation/edr-darwin-x64@0.3.8': + resolution: {integrity: sha512-JksVCS1N5ClwVF14EvO25HCQ+Laljh/KRfHERMVAC9ZwPbTuAd/9BtKvToCBi29uCHWqsXMI4lxCApYQv2nznw==} + engines: {node: '>= 18'} + + '@nomicfoundation/edr-linux-arm64-gnu@0.3.8': + resolution: {integrity: sha512-raCE+fOeNXhVBLUo87cgsHSGvYYRB6arih4eG6B9KGACWK5Veebtm9xtKeiD8YCsdUlUfat6F7ibpeNm91fpsA==} + engines: {node: '>= 18'} + + '@nomicfoundation/edr-linux-arm64-musl@0.3.8': + resolution: {integrity: sha512-PwiDp4wBZWMCIy29eKkv8moTKRrpiSDlrc+GQMSZLhOAm8T33JKKXPwD/2EbplbhCygJDGXZdtEKl9x9PaH66A==} + engines: {node: '>= 18'} + + '@nomicfoundation/edr-linux-x64-gnu@0.3.8': + resolution: {integrity: sha512-6AcvA/XKoipGap5jJmQ9Y6yT7Uf39D9lu2hBcDCXnXbMcXaDGw4mn1/L4R63D+9VGZyu1PqlcJixCUZlGGIWlg==} + engines: {node: '>= 18'} + + '@nomicfoundation/edr-linux-x64-musl@0.3.8': + resolution: {integrity: sha512-cxb0sEmZjlwhYWO28sPsV64VDx31ekskhC1IsDXU1p9ntjHSJRmW4KEIqJ2O3QwJap/kLKfMS6TckvY10gjc6w==} + engines: {node: '>= 18'} + + '@nomicfoundation/edr-win32-x64-msvc@0.3.8': + resolution: {integrity: sha512-yVuVPqRRNLZk7TbBMkKw7lzCvI8XO8fNTPTYxymGadjr9rEGRuNTU1yBXjfJ59I1jJU/X2TSkRk1OFX0P5tpZQ==} + engines: {node: '>= 18'} + + '@nomicfoundation/edr@0.3.8': + resolution: {integrity: sha512-u2UJ5QpznSHVkZRh6ePWoeVb6kmPrrqh08gCnZ9FHlJV9CITqlrTQHJkacd+INH31jx88pTAJnxePE4XAiH5qg==} + engines: {node: '>= 18'} + + '@nomicfoundation/ethereumjs-block@5.0.4': + resolution: {integrity: sha512-AcyacJ9eX/uPEvqsPiB+WO1ymE+kyH48qGGiGV+YTojdtas8itUTW5dehDSOXEEItWGbbzEJ4PRqnQZlWaPvDw==} + engines: {node: '>=18'} + + '@nomicfoundation/ethereumjs-common@4.0.4': + resolution: {integrity: sha512-9Rgb658lcWsjiicr5GzNCjI1llow/7r0k50dLL95OJ+6iZJcVbi15r3Y0xh2cIO+zgX0WIHcbzIu6FeQf9KPrg==} + + '@nomicfoundation/ethereumjs-rlp@5.0.4': + resolution: {integrity: sha512-8H1S3s8F6QueOc/X92SdrA4RDenpiAEqMg5vJH99kcQaCy/a3Q6fgseo75mgWlbanGJXSlAPtnCeG9jvfTYXlw==} + engines: {node: '>=18'} + hasBin: true + + '@nomicfoundation/ethereumjs-trie@6.0.4': + resolution: {integrity: sha512-3nSwQiFMvr2VFe/aZUyinuohYvtytUqZCUCvIWcPJ/BwJH6oQdZRB42aNFBJ/8nAh2s3OcroWpBLskzW01mFKA==} + engines: {node: '>=18'} + + '@nomicfoundation/ethereumjs-tx@5.0.4': + resolution: {integrity: sha512-Xjv8wAKJGMrP1f0n2PeyfFCCojHd7iS3s/Ab7qzF1S64kxZ8Z22LCMynArYsVqiFx6rzYy548HNVEyI+AYN/kw==} + engines: {node: '>=18'} + peerDependencies: + c-kzg: ^2.1.2 + peerDependenciesMeta: + c-kzg: + optional: true + + '@nomicfoundation/ethereumjs-util@9.0.4': + resolution: {integrity: sha512-sLOzjnSrlx9Bb9EFNtHzK/FJFsfg2re6bsGqinFinH1gCqVfz9YYlXiMWwDM4C/L4ywuHFCYwfKTVr/QHQcU0Q==} + engines: {node: '>=18'} + peerDependencies: + c-kzg: ^2.1.2 + peerDependenciesMeta: + c-kzg: + optional: true + + '@nomicfoundation/hardhat-ignition-ethers@0.15.2': + resolution: {integrity: sha512-rXkEpzl4ZNGfrht6ZFO+37dQvL+byrJaX7pNeSFzdKKqhEe4oboRwDWaBohQO+pCn837Qh/86xwwOFoGEv2+hg==} + peerDependencies: + '@nomicfoundation/hardhat-ethers': ^3.0.4 + '@nomicfoundation/hardhat-ignition': ^0.15.2 + '@nomicfoundation/ignition-core': ^0.15.2 + ethers: ^6.7.0 + hardhat: ^2.18.0 + + '@nomicfoundation/hardhat-ignition-viem@0.15.2': + resolution: {integrity: sha512-iYmw9vJLXY1Tum0idnNsrsEmuvHsRDVJcudgzaMY6sA2nLLhJDSReK2gVZdtx3rdfJz4QRhG2+h2s3T+Rzv0TQ==} + peerDependencies: + '@nomicfoundation/hardhat-ignition': ^0.15.2 + '@nomicfoundation/hardhat-viem': ^2.0.0 + '@nomicfoundation/ignition-core': ^0.15.2 + hardhat: ^2.18.0 + viem: ^2.7.6 + + '@nomicfoundation/hardhat-ignition@0.15.2': + resolution: {integrity: sha512-tdI+D+GwP8qBt3/sq0hGKk46lAfKnNj3ZtqxrNinOnQUfc3f9qXgZDFqWT2JudsmuQcuHFbn1FQ1zoDvjUVjRA==} + peerDependencies: + '@nomicfoundation/hardhat-verify': ^2.0.1 + hardhat: ^2.18.0 + + '@nomicfoundation/ignition-core@0.15.2': + resolution: {integrity: sha512-6kchZOBh6zSl0BgG1bs6+ZbNYlGjeH22yi72mgeOa0oNOYFqCpka9a4FEYv0gfcphsMMmKTMlxadanf02ZoE4w==} + + '@nomicfoundation/ignition-ui@0.15.2': + resolution: {integrity: sha512-NEX2prbfLEm45KbnBS0imvSgQgwLTgmT8zD3rAPmcIFZx+tLG4lKKw99k6EgEwmKwBiaO2zQMmt+FNoF7xGaiQ==} + + '@nomicfoundation/solidity-analyzer-darwin-arm64@0.1.1': + resolution: {integrity: sha512-KcTodaQw8ivDZyF+D76FokN/HdpgGpfjc/gFCImdLUyqB6eSWVaZPazMbeAjmfhx3R0zm/NYVzxwAokFKgrc0w==} + engines: {node: '>= 10'} + cpu: [arm64] + os: [darwin] + + '@nomicfoundation/solidity-analyzer-darwin-x64@0.1.1': + resolution: {integrity: sha512-XhQG4BaJE6cIbjAVtzGOGbK3sn1BO9W29uhk9J8y8fZF1DYz0Doj8QDMfpMu+A6TjPDs61lbsmeYodIDnfveSA==} + engines: {node: '>= 10'} + cpu: [x64] + os: [darwin] + + '@nomicfoundation/solidity-analyzer-freebsd-x64@0.1.1': + resolution: {integrity: sha512-GHF1VKRdHW3G8CndkwdaeLkVBi5A9u2jwtlS7SLhBc8b5U/GcoL39Q+1CSO3hYqePNP+eV5YI7Zgm0ea6kMHoA==} + engines: {node: '>= 10'} + cpu: [x64] + os: [freebsd] + + '@nomicfoundation/solidity-analyzer-linux-arm64-gnu@0.1.1': + resolution: {integrity: sha512-g4Cv2fO37ZsUENQ2vwPnZc2zRenHyAxHcyBjKcjaSmmkKrFr64yvzeNO8S3GBFCo90rfochLs99wFVGT/0owpg==} + engines: {node: '>= 10'} + cpu: [arm64] + os: [linux] + + '@nomicfoundation/solidity-analyzer-linux-arm64-musl@0.1.1': + resolution: {integrity: sha512-WJ3CE5Oek25OGE3WwzK7oaopY8xMw9Lhb0mlYuJl/maZVo+WtP36XoQTb7bW/i8aAdHW5Z+BqrHMux23pvxG3w==} + engines: {node: '>= 10'} + cpu: [arm64] + os: [linux] + + '@nomicfoundation/solidity-analyzer-linux-x64-gnu@0.1.1': + resolution: {integrity: sha512-5WN7leSr5fkUBBjE4f3wKENUy9HQStu7HmWqbtknfXkkil+eNWiBV275IOlpXku7v3uLsXTOKpnnGHJYI2qsdA==} + engines: {node: '>= 10'} + cpu: [x64] + os: [linux] + + '@nomicfoundation/solidity-analyzer-linux-x64-musl@0.1.1': + resolution: {integrity: sha512-KdYMkJOq0SYPQMmErv/63CwGwMm5XHenEna9X9aB8mQmhDBrYrlAOSsIPgFCUSL0hjxE3xHP65/EPXR/InD2+w==} + engines: {node: '>= 10'} + cpu: [x64] + os: [linux] + + '@nomicfoundation/solidity-analyzer-win32-arm64-msvc@0.1.1': + resolution: {integrity: sha512-VFZASBfl4qiBYwW5xeY20exWhmv6ww9sWu/krWSesv3q5hA0o1JuzmPHR4LPN6SUZj5vcqci0O6JOL8BPw+APg==} + engines: {node: '>= 10'} + cpu: [arm64] + os: [win32] + + '@nomicfoundation/solidity-analyzer-win32-ia32-msvc@0.1.1': + resolution: {integrity: sha512-JnFkYuyCSA70j6Si6cS1A9Gh1aHTEb8kOTBApp/c7NRTFGNMH8eaInKlyuuiIbvYFhlXW4LicqyYuWNNq9hkpQ==} + engines: {node: '>= 10'} + cpu: [ia32] + os: [win32] + + '@nomicfoundation/solidity-analyzer-win32-x64-msvc@0.1.1': + resolution: {integrity: sha512-HrVJr6+WjIXGnw3Q9u6KQcbZCtk0caVWhCdFADySvRyUxJ8PnzlaP+MhwNE8oyT8OZ6ejHBRrrgjSqDCFXGirw==} + engines: {node: '>= 10'} + cpu: [x64] + os: [win32] + + '@nomicfoundation/solidity-analyzer@0.1.1': + resolution: {integrity: sha512-1LMtXj1puAxyFusBgUIy5pZk3073cNXYnXUpuNKFghHbIit/xZgbk0AokpUADbNm3gyD6bFWl3LRFh3dhVdREg==} + engines: {node: '>= 12'} + + '@nomiclabs/truffle-contract@4.5.10': + resolution: {integrity: sha512-nF/6InFV+0hUvutyFgsdOMCoYlr//2fJbRER4itxYtQtc4/O1biTwZIKRu+5l2J5Sq6LU2WX7vZHtDgQdhWxIQ==} + peerDependencies: + web3: ^1.2.1 + web3-core-helpers: ^1.2.1 + web3-core-promievent: ^1.2.1 + web3-eth-abi: ^1.2.1 + web3-utils: ^1.2.1 + + '@open-rpc/meta-schema@1.14.2': + resolution: {integrity: sha512-vD4Nbkrb7wYFRcSQf+j228LwOy1C6/KKpy5NADlpMElGrAWPRxhTa2yTi6xG+x88OHzg2+cydQ0GAD6o40KUcg==} + + '@open-rpc/schema-utils-js@1.16.1': + resolution: {integrity: sha512-8D4OgBnHDAv7JeaYZ5v7SL4yR0YLLO4WLTWtdR8vmqSqvX3SvPzSsGYv06zqm9z1Lhm563MAcuearrc8g9eJ4w==} + + '@open-rpc/typings@1.12.3': + resolution: {integrity: sha512-YxoC0WBMmxOAYNk9T6sFlOsy2H3YNnXJKFwkRb5GWg1ixOOEFm/3AYOciI/4Ieq08xNzjPhIz6XfC4u4fsmAWg==} + hasBin: true + + '@scure/base@1.1.6': + resolution: {integrity: sha512-ok9AWwhcgYuGG3Zfhyqg+zwl+Wn5uE+dwC0NV/2qQkx4dABbb/bx96vWu8NSj+BNjjSjno+JRYRjle1jV08k3g==} + + '@scure/bip32@1.1.5': + resolution: {integrity: sha512-XyNh1rB0SkEqd3tXcXMi+Xe1fvg+kUIcoRIEujP1Jgv7DqW2r9lg3Ah0NkFaCs9sTkQAQA8kw7xiRXzENi9Rtw==} + + '@scure/bip32@1.3.2': + resolution: {integrity: sha512-N1ZhksgwD3OBlwTv3R6KFEcPojl/W4ElJOeCZdi+vuI5QmTFwLq3OFf2zd2ROpKvxFdgZ6hUpb0dx9bVNEwYCA==} + + '@scure/bip32@1.3.3': + resolution: {integrity: sha512-LJaN3HwRbfQK0X1xFSi0Q9amqOgzQnnDngIt+ZlsBC3Bm7/nE7K0kwshZHyaru79yIVRv/e1mQAjZyuZG6jOFQ==} + + '@scure/bip39@1.1.1': + resolution: {integrity: sha512-t+wDck2rVkh65Hmv280fYdVdY25J9YeEUIgn2LG1WM6gxFkGzcksoDiUkWVpVp3Oex9xGC68JU2dSbUfwZ2jPg==} + + '@scure/bip39@1.2.1': + resolution: {integrity: sha512-Z3/Fsz1yr904dduJD0NpiyRHhRYHdcnyh73FZWiV+/qhWi83wNJ3NWolYqCEN+ZWsUz2TWwajJggcRE9r1zUYg==} + + '@scure/bip39@1.2.2': + resolution: {integrity: sha512-HYf9TUXG80beW+hGAt3TRM8wU6pQoYur9iNypTROm42dorCGmLnFe3eWjz3gOq6G62H2WRh0FCzAR1PI+29zIA==} + + '@sentry/core@5.30.0': + resolution: {integrity: sha512-TmfrII8w1PQZSZgPpUESqjB+jC6MvZJZdLtE/0hZ+SrnKhW3x5WlYLvTXZpcWePYBku7rl2wn1RZu6uT0qCTeg==} + engines: {node: '>=6'} + + '@sentry/hub@5.30.0': + resolution: {integrity: sha512-2tYrGnzb1gKz2EkMDQcfLrDTvmGcQPuWxLnJKXJvYTQDGLlEvi2tWz1VIHjunmOvJrB5aIQLhm+dcMRwFZDCqQ==} + engines: {node: '>=6'} + + '@sentry/minimal@5.30.0': + resolution: {integrity: sha512-BwWb/owZKtkDX+Sc4zCSTNcvZUq7YcH3uAVlmh/gtR9rmUvbzAA3ewLuB3myi4wWRAMEtny6+J/FN/x+2wn9Xw==} + engines: {node: '>=6'} + + '@sentry/node@5.30.0': + resolution: {integrity: sha512-Br5oyVBF0fZo6ZS9bxbJZG4ApAjRqAnqFFurMVJJdunNb80brh7a5Qva2kjhm+U6r9NJAB5OmDyPkA1Qnt+QVg==} + engines: {node: '>=6'} + + '@sentry/tracing@5.30.0': + resolution: {integrity: sha512-dUFowCr0AIMwiLD7Fs314Mdzcug+gBVo/+NCMyDw8tFxJkwWAKl7Qa2OZxLQ0ZHjakcj1hNKfCQJ9rhyfOl4Aw==} + engines: {node: '>=6'} + + '@sentry/types@5.30.0': + resolution: {integrity: sha512-R8xOqlSTZ+htqrfteCWU5Nk0CDN5ApUTvrlvBuiH1DyP6czDZ4ktbZB0hAgBlVcK0U+qpD3ag3Tqqpa5Q67rPw==} + engines: {node: '>=6'} + + '@sentry/utils@5.30.0': + resolution: {integrity: sha512-zaYmoH0NWWtvnJjC9/CBseXMtKHm/tm40sz3YfJRxeQjyzRqNQPgivpd9R/oDJCYj999mzdW382p/qi2ypjLww==} + engines: {node: '>=6'} + + '@sinclair/typebox@0.27.8': + resolution: {integrity: sha512-+Fj43pSMwJs4KRrH/938Uf+uAELIgVBmQzg/q1YG10djyfA3TnrU8N8XzqCh/okZdszqBQTZf96idMfE5lnwTA==} + + '@sindresorhus/is@4.6.0': + resolution: {integrity: sha512-t09vSN3MdfsyCHoFcTRCH/iUtG7OJ0CsjzB8cjAmKc/va/kIgeDI/TxsigdncE/4be734m0cvIYwNaV4i2XqAw==} + engines: {node: '>=10'} + + '@sinonjs/commons@1.8.6': + resolution: {integrity: sha512-Ky+XkAkqPZSm3NLBeUng77EBQl3cmeJhITaGHdYH8kjVB+aun3S4XBRti2zt17mtt0mIUDiNxYeoJm6drVvBJQ==} + + '@sinonjs/fake-timers@6.0.1': + resolution: {integrity: sha512-MZPUxrmFubI36XS1DI3qmI0YdN1gks62JtFZvxR67ljjSNCeK6U08Zx4msEWOXuofgqUt6zPHSi1H9fbjR/NRA==} + + '@sinonjs/samsam@5.3.1': + resolution: {integrity: sha512-1Hc0b1TtyfBu8ixF/tpfSHTVWKwCBLY4QJbkgnE7HcwyvT2xArDxb4K7dMgqRm3szI+LJbzmW/s4xxEhv6hwDg==} + + '@sinonjs/text-encoding@0.7.2': + resolution: {integrity: sha512-sXXKG+uL9IrKqViTtao2Ws6dy0znu9sOaP1di/jKGW1M6VssO8vlpXCQcpZ+jisQ1tTFAC5Jo/EOzFbggBagFQ==} + + '@solidity-parser/parser@0.14.5': + resolution: {integrity: sha512-6dKnHZn7fg/iQATVEzqyUOyEidbn05q7YA2mQ9hC0MMXhhV3/JrsxmFSYZAcr7j1yUP700LLhTruvJ3MiQmjJg==} + + '@solidity-parser/parser@0.16.2': + resolution: {integrity: sha512-PI9NfoA3P8XK2VBkK5oIfRgKDsicwDZfkVq9ZTBCQYGOP1N2owgY2dyLGyU5/J/hQs8KRk55kdmvTLjy3Mu3vg==} + + '@solidity-parser/parser@0.18.0': + resolution: {integrity: sha512-yfORGUIPgLck41qyN7nbwJRAx17/jAIXCTanHOJZhB6PJ1iAk/84b/xlsVKFSyNyLXIj0dhppoE0+CRws7wlzA==} + + '@szmarczak/http-timer@4.0.6': + resolution: {integrity: sha512-4BAffykYOgO+5nzBWYwE3W90sBgLJoUPRWWcL8wlyiM8IB8ipJz3UMJ9KXQd1RKQXpKp8Tutn80HZtWsu2u76w==} + engines: {node: '>=10'} + + '@szmarczak/http-timer@5.0.1': + resolution: {integrity: sha512-+PmQX0PiAYPMeVYe237LJAYvOMYW1j2rH5YROyS3b4CTVJum34HfRvKvAzozHAQG0TnHNdUfY9nCeUyRAs//cw==} + engines: {node: '>=14.16'} + + '@truffle/abi-utils@1.0.3': + resolution: {integrity: sha512-AWhs01HCShaVKjml7Z4AbVREr/u4oiWxCcoR7Cktm0mEvtT04pvnxW5xB/cI4znRkrbPdFQlFt67kgrAjesYkw==} + engines: {node: ^16.20 || ^18.16 || >=20} + deprecated: Package no longer supported. Contact Support at https://www.npmjs.com/support for more info. + + '@truffle/blockchain-utils@0.1.9': + resolution: {integrity: sha512-RHfumgbIVo68Rv9ofDYfynjnYZIfP/f1vZy4RoqkfYAO+fqfc58PDRzB1WAGq2U6GPuOnipOJxQhnqNnffORZg==} + engines: {node: ^16.20 || ^18.16 || >=20} + deprecated: Package no longer supported. Contact Support at https://www.npmjs.com/support for more info. + + '@truffle/codec@0.17.3': + resolution: {integrity: sha512-Ko/+dsnntNyrJa57jUD9u4qx9nQby+H4GsUO6yjiCPSX0TQnEHK08XWqBSg0WdmCH2+h0y1nr2CXSx8gbZapxg==} + engines: {node: ^16.20 || ^18.16 || >=20} + deprecated: Package no longer supported. Contact Support at https://www.npmjs.com/support for more info. + + '@truffle/compile-common@0.9.8': + resolution: {integrity: sha512-DTpiyo32t/YhLI1spn84D3MHYHrnoVqO+Gp7ZHrYNwDs86mAxtNiH5lsVzSb8cPgiqlvNsRCU9nm9R0YmKMTBQ==} + engines: {node: ^16.20 || ^18.16 || >=20} + deprecated: Package no longer supported. Contact Support at https://www.npmjs.com/support for more info. + + '@truffle/contract-schema@3.4.16': + resolution: {integrity: sha512-g0WNYR/J327DqtJPI70ubS19K1Fth/1wxt2jFqLsPmz5cGZVjCwuhiie+LfBde4/Mc9QR8G+L3wtmT5cyoBxAg==} + engines: {node: ^16.20 || ^18.16 || >=20} + deprecated: Package no longer supported. Contact Support at https://www.npmjs.com/support for more info. + + '@truffle/debug-utils@6.0.57': + resolution: {integrity: sha512-Q6oI7zLaeNLB69ixjwZk2UZEWBY6b2OD1sjLMGDKBGR7GaHYiw96GLR2PFgPH1uwEeLmV4N78LYaQCrDsHbNeA==} + engines: {node: ^16.20 || ^18.16 || >=20} + deprecated: Package no longer supported. Contact Support at https://www.npmjs.com/support for more info. + + '@truffle/error@0.1.1': + resolution: {integrity: sha512-sE7c9IHIGdbK4YayH4BC8i8qMjoAOeg6nUXUDZZp8wlU21/EMpaG+CLx+KqcIPyR+GSWIW3Dm0PXkr2nlggFDA==} + deprecated: Package no longer supported. Contact Support at https://www.npmjs.com/support for more info. + + '@truffle/error@0.2.2': + resolution: {integrity: sha512-TqbzJ0O8DHh34cu8gDujnYl4dUl6o2DE4PR6iokbybvnIm/L2xl6+Gv1VC+YJS45xfH83Yo3/Zyg/9Oq8/xZWg==} + engines: {node: ^16.20 || ^18.16 || >=20} + deprecated: Package no longer supported. Contact Support at https://www.npmjs.com/support for more info. + + '@truffle/interface-adapter@0.5.37': + resolution: {integrity: sha512-lPH9MDgU+7sNDlJSClwyOwPCfuOimqsCx0HfGkznL3mcFRymc1pukAR1k17zn7ErHqBwJjiKAZ6Ri72KkS+IWw==} + engines: {node: ^16.20 || ^18.16 || >=20} + deprecated: Package no longer supported. Contact Support at https://www.npmjs.com/support for more info. + + '@trufflesuite/chromafi@3.0.0': + resolution: {integrity: sha512-oqWcOqn8nT1bwlPPfidfzS55vqcIDdpfzo3HbU9EnUmcSTX+I8z0UyUFI3tZQjByVJulbzxHxUGS3ZJPwK/GPQ==} + + '@tsconfig/node10@1.0.11': + resolution: {integrity: sha512-DcRjDCujK/kCk/cUe8Xz8ZSpm8mS3mNNpta+jGCA6USEDfktlNvm1+IuZ9eTcDbNk41BHwpHHeW+N1lKCz4zOw==} + + '@tsconfig/node12@1.0.11': + resolution: {integrity: sha512-cqefuRsh12pWyGsIoBKJA9luFu3mRxCA+ORZvA4ktLSzIuCUtWVxGIuXigEwO5/ywWFMZ2QEGKWvkZG1zDMTag==} + + '@tsconfig/node14@1.0.3': + resolution: {integrity: sha512-ysT8mhdixWK6Hw3i1V2AeRqZ5WfXg1G43mqoYlM2nc6388Fq5jcXyr5mRsqViLx/GJYdoL0bfXD8nmF+Zn/Iow==} + + '@tsconfig/node16@1.0.4': + resolution: {integrity: sha512-vxhUy4J8lyeyinH7Azl1pdd43GJhZH/tP2weN8TntQblOY+A0XbT8DJk1/oCPuOOyg/Ja757rG0CgHcWC8OfMA==} + + '@typechain/ethers-v6@0.5.1': + resolution: {integrity: sha512-F+GklO8jBWlsaVV+9oHaPh5NJdd6rAKN4tklGfInX1Q7h0xPgVLP39Jl3eCulPB5qexI71ZFHwbljx4ZXNfouA==} + peerDependencies: + ethers: 6.x + typechain: ^8.3.2 + typescript: '>=4.7.0' + + '@typechain/hardhat@9.1.0': + resolution: {integrity: sha512-mtaUlzLlkqTlfPwB3FORdejqBskSnh+Jl8AIJGjXNAQfRQ4ofHADPl1+oU7Z3pAJzmZbUXII8MhOLQltcHgKnA==} + peerDependencies: + '@typechain/ethers-v6': ^0.5.1 + ethers: ^6.1.0 + hardhat: ^2.9.9 + typechain: ^8.3.2 + + '@types/async-eventemitter@0.2.4': + resolution: {integrity: sha512-2Bq61VD01kgLf1XkK2xPtoBcu7fgn/km5JyEX9v0BlG5VQBzA+BlF9umFk+8gR8S4+eK7MgDY2oyVZCu6ar3Jw==} + + '@types/bignumber.js@5.0.0': + resolution: {integrity: sha512-0DH7aPGCClywOFaxxjE6UwpN2kQYe9LwuDQMv+zYA97j5GkOMo8e66LYT+a8JYU7jfmUFRZLa9KycxHDsKXJCA==} + deprecated: This is a stub types definition for bignumber.js (https://github.com/MikeMcl/bignumber.js/). bignumber.js provides its own type definitions, so you don't need @types/bignumber.js installed! + + '@types/bn.js@4.11.6': + resolution: {integrity: sha512-pqr857jrp2kPuO9uRjZ3PwnJTjoQy+fcdxvBTvHm6dkmEL9q+hDD/2j/0ELOBPtPnS8LjCX0gI9nbl8lVkadpg==} + + '@types/bn.js@5.1.5': + resolution: {integrity: sha512-V46N0zwKRF5Q00AZ6hWtN0T8gGmDUaUzLWQvHFo5yThtVwK/VCenFY3wXVbOvNfajEpsTfQM4IN9k/d6gUVX3A==} + + '@types/cacheable-request@6.0.3': + resolution: {integrity: sha512-IQ3EbTzGxIigb1I3qPZc1rWJnH0BmSKv5QYTalEwweFvyBDLSAe24zP0le/hyi7ecGfZVlIVAg4BZqb8WBwKqw==} + + '@types/chai-as-promised@7.1.8': + resolution: {integrity: sha512-ThlRVIJhr69FLlh6IctTXFkmhtP3NpMZ2QGq69StYLyKZFp/HOp1VdKZj7RvfNWYYcJ1xlbLGLLWj1UvP5u/Gw==} + + '@types/chai@4.3.16': + resolution: {integrity: sha512-PatH4iOdyh3MyWtmHVFXLWCCIhUbopaltqddG9BzB+gMIzee2MJrvd+jouii9Z3wzQJruGWAm7WOMjgfG8hQlQ==} + + '@types/ci-info@2.0.0': + resolution: {integrity: sha512-5R2/MHILQLDCzTuhs1j4Qqq8AaKUf7Ma4KSSkCtc12+fMs47zfa34qhto9goxpyX00tQK1zxB885VCiawZ5Qhg==} + + '@types/concat-stream@1.6.1': + resolution: {integrity: sha512-eHE4cQPoj6ngxBZMvVf6Hw7Mh4jMW4U9lpGmS5GBPB9RYxlFg+CHaVN7ErNY4W9XfLIEn20b4VDYaIrbq0q4uA==} + + '@types/debug@4.1.12': + resolution: {integrity: sha512-vIChWdVG3LG1SMxEvI/AK+FWJthlrqlTu7fbrlywTkkaONwk/UAGaULXRlf8vkzFBLVm0zkMdCquhL5aOjhXPQ==} + + '@types/events@3.0.3': + resolution: {integrity: sha512-trOc4AAUThEz9hapPtSd7wf5tiQKvTtu5b371UxXdTuqzIh0ArcRspRP0i0Viu+LXstIQ1z96t1nsPxT9ol01g==} + + '@types/find-up@2.1.1': + resolution: {integrity: sha512-60LC501bQRN9/3yfVaEEMd7IndaufffL56PBRAejPpUrY304Ps1jfnjNqPw5jmM5R8JHWiKBAe5IHzNcPV41AA==} + + '@types/form-data@0.0.33': + resolution: {integrity: sha512-8BSvG1kGm83cyJITQMZSulnl6QV8jqAGreJsc5tPu1Jq0vTSOiY/k24Wx82JRpWwZSqrala6sd5rWi6aNXvqcw==} + + '@types/fs-extra@5.1.0': + resolution: {integrity: sha512-AInn5+UBFIK9FK5xc9yP5e3TQSPNNgjHByqYcj9g5elVBnDQcQL7PlO1CIRy2gWlbwK7UPYqi7vRvFA44dCmYQ==} + + '@types/glob@7.2.0': + resolution: {integrity: sha512-ZUxbzKl0IfJILTS6t7ip5fQQM/J3TJYubDm3nMbgubNNYS62eXeUpoLUC8/7fJNiFYHTrGPQn7hspDUzIHX3UA==} + + '@types/http-cache-semantics@4.0.4': + resolution: {integrity: sha512-1m0bIFVc7eJWyve9S0RnuRgcQqF/Xd5QsUZAZeQFr1Q3/p9JWoQQEqmVy+DPTNpGXwhgIetAoYF8JSc33q29QA==} + + '@types/json-schema@7.0.15': + resolution: {integrity: sha512-5+fP8P8MFNC+AyZCDxrB2pkZFPGzqQWUzpSeuuVLvm8VMcorNYavBqoFcxK8bQz4Qsbn4oUEEem4wDLfcysGHA==} + + '@types/json5@0.0.29': + resolution: {integrity: sha512-dRLjCWHYg4oaA77cxO64oO+7JwCwnIzkZPdrrC71jQmQtlhM556pwKo5bUzqvZndkVbeFLIIi+9TC40JNF5hNQ==} + + '@types/keccak@3.0.4': + resolution: {integrity: sha512-hdnkmbie7tE0yXnQQvlIOqCyjEsoXDVEZ3ACqO+F305XgUOW4Z9ElWdogCXXRAW/khnZ7GxM0t/BGB5bORKt/g==} + + '@types/keyv@3.1.4': + resolution: {integrity: sha512-BQ5aZNSCpj7D6K2ksrRCTmKRLEpnPvWDiLPfoGyhZ++8YtiK9d/3DBKPJgry359X/P1PfruyYwvnvwFjuEiEIg==} + + '@types/lodash.clonedeep@4.5.9': + resolution: {integrity: sha512-19429mWC+FyaAhOLzsS8kZUsI+/GmBAQ0HFiCPsKGU+7pBXOQWhyrY6xNNDwUSX8SMZMJvuFVMF9O5dQOlQK9Q==} + + '@types/lodash.isequal@4.5.8': + resolution: {integrity: sha512-uput6pg4E/tj2LGxCZo9+y27JNyB2OZuuI/T5F+ylVDYuqICLG2/ktjxx0v6GvVntAf8TvEzeQLcV0ffRirXuA==} + + '@types/lodash.memoize@4.1.9': + resolution: {integrity: sha512-glY1nQuoqX4Ft8Uk+KfJudOD7DQbbEDF6k9XpGncaohW3RW4eSWBlx6AA0fZCrh40tZcQNH4jS/Oc59J6Eq+aw==} + + '@types/lodash@4.17.1': + resolution: {integrity: sha512-X+2qazGS3jxLAIz5JDXDzglAF3KpijdhFxlf/V1+hEsOUc+HnWi81L/uv/EvGuV90WY+7mPGFCUDGfQC3Gj95Q==} + + '@types/lru-cache@5.1.1': + resolution: {integrity: sha512-ssE3Vlrys7sdIzs5LOxCzTVMsU7i9oa/IaW92wF32JFb3CVczqOkru2xspuKczHEbG3nvmPY7IFqVmGGHdNbYw==} + + '@types/minimatch@5.1.2': + resolution: {integrity: sha512-K0VQKziLUWkVKiRVrx4a40iPaxTUefQmjtkQofBkYRcoaaL/8rhwDWww9qWbrgicNOgnpIsMxyNIUM4+n6dUIA==} + + '@types/minimist@1.2.5': + resolution: {integrity: sha512-hov8bUuiLiyFPGyFPE1lwWhmzYbirOXQNNo40+y3zow8aFVTeyn3VWL0VFFfdNddA8S4Vf0Tc062rzyNr7Paag==} + + '@types/mocha@10.0.6': + resolution: {integrity: sha512-dJvrYWxP/UcXm36Qn36fxhUKu8A/xMRXVT2cliFF1Z7UA9liG5Psj3ezNSZw+5puH2czDXRLcXQxf8JbJt0ejg==} + + '@types/ms@0.7.34': + resolution: {integrity: sha512-nG96G3Wp6acyAgJqGasjODb+acrI7KltPiRxzHPXnP3NgI28bpQDRv53olbqGXbfcgF5aiiHmO3xpwEpS5Ld9g==} + + '@types/node@10.17.60': + resolution: {integrity: sha512-F0KIgDJfy2nA3zMLmWGKxcH2ZVEtCZXHHdOQs2gSaQ27+lNeEfGxzkIw90aXswATX7AZ33tahPbzy6KAfUreVw==} + + '@types/node@12.20.55': + resolution: {integrity: sha512-J8xLz7q2OFulZ2cyGTLE1TbbZcjpno7FaN6zdJNrgAdrJ+DZzh/uFR6YrTb4C+nXakvud8Q4+rbhoIWlYQbUFQ==} + + '@types/node@18.15.13': + resolution: {integrity: sha512-N+0kuo9KgrUQ1Sn/ifDXsvg0TTleP7rIy4zOBGECxAljqvqfqpTfzx0Q1NUedOixRMBfe2Whhb056a42cWs26Q==} + + '@types/node@18.19.33': + resolution: {integrity: sha512-NR9+KrpSajr2qBVp/Yt5TU/rp+b5Mayi3+OlMlcg2cVCfRmcG5PWZ7S4+MG9PZ5gWBoc9Pd0BKSRViuBCRPu0A==} + + '@types/node@8.10.66': + resolution: {integrity: sha512-tktOkFUA4kXx2hhhrB8bIFb5TbwzS4uOhKEmwiD+NoiL0qtP2OQ9mFldbgD4dV1djrlBYP6eBuQZiWjuHUpqFw==} + + '@types/normalize-package-data@2.4.4': + resolution: {integrity: sha512-37i+OaWTh9qeK4LSHPsyRC7NahnGotNuZvjLSgcPzblpHB3rrCJxAOgI5gCdKm7coonsaX1Of0ILiTcnZjbfxA==} + + '@types/pbkdf2@3.1.2': + resolution: {integrity: sha512-uRwJqmiXmh9++aSu1VNEn3iIxWOhd8AHXNSdlaLfdAAdSTY9jYVeGWnzejM3dvrkbqE3/hyQkQQ29IFATEGlew==} + + '@types/prettier@2.7.3': + resolution: {integrity: sha512-+68kP9yzs4LMp7VNh8gdzMSPZFL44MLGqiHWvttYJe+6qnuVr4Ek9wSBQoveqY/r+LwjCcU29kNVkidwim+kYA==} + + '@types/qs@6.9.15': + resolution: {integrity: sha512-uXHQKES6DQKKCLh441Xv/dwxOq1TVS3JPUMlEqoEglvlhR6Mxnlew/Xq/LRVHpLyk7iK3zODe1qYHIMltO7XGg==} + + '@types/readable-stream@2.3.15': + resolution: {integrity: sha512-oM5JSKQCcICF1wvGgmecmHldZ48OZamtMxcGGVICOJA8o8cahXC1zEVAif8iwoc5j8etxFaRFnf095+CDsuoFQ==} + + '@types/resolve@1.20.6': + resolution: {integrity: sha512-A4STmOXPhMUtHH+S6ymgE2GiBSMqf4oTvcQZMcHzokuTLVYzXTB8ttjcgxOVaAp2lGwEdzZ0J+cRbbeevQj1UQ==} + + '@types/responselike@1.0.3': + resolution: {integrity: sha512-H/+L+UkTV33uf49PH5pCAUBVPNj2nDBXTN+qS1dOwyyg24l3CcicicCA7ca+HMvJBZcFgl5r8e+RR6elsb4Lyw==} + + '@types/secp256k1@4.0.6': + resolution: {integrity: sha512-hHxJU6PAEUn0TP4S/ZOzuTUvJWuZ6eIKeNKb5RBpODvSl6hp1Wrw4s7ATY50rklRCScUDpHzVA/DQdSjJ3UoYQ==} + + '@types/semver@6.2.7': + resolution: {integrity: sha512-blctEWbzUFzQx799RZjzzIdBJOXmE37YYEyDtKkx5Dg+V7o/zyyAxLPiI98A2jdTtDgxZleMdfV+7p8WbRJ1OQ==} + + '@types/semver@7.5.8': + resolution: {integrity: sha512-I8EUhyrgfLrcTkzV3TSsGyl1tSuPrEDzr0yd5m90UgNxQkyDXULk3b6MlQqTCpZpNtWe1K0hzclnZkTcLBe2UQ==} + + '@types/sinon-chai@3.2.12': + resolution: {integrity: sha512-9y0Gflk3b0+NhQZ/oxGtaAJDvRywCa5sIyaVnounqLvmf93yBF4EgIRspePtkMs3Tr844nCclYMlcCNmLCvjuQ==} + + '@types/sinon@9.0.11': + resolution: {integrity: sha512-PwP4UY33SeeVKodNE37ZlOsR9cReypbMJOhZ7BVE0lB+Hix3efCOxiJWiE5Ia+yL9Cn2Ch72EjFTRze8RZsNtg==} + + '@types/sinonjs__fake-timers@8.1.5': + resolution: {integrity: sha512-mQkU2jY8jJEF7YHjHvsQO8+3ughTL1mcnn96igfhONmR+fUPSKIkefQYpSe8bsly2Ep7oQbn/6VG5/9/0qcArQ==} + + '@types/uuid@8.3.4': + resolution: {integrity: sha512-c/I8ZRb51j+pYGAu5CrFMRxqZ2ke4y2grEBO5AUjgSkSk+qT2Ea+OdWElz/OiMf5MNpn2b17kuVBwZLQJXzihw==} + + '@types/w3c-web-usb@1.0.10': + resolution: {integrity: sha512-CHgUI5kTc/QLMP8hODUHhge0D4vx+9UiAwIGiT0sTy/B2XpdX1U5rJt6JSISgr6ikRT7vxV9EVAFeYZqUnl1gQ==} + + '@types/ws@7.4.7': + resolution: {integrity: sha512-JQbbmxZTZehdc2iszGKs5oC3NFnjeay7mtAWrdt7qNtAVK0g19muApzAy4bm9byz79xa2ZnO/BOBC2R8RC5Lww==} + + '@types/ws@8.5.3': + resolution: {integrity: sha512-6YOoWjruKj1uLf3INHH7D3qTXwFfEsg1kf3c0uDdSBJwfa/llkwIjrAGV7j7mVgGNbzTQ3HiHKKDXl6bJPD97w==} + + '@typescript-eslint/eslint-plugin@5.61.0': + resolution: {integrity: sha512-A5l/eUAug103qtkwccSCxn8ZRwT+7RXWkFECdA4Cvl1dOlDUgTpAOfSEElZn2uSUxhdDpnCdetrf0jvU4qrL+g==} + engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0} + peerDependencies: + '@typescript-eslint/parser': ^5.0.0 + eslint: ^6.0.0 || ^7.0.0 || ^8.0.0 + typescript: '*' + peerDependenciesMeta: + typescript: + optional: true + + '@typescript-eslint/parser@5.61.0': + resolution: {integrity: sha512-yGr4Sgyh8uO6fSi9hw3jAFXNBHbCtKKFMdX2IkT3ZqpKmtAq3lHS4ixB/COFuAIJpwl9/AqF7j72ZDWYKmIfvg==} + engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0} + peerDependencies: + eslint: ^6.0.0 || ^7.0.0 || ^8.0.0 + typescript: '*' + peerDependenciesMeta: + typescript: + optional: true + + '@typescript-eslint/scope-manager@5.61.0': + resolution: {integrity: sha512-W8VoMjoSg7f7nqAROEmTt6LoBpn81AegP7uKhhW5KzYlehs8VV0ZW0fIDVbcZRcaP3aPSW+JZFua+ysQN+m/Nw==} + engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0} + + '@typescript-eslint/scope-manager@5.62.0': + resolution: {integrity: sha512-VXuvVvZeQCQb5Zgf4HAxc04q5j+WrNAtNh9OwCsCgpKqESMTu3tF/jhZ3xG6T4NZwWl65Bg8KuS2uEvhSfLl0w==} + engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0} + + '@typescript-eslint/type-utils@5.61.0': + resolution: {integrity: sha512-kk8u//r+oVK2Aj3ph/26XdH0pbAkC2RiSjUYhKD+PExemG4XSjpGFeyZ/QM8lBOa7O8aGOU+/yEbMJgQv/DnCg==} + engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0} + peerDependencies: + eslint: '*' + typescript: '*' + peerDependenciesMeta: + typescript: + optional: true + + '@typescript-eslint/types@5.61.0': + resolution: {integrity: sha512-ldyueo58KjngXpzloHUog/h9REmHl59G1b3a5Sng1GfBo14BkS3ZbMEb3693gnP1k//97lh7bKsp6/V/0v1veQ==} + engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0} + + '@typescript-eslint/types@5.62.0': + resolution: {integrity: sha512-87NVngcbVXUahrRTqIK27gD2t5Cu1yuCXxbLcFtCzZGlfyVWWh8mLHkoxzjsB6DDNnvdL+fW8MiwPEJyGJQDgQ==} + engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0} + + '@typescript-eslint/typescript-estree@5.61.0': + resolution: {integrity: sha512-Fud90PxONnnLZ36oR5ClJBLTLfU4pIWBmnvGwTbEa2cXIqj70AEDEmOmpkFComjBZ/037ueKrOdHuYmSFVD7Rw==} + engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0} + peerDependencies: + typescript: '*' + peerDependenciesMeta: + typescript: + optional: true + + '@typescript-eslint/typescript-estree@5.62.0': + resolution: {integrity: sha512-CmcQ6uY7b9y694lKdRB8FEel7JbU/40iSAPomu++SjLMntB+2Leay2LO6i8VnJk58MtE9/nQSFIH6jpyRWyYzA==} + engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0} + peerDependencies: + typescript: '*' + peerDependenciesMeta: + typescript: + optional: true + + '@typescript-eslint/utils@5.61.0': + resolution: {integrity: sha512-mV6O+6VgQmVE6+xzlA91xifndPW9ElFW8vbSF0xCT/czPXVhwDewKila1jOyRwa9AE19zKnrr7Cg5S3pJVrTWQ==} + engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0} + peerDependencies: + eslint: ^6.0.0 || ^7.0.0 || ^8.0.0 + + '@typescript-eslint/utils@5.62.0': + resolution: {integrity: sha512-n8oxjeb5aIbPFEtmQxQYOLI0i9n5ySBEY/ZEHHZqKQSFnxio1rv6dthascc9dLuwrL0RC5mPCxB7vnAVGAYWAQ==} + engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0} + peerDependencies: + eslint: ^6.0.0 || ^7.0.0 || ^8.0.0 + + '@typescript-eslint/visitor-keys@5.61.0': + resolution: {integrity: sha512-50XQ5VdbWrX06mQXhy93WywSFZZGsv3EOjq+lqp6WC2t+j3mb6A9xYVdrRxafvK88vg9k9u+CT4l6D8PEatjKg==} + engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0} + + '@typescript-eslint/visitor-keys@5.62.0': + resolution: {integrity: sha512-07ny+LHRzQXepkGg6w0mFY41fVUNBrL2Roj/++7V1txKugfjm/Ci/qSND03r2RhlJhJYMcTn9AhhSSqQp0Ysyw==} + engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0} + + '@ungap/structured-clone@1.2.0': + resolution: {integrity: sha512-zuVdFrMJiuCDQUMCzQaD6KL28MjnqqN8XnAqiEq9PNm/hCPTSGfrXCOfwj1ow4LFb/tNymJPwsNbVePc1xFqrQ==} + + abbrev@1.0.9: + resolution: {integrity: sha512-LEyx4aLEC3x6T0UguF6YILf+ntvmOaWsVfENmIW0E9H09vKlLDGelMjjSm0jkDHALj8A8quZ/HapKNigzwge+Q==} + + abitype@0.7.1: + resolution: {integrity: sha512-VBkRHTDZf9Myaek/dO3yMmOzB/y2s3Zo6nVU7yaw1G+TvCHAjwaJzNGN9yo4K5D8bU/VZXKP1EJpRhFr862PlQ==} + peerDependencies: + typescript: '>=4.9.4' + zod: ^3 >=3.19.1 + peerDependenciesMeta: + zod: + optional: true + + abitype@0.9.10: + resolution: {integrity: sha512-FIS7U4n7qwAT58KibwYig5iFG4K61rbhAqaQh/UWj8v1Y8mjX3F8TC9gd8cz9yT1TYel9f8nS5NO5kZp2RW0jQ==} + peerDependencies: + typescript: '>=5.0.4' + zod: ^3 >=3.22.0 + peerDependenciesMeta: + typescript: + optional: true + zod: + optional: true + + abitype@1.0.0: + resolution: {integrity: sha512-NMeMah//6bJ56H5XRj8QCV4AwuW6hB6zqz2LnhhLdcWVQOsXki6/Pn3APeqxCma62nXIcmZWdu1DlHWS74umVQ==} + peerDependencies: + typescript: '>=5.0.4' + zod: ^3 >=3.22.0 + peerDependenciesMeta: + typescript: + optional: true + zod: + optional: true + + abortcontroller-polyfill@1.7.5: + resolution: {integrity: sha512-JMJ5soJWP18htbbxJjG7bG6yuI6pRhgJ0scHHTfkUjf6wjP912xZWvM+A4sJK3gqd9E8fcPbDnOefbA9Th/FIQ==} + + accepts@1.3.8: + resolution: {integrity: sha512-PYAthTa2m2VKxuvSD3DPC/Gy+U+sOA1LAuT8mkmRuvw+NACSaeXEQ+NHcVF7rONl6qcaxV3Uuemwawk+7+SJLw==} + engines: {node: '>= 0.6'} + + acorn-jsx@5.3.2: + resolution: {integrity: sha512-rq9s+JNhf0IChjtDXxllJ7g41oZk5SlXtp0LHwyA5cejwn7vKmKp4pPri6YEePv2PU65sAsegbXtIinmDFDXgQ==} + peerDependencies: + acorn: ^6.0.0 || ^7.0.0 || ^8.0.0 + + acorn-walk@8.3.2: + resolution: {integrity: sha512-cjkyv4OtNCIeqhHrfS81QWXoCBPExR/J62oyEqepVw8WaQeSqpW2uhuLPh1m9eWhDuOo/jUXVTlifvesOWp/4A==} + engines: {node: '>=0.4.0'} + + acorn@8.11.3: + resolution: {integrity: sha512-Y9rRfJG5jcKOE0CLisYbojUjIrIEE7AGMzA/Sm4BslANhbS+cDMpgBdcPT91oJ7OuJ9hYJBx59RjbhxVnrF8Xg==} + engines: {node: '>=0.4.0'} + hasBin: true + + address@1.2.2: + resolution: {integrity: sha512-4B/qKCfeE/ODUaAUpSwfzazo5x29WD4r3vXiWsB7I2mSDAihwEqKO+g8GELZUQSSAo5e1XTYh3ZVfLyxBc12nA==} + engines: {node: '>= 10.0.0'} + + adm-zip@0.4.16: + resolution: {integrity: sha512-TFi4HBKSGfIKsK5YCkKaaFG2m4PEDyViZmEwof3MTIgzimHLto6muaHVpbrljdIvIrFZzEq/p4nafOeLcYegrg==} + engines: {node: '>=0.3.0'} + + aes-js@3.0.0: + resolution: {integrity: sha512-H7wUZRn8WpTq9jocdxQ2c8x2sKo9ZVmzfRE13GiNJXfp7NcKYEdvl3vspKjXox6RIG2VtaRe4JFvxG4rqp2Zuw==} + + aes-js@4.0.0-beta.5: + resolution: {integrity: sha512-G965FqalsNyrPqgEGON7nIx1e/OVENSgiEIzyC63haUMuvNnwIgIjMs52hlTCKhkBny7A2ORNlfY9Zu+jmGk1Q==} + + agent-base@6.0.2: + resolution: {integrity: sha512-RZNwNclF7+MS/8bDg70amg32dyeZGZxiDuQmZxKLAlQjr3jGyLx+4Kkk58UO7D2QdgFIQCovuSuZESne6RG6XQ==} + engines: {node: '>= 6.0.0'} + + aggregate-error@3.1.0: + resolution: {integrity: sha512-4I7Td01quW/RpocfNayFdFVk1qSuoh0E7JrbRJ16nH01HhKFQ88INq9Sd+nd72zqRySlr9BmDA8xlEJ6vJMrYA==} + engines: {node: '>=8'} + + ajv@5.5.2: + resolution: {integrity: sha512-Ajr4IcMXq/2QmMkEmSvxqfLN5zGmJ92gHXAeOXq1OekoH2rfDNsgdDoL2f7QaRCy7G/E6TpxBVdRuNraMztGHw==} + + ajv@6.12.6: + resolution: {integrity: sha512-j3fVLgvTo527anyYyJOGTYJbG+vnnQYvE0m5mmkc1TK+nxAppkCLMIL0aZ4dblVCNoGShhm+kzE4ZUykBoMg4g==} + + ajv@8.13.0: + resolution: {integrity: sha512-PRA911Blj99jR5RMeTunVbNXMF6Lp4vZXnk5GQjcnUWUTsrXtekg/pnmFFI2u/I36Y/2bITGS30GZCXei6uNkA==} + + amdefine@1.0.1: + resolution: {integrity: sha512-S2Hw0TtNkMJhIabBwIojKL9YHO5T0n5eNqWJ7Lrlel/zDbftQpxpapi8tZs3X1HWa+u+QeydGmzzNU0m09+Rcg==} + engines: {node: '>=0.4.2'} + + ansi-align@3.0.1: + resolution: {integrity: sha512-IOfwwBF5iczOjp/WeY4YxyjqAFMQoZufdQWDd19SEExbVLNXqvpzSJ/M7Za4/sCPmQ0+GRquoA7bGcINcxew6w==} + + ansi-colors@4.1.1: + resolution: {integrity: sha512-JoX0apGbHaUJBNl6yF+p6JAFYZ666/hhCGKN5t9QFjbJQKUU/g8MNbFDbvfrgKXvI1QpZplPOnwIo99lX/AAmA==} + engines: {node: '>=6'} + + ansi-colors@4.1.3: + resolution: {integrity: sha512-/6w/C21Pm1A7aZitlI5Ni/2J6FFQN8i1Cvz3kHABAAbw93v/NlvKdVOqz7CCWz/3iv/JplRSEEZ83XION15ovw==} + engines: {node: '>=6'} + + ansi-escapes@4.3.2: + resolution: {integrity: sha512-gKXj5ALrKWQLsYG9jlTRmR/xKluxHV+Z9QEwNIgCfM1/uwPMCuzVVnh5mwTd+OuBZcwSIMbqssNWRm1lE51QaQ==} + engines: {node: '>=8'} + + ansi-regex@2.1.1: + resolution: {integrity: sha512-TIGnTpdo+E3+pCyAluZvtED5p5wCqLdezCyhPZzKPcxvFplEt4i+W7OONCKgeZFT3+y5NZZfOOS/Bdcanm1MYA==} + engines: {node: '>=0.10.0'} + + ansi-regex@3.0.1: + resolution: {integrity: sha512-+O9Jct8wf++lXxxFc4hc8LsjaSq0HFzzL7cVsw8pRDIPdjKD2mT4ytDZlLuSBZ4cLKZFXIrMGO7DbQCtMJJMKw==} + engines: {node: '>=4'} + + ansi-regex@5.0.1: + resolution: {integrity: sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ==} + engines: {node: '>=8'} + + ansi-styles@1.0.0: + resolution: {integrity: sha512-3iF4FIKdxaVYT3JqQuY3Wat/T2t7TRbbQ94Fu50ZUCbLy4TFbTzr90NOHQodQkNqmeEGCw8WbeP78WNi6SKYUA==} + engines: {node: '>=0.8.0'} + + ansi-styles@3.2.1: + resolution: {integrity: sha512-VT0ZI6kZRdTh8YyJw3SMbYm/u+NqfsAxEpWO0Pf9sq8/e94WxxOpPKx9FR1FlyCtOVDNOQ+8ntlqFxiRc+r5qA==} + engines: {node: '>=4'} + + ansi-styles@4.3.0: + resolution: {integrity: sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==} + engines: {node: '>=8'} + + ansi-styles@5.2.0: + resolution: {integrity: sha512-Cxwpt2SfTzTtXcfOlzGEee8O+c+MmUgGrNiBcXnuWxuFJHe6a5Hz7qwhwe5OgaSYI0IJvkLqWX1ASG+cJOkEiA==} + engines: {node: '>=10'} + + antlr4@4.13.1: + resolution: {integrity: sha512-kiXTspaRYvnIArgE97z5YVVf/cDVQABr3abFRR6mE7yesLMkgu4ujuyV/sgxafQ8wgve0DJQUJ38Z8tkgA2izA==} + engines: {node: '>=16'} + + antlr4@4.8.0: + resolution: {integrity: sha512-en/MxQ4OkPgGJQ3wD/muzj1uDnFSzdFIhc2+c6bHZokWkuBb6RRvFjpWhPxWLbgQvaEzldJZ0GSQpfSAaE3hqg==} + + antlr4ts@0.5.0-alpha.4: + resolution: {integrity: sha512-WPQDt1B74OfPv/IMS2ekXAKkTZIHl88uMetg6q3OTqgFxZ/dxDXI0EWLyZid/1Pe6hTftyg5N7gel5wNAGxXyQ==} + + any-promise@1.3.0: + resolution: {integrity: sha512-7UvmKalWRt1wgjL1RrGxoSJW/0QZFIegpeGvZG9kjp8vrRu55XTHbwnqq2GpXm9uLbcuhxm3IqX9OB4MZR1b2A==} + + anymatch@3.1.3: + resolution: {integrity: sha512-KMReFUr0B4t+D+OBkjR3KYqvocp2XaSzO55UcB6mgQMd3KbcE+mWTyvVV7D/zsdEbNnV6acZUutkiHQXvTr1Rw==} + engines: {node: '>= 8'} + + append-transform@2.0.0: + resolution: {integrity: sha512-7yeyCEurROLQJFv5Xj4lEGTy0borxepjFv1g22oAdqFu//SrAlDl1O1Nxx15SH1RoliUml6p8dwJW9jvZughhg==} + engines: {node: '>=8'} + + archy@1.0.0: + resolution: {integrity: sha512-Xg+9RwCg/0p32teKdGMPTPnVXKD0w3DfHnFTficozsAgsvq2XenPJq/MYpzzQ/v8zrOyJn6Ds39VA4JIDwFfqw==} + + arg@4.1.3: + resolution: {integrity: sha512-58S9QDqG0Xx27YwPSt9fJxivjYl432YCwfDMfZ+71RAqUrZef7LrKQZ3LHLOwCS4FLNBplP533Zx895SeOCHvA==} + + argparse@1.0.10: + resolution: {integrity: sha512-o5Roy6tNG4SL/FOkCAN6RzjiakZS25RLYFrcMttJqbdd8BWrnA+fGz57iN5Pb06pvBGvl5gQ0B48dJlslXvoTg==} + + argparse@2.0.1: + resolution: {integrity: sha512-8+9WqebbFzpX9OR+Wa6O29asIogeRMzcGtAINdpMHHyAg10f05aSFVBbcEqGf/PXw1EjAZ+q2/bEBg3DvurK3Q==} + + array-back@3.1.0: + resolution: {integrity: sha512-TkuxA4UCOvxuDK6NZYXCalszEzj+TLszyASooky+i742l9TqsOdYCMJJupxRic61hwquNtppB3hgcuq9SVSH1Q==} + engines: {node: '>=6'} + + array-back@4.0.2: + resolution: {integrity: sha512-NbdMezxqf94cnNfWLL7V/im0Ub+Anbb0IoZhvzie8+4HJ4nMQuzHuy49FkGYCJK2yAloZ3meiB6AVMClbrI1vg==} + engines: {node: '>=8'} + + array-buffer-byte-length@1.0.1: + resolution: {integrity: sha512-ahC5W1xgou+KTXix4sAO8Ki12Q+jf4i0+tmk3sC+zgcynshkHxzpXdImBehiUYKKKDwvfFiJl1tZt6ewscS1Mg==} + engines: {node: '>= 0.4'} + + array-flatten@1.1.1: + resolution: {integrity: sha512-PCVAQswWemu6UdxsDFFX/+gVeYqKAod3D3UVm91jHwynguOwAvYPhx8nNlM++NqRcK6CxxpUafjmhIdKiHibqg==} + + array-includes@3.1.8: + resolution: {integrity: sha512-itaWrbYbqpGXkGhZPGUulwnhVf5Hpy1xiCFsGqyIGglbBxmG5vSjxQen3/WGOjPpNEv1RtBLKxbmVXm8HpJStQ==} + engines: {node: '>= 0.4'} + + array-union@2.1.0: + resolution: {integrity: sha512-HGyxoOTYUyCM6stUe6EJgnd4EoewAI7zMdfqO+kGjnlZmBDz/cR5pf8r/cR4Wq60sL/p0IkcjUEEPwS3GFrIyw==} + engines: {node: '>=8'} + + array-uniq@1.0.3: + resolution: {integrity: sha512-MNha4BWQ6JbwhFhj03YK552f7cb3AzoE8SzeljgChvL1dl3IcvggXVz1DilzySZkCja+CXuZbdW7yATchWn8/Q==} + engines: {node: '>=0.10.0'} + + array.prototype.flat@1.3.2: + resolution: {integrity: sha512-djYB+Zx2vLewY8RWlNCUdHjDXs2XOgm602S9E7P/UpHgfeHL00cRiIF+IN/G/aUJ7kGPb6yO/ErDI5V2s8iycA==} + engines: {node: '>= 0.4'} + + array.prototype.flatmap@1.3.2: + resolution: {integrity: sha512-Ewyx0c9PmpcsByhSW4r+9zDU7sGjFc86qf/kKtuSCRdhfbk0SNLLkaT5qvcHnRGgc5NP/ly/y+qkXkqONX54CQ==} + engines: {node: '>= 0.4'} + + arraybuffer.prototype.slice@1.0.3: + resolution: {integrity: sha512-bMxMKAjg13EBSVscxTaYA4mRc5t1UAXa2kXiGTNfZ079HIWXEkKmkgFrh/nJqamaLSrXO5H4WFFkPEaLJWbs3A==} + engines: {node: '>= 0.4'} + + arrify@1.0.1: + resolution: {integrity: sha512-3CYzex9M9FGQjCGMGyi6/31c8GJbgb0qGyrx5HWxPd0aCwh4cB2YjMb2Xf9UuoogrMrlO9cTqnB5rI5GHZTcUA==} + engines: {node: '>=0.10.0'} + + asap@2.0.6: + resolution: {integrity: sha512-BSHWgDSAiKs50o2Re8ppvp3seVHXSRM44cdSsT9FfNEUUZLOGWVCsiWaRPWM1Znn+mqZ1OfVZ3z3DWEzSp7hRA==} + + asn1@0.2.6: + resolution: {integrity: sha512-ix/FxPn0MDjeyJ7i/yoHGFt/EX6LyNbxSEhPPXODPL+KB0VPk86UYfL0lMdy+KCnv+fmvIzySwaK5COwqVbWTQ==} + + assert-plus@1.0.0: + resolution: {integrity: sha512-NfJ4UzBCcQGLDlQq7nHxH+tv3kyZ0hHQqF5BO6J7tNJeP5do1llPr8dZ8zHonfhAu0PHAdMkSo+8o0wxg9lZWw==} + engines: {node: '>=0.8'} + + assertion-error@1.1.0: + resolution: {integrity: sha512-jgsaNduz+ndvGyFt3uSuWqvy4lCnIJiovtouQN5JZHOKCS2QuhEdbcQHFhVksz2N2U9hXJo8odG7ETyWlEeuDw==} + + ast-parents@0.0.1: + resolution: {integrity: sha512-XHusKxKz3zoYk1ic8Un640joHbFMhbqneyoZfoKnEGtf2ey9Uh/IdpcQplODdO/kENaMIWsD0nJm4+wX3UNLHA==} + + astral-regex@2.0.0: + resolution: {integrity: sha512-Z7tMw1ytTXt5jqMcOP+OQteU1VuNK9Y02uuJtKQ1Sv69jXQKKg5cibLwGJow8yzZP+eAc18EmLGPal0bp36rvQ==} + engines: {node: '>=8'} + + async-limiter@1.0.1: + resolution: {integrity: sha512-csOlWGAcRFJaI6m+F2WKdnMKr4HhdhFVBk0H/QbJFMCr+uO2kwohwXQPxw/9OCxp05r5ghVBFSyioixx3gfkNQ==} + + async@1.5.2: + resolution: {integrity: sha512-nSVgobk4rv61R9PUSDtYt7mPVB2olxNR5RWJcAsH676/ef11bUZwvu7+RGYrYauVdDPcO519v68wRhXQtxsV9w==} + + asynckit@0.4.0: + resolution: {integrity: sha512-Oei9OH4tRh0YqU3GxhX79dM/mwVgvbZJaSNaRk+bshkj0S5cfHcgYakreBjrHwatXKbz+IoIdYLxrKim2MjW0Q==} + + at-least-node@1.0.0: + resolution: {integrity: sha512-+q/t7Ekv1EDY2l6Gda6LLiX14rU9TV20Wa3ofeQmwPFZbOMo9DXrLbOjFaaclkXKWidIaopwAObQDqwWtGUjqg==} + engines: {node: '>= 4.0.0'} + + available-typed-arrays@1.0.7: + resolution: {integrity: sha512-wvUjBtSGN7+7SjNpq/9M2Tg350UZD3q62IFZLbRAR1bSMlCo1ZaeW+BJ+D090e4hIIZLBcTDWe4Mh4jvUDajzQ==} + engines: {node: '>= 0.4'} + + aws-sign2@0.7.0: + resolution: {integrity: sha512-08kcGqnYf/YmjoRhfxyu+CLxBjUtHLXLXX/vUfx9l2LYzG3c1m61nrpyFUZI6zeS+Li/wWMMidD9KgrqtGq3mA==} + + aws4@1.12.0: + resolution: {integrity: sha512-NmWvPnx0F1SfrQbYwOi7OeaNGokp9XhzNioJ/CSBs8Qa4vxug81mhJEAVZwxXuBmYB5KDRfMq/F3RR0BIU7sWg==} + + axios@0.21.4: + resolution: {integrity: sha512-ut5vewkiu8jjGBdqpM44XxjuCjq9LAKeHVmoVfHVzy8eHgxxq8SbAVQNovDA8mVi05kP0Ea/n/UzcSHcTJQfNg==} + + axios@1.6.8: + resolution: {integrity: sha512-v/ZHtJDU39mDpyBoFVkETcd/uNdxrWRrg3bKpOKzXFA6Bvqopts6ALSMU3y6ijYxbw2B+wPrIv46egTzJXCLGQ==} + + balanced-match@1.0.2: + resolution: {integrity: sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw==} + + base-x@3.0.9: + resolution: {integrity: sha512-H7JU6iBHTal1gp56aKoaa//YUxEaAOUiydvrV/pILqIHXTtqxSkATOnDA2u+jZ/61sD+L/412+7kzXRtWukhpQ==} + + base64-js@1.5.1: + resolution: {integrity: sha512-AKpaYlHn8t4SVbOHCy+b5+KKgvR4vrsD8vbvrbiQJps7fKDTkjkDry6ji0rUJjC0kzbNePLwzxq8iypo41qeWA==} + + bcrypt-pbkdf@1.0.2: + resolution: {integrity: sha512-qeFIXtP4MSoi6NLqO12WfqARWWuCKi2Rn/9hJLEmtB5yTNr9DqFWkJRCf2qShWzPeAMRnOgCrq0sg/KLv5ES9w==} + + bech32@1.1.4: + resolution: {integrity: sha512-s0IrSOzLlbvX7yp4WBfPITzpAU8sqQcpsmwXDiKwrG4r491vwCO/XpejasRNl0piBMe/DvP4Tz0mIS/X1DPJBQ==} + + better-path-resolve@1.0.0: + resolution: {integrity: sha512-pbnl5XzGBdrFU/wT4jqmJVPn2B6UHPBOhzMQkY/SPUPB6QtUXtmBHBIwCbXJol93mOpGMnQyP/+BB19q04xj7g==} + engines: {node: '>=4'} + + big-integer@1.6.36: + resolution: {integrity: sha512-t70bfa7HYEA1D9idDbmuv7YbsbVkQ+Hp+8KFSul4aE5e/i1bjCNIRYJZlA8Q8p0r9T8cF/RVvwUgRA//FydEyg==} + engines: {node: '>=0.6'} + + big.js@6.2.1: + resolution: {integrity: sha512-bCtHMwL9LeDIozFn+oNhhFoq+yQ3BNdnsLSASUxLciOb1vgvpHsIO1dsENiGMgbb4SkP5TrzWzRiLddn8ahVOQ==} + + bignumber.js@7.2.1: + resolution: {integrity: sha512-S4XzBk5sMB+Rcb/LNcpzXr57VRTxgAvaAEDAl1AwRx27j00hT84O6OkteE7u8UB3NuaaygCRrEpqox4uDOrbdQ==} + + bignumber.js@9.1.2: + resolution: {integrity: sha512-2/mKyZH9K85bzOEfhXDBFZTGd1CTs+5IHpeFQo9luiBG7hghdC851Pj2WAhb6E3R6b9tZj/XKhbg4fum+Kepug==} + + bignumber.js@https://codeload.github.com/frozeman/bignumber.js-nolookahead/tar.gz/57692b3ecfc98bbdd6b3a516cb2353652ea49934: + resolution: {tarball: https://codeload.github.com/frozeman/bignumber.js-nolookahead/tar.gz/57692b3ecfc98bbdd6b3a516cb2353652ea49934} + version: 2.0.7 + + binary-extensions@2.3.0: + resolution: {integrity: sha512-Ceh+7ox5qe7LJuLHoY0feh3pHuUDHAcRUeyL2VYghZwfpkNIy/+8Ocg0a3UuSoYzavmylwuLWQOf3hl0jjMMIw==} + engines: {node: '>=8'} + + bindings@1.5.0: + resolution: {integrity: sha512-p2q/t/mhvuOj/UeLlV6566GD/guowlr0hHxClI0W9m7MWYkL1F0hLo+0Aexs9HSPCtR1SXQ0TD3MMKrXZajbiQ==} + + bl@4.1.0: + resolution: {integrity: sha512-1W07cM9gS6DcLperZfFSj+bWLtaPGSOHWhPiGzXmvVJbRLdG82sH/Kn8EtW1VqWVA54AKf2h5k5BbnIbwF3h6w==} + + blakejs@1.2.1: + resolution: {integrity: sha512-QXUSXI3QVc/gJME0dBpXrag1kbzOqCjCX8/b54ntNyW6sjtoqxqRk3LTmXzaJoh71zMsDCjM+47jS7XiwN/+fQ==} + + bluebird@3.7.2: + resolution: {integrity: sha512-XpNj6GDQzdfW+r2Wnn7xiSAd7TM3jzkxGXBGTtWKuSXv1xUV+azxAm8jdWZN06QTQk+2N2XB9jRDkvbmQmcRtg==} + + bn-str-256@1.9.1: + resolution: {integrity: sha512-u3muv3WO5sYv9nUQsPnDGLg731yNt/MOlKPK5pmBVqClcl7tY97tyfKxw8ed44HVrpi+7dkgJgQpbXP47a3GoQ==} + + bn.js@4.11.6: + resolution: {integrity: sha512-XWwnNNFCuuSQ0m3r3C4LE3EiORltHd9M05pq6FOlVeiophzRbMo50Sbz1ehl8K3Z+jw9+vmgnXefY1hz8X+2wA==} + + bn.js@4.12.0: + resolution: {integrity: sha512-c98Bf3tPniI+scsdk237ku1Dc3ujXQTSgyiPUDEOe7tRkhrqridvh8klBv0HCEso1OLOYcHuCv/cS6DNxKH+ZA==} + + bn.js@5.2.1: + resolution: {integrity: sha512-eXRvHzWyYPBuB4NBy0cmYQjGitUrtqwbvlzP3G6VFnNRbsZQIxQ10PbKKHt8gZ/HW/D/747aDl+QkDqg3KQLMQ==} + + body-parser@1.20.2: + resolution: {integrity: sha512-ml9pReCu3M61kGlqoTm2umSXTlRTuGTx0bfYj+uIUKKYycG5NtSbeetV3faSU6R7ajOPw0g/J1PvK4qNy7s5bA==} + engines: {node: '>= 0.8', npm: 1.2.8000 || >= 1.4.16} + + boolbase@1.0.0: + resolution: {integrity: sha512-JZOSA7Mo9sNGB8+UjSgzdLtokWAky1zbztM3WRLCbZ70/3cTANmQmOdR7y2g+J0e2WXywy1yS468tY+IruqEww==} + + boolean@3.2.0: + resolution: {integrity: sha512-d0II/GO9uf9lfUHH2BQsjxzRJZBdsjgsBiW4BvhWk/3qoKwQFjIDVN19PfX8F2D/r9PCMTtLWjYVCFrpeYUzsw==} + + boxen@5.1.2: + resolution: {integrity: sha512-9gYgQKXx+1nP8mP7CzFyaUARhg7D3n1dF/FnErWmu9l6JvGpNUN278h0aSb+QjoiKSWG+iZ3uHrcqk0qrY9RQQ==} + engines: {node: '>=10'} + + brace-expansion@1.1.11: + resolution: {integrity: sha512-iCuPHDFgrHX7H2vEI/5xpz07zSHB00TpugqhmYtVmMO6518mCuRMoOYFldEBl0g187ufozdaHgWKcYFb61qGiA==} + + brace-expansion@2.0.1: + resolution: {integrity: sha512-XnAIvQ8eM+kC6aULx6wuQiwVsnzsi9d3WxzV3FpWTGA19F621kwdbsAcFKXgKUHZWsy+mY6iL1sHTxWEFCytDA==} + + braces@3.0.2: + resolution: {integrity: sha512-b8um+L1RzM3WDSzvhm6gIz1yfTbBt6YTlcEKAvsmqCZZFw46z626lVj9j1yEPW33H5H+lBQpZMP1k8l+78Ha0A==} + engines: {node: '>=8'} + + breakword@1.0.6: + resolution: {integrity: sha512-yjxDAYyK/pBvws9H4xKYpLDpYKEH6CzrBPAuXq3x18I+c/2MkVtT3qAr7Oloi6Dss9qNhPVueAAVU1CSeNDIXw==} + + brorand@1.1.0: + resolution: {integrity: sha512-cKV8tMCEpQs4hK/ik71d6LrPOnpkpGBR0wzxqr68g2m/LB2GxVYQroAjMJZRVM1Y4BCjCKc3vAamxSzOY2RP+w==} + + browser-stdout@1.3.1: + resolution: {integrity: sha512-qhAVI1+Av2X7qelOfAIYwXONood6XlZE/fXaBSmW/T5SzLAmCgzi+eiWE7fUvbHaeNBQH13UftjpXxsfLkMpgw==} + + browserify-aes@1.2.0: + resolution: {integrity: sha512-+7CHXqGuspUn/Sl5aO7Ea0xWGAtETPXNSAjHo48JfLdPWcMng33Xe4znFvQweqc/uzk5zSOI3H52CYnjCfb5hA==} + + browserslist@4.23.0: + resolution: {integrity: sha512-QW8HiM1shhT2GuzkvklfjcKDiWFXHOeFCIA/huJPwHsslwcydgk7X+z2zXpEijP98UCY7HbubZt5J2Zgvf0CaQ==} + engines: {node: ^6 || ^7 || ^8 || ^9 || ^10 || ^11 || ^12 || >=13.7} + hasBin: true + + bs58@4.0.1: + resolution: {integrity: sha512-Ok3Wdf5vOIlBrgCvTq96gBkJw+JUEzdBgyaza5HLtPm7yTHkjRy8+JzNyHF7BHa0bNWOQIp3m5YF0nnFcOIKLw==} + + bs58check@2.1.2: + resolution: {integrity: sha512-0TS1jicxdU09dwJMNZtVAfzPi6Q6QeN0pM1Fkzrjn+XYHvzMKPU3pHVpva+769iNVSfIYWf7LJ6WR+BuuMf8cA==} + + buffer-from@1.1.2: + resolution: {integrity: sha512-E+XQCRwSbaaiChtv6k6Dwgc+bx+Bs6vuKJHHl5kox/BaKbhiXzqQOwK4cO22yElGp2OCmjwVhT3HmxgyPGnJfQ==} + + buffer-to-arraybuffer@0.0.5: + resolution: {integrity: sha512-3dthu5CYiVB1DEJp61FtApNnNndTckcqe4pFcLdvHtrpG+kcyekCJKg4MRiDcFW7A6AODnXB9U4dwQiCW5kzJQ==} + + buffer-xor@1.0.3: + resolution: {integrity: sha512-571s0T7nZWK6vB67HI5dyUF7wXiNcfaPPPTl6zYCNApANjIvYJTg7hlud/+cJpdAhS7dVzqMLmfhfHR3rAcOjQ==} + + buffer@5.7.1: + resolution: {integrity: sha512-EHcyIPBQ4BSGlvjB16k5KgAJ27CIsHY/2JBmCRReo48y9rQ3MaUzWX3KVlBa4U7MyX02HdVj0K7C3WaB3ju7FQ==} + + buffer@6.0.3: + resolution: {integrity: sha512-FTiCpNxtwiZZHEZbcbTIcZjERVICn9yq/pDFkTl95/AxzD1naBctN7YO68riM/gLSDY7sdrMby8hofADYuuqOA==} + + bufferutil@4.0.8: + resolution: {integrity: sha512-4T53u4PdgsXqKaIctwF8ifXlRTTmEPJ8iEPWFdGZvcf7sbwYo6FKFEX9eNNAnzFZ7EzJAQ3CJeOtCRA4rDp7Pw==} + engines: {node: '>=6.14.2'} + + builtin-modules@3.3.0: + resolution: {integrity: sha512-zhaCDicdLuWN5UbN5IMnFqNMhNfo919sH85y2/ea+5Yg9TsTkeZxpL+JLbp6cgYFS4sRLp3YV4S6yDuqVWHYOw==} + engines: {node: '>=6'} + + builtins@5.1.0: + resolution: {integrity: sha512-SW9lzGTLvWTP1AY8xeAMZimqDrIaSdLQUcVr9DMef51niJ022Ri87SwRRKYm4A6iHfkPaiVUu/Duw2Wc4J7kKg==} + + bytes@3.1.2: + resolution: {integrity: sha512-/Nf7TyzTx6S3yRJObOAV7956r8cr2+Oj8AC5dt8wSP3BQAoeX58NoHyCU8P8zGkNXStjTSi6fzO6F0pBdcYbEg==} + engines: {node: '>= 0.8'} + + cacheable-lookup@5.0.4: + resolution: {integrity: sha512-2/kNscPhpcxrOigMZzbiWF7dz8ilhb/nIHU3EyZiXWXpeq/au8qJ8VhdftMkty3n7Gj6HIGalQG8oiBNB3AJgA==} + engines: {node: '>=10.6.0'} + + cacheable-lookup@6.1.0: + resolution: {integrity: sha512-KJ/Dmo1lDDhmW2XDPMo+9oiy/CeqosPguPCrgcVzKyZrL6pM1gU2GmPY/xo6OQPTUaA/c0kwHuywB4E6nmT9ww==} + engines: {node: '>=10.6.0'} + + cacheable-request@7.0.4: + resolution: {integrity: sha512-v+p6ongsrp0yTGbJXjgxPow2+DL93DASP4kXCDKb8/bwRtt9OEF3whggkkDkGNzgcWy2XaF4a8nZglC7uElscg==} + engines: {node: '>=8'} + + caching-transform@4.0.0: + resolution: {integrity: sha512-kpqOvwXnjjN44D89K5ccQC+RUrsy7jB/XLlRrx0D7/2HNcTPqzsb6XgYoErwko6QsV184CA2YgS1fxDiiDZMWA==} + engines: {node: '>=8'} + + call-bind@1.0.7: + resolution: {integrity: sha512-GHTSNSYICQ7scH7sZ+M2rFopRoLh8t2bLSW6BbgrtLsahOIB5iyAVJf9GjWK3cYTDaMj4XdBpM1cA6pIS0Kv2w==} + engines: {node: '>= 0.4'} + + callsites@3.1.0: + resolution: {integrity: sha512-P8BjAsXvZS+VIDUI11hHCQEv74YT67YUi5JJFNWIqL235sBmjX4+qx9Muvls5ivyNENctx46xQLQ3aTuE7ssaQ==} + engines: {node: '>=6'} + + camel-case@3.0.0: + resolution: {integrity: sha512-+MbKztAYHXPr1jNTSKQF52VpcFjwY5RkR7fxksV8Doo4KAYc5Fl4UJRgthBbTmEx8C54DqahhbLJkDwjI3PI/w==} + + camelcase-keys@6.2.2: + resolution: {integrity: sha512-YrwaA0vEKazPBkn0ipTiMpSajYDSe+KjQfrjhcBMxJt/znbvlHd8Pw/Vamaz5EB4Wfhs3SUR3Z9mwRu/P3s3Yg==} + engines: {node: '>=8'} + + camelcase@3.0.0: + resolution: {integrity: sha512-4nhGqUkc4BqbBBB4Q6zLuD7lzzrHYrjKGeYaEji/3tFR5VdJu9v+LilhGIVe8wxEJPPOeWo7eg8dwY13TZ1BNg==} + engines: {node: '>=0.10.0'} + + camelcase@4.1.0: + resolution: {integrity: sha512-FxAv7HpHrXbh3aPo4o2qxHay2lkLY3x5Mw3KeE4KQE8ysVfziWeRZDwcjauvwBSGEC/nXUPzZy8zeh4HokqOnw==} + engines: {node: '>=4'} + + camelcase@5.3.1: + resolution: {integrity: sha512-L28STB170nwWS63UjtlEOE3dldQApaJXZkOI1uMFfzf3rRuPegHaHesyee+YxQ+W6SvRDQV6UrdOdRiR153wJg==} + engines: {node: '>=6'} + + camelcase@6.3.0: + resolution: {integrity: sha512-Gmy6FhYlCY7uOElZUSbxo2UCDH8owEk996gkbrpsgGtrJLM3J7jGxl9Ic7Qwwj4ivOE5AWZWRMecDdF7hqGjFA==} + engines: {node: '>=10'} + + caniuse-lite@1.0.30001617: + resolution: {integrity: sha512-mLyjzNI9I+Pix8zwcrpxEbGlfqOkF9kM3ptzmKNw5tizSyYwMe+nGLTqMK9cO+0E+Bh6TsBxNAaHWEM8xwSsmA==} + + caseless@0.12.0: + resolution: {integrity: sha512-4tYFyifaFfGacoiObjJegolkwSU4xQNGbVgUiNYVUxbQ2x2lUsFvY4hVgVzGiIe6WLOPqycWXA40l+PWsxthUw==} + + cbor@5.2.0: + resolution: {integrity: sha512-5IMhi9e1QU76ppa5/ajP1BmMWZ2FHkhAhjeVKQ/EFCgYSEaeVaoGtL7cxJskf9oCCk+XjzaIdc3IuU/dbA/o2A==} + engines: {node: '>=6.0.0'} + + cbor@8.1.0: + resolution: {integrity: sha512-DwGjNW9omn6EwP70aXsn7FQJx5kO12tX0bZkaTjzdVFM6/7nhA4t0EENocKGx6D2Bch9PE2KzCUf5SceBdeijg==} + engines: {node: '>=12.19'} + + cbor@9.0.2: + resolution: {integrity: sha512-JPypkxsB10s9QOWwa6zwPzqE1Md3vqpPc+cai4sAecuCsRyAtAl/pMyhPlMbT/xtPnm2dznJZYRLui57qiRhaQ==} + engines: {node: '>=16'} + + chai-as-promised@7.1.1: + resolution: {integrity: sha512-azL6xMoi+uxu6z4rhWQ1jbdUhOMhis2PvscD/xjLqNMkv3BPPp2JyyuTHOrf9BOosGpNQ11v6BKv/g57RXbiaA==} + peerDependencies: + chai: '>= 2.1.2 < 5' + + chai@4.4.1: + resolution: {integrity: sha512-13sOfMv2+DWduEU+/xbun3LScLoqN17nBeTLUsmDfKdoiC1fr0n9PU4guu4AhRcOVFk/sW8LyZWHuhWtQZiF+g==} + engines: {node: '>=4'} + + chalk@0.4.0: + resolution: {integrity: sha512-sQfYDlfv2DGVtjdoQqxS0cEZDroyG8h6TamA6rvxwlrU5BaSLDx9xhatBYl2pxZ7gmpNaPFVwBtdGdu5rQ+tYQ==} + engines: {node: '>=0.8.0'} + + chalk@2.4.2: + resolution: {integrity: sha512-Mti+f9lpJNcwF4tWV8/OrTTtF1gZi+f8FqlyAdouralcFWFQWF2+NgCHShjkCb+IFBLq9buZwE1xckQU4peSuQ==} + engines: {node: '>=4'} + + chalk@4.1.2: + resolution: {integrity: sha512-oKnbhFyRIXpUuez8iBMmyEa4nbj4IOQyuhc/wy9kY7/WVPcwIO9VA668Pu8RkO7+0G76SLROeyw9CpQ061i4mA==} + engines: {node: '>=10'} + + change-case@3.0.2: + resolution: {integrity: sha512-Mww+SLF6MZ0U6kdg11algyKd5BARbyM4TbFBepwowYSR5ClfQGCGtxNXgykpN0uF/bstWeaGDT4JWaDh8zWAHA==} + + chardet@0.7.0: + resolution: {integrity: sha512-mT8iDcrh03qDGRRmoA2hmBJnxpllMR+0/0qlzjqZES6NdiWDcZkCNAk4rPFZ9Q85r27unkiNNg8ZOiwZXBHwcA==} + + charenc@0.0.2: + resolution: {integrity: sha512-yrLQ/yVUFXkzg7EDQsPieE/53+0RlaWTs+wBrvW36cyilJ2SaDWfl4Yj7MtLTXleV9uEKefbAGUPv2/iWSooRA==} + + check-error@1.0.3: + resolution: {integrity: sha512-iKEoDYaRmd1mxM90a2OEfWhjsjPpYPuQ+lMYsoxB126+t8fw7ySEO48nmDg5COTjxDI65/Y2OWpeEHk3ZOe8zg==} + + cheerio-select@2.1.0: + resolution: {integrity: sha512-9v9kG0LvzrlcungtnJtpGNxY+fzECQKhK4EGJX2vByejiMX84MFNQw4UxPJl3bFbTMw+Dfs37XaIkCwTZfLh4g==} + + cheerio@1.0.0-rc.12: + resolution: {integrity: sha512-VqR8m68vM46BNnuZ5NtnGBKIE/DfN0cRIzg9n40EIq9NOv90ayxLBXA8fXC5gquFRGJSTRqBq25Jt2ECLR431Q==} + engines: {node: '>= 6'} + + chokidar@3.5.3: + resolution: {integrity: sha512-Dr3sfKRP6oTcjf2JmUmFJfeVMvXBdegxB0iVQ5eb2V10uFJUCAS8OByZdVAyVb8xXNz3GjjTgj9kLWsZTqE6kw==} + engines: {node: '>= 8.10.0'} + + chokidar@3.6.0: + resolution: {integrity: sha512-7VT13fmjotKpGipCW9JEQAusEPE+Ei8nl6/g4FBAmIm0GOOLMua9NDDo/DWp0ZAxCr3cPq5ZpBqmPAQgDda2Pw==} + engines: {node: '>= 8.10.0'} + + chownr@1.1.4: + resolution: {integrity: sha512-jJ0bqzaylmJtVnNgzTeSOs8DPavpbYgEr/b0YL8/2GO3xJEhInFmhKMUnEJQjZumK7KXGFhUy89PrsJWlakBVg==} + + ci-info@2.0.0: + resolution: {integrity: sha512-5tK7EtrZ0N+OLFMthtqOj4fI2Jeb88C4CAZPu25LDVUgXJ0A3Js4PMGqrn0JU1W0Mh1/Z8wZzYPxqUrXeBboCQ==} + + ci-info@3.9.0: + resolution: {integrity: sha512-NIxF55hv4nSqQswkAeiOi1r83xy8JldOFDTWiug55KBu9Jnblncd2U6ViHmYgHf01TPZS77NJBhBMKdWj9HQMQ==} + engines: {node: '>=8'} + + cids@0.7.5: + resolution: {integrity: sha512-zT7mPeghoWAu+ppn8+BS1tQ5qGmbMfB4AregnQjA/qHY3GC1m1ptI9GkWNlgeu38r7CuRdXB47uY2XgAYt6QVA==} + engines: {node: '>=4.0.0', npm: '>=3.0.0'} + deprecated: This module has been superseded by the multiformats module + + cipher-base@1.0.4: + resolution: {integrity: sha512-Kkht5ye6ZGmwv40uUDZztayT2ThLQGfnj/T71N/XzeZeo3nf8foyW7zGTsPYkEya3m5f3cAypH+qe7YOrM1U2Q==} + + class-is@1.1.0: + resolution: {integrity: sha512-rhjH9AG1fvabIDoGRVH587413LPjTZgmDF9fOFCbFJQV4yuocX1mHxxvXI4g3cGwbVY9wAYIoKlg1N79frJKQw==} + + clean-stack@2.2.0: + resolution: {integrity: sha512-4diC9HaTE+KRAMWhDhrGOECgWZxoevMc5TlkObMqNSsVU62PYzXZ/SMTjzyGAFF1YusgxGcSWTEXBhp0CPwQ1A==} + engines: {node: '>=6'} + + cli-boxes@2.2.1: + resolution: {integrity: sha512-y4coMcylgSCdVinjiDBuR8PCC2bLjyGTwEmPb9NHR/QaNU6EUOXcTY/s6VjGMD6ENSEaeQYHCY0GNGS5jfMwPw==} + engines: {node: '>=6'} + + cli-cursor@3.1.0: + resolution: {integrity: sha512-I/zHAwsKf9FqGoXM4WWRACob9+SNukZTd94DWF57E4toouRulbCxcUh6RKUEOQlYTHJnzkPMySvPNaaSLNfLZw==} + engines: {node: '>=8'} + + cli-spinners@2.9.2: + resolution: {integrity: sha512-ywqV+5MmyL4E7ybXgKys4DugZbX0FC6LnwrhjuykIjnK9k8OQacQ7axGKnjDXWNhns0xot3bZI5h55H8yo9cJg==} + engines: {node: '>=6'} + + cli-table3@0.5.1: + resolution: {integrity: sha512-7Qg2Jrep1S/+Q3EceiZtQcDPWxhAvBw+ERf1162v4sikJrvojMHFqXt8QIVha8UlH9rgU0BeWPytZ9/TzYqlUw==} + engines: {node: '>=6'} + + cliui@3.2.0: + resolution: {integrity: sha512-0yayqDxWQbqk3ojkYqUKqaAQ6AfNKeKWRNA8kR0WXzAsdHpP4BIaOmMAG87JGuO6qcobyW4GjxHd9PmhEd+T9w==} + + cliui@6.0.0: + resolution: {integrity: sha512-t6wbgtoCXvAzst7QgXxJYqPt0usEfbgQdftEPbLL/cvv6HPE5VgvqCuAIDR0NgU52ds6rFwqrgakNLrHEjCbrQ==} + + cliui@7.0.4: + resolution: {integrity: sha512-OcRE68cOsVMXp1Yvonl/fzkQOyjLSu/8bhPDfQt0e0/Eb283TKP20Fs2MqoPsr9SwA595rRCA+QMzYc9nBP+JQ==} + + cliui@8.0.1: + resolution: {integrity: sha512-BSeNnyus75C4//NQ9gQt1/csTXyo/8Sb+afLAkzAptFuMsod9HFokGNudZpi/oQV73hnVK+sR+5PVRMd+Dr7YQ==} + engines: {node: '>=12'} + + clone-response@1.0.3: + resolution: {integrity: sha512-ROoL94jJH2dUVML2Y/5PEDNaSHgeOdSDicUyS7izcF63G6sTc/FTjLub4b8Il9S8S0beOfYt0TaA5qvFK+w0wA==} + + clone@1.0.4: + resolution: {integrity: sha512-JQHZ2QMW6l3aH/j6xCqQThY/9OH4D/9ls34cgkUBiEeocRTU04tHfKPBsUK1PqZCUQM7GiA0IIXJSuXHI64Kbg==} + engines: {node: '>=0.8'} + + co@4.6.0: + resolution: {integrity: sha512-QVb0dM5HvG+uaxitm8wONl7jltx8dqhfU33DcqtOZcLSVIKSDDLDi7+0LbAKiyI8hD9u42m2YxXSkMGWThaecQ==} + engines: {iojs: '>= 1.0.0', node: '>= 0.12.0'} + + code-point-at@1.1.0: + resolution: {integrity: sha512-RpAVKQA5T63xEj6/giIbUEtZwJ4UFIc3ZtvEkiaUERylqe8xb5IvqcgOurZLahv93CLKfxcw5YI+DZcUBRyLXA==} + engines: {node: '>=0.10.0'} + + color-convert@1.9.3: + resolution: {integrity: sha512-QfAUtd+vFdAtFQcC8CCyYt1fYWxSqAiK2cSD6zDB8N3cpsEBAvRxp9zOGg6G/SHHJYAT88/az/IuDGALsNVbGg==} + + color-convert@2.0.1: + resolution: {integrity: sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ==} + engines: {node: '>=7.0.0'} + + color-name@1.1.3: + resolution: {integrity: sha512-72fSenhMw2HZMTVHeCA9KCmpEIbzWiQsjN+BHcBbS9vr1mtt+vJjPdksIBNUmKAW8TFUDPJK5SUU3QhE9NEXDw==} + + color-name@1.1.4: + resolution: {integrity: sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA==} + + colors@1.4.0: + resolution: {integrity: sha512-a+UqTh4kgZg/SlGvfbzDHpgRu7AAQOmmqRHJnxhRZICKFUT91brVhNNt58CMWU9PsBbv3PDCZUHbVxuDiH2mtA==} + engines: {node: '>=0.1.90'} + + combined-stream@1.0.8: + resolution: {integrity: sha512-FQN4MRfuJeHf7cBbBMJFXhKSDq+2kAArBlmRBvcvFE5BB1HZKXtSFASDhdlz9zOYwxh8lDdnvmMOe/+5cdoEdg==} + engines: {node: '>= 0.8'} + + command-exists@1.2.9: + resolution: {integrity: sha512-LTQ/SGc+s0Xc0Fu5WaKnR0YiygZkm9eKFvyS+fRsU7/ZWFF8ykFM6Pc9aCVf1+xasOOZpO3BAVgVrKvsqKHV7w==} + + command-line-args@5.2.1: + resolution: {integrity: sha512-H4UfQhZyakIjC74I9d34fGYDwk3XpSr17QhEd0Q3I9Xq1CETHo4Hcuo87WyWHpAF1aSLjLRf5lD9ZGX2qStUvg==} + engines: {node: '>=4.0.0'} + + command-line-usage@6.1.3: + resolution: {integrity: sha512-sH5ZSPr+7UStsloltmDh7Ce5fb8XPlHyoPzTpyyMuYCtervL65+ubVZ6Q61cFtFl62UyJlc8/JwERRbAFPUqgw==} + engines: {node: '>=8.0.0'} + + commander@10.0.1: + resolution: {integrity: sha512-y4Mg2tXshplEbSGzx7amzPwKKOCGuoSRP/CjEdwwk0FOGlUbq6lKuoyDZTNZkmxHdJtp54hdfY/JUrdL7Xfdug==} + engines: {node: '>=14'} + + commander@2.20.3: + resolution: {integrity: sha512-GpVkmM8vF2vQUkj2LvZmD35JxeJOLCwJ9cUkugyk2nuhbv3+mJvpLYYt+0+USMxE+oj+ey/lJEnhZw75x/OMcQ==} + + commander@3.0.2: + resolution: {integrity: sha512-Gar0ASD4BDyKC4hl4DwHqDrmvjoxWKZigVnAbn5H1owvm4CxCPdb0HQDehwNYMJpla5+M2tPmPARzhtYuwpHow==} + + commander@6.2.1: + resolution: {integrity: sha512-U7VdrJFnJgo4xjrHpTzu0yrHPGImdsmD95ZlgYSEajAn2JKzDhDTPG9kBTefmObL2w/ngeZnilk+OV9CG3d7UA==} + engines: {node: '>= 6'} + + commondir@1.0.1: + resolution: {integrity: sha512-W9pAhw0ja1Edb5GVdIF1mjZw/ASI0AlShXM83UUGe2DVr5TdAPEA1OA8m/g8zWp9x6On7gqufY+FatDbC3MDQg==} + + concat-map@0.0.1: + resolution: {integrity: sha512-/Srv4dswyQNBfohGpz9o6Yb3Gz3SrUDqBH5rTuhGR7ahtlbYKnVxw2bCFMRljaA7EXHaXZ8wsHdodFvbkhKmqg==} + + concat-stream@1.6.2: + resolution: {integrity: sha512-27HBghJxjiZtIk3Ycvn/4kbJk/1uZuJFfuPEns6LaEvpvG1f0hTea8lilrouyo9mVc2GWdcEZ8OLoGmSADlrCw==} + engines: {'0': node >= 0.8} + + constant-case@2.0.0: + resolution: {integrity: sha512-eS0N9WwmjTqrOmR3o83F5vW8Z+9R1HnVz3xmzT2PMFug9ly+Au/fxRWlEBSb6LcZwspSsEn9Xs1uw9YgzAg1EQ==} + + content-disposition@0.5.4: + resolution: {integrity: sha512-FveZTNuGw04cxlAiWbzi6zTAL/lhehaWbTtgluJh4/E95DqMwTmha3KZN1aAWA8cFIhHzMZUvLevkw5Rqk+tSQ==} + engines: {node: '>= 0.6'} + + content-hash@2.5.2: + resolution: {integrity: sha512-FvIQKy0S1JaWV10sMsA7TRx8bpU+pqPkhbsfvOJAdjRXvYxEckAwQWGwtRjiaJfh+E0DvcWUGqcdjwMGFjsSdw==} + + content-type@1.0.5: + resolution: {integrity: sha512-nTjqfcBFEipKdXCv4YDQWCfmcLZKm81ldF0pAopTvyrFGVbcR6P/VAAd5G7N+0tTr8QqiU0tFadD6FK4NtJwOA==} + engines: {node: '>= 0.6'} + + convert-source-map@1.9.0: + resolution: {integrity: sha512-ASFBup0Mz1uyiIjANan1jzLQami9z1PoYSZCiiYW2FczPbenXc45FZdBZLzOT+r6+iciuEModtmCti+hjaAk0A==} + + convert-source-map@2.0.0: + resolution: {integrity: sha512-Kvp459HrV2FEJ1CAsi1Ku+MY3kasH19TFykTz2xWmMeq6bk2NU3XXvfJ+Q61m0xktWwt+1HSYf3JZsTms3aRJg==} + + cookie-signature@1.0.6: + resolution: {integrity: sha512-QADzlaHc8icV8I7vbaJXJwod9HWYp8uCqf1xa4OfNu1T7JVxQIrUgOWtHdNDtPiywmFbiS12VjotIXLrKM3orQ==} + + cookie@0.4.2: + resolution: {integrity: sha512-aSWTXFzaKWkvHO1Ny/s+ePFpvKsPnjc551iI41v3ny/ow6tBG5Vd+FuqGNhh1LxOmVzOlGUriIlOaokOvhaStA==} + engines: {node: '>= 0.6'} + + cookie@0.6.0: + resolution: {integrity: sha512-U71cyTamuh1CRNCfpGY6to28lxvNwPG4Guz/EVjgf3Jmzv0vlDp1atT9eS5dDjMYHucpHbWns6Lwf3BKz6svdw==} + engines: {node: '>= 0.6'} + + cookiejar@2.1.4: + resolution: {integrity: sha512-LDx6oHrK+PhzLKJU9j5S7/Y3jM/mUHvD/DeI1WQmJn652iPC5Y4TBzC9l+5OMOXlyTTA+SmVUPm0HQUwpD5Jqw==} + + core-util-is@1.0.2: + resolution: {integrity: sha512-3lqz5YjWTYnW6dlDa5TLaTCcShfar1e40rmcJVwCBJC6mWlFuj0eCHIElmG1g5kyuJ/GD+8Wn4FFCcz4gJPfaQ==} + + core-util-is@1.0.3: + resolution: {integrity: sha512-ZQBvi1DcpJ4GDqanjucZ2Hj3wEO5pZDS89BWbkcrvdxksJorwUDDZamX9ldFkp9aw2lmBDLgkObEA4DWNJ9FYQ==} + + cors@2.8.5: + resolution: {integrity: sha512-KIHbLJqu73RGr/hnbrO9uBeixNGuvSQjul/jdFvS/KFSIH1hWVd1ng7zOHx+YrEfInLG7q4n6GHQ9cDtxv/P6g==} + engines: {node: '>= 0.10'} + + cosmiconfig@8.3.6: + resolution: {integrity: sha512-kcZ6+W5QzcJ3P1Mt+83OUv/oHFqZHIx8DuxG6eZ5RGMERoLqp4BuGjhHLYGK+Kf5XVkQvqBSmAy/nGWN3qDgEA==} + engines: {node: '>=14'} + peerDependencies: + typescript: '>=4.9.5' + peerDependenciesMeta: + typescript: + optional: true + + crc-32@1.2.2: + resolution: {integrity: sha512-ROmzCKrTnOwybPcJApAA6WBWij23HVfGVNKqqrZpuyZOHqK2CwHSvpGuyt/UNNvaIjEd8X5IFGp4Mh+Ie1IHJQ==} + engines: {node: '>=0.8'} + hasBin: true + + create-hash@1.2.0: + resolution: {integrity: sha512-z00bCGNHDG8mHAkP7CtT1qVu+bFQUPjYq/4Iv3C3kWjTFV10zIjfSoeqXo9Asws8gwSHDGj/hl2u4OGIjapeCg==} + + create-hmac@1.1.7: + resolution: {integrity: sha512-MJG9liiZ+ogc4TzUwuvbER1JRdgvUFSB5+VR/g5h82fGaIRWMWddtKBHi7/sVhfjQZ6SehlyhvQYrcYkaUIpLg==} + + create-require@1.1.1: + resolution: {integrity: sha512-dcKFX3jn0MpIaXjisoRvexIJVEKzaq7z2rZKxf+MSr9TkdmHmsU4m2lcLojrj/FHl8mk5VxMmYA+ftRkP/3oKQ==} + + cross-fetch@3.1.8: + resolution: {integrity: sha512-cvA+JwZoU0Xq+h6WkMvAUqPEYy92Obet6UdKLfW60qn99ftItKjB5T+BkyWOFWe2pUyfQ+IJHmpOTznqk1M6Kg==} + + cross-fetch@4.0.0: + resolution: {integrity: sha512-e4a5N8lVvuLgAWgnCrLr2PP0YyDOTHa9H/Rj54dirp61qXnNq46m82bRhNqIA5VccJtWBvPTFRV3TtvHUKPB1g==} + + cross-spawn@5.1.0: + resolution: {integrity: sha512-pTgQJ5KC0d2hcY8eyL1IzlBPYjTkyH72XRZPnLyKus2mBfNjQs3klqbJU2VILqZryAZUt9JOb3h/mWMy23/f5A==} + + cross-spawn@7.0.3: + resolution: {integrity: sha512-iRDPJKUPVEND7dHPO8rkbOnPpyDygcDFtWjpeWNCgy8WP2rXcxXL8TskReQl6OrB2G7+UJrags1q15Fudc7G6w==} + engines: {node: '>= 8'} + + crypt@0.0.2: + resolution: {integrity: sha512-mCxBlsHFYh9C+HVpiEacem8FEBnMXgU9gy4zmNC+SXAZNB/1idgp/aulFJ4FgCi7GPEVbfyng092GqL2k2rmow==} + + crypto-addr-codec@0.1.8: + resolution: {integrity: sha512-GqAK90iLLgP3FvhNmHbpT3wR6dEdaM8hZyZtLX29SPardh3OA13RFLHDR6sntGCgRWOfiHqW6sIyohpNqOtV/g==} + + crypto-js@3.3.0: + resolution: {integrity: sha512-DIT51nX0dCfKltpRiXV+/TVZq+Qq2NgF4644+K7Ttnla7zEzqc+kjJyiB96BHNyUTBxyjzRcZYpUdZa+QAqi6Q==} + + crypto-js@4.2.0: + resolution: {integrity: sha512-KALDyEYgpY+Rlob/iriUtjV6d5Eq+Y191A5g4UqLAi8CyGP9N1+FdVbkc1SxKc2r4YAYqG8JzO2KGL+AizD70Q==} + + css-select@5.1.0: + resolution: {integrity: sha512-nwoRF1rvRRnnCqqY7updORDsuqKzqYJ28+oSMaJMMgOauh3fvwHqMS7EZpIPqK8GL+g9mKxF1vP/ZjSeNjEVHg==} + + css-what@6.1.0: + resolution: {integrity: sha512-HTUrgRJ7r4dsZKU6GjmpfRK1O76h97Z8MfS1G0FozR+oF2kG6Vfe8JE6zwrkbxigziPHinCJ+gCPjA9EaBDtRw==} + engines: {node: '>= 6'} + + csv-generate@3.4.3: + resolution: {integrity: sha512-w/T+rqR0vwvHqWs/1ZyMDWtHHSJaN06klRqJXBEpDJaM/+dZkso0OKh1VcuuYvK3XM53KysVNq8Ko/epCK8wOw==} + + csv-parse@4.16.3: + resolution: {integrity: sha512-cO1I/zmz4w2dcKHVvpCr7JVRu8/FymG5OEpmvsZYlccYolPBLoVGKUHgNoc4ZGkFeFlWGEDmMyBM+TTqRdW/wg==} + + csv-stringify@5.6.5: + resolution: {integrity: sha512-PjiQ659aQ+fUTQqSrd1XEDnOr52jh30RBurfzkscaE2tPaFsDH5wOAHJiw8XAHphRknCwMUE9KRayc4K/NbO8A==} + + csv@5.5.3: + resolution: {integrity: sha512-QTaY0XjjhTQOdguARF0lGKm5/mEq9PD9/VhZZegHDIBq2tQwgNpHc3dneD4mGo2iJs+fTKv5Bp0fZ+BRuY3Z0g==} + engines: {node: '>= 0.1.90'} + + d@1.0.2: + resolution: {integrity: sha512-MOqHvMWF9/9MX6nza0KgvFH4HpMU0EF5uUDXqX/BtxtU8NfB0QzRtJ8Oe/6SuS4kbhyzVJwjd97EA4PKrzJ8bw==} + engines: {node: '>=0.12'} + + dashdash@1.14.1: + resolution: {integrity: sha512-jRFi8UDGo6j+odZiEpjazZaWqEal3w/basFjQHQEwVtZJGDpxbH1MeYluwCS8Xq5wmLJooDlMgvVarmWfGM44g==} + engines: {node: '>=0.10'} + + data-view-buffer@1.0.1: + resolution: {integrity: sha512-0lht7OugA5x3iJLOWFhWK/5ehONdprk0ISXqVFn/NFrDu+cuc8iADFrGQz5BnRK7LLU3JmkbXSxaqX+/mXYtUA==} + engines: {node: '>= 0.4'} + + data-view-byte-length@1.0.1: + resolution: {integrity: sha512-4J7wRJD3ABAzr8wP+OcIcqq2dlUKp4DVflx++hs5h5ZKydWMI6/D/fAot+yh6g2tHh8fLFTvNOaVN357NvSrOQ==} + engines: {node: '>= 0.4'} + + data-view-byte-offset@1.0.0: + resolution: {integrity: sha512-t/Ygsytq+R995EJ5PZlD4Cu56sWa8InXySaViRzw9apusqsOO2bQP+SbYzAhR0pFKoB+43lYy8rWban9JSuXnA==} + engines: {node: '>= 0.4'} + + date-time@0.1.1: + resolution: {integrity: sha512-p4psdkgdNA6x0600SKbfWiOomNb33ADBMRHf49GMhYVgJsPefZlMSLXXVWWUpbqSxB3DL5/cxKa6a8i3XPK5Xg==} + engines: {node: '>=0.10.0'} + + death@1.1.0: + resolution: {integrity: sha512-vsV6S4KVHvTGxbEcij7hkWRv0It+sGGWVOM67dQde/o5Xjnr+KmLjxWJii2uEObIrt1CcM9w0Yaovx+iOlIL+w==} + + debug@2.6.9: + resolution: {integrity: sha512-bC7ElrdJaJnPbAP+1EotYvqZsb3ecl5wi6Bfi6BJTUcNowp6cvspg0jXznRTKDjm/E7AdgFBVeAPVMNcKGsHMA==} + peerDependencies: + supports-color: '*' + peerDependenciesMeta: + supports-color: + optional: true + + debug@3.2.7: + resolution: {integrity: sha512-CFjzYYAi4ThfiQvizrFQevTTXHtnCqWfe7x1AhgEscTz6ZbLbfoLRLPugTQyBth6f8ZERVUSyWHFD/7Wu4t1XQ==} + peerDependencies: + supports-color: '*' + peerDependenciesMeta: + supports-color: + optional: true + + debug@4.3.4: + resolution: {integrity: sha512-PRWFHuSU3eDtQJPvnNY7Jcket1j0t5OuOsFzPPzsekD52Zl8qUfFIPEiswXqIvHWGVHOgX+7G/vCNNhehwxfkQ==} + engines: {node: '>=6.0'} + peerDependencies: + supports-color: '*' + peerDependenciesMeta: + supports-color: + optional: true + + decamelize-keys@1.1.1: + resolution: {integrity: sha512-WiPxgEirIV0/eIOMcnFBA3/IJZAZqKnwAwWyvvdi4lsr1WCN22nhdf/3db3DoZcUjTV2SqfzIwNyp6y2xs3nmg==} + engines: {node: '>=0.10.0'} + + decamelize@1.2.0: + resolution: {integrity: sha512-z2S+W9X73hAUUki+N+9Za2lBlun89zigOyGrsax+KUQ6wKW4ZoWpEYBkGhQjwAjjDCkWxhY0VKEhk8wzY7F5cA==} + engines: {node: '>=0.10.0'} + + decamelize@4.0.0: + resolution: {integrity: sha512-9iE1PgSik9HeIIw2JO94IidnE3eBoQrFJ3w7sFuzSX4DpmZ3v5sZpUiV5Swcf6mQEF+Y0ru8Neo+p+nyh2J+hQ==} + engines: {node: '>=10'} + + decimal.js-light@2.5.1: + resolution: {integrity: sha512-qIMFpTMZmny+MMIitAB6D7iVPEorVw6YQRWkvarTkT4tBeSLLiHzcwj6q0MmYSFCiVpiqPJTJEYIrpcPzVEIvg==} + + decode-uri-component@0.2.2: + resolution: {integrity: sha512-FqUYQ+8o158GyGTrMFJms9qh3CqTKvAqgqsTnkLI8sKu0028orqBhxNMFkFen0zGyg6epACD32pjVk58ngIErQ==} + engines: {node: '>=0.10'} + + decompress-response@3.3.0: + resolution: {integrity: sha512-BzRPQuY1ip+qDonAOz42gRm/pg9F768C+npV/4JOsxRC2sq+Rlk+Q4ZCAsOhnIaMrgarILY+RMUIvMmmX1qAEA==} + engines: {node: '>=4'} + + decompress-response@6.0.0: + resolution: {integrity: sha512-aW35yZM6Bb/4oJlZncMH2LCoZtJXTRxES17vE3hoRiowU2kWHaJKFkSBDnDR+cm9J+9QhXmREyIfv0pji9ejCQ==} + engines: {node: '>=10'} + + deep-eql@4.1.3: + resolution: {integrity: sha512-WaEtAOpRA1MQ0eohqZjpGD8zdI0Ovsm8mmFhaDN8dvDZzyoUMcYDnf5Y6iu7HTXxf8JDS23qWa4a+hKCDyOPzw==} + engines: {node: '>=6'} + + deep-extend@0.6.0: + resolution: {integrity: sha512-LOHxIOaPYdHlJRtCQfDIVZtfw/ufM8+rVj649RIHzcm/vGwQRXFt6OPqIFWsm2XEMrNIEtWR64sY1LEKD2vAOA==} + engines: {node: '>=4.0.0'} + + deep-is@0.1.4: + resolution: {integrity: sha512-oIPzksmTg4/MriiaYGO+okXDT7ztn/w3Eptv/+gSIdMdKsJo0u4CfYNFJPy+4SKMuCqGw2wxnA+URMg3t8a/bQ==} + + deepmerge@4.3.1: + resolution: {integrity: sha512-3sUqbMEc77XqpdNO7FRyRog+eW3ph+GYCbj+rK+uYyRMuwsVy0rMiVtPn+QJlKFvWP/1PYpapqYn0Me2knFn+A==} + engines: {node: '>=0.10.0'} + + default-require-extensions@3.0.1: + resolution: {integrity: sha512-eXTJmRbm2TIt9MgWTsOH1wEuhew6XGZcMeGKCtLedIg/NCsg1iBePXkceTdK4Fii7pzmN9tGsZhKzZ4h7O/fxw==} + engines: {node: '>=8'} + + defaults@1.0.4: + resolution: {integrity: sha512-eFuaLoy/Rxalv2kr+lqMlUnrDWV+3j4pljOIJgLIhI058IQfWJ7vXhyEIHu+HtC738klGALYxOKDO0bQP3tg8A==} + + defer-to-connect@2.0.1: + resolution: {integrity: sha512-4tvttepXG1VaYGrRibk5EwJd1t4udunSOVMdLSAL6mId1ix438oPwPZMALY41FCijukO1L0twNcGsdzS7dHgDg==} + engines: {node: '>=10'} + + define-data-property@1.1.4: + resolution: {integrity: sha512-rBMvIzlpA8v6E+SJZoo++HAYqsLrkg7MSfIinMPFhmkorw7X+dOXVJQs+QT69zGkzMyfDnIMN2Wid1+NbL3T+A==} + engines: {node: '>= 0.4'} + + define-properties@1.2.1: + resolution: {integrity: sha512-8QmQKqEASLd5nx0U1B1okLElbUuuttJ/AnYmRXbbbGDWh6uS208EjD4Xqq/I9wK7u0v6O08XhTWnt5XtEbR6Dg==} + engines: {node: '>= 0.4'} + + delayed-stream@1.0.0: + resolution: {integrity: sha512-ZySD7Nf91aLB0RxL4KGrKHBXl7Eds1DAmEdcoVawXnLD7SDhpNgtuII2aAkg7a7QS41jxPSZ17p4VdGnMHk3MQ==} + engines: {node: '>=0.4.0'} + + depd@2.0.0: + resolution: {integrity: sha512-g7nH6P6dyDioJogAAGprGpCtVImJhpPk/roCzdb3fIh61/s/nPsfR6onyMwkCAR/OlC3yBC0lESvUoQEAssIrw==} + engines: {node: '>= 0.8'} + + destroy@1.2.0: + resolution: {integrity: sha512-2sJGJTaXIIaR1w4iJSNoN0hnMY7Gpc/n8D4qSCJw8QqFWXf7cuAgnEHxBpweaVcPevC2l3KpjYCx3NypQQgaJg==} + engines: {node: '>= 0.8', npm: 1.2.8000 || >= 1.4.16} + + detect-indent@5.0.0: + resolution: {integrity: sha512-rlpvsxUtM0PQvy9iZe640/IWwWYyBsTApREbA1pHOpmOUIl9MkP/U4z7vTtg4Oaojvqhxt7sdufnT0EzGaR31g==} + engines: {node: '>=4'} + + detect-indent@6.1.0: + resolution: {integrity: sha512-reYkTUJAZb9gUuZ2RvVCNhVHdg62RHnJ7WJl8ftMi4diZ6NWlciOzQN88pUhSELEwflJht4oQDv0F0BMlwaYtA==} + engines: {node: '>=8'} + + detect-libc@2.0.3: + resolution: {integrity: sha512-bwy0MGW55bG41VqxxypOsdSdGqLwXPI/focwgTYCFMbdUiBAxLg9CFzG08sz2aqzknwiX7Hkl0bQENjg8iLByw==} + engines: {node: '>=8'} + + detect-node@2.1.0: + resolution: {integrity: sha512-T0NIuQpnTvFDATNuHN5roPwSBG83rFsuO+MXXH9/3N1eFbn4wcPjttvjMLEPWJ0RGUYgQE7cGgS3tNxbqCGM7g==} + + detect-port@1.6.1: + resolution: {integrity: sha512-CmnVc+Hek2egPx1PeTFVta2W78xy2K/9Rkf6cC4T59S50tVnzKj+tnx5mmx5lwvCkujZ4uRrpRSuV+IVs3f90Q==} + engines: {node: '>= 4.0.0'} + hasBin: true + + diff-sequences@29.6.3: + resolution: {integrity: sha512-EjePK1srD3P08o2j4f0ExnylqRs5B9tJjcp9t1krH2qRi8CCdsYfwe9JgSLurFBWwq4uOlipzfk5fHNvwFKr8Q==} + engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0} + + diff@4.0.2: + resolution: {integrity: sha512-58lmxKSA4BNyLz+HHMUzlOEpg09FV+ev6ZMe3vJihgdxzgcwZ8VoEEPmALCZG9LmqfVoNMMKpttIYTVG6uDY7A==} + engines: {node: '>=0.3.1'} + + diff@5.0.0: + resolution: {integrity: sha512-/VTCrvm5Z0JGty/BWHljh+BAiw3IK+2j87NGMu8Nwc/f48WoDAC395uomO9ZD117ZOBaHmkX1oyLvkVM/aIT3w==} + engines: {node: '>=0.3.1'} + + difflib@0.2.4: + resolution: {integrity: sha512-9YVwmMb0wQHQNr5J9m6BSj6fk4pfGITGQOOs+D9Fl+INODWFOfvhIU1hNv6GgR1RBoC/9NJcwu77zShxV0kT7w==} + + dir-glob@3.0.1: + resolution: {integrity: sha512-WkrWp9GR4KXfKGYzOLmTuGVi1UWFfws377n9cc55/tb6DuqyF6pcQ5AbiHEshaDpY9v6oaSr2XCDidGmMwdzIA==} + engines: {node: '>=8'} + + doctrine@2.1.0: + resolution: {integrity: sha512-35mSku4ZXK0vfCuHEDAwt55dg2jNajHZ1odvF+8SSr82EsZY4QmXfuWso8oEd8zRhVObSN18aM0CjSdoBX7zIw==} + engines: {node: '>=0.10.0'} + + doctrine@3.0.0: + resolution: {integrity: sha512-yS+Q5i3hBf7GBkd4KG8a7eBNNWNGLTaEwwYWUijIYM7zrlYDM0BFXHjjPWlWZ1Rg7UaddZeIDmi9jF3HmqiQ2w==} + engines: {node: '>=6.0.0'} + + dom-serializer@2.0.0: + resolution: {integrity: sha512-wIkAryiqt/nV5EQKqQpo3SToSOV9J0DnbJqwK7Wv/Trc92zIAYZ4FlMu+JPFW1DfGFt81ZTCGgDEabffXeLyJg==} + + dom-walk@0.1.2: + resolution: {integrity: sha512-6QvTW9mrGeIegrFXdtQi9pk7O/nSK6lSdXW2eqUspN5LWD7UTji2Fqw5V2YLjBpHEoU9Xl/eUWNpDeZvoyOv2w==} + + domelementtype@2.3.0: + resolution: {integrity: sha512-OLETBj6w0OsagBwdXnPdN0cnMfF9opN69co+7ZrbfPGrdpPVNBUj02spi6B1N7wChLQiPn4CSH/zJvXw56gmHw==} + + domhandler@5.0.3: + resolution: {integrity: sha512-cgwlv/1iFQiFnU96XXgROh8xTeetsnJiDsTc7TYCLFd9+/WNkIqPTxiM/8pSd8VIrhXGTf1Ny1q1hquVqDJB5w==} + engines: {node: '>= 4'} + + domutils@3.1.0: + resolution: {integrity: sha512-H78uMmQtI2AhgDJjWeQmHwJJ2bLPD3GMmO7Zja/ZZh84wkm+4ut+IUnUdRa8uCGX88DiVx1j6FRe1XfxEgjEZA==} + + dot-case@2.1.1: + resolution: {integrity: sha512-HnM6ZlFqcajLsyudHq7LeeLDr2rFAVYtDv/hV5qchQEidSck8j9OPUsXY9KwJv/lHMtYlX4DjRQqwFYa+0r8Ug==} + + dot-prop@7.2.0: + resolution: {integrity: sha512-Ol/IPXUARn9CSbkrdV4VJo7uCy1I3VuSiWCaFSg+8BdUOzF9n3jefIpcgAydvUZbTdEBZs2vEiTiS9m61ssiDA==} + engines: {node: ^12.20.0 || ^14.13.1 || >=16.0.0} + + ecc-jsbn@0.1.2: + resolution: {integrity: sha512-eh9O+hwRHNbG4BLTjEl3nw044CkGm5X6LoaCf7LPp7UU8Qrt47JYNi6nPX8xjW97TKGKm1ouctg0QSpZe9qrnw==} + + ee-first@1.1.1: + resolution: {integrity: sha512-WMwm9LhRUo+WUaRN+vRuETqG89IgZphVSNkdFgeb6sS/E4OrDIN7t48CAewSHXc6C8lefD8KKfr5vY61brQlow==} + + eip55@2.1.1: + resolution: {integrity: sha512-WcagVAmNu2Ww2cDUfzuWVntYwFxbvZ5MvIyLZpMjTTkjD6sCvkGOiS86jTppzu9/gWsc8isLHAeMBWK02OnZmA==} + + electron-to-chromium@1.4.761: + resolution: {integrity: sha512-PIbxpiJGx6Bb8dQaonNc6CGTRlVntdLg/2nMa1YhnrwYOORY9a3ZgGN0UQYE6lAcj/lkyduJN7BPt/JiY+jAQQ==} + + elliptic@6.5.4: + resolution: {integrity: sha512-iLhC6ULemrljPZb+QutR5TQGB+pdW6KGD5RSegS+8sorOZT+rdQFbsQFJgvN3eRqNALqJer4oQ16YvJHlU8hzQ==} + + elliptic@6.5.5: + resolution: {integrity: sha512-7EjbcmUm17NQFu4Pmgmq2olYMj8nwMnpcddByChSUjArp8F5DQWcIcpriwO4ZToLNAJig0yiyjswfyGNje/ixw==} + + emoji-regex@8.0.0: + resolution: {integrity: sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A==} + + encodeurl@1.0.2: + resolution: {integrity: sha512-TPJXq8JqFaVYm2CWmPvnP2Iyo4ZSM7/QKcSmuMLDObfpH5fi7RUGmd/rTDf+rut/saiDiQEeVTNgAmJEdAOx0w==} + engines: {node: '>= 0.8'} + + end-of-stream@1.4.4: + resolution: {integrity: sha512-+uw1inIHVPQoaVuHzRyXd21icM+cnt4CzD5rW+NC1wjOUSTOs+Te7FOv7AhN7vS9x/oIyhLP5PR1H+phQAHu5Q==} + + enquirer@2.4.1: + resolution: {integrity: sha512-rRqJg/6gd538VHvR3PSrdRBb/1Vy2YfzHqzvbhGIQpDRKIa4FgV/54b5Q1xYSxOOwKvjXweS26E0Q+nAMwp2pQ==} + engines: {node: '>=8.6'} + + entities@4.5.0: + resolution: {integrity: sha512-V0hjH4dGPh9Ao5p0MoRY6BVqtwCjhz6vI5LT8AJ55H+4g9/4vbHx1I54fS0XuclLhDHArPQCiMjDxjaL8fPxhw==} + engines: {node: '>=0.12'} + + env-paths@2.2.1: + resolution: {integrity: sha512-+h1lkLKhZMTYjog1VEpJNG7NZJWcuc2DDk/qsqSTRRCOXiLjeQ1d1/udrUGhqMxUgAlwKNZ0cf2uqan5GLuS2A==} + engines: {node: '>=6'} + + error-ex@1.3.2: + resolution: {integrity: sha512-7dFHNmqeFSEt2ZBsCriorKnn3Z2pj+fd9kmI6QoWw4//DL+icEBfc0U7qJCisqrTsKTjw4fNFy2pW9OqStD84g==} + + es-abstract@1.23.3: + resolution: {integrity: sha512-e+HfNH61Bj1X9/jLc5v1owaLYuHdeHHSQlkhCBiTK8rBvKaULl/beGMxwrMXjpYrv4pz22BlY570vVePA2ho4A==} + engines: {node: '>= 0.4'} + + es-define-property@1.0.0: + resolution: {integrity: sha512-jxayLKShrEqqzJ0eumQbVhTYQM27CfT1T35+gCgDFoL82JLsXqTJ76zv6A0YLOgEnLUMvLzsDsGIrl8NFpT2gQ==} + engines: {node: '>= 0.4'} + + es-errors@1.3.0: + resolution: {integrity: sha512-Zf5H2Kxt2xjTvbJvP2ZWLEICxA6j+hAmMzIlypy4xcBg1vKVnx89Wy0GbS+kf5cwCVFFzdCFh2XSCFNULS6csw==} + engines: {node: '>= 0.4'} + + es-object-atoms@1.0.0: + resolution: {integrity: sha512-MZ4iQ6JwHOBQjahnjwaC1ZtIBH+2ohjamzAO3oaHcXYup7qxjF2fixyH+Q71voWHeOkI2q/TnJao/KfXYIZWbw==} + engines: {node: '>= 0.4'} + + es-set-tostringtag@2.0.3: + resolution: {integrity: sha512-3T8uNMC3OQTHkFUsFq8r/BwAXLHvU/9O9mE0fBc/MY5iq/8H7ncvO947LmYA6ldWw9Uh8Yhf25zu6n7nML5QWQ==} + engines: {node: '>= 0.4'} + + es-shim-unscopables@1.0.2: + resolution: {integrity: sha512-J3yBRXCzDu4ULnQwxyToo/OjdMx6akgVC7K6few0a7F/0wLtmKKN7I73AH5T2836UuXRqN7Qg+IIUw/+YJksRw==} + + es-to-primitive@1.2.1: + resolution: {integrity: sha512-QCOllgZJtaUo9miYBcLChTUaHNjJF3PYs1VidD7AwiEj1kYxKeQTctLAezAOH5ZKRH0g2IgPn6KwB4IT8iRpvA==} + engines: {node: '>= 0.4'} + + es5-ext@0.10.64: + resolution: {integrity: sha512-p2snDhiLaXe6dahss1LddxqEm+SkuDvV8dnIQG0MWjyHpcMNfXKPE+/Cc0y+PhxJX3A4xGNeFCj5oc0BUh6deg==} + engines: {node: '>=0.10'} + + es6-error@4.1.1: + resolution: {integrity: sha512-Um/+FxMr9CISWh0bi5Zv0iOD+4cFh5qLeks1qhAopKVAJw3drgKbKySikp7wGhDL0HPeaja0P5ULZrxLkniUVg==} + + es6-iterator@2.0.3: + resolution: {integrity: sha512-zw4SRzoUkd+cl+ZoE15A9o1oQd920Bb0iOJMQkQhl3jNc03YqVjAhG7scf9C5KWRU/R13Orf588uCC6525o02g==} + + es6-promise@4.2.8: + resolution: {integrity: sha512-HJDGx5daxeIvxdBxvG2cb9g4tEvwIk3i8+nhX0yGrYmZUzbkdg8QbDevheDB8gd0//uPj4c1EQua8Q+MViT0/w==} + + es6-symbol@3.1.4: + resolution: {integrity: sha512-U9bFFjX8tFiATgtkJ1zg25+KviIXpgRvRHS8sau3GfhVzThRQrOeksPeT0BWW2MNZs1OEWJ1DPXOQMn0KKRkvg==} + engines: {node: '>=0.12'} + + escalade@3.1.2: + resolution: {integrity: sha512-ErCHMCae19vR8vQGe50xIsVomy19rg6gFu3+r3jkEO46suLMWBksvVyoGgQV+jOfl84ZSOSlmv6Gxa89PmTGmA==} + engines: {node: '>=6'} + + escape-html@1.0.3: + resolution: {integrity: sha512-NiSupZ4OeuGwr68lGIeym/ksIZMJodUGOSCZ/FSnTxcrekbvqrgdUxlJOMpijaKZVjAJrWrGs/6Jy8OMuyj9ow==} + + escape-string-regexp@1.0.5: + resolution: {integrity: sha512-vbRorB5FUQWvla16U8R/qgaFIya2qGzwDrNmCZuYKrbdSUMG6I1ZCGQRefkRVhuOkIGVne7BQ35DSfo1qvJqFg==} + engines: {node: '>=0.8.0'} + + escape-string-regexp@4.0.0: + resolution: {integrity: sha512-TtpcNJ3XAzx3Gq8sWRzJaVajRs0uVxA2YAkdb1jm2YkPz4G6egUFAyA3n5vtEIZefPk5Wa4UXbKuS5fKkJWdgA==} + engines: {node: '>=10'} + + escodegen@1.8.1: + resolution: {integrity: sha512-yhi5S+mNTOuRvyW4gWlg5W1byMaQGWWSYHXsuFZ7GBo7tpyOwi2EdzMP/QWxh9hwkD2m+wDVHJsxhRIj+v/b/A==} + engines: {node: '>=0.12.0'} + hasBin: true + + eslint-compat-utils@0.5.0: + resolution: {integrity: sha512-dc6Y8tzEcSYZMHa+CMPLi/hyo1FzNeonbhJL7Ol0ccuKQkwopJcJBA9YL/xmMTLU1eKigXo9vj9nALElWYSowg==} + engines: {node: '>=12'} + peerDependencies: + eslint: '>=6.0.0' + + eslint-config-prettier@8.3.0: + resolution: {integrity: sha512-BgZuLUSeKzvlL/VUjx/Yb787VQ26RU3gGjA3iiFvdsp/2bMfVIWUVP7tjxtjS0e+HP409cPlPvNkQloz8C91ew==} + hasBin: true + peerDependencies: + eslint: '>=7.0.0' + + eslint-doc-generator@1.7.1: + resolution: {integrity: sha512-i1Zjl+Xcy712SZhbceCeMVaIdhbFqY27i8d7f9gyb9P/6AQNnPA0VCWynAFVGYa0hpeR5kwUI09+GBELgC2nnA==} + engines: {node: ^14.18.0 || ^16.0.0 || >=18.0.0} + hasBin: true + peerDependencies: + eslint: '>= 7' + + eslint-import-resolver-node@0.3.9: + resolution: {integrity: sha512-WFj2isz22JahUv+B788TlO3N6zL3nNJGU8CcZbPZvVEkBPaJdCV4vy5wyghty5ROFbCRnm132v8BScu5/1BQ8g==} + + eslint-module-utils@2.8.1: + resolution: {integrity: sha512-rXDXR3h7cs7dy9RNpUlQf80nX31XWJEyGq1tRMo+6GsO5VmTe4UTwtmonAD4ZkAsrfMVDA2wlGJ3790Ys+D49Q==} + engines: {node: '>=4'} + peerDependencies: + '@typescript-eslint/parser': '*' + eslint: '*' + eslint-import-resolver-node: '*' + eslint-import-resolver-typescript: '*' + eslint-import-resolver-webpack: '*' + peerDependenciesMeta: + '@typescript-eslint/parser': + optional: true + eslint: + optional: true + eslint-import-resolver-node: + optional: true + eslint-import-resolver-typescript: + optional: true + eslint-import-resolver-webpack: + optional: true + + eslint-plugin-es-x@7.6.0: + resolution: {integrity: sha512-I0AmeNgevgaTR7y2lrVCJmGYF0rjoznpDvqV/kIkZSZbZ8Rw3eu4cGlvBBULScfkSOCzqKbff5LR4CNrV7mZHA==} + engines: {node: ^14.18.0 || >=16.0.0} + peerDependencies: + eslint: '>=8' + + eslint-plugin-eslint-plugin@5.5.1: + resolution: {integrity: sha512-9AmfZzcQ7QHwpzfAQpZ7xdtwHYViylmlnruCH0aV64/tuoH3igGXg91vr0e6ShLf/mrAYGqLw5LZ/gOxJeRXnw==} + engines: {node: ^14.17.0 || ^16.0.0 || >= 18.0.0} + peerDependencies: + eslint: '>=7.0.0' + + eslint-plugin-import@2.27.5: + resolution: {integrity: sha512-LmEt3GVofgiGuiE+ORpnvP+kAm3h6MLZJ4Q5HCyHADofsb4VzXFsRiWj3c0OFiV+3DWFh0qg3v9gcPlfc3zRow==} + engines: {node: '>=4'} + peerDependencies: + '@typescript-eslint/parser': '*' + eslint: ^2 || ^3 || ^4 || ^5 || ^6 || ^7.2.0 || ^8 + peerDependenciesMeta: + '@typescript-eslint/parser': + optional: true + + eslint-plugin-mocha@10.4.1: + resolution: {integrity: sha512-G85ALUgKaLzuEuHhoW3HVRgPTmia6njQC3qCG6CEvA8/Ja9PDZnRZOuzekMki+HaViEQXINuYsmhp5WR5/4MfA==} + engines: {node: '>=14.0.0'} + peerDependencies: + eslint: '>=7.0.0' + + eslint-plugin-n@16.6.2: + resolution: {integrity: sha512-6TyDmZ1HXoFQXnhCTUjVFULReoBPOAjpuiKELMkeP40yffI/1ZRO+d9ug/VC6fqISo2WkuIBk3cvuRPALaWlOQ==} + engines: {node: '>=16.0.0'} + peerDependencies: + eslint: '>=7.0.0' + + eslint-plugin-prettier@3.4.0: + resolution: {integrity: sha512-UDK6rJT6INSfcOo545jiaOwB701uAIt2/dR7WnFQoGCVl1/EMqdANBmwUaqqQ45aXprsTGzSa39LI1PyuRBxxw==} + engines: {node: '>=6.0.0'} + peerDependencies: + eslint: '>=5.0.0' + eslint-config-prettier: '*' + prettier: '>=1.13.0' + peerDependenciesMeta: + eslint-config-prettier: + optional: true + + eslint-scope@5.1.1: + resolution: {integrity: sha512-2NxwbF/hZ0KpepYN0cNbo+FN6XoK7GaHlQhgx/hIZl6Va0bF45RQOOwhLIy8lQDbuCiadSLCBnH2CFYquit5bw==} + engines: {node: '>=8.0.0'} + + eslint-scope@7.2.2: + resolution: {integrity: sha512-dOt21O7lTMhDM+X9mB4GX+DZrZtCUJPL/wlcTqxyrx5IvO0IYtILdtrQGQp+8n5S0gwSVmOf9NQrjMOgfQZlIg==} + engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0} + + eslint-utils@3.0.0: + resolution: {integrity: sha512-uuQC43IGctw68pJA1RgbQS8/NP7rch6Cwd4j3ZBtgo4/8Flj4eGE7ZYSZRN3iq5pVUv6GPdW5Z1RFleo84uLDA==} + engines: {node: ^10.0.0 || ^12.0.0 || >= 14.0.0} + peerDependencies: + eslint: '>=5' + + eslint-visitor-keys@2.1.0: + resolution: {integrity: sha512-0rSmRBzXgDzIsD6mGdJgevzgezI534Cer5L/vyMX0kHzT/jiB43jRhd9YUlMGYLQy2zprNmoT8qasCGtY+QaKw==} + engines: {node: '>=10'} + + eslint-visitor-keys@3.4.3: + resolution: {integrity: sha512-wpc+LXeiyiisxPlEkUzU6svyS1frIO3Mgxj1fdy7Pm8Ygzguax2N3Fa/D/ag1WqbOprdI+uY6wMUl8/a2G+iag==} + engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0} + + eslint@8.57.0: + resolution: {integrity: sha512-dZ6+mexnaTIbSBZWgou51U6OmzIhYM2VcNdtiTtI7qPNZm35Akpr0f6vtw3w1Kmn5PYo+tZVfh13WrhpS6oLqQ==} + engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0} + hasBin: true + + esniff@2.0.1: + resolution: {integrity: sha512-kTUIGKQ/mDPFoJ0oVfcmyJn4iBDRptjNVIzwIFR7tqWXdVI9xfA2RMwY/gbSpJG3lkdWNEjLap/NqVHZiJsdfg==} + engines: {node: '>=0.10'} + + espree@9.6.1: + resolution: {integrity: sha512-oruZaFkjorTpF32kDSI5/75ViwGeZginGGy2NoOSg3Q9bnwlnmDm4HLnkl0RE3n+njDXR037aY1+x58Z/zFdwQ==} + engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0} + + esprima@2.7.3: + resolution: {integrity: sha512-OarPfz0lFCiW4/AV2Oy1Rp9qu0iusTKqykwTspGCZtPxmF81JR4MmIebvF1F9+UOKth2ZubLQ4XGGaU+hSn99A==} + engines: {node: '>=0.10.0'} + hasBin: true + + esprima@4.0.1: + resolution: {integrity: sha512-eGuFFw7Upda+g4p+QHvnW0RyTX/SVeJBDM/gCtMARO0cLuT2HcEKnTPvhjV6aGeqrCB/sbNop0Kszm0jsaWU4A==} + engines: {node: '>=4'} + hasBin: true + + esquery@1.5.0: + resolution: {integrity: sha512-YQLXUplAwJgCydQ78IMJywZCceoqk1oH01OERdSAJc/7U2AylwjhSCLDEtqwg811idIS/9fIU5GjG73IgjKMVg==} + engines: {node: '>=0.10'} + + esrecurse@4.3.0: + resolution: {integrity: sha512-KmfKL3b6G+RXvP8N1vr3Tq1kL/oCFgn2NYXEtqP8/L3pKapUA4G8cFVaoF3SU323CD4XypR/ffioHmkti6/Tag==} + engines: {node: '>=4.0'} + + estraverse@1.9.3: + resolution: {integrity: sha512-25w1fMXQrGdoquWnScXZGckOv+Wes+JDnuN/+7ex3SauFRS72r2lFDec0EKPt2YD1wUJ/IrfEex+9yp4hfSOJA==} + engines: {node: '>=0.10.0'} + + estraverse@4.3.0: + resolution: {integrity: sha512-39nnKffWz8xN1BU/2c79n9nB9HDzo0niYUqx6xyqUnyoAnQyyWpOTdZEeiCch8BBu515t4wp9ZmgVfVhn9EBpw==} + engines: {node: '>=4.0'} + + estraverse@5.3.0: + resolution: {integrity: sha512-MMdARuVEQziNTeJD8DgMqmhwR11BRQ/cBP+pLtYdSTnf3MIO8fFeiINEbX36ZdNlfU/7A9f3gUw49B3oQsvwBA==} + engines: {node: '>=4.0'} + + esutils@2.0.3: + resolution: {integrity: sha512-kVscqXk4OCp68SZ0dkgEKVi6/8ij300KBWTJq32P/dYeWTSwK41WyTxalN1eRmA5Z9UU/LX9D7FWSmV9SAYx6g==} + engines: {node: '>=0.10.0'} + + etag@1.8.1: + resolution: {integrity: sha512-aIL5Fx7mawVa300al2BnEE4iNvo1qETxLrPI/o05L7z6go7fCw1J6EQmbK4FmJ2AS7kgVF/KEZWufBfdClMcPg==} + engines: {node: '>= 0.6'} + + eth-ens-namehash@2.0.8: + resolution: {integrity: sha512-VWEI1+KJfz4Km//dadyvBBoBeSQ0MHTXPvr8UIXiLW6IanxvAV+DmlZAijZwAyggqGUfwQBeHf7tc9wzc1piSw==} + + eth-gas-reporter@0.2.27: + resolution: {integrity: sha512-femhvoAM7wL0GcI8ozTdxfuBtBFJ9qsyIAsmKVjlWAHUbdnnXHt+lKzz/kmldM5lA9jLuNHGwuIxorNpLbR1Zw==} + peerDependencies: + '@codechecks/client': ^0.1.0 + peerDependenciesMeta: + '@codechecks/client': + optional: true + + eth-lib@0.1.29: + resolution: {integrity: sha512-bfttrr3/7gG4E02HoWTDUcDDslN003OlOoBxk9virpAZQ1ja/jDgwkWB8QfJF7ojuEowrqy+lzp9VcJG7/k5bQ==} + + eth-lib@0.2.8: + resolution: {integrity: sha512-ArJ7x1WcWOlSpzdoTBX8vkwlkSQ85CjjifSZtV4co64vWxSV8geWfPI9x4SVYu3DSxnX4yWFVTtGL+j9DUFLNw==} + + ethereum-bloom-filters@1.1.0: + resolution: {integrity: sha512-J1gDRkLpuGNvWYzWslBQR9cDV4nd4kfvVTE/Wy4Kkm4yb3EYRSlyi0eB/inTsSTTVyA0+HyzHgbr95Fn/Z1fSw==} + + ethereum-cryptography@0.1.3: + resolution: {integrity: sha512-w8/4x1SGGzc+tO97TASLja6SLd3fRIK2tLVcV2Gx4IB21hE19atll5Cq9o3d0ZmAYC/8aw0ipieTSiekAea4SQ==} + + ethereum-cryptography@1.2.0: + resolution: {integrity: sha512-6yFQC9b5ug6/17CQpCyE3k9eKBMdhyVjzUy1WkiuY/E4vj/SXDBbCw8QEIaXqf0Mf2SnY6RmpDcwlUmBSS0EJw==} + + ethereum-cryptography@2.1.3: + resolution: {integrity: sha512-BlwbIL7/P45W8FGW2r7LGuvoEZ+7PWsniMvQ4p5s2xCyw9tmaDlpfsN9HjAucbF+t/qpVHwZUisgfK24TCW8aA==} + + ethereum-ens@0.8.0: + resolution: {integrity: sha512-a8cBTF4AWw1Q1Y37V1LSCS9pRY4Mh3f8vCg5cbXCCEJ3eno1hbI/+Ccv9SZLISYpqQhaglP3Bxb/34lS4Qf7Bg==} + + ethereumjs-abi@0.6.8: + resolution: {integrity: sha512-Tx0r/iXI6r+lRsdvkFDlut0N08jWMnKRZ6Gkq+Nmw75lZe4e6o3EkSnkaBP5NF6+m5PTGAr9JP43N3LyeoglsA==} + + ethereumjs-util@6.2.1: + resolution: {integrity: sha512-W2Ktez4L01Vexijrm5EB6w7dg4n/TgpoYU4avuT5T3Vmnw/eCRtiBrJfQYS/DCSvDIOLn2k57GcHdeBcgVxAqw==} + + ethereumjs-util@7.1.5: + resolution: {integrity: sha512-SDl5kKrQAudFBUe5OJM9Ac6WmMyYmXX/6sTmLZ3ffG2eY6ZIGBes3pEDxNN6V72WyOw4CPD5RomKdsa8DAAwLg==} + engines: {node: '>=10.0.0'} + + ethers@4.0.49: + resolution: {integrity: sha512-kPltTvWiyu+OktYy1IStSO16i2e7cS9D9OxZ81q2UUaiNPVrm/RTcbxamCXF9VUSKzJIdJV68EAIhTEVBalRWg==} + + ethers@5.7.2: + resolution: {integrity: sha512-wswUsmWo1aOK8rR7DIKiWSw9DbLWe6x98Jrn8wcTflTVvaXhAMaB5zGAXy0GYQEQp9iO1iSHWVyARQm11zUtyg==} + + ethers@6.12.1: + resolution: {integrity: sha512-j6wcVoZf06nqEcBbDWkKg8Fp895SS96dSnTCjiXT+8vt2o02raTn4Lo9ERUuIVU5bAjoPYeA+7ytQFexFmLuVw==} + engines: {node: '>=14.0.0'} + + ethjs-abi@0.1.8: + resolution: {integrity: sha512-3SIJpF+LCVJrNht9OjSJ7+3B9ABZf6dEATMj1PaslL0BW547Cz6/kGyuDvvrcEBlSsbGpCWYrJX5B8OjhcAMFQ==} + engines: {node: '>=6.5.0', npm: '>=3'} + + ethjs-unit@0.1.6: + resolution: {integrity: sha512-/Sn9Y0oKl0uqQuvgFk/zQgR7aw1g36qX/jzSQ5lSwlO0GigPymk4eGQfeNTD03w1dPOqfz8V77Cy43jH56pagw==} + engines: {node: '>=6.5.0', npm: '>=3'} + + ethjs-util@0.1.6: + resolution: {integrity: sha512-CUnVOQq7gSpDHZVVrQW8ExxUETWrnrvXYvYz55wOU8Uj4VCgw56XC2B/fVqQN+f7gmrnRHSLVnFAwsCuNwji8w==} + engines: {node: '>=6.5.0', npm: '>=3'} + + event-emitter@0.3.5: + resolution: {integrity: sha512-D9rRn9y7kLPnJ+hMq7S/nhvoKwwvVJahBi2BPmx3bvbsEdK3W9ii8cBSGjP+72/LnM4n6fo3+dkCX5FeTQruXA==} + + eventemitter3@4.0.4: + resolution: {integrity: sha512-rlaVLnVxtxvoyLsQQFBx53YmXHDxRIzzTLbdfxqi4yocpSjAxXwkU0cScM5JgSKMqEhrZpnvQ2D9gjylR0AimQ==} + + eventemitter3@5.0.1: + resolution: {integrity: sha512-GWkBvjiSZK87ELrYOSESUYeVIc9mvLLf/nXalMOS5dYrgZq9o5OVkbZAVM06CVxYsCwH9BDZFPlQTlPA1j4ahA==} + + events@3.3.0: + resolution: {integrity: sha512-mQw+2fkQbALzQ7V0MY0IqdnXNOeTtP4r0lN9z7AAawCXgqea7bDii20AYrIBrFd/Hx0M2Ocz6S111CaFkUcb0Q==} + engines: {node: '>=0.8.x'} + + evp_bytestokey@1.0.3: + resolution: {integrity: sha512-/f2Go4TognH/KvCISP7OUsHn85hT9nUkxxA9BEWxFn+Oj9o8ZNLm/40hdlgSLyuOimsrTKLUMEorQexp/aPQeA==} + + expand-template@2.0.3: + resolution: {integrity: sha512-XYfuKMvj4O35f/pOXLObndIRvyQ+/+6AhODh+OKWj9S9498pHHn/IMszH+gt0fBCRWMNfk1ZSp5x3AifmnI2vg==} + engines: {node: '>=6'} + + express@4.19.2: + resolution: {integrity: sha512-5T6nhjsT+EOMzuck8JjBHARTHfMht0POzlA60WV2pMD3gyXw2LZnZ+ueGdNxG+0calOJcWKbpFcuzLZ91YWq9Q==} + engines: {node: '>= 0.10.0'} + + ext@1.7.0: + resolution: {integrity: sha512-6hxeJYaL110a9b5TEJSj0gojyHQAmA2ch5Os+ySCiA1QGdS697XWY1pzsrSjqA9LDEEgdB/KypIlR59RcLuHYw==} + + extend@3.0.2: + resolution: {integrity: sha512-fjquC59cD7CyW6urNXK0FBufkZcoiGG80wTuPujX590cB5Ttln20E2UB4S/WARVqhXffZl2LNgS+gQdPIIim/g==} + + extendable-error@0.1.7: + resolution: {integrity: sha512-UOiS2in6/Q0FK0R0q6UY9vYpQ21mr/Qn1KOnte7vsACuNJf514WvCCUHSRCPcgjPT2bAhNIJdlE6bVap1GKmeg==} + + external-editor@3.1.0: + resolution: {integrity: sha512-hMQ4CX1p1izmuLYyZqLMO/qGNw10wSv9QDCPfzXfyFrOaCSSoRfqE1Kf1s5an66J5JZC62NewG+mK49jOCtQew==} + engines: {node: '>=4'} + + extsprintf@1.3.0: + resolution: {integrity: sha512-11Ndz7Nv+mvAC1j0ktTa7fAb0vLyGGX+rMHNBYQviQDGU0Hw7lhctJANqbPhu9nV9/izT/IntTgZ7Im/9LJs9g==} + engines: {'0': node >=0.6.0} + + fast-check@3.1.1: + resolution: {integrity: sha512-3vtXinVyuUKCKFKYcwXhGE6NtGWkqF8Yh3rvMZNzmwz8EPrgoc/v4pDdLHyLnCyCI5MZpZZkDEwFyXyEONOxpA==} + engines: {node: '>=8.0.0'} + + fast-deep-equal@1.1.0: + resolution: {integrity: sha512-fueX787WZKCV0Is4/T2cyAdM4+x1S3MXXOAhavE1ys/W42SHAPacLTQhucja22QBYrfGw50M2sRiXPtTGv9Ymw==} + + fast-deep-equal@3.1.3: + resolution: {integrity: sha512-f3qQ9oQy9j2AhBe/H9VC91wLmKBCCU/gDOnKNAYG5hswO7BLKj09Hc5HYNz9cGI++xlpDCIgDaitVs03ATR84Q==} + + fast-diff@1.3.0: + resolution: {integrity: sha512-VxPP4NqbUjj6MaAOafWeUn2cXWLcCtljklUtZf0Ind4XQ+QPtmA0b18zZy0jIQx+ExRVCR/ZQpBmik5lXshNsw==} + + fast-glob@3.3.2: + resolution: {integrity: sha512-oX2ruAFQwf/Orj8m737Y5adxDQO0LAB7/S5MnxCdTNDd4p6BsyIVsv9JQsATbTSq8KHRpLwIHbVlUNatxd+1Ow==} + engines: {node: '>=8.6.0'} + + fast-json-stable-stringify@2.1.0: + resolution: {integrity: sha512-lhd/wF+Lk98HZoTCtlVraHtfh5XYijIjalXck7saUtuanSDyLMxnHhSXEDJqHxD7msR8D0uCmqlkwjCV8xvwHw==} + + fast-levenshtein@2.0.6: + resolution: {integrity: sha512-DCXu6Ifhqcks7TZKY3Hxp3y6qphY5SJZmrWMDrKcERSOXWQdMhU9Ig/PYrzyw/ul9jOIyh0N4M0tbC5hodg8dw==} + + fast-safe-stringify@2.1.1: + resolution: {integrity: sha512-W+KJc2dmILlPplD/H4K9l9LcAHAfPtP6BY84uVLXQ6Evcz9Lcg33Y2z1IVblT6xdY54PXYVHEv+0Wpq8Io6zkA==} + + fastq@1.17.1: + resolution: {integrity: sha512-sRVD3lWVIXWg6By68ZN7vho9a1pQcN/WBFaAAsDDFzlJjvoGx0P8z7V1t72grFJfJhu3YPZBuu25f7Kaw2jN1w==} + + file-entry-cache@6.0.1: + resolution: {integrity: sha512-7Gps/XWymbLk2QLYK4NzpMOrYjMhdIxXuIvy2QBsLE6ljuodKvdkWs/cpyJJ3CVIVpH0Oi1Hvg1ovbMzLdFBBg==} + engines: {node: ^10.12.0 || >=12.0.0} + + file-uri-to-path@1.0.0: + resolution: {integrity: sha512-0Zt+s3L7Vf1biwWZ29aARiVYLx7iMGnEUl9x33fbB/j3jR81u/O2LbqK+Bm1CDSNDKVtJ/YjwY7TUd5SkeLQLw==} + + fill-range@7.0.1: + resolution: {integrity: sha512-qOo9F+dMUmC2Lcb4BbVvnKJxTPjCm+RRpe4gDuGrzkL7mEVl/djYSu2OdQ2Pa302N4oqkSg9ir6jaLWJ2USVpQ==} + engines: {node: '>=8'} + + finalhandler@1.2.0: + resolution: {integrity: sha512-5uXcUVftlQMFnWC9qu/svkWv3GTd2PfUhK/3PLkYNAe7FbqJMt3515HaxE6eRL74GdsriiwujiawdaB1BpEISg==} + engines: {node: '>= 0.8'} + + find-cache-dir@3.3.2: + resolution: {integrity: sha512-wXZV5emFEjrridIgED11OoUKLxiYjAcqot/NJdAkOhlJ+vGzwhOAfcG5OX1jP+S0PcjEn8bdMJv+g2jwQ3Onig==} + engines: {node: '>=8'} + + find-replace@3.0.0: + resolution: {integrity: sha512-6Tb2myMioCAgv5kfvP5/PkZZ/ntTpVK39fHY7WkWBgvbeE+VHd/tZuZ4mrC+bxh4cfOZeYKVPaJIZtZXV7GNCQ==} + engines: {node: '>=4.0.0'} + + find-up@1.1.2: + resolution: {integrity: sha512-jvElSjyuo4EMQGoTwo1uJU5pQMwTW5lS1x05zzfJuTIyLR3zwO27LYrxNg+dlvKpGOuGy/MzBdXh80g0ve5+HA==} + engines: {node: '>=0.10.0'} + + find-up@2.1.0: + resolution: {integrity: sha512-NWzkk0jSJtTt08+FBFMvXoeZnOJD+jTtsRmBYbAIzJdX6l7dLgR7CTubCM5/eDdPUBvLCeVasP1brfVR/9/EZQ==} + engines: {node: '>=4'} + + find-up@4.1.0: + resolution: {integrity: sha512-PpOwAdQ/YlXQ2vj8a3h8IipDuYRi3wceVQQGYWxNINccq40Anw7BlsEXCMbt1Zt+OLA6Fq9suIpIWD0OsnISlw==} + engines: {node: '>=8'} + + find-up@5.0.0: + resolution: {integrity: sha512-78/PXT1wlLLDgTzDs7sjq9hzz0vXD+zn+7wypEe4fXQxCmdmqfGsEPQxmiCSQI3ajFV91bVSsvNtrJRiW6nGng==} + engines: {node: '>=10'} + + find-yarn-workspace-root2@1.2.16: + resolution: {integrity: sha512-hr6hb1w8ePMpPVUK39S4RlwJzi+xPLuVuG8XlwXU3KD5Yn3qgBWVfy3AzNlDhWvE1EORCE65/Qm26rFQt3VLVA==} + + flat-cache@3.2.0: + resolution: {integrity: sha512-CYcENa+FtcUKLmhhqyctpclsq7QF38pKjZHsGNiSQF5r4FtoKDWabFDl3hzaEQMvT1LHEysw5twgLvpYYb4vbw==} + engines: {node: ^10.12.0 || >=12.0.0} + + flat@5.0.2: + resolution: {integrity: sha512-b6suED+5/3rTpUBdG1gupIl8MPFCAMA0QXwmljLhvCUKcUvdE4gWky9zpuGCcXHOsz4J9wPGNWq6OKpmIzz3hQ==} + hasBin: true + + flatted@3.3.1: + resolution: {integrity: sha512-X8cqMLLie7KsNUDSdzeN8FYK9rEt4Dt67OsG/DNGnYTSDBG4uFAJFBnUeiV+zCVAvwFy56IjM9sH51jVaEhNxw==} + + follow-redirects@1.15.6: + resolution: {integrity: sha512-wWN62YITEaOpSK584EZXJafH1AGpO8RVgElfkuXbTOrPX4fIfOyEpW/CsiNd8JdYrAoOvafRTOEnvsO++qCqFA==} + engines: {node: '>=4.0'} + peerDependencies: + debug: '*' + peerDependenciesMeta: + debug: + optional: true + + for-each@0.3.3: + resolution: {integrity: sha512-jqYfLp7mo9vIyQf8ykW2v7A+2N4QjeCeI5+Dz9XraiO1ign81wjiH7Fb9vSOWvQfNtmSa4H2RoQTrrXivdUZmw==} + + foreground-child@2.0.0: + resolution: {integrity: sha512-dCIq9FpEcyQyXKCkyzmlPTFNgrCzPudOe+mhvJU5zAtlBnGVy2yKxtfsxK2tQBThwq225jcvBjpw1Gr40uzZCA==} + engines: {node: '>=8.0.0'} + + forever-agent@0.6.1: + resolution: {integrity: sha512-j0KLYPhm6zeac4lz3oJ3o65qvgQCcPubiyotZrXqEaG4hNagNYO8qdlUrX5vwqv9ohqeT/Z3j6+yW067yWWdUw==} + + form-data-encoder@1.7.1: + resolution: {integrity: sha512-EFRDrsMm/kyqbTQocNvRXMLjc7Es2Vk+IQFx/YW7hkUH1eBl4J1fqiP34l74Yt0pFLCNpc06fkbVk00008mzjg==} + + form-data@2.3.3: + resolution: {integrity: sha512-1lLKB2Mu3aGP1Q/2eCOx0fNbRMe7XdwktwOruhfqqd0rIJWwN4Dh+E3hrPSlDCXnSR7UtZ1N38rVXm+6+MEhJQ==} + engines: {node: '>= 0.12'} + + form-data@2.5.1: + resolution: {integrity: sha512-m21N3WOmEEURgk6B9GLOE4RuWOFf28Lhh9qGYeNlGq4VDXUlJy2th2slBNU8Gp8EzloYZOibZJ7t5ecIrFSjVA==} + engines: {node: '>= 0.12'} + + form-data@4.0.0: + resolution: {integrity: sha512-ETEklSGi5t0QMZuiXoA/Q6vcnxcLQP5vdugSpuAyi6SVGi2clPPp+xgEhuMaHC+zGgn31Kd235W35f7Hykkaww==} + engines: {node: '>= 6'} + + forwarded@0.2.0: + resolution: {integrity: sha512-buRG0fpBtRHSTCOASe6hD258tEubFoRLb4ZNA6NxMVHNw2gOcwHo9wyablzMzOA5z9xA9L1KNjk/Nt6MT9aYow==} + engines: {node: '>= 0.6'} + + fp-ts@1.19.3: + resolution: {integrity: sha512-H5KQDspykdHuztLTg+ajGN0Z2qUjcEf3Ybxc6hLt0k7/zPkn29XnKnxlBPyW2XIddWrGaJBzBl4VLYOtk39yZg==} + + fresh@0.5.2: + resolution: {integrity: sha512-zJ2mQYM18rEFOudeV4GShTGIQ7RbzA7ozbU9I/XBpm7kqgMywgmylMwXHxZJmkVoYkna9d2pVXVXPdYTP9ej8Q==} + engines: {node: '>= 0.6'} + + fromentries@1.3.2: + resolution: {integrity: sha512-cHEpEQHUg0f8XdtZCc2ZAhrHzKzT0MrFUTcvx+hfxYu7rGMDc5SKoXFh+n4YigxsHXRzc6OrCshdR1bWH6HHyg==} + + fs-constants@1.0.0: + resolution: {integrity: sha512-y6OAwoSIf7FyjMIv94u+b5rdheZEjzR63GTyZJm5qh4Bi+2YgwLCcI/fPFZkL5PSixOt6ZNKm+w+Hfp/Bciwow==} + + fs-extra@0.30.0: + resolution: {integrity: sha512-UvSPKyhMn6LEd/WpUaV9C9t3zATuqoqfWc3QdPhPLb58prN9tqYPlPWi8Krxi44loBoUzlobqZ3+8tGpxxSzwA==} + + fs-extra@10.1.0: + resolution: {integrity: sha512-oRXApq54ETRj4eMiFzGnHWGy+zo5raudjuxN0b8H7s/RU2oW0Wvsx9O0ACRN/kRq9E8Vu/ReskGB5o3ji+FzHQ==} + engines: {node: '>=12'} + + fs-extra@4.0.3: + resolution: {integrity: sha512-q6rbdDd1o2mAnQreO7YADIxf/Whx4AHBiRf6d+/cVT8h44ss+lHgxf1FemcqDnQt9X3ct4McHr+JMGlYSsK7Cg==} + + fs-extra@7.0.1: + resolution: {integrity: sha512-YJDaCJZEnBmcbw13fvdAM9AwNOJwOzrE4pqMqBq5nFiEqXUqHwlK4B+3pUw6JNvfSPtX05xFHtYy/1ni01eGCw==} + engines: {node: '>=6 <7 || >=8'} + + fs-extra@8.1.0: + resolution: {integrity: sha512-yhlQgA6mnOJUKOsRUFsgJdQCvkKhcz8tlZG5HBQfReYZy46OwLcY+Zia0mtdHsOo9y/hP+CxMN0TU9QxoOtG4g==} + engines: {node: '>=6 <7 || >=8'} + + fs-extra@9.1.0: + resolution: {integrity: sha512-hcg3ZmepS30/7BSFqRvoo3DOMQu7IjqxO5nCDt+zM9XWjb33Wg7ziNT+Qvqbuc3+gWpzO02JubVyk2G4Zvo1OQ==} + engines: {node: '>=10'} + + fs-minipass@1.2.7: + resolution: {integrity: sha512-GWSSJGFy4e9GUeCcbIkED+bgAoFyj7XF1mV8rma3QW4NIqX9Kyx79N/PF61H5udOV3aY1IaMLs6pGbH71nlCTA==} + + fs-readdir-recursive@1.1.0: + resolution: {integrity: sha512-GNanXlVr2pf02+sPN40XN8HG+ePaNcvM0q5mZBd668Obwb0yD5GiUbZOFgwn8kGMY6I3mdyDJzieUy3PTYyTRA==} + + fs.realpath@1.0.0: + resolution: {integrity: sha512-OO0pH2lK6a0hZnAdau5ItzHPI6pUlvI7jMVnxUQRtw4owF2wk8lOSabtGDCTP4Ggrg2MbGnWO9X8K1t4+fGMDw==} + + fsevents@2.3.3: + resolution: {integrity: sha512-5xoDfX+fL7faATnagmWPpbFtwh/R77WmMMqqHGS65C3vvB0YHrgF+B1YmZ3441tMj5n63k0212XNoJwzlhffQw==} + engines: {node: ^8.16.0 || ^10.6.0 || >=11.0.0} + os: [darwin] + + function-bind@1.1.2: + resolution: {integrity: sha512-7XHNxH7qX9xG5mIwxkhumTox/MIRNcOgDrxWsMt2pAr23WHp6MrRlN7FBSFpCpr+oVO0F744iUgR82nJMfG2SA==} + + function.prototype.name@1.1.6: + resolution: {integrity: sha512-Z5kx79swU5P27WEayXM1tBi5Ze/lbIyiNgU3qyXUOf9b2rgXYyF9Dy9Cx+IQv/Lc8WCG6L82zwUPpSS9hGehIg==} + engines: {node: '>= 0.4'} + + functions-have-names@1.2.3: + resolution: {integrity: sha512-xckBUXyTIqT97tq2x2AMb+g163b5JFysYk0x4qxNFwbfQkmNZoiRHb6sPzI9/QV33WeuvVYBUIiD4NzNIyqaRQ==} + + ganache-cli@6.12.2: + resolution: {integrity: sha512-bnmwnJDBDsOWBUP8E/BExWf85TsdDEFelQSzihSJm9VChVO1SHp94YXLP5BlA4j/OTxp0wR4R1Tje9OHOuAJVw==} + deprecated: ganache-cli is now ganache; visit https://trfl.io/g7 for details + hasBin: true + bundledDependencies: + - source-map-support + - yargs + - ethereumjs-util + + gensync@1.0.0-beta.2: + resolution: {integrity: sha512-3hN7NaskYvMDLQY55gnW3NQ+mesEAepTqlg+VEbj7zzqEMBVNhzcGYYeqFo/TlYz6eQiFcp1HcsCZO+nGgS8zg==} + engines: {node: '>=6.9.0'} + + get-caller-file@1.0.3: + resolution: {integrity: sha512-3t6rVToeoZfYSGd8YoLFR2DJkiQrIiUrGcjvFX2mDw3bn6k2OtwHN0TNCLbBO+w8qTvimhDkv+LSscbJY1vE6w==} + + get-caller-file@2.0.5: + resolution: {integrity: sha512-DyFP3BM/3YHTQOCUL/w0OZHR0lpKeGrxotcHWcqNEdnltqFwXVfhEBQ94eIo34AfQpo0rGki4cyIiftY06h2Fg==} + engines: {node: 6.* || 8.* || >= 10.*} + + get-func-name@2.0.2: + resolution: {integrity: sha512-8vXOvuE167CtIc3OyItco7N/dpRtBbYOsPsXCz7X/PMnlGjYjSGuZJgM1Y7mmew7BKf9BqvLX2tnOVy1BBUsxQ==} + + get-intrinsic@1.2.4: + resolution: {integrity: sha512-5uYhsJH8VJBTv7oslg4BznJYhDoRI6waYCxMmCdnTrcCrHA/fCFKoTFz2JKKE0HdDFUF7/oQuhzumXJK7paBRQ==} + engines: {node: '>= 0.4'} + + get-package-type@0.1.0: + resolution: {integrity: sha512-pjzuKtY64GYfWizNAJ0fr9VqttZkNiK2iS430LtIHzjBEr6bX8Am2zm4sW4Ro5wjWW5cAlRL1qAMTcXbjNAO2Q==} + engines: {node: '>=8.0.0'} + + get-port@3.2.0: + resolution: {integrity: sha512-x5UJKlgeUiNT8nyo/AcnwLnZuZNcSjSw0kogRB+Whd1fjjFq4B1hySFxSFWWSn4mIBzg3sRNUDFYc4g5gjPoLg==} + engines: {node: '>=4'} + + get-port@5.1.1: + resolution: {integrity: sha512-g/Q1aTSDOxFpchXC4i8ZWvxA1lnPqx/JHqcpIw0/LX9T8x/GBbi6YnlN5nhaKIFkT8oFsscUKgDJYxfwfS6QsQ==} + engines: {node: '>=8'} + + get-stream@5.2.0: + resolution: {integrity: sha512-nBF+F1rAZVCu/p7rjzgA+Yb4lfYXrpl7a6VmJrU8wF9I1CKvP/QwPNZHnOlwbTkY6dvtFIzFMSyQXbLoTQPRpA==} + engines: {node: '>=8'} + + get-stream@6.0.1: + resolution: {integrity: sha512-ts6Wi+2j3jQjqi70w5AlN8DFnkSwC+MqmxEzdEALB2qXZYV3X/b1CTfgPLGJNMeAWxdPfU8FO1ms3NUfaHCPYg==} + engines: {node: '>=10'} + + get-symbol-description@1.0.2: + resolution: {integrity: sha512-g0QYk1dZBxGwk+Ngc+ltRH2IBp2f7zBkBMBJZCDerh6EhlhSR6+9irMCuT/09zD6qkarHUSn529sK/yL4S27mg==} + engines: {node: '>= 0.4'} + + get-tsconfig@4.7.5: + resolution: {integrity: sha512-ZCuZCnlqNzjb4QprAzXKdpp/gh6KTxSJuw3IBsPnV/7fV4NxC9ckB+vPTt8w7fJA0TaSD7c55BR47JD6MEDyDw==} + + getpass@0.1.7: + resolution: {integrity: sha512-0fzj9JxOLfJ+XGLhR8ze3unN0KZCgZwiSSDz168VERjK8Wl8kVSdcu2kspd4s4wtAa1y/qrVRiAA0WclVsu0ng==} + + ghost-testrpc@0.0.2: + resolution: {integrity: sha512-i08dAEgJ2g8z5buJIrCTduwPIhih3DP+hOCTyyryikfV8T0bNvHnGXO67i0DD1H4GBDETTclPy9njZbfluQYrQ==} + hasBin: true + + github-from-package@0.0.0: + resolution: {integrity: sha512-SyHy3T1v2NUXn29OsWdxmK6RwHD+vkj3v8en8AOBZ1wBQ/hCAQ5bAQTD02kW4W9tUp/3Qh6J8r9EvntiyCmOOw==} + + glob-parent@5.1.2: + resolution: {integrity: sha512-AOIgSQCepiJYwP3ARnGx+5VnTu2HBYdzbGP45eLw1vr3zB3vZLeyed1sC9hnbcOc9/SrMyM5RPQrkGz4aS9Zow==} + engines: {node: '>= 6'} + + glob-parent@6.0.2: + resolution: {integrity: sha512-XxwI8EOhVQgWp6iDL+3b0r86f4d6AX6zSU55HfB4ydCEuXLXc5FcYeOu+nnGftS4TEju/11rt4KJPTMgbfmv4A==} + engines: {node: '>=10.13.0'} + + glob@5.0.15: + resolution: {integrity: sha512-c9IPMazfRITpmAAKi22dK1VKxGDX9ehhqfABDriL/lzO92xcUKEJPQHrVA/2YHSNFB4iFlykVmWvwo48nr3OxA==} + + glob@7.1.7: + resolution: {integrity: sha512-OvD9ENzPLbegENnYP5UUfJIirTg4+XwMWGaQfQTY0JenxNvvIKP3U3/tAQSPIu/lHxXYSZmpXlUHeqAIdKzBLQ==} + + glob@7.2.0: + resolution: {integrity: sha512-lmLf6gtyrPq8tTjSmrO94wBeQbFR3HbLHbuyD69wuyQkImp2hWqMGB47OX65FBkPffO641IP9jWa1z4ivqG26Q==} + + glob@8.1.0: + resolution: {integrity: sha512-r8hpEjiQEYlF2QU0df3dS+nxxSIreXQS1qRhMJM0Q5NDdR386C7jb7Hwwod8Fgiuex+k0GFjgft18yvxm5XoCQ==} + engines: {node: '>=12'} + + global-modules@2.0.0: + resolution: {integrity: sha512-NGbfmJBp9x8IxyJSd1P+otYK8vonoJactOogrVfFRIAEY1ukil8RSKDz2Yo7wh1oihl51l/r6W4epkeKJHqL8A==} + engines: {node: '>=6'} + + global-prefix@3.0.0: + resolution: {integrity: sha512-awConJSVCHVGND6x3tmMaKcQvwXLhjdkmomy2W+Goaui8YPgYgXJZewhg3fWC+DlfqqQuWg8AwqjGTD2nAPVWg==} + engines: {node: '>=6'} + + global@4.4.0: + resolution: {integrity: sha512-wv/LAoHdRE3BeTGz53FAamhGlPLhlssK45usmGFThIi4XqnBmjKQ16u+RNbP7WvigRZDxUsM0J3gcQ5yicaL0w==} + + globals@11.12.0: + resolution: {integrity: sha512-WOBp/EEGUiIsJSp7wcv/y6MO+lV9UoncWqxuFfm8eBwzWNgyfBd6Gz+IeKQ9jCmyhoH99g15M3T+QaVHFjizVA==} + engines: {node: '>=4'} + + globals@13.24.0: + resolution: {integrity: sha512-AhO5QUcj8llrbG09iWhPU2B204J1xnPeL8kQmVorSsy+Sjj1sk8gIyh6cUocGmH4L0UuhAJy+hJMRA4mgA4mFQ==} + engines: {node: '>=8'} + + globalthis@1.0.4: + resolution: {integrity: sha512-DpLKbNU4WylpxJykQujfCcwYWiV/Jhm50Goo0wrVILAv5jOr9d+H+UR3PhSCD2rCCEIg0uc+G+muBTwD54JhDQ==} + engines: {node: '>= 0.4'} + + globby@10.0.2: + resolution: {integrity: sha512-7dUi7RvCoT/xast/o/dLN53oqND4yk0nsHkhRgn9w65C4PofCLOoJ39iSOg+qVDdWQPIEj+eszMHQ+aLVwwQSg==} + engines: {node: '>=8'} + + globby@11.1.0: + resolution: {integrity: sha512-jhIXaOzy1sb8IyocaruWSn1TjmnBVs8Ayhcy83rmxNJ8q2uWKCAj3CnJY+KpGSXCueAPc0i05kVvVKtP1t9S3g==} + engines: {node: '>=10'} + + gopd@1.0.1: + resolution: {integrity: sha512-d65bNlIadxvpb/A2abVdlqKqV563juRnZ1Wtk6s1sIR8uNsXR70xqIzVqxVf1eTqDunwT2MkczEeaezCKTZhwA==} + + got@11.8.6: + resolution: {integrity: sha512-6tfZ91bOr7bOXnK7PRDCGBLa1H4U080YHNaAQ2KsMGlLEzRbk44nsZF2E1IeRc3vtJHPVbKCYgdFbaGO2ljd8g==} + engines: {node: '>=10.19.0'} + + got@12.1.0: + resolution: {integrity: sha512-hBv2ty9QN2RdbJJMK3hesmSkFTjVIHyIDDbssCKnSmq62edGgImJWD10Eb1k77TiV1bxloxqcFAVK8+9pkhOig==} + engines: {node: '>=14.16'} + + graceful-fs@4.2.11: + resolution: {integrity: sha512-RbJ5/jmFcNNCcDV5o9eTnBLJ/HszWV0P73bc+Ff4nS/rJj+YaS6IGyiOL0VoBYX+l1Wrl3k63h/KrH+nhJ0XvQ==} + + grapheme-splitter@1.0.4: + resolution: {integrity: sha512-bzh50DW9kTPM00T8y4o8vQg89Di9oLJVLW/KaOGIXJWP/iqCN6WKYkbNOF04vFLJhwcpYUh9ydh/+5vpOqV4YQ==} + + graphemer@1.4.0: + resolution: {integrity: sha512-EtKwoO6kxCL9WO5xipiHTZlSzBm7WLT627TqC/uVRd0HKmq8NXyebnNYxDoBi7wt8eTWrUrKXCOVaFq9x1kgag==} + + handlebars@4.7.8: + resolution: {integrity: sha512-vafaFqs8MZkRrSX7sFVUdo3ap/eNiLnb4IakshzvP56X5Nr1iGKAIqdX6tMlm6HcNRIkr6AxO5jFEoJzzpT8aQ==} + engines: {node: '>=0.4.7'} + hasBin: true + + har-schema@2.0.0: + resolution: {integrity: sha512-Oqluz6zhGX8cyRaTQlFMPw80bSJVG2x/cFb8ZPhUILGgHka9SsokCCOQgpveePerqidZOrT14ipqfJb7ILcW5Q==} + engines: {node: '>=4'} + + har-validator@5.1.5: + resolution: {integrity: sha512-nmT2T0lljbxdQZfspsno9hgrG3Uir6Ks5afism62poxqBM6sDnMEuPmzTq8XN0OEwqKLLdh1jQI3qyE66Nzb3w==} + engines: {node: '>=6'} + deprecated: this library is no longer supported + + hard-rejection@2.1.0: + resolution: {integrity: sha512-VIZB+ibDhx7ObhAe7OVtoEbuP4h/MuOTHJ+J8h/eBXotJYl0fBgR72xDFCKgIh22OJZIOVNxBMWuhAr10r8HdA==} + engines: {node: '>=6'} + + hardhat-gas-reporter@1.0.10: + resolution: {integrity: sha512-02N4+So/fZrzJ88ci54GqwVA3Zrf0C9duuTyGt0CFRIh/CdNwbnTgkXkRfojOMLBQ+6t+lBIkgbsOtqMvNwikA==} + peerDependencies: + hardhat: ^2.0.2 + + has-bigints@1.0.2: + resolution: {integrity: sha512-tSvCKtBr9lkF0Ex0aQiP9N+OpV4zi2r/Nee5VkRDbaqv35RLYMzbwQfFSZZH0kR+Rd6302UJZ2p/bJCEoR3VoQ==} + + has-color@0.1.7: + resolution: {integrity: sha512-kaNz5OTAYYmt646Hkqw50/qyxP2vFnTVu5AQ1Zmk22Kk5+4Qx6BpO8+u7IKsML5fOsFk0ZT0AcCJNYwcvaLBvw==} + engines: {node: '>=0.10.0'} + + has-flag@1.0.0: + resolution: {integrity: sha512-DyYHfIYwAJmjAjSSPKANxI8bFY9YtFrgkAfinBojQ8YJTOuOuav64tMUJv584SES4xl74PmuaevIyaLESHdTAA==} + engines: {node: '>=0.10.0'} + + has-flag@3.0.0: + resolution: {integrity: sha512-sKJf1+ceQBr4SMkvQnBDNDtf4TXpVhVGateu0t918bl30FnbE2m4vNLX+VWe/dpjlb+HugGYzW7uQXH98HPEYw==} + engines: {node: '>=4'} + + has-flag@4.0.0: + resolution: {integrity: sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ==} + engines: {node: '>=8'} + + has-property-descriptors@1.0.2: + resolution: {integrity: sha512-55JNKuIW+vq4Ke1BjOTjM2YctQIvCT7GFzHwmfZPGo5wnrgkid0YQtnAleFSqumZm4az3n2BS+erby5ipJdgrg==} + + has-proto@1.0.3: + resolution: {integrity: sha512-SJ1amZAJUiZS+PhsVLf5tGydlaVB8EdFpaSO4gmiUKUOxk8qzn5AIy4ZeJUmh22znIdk/uMAUT2pl3FxzVUH+Q==} + engines: {node: '>= 0.4'} + + has-symbols@1.0.3: + resolution: {integrity: sha512-l3LCuF6MgDNwTDKkdYGEihYjt5pRPbEg46rtlmnSPlUbgmB8LOIrKJbYYFBSbnPaJexMKtiPO8hmeRjRz2Td+A==} + engines: {node: '>= 0.4'} + + has-tostringtag@1.0.2: + resolution: {integrity: sha512-NqADB8VjPFLM2V0VvHUewwwsw0ZWBaIdgo+ieHtK3hasLz4qeCRjYcqfB6AQrBggRKppKF8L52/VqdVsO47Dlw==} + engines: {node: '>= 0.4'} + + has@1.0.4: + resolution: {integrity: sha512-qdSAmqLF6209RFj4VVItywPMbm3vWylknmB3nvNiUIs72xAimcM8nVYxYr7ncvZq5qzk9MKIZR8ijqD/1QuYjQ==} + engines: {node: '>= 0.4.0'} + + hash-base@3.1.0: + resolution: {integrity: sha512-1nmYp/rhMDiE7AYkDw+lLwlAzz0AntGIe51F3RfFfEqyQ3feY2eI/NcwC6umIQVOASPMsWJLJScWKSSvzL9IVA==} + engines: {node: '>=4'} + + hash.js@1.1.3: + resolution: {integrity: sha512-/UETyP0W22QILqS+6HowevwhEFJ3MBJnwTf75Qob9Wz9t0DPuisL8kW8YZMK62dHAKE1c1p+gY1TtOLY+USEHA==} + + hash.js@1.1.7: + resolution: {integrity: sha512-taOaskGt4z4SOANNseOviYDvjEJinIkRgmp7LbKP2YTTmVxWBl87s/uzK9r+44BclBSp2X7K1hqeNfz9JbBeXA==} + + hasha@5.2.2: + resolution: {integrity: sha512-Hrp5vIK/xr5SkeN2onO32H0MgNZ0f17HRNH39WfL0SYUNOTZ5Lz1TJ8Pajo/87dYGEFlLMm7mIc/k/s6Bvz9HQ==} + engines: {node: '>=8'} + + hasown@2.0.2: + resolution: {integrity: sha512-0hJU9SCPvmMzIBdZFqNPXWa6dqh7WdH0cII9y+CyS8rG3nL48Bclra9HmKhVVUHyPWNH5Y7xDwAB7bfgSjkUMQ==} + engines: {node: '>= 0.4'} + + he@1.2.0: + resolution: {integrity: sha512-F/1DnUGPopORZi0ni+CvrCgHQ5FyEAHRLSApuYWMmrbSwoN2Mn/7k+Gl38gJnR7yyDZk6WLXwiGod1JOWNDKGw==} + hasBin: true + + header-case@1.0.1: + resolution: {integrity: sha512-i0q9mkOeSuhXw6bGgiQCCBgY/jlZuV/7dZXyZ9c6LcBrqwvT8eT719E9uxE5LiZftdl+z81Ugbg/VvXV4OJOeQ==} + + heap@0.2.7: + resolution: {integrity: sha512-2bsegYkkHO+h/9MGbn6KWcE45cHZgPANo5LXF7EvWdT0yT2EguSVO1nDgU5c8+ZOPwp2vMNa7YFsJhVcDR9Sdg==} + + highlight.js@10.7.3: + resolution: {integrity: sha512-tzcUFauisWKNHaRkN4Wjl/ZA07gENAjFl3J/c480dprkGTg5EQstgaNFqBfUqCq54kZRIEcreTsAgF/m2quD7A==} + + highlightjs-solidity@2.0.6: + resolution: {integrity: sha512-DySXWfQghjm2l6a/flF+cteroJqD4gI8GSdL4PtvxZSsAHie8m3yVe2JFoRg03ROKT6hp2Lc/BxXkqerNmtQYg==} + + hmac-drbg@1.0.1: + resolution: {integrity: sha512-Tti3gMqLdZfhOQY1Mzf/AanLiqh1WTiJgEj26ZuYQ9fbkLomzGchCws4FyrSd4VkpBfiNhaE1On+lOz894jvXg==} + + hosted-git-info@2.8.9: + resolution: {integrity: sha512-mxIDAb9Lsm6DoOJ7xH+5+X4y1LU/4Hi50L9C5sIswK3JzULS4bwk1FvjdBgvYR4bzT4tuUQiC15FE2f5HbLvYw==} + + html-escaper@2.0.2: + resolution: {integrity: sha512-H2iMtd0I4Mt5eYiapRdIDjp+XzelXQ0tFE4JS7YFwFevXXMmOp9myNrUvCg0D6ws8iqkRPBfKHgbwig1SmlLfg==} + + htmlparser2@8.0.2: + resolution: {integrity: sha512-GYdjWKDkbRLkZ5geuHs5NY1puJ+PXwP7+fHPRz06Eirsb9ugf6d8kkXav6ADhcODhFFPMIXyxkxSuMf3D6NCFA==} + + http-basic@8.1.3: + resolution: {integrity: sha512-/EcDMwJZh3mABI2NhGfHOGOeOZITqfkEO4p/xK+l3NpyncIHUQBoMvCSF/b5GqvKtySC2srL/GGG3+EtlqlmCw==} + engines: {node: '>=6.0.0'} + + http-cache-semantics@4.1.1: + resolution: {integrity: sha512-er295DKPVsV82j5kw1Gjt+ADA/XYHsajl82cGNQG2eyoPkvgUhX+nDIyelzhIWbbsXP39EHcI6l5tYs2FYqYXQ==} + + http-errors@2.0.0: + resolution: {integrity: sha512-FtwrG/euBzaEjYeRqOgly7G0qviiXoJWnvEH2Z1plBdXgbyjv34pHTSb9zoeHMyDy33+DWy5Wt9Wo+TURtOYSQ==} + engines: {node: '>= 0.8'} + + http-https@1.0.0: + resolution: {integrity: sha512-o0PWwVCSp3O0wS6FvNr6xfBCHgt0m1tvPLFOCc2iFDKTRAXhB7m8klDf7ErowFH8POa6dVdGatKU5I1YYwzUyg==} + + http-response-object@3.0.2: + resolution: {integrity: sha512-bqX0XTF6fnXSQcEJ2Iuyr75yVakyjIDCqroJQ/aHfSdlM743Cwqoi2nDYMzLGWUcuTWGWy8AAvOKXTfiv6q9RA==} + + http-signature@1.2.0: + resolution: {integrity: sha512-CAbnr6Rz4CYQkLYUtSNXxQPUH2gK8f3iWexVlsnMeD+GjlsQ0Xsy1cOX+mN3dtxYomRy21CiOzU8Uhw6OwncEQ==} + engines: {node: '>=0.8', npm: '>=1.3.7'} + + http2-wrapper@1.0.3: + resolution: {integrity: sha512-V+23sDMr12Wnz7iTcDeJr3O6AIxlnvT/bmaAAAP/Xda35C90p9599p0F1eHR/N1KILWSoWVAiOMFjBBXaXSMxg==} + engines: {node: '>=10.19.0'} + + http2-wrapper@2.2.1: + resolution: {integrity: sha512-V5nVw1PAOgfI3Lmeaj2Exmeg7fenjhRUgz1lPSezy1CuhPYbgQtbQj4jZfEAEMlaL+vupsvhjqCyjzob0yxsmQ==} + engines: {node: '>=10.19.0'} + + https-proxy-agent@5.0.1: + resolution: {integrity: sha512-dFcAjpTQFgoLMzC2VwU+C/CbS7uRL0lWmxDITmqm7C+7F0Odmj6s9l6alZc6AELXhrnggM2CeWSXHGOdX2YtwA==} + engines: {node: '>= 6'} + + human-id@1.0.2: + resolution: {integrity: sha512-UNopramDEhHJD+VR+ehk8rOslwSfByxPIZyJRfV739NDhN5LF1fa1MqnzKm2lGTQRjNrjK19Q5fhkgIfjlVUKw==} + + iconv-lite@0.4.24: + resolution: {integrity: sha512-v3MXnZAcvnywkTUEZomIActle7RXXeedOR31wwl7VlyoXO4Qi9arvSenNQWne1TcRwhCL1HwLI21bEqdpj8/rA==} + engines: {node: '>=0.10.0'} + + idna-uts46-hx@2.3.1: + resolution: {integrity: sha512-PWoF9Keq6laYdIRwwCdhTPl60xRqAloYNMQLiyUnG42VjT53oW07BXIRM+NK7eQjzXjAk2gUvX9caRxlnF9TAA==} + engines: {node: '>=4.0.0'} + + ieee754@1.2.1: + resolution: {integrity: sha512-dcyqhDvX1C46lXZcVqCpK+FtMRQVdIMN6/Df5js2zouUsqG7I6sFxitIC+7KYK29KdXOLHdu9zL4sFnoVQnqaA==} + + ignore@5.3.1: + resolution: {integrity: sha512-5Fytz/IraMjqpwfd34ke28PTVMjZjJG2MPn5t7OE4eUCUNf8BAa7b5WUS9/Qvr6mwOQS7Mk6vdsMno5he+T8Xw==} + engines: {node: '>= 4'} + + immer@10.0.2: + resolution: {integrity: sha512-Rx3CqeqQ19sxUtYV9CU911Vhy8/721wRFnJv3REVGWUmoAcIwzifTsdmJte/MV+0/XpM35LZdQMBGkRIoLPwQA==} + + immutable@4.3.5: + resolution: {integrity: sha512-8eabxkth9gZatlwl5TBuJnCsoTADlL6ftEr7A4qgdaTsPyreilDSnUk57SO+jfKcNtxPa22U5KK6DSeAYhpBJw==} + + import-fresh@3.3.0: + resolution: {integrity: sha512-veYYhQa+D1QBKznvhUHxb8faxlrwUnxseDAbAp457E0wLNio2bOSKnjYDhMj+YiAq61xrMGhQk9iXVk5FzgQMw==} + engines: {node: '>=6'} + + imurmurhash@0.1.4: + resolution: {integrity: sha512-JmXMZ6wuvDmLiHEml9ykzqO6lwFbof0GG4IkcGaENdCRDDmMVnny7s5HsIgHCbaq0w2MyPhDqkhTUgS2LU2PHA==} + engines: {node: '>=0.8.19'} + + indent-string@4.0.0: + resolution: {integrity: sha512-EdDDZu4A2OyIK7Lr/2zG+w5jmbuk1DVBnEwREQvBzspBJkCEbRa8GxU1lghYcaGJCnRWibjDXlq779X1/y5xwg==} + engines: {node: '>=8'} + + inflight@1.0.6: + resolution: {integrity: sha512-k92I/b08q4wvFscXCLvqfsHCrjrF7yiXsQuIVvVE7N82W3+aqpzuUdBbfhWcy/FZR3/4IgflMgKLOsvPDrGCJA==} + + inherits@2.0.4: + resolution: {integrity: sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ==} + + ini@1.3.8: + resolution: {integrity: sha512-JV/yugV2uzW5iMRSiZAyDtQd+nxtUnjeLt0acNdw98kKLrvuRVyB80tsREOE7yvGVgalhZ6RNXCmEHkUKBKxew==} + + internal-slot@1.0.7: + resolution: {integrity: sha512-NGnrKwXzSms2qUUih/ILZ5JBqNTSa1+ZmP6flaIp6KmSElgE9qdndzS3cqjrDovwFdmwsGsLdeFgB6suw+1e9g==} + engines: {node: '>= 0.4'} + + interpret@1.4.0: + resolution: {integrity: sha512-agE4QfB2Lkp9uICn7BAqoscw4SZP9kTE2hxiFI3jBPmXJfdqiahTbUuKGsMoN2GtqL9AxhYioAcVvgsb1HvRbA==} + engines: {node: '>= 0.10'} + + invariant@2.2.4: + resolution: {integrity: sha512-phJfQVBuaJM5raOpJjSfkiD6BpbCE4Ns//LaXl6wGYtUBY83nWS6Rf9tXm2e8VaK60JEjYldbPif/A2B1C2gNA==} + + invert-kv@1.0.0: + resolution: {integrity: sha512-xgs2NH9AE66ucSq4cNG1nhSFghr5l6tdL15Pk+jl46bmmBapgoaY/AacXyaDznAqmGL99TiLSQgO/XazFSKYeQ==} + engines: {node: '>=0.10.0'} + + io-ts@1.10.4: + resolution: {integrity: sha512-b23PteSnYXSONJ6JQXRAlvJhuw8KOtkqa87W4wDtvMrud/DTJd5X+NpOOI+O/zZwVq6v0VLAaJ+1EDViKEuN9g==} + + ipaddr.js@1.9.1: + resolution: {integrity: sha512-0KI/607xoxSToH7GjN1FfSbLoU0+btTicjsQSWQlh/hZykN8KpmMf7uYwPW3R+akZ6R/w18ZlXSHBYXiYUPO3g==} + engines: {node: '>= 0.10'} + + is-arguments@1.1.1: + resolution: {integrity: sha512-8Q7EARjzEnKpt/PCD7e1cgUS0a6X8u5tdSiMqXhojOdoV9TsMsiO+9VLC5vAmO8N7/GmXn7yjR8qnA6bVAEzfA==} + engines: {node: '>= 0.4'} + + is-array-buffer@3.0.4: + resolution: {integrity: sha512-wcjaerHw0ydZwfhiKbXJWLDY8A7yV7KhjQOpb83hGgGfId/aQa4TOvwyzn2PuswW2gPCYEL/nEAiSVpdOj1lXw==} + engines: {node: '>= 0.4'} + + is-arrayish@0.2.1: + resolution: {integrity: sha512-zz06S8t0ozoDXMG+ube26zeCTNXcKIPJZJi8hBrF4idCLms4CG9QtK7qBl1boi5ODzFpjswb5JPmHCbMpjaYzg==} + + is-bigint@1.0.4: + resolution: {integrity: sha512-zB9CruMamjym81i2JZ3UMn54PKGsQzsJeo6xvN3HJJ4CAsQNB6iRutp2To77OfCNuoxspsIhzaPoO1zyCEhFOg==} + + is-binary-path@2.1.0: + resolution: {integrity: sha512-ZMERYes6pDydyuGidse7OsHxtbI7WVeUEozgR/g7rd0xUimYNlvZRE/K2MgZTjWy725IfelLeVcEM97mmtRGXw==} + engines: {node: '>=8'} + + is-boolean-object@1.1.2: + resolution: {integrity: sha512-gDYaKHJmnj4aWxyj6YHyXVpdQawtVLHU5cb+eztPGczf6cjuTdwve5ZIEfgXqH4e57An1D1AKf8CZ3kYrQRqYA==} + engines: {node: '>= 0.4'} + + is-builtin-module@3.2.1: + resolution: {integrity: sha512-BSLE3HnV2syZ0FK0iMA/yUGplUeMmNz4AW5fnTunbCIqZi4vG3WjJT9FHMy5D69xmAYBHXQhJdALdpwVxV501A==} + engines: {node: '>=6'} + + is-callable@1.2.7: + resolution: {integrity: sha512-1BC0BVFhS/p0qtw6enp8e+8OD0UrK0oFLztSjNzhcKA3WDuJxxAPXzPuPtKkjEY9UUoEWlX/8fgKeu2S8i9JTA==} + engines: {node: '>= 0.4'} + + is-core-module@2.13.1: + resolution: {integrity: sha512-hHrIjvZsftOsvKSn2TRYl63zvxsgE0K+0mYMoH6gD4omR5IWB2KynivBQczo3+wF1cCkjzvptnI9Q0sPU66ilw==} + + is-data-view@1.0.1: + resolution: {integrity: sha512-AHkaJrsUVW6wq6JS8y3JnM/GJF/9cf+k20+iDzlSaJrinEo5+7vRiteOSwBhHRiAyQATN1AmY4hwzxJKPmYf+w==} + engines: {node: '>= 0.4'} + + is-date-object@1.0.5: + resolution: {integrity: sha512-9YQaSxsAiSwcvS33MBk3wTCVnWK+HhF8VZR2jRxehM16QcVOdHqPn4VPHmRK4lSr38n9JriurInLcP90xsYNfQ==} + engines: {node: '>= 0.4'} + + is-extglob@2.1.1: + resolution: {integrity: sha512-SbKbANkN603Vi4jEZv49LeVJMn4yGwsbzZworEoyEiutsN3nJYdbO36zfhGJ6QEDpOZIFkDtnq5JRxmvl3jsoQ==} + engines: {node: '>=0.10.0'} + + is-fullwidth-code-point@1.0.0: + resolution: {integrity: sha512-1pqUqRjkhPJ9miNq9SwMfdvi6lBJcd6eFxvfaivQhaH3SgisfiuudvFntdKOmxuee/77l+FPjKrQjWvmPjWrRw==} + engines: {node: '>=0.10.0'} + + is-fullwidth-code-point@2.0.0: + resolution: {integrity: sha512-VHskAKYM8RfSFXwee5t5cbN5PZeq1Wrh6qd5bkyiXIf6UQcN6w/A0eXM9r6t8d+GYOh+o6ZhiEnb88LN/Y8m2w==} + engines: {node: '>=4'} + + is-fullwidth-code-point@3.0.0: + resolution: {integrity: sha512-zymm5+u+sCsSWyD9qNaejV3DFvhCKclKdizYaJUuHA83RLjb7nSuGnddCHGv0hk+KY7BMAlsWeK4Ueg6EV6XQg==} + engines: {node: '>=8'} + + is-function@1.0.2: + resolution: {integrity: sha512-lw7DUp0aWXYg+CBCN+JKkcE0Q2RayZnSvnZBlwgxHBQhqt5pZNVy4Ri7H9GmmXkdu7LUthszM+Tor1u/2iBcpQ==} + + is-generator-function@1.0.10: + resolution: {integrity: sha512-jsEjy9l3yiXEQ+PsXdmBwEPcOxaXWLspKdplFUVI9vq1iZgIekeC0L167qeu86czQaxed3q/Uzuw0swL0irL8A==} + engines: {node: '>= 0.4'} + + is-glob@4.0.3: + resolution: {integrity: sha512-xelSayHH36ZgE7ZWhli7pW34hNbNl8Ojv5KVmkJD4hBdD3th8Tfk9vYasLM+mXWOZhFkgZfxhLSnrwRr4elSSg==} + engines: {node: '>=0.10.0'} + + is-hex-prefixed@1.0.0: + resolution: {integrity: sha512-WvtOiug1VFrE9v1Cydwm+FnXd3+w9GaeVUss5W4v/SLy3UW00vP+6iNF2SdnfiBoLy4bTqVdkftNGTUeOFVsbA==} + engines: {node: '>=6.5.0', npm: '>=3'} + + is-interactive@1.0.0: + resolution: {integrity: sha512-2HvIEKRoqS62guEC+qBjpvRubdX910WCMuJTZ+I9yvqKU2/12eSL549HMwtabb4oupdj2sMP50k+XJfB/8JE6w==} + engines: {node: '>=8'} + + is-lower-case@1.1.3: + resolution: {integrity: sha512-+5A1e/WJpLLXZEDlgz4G//WYSHyQBD32qa4Jd3Lw06qQlv3fJHnp3YIHjTQSGzHMgzmVKz2ZP3rBxTHkPw/lxA==} + + is-negative-zero@2.0.3: + resolution: {integrity: sha512-5KoIu2Ngpyek75jXodFvnafB6DJgr3u8uuK0LEZJjrU19DrMD3EVERaR8sjz8CCGgpZvxPl9SuE1GMVPFHx1mw==} + engines: {node: '>= 0.4'} + + is-number-object@1.0.7: + resolution: {integrity: sha512-k1U0IRzLMo7ZlYIfzRu23Oh6MiIFasgpb9X76eqfFZAqwH44UI4KTBvBYIZ1dSL9ZzChTB9ShHfLkR4pdW5krQ==} + engines: {node: '>= 0.4'} + + is-number@7.0.0: + resolution: {integrity: sha512-41Cifkg6e8TylSpdtTpeLVMqvSBEVzTttHvERD741+pnZ8ANv0004MRL43QKPDlK9cGvNp6NZWZUBlbGXYxxng==} + engines: {node: '>=0.12.0'} + + is-path-inside@3.0.3: + resolution: {integrity: sha512-Fd4gABb+ycGAmKou8eMftCupSir5lRxqf4aD/vd0cD2qc4HL07OjCeuHMr8Ro4CoMaeCKDB0/ECBOVWjTwUvPQ==} + engines: {node: '>=8'} + + is-plain-obj@1.1.0: + resolution: {integrity: sha512-yvkRyxmFKEOQ4pNXCmJG5AEQNlXJS5LaONXo5/cLdTZdWvsZ1ioJEonLGAosKlMWE8lwUy/bJzMjcw8az73+Fg==} + engines: {node: '>=0.10.0'} + + is-plain-obj@2.1.0: + resolution: {integrity: sha512-YWnfyRwxL/+SsrWYfOpUtz5b3YD+nyfkHvjbcanzk8zgyO4ASD67uVMRt8k5bM4lLMDnXfriRhOpemw+NfT1eA==} + engines: {node: '>=8'} + + is-regex@1.1.4: + resolution: {integrity: sha512-kvRdxDsxZjhzUX07ZnLydzS1TU/TJlTUHHY4YLL87e37oUA49DfkLqgy+VjFocowy29cKvcSiu+kIv728jTTVg==} + engines: {node: '>= 0.4'} + + is-shared-array-buffer@1.0.3: + resolution: {integrity: sha512-nA2hv5XIhLR3uVzDDfCIknerhx8XUKnstuOERPNNIinXG7v9u+ohXF67vxm4TPTEPU6lm61ZkwP3c9PCB97rhg==} + engines: {node: '>= 0.4'} + + is-stream@2.0.1: + resolution: {integrity: sha512-hFoiJiTl63nn+kstHGBtewWSKnQLpyb155KHheA1l39uvtO9nWIop1p3udqPcUd/xbF1VLMO4n7OI6p7RbngDg==} + engines: {node: '>=8'} + + is-string@1.0.7: + resolution: {integrity: sha512-tE2UXzivje6ofPW7l23cjDOMa09gb7xlAqG6jG5ej6uPV32TlWP3NKPigtaGeHNu9fohccRYvIiZMfOOnOYUtg==} + engines: {node: '>= 0.4'} + + is-subdir@1.2.0: + resolution: {integrity: sha512-2AT6j+gXe/1ueqbW6fLZJiIw3F8iXGJtt0yDrZaBhAZEG1raiTxKWU+IPqMCzQAXOUCKdA4UDMgacKH25XG2Cw==} + engines: {node: '>=4'} + + is-symbol@1.0.4: + resolution: {integrity: sha512-C/CPBqKWnvdcxqIARxyOh4v1UUEOCHpgDa0WYgpKDFMszcrPcffg5uhwSgPCLD2WWxmq6isisz87tzT01tuGhg==} + engines: {node: '>= 0.4'} + + is-typed-array@1.1.13: + resolution: {integrity: sha512-uZ25/bUAlUY5fR4OKT4rZQEBrzQWYV9ZJYGGsUmEJ6thodVJ1HX64ePQ6Z0qPWP+m+Uq6e9UugrE38jeYsDSMw==} + engines: {node: '>= 0.4'} + + is-typedarray@1.0.0: + resolution: {integrity: sha512-cyA56iCMHAh5CdzjJIa4aohJyeO1YbwLi3Jc35MmRU6poroFjIGZzUzupGiRPOjgHg9TLu43xbpwXk523fMxKA==} + + is-unicode-supported@0.1.0: + resolution: {integrity: sha512-knxG2q4UC3u8stRGyAVJCOdxFmv5DZiRcdlIaAQXAbSfJya+OhopNotLQrstBhququ4ZpuKbDc/8S6mgXgPFPw==} + engines: {node: '>=10'} + + is-upper-case@1.1.2: + resolution: {integrity: sha512-GQYSJMgfeAmVwh9ixyk888l7OIhNAGKtY6QA+IrWlu9MDTCaXmeozOZ2S9Knj7bQwBO/H6J2kb+pbyTUiMNbsw==} + + is-url@1.2.4: + resolution: {integrity: sha512-ITvGim8FhRiYe4IQ5uHSkj7pVaPDrCTkNd3yq3cV7iZAcJdHTUMPMEHcqSOy9xZ9qFenQCvi+2wjH9a1nXqHww==} + + is-utf8@0.2.1: + resolution: {integrity: sha512-rMYPYvCzsXywIsldgLaSoPlw5PfoB/ssr7hY4pLfcodrA5M/eArza1a9VmTiNIBNMjOGr1Ow9mTyU2o69U6U9Q==} + + is-weakref@1.0.2: + resolution: {integrity: sha512-qctsuLZmIQ0+vSSMfoVvyFe2+GSEvnmZ2ezTup1SBse9+twCCeial6EEi3Nc2KFcf6+qz2FBPnjXsk8xhKSaPQ==} + + is-windows@1.0.2: + resolution: {integrity: sha512-eXK1UInq2bPmjyX6e3VHIzMLobc4J94i4AWn+Hpq3OU5KkrRC96OAcR3PRJ/pGu6m8TRnBHP9dkXQVsT/COVIA==} + engines: {node: '>=0.10.0'} + + isarray@0.0.1: + resolution: {integrity: sha512-D2S+3GLxWH+uhrNEcoh/fnmYeP8E8/zHl644d/jdA0g2uyXvy3sb0qxotE+ne0LtccHknQzWwZEzhak7oJ0COQ==} + + isarray@1.0.0: + resolution: {integrity: sha512-VLghIWNM6ELQzo7zwmcg0NmTVyWKYjvIeM83yjp0wRDTmUnrM678fQbcKBo6n2CJEF0szoG//ytg+TKla89ALQ==} + + isarray@2.0.5: + resolution: {integrity: sha512-xHjhDr3cNBK0BzdUJSPXZntQUx/mwMS5Rw4A7lPJ90XGAO6ISP/ePDNuo0vhqOZU+UD5JoodwCAAoZQd3FeAKw==} + + isexe@2.0.0: + resolution: {integrity: sha512-RHxMLp9lnKHGHRng9QFhRCMbYAcVpn69smSGcq3f36xjgVVWThj4qqLbTLlq7Ssj8B+fIQ1EuCEGI2lKsyQeIw==} + + isomorphic-fetch@3.0.0: + resolution: {integrity: sha512-qvUtwJ3j6qwsF3jLxkZ72qCgjMysPzDfeV240JHiGZsANBYd+EEuu35v7dfrJ9Up0Ak07D7GGSkGhCHTqg/5wA==} + + isomorphic-ws@5.0.0: + resolution: {integrity: sha512-muId7Zzn9ywDsyXgTIafTry2sV3nySZeUDe6YedVd1Hvuuep5AsIlqK+XefWpYTyJG5e503F2xIuT2lcU6rCSw==} + peerDependencies: + ws: '*' + + isows@1.0.3: + resolution: {integrity: sha512-2cKei4vlmg2cxEjm3wVSqn8pcoRF/LX/wpifuuNquFO4SQmPwarClT+SUCA2lt+l581tTeZIPIZuIDo2jWN1fg==} + peerDependencies: + ws: '*' + + isstream@0.1.2: + resolution: {integrity: sha512-Yljz7ffyPbrLpLngrMtZ7NduUgVvi6wG9RJ9IUcyCd59YQ911PBJphODUcbOVbqYfxe1wuYf/LJ8PauMRwsM/g==} + + istanbul-lib-coverage@3.2.2: + resolution: {integrity: sha512-O8dpsF+r0WV/8MNRKfnmrtCWhuKjxrq2w+jpzBL5UZKTi2LeVWnWOmWRxFlesJONmc+wLAGvKQZEOanko0LFTg==} + engines: {node: '>=8'} + + istanbul-lib-hook@3.0.0: + resolution: {integrity: sha512-Pt/uge1Q9s+5VAZ+pCo16TYMWPBIl+oaNIjgLQxcX0itS6ueeaA+pEfThZpH8WxhFgCiEb8sAJY6MdUKgiIWaQ==} + engines: {node: '>=8'} + + istanbul-lib-instrument@4.0.3: + resolution: {integrity: sha512-BXgQl9kf4WTCPCCpmFGoJkz/+uhvm7h7PFKUYxh7qarQd3ER33vHG//qaE8eN25l07YqZPpHXU9I09l/RD5aGQ==} + engines: {node: '>=8'} + + istanbul-lib-processinfo@2.0.3: + resolution: {integrity: sha512-NkwHbo3E00oybX6NGJi6ar0B29vxyvNwoC7eJ4G4Yq28UfY758Hgn/heV8VRFhevPED4LXfFz0DQ8z/0kw9zMg==} + engines: {node: '>=8'} + + istanbul-lib-report@3.0.1: + resolution: {integrity: sha512-GCfE1mtsHGOELCU8e/Z7YWzpmybrx/+dSTfLrvY8qRmaY6zXTKWn6WQIjaAFw069icm6GVMNkgu0NzI4iPZUNw==} + engines: {node: '>=10'} + + istanbul-lib-source-maps@4.0.1: + resolution: {integrity: sha512-n3s8EwkdFIJCG3BPKBYvskgXGoy88ARzvegkitk60NxRdwltLOTaH7CUiMRXvwYorl0Q712iEjcWB+fK/MrWVw==} + engines: {node: '>=10'} + + istanbul-reports@3.1.7: + resolution: {integrity: sha512-BewmUXImeuRk2YY0PVbxgKAysvhRPUQE0h5QRM++nVWyubKGV0l8qQ5op8+B2DOmwSe63Jivj0BjkPQVf8fP5g==} + engines: {node: '>=8'} + + jest-diff@29.7.0: + resolution: {integrity: sha512-LMIgiIrhigmPrs03JHpxUh2yISK3vLFPkAodPeo0+BuF7wA2FoQbkEg1u8gBYBThncu7e1oEDUfIXVuTqLRUjw==} + engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0} + + jest-get-type@29.6.3: + resolution: {integrity: sha512-zrteXnqYxfQh7l5FHyL38jL39di8H8rHoecLH3JNxH3BwOrBsNeabdap5e0I23lD4HHI8W5VFBZqG4Eaq5LNcw==} + engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0} + + js-sha3@0.5.5: + resolution: {integrity: sha512-yLLwn44IVeunwjpDVTDZmQeVbB0h+dZpY2eO68B/Zik8hu6dH+rKeLxwua79GGIvW6xr8NBAcrtiUbYrTjEFTA==} + + js-sha3@0.5.7: + resolution: {integrity: sha512-GII20kjaPX0zJ8wzkTbNDYMY7msuZcTWk8S5UOh6806Jq/wz1J8/bnr8uGU0DAUmYDjj2Mr4X1cW8v/GLYnR+g==} + + js-sha3@0.8.0: + resolution: {integrity: sha512-gF1cRrHhIzNfToc802P800N8PpXS+evLLXfsVpowqmAFR9uwbi89WvXg2QspOmXL8QL86J4T1EpFu+yUkwJY3Q==} + + js-tokens@4.0.0: + resolution: {integrity: sha512-RdJUflcE3cUzKiMqQgsCu06FPu9UdIJO0beYbPhHN4k6apgJtifcoCtT9bcxOpYBtpD2kCM6Sbzg4CausW/PKQ==} + + js-yaml@3.14.1: + resolution: {integrity: sha512-okMH7OXXJ7YrN9Ok3/SXrnu4iX9yOk+25nqX4imS2npuvTYDmo/QEZoqwZkYaIDk3jVvBOTOIEgEhaLOynBS9g==} + hasBin: true + + js-yaml@4.1.0: + resolution: {integrity: sha512-wpxZs9NoxZaJESJGIZTyDEaYpl0FKSA+FB9aJiyemKhMwkxQg63h4T1KJgUGHpTqPDNRcmmYLugrRjJlBtWvRA==} + hasBin: true + + jsbn@0.1.1: + resolution: {integrity: sha512-UVU9dibq2JcFWxQPA6KCqj5O42VOmAY3zQUfEKxU0KpTGXwNoCjkX1e13eHNvw/xPynt6pU0rZ1htjWTNTSXsg==} + + jsesc@2.5.2: + resolution: {integrity: sha512-OYu7XEzjkCQ3C5Ps3QIZsQfNpqoJyZZA99wd9aWd05NCtC5pWOkShK2mkL6HXQR6/Cy2lbNdPlZBpuQHXE63gA==} + engines: {node: '>=4'} + hasBin: true + + json-buffer@3.0.1: + resolution: {integrity: sha512-4bV5BfR2mqfQTJm+V5tPPdf+ZpuhiIvTuAB5g8kcrXOZpTT/QwwVRWBywX1ozr6lEuPdbHxwaJlm9G6mI2sfSQ==} + + json-parse-even-better-errors@2.3.1: + resolution: {integrity: sha512-xyFwyhro/JEof6Ghe2iz2NcXoj2sloNsWr/XsERDK/oiPCfaNhl5ONfp+jQdAZRQQ0IJWNzH9zIZF7li91kh2w==} + + json-schema-traverse@0.3.1: + resolution: {integrity: sha512-4JD/Ivzg7PoW8NzdrBSr3UFwC9mHgvI7Z6z3QGBsSHgKaRTUDmyZAAKJo2UbG1kUVfS9WS8bi36N49U1xw43DA==} + + json-schema-traverse@0.4.1: + resolution: {integrity: sha512-xbbCH5dCYU5T8LcEhhuh7HJ88HXuW3qsI3Y0zOZFKfZEHcpWiHU/Jxzk629Brsab/mMiHQti9wMP+845RPe3Vg==} + + json-schema-traverse@1.0.0: + resolution: {integrity: sha512-NM8/P9n3XjXhIZn1lLhkFaACTOURQXjWhV4BA/RnOv8xvgqtqpAX9IO4mRQxSx1Rlo4tqzeqb0sOlruaOy3dug==} + + json-schema@0.4.0: + resolution: {integrity: sha512-es94M3nTIfsEPisRafak+HDLfHXnKBhV3vU5eqPcS3flIWqcxJWgXHXiey3YrpaNsanY5ei1VoYEbOzijuq9BA==} + + json-stable-stringify-without-jsonify@1.0.1: + resolution: {integrity: sha512-Bdboy+l7tA3OGW6FjyFHWkP5LuByj1Tk33Ljyq0axyzdk9//JSi2u3fP1QSmd1KNwq6VOKYGlAu87CisVir6Pw==} + + json-stringify-safe@5.0.1: + resolution: {integrity: sha512-ZClg6AaYvamvYEE82d3Iyd3vSSIjQ+odgjaTzRuO3s7toCdFKczob2i0zCh7JE8kWn17yvAWhUVxvqGwUalsRA==} + + json5@1.0.2: + resolution: {integrity: sha512-g1MWMLBiz8FKi1e4w0UyVL3w+iJceWAFBAaBnnGKOpNa5f8TLktkbre1+s6oICydWAm+HRUGTmI+//xv2hvXYA==} + hasBin: true + + json5@2.2.3: + resolution: {integrity: sha512-XmOWe7eyHYH14cLdVPoyg+GOH3rYX++KpzrylJwSW98t3Nk+U8XOl8FWKOgwtzdb8lXGf6zYwDUzeHMWfxasyg==} + engines: {node: '>=6'} + hasBin: true + + jsonfile@2.4.0: + resolution: {integrity: sha512-PKllAqbgLgxHaj8TElYymKCAgrASebJrWpTnEkOaTowt23VKXXN0sUeriJ+eh7y6ufb/CC5ap11pz71/cM0hUw==} + + jsonfile@4.0.0: + resolution: {integrity: sha512-m6F1R3z8jjlf2imQHS2Qez5sjKWQzbuuhuJ/FKYFRZvPE3PuHcSMVZzfsLhGVOkfd20obL5SWEBew5ShlquNxg==} + + jsonfile@6.1.0: + resolution: {integrity: sha512-5dgndWOriYSm5cnYaJNhalLNDKOqFwyDB/rr1E9ZsGciGvKPs8R2xYGCacuf3z6K1YKDz182fd+fY3cn3pMqXQ==} + + jsonschema@1.4.1: + resolution: {integrity: sha512-S6cATIPVv1z0IlxdN+zUk5EPjkGCdnhN4wVSBlvoUO1tOLJootbo9CquNJmbIh4yikWHiUedhRYrNPn1arpEmQ==} + + jsprim@1.4.2: + resolution: {integrity: sha512-P2bSOMAc/ciLz6DzgjVlGJP9+BrJWu5UDGK70C2iweC5QBIeFf0ZXRvGjEj2uYgrY2MkAAhsSWHDWlFtEroZWw==} + engines: {node: '>=0.6.0'} + + just-extend@4.2.1: + resolution: {integrity: sha512-g3UB796vUFIY90VIv/WX3L2c8CS2MdWUww3CNrYmqza1Fg0DURc2K/O4YrnklBdQarSJ/y8JnJYDGc+1iumQjg==} + + keccak@3.0.4: + resolution: {integrity: sha512-3vKuW0jV8J3XNTzvfyicFR5qvxrSAGl7KIhvgOu5cmWwM7tZRj3fMbj/pfIf4be7aznbc+prBWGjywox/g2Y6Q==} + engines: {node: '>=10.0.0'} + + keyv@4.5.4: + resolution: {integrity: sha512-oxVHkHR/EJf2CNXnWxRLW6mg7JyCCUcG0DtEGmL2ctUo1PNTin1PUil+r/+4r5MpVgC/fn1kjsx7mjSujKqIpw==} + + kind-of@6.0.3: + resolution: {integrity: sha512-dcS1ul+9tmeD95T+x28/ehLgd9mENa3LsvDTtzm3vyBEO7RPptvAD+t44WVXaUjTBRcrpFeFlC8WCruUR456hw==} + engines: {node: '>=0.10.0'} + + klaw@1.3.1: + resolution: {integrity: sha512-TED5xi9gGQjGpNnvRWknrwAB1eL5GciPfVFOt3Vk1OJCVDQbzuSfrF3hkUQKlsgKrG1F+0t5W0m+Fje1jIt8rw==} + + kleur@3.0.3: + resolution: {integrity: sha512-eTIzlVOSUR+JxdDFepEYcBMtZ9Qqdef+rnzWdRZuMbOywu5tO2w2N7rqjoANZ5k9vywhL6Br1VRjUIgTQx4E8w==} + engines: {node: '>=6'} + + kleur@4.1.5: + resolution: {integrity: sha512-o+NO+8WrRiQEE4/7nwRJhN1HWpVmJm511pBHUxPLtp0BUISzlBplORYSmTclCnJvQq2tKu/sgl3xVpkc7ZWuQQ==} + engines: {node: '>=6'} + + lcid@1.0.0: + resolution: {integrity: sha512-YiGkH6EnGrDGqLMITnGjXtGmNtjoXw9SVUzcaos8RBi7Ps0VBylkq+vOcY9QE5poLasPCR849ucFUkl0UzUyOw==} + engines: {node: '>=0.10.0'} + + levn@0.3.0: + resolution: {integrity: sha512-0OO4y2iOHix2W6ujICbKIaEQXvFQHue65vUG3pb5EUomzPI90z9hsA1VsO/dbIIpC53J8gxM9Q4Oho0jrCM/yA==} + engines: {node: '>= 0.8.0'} + + levn@0.4.1: + resolution: {integrity: sha512-+bT2uH4E5LGE7h/n3evcS/sQlJXCpIp6ym8OWJ5eV6+67Dsql/LaaT7qJBAt2rzfoa/5QBGBhxDix1dMt2kQKQ==} + engines: {node: '>= 0.8.0'} + + lines-and-columns@1.2.4: + resolution: {integrity: sha512-7ylylesZQ/PV29jhEDl3Ufjo6ZX7gCqJr5F7PKrqc93v7fzSymt1BpwEU8nAUXs8qzzvqhbjhK5QZg6Mt/HkBg==} + + load-json-file@1.1.0: + resolution: {integrity: sha512-cy7ZdNRXdablkXYNI049pthVeXFurRyb9+hA/dZzerZ0pGTx42z+y+ssxBaVV2l70t1muq5IdKhn4UtcoGUY9A==} + engines: {node: '>=0.10.0'} + + load-yaml-file@0.2.0: + resolution: {integrity: sha512-OfCBkGEw4nN6JLtgRidPX6QxjBQGQf72q3si2uvqyFEMbycSFFHwAZeXx6cJgFM9wmLrf9zBwCP3Ivqa+LLZPw==} + engines: {node: '>=6'} + + locate-path@2.0.0: + resolution: {integrity: sha512-NCI2kiDkyR7VeEKm27Kda/iQHyKJe1Bu0FlTbYp3CqJu+9IFe9bLyAjMxf5ZDDbEg+iMPzB5zYyUTSm8wVTKmA==} + engines: {node: '>=4'} + + locate-path@5.0.0: + resolution: {integrity: sha512-t7hw9pI+WvuwNJXwk5zVHpyhIqzg2qTlklJOf0mVxGSbe3Fp2VieZcduNYjaLDoy6p9uGpQEGWG87WpMKlNq8g==} + engines: {node: '>=8'} + + locate-path@6.0.0: + resolution: {integrity: sha512-iPZK6eYjbxRu3uB4/WZ3EsEIMJFMqAoopl3R+zuq0UjcAm/MO6KCweDgPfP3elTztoKP3KtnVHxTn2NHBSDVUw==} + engines: {node: '>=10'} + + lodash.assign@4.2.0: + resolution: {integrity: sha512-hFuH8TY+Yji7Eja3mGiuAxBqLagejScbG8GbG0j6o9vzn0YL14My+ktnqtZgFTosKymC9/44wP6s7xyuLfnClw==} + + lodash.camelcase@4.3.0: + resolution: {integrity: sha512-TwuEnCnxbc3rAvhf/LbG7tJUDzhqXyFnv3dtzLOPgCG/hODL7WFnsbwktkD7yUV0RrreP/l1PALq/YSg6VvjlA==} + + lodash.clonedeep@4.5.0: + resolution: {integrity: sha512-H5ZhCF25riFd9uB5UCkVKo61m3S/xZk1x4wA6yp/L3RFP6Z/eHH1ymQcGLo7J3GMPfm0V/7m1tryHuGVxpqEBQ==} + + lodash.deburr@4.1.0: + resolution: {integrity: sha512-m/M1U1f3ddMCs6Hq2tAsYThTBDaAKFDX3dwDo97GEYzamXi9SqUpjWi/Rrj/gf3X2n8ktwgZrlP1z6E3v/IExQ==} + + lodash.flattendeep@4.4.0: + resolution: {integrity: sha512-uHaJFihxmJcEX3kT4I23ABqKKalJ/zDrDg0lsFtc1h+3uw49SIJ5beyhx5ExVRti3AvKoOJngIj7xz3oylPdWQ==} + + lodash.get@4.4.2: + resolution: {integrity: sha512-z+Uw/vLuy6gQe8cfaFWD7p0wVv8fJl3mbzXh33RS+0oW2wvUqiRXiQ69gLWSLpgB5/6sU+r6BlQR0MBILadqTQ==} + + lodash.isequal@4.5.0: + resolution: {integrity: sha512-pDo3lu8Jhfjqls6GkMgpahsF9kCyayhgykjyLMNFTKWrpVdAQtYyB4muAMWozBB4ig/dtWAmsMxLEI8wuz+DYQ==} + + lodash.memoize@4.1.2: + resolution: {integrity: sha512-t7j+NzmgnQzTAYXcsHYLgimltOV1MXHtlOWf6GjL9Kj8GK5FInw5JotxvbOs+IvV1/Dzo04/fCGfLVs7aXb4Ag==} + + lodash.merge@4.6.2: + resolution: {integrity: sha512-0KpjqXRVvrYyCsX1swR/XTK0va6VQkQM6MNo7PqW77ByjAhoARA8EfrP1N4+KlKj8YS0ZUCtRT/YUuhyYDujIQ==} + + lodash.snakecase@4.1.1: + resolution: {integrity: sha512-QZ1d4xoBHYUeuouhEq3lk3Uq7ldgyFXGBhg04+oRLnIz8o9T65Eh+8YdroUwn846zchkA9yDsDl5CVVaV2nqYw==} + + lodash.startcase@4.4.0: + resolution: {integrity: sha512-+WKqsK294HMSc2jEbNgpHpd0JfIBhp7rEV4aqXWqFr6AlXov+SlcgB1Fv01y2kGe3Gc8nMW7VA0SrGuSkRfIEg==} + + lodash.trim@4.5.1: + resolution: {integrity: sha512-nJAlRl/K+eiOehWKDzoBVrSMhK0K3A3YQsUNXHQa5yIrKBAhsZgSu3KoAFoFT+mEgiyBHddZ0pRk1ITpIp90Wg==} + + lodash.truncate@4.4.2: + resolution: {integrity: sha512-jttmRe7bRse52OsWIMDLaXxWqRAmtIUccAQ3garviCqJjafXOfNMO0yMfNpdD6zbGaTU0P5Nz7e7gAT6cKmJRw==} + + lodash@4.17.21: + resolution: {integrity: sha512-v2kDEe57lecTulaDIuNTPy3Ry4gLGJ6Z1O3vE1krgXZNrsQ+LFTGHVxVjcXPs17LhbZVGedAJv8XZ1tvj5FvSg==} + + log-symbols@4.1.0: + resolution: {integrity: sha512-8XPvpAA8uyhfteu8pIvQxpJZ7SYYdpUivZpGy6sFsBuKRY/7rQGavedeB8aK+Zkyq6upMFVL/9AW6vOYzfRyLg==} + engines: {node: '>=10'} + + loose-envify@1.4.0: + resolution: {integrity: sha512-lyuxPGr/Wfhrlem2CL/UcnUc1zcqKAImBDzukY7Y5F/yQiNdko6+fRLevlw1HgMySw7f611UIY408EtxRSoK3Q==} + hasBin: true + + loupe@2.3.7: + resolution: {integrity: sha512-zSMINGVYkdpYSOBmLi0D1Uo7JU9nVdQKrHxC8eYlV+9YKK9WePqAlL7lSlorG/U2Fw1w0hTBmaa/jrQ3UbPHtA==} + + lower-case-first@1.0.2: + resolution: {integrity: sha512-UuxaYakO7XeONbKrZf5FEgkantPf5DUqDayzP5VXZrtRPdH86s4kN47I8B3TW10S4QKiE3ziHNf3kRN//okHjA==} + + lower-case@1.1.4: + resolution: {integrity: sha512-2Fgx1Ycm599x+WGpIYwJOvsjmXFzTSc34IwDWALRA/8AopUKAVPwfJ+h5+f85BCp0PWmmJcWzEpxOpoXycMpdA==} + + lower-case@2.0.2: + resolution: {integrity: sha512-7fm3l3NAF9WfN6W3JOmf5drwpVqX78JtoGJ3A6W0a6ZnldM41w2fV5D490psKFTpMds8TJse/eHLFFsNHHjHgg==} + + lowercase-keys@2.0.0: + resolution: {integrity: sha512-tqNXrS78oMOE73NMxK4EMLQsQowWf8jKooH9g7xPavRT706R6bkQJ6DY2Te7QukaZsulxa30wQ7bk0pm4XiHmA==} + engines: {node: '>=8'} + + lowercase-keys@3.0.0: + resolution: {integrity: sha512-ozCC6gdQ+glXOQsveKD0YsDy8DSQFjDTz4zyzEHNV5+JP5D62LmfDZ6o1cycFx9ouG940M5dE8C8CTewdj2YWQ==} + engines: {node: ^12.20.0 || ^14.13.1 || >=16.0.0} + + lru-cache@10.2.2: + resolution: {integrity: sha512-9hp3Vp2/hFQUiIwKo8XCeFVnrg8Pk3TYNPIR7tJADKi5YfcF7vEaK7avFHTlSy3kOKYaJQaalfEo6YuXdceBOQ==} + engines: {node: 14 || >=16.14} + + lru-cache@4.1.5: + resolution: {integrity: sha512-sWZlbEP2OsHNkXrMl5GYk/jKk70MBng6UU4YI/qGDYbgf6YbP4EvmqISbXCoJiRKs+1bSpFHVgQxvJ17F2li5g==} + + lru-cache@5.1.1: + resolution: {integrity: sha512-KpNARQA3Iwv+jTA0utUVVbrh+Jlrr1Fv0e56GGzAFOXN7dk/FviaDW8LHmK52DlcH4WP2n6gI8vN1aesBFgo9w==} + + lru_map@0.3.3: + resolution: {integrity: sha512-Pn9cox5CsMYngeDbmChANltQl+5pi6XmTrraMSzhPmMBbmgcxmqWry0U3PGapCU1yB4/LqCcom7qhHZiF/jGfQ==} + + make-dir@3.1.0: + resolution: {integrity: sha512-g3FeP20LNwhALb/6Cz6Dd4F2ngze0jz7tbzrD2wAV+o9FeNHe4rL+yK2md0J/fiSf1sa1ADhXqi5+oVwOM/eGw==} + engines: {node: '>=8'} + + make-dir@4.0.0: + resolution: {integrity: sha512-hXdUTZYIVOt1Ex//jAQi+wTZZpUpwBj/0QsOzqegb3rGMMeJiSEu5xLHnYfBrRV4RH2+OCSOO95Is/7x1WJ4bw==} + engines: {node: '>=10'} + + make-error@1.3.6: + resolution: {integrity: sha512-s8UhlNe7vPKomQhC1qFelMokr/Sc3AgNbso3n74mVPA5LTZwkB9NlXf4XPamLxJE8h0gh73rM94xvwRT2CVInw==} + + map-obj@1.0.1: + resolution: {integrity: sha512-7N/q3lyZ+LVCp7PzuxrJr4KMbBE2hW7BT7YNia330OFxIf4d3r5zVpicP2650l7CPN6RM9zOJRl3NGpqSiw3Eg==} + engines: {node: '>=0.10.0'} + + map-obj@4.3.0: + resolution: {integrity: sha512-hdN1wVrZbb29eBGiGjJbeP8JbKjq1urkHJ/LIP/NY48MZ1QVXUsQBV1G1zvYFHn1XE06cwjBsOI2K3Ulnj1YXQ==} + engines: {node: '>=8'} + + markdown-table@1.1.3: + resolution: {integrity: sha512-1RUZVgQlpJSPWYbFSpmudq5nHY1doEIv89gBtF0s4gW1GF2XorxcA/70M5vq7rLv0a6mhOUccRsqkwhwLCIQ2Q==} + + markdown-table@3.0.3: + resolution: {integrity: sha512-Z1NL3Tb1M9wH4XESsCDEksWoKTdlUafKc4pt0GRwjUyXaCFZ+dc3g2erqB6zm3szA2IUSi7VnPI+o/9jnxh9hw==} + + md5.js@1.3.5: + resolution: {integrity: sha512-xitP+WxNPcTTOgnTJcrhM0xvdPepipPSf3I8EIpGKeFLjt3PlJLIDG3u8EX53ZIubkb+5U2+3rELYpEhHhzdkg==} + + media-typer@0.3.0: + resolution: {integrity: sha512-dq+qelQ9akHpcOl/gUVRTxVIOkAJ1wR3QAvb4RsVjS8oVoFjDGTc679wJYmUmknUF5HwMLOgb5O+a3KxfWapPQ==} + engines: {node: '>= 0.6'} + + memorystream@0.3.1: + resolution: {integrity: sha512-S3UwM3yj5mtUSEfP41UZmt/0SCoVYUcU1rkXv+BQ5Ig8ndL4sPoJNBUJERafdPb5jjHJGuMgytgKvKIf58XNBw==} + engines: {node: '>= 0.10.0'} + + meow@6.1.1: + resolution: {integrity: sha512-3YffViIt2QWgTy6Pale5QpopX/IvU3LPL03jOTqp6pGj3VjesdO/U8CuHMKpnQr4shCNCM5fd5XFFvIIl6JBHg==} + engines: {node: '>=8'} + + merge-descriptors@1.0.1: + resolution: {integrity: sha512-cCi6g3/Zr1iqQi6ySbseM1Xvooa98N0w31jzUYrXPX2xqObmFGHJ0tQ5u74H3mVh7wLouTseZyYIq39g8cNp1w==} + + merge2@1.4.1: + resolution: {integrity: sha512-8q7VEgMJW4J8tcfVPy8g09NcQwZdbwFEqhe/WZkoIzjn/3TGDwtOCYtXGxA3O8tPzpczCCDgv+P2P5y00ZJOOg==} + engines: {node: '>= 8'} + + methods@1.1.2: + resolution: {integrity: sha512-iclAHeNqNm68zFtnZ0e+1L2yUIdvzNoauKU4WBA3VvH/vPFieF7qfRlwUZU+DA9P9bPXIS90ulxoUoCH23sV2w==} + engines: {node: '>= 0.6'} + + micro-ftch@0.3.1: + resolution: {integrity: sha512-/0LLxhzP0tfiR5hcQebtudP56gUurs2CLkGarnCiB/OqEyUFQ6U3paQi/tgLv0hBJYt2rnr9MNpxz4fiiugstg==} + + micromatch@4.0.5: + resolution: {integrity: sha512-DMy+ERcEW2q8Z2Po+WNXuw3c5YaUSFjAO5GsJqfEl7UjvtIuFKO6ZrKvcItdy98dwFI2N1tg3zNIdKaQT+aNdA==} + engines: {node: '>=8.6'} + + mime-db@1.52.0: + resolution: {integrity: sha512-sPU4uV7dYlvtWJxwwxHD0PuihVNiE7TyAbQ5SWxDCB9mUYvOgroQOwYQQOKPJ8CIbE+1ETVlOoK1UC2nU3gYvg==} + engines: {node: '>= 0.6'} + + mime-types@2.1.35: + resolution: {integrity: sha512-ZDY+bPm5zTTF+YpCrAU9nK0UgICYPT0QtT1NZWFv4s++TNkcgVaT0g6+4R2uI4MjQjzysHB1zxuWL50hzaeXiw==} + engines: {node: '>= 0.6'} + + mime@1.6.0: + resolution: {integrity: sha512-x0Vn8spI+wuJ1O6S7gnbaQg8Pxh4NNHb7KSINmEWKiPE4RKOplvijn+NkmYmmRgP68mc70j2EbeTFRsrswaQeg==} + engines: {node: '>=4'} + hasBin: true + + mimic-fn@2.1.0: + resolution: {integrity: sha512-OqbOk5oEQeAZ8WXWydlu9HJjz9WVdEIvamMCcXmuqUYjTknH/sqsWvhQ3vgwKFRR1HpjvNBKQ37nbJgYzGqGcg==} + engines: {node: '>=6'} + + mimic-response@1.0.1: + resolution: {integrity: sha512-j5EctnkH7amfV/q5Hgmoal1g2QHFJRraOtmx0JpIqkxhBhI/lJSl1nMpQ45hVarwNETOoWEimndZ4QK0RHxuxQ==} + engines: {node: '>=4'} + + mimic-response@3.1.0: + resolution: {integrity: sha512-z0yWI+4FDrrweS8Zmt4Ej5HdJmky15+L2e6Wgn3+iK5fWzb6T3fhNFq2+MeTRb064c6Wr4N/wv0DzQTjNzHNGQ==} + engines: {node: '>=10'} + + min-document@2.19.0: + resolution: {integrity: sha512-9Wy1B3m3f66bPPmU5hdA4DR4PB2OfDU/+GS3yAB7IQozE3tqXaVv2zOjgla7MEGSRv95+ILmOuvhLkOK6wJtCQ==} + + min-indent@1.0.1: + resolution: {integrity: sha512-I9jwMn07Sy/IwOj3zVkVik2JTvgpaykDZEigL6Rx6N9LbMywwUSMtxET+7lVoDLLd3O3IXwJwvuuns8UB/HeAg==} + engines: {node: '>=4'} + + minimalistic-assert@1.0.1: + resolution: {integrity: sha512-UtJcAD4yEaGtjPezWuO9wC4nwUnVH/8/Im3yEHQP4b67cXlD/Qr9hdITCU1xDbSEXg2XKNaP8jsReV7vQd00/A==} + + minimalistic-crypto-utils@1.0.1: + resolution: {integrity: sha512-JIYlbt6g8i5jKfJ3xz7rF0LXmv2TkDxBLUkiBeZ7bAx4GnnNMr8xFpGnOxn6GhTEHx3SjRrZEoU+j04prX1ktg==} + + minimatch@3.1.2: + resolution: {integrity: sha512-J7p63hRiAjw1NDEww1W7i37+ByIrOWO5XQQAzZ3VOcL0PNybwpfmV/N05zFAzwQ9USyEcX6t3UO+K5aqBQOIHw==} + + minimatch@5.0.1: + resolution: {integrity: sha512-nLDxIFRyhDblz3qMuq+SoRZED4+miJ/G+tdDrjkkkRnjAsBexeGpgjLEQ0blJy7rHhR2b93rhQY4SvyWu9v03g==} + engines: {node: '>=10'} + + minimist-options@4.1.0: + resolution: {integrity: sha512-Q4r8ghd80yhO/0j1O3B2BjweX3fiHg9cdOwjJd2J76Q135c+NDxGCqdYKQ1SKBuFfgWbAUzBfvYjPUEeNgqN1A==} + engines: {node: '>= 6'} + + minimist@1.2.8: + resolution: {integrity: sha512-2yyAR8qBkN3YuheJanUpWC5U3bb5osDywNB8RzDVlDwDHbocAJveqqj1u8+SVD7jkWT4yvsHCpWqqWqAxb0zCA==} + + minipass@2.9.0: + resolution: {integrity: sha512-wxfUjg9WebH+CUDX/CdbRlh5SmfZiy/hpkxaRI16Y9W56Pa75sWgd/rvFilSgrauD9NyFymP/+JFV3KwzIsJeg==} + + minizlib@1.3.3: + resolution: {integrity: sha512-6ZYMOEnmVsdCeTJVE0W9ZD+pVnE8h9Hma/iOwwRDsdQoePpoX56/8B6z3P9VNwppJuBKNRuFDRNRqRWexT9G9Q==} + + mixme@0.5.10: + resolution: {integrity: sha512-5H76ANWinB1H3twpJ6JY8uvAtpmFvHNArpilJAjXRKXSDDLPIMoZArw5SH0q9z+lLs8IrMw7Q2VWpWimFKFT1Q==} + engines: {node: '>= 8.0.0'} + + mkdirp-classic@0.5.3: + resolution: {integrity: sha512-gKLcREMhtuZRwRAfqP3RFW+TK4JqApVBtOIftVgjuABpAtpxhPGaDcfvbhNvD0B8iD1oUr/txX35NjcaY6Ns/A==} + + mkdirp-promise@5.0.1: + resolution: {integrity: sha512-Hepn5kb1lJPtVW84RFT40YG1OddBNTOVUZR2bzQUHc+Z03en8/3uX0+060JDhcEzyO08HmipsN9DcnFMxhIL9w==} + engines: {node: '>=4'} + deprecated: This package is broken and no longer maintained. 'mkdirp' itself supports promises now, please switch to that. + + mkdirp@0.5.6: + resolution: {integrity: sha512-FP+p8RB8OWpF3YZBCrP5gtADmtXApB5AMLn+vdyA+PyxCjrCs00mjyUozssO33cwDeT3wNGdLxJ5M//YqtHAJw==} + hasBin: true + + mkdirp@1.0.4: + resolution: {integrity: sha512-vVqVZQyf3WLx2Shd0qJ9xuvqgAyKPLAiqITEtqW0oIUjzo3PePDd6fW9iFz30ef7Ysp/oiWqbhszeGWW2T6Gzw==} + engines: {node: '>=10'} + hasBin: true + + mkdirp@3.0.1: + resolution: {integrity: sha512-+NsyUUAZDmo6YVHzL/stxSu3t9YS1iljliy3BSDrXJ/dkn1KYdmtZODGGjLcc9XLgVVpH4KshHB8XmZgMhaBXg==} + engines: {node: '>=10'} + hasBin: true + + mnemonist@0.38.5: + resolution: {integrity: sha512-bZTFT5rrPKtPJxj8KSV0WkPyNxl72vQepqqVUAW2ARUpUSF2qXMB6jZj7hW5/k7C1rtpzqbD/IIbJwLXUjCHeg==} + + mocha@10.4.0: + resolution: {integrity: sha512-eqhGB8JKapEYcC4ytX/xrzKforgEc3j1pGlAXVy3eRwrtAy5/nIfT1SvgGzfN0XZZxeLq0aQWkOUAmqIJiv+bA==} + engines: {node: '>= 14.0.0'} + hasBin: true + + mock-fs@4.14.0: + resolution: {integrity: sha512-qYvlv/exQ4+svI3UOvPUpLDF0OMX5euvUH0Ny4N5QyRyhNdgAgUrVH3iUINSzEPLvx0kbo/Bp28GJKIqvE7URw==} + + ms@2.0.0: + resolution: {integrity: sha512-Tpp60P6IUJDTuOq/5Z8cdskzJujfwqfOTkrwIwj7IRISpnkJnT6SyJ4PCPnGMoFjC9ddhal5KVIYtAt97ix05A==} + + ms@2.1.2: + resolution: {integrity: sha512-sGkPx+VjMtmA6MX27oA4FBFELFCZZ4S4XqeGOXCv68tT+jb3vk/RyaKWP0PTKyWtmLSM0b+adUTEvbs1PEaH2w==} + + ms@2.1.3: + resolution: {integrity: sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==} + + multibase@0.6.1: + resolution: {integrity: sha512-pFfAwyTjbbQgNc3G7D48JkJxWtoJoBMaR4xQUOuB8RnCgRqaYmWNFeJTTvrJ2w51bjLq2zTby6Rqj9TQ9elSUw==} + deprecated: This module has been superseded by the multiformats module + + multibase@0.7.0: + resolution: {integrity: sha512-TW8q03O0f6PNFTQDvh3xxH03c8CjGaaYrjkl9UQPG6rz53TQzzxJVCIWVjzcbN/Q5Y53Zd0IBQBMVktVgNx4Fg==} + deprecated: This module has been superseded by the multiformats module + + multicodec@0.5.7: + resolution: {integrity: sha512-PscoRxm3f+88fAtELwUnZxGDkduE2HD9Q6GHUOywQLjOGT/HAdhjLDYNZ1e7VR0s0TP0EwZ16LNUTFpoBGivOA==} + deprecated: This module has been superseded by the multiformats module + + multicodec@1.0.4: + resolution: {integrity: sha512-NDd7FeS3QamVtbgfvu5h7fd1IlbaC4EQ0/pgU4zqE2vdHCmBGsUa0TiM8/TdSeG6BMPC92OOCf8F1ocE/Wkrrg==} + deprecated: This module has been superseded by the multiformats module + + multihashes@0.4.21: + resolution: {integrity: sha512-uVSvmeCWf36pU2nB4/1kzYZjsXD9vofZKpgudqkceYY5g2aZZXJ5r9lxuzoRLl1OAp28XljXsEJ/X/85ZsKmKw==} + + mz@2.7.0: + resolution: {integrity: sha512-z81GNO7nnYMEhrGh9LeymoE4+Yr0Wn5McHIZMK5cfQCl+NDX08sCZgUc9/6MHni9IWuFLm1Z3HTCXu2z9fN62Q==} + + nano-base32@1.0.1: + resolution: {integrity: sha512-sxEtoTqAPdjWVGv71Q17koMFGsOMSiHsIFEvzOM7cNp8BXB4AnEwmDabm5dorusJf/v1z7QxaZYxUorU9RKaAw==} + + nano-json-stream-parser@0.1.2: + resolution: {integrity: sha512-9MqxMH/BSJC7dnLsEMPyfN5Dvoo49IsPFYMcHw3Bcfc2kN0lpHRBSzlMSVx4HGyJ7s9B31CyBTVehWJoQ8Ctew==} + + napi-build-utils@1.0.2: + resolution: {integrity: sha512-ONmRUqK7zj7DWX0D9ADe03wbwOBZxNAfF20PlGfCWQcD3+/MakShIHrMqx9YwPTfxDdF1zLeL+RGZiR9kGMLdg==} + + natural-compare-lite@1.4.0: + resolution: {integrity: sha512-Tj+HTDSJJKaZnfiuw+iaF9skdPpTo2GtEly5JHnWV/hfv2Qj/9RKsGISQtLh2ox3l5EAGw487hnBee0sIJ6v2g==} + + natural-compare@1.4.0: + resolution: {integrity: sha512-OWND8ei3VtNC9h7V60qff3SVobHr996CTwgxubgyQYEpg290h9J0buyECNNJexkFm5sOajh5G116RYA1c8ZMSw==} + + ndjson@2.0.0: + resolution: {integrity: sha512-nGl7LRGrzugTtaFcJMhLbpzJM6XdivmbkdlaGcrk/LXg2KL/YBC6z1g70xh0/al+oFuVFP8N8kiWRucmeEH/qQ==} + engines: {node: '>=10'} + hasBin: true + + negotiator@0.6.3: + resolution: {integrity: sha512-+EUsqGPLsM+j/zdChZjsnX51g4XrHFOIXwfnCVPGlQk/k5giakcKsuxCObBRu6DSm9opw/O6slWbJdghQM4bBg==} + engines: {node: '>= 0.6'} + + neo-async@2.6.2: + resolution: {integrity: sha512-Yd3UES5mWCSqR+qNT93S3UoYUkqAZ9lLg8a7g9rimsWmYGK8cVToA4/sF3RrshdyV3sAGMXVUmpMYOw+dLpOuw==} + + next-tick@1.1.0: + resolution: {integrity: sha512-CXdUiJembsNjuToQvxayPZF9Vqht7hewsvy2sOWafLvi2awflj9mOC6bHIg50orX8IJvWKY9wYQ/zB2kogPslQ==} + + nise@4.1.0: + resolution: {integrity: sha512-eQMEmGN/8arp0xsvGoQ+B1qvSkR73B1nWSCh7nOt5neMCtwcQVYQGdzQMhcNscktTsWB54xnlSQFzOAPJD8nXA==} + + no-case@2.3.2: + resolution: {integrity: sha512-rmTZ9kz+f3rCvK2TD1Ue/oZlns7OGoIWP4fc3llxxRXlOkHKoWPPWJOfFYpITabSow43QJbRIoHQXtt10VldyQ==} + + no-case@3.0.4: + resolution: {integrity: sha512-fgAN3jGAh+RoxUGZHTSOLJIqUc2wmoBwGR4tbpNAKmmovFoWq0OdRkb0VkldReO2a2iBT/OEulG9XSUc10r3zg==} + + node-abi@3.62.0: + resolution: {integrity: sha512-CPMcGa+y33xuL1E0TcNIu4YyaZCxnnvkVaEXrsosR3FxN+fV8xvb7Mzpb7IgKler10qeMkE6+Dp8qJhpzdq35g==} + engines: {node: '>=10'} + + node-addon-api@2.0.2: + resolution: {integrity: sha512-Ntyt4AIXyaLIuMHF6IOoTakB3K+RWxwtsHNRxllEoA6vPwP9o4866g6YWDLUdnucilZhmkxiHwHr11gAENw+QA==} + + node-addon-api@3.2.1: + resolution: {integrity: sha512-mmcei9JghVNDYydghQmeDX8KoAm0FAiYyIcUt/N4nhyAipB17pllZQDOJD2fotxABnt4Mdz+dKTO7eftLg4d0A==} + + node-addon-api@6.1.0: + resolution: {integrity: sha512-+eawOlIgy680F0kBzPUNFhMZGtJ1YmqM6l4+Crf4IkImjYrO/mqPwRMh352g23uIaQKFItcQ64I7KMaJxHgAVA==} + + node-emoji@1.11.0: + resolution: {integrity: sha512-wo2DpQkQp7Sjm2A0cq+sN7EHKO6Sl0ctXeBdFZrL9T9+UywORbufTcTZxom8YqpLQt/FqNMUkOpkZrJVYSKD3A==} + + node-fetch@2.7.0: + resolution: {integrity: sha512-c4FRfUm/dbcWZ7U+1Wq0AwCyFL+3nt2bEw05wfxSz+DWpWsitgmSgYmy2dQdWyKC1694ELPqMs/YzUSNozLt8A==} + engines: {node: 4.x || >=6.0.0} + peerDependencies: + encoding: ^0.1.0 + peerDependenciesMeta: + encoding: + optional: true + + node-gyp-build@4.8.1: + resolution: {integrity: sha512-OSs33Z9yWr148JZcbZd5WiAXhh/n9z8TxQcdMhIOlpN9AhWpLfvVFO73+m77bBABQMaY9XSvIa+qk0jlI7Gcaw==} + hasBin: true + + node-hid@2.2.0: + resolution: {integrity: sha512-vj48zh9j555DZzUhMc8tk/qw6xPFrDyPBH1ST1Z/hWaA/juBJw7IuSxPeOgpzNFNU36mGYj+THioRMt1xOdm/g==} + engines: {node: '>=10'} + hasBin: true + + node-preload@0.2.1: + resolution: {integrity: sha512-RM5oyBy45cLEoHqCeh+MNuFAxO0vTFBLskvQbOKnEE7YTTSN4tbN8QWDIPQ6L+WvKsB/qLEGpYe2ZZ9d4W9OIQ==} + engines: {node: '>=8'} + + node-releases@2.0.14: + resolution: {integrity: sha512-y10wOWt8yZpqXmOgRo77WaHEmhYQYGNA6y421PKsKYWEK8aW+cqAphborZDhqfyKrbZEN92CN1X2KbafY2s7Yw==} + + nofilter@1.0.4: + resolution: {integrity: sha512-N8lidFp+fCz+TD51+haYdbDGrcBWwuHX40F5+z0qkUjMJ5Tp+rdSuAkMJ9N9eoolDlEVTf6u5icM+cNKkKW2mA==} + engines: {node: '>=8'} + + nofilter@3.1.0: + resolution: {integrity: sha512-l2NNj07e9afPnhAhvgVrCD/oy2Ai1yfLpuo3EpiO1jFTsB4sFz6oIfAfSZyQzVpkZQ9xS8ZS5g1jCBgq4Hwo0g==} + engines: {node: '>=12.19'} + + nopt@3.0.6: + resolution: {integrity: sha512-4GUt3kSEYmk4ITxzB/b9vaIDfUVWN/Ml1Fwl11IlnIG2iaJ9O6WXZ9SrYM9NLI8OCBieN2Y8SWC2oJV0RQ7qYg==} + hasBin: true + + normalize-package-data@2.5.0: + resolution: {integrity: sha512-/5CMN3T0R4XTj4DcGaexo+roZSdSFW/0AOOTROrjxzCG1wrWXEsGbRKevjlIL+ZDE4sZlJr5ED4YW0yqmkK+eA==} + + normalize-path@3.0.0: + resolution: {integrity: sha512-6eZs5Ls3WtCisHWp9S2GUy8dqkpGi4BVSz3GaqiE6ezub0512ESztXUwUB6C6IKbQkY2Pnb/mD4WYojCRwcwLA==} + engines: {node: '>=0.10.0'} + + normalize-url@6.1.0: + resolution: {integrity: sha512-DlL+XwOy3NxAQ8xuC0okPgK46iuVNAK01YN7RueYBqqFeGsBjV9XmCAzAdgt+667bCl5kPh9EqKKDwnaPG1I7A==} + engines: {node: '>=10'} + + nth-check@2.1.1: + resolution: {integrity: sha512-lqjrjmaOoAnWfMmBPL+XNnynZh2+swxiX3WUE0s4yEHI6m+AwrK2UZOimIRl3X/4QctVqS8AiZjFqyOGrMXb/w==} + + number-is-nan@1.0.1: + resolution: {integrity: sha512-4jbtZXNAsfZbAHiiqjLPBiCl16dES1zI4Hpzzxw61Tk+loF+sBDBKx1ICKKKwIqQ7M0mFn1TmkN7euSncWgHiQ==} + engines: {node: '>=0.10.0'} + + number-to-bn@1.7.0: + resolution: {integrity: sha512-wsJ9gfSz1/s4ZsJN01lyonwuxA1tml6X1yBDnfpMglypcBRFZZkus26EdPSlqS5GJfYddVZa22p3VNb3z5m5Ig==} + engines: {node: '>=6.5.0', npm: '>=3'} + + nyc@15.1.0: + resolution: {integrity: sha512-jMW04n9SxKdKi1ZMGhvUTHBN0EICCRkHemEoE5jm6mTYcqcdas0ATzgUgejlQUHMvpnOZqGB5Xxsv9KxJW1j8A==} + engines: {node: '>=8.9'} + hasBin: true + + oauth-sign@0.9.0: + resolution: {integrity: sha512-fexhUFFPTGV8ybAtSIGbV6gOkSv8UtRbDBnAyLQw4QPKkgNlsH2ByPGtMUqdWkos6YCRmAqViwgZrJc/mRDzZQ==} + + object-assign@4.1.1: + resolution: {integrity: sha512-rJgTQnkUnH1sFw8yT6VSU3zD3sWmu6sZhIseY8VX+GRu3P6F7Fu+JNDoXfklElbLJSnc3FUQHVe4cU5hj+BcUg==} + engines: {node: '>=0.10.0'} + + object-inspect@1.13.1: + resolution: {integrity: sha512-5qoj1RUiKOMsCCNLV1CBiPYE10sziTsnmNxkAI/rZhiD63CF7IqdFGC/XzjWjpSgLf0LxXX3bDFIh0E18f6UhQ==} + + object-keys@1.1.1: + resolution: {integrity: sha512-NuAESUOUMrlIXOfHKzD6bpPu3tYt3xvjNdRIQ+FeT0lNb4K8WR70CaDxhuNguS2XG+GjkyMwOzsN5ZktImfhLA==} + engines: {node: '>= 0.4'} + + object.assign@4.1.5: + resolution: {integrity: sha512-byy+U7gp+FVwmyzKPYhW2h5l3crpmGsxl7X2s8y43IgxvG4g3QZ6CffDtsNQy1WsmZpQbO+ybo0AlW7TY6DcBQ==} + engines: {node: '>= 0.4'} + + object.values@1.2.0: + resolution: {integrity: sha512-yBYjY9QX2hnRmZHAjG/f13MzmBzxzYgQhFrke06TTyKY5zSTEqkOeukBzIdVA3j3ulu8Qa3MbVFShV7T2RmGtQ==} + engines: {node: '>= 0.4'} + + obliterator@2.0.4: + resolution: {integrity: sha512-lgHwxlxV1qIg1Eap7LgIeoBWIMFibOjbrYPIPJZcI1mmGAI2m3lNYpK12Y+GBdPQ0U1hRwSord7GIaawz962qQ==} + + oboe@2.1.5: + resolution: {integrity: sha512-zRFWiF+FoicxEs3jNI/WYUrVEgA7DeET/InK0XQuudGHRg8iIob3cNPrJTKaz4004uaA9Pbe+Dwa8iluhjLZWA==} + + on-finished@2.4.1: + resolution: {integrity: sha512-oVlzkg3ENAhCk2zdv7IJwd/QUD4z2RxRwpkcGY8psCVcCYZNq4wYnVWALHM+brtuJjePWiYF/ClmuDr8Ch5+kg==} + engines: {node: '>= 0.8'} + + once@1.4.0: + resolution: {integrity: sha512-lNaJgI+2Q5URQBkccEKHTQOPaXdUxnZZElQTZY0MFUAuaEqe1E+Nyvgdz/aIyNi6Z9MzO5dv1H8n58/GELp3+w==} + + onetime@5.1.2: + resolution: {integrity: sha512-kbpaSSGJTWdAY5KPVeMOKXSrPtr8C8C7wodJbcsd51jRnmD+GZu8Y0VoU6Dm5Z4vWr0Ig/1NKuWRKf7j5aaYSg==} + engines: {node: '>=6'} + + optionator@0.8.3: + resolution: {integrity: sha512-+IW9pACdk3XWmmTXG8m3upGUJst5XRGzxMRjXzAuJ1XnIFNvfhjjIuYkDvysnPQ7qzqVzLt78BCruntqRhWQbA==} + engines: {node: '>= 0.8.0'} + + optionator@0.9.4: + resolution: {integrity: sha512-6IpQ7mKUxRcZNLIObR0hz7lxsapSSIYNZJwXPGeF0mTVqGKFIXj1DQcMoT22S3ROcLyY/rz0PWaWZ9ayWmad9g==} + engines: {node: '>= 0.8.0'} + + ora@5.4.1: + resolution: {integrity: sha512-5b6Y85tPxZZ7QytO+BQzysW31HJku27cRIlkbAXaNx+BdcVi+LlRFmVXzeF6a7JCwJpyw5c4b+YSVImQIrBpuQ==} + engines: {node: '>=10'} + + ordinal@1.0.3: + resolution: {integrity: sha512-cMddMgb2QElm8G7vdaa02jhUNbTSrhsgAGUz1OokD83uJTwSUn+nKoNoKVVaRa08yF6sgfO7Maou1+bgLd9rdQ==} + + os-locale@1.4.0: + resolution: {integrity: sha512-PRT7ZORmwu2MEFt4/fv3Q+mEfN4zetKxufQrkShY2oGvUms9r8otu5HfdyIFHkYXjO7laNsoVGmM2MANfuTA8g==} + engines: {node: '>=0.10.0'} + + os-tmpdir@1.0.2: + resolution: {integrity: sha512-D2FR03Vir7FIu45XBY20mTb+/ZSWB00sjU9jdQXt83gDrI4Ztz5Fs7/yy74g2N5SVQY4xY1qDr4rNddwYRVX0g==} + engines: {node: '>=0.10.0'} + + outdent@0.5.0: + resolution: {integrity: sha512-/jHxFIzoMXdqPzTaCpFzAAWhpkSjZPF4Vsn6jAfNpmbH/ymsmd7Qc6VE9BGn0L6YMj6uwpQLxCECpus4ukKS9Q==} + + p-cancelable@2.1.1: + resolution: {integrity: sha512-BZOr3nRQHOntUjTrH8+Lh54smKHoHyur8We1V8DSMVrl5A2malOOwuJRnKRDjSnkoeBh4at6BwEnb5I7Jl31wg==} + engines: {node: '>=8'} + + p-cancelable@3.0.0: + resolution: {integrity: sha512-mlVgR3PGuzlo0MmTdk4cXqXWlwQDLnONTAg6sm62XkMJEiRxN3GL3SffkYvqwonbkJBcrI7Uvv5Zh9yjvn2iUw==} + engines: {node: '>=12.20'} + + p-filter@2.1.0: + resolution: {integrity: sha512-ZBxxZ5sL2HghephhpGAQdoskxplTwr7ICaehZwLIlfL6acuVgZPm8yBNuRAFBGEqtD/hmUeq9eqLg2ys9Xr/yw==} + engines: {node: '>=8'} + + p-limit@1.3.0: + resolution: {integrity: sha512-vvcXsLAJ9Dr5rQOPk7toZQZJApBl2K4J6dANSsEuh6QI41JYcsS/qhTGa9ErIUUgK3WNQoJYvylxvjqmiqEA9Q==} + engines: {node: '>=4'} + + p-limit@2.3.0: + resolution: {integrity: sha512-//88mFWSJx8lxCzwdAABTJL2MyWB12+eIY7MDL2SqLmAkeKU9qxRvWuSyTjm3FUmpBEMuFfckAIqEaVGUDxb6w==} + engines: {node: '>=6'} + + p-limit@3.1.0: + resolution: {integrity: sha512-TYOanM3wGwNGsZN2cVTYPArw454xnXj5qmWF1bEoAc4+cU/ol7GVh7odevjp1FNHduHc3KZMcFduxU5Xc6uJRQ==} + engines: {node: '>=10'} + + p-locate@2.0.0: + resolution: {integrity: sha512-nQja7m7gSKuewoVRen45CtVfODR3crN3goVQ0DDZ9N3yHxgpkuBhZqsaiotSQRrADUrne346peY7kT3TSACykg==} + engines: {node: '>=4'} + + p-locate@4.1.0: + resolution: {integrity: sha512-R79ZZ/0wAxKGu3oYMlz8jy/kbhsNrS7SKZ7PxEHBgJ5+F2mtFW2fK2cOtBh1cHYkQsbzFV7I+EoRKe6Yt0oK7A==} + engines: {node: '>=8'} + + p-locate@5.0.0: + resolution: {integrity: sha512-LaNjtRWUBY++zB5nE/NwcaoMylSPk+S+ZHNB1TzdbMJMny6dynpAGt7X/tl/QYq3TIeE6nxHppbo2LGymrG5Pw==} + engines: {node: '>=10'} + + p-map@2.1.0: + resolution: {integrity: sha512-y3b8Kpd8OAN444hxfBbFfj1FY/RjtTd8tzYwhUqNYXx0fXx2iX4maP4Qr6qhIKbQXI02wTLAda4fYUbDagTUFw==} + engines: {node: '>=6'} + + p-map@3.0.0: + resolution: {integrity: sha512-d3qXVTF/s+W+CdJ5A29wywV2n8CQQYahlgz2bFiA+4eVNJbHJodPZ+/gXwPGh0bOqA+j8S+6+ckmvLGPk1QpxQ==} + engines: {node: '>=8'} + + p-map@4.0.0: + resolution: {integrity: sha512-/bjOqmgETBYB5BoEeGVea8dmvHb2m9GLy1E9W43yeyfP6QQCZGFNa+XRceJEuDB6zqr+gKpIAmlLebMpykw/MQ==} + engines: {node: '>=10'} + + p-try@1.0.0: + resolution: {integrity: sha512-U1etNYuMJoIz3ZXSrrySFjsXQTWOx2/jdi86L+2pRvph/qMKL6sbcCYdH23fqsbm8TH2Gn0OybpT4eSFlCVHww==} + engines: {node: '>=4'} + + p-try@2.2.0: + resolution: {integrity: sha512-R4nPAVTAU0B9D35/Gk3uJf/7XYbQcyohSKdvAxIRSNghFl4e71hVoGnBNQz9cWaXxO2I10KTC+3jMdvvoKw6dQ==} + engines: {node: '>=6'} + + package-hash@4.0.0: + resolution: {integrity: sha512-whdkPIooSu/bASggZ96BWVvZTRMOFxnyUG5PnTSGKoJE2gd5mbVNmR2Nj20QFzxYYgAXpoqC+AiXzl+UMRh7zQ==} + engines: {node: '>=8'} + + pako@1.0.11: + resolution: {integrity: sha512-4hLB8Py4zZce5s4yd9XzopqwVv/yGNhV1Bl8NTmCq1763HeK2+EwVTv+leGeL13Dnh2wfbqowVPXCIO0z4taYw==} + + param-case@2.1.1: + resolution: {integrity: sha512-eQE845L6ot89sk2N8liD8HAuH4ca6Vvr7VWAWwt7+kvvG5aBcPmmphQ68JsEG2qa9n1TykS2DLeMt363AAH8/w==} + + parent-module@1.0.1: + resolution: {integrity: sha512-GQ2EWRpQV8/o+Aw8YqtfZZPfNRWZYkbidE9k5rpl/hC3vtHHBfGm2Ifi6qWV+coDGkrUKZAxE3Lot5kcsRlh+g==} + engines: {node: '>=6'} + + parse-cache-control@1.0.1: + resolution: {integrity: sha512-60zvsJReQPX5/QP0Kzfd/VrpjScIQ7SHBW6bFCYfEP+fp0Eppr1SHhIO5nd1PjZtvclzSzES9D/p5nFJurwfWg==} + + parse-headers@2.0.5: + resolution: {integrity: sha512-ft3iAoLOB/MlwbNXgzy43SWGP6sQki2jQvAyBg/zDFAgr9bfNWZIUj42Kw2eJIl8kEi4PbgE6U1Zau/HwI75HA==} + + parse-json@2.2.0: + resolution: {integrity: sha512-QR/GGaKCkhwk1ePQNYDRKYZ3mwU9ypsKhB0XyFnLQdomyEqk3e8wpW3V5Jp88zbxK4n5ST1nqo+g9juTpownhQ==} + engines: {node: '>=0.10.0'} + + parse-json@5.2.0: + resolution: {integrity: sha512-ayCKvm/phCGxOkYRSCM82iDwct8/EonSEgCSxWxD7ve6jHggsFl4fZVQBPRNgQoKiuV/odhFrGzQXZwbifC8Rg==} + engines: {node: '>=8'} + + parse-ms@0.1.2: + resolution: {integrity: sha512-VwMglE9412ifMHcRFEVJePEpreQh90wjIiOdP0UQQGKV4l+QprdKI+p5noXTkmGjznBMb40s+VymcclATAVvYA==} + engines: {node: '>=0.10.0'} + + parse5-htmlparser2-tree-adapter@7.0.0: + resolution: {integrity: sha512-B77tOZrqqfUfnVcOrUvfdLbz4pu4RopLD/4vmu3HUPswwTA8OH0EMW9BlWR2B0RCoiZRAHEUu7IxeP1Pd1UU+g==} + + parse5@7.1.2: + resolution: {integrity: sha512-Czj1WaSVpaoj0wbhMzLmWD69anp2WH7FXMB9n1Sy8/ZFF9jolSQVMu1Ij5WIyGmcBmhk7EOndpO4mIpihVqAXw==} + + parseurl@1.3.3: + resolution: {integrity: sha512-CiyeOxFT/JZyN5m0z9PfXw4SCBJ6Sygz1Dpl0wqjlhDEGGBP1GnsUVEL0p63hoG1fcj3fHynXi9NYO4nWOL+qQ==} + engines: {node: '>= 0.8'} + + pascal-case@2.0.1: + resolution: {integrity: sha512-qjS4s8rBOJa2Xm0jmxXiyh1+OFf6ekCWOvUaRgAQSktzlTbMotS0nmG9gyYAybCWBcuP4fsBeRCKNwGBnMe2OQ==} + + path-case@2.1.1: + resolution: {integrity: sha512-Ou0N05MioItesaLr9q8TtHVWmJ6fxWdqKB2RohFmNWVyJ+2zeKIeDNWAN6B/Pe7wpzWChhZX6nONYmOnMeJQ/Q==} + + path-exists@2.1.0: + resolution: {integrity: sha512-yTltuKuhtNeFJKa1PiRzfLAU5182q1y4Eb4XCJ3PBqyzEDkAZRzBrKKBct682ls9reBVHf9udYLN5Nd+K1B9BQ==} + engines: {node: '>=0.10.0'} + + path-exists@3.0.0: + resolution: {integrity: sha512-bpC7GYwiDYQ4wYLe+FA8lhRjhQCMcQGuSgGGqDkg/QerRWw9CmGRT0iSOVRSZJ29NMLZgIzqaljJ63oaL4NIJQ==} + engines: {node: '>=4'} + + path-exists@4.0.0: + resolution: {integrity: sha512-ak9Qy5Q7jYb2Wwcey5Fpvg2KoAc/ZIhLSLOSBmRmygPsGwkVVt0fZa0qrtMz+m6tJTAHfZQ8FnmB4MG4LWy7/w==} + engines: {node: '>=8'} + + path-is-absolute@1.0.1: + resolution: {integrity: sha512-AVbw3UJ2e9bq64vSaS9Am0fje1Pa8pbGqTTsmXfaIiMpnr5DlDhfJOuLj9Sf95ZPVDAUerDfEk88MPmPe7UCQg==} + engines: {node: '>=0.10.0'} + + path-key@3.1.1: + resolution: {integrity: sha512-ojmeN0qd+y0jszEtoY48r0Peq5dwMEkIlCOu6Q5f41lfkswXuKtYrhgoTpLnyIcHm24Uhqx+5Tqm2InSwLhE6Q==} + engines: {node: '>=8'} + + path-parse@1.0.7: + resolution: {integrity: sha512-LDJzPVEEEPR+y48z93A0Ed0yXb8pAByGWo/k5YYdYgpY2/2EsOsksJrq7lOHxryrVOn1ejG6oAp8ahvOIQD8sw==} + + path-to-regexp@0.1.7: + resolution: {integrity: sha512-5DFkuoqlv1uYQKxy8omFBeJPQcdoE07Kv2sferDCrAq1ohOU+MSDswDIbnx3YAM60qIOnYa53wBhXW0EbMonrQ==} + + path-to-regexp@1.8.0: + resolution: {integrity: sha512-n43JRhlUKUAlibEJhPeir1ncUID16QnEjNpwzNdO3Lm4ywrBpBZ5oLD0I6br9evr1Y9JTqwRtAh7JLoOzAQdVA==} + + path-type@1.1.0: + resolution: {integrity: sha512-S4eENJz1pkiQn9Znv33Q+deTOKmbl+jj1Fl+qiP/vYezj+S8x+J3Uo0ISrx/QoEvIlOaDWJhPaRd1flJ9HXZqg==} + engines: {node: '>=0.10.0'} + + path-type@4.0.0: + resolution: {integrity: sha512-gDKb8aZMDeD/tZWs9P6+q0J9Mwkdl6xMV8TjnGP3qJVJ06bdMgkbBlLU8IdfOsIsFz2BW1rNVT3XuNEl8zPAvw==} + engines: {node: '>=8'} + + pathval@1.1.1: + resolution: {integrity: sha512-Dp6zGqpTdETdR63lehJYPeIOqpiNBNtc7BpWSLrOje7UaIsE5aY92r/AunQA7rsXvet3lrJ3JnZX29UPTKXyKQ==} + + pbkdf2@3.1.2: + resolution: {integrity: sha512-iuh7L6jA7JEGu2WxDwtQP1ddOpaJNC4KlDEFfdQajSGgGPNi4OyDc2R7QnbY2bR9QjBVGwgvTdNJZoE7RaxUMA==} + engines: {node: '>=0.12'} + + performance-now@2.1.0: + resolution: {integrity: sha512-7EAHlyLHI56VEIdK57uwHdHKIaAGbnXPiw0yWbarQZOKaKpvUIgW0jWRVLiatnM+XXlSwsanIBH/hzGMJulMow==} + + picocolors@1.0.0: + resolution: {integrity: sha512-1fygroTLlHu66zi26VoTDv8yRgm0Fccecssto+MhsZ0D/DGW2sm8E8AjW7NU5VVTRt5GxbeZ5qBuJr+HyLYkjQ==} + + picomatch@2.3.1: + resolution: {integrity: sha512-JU3teHTNjmE2VCGFzuY8EXzCDVwEqB2a8fsIvwaStHhAWJEeVd1o1QD80CU6+ZdEXXSLbSsuLwJjkCBWqRQUVA==} + engines: {node: '>=8.6'} + + pify@2.3.0: + resolution: {integrity: sha512-udgsAY+fTnvv7kI7aaxbqwWNb0AHiB0qBO89PZKPkoTmGOgdbrHDKD+0B2X4uTfJ/FT1R09r9gTsjUjNJotuog==} + engines: {node: '>=0.10.0'} + + pify@4.0.1: + resolution: {integrity: sha512-uB80kBFb/tfd68bVleG9T5GGsGPjJrLAUpR5PZIrhBnIaRTQRjqdJSsIKkOP6OAIFbj7GOrcudc5pNjZ+geV2g==} + engines: {node: '>=6'} + + pinkie-promise@2.0.1: + resolution: {integrity: sha512-0Gni6D4UcLTbv9c57DfxDGdr41XfgUjqWZu492f0cIGr16zDU06BWP/RAEvOuo7CQ0CNjHaLlM59YJJFm3NWlw==} + engines: {node: '>=0.10.0'} + + pinkie@2.0.4: + resolution: {integrity: sha512-MnUuEycAemtSaeFSjXKW/aroV7akBbY+Sv+RkyqFjgAe73F+MR0TBWKBRDkmfWq/HiFmdavfZ1G7h4SPZXaCSg==} + engines: {node: '>=0.10.0'} + + pkg-dir@4.2.0: + resolution: {integrity: sha512-HRDzbaKjC+AOWVXxAU/x54COGeIv9eb+6CkDSQoNTt4XyWoIJvuPsXizxu/Fr23EiekbtZwmh1IcIG/l/a10GQ==} + engines: {node: '>=8'} + + pluralize@8.0.0: + resolution: {integrity: sha512-Nc3IT5yHzflTfbjgqWcCPpo7DaKy4FnpB0l/zCAW0Tc7jxAiuqSxHasntB3D7887LSrA93kDJ9IXovxJYxyLCA==} + engines: {node: '>=4'} + + possible-typed-array-names@1.0.0: + resolution: {integrity: sha512-d7Uw+eZoloe0EHDIYoe+bQ5WXnGMOpmiZFTuMWCwpjzzkL2nTjcKiAk4hh8TjnGye2TwWOk3UXucZ+3rbmBa8Q==} + engines: {node: '>= 0.4'} + + prebuild-install@7.1.2: + resolution: {integrity: sha512-UnNke3IQb6sgarcZIDU3gbMeTp/9SSU1DAIkil7PrqG1vZlBtY5msYccSKSHDqa3hNg436IXK+SNImReuA1wEQ==} + engines: {node: '>=10'} + hasBin: true + + preferred-pm@3.1.3: + resolution: {integrity: sha512-MkXsENfftWSRpzCzImcp4FRsCc3y1opwB73CfCNWyzMqArju2CrlMHlqB7VexKiPEOjGMbttv1r9fSCn5S610w==} + engines: {node: '>=10'} + + prelude-ls@1.1.2: + resolution: {integrity: sha512-ESF23V4SKG6lVSGZgYNpbsiaAkdab6ZgOxe52p7+Kid3W3u3bxR4Vfd/o21dmN7jSt0IwgZ4v5MUd26FEtXE9w==} + engines: {node: '>= 0.8.0'} + + prelude-ls@1.2.1: + resolution: {integrity: sha512-vkcDPrRZo1QZLbn5RLGPpg/WmIQ65qoWWhcGKf/b5eplkkarX0m9z8ppCat4mlOqUsWpyNuYgO3VRyrYHSzX5g==} + engines: {node: '>= 0.8.0'} + + prettier-linter-helpers@1.0.0: + resolution: {integrity: sha512-GbK2cP9nraSSUF9N2XwUwqfzlAFlMNYYl+ShE/V+H8a9uNl/oUqB1w2EL54Jh0OlyRSd8RfWYJ3coVS4TROP2w==} + engines: {node: '>=6.0.0'} + + prettier@2.4.1: + resolution: {integrity: sha512-9fbDAXSBcc6Bs1mZrDYb3XKzDLm4EXXL9sC1LqKP5rZkT6KRr/rf9amVUcODVXgguK/isJz0d0hP72WeaKWsvA==} + engines: {node: '>=10.13.0'} + hasBin: true + + prettier@2.8.8: + resolution: {integrity: sha512-tdN8qQGvNjw4CHbY+XXk0JgCXn9QiF21a55rBe5LJAU+kDyC4WQn4+awm2Xfk2lQMk5fKup9XgzTZtGkjBdP9Q==} + engines: {node: '>=10.13.0'} + hasBin: true + + pretty-format@29.7.0: + resolution: {integrity: sha512-Pdlw/oPxN+aXdmM9R00JVC9WVFoCLTKJvDVLgmJ+qAffBMxsV85l/Lu7sNx4zSzPyoL2euImuEwHhOXdEgNFZQ==} + engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0} + + pretty-ms@0.2.2: + resolution: {integrity: sha512-ah/vWDJAT0arxQwVcSGp6etaLTZr4IsrXTy/khfjimzdYgSxYWzTMByrtpJUWinAnVY8szDg+qQhsE5MUMz3lQ==} + engines: {node: '>=0.10.0'} + hasBin: true + + process-nextick-args@2.0.1: + resolution: {integrity: sha512-3ouUOpQhtgrbOa17J7+uxOTpITYWaGP7/AhoR3+A+/1e9skrzelGi/dXzEYyvbxubEF6Wn2ypscTKiKJFFn1ag==} + + process-on-spawn@1.0.0: + resolution: {integrity: sha512-1WsPDsUSMmZH5LeMLegqkPDrsGgsWwk1Exipy2hvB0o/F0ASzbpIctSCcZIK1ykJvtTJULEH+20WOFjMvGnCTg==} + engines: {node: '>=8'} + + process@0.11.10: + resolution: {integrity: sha512-cdGef/drWFoydD1JsMzuFf8100nZl+GT+yacc2bEced5f9Rjk4z+WtFUTBu9PhOi9j/jfmBPu0mMEY4wIdAF8A==} + engines: {node: '>= 0.6.0'} + + promise@8.3.0: + resolution: {integrity: sha512-rZPNPKTOYVNEEKFaq1HqTgOwZD+4/YHS5ukLzQCypkj+OkYx7iv0mA91lJlpPPZ8vMau3IIGj5Qlwrx+8iiSmg==} + + prompts@2.4.2: + resolution: {integrity: sha512-NxNv/kLguCA7p3jE8oL2aEBsrJWgAakBpgmgK6lpPWV+WuOmY6r2/zbAVnP+T8bQlA0nzHXSJSJW0Hq7ylaD2Q==} + engines: {node: '>= 6'} + + proxy-addr@2.0.7: + resolution: {integrity: sha512-llQsMLSUDUPT44jdrU/O37qlnifitDP+ZwrmmZcoSKyLKvtZxpyV0n2/bD/N4tBAAZ/gJEdZU7KMraoK1+XYAg==} + engines: {node: '>= 0.10'} + + proxy-from-env@1.1.0: + resolution: {integrity: sha512-D+zkORCbA9f1tdWRK0RaCR3GPv50cMxcrz4X8k5LTSUD1Dkw47mKJEZQNunItRTkWwgtaUSo1RVFRIG9ZXiFYg==} + + pseudomap@1.0.2: + resolution: {integrity: sha512-b/YwNhb8lk1Zz2+bXXpS/LK9OisiZZ1SNsSLxN1x2OXVEhW2Ckr/7mWE5vrC1ZTiJlD9g19jWszTmJsB+oEpFQ==} + + psl@1.9.0: + resolution: {integrity: sha512-E/ZsdU4HLs/68gYzgGTkMicWTLPdAftJLfJFlLUAAKZGkStNU72sZjT66SnMDVOfOWY/YAoiD7Jxa9iHvngcag==} + + pump@3.0.0: + resolution: {integrity: sha512-LwZy+p3SFs1Pytd/jYct4wpv49HiYCqd9Rlc5ZVdk0V+8Yzv6jR5Blk3TRmPL1ft69TxP0IMZGJ+WPFU2BFhww==} + + punycode@2.1.0: + resolution: {integrity: sha512-Yxz2kRwT90aPiWEMHVYnEf4+rhwF1tBmmZ4KepCP+Wkium9JxtWnUm1nqGwpiAHr/tnTSeHqr3wb++jgSkXjhA==} + engines: {node: '>=6'} + + punycode@2.3.1: + resolution: {integrity: sha512-vYt7UD1U9Wg6138shLtLOvdAu+8DsC/ilFtEVHcH+wydcSpNE20AfSOduf6MkRFahL5FY7X1oU7nKVZFtfq8Fg==} + engines: {node: '>=6'} + + pure-rand@5.0.5: + resolution: {integrity: sha512-BwQpbqxSCBJVpamI6ydzcKqyFmnd5msMWUGvzXLm1aXvusbbgkbOto/EUPM00hjveJEaJtdbhUjKSzWRhQVkaw==} + + qs@6.11.0: + resolution: {integrity: sha512-MvjoMCJwEarSbUYk5O+nmoSzSutSsTwF85zcHPQ9OrlFoZOYIjaqBAJIqIXjptyD5vThxGq52Xu/MaJzRkIk4Q==} + engines: {node: '>=0.6'} + + qs@6.12.1: + resolution: {integrity: sha512-zWmv4RSuB9r2mYQw3zxQuHWeU+42aKi1wWig/j4ele4ygELZ7PEO6MM7rim9oAQH2A5MWfsAVf/jPvTPgCbvUQ==} + engines: {node: '>=0.6'} + + qs@6.5.3: + resolution: {integrity: sha512-qxXIEh4pCGfHICj1mAJQ2/2XVZkjCDTcEgfoSQxc/fYivUZxTkk7L3bDBJSoNrEzXI17oUO5Dp07ktqE5KzczA==} + engines: {node: '>=0.6'} + + query-string@5.1.1: + resolution: {integrity: sha512-gjWOsm2SoGlgLEdAGt7a6slVOk9mGiXmPFMqrEhLQ68rhQuBnpfs3+EmlvqKyxnCo9/PPlF+9MtY02S1aFg+Jw==} + engines: {node: '>=0.10.0'} + + queue-microtask@1.2.3: + resolution: {integrity: sha512-NuaNSa6flKT5JaSYQzJok04JzTL1CA6aGhv5rfLW3PgqA+M2ChpZQnAC8h8i4ZFkBS8X5RqkDBHA7r4hej3K9A==} + + quick-lru@4.0.1: + resolution: {integrity: sha512-ARhCpm70fzdcvNQfPoy49IaanKkTlRWF2JMzqhcJbhSFRZv7nPTvZJdcY7301IPmvW+/p0RgIWnQDLJxifsQ7g==} + engines: {node: '>=8'} + + quick-lru@5.1.1: + resolution: {integrity: sha512-WuyALRjWPDGtt/wzJiadO5AXY+8hZ80hVpe6MyivgraREW751X3SbhRvG3eLKOYN+8VEvqLcf3wdnt44Z4S4SA==} + engines: {node: '>=10'} + + rambda@7.5.0: + resolution: {integrity: sha512-y/M9weqWAH4iopRd7EHDEQQvpFPHj1AA3oHozE9tfITHUtTR7Z9PSlIRRG2l1GuW7sefC1cXFfIcF+cgnShdBA==} + + randombytes@2.1.0: + resolution: {integrity: sha512-vYl3iOX+4CKUWuxGi9Ukhie6fsqXqS9FE2Zaic4tNFD2N2QQaXOMFbuKK4QmDHC0JO6B1Zp41J0LpT0oR68amQ==} + + range-parser@1.2.1: + resolution: {integrity: sha512-Hrgsx+orqoygnmhFbKaHE6c296J+HTAQXoxEF6gNupROmmGJRoyzfG3ccAveqCBrwr/2yxQ5BVd/GTl5agOwSg==} + engines: {node: '>= 0.6'} + + raw-body@2.5.2: + resolution: {integrity: sha512-8zGqypfENjCIqGhgXToC8aB2r7YrBX+AQAfIPs/Mlk+BtPTztOvTS01NRW/3Eh60J+a48lt8qsCzirQ6loCVfA==} + engines: {node: '>= 0.8'} + + rc@1.2.8: + resolution: {integrity: sha512-y3bGgqKj3QBdxLbLkomlohkvsA8gdAiUQlSBJnBhfn+BPxg4bc62d8TcBW15wavDfgexCgccckhcZvywyQYPOw==} + hasBin: true + + react-dom@18.3.1: + resolution: {integrity: sha512-5m4nQKp+rZRb09LNH59GM4BxTh9251/ylbKIbpe7TpGxfJ+9kv6BLkLBXIjjspbgbnIBNqlI23tRnTWT0snUIw==} + peerDependencies: + react: ^18.3.1 + + react-is@18.3.1: + resolution: {integrity: sha512-/LLMVyas0ljjAtoYiPqYiL8VWXzUUdThrmU5+n20DZv+a+ClRoevUzw5JxU+Ieh5/c87ytoTBV9G1FiKfNJdmg==} + + react@18.3.1: + resolution: {integrity: sha512-wS+hAgJShR0KhEvPJArfuPVN1+Hz1t0Y6n5jLrGQbkb4urgPE/0Rve+1kMB1v/oWgHgm4WIcV+i7F2pTVj+2iQ==} + engines: {node: '>=0.10.0'} + + read-pkg-up@1.0.1: + resolution: {integrity: sha512-WD9MTlNtI55IwYUS27iHh9tK3YoIVhxis8yKhLpTqWtml739uXc9NWTpxoHkfZf3+DkCCsXox94/VWZniuZm6A==} + engines: {node: '>=0.10.0'} + + read-pkg-up@7.0.1: + resolution: {integrity: sha512-zK0TB7Xd6JpCLmlLmufqykGE+/TlOePD6qKClNW7hHDKFh/J7/7gCWGR7joEQEW1bKq3a3yUZSObOoWLFQ4ohg==} + engines: {node: '>=8'} + + read-pkg@1.1.0: + resolution: {integrity: sha512-7BGwRHqt4s/uVbuyoeejRn4YmFnYZiFl4AuaeXHlgZf3sONF0SOGlxs2Pw8g6hCKupo08RafIO5YXFNOKTfwsQ==} + engines: {node: '>=0.10.0'} + + read-pkg@5.2.0: + resolution: {integrity: sha512-Ug69mNOpfvKDAc2Q8DRpMjjzdtrnv9HcSMX+4VsZxD1aZ6ZzrIE7rlzXBtWTyhULSMKg076AW6WR5iZpD0JiOg==} + engines: {node: '>=8'} + + read-yaml-file@1.1.0: + resolution: {integrity: sha512-VIMnQi/Z4HT2Fxuwg5KrY174U1VdUIASQVWXXyqtNRtxSr9IYkn1rsI6Tb6HsrHCmB7gVpNwX6JxPTHcH6IoTA==} + engines: {node: '>=6'} + + readable-stream@2.3.8: + resolution: {integrity: sha512-8p0AUk4XODgIewSi0l8Epjs+EVnWiK7NoDIEGU0HhE7+ZyY8D1IMY7odu5lRrFXGg71L15KG8QrPmum45RTtdA==} + + readable-stream@3.6.2: + resolution: {integrity: sha512-9u/sniCrY3D5WdsERHzHE4G2YCXqoG5FTHUiCC4SIbr6XcLZBY05ya9EKjYek9O5xOAwjGq+1JdGBAS7Q9ScoA==} + engines: {node: '>= 6'} + + readdirp@3.6.0: + resolution: {integrity: sha512-hOS089on8RduqdbhvQ5Z37A0ESjsqz6qnRcffsMU3495FuTdqSm+7bhJ29JvIOsBDEEnan5DPu9t3To9VRlMzA==} + engines: {node: '>=8.10.0'} + + rechoir@0.6.2: + resolution: {integrity: sha512-HFM8rkZ+i3zrV+4LQjwQ0W+ez98pApMGM3HUrN04j3CqzPOzl9nmP15Y8YXNm8QHGv/eacOVEjqhmWpkRV0NAw==} + engines: {node: '>= 0.10'} + + recursive-readdir@2.2.3: + resolution: {integrity: sha512-8HrF5ZsXk5FAH9dgsx3BlUer73nIhuj+9OrQwEbLTPOBzGkL1lsFCR01am+v+0m2Cmbs1nP12hLDl5FA7EszKA==} + engines: {node: '>=6.0.0'} + + redent@3.0.0: + resolution: {integrity: sha512-6tDA8g98We0zd0GvVeMT9arEOnTw9qM03L9cJXaCjrip1OO764RDBLBfrB4cwzNGDj5OA5ioymC9GkizgWJDUg==} + engines: {node: '>=8'} + + reduce-flatten@2.0.0: + resolution: {integrity: sha512-EJ4UNY/U1t2P/2k6oqotuX2Cc3T6nxJwsM0N0asT7dhrtH1ltUxDn4NalSYmPE2rCkVpcf/X6R0wDwcFpzhd4w==} + engines: {node: '>=6'} + + regenerator-runtime@0.14.1: + resolution: {integrity: sha512-dYnhHh0nJoMfnkZs6GmmhFknAGRrLznOu5nc9ML+EJxGvrx6H7teuevqVqCuPcPK//3eDrrjQhehXVx9cnkGdw==} + + regexp.prototype.flags@1.5.2: + resolution: {integrity: sha512-NcDiDkTLuPR+++OCKB0nWafEmhg/Da8aUPLPMQbK+bxKKCm1/S5he+AqYa4PlMCVBalb4/yxIRub6qkEx5yJbw==} + engines: {node: '>= 0.4'} + + release-zalgo@1.0.0: + resolution: {integrity: sha512-gUAyHVHPPC5wdqX/LG4LWtRYtgjxyX78oanFNTMMyFEfOqdC54s3eE82imuWKbOeqYht2CrNf64Qb8vgmmtZGA==} + engines: {node: '>=4'} + + req-cwd@2.0.0: + resolution: {integrity: sha512-ueoIoLo1OfB6b05COxAA9UpeoscNpYyM+BqYlA7H6LVF4hKGPXQQSSaD2YmvDVJMkk4UDpAHIeU1zG53IqjvlQ==} + engines: {node: '>=4'} + + req-from@2.0.0: + resolution: {integrity: sha512-LzTfEVDVQHBRfjOUMgNBA+V6DWsSnoeKzf42J7l0xa/B4jyPOuuF5MlNSmomLNGemWTnV2TIdjSSLnEn95fOQA==} + engines: {node: '>=4'} + + request@2.88.2: + resolution: {integrity: sha512-MsvtOrfG9ZcrOwAW+Qi+F6HbD0CWXEh9ou77uOb7FM2WPhwT7smM833PzanhJLsgXjN89Ir6V2PczXNnMpwKhw==} + engines: {node: '>= 6'} + deprecated: request has been deprecated, see https://github.com/request/request/issues/3142 + + require-directory@2.1.1: + resolution: {integrity: sha512-fGxEI7+wsG9xrvdjsrlmL22OMTTiHRwAMroiEeMgq8gzoLC/PQr7RsRDSTLUg/bZAZtF+TVIkHc6/4RIKrui+Q==} + engines: {node: '>=0.10.0'} + + require-from-string@1.2.1: + resolution: {integrity: sha512-H7AkJWMobeskkttHyhTVtS0fxpFLjxhbfMa6Bk3wimP7sdPRGL3EyCg3sAQenFfAe+xQ+oAc85Nmtvq0ROM83Q==} + engines: {node: '>=0.10.0'} + + require-from-string@2.0.2: + resolution: {integrity: sha512-Xf0nWe6RseziFMu+Ap9biiUbmplq6S9/p+7w7YXP/JBHhrUDDUhwa+vANyubuqfZWTveU//DYVGsDG7RKL/vEw==} + engines: {node: '>=0.10.0'} + + require-main-filename@1.0.1: + resolution: {integrity: sha512-IqSUtOVP4ksd1C/ej5zeEh/BIP2ajqpn8c5x+q99gvcIG/Qf0cud5raVnE/Dwd0ua9TXYDoDc0RE5hBSdz22Ug==} + + require-main-filename@2.0.0: + resolution: {integrity: sha512-NKN5kMDylKuldxYLSUfrbo5Tuzh4hd+2E8NPPX02mZtn1VuREQToYe/ZdlJy+J3uCpfaiGF05e7B8W0iXbQHmg==} + + requireindex@1.2.0: + resolution: {integrity: sha512-L9jEkOi3ASd9PYit2cwRfyppc9NoABujTP8/5gFcbERmo5jUoAKovIC3fsF17pkTnGsrByysqX+Kxd2OTNI1ww==} + engines: {node: '>=0.10.5'} + + resolve-alpn@1.2.1: + resolution: {integrity: sha512-0a1F4l73/ZFZOakJnQ3FvkJ2+gSTQWz/r2KE5OdDY0TxPm5h4GkqkWWfM47T7HsbnOtcJVEF4epCVy6u7Q3K+g==} + + resolve-from@3.0.0: + resolution: {integrity: sha512-GnlH6vxLymXJNMBo7XP1fJIzBFbdYt49CuTwmB/6N53t+kMPRMFKz783LlQ4tv28XoQfMWinAJX6WCGf2IlaIw==} + engines: {node: '>=4'} + + resolve-from@4.0.0: + resolution: {integrity: sha512-pb/MYmXstAkysRFx8piNI1tGFNQIFA3vkE3Gq4EuA1dF6gHp/+vgZqsCGJapvy8N3Q+4o7FwvquPJcnZ7RYy4g==} + engines: {node: '>=4'} + + resolve-from@5.0.0: + resolution: {integrity: sha512-qYg9KP24dD5qka9J47d0aVky0N+b4fTU89LN9iDnjB5waksiC49rvMB0PrUJQGoTmH50XPiqOvAjDfaijGxYZw==} + engines: {node: '>=8'} + + resolve-pkg-maps@1.0.0: + resolution: {integrity: sha512-seS2Tj26TBVOC2NIc2rOe2y2ZO7efxITtLZcGSOnHHNOQ7CkiUBfw0Iw2ck6xkIhPwLhKNLS8BO+hEpngQlqzw==} + + resolve@1.1.7: + resolution: {integrity: sha512-9znBF0vBcaSN3W2j7wKvdERPwqTxSpCq+if5C0WoTCyV9n24rua28jeuQ2pL/HOf+yUe/Mef+H/5p60K0Id3bg==} + + resolve@1.17.0: + resolution: {integrity: sha512-ic+7JYiV8Vi2yzQGFWOkiZD5Z9z7O2Zhm9XMaTxdJExKasieFCr+yXZ/WmXsckHiKl12ar0y6XiXDx3m4RHn1w==} + + resolve@1.22.8: + resolution: {integrity: sha512-oKWePCxqpd6FlLvGV1VU0x7bkPmmCNolxzjMf4NczoDnQcIWrAF+cPtZn5i6n+RfD2d9i0tzpKnG6Yk168yIyw==} + hasBin: true + + responselike@2.0.1: + resolution: {integrity: sha512-4gl03wn3hj1HP3yzgdI7d3lCkF95F21Pz4BPGvKHinyQzALR5CapwC8yIi0Rh58DEMQ/SguC03wFj2k0M/mHhw==} + + restore-cursor@3.1.0: + resolution: {integrity: sha512-l+sSefzHpj5qimhFSE5a8nufZYAM3sBSVMAPtYkmC+4EH2anSGaEMXSD0izRQbu9nfyQ9y5JrVmp7E8oZrUjvA==} + engines: {node: '>=8'} + + reusify@1.0.4: + resolution: {integrity: sha512-U9nH88a3fc/ekCF1l0/UP1IosiuIjyTh7hBvXVMHYgVcfGvt897Xguj2UOLDeI5BG2m7/uwyaLVT6fbtCwTyzw==} + engines: {iojs: '>=1.0.0', node: '>=0.10.0'} + + rimraf@2.7.1: + resolution: {integrity: sha512-uWjbaKIK3T1OSVptzX7Nl6PvQ3qAGtKEtVRjRuazjfL3Bx5eI409VZSqgND+4UNnmzLVdPj9FqFJNPqBZFve4w==} + hasBin: true + + rimraf@3.0.2: + resolution: {integrity: sha512-JZkJMZkAGFFPP2YqXZXPbMlMBgsxzE8ILs4lMIX/2o0L9UBw9O/Y3o6wFw/i9YLapcUJWwqbi3kdxIPdC62TIA==} + hasBin: true + + ripemd160-min@0.0.6: + resolution: {integrity: sha512-+GcJgQivhs6S9qvLogusiTcS9kQUfgR75whKuy5jIhuiOfQuJ8fjqxV6EGD5duH1Y/FawFUMtMhyeq3Fbnib8A==} + engines: {node: '>=8'} + + ripemd160@2.0.2: + resolution: {integrity: sha512-ii4iagi25WusVoiC4B4lq7pbXfAp3D9v5CwfkY33vffw2+pkDjY1D8GaN7spsxvCSx8dkPqOZCEZyfxcmJG2IA==} + + rlp@2.2.7: + resolution: {integrity: sha512-d5gdPmgQ0Z+AklL2NVXr/IoSjNZFfTVvQWzL/AM2AOcSzYP2xjlb0AC8YyCLc41MSNf6P6QVtjgPdmVtzb+4lQ==} + hasBin: true + + run-parallel@1.2.0: + resolution: {integrity: sha512-5l4VyZR86LZ/lDxZTR6jqL8AFE2S0IFLMP26AbjsLVADxHdhB/c0GUsH+y39UfCi3dzz8OlQuPmnaJOMoDHQBA==} + + rxjs@7.8.1: + resolution: {integrity: sha512-AA3TVj+0A2iuIoQkWEK/tqFjBq2j+6PO6Y0zJcvzLAFhEFIO3HL0vls9hWLncZbAAbK0mar7oZ4V079I/qPMxg==} + + safe-array-concat@1.1.2: + resolution: {integrity: sha512-vj6RsCsWBCf19jIeHEfkRMw8DPiBb+DMXklQ/1SGDHOMlHdPUkZXFQ2YdplS23zESTijAcurb1aSgJA3AgMu1Q==} + engines: {node: '>=0.4'} + + safe-buffer@5.1.2: + resolution: {integrity: sha512-Gd2UZBJDkXlY7GbJxfsE8/nvKkUEU1G38c1siN6QP6a9PT9MmHB8GnpscSmMJSoF8LOIrt8ud/wPtojys4G6+g==} + + safe-buffer@5.2.1: + resolution: {integrity: sha512-rp3So07KcdmmKbGvgaNxQSJr7bGVSVk5S9Eq1F+ppbRo70+YeaDxkw5Dd8NPN+GD6bjnYm2VuPuCXmpuYvmCXQ==} + + safe-regex-test@1.0.3: + resolution: {integrity: sha512-CdASjNJPvRa7roO6Ra/gLYBTzYzzPyyBXxIMdGW3USQLyjWEls2RgW5UBTXaQVp+OrpeCK3bLem8smtmheoRuw==} + engines: {node: '>= 0.4'} + + safer-buffer@2.1.2: + resolution: {integrity: sha512-YZo3K82SD7Riyi0E1EQPojLz7kpepnSQI9IyPbHHg1XXXevb5dJI7tpyN2ADxGcQbHG7vcyRHk0cbwqcQriUtg==} + + sc-istanbul@0.4.6: + resolution: {integrity: sha512-qJFF/8tW/zJsbyfh/iT/ZM5QNHE3CXxtLJbZsL+CzdJLBsPD7SedJZoUA4d8iAcN2IoMp/Dx80shOOd2x96X/g==} + hasBin: true + + scheduler@0.23.2: + resolution: {integrity: sha512-UOShsPwz7NrMUqhR6t0hWjFduvOzbtv7toDH1/hIrfRNIDBnnBWd0CwJTGvTpngVlmwGCdP9/Zl/tVrDqcuYzQ==} + + scrypt-js@2.0.4: + resolution: {integrity: sha512-4KsaGcPnuhtCZQCxFxN3GVYIhKFPTdLd8PLC552XwbMndtD0cjRFAhDuuydXQ0h08ZfPgzqe6EKHozpuH74iDw==} + + scrypt-js@3.0.1: + resolution: {integrity: sha512-cdwTTnqPu0Hyvf5in5asVdZocVDTNRmR7XEcJuIzMjJeSHybHl7vpB66AzwTaIg6CLSbtjcxc8fqcySfnTkccA==} + + secp256k1@4.0.3: + resolution: {integrity: sha512-NLZVf+ROMxwtEj3Xa562qgv2BK5e2WNmXPiOdVIPLgs6lyTzMvBq0aWTYMI5XCP9jZMVKOcqZLw/Wc4vDkuxhA==} + engines: {node: '>=10.0.0'} + + semver@5.7.2: + resolution: {integrity: sha512-cBznnQ9KjJqU67B52RMC65CMarK2600WFnbkcaiwWq3xy/5haFJlshgnpjovMVJ+Hff49d8GEn0b87C5pDQ10g==} + hasBin: true + + semver@6.3.1: + resolution: {integrity: sha512-BR7VvDCVHO+q2xBEWskxS6DJE1qRnb7DxzUrogb71CWoSficBxYsiAGd+Kl0mmq/MprG9yArRkyrQxTO6XjMzA==} + hasBin: true + + semver@7.6.2: + resolution: {integrity: sha512-FNAIBWCx9qcRhoHcgcJ0gvU7SN1lYU2ZXuSfl04bSC5OpvDHFyJCjdNHomPXxjQlCBU67YW64PzY7/VIEH7F2w==} + engines: {node: '>=10'} + hasBin: true + + send@0.18.0: + resolution: {integrity: sha512-qqWzuOjSFOuqPjFe4NOsMLafToQQwBSOEpS+FwEt3A2V3vKubTquT3vmLTQpFgMXp8AlFWFuP1qKaJZOtPpVXg==} + engines: {node: '>= 0.8.0'} + + sentence-case@2.1.1: + resolution: {integrity: sha512-ENl7cYHaK/Ktwk5OTD+aDbQ3uC8IByu/6Bkg+HDv8Mm+XnBnppVNalcfJTNsp1ibstKh030/JKQQWglDvtKwEQ==} + + serialize-javascript@6.0.0: + resolution: {integrity: sha512-Qr3TosvguFt8ePWqsvRfrKyQXIiW+nGbYpy8XK24NQHE83caxWt+mIymTT19DGFbNWNLfEwsrkSmN64lVWB9ag==} + + serve-static@1.15.0: + resolution: {integrity: sha512-XGuRDNjXUijsUL0vl6nSD7cwURuzEgglbOaFuZM9g3kwDXOWVTck0jLzjPzGD+TazWbboZYu52/9/XPdUgne9g==} + engines: {node: '>= 0.8.0'} + + servify@0.1.12: + resolution: {integrity: sha512-/xE6GvsKKqyo1BAY+KxOWXcLpPsUUyji7Qg3bVD7hh1eRze5bR1uYiuDA/k3Gof1s9BTzQZEJK8sNcNGFIzeWw==} + engines: {node: '>=6'} + + set-blocking@2.0.0: + resolution: {integrity: sha512-KiKBS8AnWGEyLzofFfmvKwpdPzqiy16LvQfK3yv/fVH7Bj13/wl3JSR1J+rfgRE9q7xUJK4qvgS8raSOeLUehw==} + + set-function-length@1.2.2: + resolution: {integrity: sha512-pgRc4hJ4/sNjWCSS9AmnS40x3bNMDTknHgL5UaMBTMyJnU90EgWh1Rz+MC9eFu4BuN/UwZjKQuY/1v3rM7HMfg==} + engines: {node: '>= 0.4'} + + set-function-name@2.0.2: + resolution: {integrity: sha512-7PGFlmtwsEADb0WYyvCMa1t+yke6daIG4Wirafur5kcf+MhUnPms1UeR0CKQdTZD81yESwMHbtn+TR+dMviakQ==} + engines: {node: '>= 0.4'} + + setimmediate@1.0.4: + resolution: {integrity: sha512-/TjEmXQVEzdod/FFskf3o7oOAsGhHf2j1dZqRFbDzq4F3mvvxflIIi4Hd3bLQE9y/CpwqfSQam5JakI/mi3Pog==} + + setimmediate@1.0.5: + resolution: {integrity: sha512-MATJdZp8sLqDl/68LfQmbP8zKPLQNV6BIZoIgrscFDQ+RsvK/BxeDQOgyxKKoh0y/8h3BqVFnCqQ/gd+reiIXA==} + + setprototypeof@1.2.0: + resolution: {integrity: sha512-E5LDX7Wrp85Kil5bhZv46j8jOeboKq5JMmYM3gVGdGH8xFpPWXUMsNrlODCrkoxMEeNi/XZIwuRvY4XNwYMJpw==} + + sha.js@2.4.11: + resolution: {integrity: sha512-QMEp5B7cftE7APOjk5Y6xgrbWu+WkLVQwk8JNjZ8nKRciZaByEW6MubieAiToS7+dwvrjGhH8jRXz3MVd0AYqQ==} + hasBin: true + + sha1@1.1.1: + resolution: {integrity: sha512-dZBS6OrMjtgVkopB1Gmo4RQCDKiZsqcpAQpkV/aaj+FCrCg8r4I4qMkDPQjBgLIxlmu9k4nUbWq6ohXahOneYA==} + + sha3@2.1.4: + resolution: {integrity: sha512-S8cNxbyb0UGUM2VhRD4Poe5N58gJnJsLJ5vC7FYWGUmGhcsj4++WaIOBFVDxlG0W3To6xBuiRh+i0Qp2oNCOtg==} + + shebang-command@1.2.0: + resolution: {integrity: sha512-EV3L1+UQWGor21OmnvojK36mhg+TyIKDh3iFBKBohr5xeXIhNBcx8oWdgkTEEQ+BEFFYdLRuqMfd5L84N1V5Vg==} + engines: {node: '>=0.10.0'} + + shebang-command@2.0.0: + resolution: {integrity: sha512-kHxr2zZpYtdmrN1qDjrrX/Z1rR1kG8Dx+gkpK1G4eXmvXswmcE1hTWBWYUzlraYw1/yZp6YuDY77YtvbN0dmDA==} + engines: {node: '>=8'} + + shebang-regex@1.0.0: + resolution: {integrity: sha512-wpoSFAxys6b2a2wHZ1XpDSgD7N9iVjg29Ph9uV/uaP9Ex/KXlkTZTeddxDPSYQpgvzKLGJke2UU0AzoGCjNIvQ==} + engines: {node: '>=0.10.0'} + + shebang-regex@3.0.0: + resolution: {integrity: sha512-7++dFhtcx3353uBaq8DDR4NuxBetBzC7ZQOhmTQInHEd6bSrXdiEyzCvG07Z44UYdLShWUyXt5M/yhz8ekcb1A==} + engines: {node: '>=8'} + + shelljs@0.8.5: + resolution: {integrity: sha512-TiwcRcrkhHvbrZbnRcFYMLl30Dfov3HKqzp5tO5b4pt6G/SezKcYhmDg15zXVBswHmctSAQKznqNW2LO5tTDow==} + engines: {node: '>=4'} + hasBin: true + + side-channel@1.0.6: + resolution: {integrity: sha512-fDW/EZ6Q9RiO8eFG8Hj+7u/oW+XrPTIChwCOM2+th2A6OblDtYYIpve9m+KvI9Z4C9qSEXlaGR6bTEYHReuglA==} + engines: {node: '>= 0.4'} + + signal-exit@3.0.7: + resolution: {integrity: sha512-wnD2ZE+l+SPC/uoS0vXeE9L1+0wuaMqKlfz9AMUo38JsyLSBWSFcHR1Rri62LZc12vLr1gb3jl7iwQhgwpAbGQ==} + + simple-concat@1.0.1: + resolution: {integrity: sha512-cSFtAPtRhljv69IK0hTVZQ+OfE9nePi/rtJmw5UjHeVyVroEqJXP1sFztKUy1qU+xvz3u/sfYJLa947b7nAN2Q==} + + simple-get@2.8.2: + resolution: {integrity: sha512-Ijd/rV5o+mSBBs4F/x9oDPtTx9Zb6X9brmnXvMW4J7IR15ngi9q5xxqWBKU744jTZiaXtxaPL7uHG6vtN8kUkw==} + + simple-get@4.0.1: + resolution: {integrity: sha512-brv7p5WgH0jmQJr1ZDDfKDOSeWWg+OVypG99A/5vYGPqJ6pxiaHLy8nxtFjBA7oMa01ebA9gfh1uMCFqOuXxvA==} + + sinon-chai@3.7.0: + resolution: {integrity: sha512-mf5NURdUaSdnatJx3uhoBOrY9dtL19fiOtAdT1Azxg3+lNJFiuN0uzaU3xX1LeAfL17kHQhTAJgpsfhbMJMY2g==} + peerDependencies: + chai: ^4.0.0 + sinon: '>=4.0.0' + + sinon@9.2.4: + resolution: {integrity: sha512-zljcULZQsJxVra28qIAL6ow1Z9tpattkCTEJR4RBP3TGc00FcttsP5pK284Nas5WjMZU5Yzy3kAIp3B3KRf5Yg==} + deprecated: 16.1.1 + + sisteransi@1.0.5: + resolution: {integrity: sha512-bLGGlR1QxBcynn2d5YmDX4MGjlZvy2MRBDRNHLJ8VI6l6+9FUiyTFNJ0IveOSP0bcXgVDPRcfGqA0pjaqUpfVg==} + + slash@3.0.0: + resolution: {integrity: sha512-g9Q1haeby36OSStwb4ntCGGGaKsaVSjQ68fBxoQcutl5fS1vuY18H3wSt3jFyFtrkx+Kz0V1G85A4MyAdDMi2Q==} + engines: {node: '>=8'} + + slice-ansi@4.0.0: + resolution: {integrity: sha512-qMCMfhY040cVHT43K9BFygqYbUPFZKHOg7K73mtTWJRb8pyP3fzf4Ixd5SzdEJQ6MRUg/WBnOLxghZtKKurENQ==} + engines: {node: '>=10'} + + smartwrap@2.0.2: + resolution: {integrity: sha512-vCsKNQxb7PnCNd2wY1WClWifAc2lwqsG8OaswpJkVJsvMGcnEntdTCDajZCkk93Ay1U3t/9puJmb525Rg5MZBA==} + engines: {node: '>=6'} + hasBin: true + + snake-case@2.1.0: + resolution: {integrity: sha512-FMR5YoPFwOLuh4rRz92dywJjyKYZNLpMn1R5ujVpIYkbA9p01fq8RMg0FkO4M+Yobt4MjHeLTJVm5xFFBHSV2Q==} + + solc@0.4.26: + resolution: {integrity: sha512-o+c6FpkiHd+HPjmjEVpQgH7fqZ14tJpXhho+/bQXlXbliLIS/xjXb42Vxh+qQY1WCSTMQ0+a5vR9vi0MfhU6mA==} + hasBin: true + + solc@0.7.3: + resolution: {integrity: sha512-GAsWNAjGzIDg7VxzP6mPjdurby3IkGCjQcM8GFYZT6RyaoUZKmMU6Y7YwG+tFGhv7dwZ8rmR4iwFDrrD99JwqA==} + engines: {node: '>=8.0.0'} + hasBin: true + + solhint@3.6.2: + resolution: {integrity: sha512-85EeLbmkcPwD+3JR7aEMKsVC9YrRSxd4qkXuMzrlf7+z2Eqdfm1wHWq1ffTuo5aDhoZxp2I9yF3QkxZOxOL7aQ==} + hasBin: true + + solidity-coverage@0.8.12: + resolution: {integrity: sha512-8cOB1PtjnjFRqOgwFiD8DaUsYJtVJ6+YdXQtSZDrLGf8cdhhh8xzTtGzVTGeBf15kTv0v7lYPJlV/az7zLEPJw==} + hasBin: true + peerDependencies: + hardhat: ^2.11.0 + + solpp@0.11.5: + resolution: {integrity: sha512-LjzCGMrTDXtera2C4mbQGZSpBznP+o3/82L2CneAAMNbm+t4xPsvfrgJkIaY+IZ5YLrB8IXn7cYthwHMKvAWnQ==} + engines: {node: '>=8.15.1'} + hasBin: true + + source-map-support@0.5.21: + resolution: {integrity: sha512-uBHU3L3czsIyYXKX88fdrGovxdSCoTGDRZ6SYXtSRxLZUzHg5P/66Ht6uoUlHu9EZod+inXhKo3qQgwXUT/y1w==} + + source-map@0.2.0: + resolution: {integrity: sha512-CBdZ2oa/BHhS4xj5DlhjWNHcan57/5YuvfdLf17iVmIpd9KRm+DFLmC6nBNj+6Ua7Kt3TmOjDpQT1aTYOQtoUA==} + engines: {node: '>=0.8.0'} + + source-map@0.6.1: + resolution: {integrity: sha512-UjgapumWlbMhkBgzT7Ykc5YXUT46F0iKu8SGXq0bcwP5dz/h0Plj6enJqjz1Zbq2l5WaqYnrVbwWOWMyF3F47g==} + engines: {node: '>=0.10.0'} + + spawn-wrap@2.0.0: + resolution: {integrity: sha512-EeajNjfN9zMnULLwhZZQU3GWBoFNkbngTUPfaawT4RkMiviTxcX0qfhVbGey39mfctfDHkWtuecgQ8NJcyQWHg==} + engines: {node: '>=8'} + + spawndamnit@2.0.0: + resolution: {integrity: sha512-j4JKEcncSjFlqIwU5L/rp2N5SIPsdxaRsIv678+TZxZ0SRDJTm8JrxJMjE/XuiEZNEir3S8l0Fa3Ke339WI4qA==} + + spdx-correct@3.2.0: + resolution: {integrity: sha512-kN9dJbvnySHULIluDHy32WHRUu3Og7B9sbY7tsFLctQkIqnMh3hErYgdMjTYuqmcXX+lK5T1lnUt3G7zNswmZA==} + + spdx-exceptions@2.5.0: + resolution: {integrity: sha512-PiU42r+xO4UbUS1buo3LPJkjlO7430Xn5SVAhdpzzsPHsjbYVflnnFdATgabnLude+Cqu25p6N+g2lw/PFsa4w==} + + spdx-expression-parse@3.0.1: + resolution: {integrity: sha512-cbqHunsQWnJNE6KhVSMsMeH5H/L9EpymbzqTQ3uLwNCLZ1Q481oWaofqH7nO6V07xlXwY6PhQdQ2IedWx/ZK4Q==} + + spdx-license-ids@3.0.17: + resolution: {integrity: sha512-sh8PWc/ftMqAAdFiBu6Fy6JUOYjqDJBJvIhpfDMyHrr0Rbp5liZqd4TjtQ/RgfLjKFZb+LMx5hpml5qOWy0qvg==} + + split2@3.2.2: + resolution: {integrity: sha512-9NThjpgZnifTkJpzTZ7Eue85S49QwpNhZTq6GRJwObb6jnLFNGB7Qm73V5HewTROPyxD0C29xqmaI68bQtV+hg==} + + sprintf-js@1.0.3: + resolution: {integrity: sha512-D9cPgkvLlV3t3IzL0D0YLvGA9Ahk4PcvVwUbN0dSGr1aP0Nrt4AEnTUbuGvquEC0mA64Gqt1fzirlRs5ibXx8g==} + + sshpk@1.18.0: + resolution: {integrity: sha512-2p2KJZTSqQ/I3+HX42EpYOa2l3f8Erv8MWKsy2I9uf4wA7yFIkXRffYdsx86y6z4vHtV8u7g+pPlr8/4ouAxsQ==} + engines: {node: '>=0.10.0'} + hasBin: true + + stacktrace-parser@0.1.10: + resolution: {integrity: sha512-KJP1OCML99+8fhOHxwwzyWrlUuVX5GQ0ZpJTd1DFXhdkrvg1szxfHhawXUZ3g9TkXORQd4/WG68jMlQZ2p8wlg==} + engines: {node: '>=6'} + + statuses@2.0.1: + resolution: {integrity: sha512-RwNA9Z/7PrK06rYLIzFMlaF+l73iwpzsqRIFgbMLbTcLD6cOao82TaWefPXQvB2fOC4AjuYSEndS7N/mTCbkdQ==} + engines: {node: '>= 0.8'} + + stream-transform@2.1.3: + resolution: {integrity: sha512-9GHUiM5hMiCi6Y03jD2ARC1ettBXkQBoQAe7nJsPknnI0ow10aXjTnew8QtYQmLjzn974BnmWEAJgCY6ZP1DeQ==} + + strict-uri-encode@1.1.0: + resolution: {integrity: sha512-R3f198pcvnB+5IpnBlRkphuE9n46WyVl8I39W/ZUTZLz4nqSP/oLYUrcnJrw462Ds8he4YKMov2efsTIw1BDGQ==} + engines: {node: '>=0.10.0'} + + string-format@2.0.0: + resolution: {integrity: sha512-bbEs3scLeYNXLecRRuk6uJxdXUSj6le/8rNPHChIJTn2V79aXVTR1EH2OH5zLKKoz0V02fOUKZZcw01pLUShZA==} + + string-width@1.0.2: + resolution: {integrity: sha512-0XsVpQLnVCXHJfyEs8tC0zpTVIr5PKKsQtkT29IwupnPTjtPmQ3xT/4yCREF9hYkV/3M3kzcUTSAZT6a6h81tw==} + engines: {node: '>=0.10.0'} + + string-width@2.1.1: + resolution: {integrity: sha512-nOqH59deCq9SRHlxq1Aw85Jnt4w6KvLKqWVik6oA9ZklXLNIOlqg4F2yrT1MVaTjAqvVwdfeZ7w7aCvJD7ugkw==} + engines: {node: '>=4'} + + string-width@4.2.3: + resolution: {integrity: sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g==} + engines: {node: '>=8'} + + string.prototype.trim@1.2.9: + resolution: {integrity: sha512-klHuCNxiMZ8MlsOihJhJEBJAiMVqU3Z2nEXWfWnIqjN0gEFS9J9+IxKozWWtQGcgoa1WUZzLjKPTr4ZHNFTFxw==} + engines: {node: '>= 0.4'} + + string.prototype.trimend@1.0.8: + resolution: {integrity: sha512-p73uL5VCHCO2BZZ6krwwQE3kCzM7NKmis8S//xEC6fQonchbum4eP6kR4DLEjQFO3Wnj3Fuo8NM0kOSjVdHjZQ==} + + string.prototype.trimstart@1.0.8: + resolution: {integrity: sha512-UXSH262CSZY1tfu3G3Secr6uGLCFVPMhIqHjlgCUtCCcgihYc/xKs9djMTMUOb2j1mVSeU8EU6NWc/iQKU6Gfg==} + engines: {node: '>= 0.4'} + + string_decoder@1.1.1: + resolution: {integrity: sha512-n/ShnvDi6FHbbVfviro+WojiFzv+s8MPMHBczVePfUpDJLwoLT0ht1l4YwBCbi8pJAveEEdnkHyPyTP/mzRfwg==} + + string_decoder@1.3.0: + resolution: {integrity: sha512-hkRX8U1WjJFd8LsDJ2yQ/wWWxaopEsABU1XfkM8A+j0+85JAGppt16cr1Whg6KIbb4okU6Mql6BOj+uup/wKeA==} + + strip-ansi@0.1.1: + resolution: {integrity: sha512-behete+3uqxecWlDAm5lmskaSaISA+ThQ4oNNBDTBJt0x2ppR6IPqfZNuj6BLaLJ/Sji4TPZlcRyOis8wXQTLg==} + engines: {node: '>=0.8.0'} + hasBin: true + + strip-ansi@3.0.1: + resolution: {integrity: sha512-VhumSSbBqDTP8p2ZLKj40UjBCV4+v8bUSEpUb4KjRgWk9pbqGF4REFj6KEagidb2f/M6AzC0EmFyDNGaw9OCzg==} + engines: {node: '>=0.10.0'} + + strip-ansi@4.0.0: + resolution: {integrity: sha512-4XaJ2zQdCzROZDivEVIDPkcQn8LMFSa8kj8Gxb/Lnwzv9A8VctNZ+lfivC/sV3ivW8ElJTERXZoPBRrZKkNKow==} + engines: {node: '>=4'} + + strip-ansi@6.0.1: + resolution: {integrity: sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A==} + engines: {node: '>=8'} + + strip-bom@2.0.0: + resolution: {integrity: sha512-kwrX1y7czp1E69n2ajbG65mIo9dqvJ+8aBQXOGVxqwvNbsXdFM6Lq37dLAY3mknUwru8CfcCbfOLL/gMo+fi3g==} + engines: {node: '>=0.10.0'} + + strip-bom@3.0.0: + resolution: {integrity: sha512-vavAMRXOgBVNF6nyEEmL3DBK19iRpDcoIwW+swQ+CbGiu7lju6t+JklA1MHweoWtadgt4ISVUsXLyDq34ddcwA==} + engines: {node: '>=4'} + + strip-bom@4.0.0: + resolution: {integrity: sha512-3xurFv5tEgii33Zi8Jtp55wEIILR9eh34FAW00PZf+JnSsTmV/ioewSgQl97JHvgjoRGwPShsWm+IdrxB35d0w==} + engines: {node: '>=8'} + + strip-hex-prefix@1.0.0: + resolution: {integrity: sha512-q8d4ue7JGEiVcypji1bALTos+0pWtyGlivAWyPuTkHzuTCJqrK9sWxYQZUq6Nq3cuyv3bm734IhHvHtGGURU6A==} + engines: {node: '>=6.5.0', npm: '>=3'} + + strip-indent@2.0.0: + resolution: {integrity: sha512-RsSNPLpq6YUL7QYy44RnPVTn/lcVZtb48Uof3X5JLbF4zD/Gs7ZFDv2HWol+leoQN2mT86LAzSshGfkTlSOpsA==} + engines: {node: '>=4'} + + strip-indent@3.0.0: + resolution: {integrity: sha512-laJTa3Jb+VQpaC6DseHhF7dXVqHTfJPCRDaEbid/drOhgitgYku/letMUqOXFoWV0zIIUbjpdH2t+tYj4bQMRQ==} + engines: {node: '>=8'} + + strip-json-comments@2.0.1: + resolution: {integrity: sha512-4gB8na07fecVVkOI6Rs4e7T6NOTki5EmL7TUduTs6bu3EdnSycntVJ4re8kgZA+wx9IueI2Y11bfbgwtzuE0KQ==} + engines: {node: '>=0.10.0'} + + strip-json-comments@3.1.1: + resolution: {integrity: sha512-6fPc+R4ihwqP6N/aIv2f1gMH8lOVtWQHoqC4yK6oSDVVocumAsfCqjkXnqiYMhmMwS/mEHLp7Vehlt3ql6lEig==} + engines: {node: '>=8'} + + supports-color@3.2.3: + resolution: {integrity: sha512-Jds2VIYDrlp5ui7t8abHN2bjAu4LV/q4N2KivFPpGH0lrka0BMq/33AmECUXlKPcHigkNaqfXRENFju+rlcy+A==} + engines: {node: '>=0.8.0'} + + supports-color@5.5.0: + resolution: {integrity: sha512-QjVjwdXIt408MIiAqCX4oUKsgU2EqAGzs2Ppkm4aQYbjm+ZEWEcW4SfFNTr4uMNZma0ey4f5lgLrkB0aX0QMow==} + engines: {node: '>=4'} + + supports-color@7.2.0: + resolution: {integrity: sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw==} + engines: {node: '>=8'} + + supports-color@8.1.1: + resolution: {integrity: sha512-MpUEN2OodtUzxvKQl72cUF7RQ5EiHsGvSsVG0ia9c5RbWGL2CI4C7EpPS8UTBIplnlzZiNuV56w+FuNxy3ty2Q==} + engines: {node: '>=10'} + + supports-preserve-symlinks-flag@1.0.0: + resolution: {integrity: sha512-ot0WnXS9fgdkgIcePe6RHNk1WA8+muPa6cSjeR3V8K27q9BB1rTE3R1p7Hv0z1ZyAc8s6Vvv8DIyWf681MAt0w==} + engines: {node: '>= 0.4'} + + swap-case@1.1.2: + resolution: {integrity: sha512-BAmWG6/bx8syfc6qXPprof3Mn5vQgf5dwdUNJhsNqU9WdPt5P+ES/wQ5bxfijy8zwZgZZHslC3iAsxsuQMCzJQ==} + + swarm-js@0.1.42: + resolution: {integrity: sha512-BV7c/dVlA3R6ya1lMlSSNPLYrntt0LUq4YMgy3iwpCIc6rZnS5W2wUoctarZ5pXlpKtxDDf9hNziEkcfrxdhqQ==} + + sync-request@6.1.0: + resolution: {integrity: sha512-8fjNkrNlNCrVc/av+Jn+xxqfCjYaBoHqCsDz6mt030UMxJGr+GSfCV1dQt2gRtlL63+VPidwDVLr7V2OcTSdRw==} + engines: {node: '>=8.0.0'} + + sync-rpc@1.3.6: + resolution: {integrity: sha512-J8jTXuZzRlvU7HemDgHi3pGnh/rkoqR/OZSjhTyyZrEkkYQbk7Z33AXp37mkPfPpfdOuj7Ex3H/TJM1z48uPQw==} + + table-layout@1.0.2: + resolution: {integrity: sha512-qd/R7n5rQTRFi+Zf2sk5XVVd9UQl6ZkduPFC3S7WEGJAmetDTjY3qPN50eSKzwuzEyQKy5TN2TiZdkIjos2L6A==} + engines: {node: '>=8.0.0'} + + table@6.8.2: + resolution: {integrity: sha512-w2sfv80nrAh2VCbqR5AK27wswXhqcck2AhfnNW76beQXskGZ1V12GwS//yYVa3d3fcvAip2OUnbDAjW2k3v9fA==} + engines: {node: '>=10.0.0'} + + tar-fs@2.1.1: + resolution: {integrity: sha512-V0r2Y9scmbDRLCNex/+hYzvp/zyYjvFbHPNgVTKfQvVrb6guiE/fxP+XblDNR011utopbkex2nM4dHNV6GDsng==} + + tar-stream@2.2.0: + resolution: {integrity: sha512-ujeqbceABgwMZxEJnk2HDY2DlnUZ+9oEcb1KzTVfYHio0UE6dG71n60d8D2I4qNvleWrrXpmjpt7vZeF1LnMZQ==} + engines: {node: '>=6'} + + tar@4.4.19: + resolution: {integrity: sha512-a20gEsvHnWe0ygBY8JbxoM4w3SJdhc7ZAuxkLqh+nvNQN2IOt0B5lLgM490X5Hl8FF0dl0tOf2ewFYAlIFgzVA==} + engines: {node: '>=4.5'} + + term-size@2.2.1: + resolution: {integrity: sha512-wK0Ri4fOGjv/XPy8SBHZChl8CM7uMc5VML7SqiQ0zG7+J5Vr+RMQDoHa2CNT6KHUnTGIXH34UDMkPzAUyapBZg==} + engines: {node: '>=8'} + + test-exclude@6.0.0: + resolution: {integrity: sha512-cAGWPIyOHU6zlmg88jwm7VRyXnMN7iV68OGAbYDk/Mh/xC/pzVPlQtY6ngoIH/5/tciuhGfvESU8GrHrcxD56w==} + engines: {node: '>=8'} + + testrpc@0.0.1: + resolution: {integrity: sha512-afH1hO+SQ/VPlmaLUFj2636QMeDvPCeQMc/9RBMW0IfjNe9gFD9Ra3ShqYkB7py0do1ZcCna/9acHyzTJ+GcNA==} + deprecated: testrpc has been renamed to ganache-cli, please use this package from now on. + + text-table@0.2.0: + resolution: {integrity: sha512-N+8UisAXDGk8PFXP4HAzVR9nbfmVJ3zYLAWiTIoqC5v5isinhr+r5uaO8+7r3BMfuNIufIsA7RdpVgacC2cSpw==} + + then-request@6.0.2: + resolution: {integrity: sha512-3ZBiG7JvP3wbDzA9iNY5zJQcHL4jn/0BWtXIkagfz7QgOL/LqjCEOBQuJNZfu0XYnv5JhKh+cDxCPM4ILrqruA==} + engines: {node: '>=6.0.0'} + + thenify-all@1.6.0: + resolution: {integrity: sha512-RNxQH/qI8/t3thXJDwcstUO4zeqo64+Uy/+sNVRBx4Xn2OX+OZ9oP+iJnNFqplFra2ZUVeKCSa2oVWi3T4uVmA==} + engines: {node: '>=0.8'} + + thenify@3.3.1: + resolution: {integrity: sha512-RVZSIV5IG10Hk3enotrhvz0T9em6cyHBLkH/YAZuKqd8hRkKhSfCGIcP2KUY0EPxndzANBmNllzWPwak+bheSw==} + + through2@4.0.2: + resolution: {integrity: sha512-iOqSav00cVxEEICeD7TjLB1sueEL+81Wpzp2bY17uZjZN0pWZPuo4suZ/61VujxmqSGFfgOcNuTZ85QJwNZQpw==} + + time-require@0.1.2: + resolution: {integrity: sha512-IqcSpa1sVNleRbC9eHnN7p7vwEHNmsjsXUDqjlnvo4+2VLJ7/gIY2XACTBuRhMB4weYbDYKsR3av2ySykRhDIA==} + engines: {node: '>= 0.10.0'} + + timed-out@4.0.1: + resolution: {integrity: sha512-G7r3AhovYtr5YKOWQkta8RKAPb+J9IsO4uVmzjl8AZwfhs8UcUwTiD6gcJYSgOtzyjvQKrKYn41syHbUWMkafA==} + engines: {node: '>=0.10.0'} + + title-case@2.1.1: + resolution: {integrity: sha512-EkJoZ2O3zdCz3zJsYCsxyq2OC5hrxR9mfdd5I+w8h/tmFfeOxJ+vvkxsKxdmN0WtS9zLdHEgfgVOiMVgv+Po4Q==} + + tmp@0.0.33: + resolution: {integrity: sha512-jRCJlojKnZ3addtTOjdIqoRuPEKBvNXcGYqzO6zWZX8KfKEpnGY5jfggJQ3EjKuu8D4bJRr0y+cYJFmYbImXGw==} + engines: {node: '>=0.6.0'} + + to-fast-properties@2.0.0: + resolution: {integrity: sha512-/OaKK0xYrs3DmxRYqL/yDc+FxFUVYhDlXMhRmv3z915w2HF1tnN1omB354j8VUGO/hbRzyD6Y3sA7v7GS/ceog==} + engines: {node: '>=4'} + + to-regex-range@5.0.1: + resolution: {integrity: sha512-65P7iz6X5yEr1cwcgvQxbbIw7Uk3gOy5dIdtZ4rDveLqhrdJP+Li/Hx6tyK0NEb+2GCyneCMJiGqrADCSNk8sQ==} + engines: {node: '>=8.0'} + + toidentifier@1.0.1: + resolution: {integrity: sha512-o5sSPKEkg/DIQNmH43V0/uerLrpzVedkUh8tGNvaeXpfpuwjKenlSox/2O/BTlZUtEe+JG7s5YhEz608PlAHRA==} + engines: {node: '>=0.6'} + + tough-cookie@2.5.0: + resolution: {integrity: sha512-nlLsUzgm1kfLXSXfRZMc1KLAugd4hqJHDTvc2hDIwS3mZAfMEuMbc03SujMF+GEcpaX/qboeycw6iO8JwVv2+g==} + engines: {node: '>=0.8'} + + tr46@0.0.3: + resolution: {integrity: sha512-N3WMsuqV66lT30CrXNbEjx4GEwlow3v6rr4mCcv6prnfwhS01rkgyFdjPNBYd9br7LpXV1+Emh01fHnq2Gdgrw==} + + trim-newlines@3.0.1: + resolution: {integrity: sha512-c1PTsA3tYrIsLGkJkzHF+w9F2EyxfXGo4UyJc4pFL++FMjnq0HJS69T3M7d//gKrFKwy429bouPescbjecU+Zw==} + engines: {node: '>=8'} + + truffle-blockchain-utils@0.0.5: + resolution: {integrity: sha512-eCCV8FbYOuKagRY5NiqJCZrrh9GjWX2573ahqZPvUrzxYGIvCpSsHpGCub2e00YefpMfBqwscbsDTK7WNVfwoA==} + deprecated: 'WARNING: This package has been renamed to @truffle/blockchain-utils.' + + truffle-contract-schema@2.0.3: + resolution: {integrity: sha512-eI5cFifbB3zpcO4RsXSnjN9JMSlJ4M50GQPdrfbrIXRTXHsyQ433SkgFjIATUwfq++TXWkCRfKMjN8eA7YQ3+Q==} + deprecated: 'WARNING: This package has been renamed to @truffle/contract-schema.' + + truffle-contract@3.0.8: + resolution: {integrity: sha512-uhXb/G4dORU4RjFlwZZbFT0n5BS8akify+MaRsnWWs4SA/bo6x4/bQs1xtdO3b5Cl9nXiOX88wdQzRj3xtPVUg==} + deprecated: 'WARNING: This package has been renamed to @truffle/contract.' + + truffle-error@0.0.3: + resolution: {integrity: sha512-9gxs1z6BUn7MqrE4NPm/jcYe8rLok3Z57aweGIh1+CoRJSttzYqwcXCqaPRSNrTFnsTeZMBukkYr/PUcADoihw==} + deprecated: 'WARNING: This package has been renamed to @truffle/error.' + + ts-command-line-args@2.5.1: + resolution: {integrity: sha512-H69ZwTw3rFHb5WYpQya40YAX2/w7Ut75uUECbgBIsLmM+BNuYnxsltfyyLMxy6sEeKxgijLTnQtLd0nKd6+IYw==} + hasBin: true + + ts-essentials@7.0.3: + resolution: {integrity: sha512-8+gr5+lqO3G84KdiTSMRLtuyJ+nTBVRKuCrK4lidMPdVeEp0uqC875uE5NMcaA7YYMN7XsNiFQuMvasF8HT/xQ==} + peerDependencies: + typescript: '>=3.7.0' + + ts-node@10.9.2: + resolution: {integrity: sha512-f0FFpIdcHgn8zcPSbf1dRevwt047YMnaiJM3u2w2RewrB+fob/zePZcrOyQoLMMO7aBIddLcQIEK5dYjkLnGrQ==} + hasBin: true + peerDependencies: + '@swc/core': '>=1.2.50' + '@swc/wasm': '>=1.2.50' + '@types/node': '*' + typescript: '>=2.7' + peerDependenciesMeta: + '@swc/core': + optional: true + '@swc/wasm': + optional: true + + tsconfig-paths@3.15.0: + resolution: {integrity: sha512-2Ac2RgzDe/cn48GvOe3M+o82pEFewD3UPbyoUHHdKasHwJKjds4fLXWf/Ux5kATBKN20oaFGu+jbElp1pos0mg==} + + tslib@1.14.1: + resolution: {integrity: sha512-Xni35NKzjgMrwevysHTCArtLDpPvye8zV/0E4EyYn43P7/7qvQwPh9BGkHewbMulVntbigmcT7rdX3BNo9wRJg==} + + tslib@2.4.0: + resolution: {integrity: sha512-d6xOpEDfsi2CZVlPQzGeux8XMwLT9hssAsaPYExaQMuYskwb+x1x7J371tWlbBdWHroy99KnVB6qIkUbs5X3UQ==} + + tslib@2.6.2: + resolution: {integrity: sha512-AEYxH93jGFPn/a2iVAwW87VuUIkR1FVUKB77NwMF7nBTDkDrrT/Hpt/IrCJ0QXhW27jTBDcf5ZY7w6RiqTMw2Q==} + + tsort@0.0.1: + resolution: {integrity: sha512-Tyrf5mxF8Ofs1tNoxA13lFeZ2Zrbd6cKbuH3V+MQ5sb6DtBj5FjrXVsRWT8YvNAQTqNoz66dz1WsbigI22aEnw==} + + tsutils@3.21.0: + resolution: {integrity: sha512-mHKK3iUXL+3UF6xL5k0PEhKRUBKPBCv/+RkEOpjRWxxx27KKRBmmA60A9pgOUvMi8GKhRMPEmjBRPzs2W7O1OA==} + engines: {node: '>= 6'} + peerDependencies: + typescript: '>=2.8.0 || >= 3.2.0-dev || >= 3.3.0-dev || >= 3.4.0-dev || >= 3.5.0-dev || >= 3.6.0-dev || >= 3.6.0-beta || >= 3.7.0-dev || >= 3.7.0-beta' + + tty-table@4.2.3: + resolution: {integrity: sha512-Fs15mu0vGzCrj8fmJNP7Ynxt5J7praPXqFN0leZeZBXJwkMxv9cb2D454k1ltrtUSJbZ4yH4e0CynsHLxmUfFA==} + engines: {node: '>=8.0.0'} + hasBin: true + + tunnel-agent@0.6.0: + resolution: {integrity: sha512-McnNiV1l8RYeY8tBgEpuodCC1mLUdbSN+CYBL7kJsJNInOP8UjDDEwdk6Mw60vdLLrr5NHKZhMAOSrR2NZuQ+w==} + + tweetnacl-util@0.15.1: + resolution: {integrity: sha512-RKJBIj8lySrShN4w6i/BonWp2Z/uxwC3h4y7xsRrpP59ZboCd0GpEVsOnMDYLMmKBpYhb5TgHzZXy7wTfYFBRw==} + + tweetnacl@0.14.5: + resolution: {integrity: sha512-KXXFFdAbFXY4geFIwoyNK+f5Z1b7swfXABfL7HXCmoIWMKU3dmS26672A4EeQtDzLKy7SXmfBu51JolvEKwtGA==} + + tweetnacl@1.0.3: + resolution: {integrity: sha512-6rt+RN7aOi1nGMyC4Xa5DdYiukl2UWCbcJft7YhxReBGQD7OAM8Pbxw6YMo4r2diNEA8FEmu32YOn9rhaiE5yw==} + + type-check@0.3.2: + resolution: {integrity: sha512-ZCmOJdvOWDBYJlzAoFkC+Q0+bUyEOS1ltgp1MGU03fqHG+dbi9tBFU2Rd9QKiDZFAYrhPh2JUf7rZRIuHRKtOg==} + engines: {node: '>= 0.8.0'} + + type-check@0.4.0: + resolution: {integrity: sha512-XleUoc9uwGXqjWwXaUTZAmzMcFZ5858QA2vvx1Ur5xIcixXIP+8LnFDgRplU30us6teqdlskFfu+ae4K79Ooew==} + engines: {node: '>= 0.8.0'} + + type-detect@4.0.8: + resolution: {integrity: sha512-0fr/mIH1dlO+x7TlcMy+bIDqKPsw/70tVyeHW787goQjhmqaZe10uwLujubK9q9Lg6Fiho1KUKDYz0Z7k7g5/g==} + engines: {node: '>=4'} + + type-fest@0.13.1: + resolution: {integrity: sha512-34R7HTnG0XIJcBSn5XhDd7nNFPRcXYRZrBB2O2jdKqYODldSzBAqzsWoZYYvduky73toYS/ESqxPvkDf/F0XMg==} + engines: {node: '>=10'} + + type-fest@0.20.2: + resolution: {integrity: sha512-Ne+eE4r0/iWnpAxD852z3A+N0Bt5RN//NjJwRd2VFHEmrywxf5vsZlh4R6lixl6B+wz/8d+maTSAkN1FIkI3LQ==} + engines: {node: '>=10'} + + type-fest@0.21.3: + resolution: {integrity: sha512-t0rzBq87m3fVcduHDUFhKmyyX+9eo6WQjZvf51Ea/M0Q7+T374Jp1aUiyUl0GKxp8M/OETVHSDvmkyPgvX+X2w==} + engines: {node: '>=10'} + + type-fest@0.6.0: + resolution: {integrity: sha512-q+MB8nYR1KDLrgr4G5yemftpMC7/QLqVndBmEEdqzmNj5dcFOO4Oo8qlwZE3ULT3+Zim1F8Kq4cBnikNhlCMlg==} + engines: {node: '>=8'} + + type-fest@0.7.1: + resolution: {integrity: sha512-Ne2YiiGN8bmrmJJEuTWTLJR32nh/JdL1+PSicowtNb0WFpn59GK8/lfD61bVtzguz7b3PBt74nxpv/Pw5po5Rg==} + engines: {node: '>=8'} + + type-fest@0.8.1: + resolution: {integrity: sha512-4dbzIzqvjtgiM5rw1k5rEHtBANKmdudhGyBEajN01fEyhaAIhsoKNy6y7+IN93IfpFtwY9iqi7kD+xwKhQsNJA==} + engines: {node: '>=8'} + + type-fest@2.19.0: + resolution: {integrity: sha512-RAH822pAdBgcNMAfWnCBU3CFZcfZ/i1eZjwFU/dsLKumyuuP3niueg2UAukXYF0E2AAoc82ZSSf9J0WQBinzHA==} + engines: {node: '>=12.20'} + + type-fest@3.13.1: + resolution: {integrity: sha512-tLq3bSNx+xSpwvAJnzrK0Ep5CLNWjvFTOp71URMaAEWBfRb9nnJiBoUe0tF8bI4ZFO3omgBR6NvnbzVUT3Ly4g==} + engines: {node: '>=14.16'} + + type-is@1.6.18: + resolution: {integrity: sha512-TkRKr9sUTxEH8MdfuCSP7VizJyzRNMjj2J2do2Jr3Kym598JVdEksuzPQCnlFPW4ky9Q+iA+ma9BGm06XQBy8g==} + engines: {node: '>= 0.6'} + + type@2.7.2: + resolution: {integrity: sha512-dzlvlNlt6AXU7EBSfpAscydQ7gXB+pPGsPnfJnZpiNJBDj7IaJzQlBZYGdEi4R9HmPdBv2XmWJ6YUtoTa7lmCw==} + + typechain@8.3.2: + resolution: {integrity: sha512-x/sQYr5w9K7yv3es7jo4KTX05CLxOf7TRWwoHlrjRh8H82G64g+k7VuWPJlgMo6qrjfCulOdfBjiaDtmhFYD/Q==} + hasBin: true + peerDependencies: + typescript: '>=4.3.0' + + typed-array-buffer@1.0.2: + resolution: {integrity: sha512-gEymJYKZtKXzzBzM4jqa9w6Q1Jjm7x2d+sh19AdsD4wqnMPDYyvwpsIc2Q/835kHuo3BEQ7CjelGhfTsoBb2MQ==} + engines: {node: '>= 0.4'} + + typed-array-byte-length@1.0.1: + resolution: {integrity: sha512-3iMJ9q0ao7WE9tWcaYKIptkNBuOIcZCCT0d4MRvuuH88fEoEH62IuQe0OtraD3ebQEoTRk8XCBoknUNc1Y67pw==} + engines: {node: '>= 0.4'} + + typed-array-byte-offset@1.0.2: + resolution: {integrity: sha512-Ous0vodHa56FviZucS2E63zkgtgrACj7omjwd/8lTEMEPFFyjfixMZ1ZXenpgCFBBt4EC1J2XsyVS2gkG0eTFA==} + engines: {node: '>= 0.4'} + + typed-array-length@1.0.6: + resolution: {integrity: sha512-/OxDN6OtAk5KBpGb28T+HZc2M+ADtvRxXrKKbUwtsLgdoxgX13hyy7ek6bFRl5+aBs2yZzB0c4CnQfAtVypW/g==} + engines: {node: '>= 0.4'} + + typedarray-to-buffer@3.1.5: + resolution: {integrity: sha512-zdu8XMNEDepKKR+XYOXAVPtWui0ly0NtohUscw+UmaHiAWT8hrV1rr//H6V+0DvJ3OQ19S979M0laLfX8rm82Q==} + + typedarray@0.0.6: + resolution: {integrity: sha512-/aCDEGatGvZ2BIk+HmLf4ifCJFwvKFNb9/JeZPMulfgFracn9QFcAf5GO8B/mweUjSoblS5In0cWhqpfs/5PQA==} + + typescript@5.0.4: + resolution: {integrity: sha512-cW9T5W9xY37cc+jfEnaUvX91foxtHkza3Nw3wkoF4sSlKn0MONdkdEndig/qPBWXNkmplh3NzayQzCiHM4/hqw==} + engines: {node: '>=12.20'} + hasBin: true + + typical@4.0.0: + resolution: {integrity: sha512-VAH4IvQ7BDFYglMd7BPRDfLgxZZX4O4TFcRDA6EN5X7erNJJq+McIEp8np9aVtxrCJ6qx4GTYVfOWNjcqwZgRw==} + engines: {node: '>=8'} + + typical@5.2.0: + resolution: {integrity: sha512-dvdQgNDNJo+8B2uBQoqdb11eUCE1JQXhvjC/CZtgvZseVd5TYMXnq0+vuUemXbd/Se29cTaUuPX3YIc2xgbvIg==} + engines: {node: '>=8'} + + uglify-js@3.17.4: + resolution: {integrity: sha512-T9q82TJI9e/C1TAxYvfb16xO120tMVFZrGA3f9/P4424DNu6ypK103y0GPFVa17yotwSyZW5iYXgjYHkGrJW/g==} + engines: {node: '>=0.8.0'} + hasBin: true + + ultron@1.1.1: + resolution: {integrity: sha512-UIEXBNeYmKptWH6z8ZnqTeS8fV74zG0/eRU9VGkpzz+LIJNs8W/zM/L+7ctCkRrgbNnnR0xxw4bKOr0cW0N0Og==} + + unbox-primitive@1.0.2: + resolution: {integrity: sha512-61pPlCD9h51VoreyJ0BReideM3MDKMKnh6+V9L08331ipq6Q8OFXZYiqP6n/tbHx4s5I9uRhcye6BrbkizkBDw==} + + underscore@1.13.6: + resolution: {integrity: sha512-+A5Sja4HP1M08MaXya7p5LvjuM7K6q/2EaC0+iovj/wOcMsTzMvDFbasi/oSapiwOlt252IqsKqPjCl7huKS0A==} + + undici-types@5.26.5: + resolution: {integrity: sha512-JlCMO+ehdEIKqlFxk6IfVoAUVmgz7cU7zD/h9XZ0qzeosSHmUJVOzSQvvYSYWXkFXC+IfLKSIffhv0sVZup6pA==} + + undici@5.28.4: + resolution: {integrity: sha512-72RFADWFqKmUb2hmmvNODKL3p9hcB6Gt2DOQMis1SEBaV6a4MH8soBvzg+95CYhCKPFedut2JY9bMfrDl9D23g==} + engines: {node: '>=14.0'} + + universalify@0.1.2: + resolution: {integrity: sha512-rBJeI5CXAlmy1pV+617WB9J63U6XcazHHF2f2dbJix4XzpUF0RS3Zbj0FGIOCAva5P/d/GBOYaACQ1w+0azUkg==} + engines: {node: '>= 4.0.0'} + + universalify@2.0.1: + resolution: {integrity: sha512-gptHNQghINnc/vTGIk0SOFGFNXw7JVrlRUtConJRlvaw6DuX0wO5Jeko9sWrMBhh+PsYAZ7oXAiOnf/UKogyiw==} + engines: {node: '>= 10.0.0'} + + unpipe@1.0.0: + resolution: {integrity: sha512-pjy2bYhSsufwWlKwPc+l3cN7+wuJlK6uz0YdJEOlQDbl6jo/YlPi4mb8agUkVC8BF7V8NuzeyPNqRksA3hztKQ==} + engines: {node: '>= 0.8'} + + untildify@4.0.0: + resolution: {integrity: sha512-KK8xQ1mkzZeg9inewmFVDNkg3l5LUhoq9kN6iWYB/CC9YMG8HA+c1Q8HwDe6dEX7kErrEVNVBO3fWsVq5iDgtw==} + engines: {node: '>=8'} + + update-browserslist-db@1.0.15: + resolution: {integrity: sha512-K9HWH62x3/EalU1U6sjSZiylm9C8tgq2mSvshZpqc7QE69RaA2qjhkW2HlNA0tFpEbtyFz7HTqbSdN4MSwUodA==} + hasBin: true + peerDependencies: + browserslist: '>= 4.21.0' + + upper-case-first@1.1.2: + resolution: {integrity: sha512-wINKYvI3Db8dtjikdAqoBbZoP6Q+PZUyfMR7pmwHzjC2quzSkUq5DmPrTtPEqHaz8AGtmsB4TqwapMTM1QAQOQ==} + + upper-case@1.1.3: + resolution: {integrity: sha512-WRbjgmYzgXkCV7zNVpy5YgrHgbBv126rMALQQMrmzOVC4GM2waQ9x7xtm8VU+1yF2kWyPzI9zbZ48n4vSxwfSA==} + + uri-js@4.4.1: + resolution: {integrity: sha512-7rKUyy33Q1yc98pQ1DAmLtwX109F7TIfWlW1Ydo8Wl1ii1SeHieeh0HHfPeL2fMXK6z0s8ecKs9frCuLJvndBg==} + + url-set-query@1.0.0: + resolution: {integrity: sha512-3AChu4NiXquPfeckE5R5cGdiHCMWJx1dwCWOmWIL4KHAziJNOFIYJlpGFeKDvwLPHovZRCxK3cYlwzqI9Vp+Gg==} + + usb@2.9.0: + resolution: {integrity: sha512-G0I/fPgfHUzWH8xo2KkDxTTFruUWfppgSFJ+bQxz/kVY2x15EQ/XDB7dqD1G432G4gBG4jYQuF3U7j/orSs5nw==} + engines: {node: '>=10.20.0 <11.x || >=12.17.0 <13.0 || >=14.0.0'} + + utf-8-validate@5.0.10: + resolution: {integrity: sha512-Z6czzLq4u8fPOyx7TU6X3dvUZVvoJmxSQ+IcrlmagKhilxlhZgxPK6C5Jqbkw1IDUmFTM+cz9QDnnLTwDz/2gQ==} + engines: {node: '>=6.14.2'} + + utf8@2.1.2: + resolution: {integrity: sha512-QXo+O/QkLP/x1nyi54uQiG0XrODxdysuQvE5dtVqv7F5K2Qb6FsN+qbr6KhF5wQ20tfcV3VQp0/2x1e1MRSPWg==} + + utf8@3.0.0: + resolution: {integrity: sha512-E8VjFIQ/TyQgp+TZfS6l8yp/xWppSAHzidGiRrqe4bK4XP9pTRyKFgGJpO3SN7zdX4DeomTrwaseCHovfpFcqQ==} + + util-deprecate@1.0.2: + resolution: {integrity: sha512-EPD5q1uXyFxJpCrLnCc1nHnq3gOa6DZBocAIiI2TaSCA7VCJ1UJDMagCzIkXNsUYfD1daK//LTEQ8xiIbrHtcw==} + + util@0.12.5: + resolution: {integrity: sha512-kZf/K6hEIrWHI6XqOFUiiMa+79wE/D8Q+NCNAWclkyg3b4d2k7s0QGepNjiABc+aR3N1PAyHL7p6UcLY6LmrnA==} + + utils-merge@1.0.1: + resolution: {integrity: sha512-pMZTvIkT1d+TFGvDOqodOclx0QWkkgi6Tdoa8gC8ffGAAqz9pzPTZWAybbsHHoED/ztMtkv/VoYTYyShUn81hA==} + engines: {node: '>= 0.4.0'} + + uuid@2.0.1: + resolution: {integrity: sha512-nWg9+Oa3qD2CQzHIP4qKUqwNfzKn8P0LtFhotaCTFchsV7ZfDhAybeip/HZVeMIpZi9JgY1E3nUlwaCmZT1sEg==} + deprecated: Please upgrade to version 7 or higher. Older versions may use Math.random() in certain circumstances, which is known to be problematic. See https://v8.dev/blog/math-random for details. + + uuid@3.4.0: + resolution: {integrity: sha512-HjSDRw6gZE5JMggctHBcjVak08+KEVhSIiDzFnT9S9aegmp85S/bReBVTb4QTFaRNptJ9kuYaNhnbNEOkbKb/A==} + deprecated: Please upgrade to version 7 or higher. Older versions may use Math.random() in certain circumstances, which is known to be problematic. See https://v8.dev/blog/math-random for details. + hasBin: true + + uuid@8.3.2: + resolution: {integrity: sha512-+NYs2QeMWy+GWFOEm9xnn6HCDp0l7QBD7ml8zLUmJ+93Q5NF0NocErnwkTkXVFNiX3/fpC6afS8Dhb/gz7R7eg==} + hasBin: true + + uuid@9.0.1: + resolution: {integrity: sha512-b+1eJOlsR9K8HJpow9Ok3fiWOWSIcIzXodvv0rQjVoOVNpWMpxf1wZNpt4y9h10odCNrqnYp1OBzRktckBe3sA==} + hasBin: true + + v8-compile-cache-lib@3.0.1: + resolution: {integrity: sha512-wa7YjyUGfNZngI/vtK0UHAN+lgDCxBPCylVXGp0zu59Fz5aiGtNXaq3DhIov063MorB+VfufLh3JlF2KdTK3xg==} + + validate-npm-package-license@3.0.4: + resolution: {integrity: sha512-DpKm2Ui/xN7/HQKCtpZxoRWBhZ9Z0kqtygG8XCgNQ8ZlDnxuQmWhj566j8fN4Cu3/JmbhsDo7fcAJq4s9h27Ew==} + + varint@5.0.2: + resolution: {integrity: sha512-lKxKYG6H03yCZUpAGOPOsMcGxd1RHCu1iKvEHYDPmTyq2HueGhD73ssNBqqQWfvYs04G9iUFRvmAVLW20Jw6ow==} + + vary@1.1.2: + resolution: {integrity: sha512-BNGbWLfd0eUPabhkXUVm0j8uuvREyTh5ovRa/dyow/BqAbZJyC+5fU+IzQOzmAKzYqYRAISoRhdQr3eIZ/PXqg==} + engines: {node: '>= 0.8'} + + verror@1.10.0: + resolution: {integrity: sha512-ZZKSmDAEFOijERBLkmYfJ+vmk3w+7hOLYDNkRCuRuMJGEmqYNCNLyBBFwWKVMhfwaEF3WOd0Zlw86U/WC/+nYw==} + engines: {'0': node >=0.6.0} + + viem@2.10.3: + resolution: {integrity: sha512-GmPMH+D/SDSXpVSjLM0GN1H1/h4NUPHaIqnFLwAit8nkfCiDuajKflGFiMPCIs1h7QZlBICuKvON/rc09H+w6Q==} + peerDependencies: + typescript: '>=5.0.4' + peerDependenciesMeta: + typescript: + optional: true + + wcwidth@1.0.1: + resolution: {integrity: sha512-XHPEwS0q6TaxcvG85+8EYkbiCux2XtWG2mkc47Ng2A77BQu9+DqIOJldST4HgPkuea7dvKSj5VgX3P1d4rW8Tg==} + + web3-bzz@1.10.0: + resolution: {integrity: sha512-o9IR59io3pDUsXTsps5pO5hW1D5zBmg46iNc2t4j2DkaYHNdDLwk2IP9ukoM2wg47QILfPEJYzhTfkS/CcX0KA==} + engines: {node: '>=8.0.0'} + + web3-bzz@1.10.4: + resolution: {integrity: sha512-ZZ/X4sJ0Uh2teU9lAGNS8EjveEppoHNQiKlOXAjedsrdWuaMErBPdLQjXfcrYvN6WM6Su9PMsAxf3FXXZ+HwQw==} + engines: {node: '>=8.0.0'} + + web3-core-helpers@1.10.0: + resolution: {integrity: sha512-pIxAzFDS5vnbXvfvLSpaA1tfRykAe9adw43YCKsEYQwH0gCLL0kMLkaCX3q+Q8EVmAh+e1jWL/nl9U0de1+++g==} + engines: {node: '>=8.0.0'} + + web3-core-helpers@1.10.4: + resolution: {integrity: sha512-r+L5ylA17JlD1vwS8rjhWr0qg7zVoVMDvWhajWA5r5+USdh91jRUYosp19Kd1m2vE034v7Dfqe1xYRoH2zvG0g==} + engines: {node: '>=8.0.0'} + + web3-core-method@1.10.0: + resolution: {integrity: sha512-4R700jTLAMKDMhQ+nsVfIXvH6IGJlJzGisIfMKWAIswH31h5AZz7uDUW2YctI+HrYd+5uOAlS4OJeeT9bIpvkA==} + engines: {node: '>=8.0.0'} + + web3-core-method@1.10.4: + resolution: {integrity: sha512-uZTb7flr+Xl6LaDsyTeE2L1TylokCJwTDrIVfIfnrGmnwLc6bmTWCCrm71sSrQ0hqs6vp/MKbQYIYqUN0J8WyA==} + engines: {node: '>=8.0.0'} + + web3-core-promievent@1.10.0: + resolution: {integrity: sha512-68N7k5LWL5R38xRaKFrTFT2pm2jBNFaM4GioS00YjAKXRQ3KjmhijOMG3TICz6Aa5+6GDWYelDNx21YAeZ4YTg==} + engines: {node: '>=8.0.0'} + + web3-core-promievent@1.10.4: + resolution: {integrity: sha512-2de5WnJQ72YcIhYwV/jHLc4/cWJnznuoGTJGD29ncFQHAfwW/MItHFSVKPPA5v8AhJe+r6y4Y12EKvZKjQVBvQ==} + engines: {node: '>=8.0.0'} + + web3-core-requestmanager@1.10.0: + resolution: {integrity: sha512-3z/JKE++Os62APml4dvBM+GAuId4h3L9ckUrj7ebEtS2AR0ixyQPbrBodgL91Sv7j7cQ3Y+hllaluqjguxvSaQ==} + engines: {node: '>=8.0.0'} + + web3-core-requestmanager@1.10.4: + resolution: {integrity: sha512-vqP6pKH8RrhT/2MoaU+DY/OsYK9h7HmEBNCdoMj+4ZwujQtw/Mq2JifjwsJ7gits7Q+HWJwx8q6WmQoVZAWugg==} + engines: {node: '>=8.0.0'} + + web3-core-subscriptions@1.10.0: + resolution: {integrity: sha512-HGm1PbDqsxejI075gxBc5OSkwymilRWZufIy9zEpnWKNmfbuv5FfHgW1/chtJP6aP3Uq2vHkvTDl3smQBb8l+g==} + engines: {node: '>=8.0.0'} + + web3-core-subscriptions@1.10.4: + resolution: {integrity: sha512-o0lSQo/N/f7/L76C0HV63+S54loXiE9fUPfHFcTtpJRQNDBVsSDdWRdePbWwR206XlsBqD5VHApck1//jEafTw==} + engines: {node: '>=8.0.0'} + + web3-core@1.10.0: + resolution: {integrity: sha512-fWySwqy2hn3TL89w5TM8wXF1Z2Q6frQTKHWmP0ppRQorEK8NcHJRfeMiv/mQlSKoTS1F6n/nv2uyZsixFycjYQ==} + engines: {node: '>=8.0.0'} + + web3-core@1.10.4: + resolution: {integrity: sha512-B6elffYm81MYZDTrat7aEhnhdtVE3lDBUZft16Z8awYMZYJDbnykEbJVS+l3mnA7AQTnSDr/1MjWofGDLBJPww==} + engines: {node: '>=8.0.0'} + + web3-core@4.3.2: + resolution: {integrity: sha512-uIMVd/j4BgOnwfpY8ZT+QKubOyM4xohEhFZXz9xB8wimXWMMlYVlIK/TbfHqFolS9uOerdSGhsMbcK9lETae8g==} + engines: {node: '>=14', npm: '>=6.12.0'} + + web3-errors@1.1.4: + resolution: {integrity: sha512-WahtszSqILez+83AxGecVroyZsMuuRT+KmQp4Si5P4Rnqbczno1k748PCrZTS1J4UCPmXMG2/Vt+0Bz2zwXkwQ==} + engines: {node: '>=14', npm: '>=6.12.0'} + + web3-eth-abi@1.10.0: + resolution: {integrity: sha512-cwS+qRBWpJ43aI9L3JS88QYPfFcSJJ3XapxOQ4j40v6mk7ATpA8CVK1vGTzpihNlOfMVRBkR95oAj7oL6aiDOg==} + engines: {node: '>=8.0.0'} + + web3-eth-abi@1.10.4: + resolution: {integrity: sha512-cZ0q65eJIkd/jyOlQPDjr8X4fU6CRL1eWgdLwbWEpo++MPU/2P4PFk5ZLAdye9T5Sdp+MomePPJ/gHjLMj2VfQ==} + engines: {node: '>=8.0.0'} + + web3-eth-abi@4.2.1: + resolution: {integrity: sha512-IE91WUhhiDpBtbkl/DHUoZz7z7T5FXvl3zPLkrxT+dNlOT+wni+US/67jQCLvJRbqf9ApQ26lVYry0bovFgyqA==} + engines: {node: '>=14', npm: '>=6.12.0'} + + web3-eth-accounts@1.10.0: + resolution: {integrity: sha512-wiq39Uc3mOI8rw24wE2n15hboLE0E9BsQLdlmsL4Zua9diDS6B5abXG0XhFcoNsXIGMWXVZz4TOq3u4EdpXF/Q==} + engines: {node: '>=8.0.0'} + + web3-eth-accounts@1.10.4: + resolution: {integrity: sha512-ysy5sVTg9snYS7tJjxVoQAH6DTOTkRGR8emEVCWNGLGiB9txj+qDvSeT0izjurS/g7D5xlMAgrEHLK1Vi6I3yg==} + engines: {node: '>=8.0.0'} + + web3-eth-accounts@4.1.2: + resolution: {integrity: sha512-y0JynDeTDnclyuE9mShXLeEj+BCrPHxPHOyPCgTchUBQsALF9+0OhP7WiS3IqUuu0Hle5bjG2f5ddeiPtNEuLg==} + engines: {node: '>=14', npm: '>=6.12.0'} + + web3-eth-contract@1.10.0: + resolution: {integrity: sha512-MIC5FOzP/+2evDksQQ/dpcXhSqa/2hFNytdl/x61IeWxhh6vlFeSjq0YVTAyIzdjwnL7nEmZpjfI6y6/Ufhy7w==} + engines: {node: '>=8.0.0'} + + web3-eth-contract@1.10.4: + resolution: {integrity: sha512-Q8PfolOJ4eV9TvnTj1TGdZ4RarpSLmHnUnzVxZ/6/NiTfe4maJz99R0ISgwZkntLhLRtw0C7LRJuklzGYCNN3A==} + engines: {node: '>=8.0.0'} + + web3-eth-contract@4.4.0: + resolution: {integrity: sha512-pZ/w6Lb6ZDUUs7f5GCKXiHDAGGvt2tdwiHkvgmQTRnq9b0MEsUpteDyPYspHxKzQWLgbeK37jPb8zbQe4kE/Hg==} + engines: {node: '>=14', npm: '>=6.12.0'} + + web3-eth-ens@1.10.0: + resolution: {integrity: sha512-3hpGgzX3qjgxNAmqdrC2YUQMTfnZbs4GeLEmy8aCWziVwogbuqQZ+Gzdfrym45eOZodk+lmXyLuAdqkNlvkc1g==} + engines: {node: '>=8.0.0'} + + web3-eth-ens@1.10.4: + resolution: {integrity: sha512-LLrvxuFeVooRVZ9e5T6OWKVflHPFgrVjJ/jtisRWcmI7KN/b64+D/wJzXqgmp6CNsMQcE7rpmf4CQmJCrTdsgg==} + engines: {node: '>=8.0.0'} + + web3-eth-ens@4.2.0: + resolution: {integrity: sha512-qYj34te2UctoObt8rlEIY/t2MuTMiMiiHhO2JAHRGqSLCQ7b8DM3RpvkiiSB0N0ZyEn+CetZqJCTYb8DNKBS/g==} + engines: {node: '>=14', npm: '>=6.12.0'} + + web3-eth-iban@1.10.0: + resolution: {integrity: sha512-0l+SP3IGhInw7Q20LY3IVafYEuufo4Dn75jAHT7c2aDJsIolvf2Lc6ugHkBajlwUneGfbRQs/ccYPQ9JeMUbrg==} + engines: {node: '>=8.0.0'} + + web3-eth-iban@1.10.4: + resolution: {integrity: sha512-0gE5iNmOkmtBmbKH2aTodeompnNE8jEyvwFJ6s/AF6jkw9ky9Op9cqfzS56AYAbrqEFuClsqB/AoRves7LDELw==} + engines: {node: '>=8.0.0'} + + web3-eth-iban@4.0.7: + resolution: {integrity: sha512-8weKLa9KuKRzibC87vNLdkinpUE30gn0IGY027F8doeJdcPUfsa4IlBgNC4k4HLBembBB2CTU0Kr/HAOqMeYVQ==} + engines: {node: '>=14', npm: '>=6.12.0'} + + web3-eth-personal@1.10.0: + resolution: {integrity: sha512-anseKn98w/d703eWq52uNuZi7GhQeVjTC5/svrBWEKob0WZ5kPdo+EZoFN0sp5a5ubbrk/E0xSl1/M5yORMtpg==} + engines: {node: '>=8.0.0'} + + web3-eth-personal@1.10.4: + resolution: {integrity: sha512-BRa/hs6jU1hKHz+AC/YkM71RP3f0Yci1dPk4paOic53R4ZZG4MgwKRkJhgt3/GPuPliwS46f/i5A7fEGBT4F9w==} + engines: {node: '>=8.0.0'} + + web3-eth-personal@4.0.8: + resolution: {integrity: sha512-sXeyLKJ7ddQdMxz1BZkAwImjqh7OmKxhXoBNF3isDmD4QDpMIwv/t237S3q4Z0sZQamPa/pHebJRWVuvP8jZdw==} + engines: {node: '>=14', npm: '>=6.12.0'} + + web3-eth@1.10.0: + resolution: {integrity: sha512-Z5vT6slNMLPKuwRyKGbqeGYC87OAy8bOblaqRTgg94CXcn/mmqU7iPIlG4506YdcdK3x6cfEDG7B6w+jRxypKA==} + engines: {node: '>=8.0.0'} + + web3-eth@1.10.4: + resolution: {integrity: sha512-Sql2kYKmgt+T/cgvg7b9ce24uLS7xbFrxE4kuuor1zSCGrjhTJ5rRNG8gTJUkAJGKJc7KgnWmgW+cOfMBPUDSA==} + engines: {node: '>=8.0.0'} + + web3-eth@4.6.0: + resolution: {integrity: sha512-8KtxlGsomovoFULqEpfixgmCpaJ2YIJGxbXUfezh2coXHjVgEopQhARYtKGClyV5kkdCIqwHS8Gvsm6TVNqH6Q==} + engines: {node: '>=14', npm: '>=6.12.0'} + + web3-net@1.10.0: + resolution: {integrity: sha512-NLH/N3IshYWASpxk4/18Ge6n60GEvWBVeM8inx2dmZJVmRI6SJIlUxbL8jySgiTn3MMZlhbdvrGo8fpUW7a1GA==} + engines: {node: '>=8.0.0'} + + web3-net@1.10.4: + resolution: {integrity: sha512-mKINnhOOnZ4koA+yV2OT5s5ztVjIx7IY9a03w6s+yao/BUn+Luuty0/keNemZxTr1E8Ehvtn28vbOtW7Ids+Ow==} + engines: {node: '>=8.0.0'} + + web3-net@4.0.7: + resolution: {integrity: sha512-SzEaXFrBjY25iQGk5myaOfO9ZyfTwQEa4l4Ps4HDNVMibgZji3WPzpjq8zomVHMwi8bRp6VV7YS71eEsX7zLow==} + engines: {node: '>=14', npm: '>=6.12.0'} + + web3-providers-http@1.10.0: + resolution: {integrity: sha512-eNr965YB8a9mLiNrkjAWNAPXgmQWfpBfkkn7tpEFlghfww0u3I0tktMZiaToJVcL2+Xq+81cxbkpeWJ5XQDwOA==} + engines: {node: '>=8.0.0'} + + web3-providers-http@1.10.4: + resolution: {integrity: sha512-m2P5Idc8hdiO0l60O6DSCPw0kw64Zgi0pMjbEFRmxKIck2Py57RQMu4bxvkxJwkF06SlGaEQF8rFZBmuX7aagQ==} + engines: {node: '>=8.0.0'} + + web3-providers-http@4.1.0: + resolution: {integrity: sha512-6qRUGAhJfVQM41E5t+re5IHYmb5hSaLc02BE2MaRQsz2xKA6RjmHpOA5h/+ojJxEpI9NI2CrfDKOAgtJfoUJQg==} + engines: {node: '>=14', npm: '>=6.12.0'} + + web3-providers-ipc@1.10.0: + resolution: {integrity: sha512-OfXG1aWN8L1OUqppshzq8YISkWrYHaATW9H8eh0p89TlWMc1KZOL9vttBuaBEi96D/n0eYDn2trzt22bqHWfXA==} + engines: {node: '>=8.0.0'} + + web3-providers-ipc@1.10.4: + resolution: {integrity: sha512-YRF/bpQk9z3WwjT+A6FI/GmWRCASgd+gC0si7f9zbBWLXjwzYAKG73bQBaFRAHex1hl4CVcM5WUMaQXf3Opeuw==} + engines: {node: '>=8.0.0'} + + web3-providers-ipc@4.0.7: + resolution: {integrity: sha512-YbNqY4zUvIaK2MHr1lQFE53/8t/ejHtJchrWn9zVbFMGXlTsOAbNoIoZWROrg1v+hCBvT2c9z8xt7e/+uz5p1g==} + engines: {node: '>=14', npm: '>=6.12.0'} + + web3-providers-ws@1.10.0: + resolution: {integrity: sha512-sK0fNcglW36yD5xjnjtSGBnEtf59cbw4vZzJ+CmOWIKGIR96mP5l684g0WD0Eo+f4NQc2anWWXG74lRc9OVMCQ==} + engines: {node: '>=8.0.0'} + + web3-providers-ws@1.10.4: + resolution: {integrity: sha512-j3FBMifyuFFmUIPVQR4pj+t5ILhAexAui0opgcpu9R5LxQrLRUZxHSnU+YO25UycSOa/NAX8A+qkqZNpcFAlxA==} + engines: {node: '>=8.0.0'} + + web3-providers-ws@4.0.7: + resolution: {integrity: sha512-n4Dal9/rQWjS7d6LjyEPM2R458V8blRm0eLJupDEJOOIBhGYlxw5/4FthZZ/cqB7y/sLVi7K09DdYx2MeRtU5w==} + engines: {node: '>=14', npm: '>=6.12.0'} + + web3-rpc-methods@1.2.0: + resolution: {integrity: sha512-CWJ/g4I4WyYvLkf21wCZAehdhU/VjX/OAPHnqF5/FPDJlogOsOnGXHqi1Z5AP+ocdt395PNubd8jyMMJoYGSBA==} + engines: {node: '>=14', npm: '>=6.12.0'} + + web3-shh@1.10.0: + resolution: {integrity: sha512-uNUUuNsO2AjX41GJARV9zJibs11eq6HtOe6Wr0FtRUcj8SN6nHeYIzwstAvJ4fXA53gRqFMTxdntHEt9aXVjpg==} + engines: {node: '>=8.0.0'} + + web3-shh@1.10.4: + resolution: {integrity: sha512-cOH6iFFM71lCNwSQrC3niqDXagMqrdfFW85hC9PFUrAr3PUrIem8TNstTc3xna2bwZeWG6OBy99xSIhBvyIACw==} + engines: {node: '>=8.0.0'} + + web3-types@1.6.0: + resolution: {integrity: sha512-qgOtADqlD5hw+KPKBUGaXAcdNLL0oh6qTeVgXwewCfbL/lG9R+/GrgMQB1gbTJ3cit8hMwtH8KX2Em6OwO0HRw==} + engines: {node: '>=14', npm: '>=6.12.0'} + + web3-utils@1.10.0: + resolution: {integrity: sha512-kSaCM0uMcZTNUSmn5vMEhlo02RObGNRRCkdX0V9UTAU0+lrvn0HSaudyCo6CQzuXUsnuY2ERJGCGPfeWmv19Rg==} + engines: {node: '>=8.0.0'} + + web3-utils@1.10.4: + resolution: {integrity: sha512-tsu8FiKJLk2PzhDl9fXbGUWTkkVXYhtTA+SmEFkKft+9BgwLxfCRpU96sWv7ICC8zixBNd3JURVoiR3dUXgP8A==} + engines: {node: '>=8.0.0'} + + web3-utils@4.2.3: + resolution: {integrity: sha512-m5plKTC2YtQntHITQRyIePw52UVP1IrShhmA2FACtn4zmc5ADmrXOlQWiPzxFP/18eRJsAaUAw2+CQn1u4WPxQ==} + engines: {node: '>=14', npm: '>=6.12.0'} + + web3-validator@2.0.5: + resolution: {integrity: sha512-2gLOSW8XqEN5pw5jVUm20EB7A8SbQiekpAtiI0JBmCIV0a2rp97v8FgWY5E3UEqnw5WFfEqvcDVW92EyynDTyQ==} + engines: {node: '>=14', npm: '>=6.12.0'} + + web3@0.20.6: + resolution: {integrity: sha512-diON1+Y8sPQ33htuTMZfyo+qlsmCBSYwi+MVTRneS8anqZUaTrGaBkTpPkPUvfX1X+NK+Y2spLaaei3HfXeSuw==} + + web3@0.20.7: + resolution: {integrity: sha512-VU6/DSUX93d1fCzBz7WP/SGCQizO1rKZi4Px9j/3yRyfssHyFcZamMw2/sj4E8TlfMXONvZLoforR8B4bRoyTQ==} + + web3@1.10.0: + resolution: {integrity: sha512-YfKY9wSkGcM8seO+daR89oVTcbu18NsVfvOngzqMYGUU0pPSQmE57qQDvQzUeoIOHAnXEBNzrhjQJmm8ER0rng==} + engines: {node: '>=8.0.0'} + + web3@1.10.4: + resolution: {integrity: sha512-kgJvQZjkmjOEKimx/tJQsqWfRDPTTcBfYPa9XletxuHLpHcXdx67w8EFn5AW3eVxCutE9dTVHgGa9VYe8vgsEA==} + engines: {node: '>=8.0.0'} + + web3@4.8.0: + resolution: {integrity: sha512-kQSF2NlHk8yjS3SRiJW3S+U5ibkEmVRhB4/GYsVwGvdAkFC2b+EIE1Ob7J56OmqW9VBZgkx1+SuWqo5JTIJSYQ==} + engines: {node: '>=14.0.0', npm: '>=6.12.0'} + + webidl-conversions@3.0.1: + resolution: {integrity: sha512-2JAn3z8AR6rjK8Sm8orRC0h/bcl/DqL7tRPdGZ4I1CjdF+EaMLmYxBHyXuKL849eucPFhvBoxMsflfOb8kxaeQ==} + + websocket@1.0.34: + resolution: {integrity: sha512-PRDso2sGwF6kM75QykIesBijKSVceR6jL2G8NGYyq2XrItNC2P5/qL5XeR056GhA+Ly7JMFvJb9I312mJfmqnQ==} + engines: {node: '>=4.0.0'} + + whatwg-fetch@3.6.20: + resolution: {integrity: sha512-EqhiFU6daOA8kpjOWTL0olhVOF3i7OrFzSYiGsEMB8GcXS+RrzauAERX65xMeNWVqxA6HXH2m69Z9LaKKdisfg==} + + whatwg-url@5.0.0: + resolution: {integrity: sha512-saE57nupxk6v3HY35+jzBwYa0rKSy0XR8JSxZPwgLr7ys0IBzhGviA1/TUGJLmSVqs8pb9AnvICXEuOHLprYTw==} + + which-boxed-primitive@1.0.2: + resolution: {integrity: sha512-bwZdv0AKLpplFY2KZRX6TvyuN7ojjr7lwkg6ml0roIy9YeuSr7JS372qlNW18UQYzgYK9ziGcerWqZOmEn9VNg==} + + which-module@1.0.0: + resolution: {integrity: sha512-F6+WgncZi/mJDrammbTuHe1q0R5hOXv/mBaiNA2TCNT/LTHusX0V+CJnj9XT8ki5ln2UZyyddDgHfCzyrOH7MQ==} + + which-module@2.0.1: + resolution: {integrity: sha512-iBdZ57RDvnOR9AGBhML2vFZf7h8vmBjhoaZqODJBFWHVtKkDmKuHai3cx5PgVMrX5YDNp27AofYbAwctSS+vhQ==} + + which-pm@2.0.0: + resolution: {integrity: sha512-Lhs9Pmyph0p5n5Z3mVnN0yWcbQYUAD7rbQUiMsQxOJ3T57k7RFe35SUwWMf7dsbDZks1uOmw4AecB/JMDj3v/w==} + engines: {node: '>=8.15'} + + which-typed-array@1.1.15: + resolution: {integrity: sha512-oV0jmFtUky6CXfkqehVvBP/LSWJ2sy4vWMioiENyJLePrBO/yKyV9OyJySfAKosh+RYkIl5zJCNZ8/4JncrpdA==} + engines: {node: '>= 0.4'} + + which@1.3.1: + resolution: {integrity: sha512-HxJdYWq1MTIQbJ3nw0cqssHoTNU267KlrDuGZ1WYlxDStUtKUhOaJmh112/TZmHxxUfuJqPXSOm7tDyas0OSIQ==} + hasBin: true + + which@2.0.2: + resolution: {integrity: sha512-BLI3Tl1TW3Pvl70l3yq3Y64i+awpwXqsGBYWkkqMtnbXgrMD+yj7rhW0kuEDxzJaYXGjEW5ogapKNMEKNMjibA==} + engines: {node: '>= 8'} + hasBin: true + + widest-line@3.1.0: + resolution: {integrity: sha512-NsmoXalsWVDMGupxZ5R08ka9flZjjiLvHVAWYOKtiKM8ujtZWr9cRffak+uSE48+Ob8ObalXpwyeUiyDD6QFgg==} + engines: {node: '>=8'} + + window-size@0.2.0: + resolution: {integrity: sha512-UD7d8HFA2+PZsbKyaOCEy8gMh1oDtHgJh1LfgjQ4zVXmYjAT/kvz3PueITKuqDiIXQe7yzpPnxX3lNc+AhQMyw==} + engines: {node: '>= 0.10.0'} + hasBin: true + + word-wrap@1.2.5: + resolution: {integrity: sha512-BN22B5eaMMI9UMtjrGd5g5eCYPpCPDUy0FJXbYsaT5zYxjFOckS53SQDE3pWkVoWpHXVb3BrYcEN4Twa55B5cA==} + engines: {node: '>=0.10.0'} + + wordwrap@1.0.0: + resolution: {integrity: sha512-gvVzJFlPycKc5dZN4yPkP8w7Dc37BtP1yczEneOb4uq34pXZcvrtRTmWV8W+Ume+XCxKgbjM+nevkyFPMybd4Q==} + + wordwrapjs@4.0.1: + resolution: {integrity: sha512-kKlNACbvHrkpIw6oPeYDSmdCTu2hdMHoyXLTcUKala++lx5Y+wjJ/e474Jqv5abnVmwxw08DiTuHmw69lJGksA==} + engines: {node: '>=8.0.0'} + + workerpool@6.2.1: + resolution: {integrity: sha512-ILEIE97kDZvF9Wb9f6h5aXK4swSlKGUcOEGiIYb2OOu/IrDU9iwj0fD//SsA6E5ibwJxpEvhullJY4Sl4GcpAw==} + + wrap-ansi@2.1.0: + resolution: {integrity: sha512-vAaEaDM946gbNpH5pLVNR+vX2ht6n0Bt3GXwVB1AuAqZosOvHNF3P7wDnh8KLkSqgUh0uh77le7Owgoz+Z9XBw==} + engines: {node: '>=0.10.0'} + + wrap-ansi@6.2.0: + resolution: {integrity: sha512-r6lPcBGxZXlIcymEu7InxDMhdW0KDxpLgoFLcguasxCaJ/SOIZwINatK9KY/tf+ZrlywOKU0UDj3ATXUBfxJXA==} + engines: {node: '>=8'} + + wrap-ansi@7.0.0: + resolution: {integrity: sha512-YVGIj2kamLSTxw6NsZjoBxfSwsn0ycdesmc4p+Q21c5zPuZ1pl+NfxVdxPtdHvmNVOQ6XSYG4AUtyt/Fi7D16Q==} + engines: {node: '>=10'} + + wrappy@1.0.2: + resolution: {integrity: sha512-l4Sp/DRseor9wL6EvV2+TuQn63dMkPjZ/sp9XkghTEbV9KlPS1xUsZ3u7/IQO4wxtcFB4bgpQPRcR3QCvezPcQ==} + + write-file-atomic@3.0.3: + resolution: {integrity: sha512-AvHcyZ5JnSfq3ioSyjrBkH9yW4m7Ayk8/9My/DD9onKeu/94fwrMocemO2QAJFAlnnDN+ZDS+ZjAR5ua1/PV/Q==} + + ws@3.3.3: + resolution: {integrity: sha512-nnWLa/NwZSt4KQJu51MYlCcSQ5g7INpOrOMt4XV8j4dqTXdmlUmSHQ8/oLC069ckre0fRsgfvsKwbTdtKLCDkA==} + peerDependencies: + bufferutil: ^4.0.1 + utf-8-validate: ^5.0.2 + peerDependenciesMeta: + bufferutil: + optional: true + utf-8-validate: + optional: true + + ws@7.4.6: + resolution: {integrity: sha512-YmhHDO4MzaDLB+M9ym/mDA5z0naX8j7SIlT8f8z+I0VtzsRbekxEutHSme7NPS2qE8StCYQNUnfWdXta/Yu85A==} + engines: {node: '>=8.3.0'} + peerDependencies: + bufferutil: ^4.0.1 + utf-8-validate: ^5.0.2 + peerDependenciesMeta: + bufferutil: + optional: true + utf-8-validate: + optional: true + + ws@7.5.9: + resolution: {integrity: sha512-F+P9Jil7UiSKSkppIiD94dN07AwvFixvLIj1Og1Rl9GGMuNipJnV9JzjD6XuqmAeiswGvUmNLjr5cFuXwNS77Q==} + engines: {node: '>=8.3.0'} + peerDependencies: + bufferutil: ^4.0.1 + utf-8-validate: ^5.0.2 + peerDependenciesMeta: + bufferutil: + optional: true + utf-8-validate: + optional: true + + ws@8.13.0: + resolution: {integrity: sha512-x9vcZYTrFPC7aSIbj7sRCYo7L/Xb8Iy+pW0ng0wt2vCJv7M9HOMy0UoN3rr+IFC7hb7vXoqS+P9ktyLLLhO+LA==} + engines: {node: '>=10.0.0'} + peerDependencies: + bufferutil: ^4.0.1 + utf-8-validate: '>=5.0.2' + peerDependenciesMeta: + bufferutil: + optional: true + utf-8-validate: + optional: true + + ws@8.17.0: + resolution: {integrity: sha512-uJq6108EgZMAl20KagGkzCKfMEjxmKvZHG7Tlq0Z6nOky7YF7aq4mOx6xK8TJ/i1LeK4Qus7INktacctDgY8Ow==} + engines: {node: '>=10.0.0'} + peerDependencies: + bufferutil: ^4.0.1 + utf-8-validate: '>=5.0.2' + peerDependenciesMeta: + bufferutil: + optional: true + utf-8-validate: + optional: true + + ws@8.5.0: + resolution: {integrity: sha512-BWX0SWVgLPzYwF8lTzEy1egjhS4S4OEAHfsO8o65WOVsrnSRGaSiUaa9e0ggGlkMTtBlmOpEXiie9RUcBO86qg==} + engines: {node: '>=10.0.0'} + peerDependencies: + bufferutil: ^4.0.1 + utf-8-validate: ^5.0.2 + peerDependenciesMeta: + bufferutil: + optional: true + utf-8-validate: + optional: true + + xhr-request-promise@0.1.3: + resolution: {integrity: sha512-YUBytBsuwgitWtdRzXDDkWAXzhdGB8bYm0sSzMPZT7Z2MBjMSTHFsyCT1yCRATY+XC69DUrQraRAEgcoCRaIPg==} + + xhr-request@1.1.0: + resolution: {integrity: sha512-Y7qzEaR3FDtL3fP30k9wO/e+FBnBByZeybKOhASsGP30NIkRAAkKD/sCnLvgEfAIEC1rcmK7YG8f4oEnIrrWzA==} + + xhr2-cookies@1.1.0: + resolution: {integrity: sha512-hjXUA6q+jl/bd8ADHcVfFsSPIf+tyLIjuO9TwJC9WI6JP2zKcS7C+p56I9kCLLsaCiNT035iYvEUUzdEFj/8+g==} + + xhr2@0.2.1: + resolution: {integrity: sha512-sID0rrVCqkVNUn8t6xuv9+6FViXjUVXq8H5rWOH2rz9fDNQEd4g0EA2XlcEdJXRz5BMEn4O1pJFdT+z4YHhoWw==} + engines: {node: '>= 6'} + + xhr@2.6.0: + resolution: {integrity: sha512-/eCGLb5rxjx5e3mF1A7s+pLlR6CGyqWN91fv1JgER5mVWg1MZmlhBvy9kjcsOdRk8RrIujotWyJamfyrp+WIcA==} + + xmlhttprequest@1.8.0: + resolution: {integrity: sha512-58Im/U0mlVBLM38NdZjHyhuMtCqa61469k2YP/AaPbvCoV9aQGUpbJBj1QRm2ytRiVQBD/fsw7L2bJGDVQswBA==} + engines: {node: '>=0.4.0'} + + xtend@4.0.2: + resolution: {integrity: sha512-LKYU1iAXJXUgAXn9URjiu+MWhyUXHsvfp7mcuYm9dSUKK0/CjtrUwFAxD82/mCWbtLsGjFIad0wIsod4zrTAEQ==} + engines: {node: '>=0.4'} + + y18n@3.2.2: + resolution: {integrity: sha512-uGZHXkHnhF0XeeAPgnKfPv1bgKAYyVvmNL1xlKsPYZPaIHxGti2hHqvOCQv71XMsLxu1QjergkqogUnms5D3YQ==} + + y18n@4.0.3: + resolution: {integrity: sha512-JKhqTOwSrqNA1NY5lSztJ1GrBiUodLMmIZuLiDaMRJ+itFd+ABVE8XBjOvIWL+rSqNDC74LCSFmlb/U4UZ4hJQ==} + + y18n@5.0.8: + resolution: {integrity: sha512-0pfFzegeDWJHJIAmTLRP2DwHjdF5s7jo9tuztdQxAhINCdvS+3nGINqPd00AphqJR/0LhANUS6/+7SCb98YOfA==} + engines: {node: '>=10'} + + yaeti@0.0.6: + resolution: {integrity: sha512-MvQa//+KcZCUkBTIC9blM+CU9J2GzuTytsOUwf2lidtvkx/6gnEp1QvJv34t9vdjhFmha/mUiNDbN0D0mJWdug==} + engines: {node: '>=0.10.32'} + + yallist@2.1.2: + resolution: {integrity: sha512-ncTzHV7NvsQZkYe1DW7cbDLm0YpzHmZF5r/iyP3ZnQtMiJ+pjzisCiMNI+Sj+xQF5pXhSHxSB3uDbsBTzY/c2A==} + + yallist@3.1.1: + resolution: {integrity: sha512-a4UGQaWPH59mOXUYnAG2ewncQS4i4F43Tv3JoAM+s2VDAmS9NsK8GpDMLrCHPksFT7h3K6TOoUNn2pb7RoXx4g==} + + yargs-parser@18.1.3: + resolution: {integrity: sha512-o50j0JeToy/4K6OZcaQmW6lyXXKhq7csREXcDwk2omFPJEwUNOVtJKvmDr9EI1fAJZUyZcRF7kxGBWmRXudrCQ==} + engines: {node: '>=6'} + + yargs-parser@2.4.1: + resolution: {integrity: sha512-9pIKIJhnI5tonzG6OnCFlz/yln8xHYcGl+pn3xR0Vzff0vzN1PbNRaelgfgRUwZ3s4i3jvxT9WhmUGL4whnasA==} + + yargs-parser@20.2.4: + resolution: {integrity: sha512-WOkpgNhPTlE73h4VFAFsOnomJVaovO8VqLDzy5saChRBFQFBoMYirowyW+Q9HB4HFF4Z7VZTiG3iSzJJA29yRA==} + engines: {node: '>=10'} + + yargs-parser@21.1.1: + resolution: {integrity: sha512-tVpsJW7DdjecAiFpbIB1e3qxIQsE6NoPc5/eTdrbbIC4h0LVsWhnoa3g+m2HclBIujHzsxZ4VJVA+GUuc2/LBw==} + engines: {node: '>=12'} + + yargs-unparser@2.0.0: + resolution: {integrity: sha512-7pRTIA9Qc1caZ0bZ6RYRGbHJthJWuakf+WmHK0rVeLkNrrGhfoabBNdue6kdINI6r4if7ocq9aD/n7xwKOdzOA==} + engines: {node: '>=10'} + + yargs@15.4.1: + resolution: {integrity: sha512-aePbxDmcYW++PaqBsJ+HYUFwCdv4LVvdnhBy78E57PIor8/OVvhMrADFFEDh8DHDFRv/O9i3lPhsENjO7QX0+A==} + engines: {node: '>=8'} + + yargs@16.2.0: + resolution: {integrity: sha512-D1mvvtDG0L5ft/jGWkLpG1+m0eQxOfaBvTNELraWj22wSVUMWxZUvYgJYcKh6jGGIkJFhH4IZPQhR4TKpc8mBw==} + engines: {node: '>=10'} + + yargs@17.7.2: + resolution: {integrity: sha512-7dSzzRQ++CKnNI/krKnYRV7JKKPUXMEh61soaHKg9mrWEhzFWhFnxPxGl+69cD1Ou63C13NUPCnmIcrvqCuM6w==} + engines: {node: '>=12'} + + yargs@4.8.1: + resolution: {integrity: sha512-LqodLrnIDM3IFT+Hf/5sxBnEGECrfdC1uIbgZeJmESCSo4HoCAaKEus8MylXHAkdacGc0ye+Qa+dpkuom8uVYA==} + + yn@3.1.1: + resolution: {integrity: sha512-Ux4ygGWsu2c7isFWe8Yu1YluJmqVhxqK2cLXNQA5AcC3QfbGNpM7fu0Y8b/z16pXLnFxZYvWhd3fhBY9DLmC6Q==} + engines: {node: '>=6'} + + yocto-queue@0.1.0: + resolution: {integrity: sha512-rVksvsnNCdJ/ohGc6xgPwyN8eheCxsiLM8mxuE/t/mOVqJewPuO1miLpTHQiRgTKCLexL4MeAFVagts7HmNZ2Q==} + engines: {node: '>=10'} + + zod@3.23.8: + resolution: {integrity: sha512-XBx9AXhXktjUqnepgTiE5flcKIYWi/rme0Eaj+5Y0lftuGBq+jyRu/md4WnuxqgP1ubdpNCsYEYPxrzVHD8d6g==} + +snapshots: + + '@adraffy/ens-normalize@1.10.0': {} + + '@adraffy/ens-normalize@1.10.1': {} + + '@ampproject/remapping@2.3.0': + dependencies: + '@jridgewell/gen-mapping': 0.3.5 + '@jridgewell/trace-mapping': 0.3.25 + + '@babel/code-frame@7.24.2': + dependencies: + '@babel/highlight': 7.24.5 + picocolors: 1.0.0 + + '@babel/compat-data@7.24.4': {} + + '@babel/core@7.24.5': + dependencies: + '@ampproject/remapping': 2.3.0 + '@babel/code-frame': 7.24.2 + '@babel/generator': 7.24.5 + '@babel/helper-compilation-targets': 7.23.6 + '@babel/helper-module-transforms': 7.24.5(@babel/core@7.24.5) + '@babel/helpers': 7.24.5 + '@babel/parser': 7.24.5 + '@babel/template': 7.24.0 + '@babel/traverse': 7.24.5 + '@babel/types': 7.24.5 + convert-source-map: 2.0.0 + debug: 4.3.4(supports-color@8.1.1) + gensync: 1.0.0-beta.2 + json5: 2.2.3 + semver: 6.3.1 + transitivePeerDependencies: + - supports-color + + '@babel/generator@7.24.5': + dependencies: + '@babel/types': 7.24.5 + '@jridgewell/gen-mapping': 0.3.5 + '@jridgewell/trace-mapping': 0.3.25 + jsesc: 2.5.2 + + '@babel/helper-compilation-targets@7.23.6': + dependencies: + '@babel/compat-data': 7.24.4 + '@babel/helper-validator-option': 7.23.5 + browserslist: 4.23.0 + lru-cache: 5.1.1 + semver: 6.3.1 + + '@babel/helper-environment-visitor@7.22.20': {} + + '@babel/helper-function-name@7.23.0': + dependencies: + '@babel/template': 7.24.0 + '@babel/types': 7.24.5 + + '@babel/helper-hoist-variables@7.22.5': + dependencies: + '@babel/types': 7.24.5 + + '@babel/helper-module-imports@7.24.3': + dependencies: + '@babel/types': 7.24.5 + + '@babel/helper-module-transforms@7.24.5(@babel/core@7.24.5)': + dependencies: + '@babel/core': 7.24.5 + '@babel/helper-environment-visitor': 7.22.20 + '@babel/helper-module-imports': 7.24.3 + '@babel/helper-simple-access': 7.24.5 + '@babel/helper-split-export-declaration': 7.24.5 + '@babel/helper-validator-identifier': 7.24.5 + + '@babel/helper-simple-access@7.24.5': + dependencies: + '@babel/types': 7.24.5 + + '@babel/helper-split-export-declaration@7.24.5': + dependencies: + '@babel/types': 7.24.5 + + '@babel/helper-string-parser@7.24.1': {} + + '@babel/helper-validator-identifier@7.24.5': {} + + '@babel/helper-validator-option@7.23.5': {} + + '@babel/helpers@7.24.5': + dependencies: + '@babel/template': 7.24.0 + '@babel/traverse': 7.24.5 + '@babel/types': 7.24.5 + transitivePeerDependencies: + - supports-color + + '@babel/highlight@7.24.5': + dependencies: + '@babel/helper-validator-identifier': 7.24.5 + chalk: 2.4.2 + js-tokens: 4.0.0 + picocolors: 1.0.0 + + '@babel/parser@7.24.5': + dependencies: + '@babel/types': 7.24.5 + + '@babel/runtime@7.24.5': + dependencies: + regenerator-runtime: 0.14.1 + + '@babel/template@7.24.0': + dependencies: + '@babel/code-frame': 7.24.2 + '@babel/parser': 7.24.5 + '@babel/types': 7.24.5 + + '@babel/traverse@7.24.5': + dependencies: + '@babel/code-frame': 7.24.2 + '@babel/generator': 7.24.5 + '@babel/helper-environment-visitor': 7.22.20 + '@babel/helper-function-name': 7.23.0 + '@babel/helper-hoist-variables': 7.22.5 + '@babel/helper-split-export-declaration': 7.24.5 + '@babel/parser': 7.24.5 + '@babel/types': 7.24.5 + debug: 4.3.4(supports-color@8.1.1) + globals: 11.12.0 + transitivePeerDependencies: + - supports-color + + '@babel/types@7.24.5': + dependencies: + '@babel/helper-string-parser': 7.24.1 + '@babel/helper-validator-identifier': 7.24.5 + to-fast-properties: 2.0.0 + + '@changesets/apply-release-plan@7.0.0': + dependencies: + '@babel/runtime': 7.24.5 + '@changesets/config': 3.0.0 + '@changesets/get-version-range-type': 0.4.0 + '@changesets/git': 3.0.0 + '@changesets/types': 6.0.0 + '@manypkg/get-packages': 1.1.3 + detect-indent: 6.1.0 + fs-extra: 7.0.1 + lodash.startcase: 4.4.0 + outdent: 0.5.0 + prettier: 2.8.8 + resolve-from: 5.0.0 + semver: 7.6.2 + + '@changesets/assemble-release-plan@6.0.0': + dependencies: + '@babel/runtime': 7.24.5 + '@changesets/errors': 0.2.0 + '@changesets/get-dependents-graph': 2.0.0 + '@changesets/types': 6.0.0 + '@manypkg/get-packages': 1.1.3 + semver: 7.6.2 + + '@changesets/changelog-git@0.2.0': + dependencies: + '@changesets/types': 6.0.0 + + '@changesets/cli@2.27.1': + dependencies: + '@babel/runtime': 7.24.5 + '@changesets/apply-release-plan': 7.0.0 + '@changesets/assemble-release-plan': 6.0.0 + '@changesets/changelog-git': 0.2.0 + '@changesets/config': 3.0.0 + '@changesets/errors': 0.2.0 + '@changesets/get-dependents-graph': 2.0.0 + '@changesets/get-release-plan': 4.0.0 + '@changesets/git': 3.0.0 + '@changesets/logger': 0.1.0 + '@changesets/pre': 2.0.0 + '@changesets/read': 0.6.0 + '@changesets/types': 6.0.0 + '@changesets/write': 0.3.0 + '@manypkg/get-packages': 1.1.3 + '@types/semver': 7.5.8 + ansi-colors: 4.1.3 + chalk: 2.4.2 + ci-info: 3.9.0 + enquirer: 2.4.1 + external-editor: 3.1.0 + fs-extra: 7.0.1 + human-id: 1.0.2 + meow: 6.1.1 + outdent: 0.5.0 + p-limit: 2.3.0 + preferred-pm: 3.1.3 + resolve-from: 5.0.0 + semver: 7.6.2 + spawndamnit: 2.0.0 + term-size: 2.2.1 + tty-table: 4.2.3 + + '@changesets/config@3.0.0': + dependencies: + '@changesets/errors': 0.2.0 + '@changesets/get-dependents-graph': 2.0.0 + '@changesets/logger': 0.1.0 + '@changesets/types': 6.0.0 + '@manypkg/get-packages': 1.1.3 + fs-extra: 7.0.1 + micromatch: 4.0.5 + + '@changesets/errors@0.2.0': + dependencies: + extendable-error: 0.1.7 + + '@changesets/get-dependents-graph@2.0.0': + dependencies: + '@changesets/types': 6.0.0 + '@manypkg/get-packages': 1.1.3 + chalk: 2.4.2 + fs-extra: 7.0.1 + semver: 7.6.2 + + '@changesets/get-release-plan@4.0.0': + dependencies: + '@babel/runtime': 7.24.5 + '@changesets/assemble-release-plan': 6.0.0 + '@changesets/config': 3.0.0 + '@changesets/pre': 2.0.0 + '@changesets/read': 0.6.0 + '@changesets/types': 6.0.0 + '@manypkg/get-packages': 1.1.3 + + '@changesets/get-version-range-type@0.4.0': {} + + '@changesets/git@3.0.0': + dependencies: + '@babel/runtime': 7.24.5 + '@changesets/errors': 0.2.0 + '@changesets/types': 6.0.0 '@manypkg/get-packages': 1.1.3 is-subdir: 1.2.0 micromatch: 4.0.5 spawndamnit: 2.0.0 - dev: true - /@changesets/logger@0.1.0: - resolution: {integrity: sha512-pBrJm4CQm9VqFVwWnSqKEfsS2ESnwqwH+xR7jETxIErZcfd1u2zBSqrHbRHR7xjhSgep9x2PSKFKY//FAshA3g==} + '@changesets/logger@0.1.0': dependencies: chalk: 2.4.2 - dev: true - /@changesets/parse@0.4.0: - resolution: {integrity: sha512-TS/9KG2CdGXS27S+QxbZXgr8uPsP4yNJYb4BC2/NeFUj80Rni3TeD2qwWmabymxmrLo7JEsytXH1FbpKTbvivw==} + '@changesets/parse@0.4.0': dependencies: '@changesets/types': 6.0.0 js-yaml: 3.14.1 - dev: true - /@changesets/pre@2.0.0: - resolution: {integrity: sha512-HLTNYX/A4jZxc+Sq8D1AMBsv+1qD6rmmJtjsCJa/9MSRybdxh0mjbTvE6JYZQ/ZiQ0mMlDOlGPXTm9KLTU3jyw==} + '@changesets/pre@2.0.0': dependencies: '@babel/runtime': 7.24.5 '@changesets/errors': 0.2.0 '@changesets/types': 6.0.0 '@manypkg/get-packages': 1.1.3 fs-extra: 7.0.1 - dev: true - /@changesets/read@0.6.0: - resolution: {integrity: sha512-ZypqX8+/im1Fm98K4YcZtmLKgjs1kDQ5zHpc2U1qdtNBmZZfo/IBiG162RoP0CUF05tvp2y4IspH11PLnPxuuw==} + '@changesets/read@0.6.0': dependencies: '@babel/runtime': 7.24.5 '@changesets/git': 3.0.0 @@ -2238,35 +7620,24 @@ packages: chalk: 2.4.2 fs-extra: 7.0.1 p-filter: 2.1.0 - dev: true - /@changesets/types@4.1.0: - resolution: {integrity: sha512-LDQvVDv5Kb50ny2s25Fhm3d9QSZimsoUGBsUioj6MC3qbMUCuC8GPIvk/M6IvXx3lYhAs0lwWUQLb+VIEUCECw==} - dev: true + '@changesets/types@4.1.0': {} - /@changesets/types@6.0.0: - resolution: {integrity: sha512-b1UkfNulgKoWfqyHtzKS5fOZYSJO+77adgL7DLRDr+/7jhChN+QcHnbjiQVOz/U+Ts3PGNySq7diAItzDgugfQ==} - dev: true + '@changesets/types@6.0.0': {} - /@changesets/write@0.3.0: - resolution: {integrity: sha512-slGLb21fxZVUYbyea+94uFiD6ntQW0M2hIKNznFizDhZPDgn2c/fv1UzzlW43RVzh1BEDuIqW6hzlJ1OflNmcw==} + '@changesets/write@0.3.0': dependencies: '@babel/runtime': 7.24.5 '@changesets/types': 6.0.0 fs-extra: 7.0.1 human-id: 1.0.2 prettier: 2.8.8 - dev: true - /@cspotcode/source-map-support@0.8.1: - resolution: {integrity: sha512-IchNf6dN4tHoMFIn/7OE8LWZ19Y6q/67Bmf6vnGREv8RSbBVb9LPJxEcnwrcwX6ixSvaiGoomAUvu4YSxXrVgw==} - engines: {node: '>=12'} + '@cspotcode/source-map-support@0.8.1': dependencies: '@jridgewell/trace-mapping': 0.3.9 - dev: true - /@ensdomains/address-encoder@0.1.9: - resolution: {integrity: sha512-E2d2gP4uxJQnDu2Kfg1tHNspefzbLT8Tyjrm5sEuim32UkU2sm5xL4VXtgc2X33fmPEw9+jUMpGs4veMbf+PYg==} + '@ensdomains/address-encoder@0.1.9': dependencies: bech32: 1.1.4 blakejs: 1.2.1 @@ -2275,21 +7646,16 @@ packages: crypto-addr-codec: 0.1.8 nano-base32: 1.0.1 ripemd160: 2.0.2 - dev: false - /@ensdomains/ens@0.4.5: - resolution: {integrity: sha512-JSvpj1iNMFjK6K+uVl4unqMoa9rf5jopb8cya5UGBWz23Nw8hSNT7efgUx4BTlAPAgpNlEioUfeTyQ6J9ZvTVw==} - deprecated: Please use @ensdomains/ens-contracts + '@ensdomains/ens@0.4.5': dependencies: bluebird: 3.7.2 eth-ens-namehash: 2.0.8 solc: 0.4.26 testrpc: 0.0.1 web3-utils: 1.10.4 - dev: false - /@ensdomains/ensjs@2.1.0: - resolution: {integrity: sha512-GRbGPT8Z/OJMDuxs75U/jUNEC0tbL0aj7/L/QQznGYKm/tiasp+ndLOaoULy9kKJFC0TBByqfFliEHDgoLhyog==} + '@ensdomains/ensjs@2.1.0(bufferutil@4.0.8)(utf-8-validate@5.0.10)': dependencies: '@babel/runtime': 7.24.5 '@ensdomains/address-encoder': 0.1.9 @@ -2297,34 +7663,22 @@ packages: '@ensdomains/resolver': 0.2.4 content-hash: 2.5.2 eth-ens-namehash: 2.0.8 - ethers: 5.7.2 + ethers: 5.7.2(bufferutil@4.0.8)(utf-8-validate@5.0.10) js-sha3: 0.8.0 transitivePeerDependencies: - bufferutil - utf-8-validate - dev: false - /@ensdomains/resolver@0.2.4: - resolution: {integrity: sha512-bvaTH34PMCbv6anRa9I/0zjLJgY4EuznbEMgbV77JBCQ9KNC46rzi0avuxpOfu+xDjPEtSFGqVEOr5GlUSGudA==} - deprecated: Please use @ensdomains/ens-contracts - dev: false + '@ensdomains/resolver@0.2.4': {} - /@eslint-community/eslint-utils@4.4.0(eslint@8.57.0): - resolution: {integrity: sha512-1/sA4dwrzBAyeUoQ6oxahHKmrZvsnLCg4RfxW3ZFGGmQkSNQPFNLV9CUEFQP1x9EYXHTo5p6xdhZM1Ne9p/AfA==} - engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0} - peerDependencies: - eslint: ^6.0.0 || ^7.0.0 || >=8.0.0 + '@eslint-community/eslint-utils@4.4.0(eslint@8.57.0)': dependencies: eslint: 8.57.0 eslint-visitor-keys: 3.4.3 - /@eslint-community/regexpp@4.10.0: - resolution: {integrity: sha512-Cu96Sd2By9mCNTx2iyKOmq10v22jUVQv0lQnlGNy16oE9589yE+QADPbrMGCkA51cKZSg3Pu/aTJVTGfL/qjUA==} - engines: {node: ^12.0.0 || ^14.0.0 || >=16.0.0} - - /@eslint/eslintrc@2.1.4: - resolution: {integrity: sha512-269Z39MS6wVJtsoUl10L60WdkhJVdPG24Q4eZTH3nnF6lpvSShEK3wQjDX9JRWAUPvPh7COouPpU9IrqaZFvtQ==} - engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0} + '@eslint-community/regexpp@4.10.0': {} + + '@eslint/eslintrc@2.1.4': dependencies: ajv: 6.12.6 debug: 4.3.4(supports-color@8.1.1) @@ -2338,51 +7692,37 @@ packages: transitivePeerDependencies: - supports-color - /@eslint/js@8.57.0: - resolution: {integrity: sha512-Ys+3g2TaW7gADOJzPt83SJtCDhMjndcDMFVQ/Tj9iA1BfJzFKD9mAUXT3OenpuPHbI6P/myECxRJrofUsDx/5g==} - engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0} + '@eslint/js@8.57.0': {} - /@ethereumjs/common@2.5.0: - resolution: {integrity: sha512-DEHjW6e38o+JmB/NO3GZBpW4lpaiBpkFgXF6jLcJ6gETBYpEyaA5nTimsWBUJR3Vmtm/didUEbNjajskugZORg==} + '@ethereumjs/common@2.5.0': dependencies: crc-32: 1.2.2 ethereumjs-util: 7.1.5 - dev: false - /@ethereumjs/common@2.6.5: - resolution: {integrity: sha512-lRyVQOeCDaIVtgfbowla32pzeDv2Obr8oR8Put5RdUBNRGr1VGPGQNGP6elWIpgK3YdpzqTOh4GyUGOureVeeA==} + '@ethereumjs/common@2.6.5': dependencies: crc-32: 1.2.2 ethereumjs-util: 7.1.5 - /@ethereumjs/rlp@4.0.1: - resolution: {integrity: sha512-tqsQiBQDQdmPWE1xkkBq4rlSW5QZpLOUJ5RJh2/9fug+q9tnUhuZoVLk7s0scUIKTOzEtR72DFBXI4WiZcMpvw==} - engines: {node: '>=14'} - hasBin: true + '@ethereumjs/rlp@4.0.1': {} - /@ethereumjs/tx@3.3.2: - resolution: {integrity: sha512-6AaJhwg4ucmwTvw/1qLaZUX5miWrwZ4nLOUsKyb/HtzS3BMw/CasKhdi1ims9mBKeK9sOJCH4qGKOBGyJCeeog==} + '@ethereumjs/tx@3.3.2': dependencies: '@ethereumjs/common': 2.5.0 ethereumjs-util: 7.1.5 - dev: false - /@ethereumjs/tx@3.5.2: - resolution: {integrity: sha512-gQDNJWKrSDGu2w7w0PzVXVBNMzb7wwdDOmOqczmhNjqFxFuIbhVJDwiGEnxFNC2/b8ifcZzY7MLcluizohRzNw==} + '@ethereumjs/tx@3.5.2': dependencies: '@ethereumjs/common': 2.6.5 ethereumjs-util: 7.1.5 - /@ethereumjs/util@8.1.0: - resolution: {integrity: sha512-zQ0IqbdX8FZ9aw11vP+dZkKDkS+kgIvQPHnSAXzP9pLu+Rfu3D3XEeLbicvoXJTYnhZiPmsZUxgdzXwNKxRPbA==} - engines: {node: '>=14'} + '@ethereumjs/util@8.1.0': dependencies: '@ethereumjs/rlp': 4.0.1 ethereum-cryptography: 2.1.3 micro-ftch: 0.3.1 - /@ethersproject/abi@5.7.0: - resolution: {integrity: sha512-351ktp42TiRcYB3H1OP8yajPeAQstMW/yCFokj/AthP9bLHzQFPlOrxOcwYEDkUAICmOHljvN4K39OMTMUa9RA==} + '@ethersproject/abi@5.7.0': dependencies: '@ethersproject/address': 5.7.0 '@ethersproject/bignumber': 5.7.0 @@ -2394,8 +7734,7 @@ packages: '@ethersproject/properties': 5.7.0 '@ethersproject/strings': 5.7.0 - /@ethersproject/abstract-provider@5.7.0: - resolution: {integrity: sha512-R41c9UkchKCpAqStMYUpdunjo3pkEvZC3FAwZn5S5MGbXoMQOHIdHItezTETxAO5bevtMApSyEhn9+CHcDsWBw==} + '@ethersproject/abstract-provider@5.7.0': dependencies: '@ethersproject/bignumber': 5.7.0 '@ethersproject/bytes': 5.7.0 @@ -2405,8 +7744,7 @@ packages: '@ethersproject/transactions': 5.7.0 '@ethersproject/web': 5.7.1 - /@ethersproject/abstract-signer@5.7.0: - resolution: {integrity: sha512-a16V8bq1/Cz+TGCkE2OPMTOUDLS3grCpdjoJCYNnVBbdYEMSgKrU0+B90s8b6H+ByYTBZN7a3g76jdIJi7UfKQ==} + '@ethersproject/abstract-signer@5.7.0': dependencies: '@ethersproject/abstract-provider': 5.7.0 '@ethersproject/bignumber': 5.7.0 @@ -2414,18 +7752,15 @@ packages: '@ethersproject/logger': 5.7.0 '@ethersproject/properties': 5.7.0 - /@ethersproject/address@5.6.1: - resolution: {integrity: sha512-uOgF0kS5MJv9ZvCz7x6T2EXJSzotiybApn4XlOgoTX0xdtyVIJ7pF+6cGPxiEq/dpBiTfMiw7Yc81JcwhSYA0Q==} + '@ethersproject/address@5.6.1': dependencies: '@ethersproject/bignumber': 5.7.0 '@ethersproject/bytes': 5.7.0 '@ethersproject/keccak256': 5.7.0 '@ethersproject/logger': 5.7.0 '@ethersproject/rlp': 5.7.0 - dev: true - /@ethersproject/address@5.7.0: - resolution: {integrity: sha512-9wYhYt7aghVGo758POM5nqcOMaE168Q6aRLJZwUmiqSrAungkG74gSSeKEIR7ukixesdRZGPgVqme6vmxs1fkA==} + '@ethersproject/address@5.7.0': dependencies: '@ethersproject/bignumber': 5.7.0 '@ethersproject/bytes': 5.7.0 @@ -2433,36 +7768,30 @@ packages: '@ethersproject/logger': 5.7.0 '@ethersproject/rlp': 5.7.0 - /@ethersproject/base64@5.7.0: - resolution: {integrity: sha512-Dr8tcHt2mEbsZr/mwTPIQAf3Ai0Bks/7gTw9dSqk1mQvhW3XvRlmDJr/4n+wg1JmCl16NZue17CDh8xb/vZ0sQ==} + '@ethersproject/base64@5.7.0': dependencies: '@ethersproject/bytes': 5.7.0 - /@ethersproject/basex@5.7.0: - resolution: {integrity: sha512-ywlh43GwZLv2Voc2gQVTKBoVQ1mti3d8HK5aMxsfu/nRDnMmNqaSJ3r3n85HBByT8OpoY96SXM1FogC533T4zw==} + '@ethersproject/basex@5.7.0': dependencies: '@ethersproject/bytes': 5.7.0 '@ethersproject/properties': 5.7.0 - /@ethersproject/bignumber@5.7.0: - resolution: {integrity: sha512-n1CAdIHRWjSucQO3MC1zPSVgV/6dy/fjL9pMrPP9peL+QxEg9wOsVqwD4+818B6LUEtaXzVHQiuivzRoxPxUGw==} + '@ethersproject/bignumber@5.7.0': dependencies: '@ethersproject/bytes': 5.7.0 '@ethersproject/logger': 5.7.0 bn.js: 5.2.1 - /@ethersproject/bytes@5.7.0: - resolution: {integrity: sha512-nsbxwgFXWh9NyYWo+U8atvmMsSdKJprTcICAkvbBffT75qDocbuggBU0SJiVK2MuTrp0q+xvLkTnGMPK1+uA9A==} + '@ethersproject/bytes@5.7.0': dependencies: '@ethersproject/logger': 5.7.0 - /@ethersproject/constants@5.7.0: - resolution: {integrity: sha512-DHI+y5dBNvkpYUMiRQyxRBYBefZkJfo70VUkUAsRjcPs47muV9evftfZ0PJVCXYbAiCgght0DtcF9srFQmIgWA==} + '@ethersproject/constants@5.7.0': dependencies: '@ethersproject/bignumber': 5.7.0 - /@ethersproject/contracts@5.7.0: - resolution: {integrity: sha512-5GJbzEU3X+d33CdfPhcyS+z8MzsTrBGk/sc+G+59+tPa9yFkl6HQ9D6L0QMgNTA9q8dT0XKxxkyp883XsQvbbg==} + '@ethersproject/contracts@5.7.0': dependencies: '@ethersproject/abi': 5.7.0 '@ethersproject/abstract-provider': 5.7.0 @@ -2475,8 +7804,7 @@ packages: '@ethersproject/properties': 5.7.0 '@ethersproject/transactions': 5.7.0 - /@ethersproject/hash@5.7.0: - resolution: {integrity: sha512-qX5WrQfnah1EFnO5zJv1v46a8HW0+E5xuBBDTwMFZLuVTx0tbU2kkx15NqdjxecrLGatQN9FGQKpb1FKdHCt+g==} + '@ethersproject/hash@5.7.0': dependencies: '@ethersproject/abstract-signer': 5.7.0 '@ethersproject/address': 5.7.0 @@ -2488,8 +7816,7 @@ packages: '@ethersproject/properties': 5.7.0 '@ethersproject/strings': 5.7.0 - /@ethersproject/hdnode@5.7.0: - resolution: {integrity: sha512-OmyYo9EENBPPf4ERhR7oj6uAtUAhYGqOnIS+jE5pTXvdKBS99ikzq1E7Iv0ZQZ5V36Lqx1qZLeak0Ra16qpeOg==} + '@ethersproject/hdnode@5.7.0': dependencies: '@ethersproject/abstract-signer': 5.7.0 '@ethersproject/basex': 5.7.0 @@ -2504,8 +7831,7 @@ packages: '@ethersproject/transactions': 5.7.0 '@ethersproject/wordlists': 5.7.0 - /@ethersproject/json-wallets@5.7.0: - resolution: {integrity: sha512-8oee5Xgu6+RKgJTkvEMl2wDgSPSAQ9MB/3JYjFV9jlKvcYHUXZC+cQp0njgmxdHkYWn8s6/IqIZYm0YWCjO/0g==} + '@ethersproject/json-wallets@5.7.0': dependencies: '@ethersproject/abstract-signer': 5.7.0 '@ethersproject/address': 5.7.0 @@ -2521,33 +7847,27 @@ packages: aes-js: 3.0.0 scrypt-js: 3.0.1 - /@ethersproject/keccak256@5.7.0: - resolution: {integrity: sha512-2UcPboeL/iW+pSg6vZ6ydF8tCnv3Iu/8tUmLLzWWGzxWKFFqOBQFLo6uLUv6BDrLgCDfN28RJ/wtByx+jZ4KBg==} + '@ethersproject/keccak256@5.7.0': dependencies: '@ethersproject/bytes': 5.7.0 js-sha3: 0.8.0 - /@ethersproject/logger@5.7.0: - resolution: {integrity: sha512-0odtFdXu/XHtjQXJYA3u9G0G8btm0ND5Cu8M7i5vhEcE8/HmF4Lbdqanwyv4uQTr2tx6b7fQRmgLrsnpQlmnig==} + '@ethersproject/logger@5.7.0': {} - /@ethersproject/networks@5.7.1: - resolution: {integrity: sha512-n/MufjFYv3yFcUyfhnXotyDlNdFb7onmkSy8aQERi2PjNcnWQ66xXxa3XlS8nCcA8aJKJjIIMNJTC7tu80GwpQ==} + '@ethersproject/networks@5.7.1': dependencies: '@ethersproject/logger': 5.7.0 - /@ethersproject/pbkdf2@5.7.0: - resolution: {integrity: sha512-oR/dBRZR6GTyaofd86DehG72hY6NpAjhabkhxgr3X2FpJtJuodEl2auADWBZfhDHgVCbu3/H/Ocq2uC6dpNjjw==} + '@ethersproject/pbkdf2@5.7.0': dependencies: '@ethersproject/bytes': 5.7.0 '@ethersproject/sha2': 5.7.0 - /@ethersproject/properties@5.7.0: - resolution: {integrity: sha512-J87jy8suntrAkIZtecpxEPxY//szqr1mlBaYlQ0r4RCaiD2hjheqF9s1LVE8vVuJCXisjIP+JgtK/Do54ej4Sw==} + '@ethersproject/properties@5.7.0': dependencies: '@ethersproject/logger': 5.7.0 - /@ethersproject/providers@5.7.2: - resolution: {integrity: sha512-g34EWZ1WWAVgr4aptGlVBF8mhl3VWjv+8hoAnzStu8Ah22VHBsuGzP17eb6xDVRzw895G4W7vvx60lFFur/1Rg==} + '@ethersproject/providers@5.7.2(bufferutil@4.0.8)(utf-8-validate@5.0.10)': dependencies: '@ethersproject/abstract-provider': 5.7.0 '@ethersproject/abstract-signer': 5.7.0 @@ -2568,32 +7888,28 @@ packages: '@ethersproject/transactions': 5.7.0 '@ethersproject/web': 5.7.1 bech32: 1.1.4 - ws: 7.4.6 + ws: 7.4.6(bufferutil@4.0.8)(utf-8-validate@5.0.10) transitivePeerDependencies: - bufferutil - utf-8-validate - /@ethersproject/random@5.7.0: - resolution: {integrity: sha512-19WjScqRA8IIeWclFme75VMXSBvi4e6InrUNuaR4s5pTF2qNhcGdCUwdxUVGtDDqC00sDLCO93jPQoDUH4HVmQ==} + '@ethersproject/random@5.7.0': dependencies: '@ethersproject/bytes': 5.7.0 '@ethersproject/logger': 5.7.0 - /@ethersproject/rlp@5.7.0: - resolution: {integrity: sha512-rBxzX2vK8mVF7b0Tol44t5Tb8gomOHkj5guL+HhzQ1yBh/ydjGnpw6at+X6Iw0Kp3OzzzkcKp8N9r0W4kYSs9w==} + '@ethersproject/rlp@5.7.0': dependencies: '@ethersproject/bytes': 5.7.0 '@ethersproject/logger': 5.7.0 - /@ethersproject/sha2@5.7.0: - resolution: {integrity: sha512-gKlH42riwb3KYp0reLsFTokByAKoJdgFCwI+CCiX/k+Jm2mbNs6oOaCjYQSlI1+XBVejwH2KrmCbMAT/GnRDQw==} + '@ethersproject/sha2@5.7.0': dependencies: '@ethersproject/bytes': 5.7.0 '@ethersproject/logger': 5.7.0 hash.js: 1.1.7 - /@ethersproject/signing-key@5.7.0: - resolution: {integrity: sha512-MZdy2nL3wO0u7gkB4nA/pEf8lu1TlFswPNmy8AiYkfKTdO6eXBJyUdmHO/ehm/htHw9K/qF8ujnTyUAD+Ry54Q==} + '@ethersproject/signing-key@5.7.0': dependencies: '@ethersproject/bytes': 5.7.0 '@ethersproject/logger': 5.7.0 @@ -2602,8 +7918,7 @@ packages: elliptic: 6.5.4 hash.js: 1.1.7 - /@ethersproject/solidity@5.7.0: - resolution: {integrity: sha512-HmabMd2Dt/raavyaGukF4XxizWKhKQ24DoLtdNbBmNKUOPqwjsKQSdV9GQtj9CBEea9DlzETlVER1gYeXXBGaA==} + '@ethersproject/solidity@5.7.0': dependencies: '@ethersproject/bignumber': 5.7.0 '@ethersproject/bytes': 5.7.0 @@ -2612,15 +7927,13 @@ packages: '@ethersproject/sha2': 5.7.0 '@ethersproject/strings': 5.7.0 - /@ethersproject/strings@5.7.0: - resolution: {integrity: sha512-/9nu+lj0YswRNSH0NXYqrh8775XNyEdUQAuf3f+SmOrnVewcJ5SBNAjF7lpgehKi4abvNNXyf+HX86czCdJ8Mg==} + '@ethersproject/strings@5.7.0': dependencies: '@ethersproject/bytes': 5.7.0 '@ethersproject/constants': 5.7.0 '@ethersproject/logger': 5.7.0 - /@ethersproject/transactions@5.7.0: - resolution: {integrity: sha512-kmcNicCp1lp8qanMTC3RIikGgoJ80ztTyvtsFvCYpSCfkjhD0jZ2LOrnbcuxuToLIUYYf+4XwD1rP+B/erDIhQ==} + '@ethersproject/transactions@5.7.0': dependencies: '@ethersproject/address': 5.7.0 '@ethersproject/bignumber': 5.7.0 @@ -2632,15 +7945,13 @@ packages: '@ethersproject/rlp': 5.7.0 '@ethersproject/signing-key': 5.7.0 - /@ethersproject/units@5.7.0: - resolution: {integrity: sha512-pD3xLMy3SJu9kG5xDGI7+xhTEmGXlEqXU4OfNapmfnxLVY4EMSSRp7j1k7eezutBPH7RBN/7QPnwR7hzNlEFeg==} + '@ethersproject/units@5.7.0': dependencies: '@ethersproject/bignumber': 5.7.0 '@ethersproject/constants': 5.7.0 '@ethersproject/logger': 5.7.0 - /@ethersproject/wallet@5.7.0: - resolution: {integrity: sha512-MhmXlJXEJFBFVKrDLB4ZdDzxcBxQ3rLyCkhNqVu3CDYvR97E+8r01UgrI+TI99Le+aYm/in/0vp86guJuM7FCA==} + '@ethersproject/wallet@5.7.0': dependencies: '@ethersproject/abstract-provider': 5.7.0 '@ethersproject/abstract-signer': 5.7.0 @@ -2658,8 +7969,7 @@ packages: '@ethersproject/transactions': 5.7.0 '@ethersproject/wordlists': 5.7.0 - /@ethersproject/web@5.7.1: - resolution: {integrity: sha512-Gueu8lSvyjBWL4cYsWsjh6MtMwM0+H4HvqFPZfB6dV8ctbP9zFAO73VG1cMWae0FLPCtz0peKPpZY8/ugJJX2w==} + '@ethersproject/web@5.7.1': dependencies: '@ethersproject/base64': 5.7.0 '@ethersproject/bytes': 5.7.0 @@ -2667,8 +7977,7 @@ packages: '@ethersproject/properties': 5.7.0 '@ethersproject/strings': 5.7.0 - /@ethersproject/wordlists@5.7.0: - resolution: {integrity: sha512-S2TFNJNfHWVHNE6cNDjbVlZ6MgE17MIxMbMg2zv3wn+3XSJGosL1m9ZVv3GXCf/2ymSsQ+hRI5IzoMJTG6aoVA==} + '@ethersproject/wordlists@5.7.0': dependencies: '@ethersproject/bytes': 5.7.0 '@ethersproject/hash': 5.7.0 @@ -2676,14 +7985,9 @@ packages: '@ethersproject/properties': 5.7.0 '@ethersproject/strings': 5.7.0 - /@fastify/busboy@2.1.1: - resolution: {integrity: sha512-vBZP4NlzfOlerQTnba4aqZoMhE/a9HY7HRqoOPaETQcSQuWEIyZMHGfVu6w9wGtGK5fED5qRs2DteVCjOH60sA==} - engines: {node: '>=14'} - dev: false + '@fastify/busboy@2.1.1': {} - /@fvictorio/tabtab@0.0.3: - resolution: {integrity: sha512-bT/BSy8MJThrTebqTCjXRnGSgZWthHLigZ4k2AvfNtC79vPyBS1myaxw8gRU6RxIcdDD3HBtm7pOsOoyC086Zg==} - engines: {node: '>=10'} + '@fvictorio/tabtab@0.0.3': dependencies: debug: 4.3.4(supports-color@8.1.1) enquirer: 2.4.1 @@ -2692,11 +7996,8 @@ packages: untildify: 4.0.0 transitivePeerDependencies: - supports-color - dev: false - /@humanwhocodes/config-array@0.11.14: - resolution: {integrity: sha512-3T8LkOmg45BV5FICb15QQMsyUSWrQ8AygVfC7ZG32zOalnqrilm018ZVCw0eapXux8FtA33q8PSRSstjee3jSg==} - engines: {node: '>=10.10.0'} + '@humanwhocodes/config-array@0.11.14': dependencies: '@humanwhocodes/object-schema': 2.0.3 debug: 4.3.4(supports-color@8.1.1) @@ -2704,120 +8005,78 @@ packages: transitivePeerDependencies: - supports-color - /@humanwhocodes/module-importer@1.0.1: - resolution: {integrity: sha512-bxveV4V8v5Yb4ncFTT3rPSgZBOpCkjfK0y4oVVVJwIuDVBRMDXrPyXRL988i5ap9m9bnyEEjWfm5WkBmtffLfA==} - engines: {node: '>=12.22'} + '@humanwhocodes/module-importer@1.0.1': {} - /@humanwhocodes/object-schema@2.0.3: - resolution: {integrity: sha512-93zYdMES/c1D69yZiKDBj0V24vqNzB/koF26KPaagAfd3P/4gUlh3Dys5ogAK+Exi9QyzlD8x/08Zt7wIKcDcA==} + '@humanwhocodes/object-schema@2.0.3': {} - /@istanbuljs/load-nyc-config@1.1.0: - resolution: {integrity: sha512-VjeHSlIzpv/NyD3N0YuHfXOPDIixcA1q2ZV98wsMqcYlPmv2n3Yb2lYP9XMElnaFVXg5A7YLTeLu6V84uQDjmQ==} - engines: {node: '>=8'} + '@istanbuljs/load-nyc-config@1.1.0': dependencies: camelcase: 5.3.1 find-up: 4.1.0 get-package-type: 0.1.0 js-yaml: 3.14.1 resolve-from: 5.0.0 - dev: true - /@istanbuljs/schema@0.1.3: - resolution: {integrity: sha512-ZXRY4jNvVgSVQ8DL3LTcakaAtXwTVUxE81hslsyD2AtoXW/wVob10HkOJ1X/pAlcI7D+2YoZKg5do8G/w6RYgA==} - engines: {node: '>=8'} - dev: true + '@istanbuljs/schema@0.1.3': {} - /@jest/schemas@29.6.3: - resolution: {integrity: sha512-mo5j5X+jIZmJQveBKeS/clAueipV7KgiX1vMgCxam1RNYiqE1w62n0/tJJnHtjW8ZHcQco5gY85jA3mi0L+nSA==} - engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0} + '@jest/schemas@29.6.3': dependencies: '@sinclair/typebox': 0.27.8 - dev: true - /@jridgewell/gen-mapping@0.3.5: - resolution: {integrity: sha512-IzL8ZoEDIBRWEzlCcRhOaCupYyN5gdIK+Q6fbFdPDg6HqX6jpkItn7DFIpW9LQzXG6Df9sA7+OKnq0qlz/GaQg==} - engines: {node: '>=6.0.0'} + '@jridgewell/gen-mapping@0.3.5': dependencies: '@jridgewell/set-array': 1.2.1 '@jridgewell/sourcemap-codec': 1.4.15 '@jridgewell/trace-mapping': 0.3.25 - dev: true - /@jridgewell/resolve-uri@3.1.2: - resolution: {integrity: sha512-bRISgCIjP20/tbWSPWMEi54QVPRZExkuD9lJL+UIxUKtwVJA8wW1Trb1jMs1RFXo1CBTNZ/5hpC9QvmKWdopKw==} - engines: {node: '>=6.0.0'} - dev: true + '@jridgewell/resolve-uri@3.1.2': {} - /@jridgewell/set-array@1.2.1: - resolution: {integrity: sha512-R8gLRTZeyp03ymzP/6Lil/28tGeGEzhx1q2k703KGWRAI1VdvPIXdG70VJc2pAMw3NA6JKL5hhFu1sJX0Mnn/A==} - engines: {node: '>=6.0.0'} - dev: true + '@jridgewell/set-array@1.2.1': {} - /@jridgewell/sourcemap-codec@1.4.15: - resolution: {integrity: sha512-eF2rxCRulEKXHTRiDrDy6erMYWqNw4LPdQ8UQA4huuxaQsVeRPFl2oM8oDGxMFhJUWZf9McpLtJasDDZb/Bpeg==} - dev: true + '@jridgewell/sourcemap-codec@1.4.15': {} - /@jridgewell/trace-mapping@0.3.25: - resolution: {integrity: sha512-vNk6aEwybGtawWmy/PzwnGDOjCkLWSD2wqvjGGAgOAwCGWySYXfYoxt00IJkTF+8Lb57DwOb3Aa0o9CApepiYQ==} + '@jridgewell/trace-mapping@0.3.25': dependencies: '@jridgewell/resolve-uri': 3.1.2 '@jridgewell/sourcemap-codec': 1.4.15 - dev: true - /@jridgewell/trace-mapping@0.3.9: - resolution: {integrity: sha512-3Belt6tdc8bPgAtbcmdtNJlirVoTmEb5e2gC94PnkwEW9jI6CAHUeoG85tjWP5WquqfavoMtMwiG4P926ZKKuQ==} + '@jridgewell/trace-mapping@0.3.9': dependencies: '@jridgewell/resolve-uri': 3.1.2 '@jridgewell/sourcemap-codec': 1.4.15 - dev: true - /@json-schema-spec/json-pointer@0.1.2: - resolution: {integrity: sha512-BYY7IavBjwsWWSmVcMz2A9mKiDD9RvacnsItgmy1xV8cmgbtxFfKmKMtkVpD7pYtkx4mIW4800yZBXueVFIWPw==} - dev: true + '@json-schema-spec/json-pointer@0.1.2': {} - /@json-schema-tools/dereferencer@1.5.4: - resolution: {integrity: sha512-4cmEdRPIG7WrcSWGRV6HBDCLXEOXGkaOZnopqBxoG24mKYuCHWg4M6N9nioTQyNfKqlPkOPvT4lStQqkPnhLgA==} + '@json-schema-tools/dereferencer@1.5.4': dependencies: '@json-schema-tools/reference-resolver': 1.2.4 '@json-schema-tools/traverse': 1.10.4 fast-safe-stringify: 2.1.1 transitivePeerDependencies: - encoding - dev: true - /@json-schema-tools/meta-schema@1.6.19: - resolution: {integrity: sha512-55zuWFW7tr4tf/G5AYmybcPdGOkVAreQbt2JdnogX4I2r/zkxZiimYPJESDf5je9BI2oRveak2p296HzDppeaA==} - dev: true + '@json-schema-tools/meta-schema@1.6.19': {} - /@json-schema-tools/reference-resolver@1.2.4: - resolution: {integrity: sha512-Oag20zDuapO6nBQp00k8Rd5sDTb8Gfz9uH43Tf7dHKNx7nHDK/WdeTe7OxkOmLQCL6aS+mCJx1Zv+fZBCD+tzQ==} + '@json-schema-tools/reference-resolver@1.2.4': dependencies: '@json-schema-spec/json-pointer': 0.1.2 isomorphic-fetch: 3.0.0 transitivePeerDependencies: - encoding - dev: true - /@json-schema-tools/referencer@1.1.3: - resolution: {integrity: sha512-p2JU7GpHn1kMyP7gnB2Wnki+OnifsSi75Uj5PxqIg2pT4fqh+BM3rEEZKpaET4xv0ZszG46CCI9eEvs68v2rXg==} + '@json-schema-tools/referencer@1.1.3': dependencies: '@json-schema-tools/traverse': 1.10.4 - dev: true - /@json-schema-tools/titleizer@1.0.8: - resolution: {integrity: sha512-xgsg7ghVhd+9ZrhpmakNJUMmp+R+1mB6n4zn4iRg6P47GTfN04L/GR7mjC8LvO+XaZxbIzE6EzvHeZ5+nmhjJA==} + '@json-schema-tools/titleizer@1.0.8': dependencies: '@json-schema-tools/traverse': 1.10.4 - dev: true - /@json-schema-tools/titleizer@1.0.9: - resolution: {integrity: sha512-Gwg3YTP5P+3Q+OnvEcthTnsup3AsEkxZCrRLXoWppdjtSzRnsWxtvmpKdGLbVcocPC7Sh3aqJ7Arp85Ii6q2GA==} + '@json-schema-tools/titleizer@1.0.9': dependencies: '@json-schema-tools/traverse': 1.10.4 - dev: true - /@json-schema-tools/transpiler@1.10.5: - resolution: {integrity: sha512-uRm43U8wKWQV8czvvkJYwcUERpQC+azKmqbd7RhV1gWx7s1t0frLtrWqGbXh9xMcgdtF7+Tkiwex48nW5EnX1w==} + '@json-schema-tools/transpiler@1.10.5': dependencies: '@json-schema-tools/referencer': 1.1.3 '@json-schema-tools/titleizer': 1.0.9 @@ -2826,29 +8085,21 @@ packages: lodash.deburr: 4.1.0 lodash.snakecase: 4.1.1 lodash.trim: 4.5.1 - dev: true - /@json-schema-tools/traverse@1.10.4: - resolution: {integrity: sha512-9e42zjhLIxzBONroNC4SGsTqdB877tzwH2S6lqgTav9K24kWJR9vNieeMVSuyqnY8FlclH21D8wsm/tuD9WA9Q==} - dev: true + '@json-schema-tools/traverse@1.10.4': {} - /@ledgerhq/cryptoassets@9.13.0: - resolution: {integrity: sha512-MzGJyc48OGU/FLYGYwEJyfOgbJzlR8XJ9Oo6XpNpNUM1/E5NDqvD72V0D+0uWIJYN3e2NtyqHXShLZDu7P95YA==} + '@ledgerhq/cryptoassets@9.13.0': dependencies: invariant: 2.2.4 - dev: false - /@ledgerhq/devices@8.3.0: - resolution: {integrity: sha512-h5Scr+yIae8yjPOViCHLdMjpqn4oC2Whrsq8LinRxe48LEGMdPqSV1yY7+3Ch827wtzNpMv+/ilKnd8rY+rTlg==} + '@ledgerhq/devices@8.3.0': dependencies: '@ledgerhq/errors': 6.16.4 '@ledgerhq/logs': 6.12.0 rxjs: 7.8.1 semver: 7.6.2 - dev: false - /@ledgerhq/domain-service@1.1.20(debug@4.3.4): - resolution: {integrity: sha512-+o1cEZj9HkJeIz2eL3r52tzkOiEKMs9w5aXF+Gy4mrmBjQ3Tw0OY9b69b3jz6PjlEHwAZsDRmcvF1/hSW6ITjw==} + '@ledgerhq/domain-service@1.1.20(debug@4.3.4)': dependencies: '@ledgerhq/errors': 6.16.4 '@ledgerhq/logs': 6.12.0 @@ -2859,14 +8110,10 @@ packages: react-dom: 18.3.1(react@18.3.1) transitivePeerDependencies: - debug - dev: false - /@ledgerhq/errors@6.16.4: - resolution: {integrity: sha512-M57yFaLYSN+fZCX0E0zUqOmrV6eipK+s5RhijHoUNlHUqrsvUz7iRQgpd5gRgHB5VkIjav7KdaZjKiWGcHovaQ==} - dev: false + '@ledgerhq/errors@6.16.4': {} - /@ledgerhq/hw-app-eth@6.33.6(debug@4.3.4): - resolution: {integrity: sha512-QzYvr5FNEWWd70Vg04A2i8CY0mtPgJrrX7/KePabjXrR8NjDyJ5Ej8qSQPBTp2dkR4TGiz5Y7+HIcWpdgYzjzg==} + '@ledgerhq/hw-app-eth@6.33.6(debug@4.3.4)': dependencies: '@ethersproject/abi': 5.7.0 '@ethersproject/rlp': 5.7.0 @@ -2881,28 +8128,22 @@ packages: crypto-js: 4.2.0 transitivePeerDependencies: - debug - dev: false - /@ledgerhq/hw-transport-mocker@6.28.6: - resolution: {integrity: sha512-JDO2kqMOTRCQWNZr1KVlyX1AqE6WBzHjJDS3FnSI8Z/Bj2KSc2/1H/4lW6+Ap64yLtlmOW3GchdafFmLgYAgqw==} + '@ledgerhq/hw-transport-mocker@6.28.6': dependencies: '@ledgerhq/hw-transport': 6.30.6 '@ledgerhq/logs': 6.12.0 rxjs: 7.8.1 - dev: false - /@ledgerhq/hw-transport-node-hid-noevents@6.29.6: - resolution: {integrity: sha512-H1cGC4TLwSCxve3rbV7qfPJBZfy7VD7k9Czc9HOMDwQ9zHFtaoeiIotIMGjzHjfPtAGauMpAYvrpmEdBBX5sHg==} + '@ledgerhq/hw-transport-node-hid-noevents@6.29.6': dependencies: '@ledgerhq/devices': 8.3.0 '@ledgerhq/errors': 6.16.4 '@ledgerhq/hw-transport': 6.30.6 '@ledgerhq/logs': 6.12.0 node-hid: 2.2.0 - dev: false - /@ledgerhq/hw-transport-node-hid@6.28.6: - resolution: {integrity: sha512-USSTOO0zv9XtguWismP7/StnNS/s7Rz0JOGGaBhKe3Bzl7d5XPncUlmOvoNFzzY/QdasEoFs2QId1+ibJG71Vw==} + '@ledgerhq/hw-transport-node-hid@6.28.6': dependencies: '@ledgerhq/devices': 8.3.0 '@ledgerhq/errors': 6.16.4 @@ -2912,39 +8153,29 @@ packages: lodash: 4.17.21 node-hid: 2.2.0 usb: 2.9.0 - dev: false - /@ledgerhq/hw-transport@6.30.6: - resolution: {integrity: sha512-fT0Z4IywiuJuZrZE/+W0blkV5UCotDPFTYKLkKCLzYzuE6javva7D/ajRaIeR+hZ4kTmKF4EqnsmDCXwElez+w==} + '@ledgerhq/hw-transport@6.30.6': dependencies: '@ledgerhq/devices': 8.3.0 '@ledgerhq/errors': 6.16.4 '@ledgerhq/logs': 6.12.0 events: 3.3.0 - dev: false - /@ledgerhq/logs@6.12.0: - resolution: {integrity: sha512-ExDoj1QV5eC6TEbMdLUMMk9cfvNKhhv5gXol4SmULRVCx/3iyCPhJ74nsb3S0Vb+/f+XujBEj3vQn5+cwS0fNA==} - dev: false + '@ledgerhq/logs@6.12.0': {} - /@ledgerhq/types-live@6.46.0: - resolution: {integrity: sha512-UtI4qm13wJIv9FB/0g6Hi1NijU7PuJEGetqGQxELlKEOmjubXa52EfKVA9IVOngL25m6U8i7jzluwLsHiN2uQQ==} + '@ledgerhq/types-live@6.46.0': dependencies: bignumber.js: 9.1.2 rxjs: 7.8.1 - dev: false - /@manypkg/find-root@1.1.0: - resolution: {integrity: sha512-mki5uBvhHzO8kYYix/WRy2WX8S3B5wdVSc9D6KcU5lQNglP2yt58/VfLuAK49glRXChosY8ap2oJ1qgma3GUVA==} + '@manypkg/find-root@1.1.0': dependencies: '@babel/runtime': 7.24.5 '@types/node': 12.20.55 find-up: 4.1.0 fs-extra: 8.1.0 - dev: true - /@manypkg/get-packages@1.1.3: - resolution: {integrity: sha512-fo+QhuU3qE/2TQMQmbVMqaQ6EWbMhi4ABWP+O4AM1NqPBuy0OrApV5LO6BrrgnhtAHS2NH6RrVk9OL181tTi8A==} + '@manypkg/get-packages@1.1.3': dependencies: '@babel/runtime': 7.24.5 '@changesets/types': 4.1.0 @@ -2952,103 +8183,60 @@ packages: fs-extra: 8.1.0 globby: 11.1.0 read-yaml-file: 1.1.0 - dev: true - /@metamask/eth-sig-util@4.0.1: - resolution: {integrity: sha512-tghyZKLHZjcdlDqCA3gNZmLeR0XvOE9U1qoQO9ohyAZT6Pya+H9vkBPcsyXytmYLNgVoin7CKCmweo/R43V+tQ==} - engines: {node: '>=12.0.0'} + '@metamask/eth-sig-util@4.0.1': dependencies: ethereumjs-abi: 0.6.8 ethereumjs-util: 6.2.1 ethjs-util: 0.1.6 tweetnacl: 1.0.3 tweetnacl-util: 0.15.1 - dev: false - /@noble/curves@1.2.0: - resolution: {integrity: sha512-oYclrNgRaM9SsBUBVbb8M6DTV7ZHRTKugureoYEncY5c65HOmRzvSiTE3y5CYaPYJA/GVkrhXEoF0M3Ya9PMnw==} + '@noble/curves@1.2.0': dependencies: '@noble/hashes': 1.3.2 - /@noble/curves@1.3.0: - resolution: {integrity: sha512-t01iSXPuN+Eqzb4eBX0S5oubSqXbK/xXa1Ne18Hj8f9pStxztHCE2gfboSp/dZRLSqfuLpRK2nDXDK+W9puocA==} + '@noble/curves@1.3.0': dependencies: '@noble/hashes': 1.3.3 - /@noble/hashes@1.2.0: - resolution: {integrity: sha512-FZfhjEDbT5GRswV3C6uvLPHMiVD6lQBmpoX5+eSiPaMTXte/IKqI5dykDxzZB/WBeK/CDuQRBWarPdi3FNY2zQ==} + '@noble/hashes@1.2.0': {} - /@noble/hashes@1.3.2: - resolution: {integrity: sha512-MVC8EAQp7MvEcm30KWENFjgR+Mkmf+D189XJTkFIlwohU5hcBbn1ZkKq7KVTi2Hme3PMGF390DaL52beVrIihQ==} - engines: {node: '>= 16'} + '@noble/hashes@1.3.2': {} - /@noble/hashes@1.3.3: - resolution: {integrity: sha512-V7/fPHgl+jsVPXqqeOzT8egNj2iBIVt+ECeMMG8TdcnTikP3oaBtUVqpT/gYCR68aEBJSF+XbYUxStjbFMqIIA==} - engines: {node: '>= 16'} + '@noble/hashes@1.3.3': {} - /@noble/hashes@1.4.0: - resolution: {integrity: sha512-V1JJ1WTRUqHHrOSh597hURcMqVKVGL/ea3kv0gSnEdsEZ0/+VyPghM1lMNGc00z7CIQorSvbKpuJkxvuHbvdbg==} - engines: {node: '>= 16'} + '@noble/hashes@1.4.0': {} - /@noble/secp256k1@1.7.1: - resolution: {integrity: sha512-hOUk6AyBFmqVrv7k5WAw/LpszxVbj9gGN4JRkIX52fdFAj1UA61KXmZDvqVEm+pOyec3+fIeZB02LYa/pWOArw==} + '@noble/secp256k1@1.7.1': {} - /@nodelib/fs.scandir@2.1.5: - resolution: {integrity: sha512-vq24Bq3ym5HEQm2NKCr3yXDwjc7vTsEThRDnkp2DK9p1uqLR+DHurm/NOTo0KG7HYHU7eppKZj3MyqYuMBf62g==} - engines: {node: '>= 8'} + '@nodelib/fs.scandir@2.1.5': dependencies: '@nodelib/fs.stat': 2.0.5 run-parallel: 1.2.0 - /@nodelib/fs.stat@2.0.5: - resolution: {integrity: sha512-RkhPPp2zrqDAQA/2jNhnztcPAlv64XdhIp7a7454A5ovI7Bukxgt7MX7udwAu3zg1DcpPU0rz3VV1SeaqvY4+A==} - engines: {node: '>= 8'} + '@nodelib/fs.stat@2.0.5': {} - /@nodelib/fs.walk@1.2.8: - resolution: {integrity: sha512-oGB+UxlgWcgQkgwo8GcEGwemoTFt3FIO9ababBmaGwXIoBKZ+GTy0pP185beGg7Llih/NSHSV2XAs1lnznocSg==} - engines: {node: '>= 8'} + '@nodelib/fs.walk@1.2.8': dependencies: '@nodelib/fs.scandir': 2.1.5 fastq: 1.17.1 - /@nomicfoundation/edr-darwin-arm64@0.3.8: - resolution: {integrity: sha512-eB0leCexS8sQEmfyD72cdvLj9djkBzQGP4wSQw6SNf2I4Sw4Cnzb3d45caG2FqFFjbvfqL0t+badUUIceqQuMw==} - engines: {node: '>= 18'} - dev: false + '@nomicfoundation/edr-darwin-arm64@0.3.8': {} - /@nomicfoundation/edr-darwin-x64@0.3.8: - resolution: {integrity: sha512-JksVCS1N5ClwVF14EvO25HCQ+Laljh/KRfHERMVAC9ZwPbTuAd/9BtKvToCBi29uCHWqsXMI4lxCApYQv2nznw==} - engines: {node: '>= 18'} - dev: false + '@nomicfoundation/edr-darwin-x64@0.3.8': {} - /@nomicfoundation/edr-linux-arm64-gnu@0.3.8: - resolution: {integrity: sha512-raCE+fOeNXhVBLUo87cgsHSGvYYRB6arih4eG6B9KGACWK5Veebtm9xtKeiD8YCsdUlUfat6F7ibpeNm91fpsA==} - engines: {node: '>= 18'} - dev: false + '@nomicfoundation/edr-linux-arm64-gnu@0.3.8': {} - /@nomicfoundation/edr-linux-arm64-musl@0.3.8: - resolution: {integrity: sha512-PwiDp4wBZWMCIy29eKkv8moTKRrpiSDlrc+GQMSZLhOAm8T33JKKXPwD/2EbplbhCygJDGXZdtEKl9x9PaH66A==} - engines: {node: '>= 18'} - dev: false + '@nomicfoundation/edr-linux-arm64-musl@0.3.8': {} - /@nomicfoundation/edr-linux-x64-gnu@0.3.8: - resolution: {integrity: sha512-6AcvA/XKoipGap5jJmQ9Y6yT7Uf39D9lu2hBcDCXnXbMcXaDGw4mn1/L4R63D+9VGZyu1PqlcJixCUZlGGIWlg==} - engines: {node: '>= 18'} - dev: false + '@nomicfoundation/edr-linux-x64-gnu@0.3.8': {} - /@nomicfoundation/edr-linux-x64-musl@0.3.8: - resolution: {integrity: sha512-cxb0sEmZjlwhYWO28sPsV64VDx31ekskhC1IsDXU1p9ntjHSJRmW4KEIqJ2O3QwJap/kLKfMS6TckvY10gjc6w==} - engines: {node: '>= 18'} - dev: false + '@nomicfoundation/edr-linux-x64-musl@0.3.8': {} - /@nomicfoundation/edr-win32-x64-msvc@0.3.8: - resolution: {integrity: sha512-yVuVPqRRNLZk7TbBMkKw7lzCvI8XO8fNTPTYxymGadjr9rEGRuNTU1yBXjfJ59I1jJU/X2TSkRk1OFX0P5tpZQ==} - engines: {node: '>= 18'} - dev: false + '@nomicfoundation/edr-win32-x64-msvc@0.3.8': {} - /@nomicfoundation/edr@0.3.8: - resolution: {integrity: sha512-u2UJ5QpznSHVkZRh6ePWoeVb6kmPrrqh08gCnZ9FHlJV9CITqlrTQHJkacd+INH31jx88pTAJnxePE4XAiH5qg==} - engines: {node: '>= 18'} + '@nomicfoundation/edr@0.3.8': dependencies: '@nomicfoundation/edr-darwin-arm64': 0.3.8 '@nomicfoundation/edr-darwin-x64': 0.3.8 @@ -3057,11 +8245,8 @@ packages: '@nomicfoundation/edr-linux-x64-gnu': 0.3.8 '@nomicfoundation/edr-linux-x64-musl': 0.3.8 '@nomicfoundation/edr-win32-x64-msvc': 0.3.8 - dev: false - /@nomicfoundation/ethereumjs-block@5.0.4: - resolution: {integrity: sha512-AcyacJ9eX/uPEvqsPiB+WO1ymE+kyH48qGGiGV+YTojdtas8itUTW5dehDSOXEEItWGbbzEJ4PRqnQZlWaPvDw==} - engines: {node: '>=18'} + '@nomicfoundation/ethereumjs-block@5.0.4': dependencies: '@nomicfoundation/ethereumjs-common': 4.0.4 '@nomicfoundation/ethereumjs-rlp': 5.0.4 @@ -3071,23 +8256,16 @@ packages: ethereum-cryptography: 0.1.3 transitivePeerDependencies: - c-kzg - dev: true - /@nomicfoundation/ethereumjs-common@4.0.4: - resolution: {integrity: sha512-9Rgb658lcWsjiicr5GzNCjI1llow/7r0k50dLL95OJ+6iZJcVbi15r3Y0xh2cIO+zgX0WIHcbzIu6FeQf9KPrg==} + '@nomicfoundation/ethereumjs-common@4.0.4': dependencies: '@nomicfoundation/ethereumjs-util': 9.0.4 transitivePeerDependencies: - c-kzg - /@nomicfoundation/ethereumjs-rlp@5.0.4: - resolution: {integrity: sha512-8H1S3s8F6QueOc/X92SdrA4RDenpiAEqMg5vJH99kcQaCy/a3Q6fgseo75mgWlbanGJXSlAPtnCeG9jvfTYXlw==} - engines: {node: '>=18'} - hasBin: true + '@nomicfoundation/ethereumjs-rlp@5.0.4': {} - /@nomicfoundation/ethereumjs-trie@6.0.4: - resolution: {integrity: sha512-3nSwQiFMvr2VFe/aZUyinuohYvtytUqZCUCvIWcPJ/BwJH6oQdZRB42aNFBJ/8nAh2s3OcroWpBLskzW01mFKA==} - engines: {node: '>=18'} + '@nomicfoundation/ethereumjs-trie@6.0.4': dependencies: '@nomicfoundation/ethereumjs-rlp': 5.0.4 '@nomicfoundation/ethereumjs-util': 9.0.4 @@ -3097,74 +8275,39 @@ packages: readable-stream: 3.6.2 transitivePeerDependencies: - c-kzg - dev: true - /@nomicfoundation/ethereumjs-tx@5.0.4: - resolution: {integrity: sha512-Xjv8wAKJGMrP1f0n2PeyfFCCojHd7iS3s/Ab7qzF1S64kxZ8Z22LCMynArYsVqiFx6rzYy548HNVEyI+AYN/kw==} - engines: {node: '>=18'} - peerDependencies: - c-kzg: ^2.1.2 - peerDependenciesMeta: - c-kzg: - optional: true + '@nomicfoundation/ethereumjs-tx@5.0.4': dependencies: '@nomicfoundation/ethereumjs-common': 4.0.4 '@nomicfoundation/ethereumjs-rlp': 5.0.4 '@nomicfoundation/ethereumjs-util': 9.0.4 ethereum-cryptography: 0.1.3 - /@nomicfoundation/ethereumjs-util@9.0.4: - resolution: {integrity: sha512-sLOzjnSrlx9Bb9EFNtHzK/FJFsfg2re6bsGqinFinH1gCqVfz9YYlXiMWwDM4C/L4ywuHFCYwfKTVr/QHQcU0Q==} - engines: {node: '>=18'} - peerDependencies: - c-kzg: ^2.1.2 - peerDependenciesMeta: - c-kzg: - optional: true + '@nomicfoundation/ethereumjs-util@9.0.4': dependencies: '@nomicfoundation/ethereumjs-rlp': 5.0.4 ethereum-cryptography: 0.1.3 - /@nomicfoundation/hardhat-ignition-ethers@0.15.2(@nomicfoundation/hardhat-ethers@packages+hardhat-ethers)(@nomicfoundation/hardhat-ignition@0.15.2)(@nomicfoundation/ignition-core@0.15.2)(ethers@6.12.1)(hardhat@packages+hardhat-core): - resolution: {integrity: sha512-rXkEpzl4ZNGfrht6ZFO+37dQvL+byrJaX7pNeSFzdKKqhEe4oboRwDWaBohQO+pCn837Qh/86xwwOFoGEv2+hg==} - peerDependencies: - '@nomicfoundation/hardhat-ethers': ^3.0.4 - '@nomicfoundation/hardhat-ignition': ^0.15.2 - '@nomicfoundation/ignition-core': ^0.15.2 - ethers: ^6.7.0 - hardhat: ^2.18.0 + '@nomicfoundation/hardhat-ignition-ethers@0.15.2(@nomicfoundation/hardhat-ethers@packages+hardhat-ethers)(@nomicfoundation/hardhat-ignition@0.15.2(@nomicfoundation/hardhat-verify@packages+hardhat-verify)(bufferutil@4.0.8)(hardhat@packages+hardhat-core)(utf-8-validate@5.0.10))(@nomicfoundation/ignition-core@0.15.2(bufferutil@4.0.8)(utf-8-validate@5.0.10))(ethers@6.12.1(bufferutil@4.0.8)(utf-8-validate@5.0.10))(hardhat@packages+hardhat-core)': dependencies: '@nomicfoundation/hardhat-ethers': link:packages/hardhat-ethers - '@nomicfoundation/hardhat-ignition': 0.15.2(@nomicfoundation/hardhat-verify@packages+hardhat-verify)(hardhat@packages+hardhat-core) - '@nomicfoundation/ignition-core': 0.15.2 - ethers: 6.12.1 + '@nomicfoundation/hardhat-ignition': 0.15.2(@nomicfoundation/hardhat-verify@packages+hardhat-verify)(bufferutil@4.0.8)(hardhat@packages+hardhat-core)(utf-8-validate@5.0.10) + '@nomicfoundation/ignition-core': 0.15.2(bufferutil@4.0.8)(utf-8-validate@5.0.10) + ethers: 6.12.1(bufferutil@4.0.8)(utf-8-validate@5.0.10) hardhat: link:packages/hardhat-core - dev: true - /@nomicfoundation/hardhat-ignition-viem@0.15.2(@nomicfoundation/hardhat-ignition@0.15.2)(@nomicfoundation/hardhat-viem@packages+hardhat-viem)(@nomicfoundation/ignition-core@0.15.2)(hardhat@packages+hardhat-core)(viem@2.10.3): - resolution: {integrity: sha512-iYmw9vJLXY1Tum0idnNsrsEmuvHsRDVJcudgzaMY6sA2nLLhJDSReK2gVZdtx3rdfJz4QRhG2+h2s3T+Rzv0TQ==} - peerDependencies: - '@nomicfoundation/hardhat-ignition': ^0.15.2 - '@nomicfoundation/hardhat-viem': ^2.0.0 - '@nomicfoundation/ignition-core': ^0.15.2 - hardhat: ^2.18.0 - viem: ^2.7.6 + '@nomicfoundation/hardhat-ignition-viem@0.15.2(@nomicfoundation/hardhat-ignition@0.15.2(@nomicfoundation/hardhat-verify@packages+hardhat-verify)(bufferutil@4.0.8)(hardhat@packages+hardhat-core)(utf-8-validate@5.0.10))(@nomicfoundation/hardhat-viem@packages+hardhat-viem)(@nomicfoundation/ignition-core@0.15.2(bufferutil@4.0.8)(utf-8-validate@5.0.10))(hardhat@packages+hardhat-core)(viem@2.10.3(bufferutil@4.0.8)(typescript@5.0.4)(utf-8-validate@5.0.10)(zod@3.23.8))': dependencies: - '@nomicfoundation/hardhat-ignition': 0.15.2(@nomicfoundation/hardhat-verify@packages+hardhat-verify)(hardhat@packages+hardhat-core) + '@nomicfoundation/hardhat-ignition': 0.15.2(@nomicfoundation/hardhat-verify@packages+hardhat-verify)(bufferutil@4.0.8)(hardhat@packages+hardhat-core)(utf-8-validate@5.0.10) '@nomicfoundation/hardhat-viem': link:packages/hardhat-viem - '@nomicfoundation/ignition-core': 0.15.2 + '@nomicfoundation/ignition-core': 0.15.2(bufferutil@4.0.8)(utf-8-validate@5.0.10) hardhat: link:packages/hardhat-core - viem: 2.10.3(typescript@5.0.4) - dev: true + viem: 2.10.3(bufferutil@4.0.8)(typescript@5.0.4)(utf-8-validate@5.0.10)(zod@3.23.8) - /@nomicfoundation/hardhat-ignition@0.15.2(@nomicfoundation/hardhat-verify@packages+hardhat-verify)(hardhat@packages+hardhat-core): - resolution: {integrity: sha512-tdI+D+GwP8qBt3/sq0hGKk46lAfKnNj3ZtqxrNinOnQUfc3f9qXgZDFqWT2JudsmuQcuHFbn1FQ1zoDvjUVjRA==} - peerDependencies: - '@nomicfoundation/hardhat-verify': ^2.0.1 - hardhat: ^2.18.0 + '@nomicfoundation/hardhat-ignition@0.15.2(@nomicfoundation/hardhat-verify@packages+hardhat-verify)(bufferutil@4.0.8)(hardhat@packages+hardhat-core)(utf-8-validate@5.0.10)': dependencies: '@nomicfoundation/hardhat-verify': link:packages/hardhat-verify - '@nomicfoundation/ignition-core': 0.15.2 + '@nomicfoundation/ignition-core': 0.15.2(bufferutil@4.0.8)(utf-8-validate@5.0.10) '@nomicfoundation/ignition-ui': 0.15.2 chalk: 4.1.2 debug: 4.3.4(supports-color@8.1.1) @@ -3175,16 +8318,14 @@ packages: - bufferutil - supports-color - utf-8-validate - dev: true - /@nomicfoundation/ignition-core@0.15.2: - resolution: {integrity: sha512-6kchZOBh6zSl0BgG1bs6+ZbNYlGjeH22yi72mgeOa0oNOYFqCpka9a4FEYv0gfcphsMMmKTMlxadanf02ZoE4w==} + '@nomicfoundation/ignition-core@0.15.2(bufferutil@4.0.8)(utf-8-validate@5.0.10)': dependencies: '@ethersproject/address': 5.6.1 '@nomicfoundation/solidity-analyzer': 0.1.1 cbor: 9.0.2 debug: 4.3.4(supports-color@8.1.1) - ethers: 6.12.1 + ethers: 6.12.1(bufferutil@4.0.8)(utf-8-validate@5.0.10) fs-extra: 10.1.0 immer: 10.0.2 lodash: 4.17.21 @@ -3193,95 +8334,40 @@ packages: - bufferutil - supports-color - utf-8-validate - dev: true - /@nomicfoundation/ignition-ui@0.15.2: - resolution: {integrity: sha512-NEX2prbfLEm45KbnBS0imvSgQgwLTgmT8zD3rAPmcIFZx+tLG4lKKw99k6EgEwmKwBiaO2zQMmt+FNoF7xGaiQ==} - dev: true + '@nomicfoundation/ignition-ui@0.15.2': {} - /@nomicfoundation/solidity-analyzer-darwin-arm64@0.1.1: - resolution: {integrity: sha512-KcTodaQw8ivDZyF+D76FokN/HdpgGpfjc/gFCImdLUyqB6eSWVaZPazMbeAjmfhx3R0zm/NYVzxwAokFKgrc0w==} - engines: {node: '>= 10'} - cpu: [arm64] - os: [darwin] - requiresBuild: true + '@nomicfoundation/solidity-analyzer-darwin-arm64@0.1.1': optional: true - /@nomicfoundation/solidity-analyzer-darwin-x64@0.1.1: - resolution: {integrity: sha512-XhQG4BaJE6cIbjAVtzGOGbK3sn1BO9W29uhk9J8y8fZF1DYz0Doj8QDMfpMu+A6TjPDs61lbsmeYodIDnfveSA==} - engines: {node: '>= 10'} - cpu: [x64] - os: [darwin] - requiresBuild: true + '@nomicfoundation/solidity-analyzer-darwin-x64@0.1.1': optional: true - /@nomicfoundation/solidity-analyzer-freebsd-x64@0.1.1: - resolution: {integrity: sha512-GHF1VKRdHW3G8CndkwdaeLkVBi5A9u2jwtlS7SLhBc8b5U/GcoL39Q+1CSO3hYqePNP+eV5YI7Zgm0ea6kMHoA==} - engines: {node: '>= 10'} - cpu: [x64] - os: [freebsd] - requiresBuild: true + '@nomicfoundation/solidity-analyzer-freebsd-x64@0.1.1': optional: true - /@nomicfoundation/solidity-analyzer-linux-arm64-gnu@0.1.1: - resolution: {integrity: sha512-g4Cv2fO37ZsUENQ2vwPnZc2zRenHyAxHcyBjKcjaSmmkKrFr64yvzeNO8S3GBFCo90rfochLs99wFVGT/0owpg==} - engines: {node: '>= 10'} - cpu: [arm64] - os: [linux] - requiresBuild: true + '@nomicfoundation/solidity-analyzer-linux-arm64-gnu@0.1.1': optional: true - /@nomicfoundation/solidity-analyzer-linux-arm64-musl@0.1.1: - resolution: {integrity: sha512-WJ3CE5Oek25OGE3WwzK7oaopY8xMw9Lhb0mlYuJl/maZVo+WtP36XoQTb7bW/i8aAdHW5Z+BqrHMux23pvxG3w==} - engines: {node: '>= 10'} - cpu: [arm64] - os: [linux] - requiresBuild: true + '@nomicfoundation/solidity-analyzer-linux-arm64-musl@0.1.1': optional: true - /@nomicfoundation/solidity-analyzer-linux-x64-gnu@0.1.1: - resolution: {integrity: sha512-5WN7leSr5fkUBBjE4f3wKENUy9HQStu7HmWqbtknfXkkil+eNWiBV275IOlpXku7v3uLsXTOKpnnGHJYI2qsdA==} - engines: {node: '>= 10'} - cpu: [x64] - os: [linux] - requiresBuild: true + '@nomicfoundation/solidity-analyzer-linux-x64-gnu@0.1.1': optional: true - /@nomicfoundation/solidity-analyzer-linux-x64-musl@0.1.1: - resolution: {integrity: sha512-KdYMkJOq0SYPQMmErv/63CwGwMm5XHenEna9X9aB8mQmhDBrYrlAOSsIPgFCUSL0hjxE3xHP65/EPXR/InD2+w==} - engines: {node: '>= 10'} - cpu: [x64] - os: [linux] - requiresBuild: true + '@nomicfoundation/solidity-analyzer-linux-x64-musl@0.1.1': optional: true - /@nomicfoundation/solidity-analyzer-win32-arm64-msvc@0.1.1: - resolution: {integrity: sha512-VFZASBfl4qiBYwW5xeY20exWhmv6ww9sWu/krWSesv3q5hA0o1JuzmPHR4LPN6SUZj5vcqci0O6JOL8BPw+APg==} - engines: {node: '>= 10'} - cpu: [arm64] - os: [win32] - requiresBuild: true + '@nomicfoundation/solidity-analyzer-win32-arm64-msvc@0.1.1': optional: true - /@nomicfoundation/solidity-analyzer-win32-ia32-msvc@0.1.1: - resolution: {integrity: sha512-JnFkYuyCSA70j6Si6cS1A9Gh1aHTEb8kOTBApp/c7NRTFGNMH8eaInKlyuuiIbvYFhlXW4LicqyYuWNNq9hkpQ==} - engines: {node: '>= 10'} - cpu: [ia32] - os: [win32] - requiresBuild: true + '@nomicfoundation/solidity-analyzer-win32-ia32-msvc@0.1.1': optional: true - /@nomicfoundation/solidity-analyzer-win32-x64-msvc@0.1.1: - resolution: {integrity: sha512-HrVJr6+WjIXGnw3Q9u6KQcbZCtk0caVWhCdFADySvRyUxJ8PnzlaP+MhwNE8oyT8OZ6ejHBRrrgjSqDCFXGirw==} - engines: {node: '>= 10'} - cpu: [x64] - os: [win32] - requiresBuild: true + '@nomicfoundation/solidity-analyzer-win32-x64-msvc@0.1.1': optional: true - /@nomicfoundation/solidity-analyzer@0.1.1: - resolution: {integrity: sha512-1LMtXj1puAxyFusBgUIy5pZk3073cNXYnXUpuNKFghHbIit/xZgbk0AokpUADbNm3gyD6bFWl3LRFh3dhVdREg==} - engines: {node: '>= 12'} + '@nomicfoundation/solidity-analyzer@0.1.1': optionalDependencies: '@nomicfoundation/solidity-analyzer-darwin-arm64': 0.1.1 '@nomicfoundation/solidity-analyzer-darwin-x64': 0.1.1 @@ -3294,43 +8380,32 @@ packages: '@nomicfoundation/solidity-analyzer-win32-ia32-msvc': 0.1.1 '@nomicfoundation/solidity-analyzer-win32-x64-msvc': 0.1.1 - /@nomiclabs/truffle-contract@4.5.10(web3-core-helpers@1.10.3)(web3-core-promievent@1.10.3)(web3-eth-abi@1.10.4)(web3-utils@1.10.4)(web3@1.10.4): - resolution: {integrity: sha512-nF/6InFV+0hUvutyFgsdOMCoYlr//2fJbRER4itxYtQtc4/O1biTwZIKRu+5l2J5Sq6LU2WX7vZHtDgQdhWxIQ==} - peerDependencies: - web3: ^1.2.1 - web3-core-helpers: ^1.2.1 - web3-core-promievent: ^1.2.1 - web3-eth-abi: ^1.2.1 - web3-utils: ^1.2.1 + '@nomiclabs/truffle-contract@4.5.10(bufferutil@4.0.8)(utf-8-validate@5.0.10)(web3-core-helpers@1.10.4)(web3-core-promievent@1.10.4)(web3-eth-abi@4.2.1(typescript@5.0.4)(zod@3.23.8))(web3-utils@4.2.3)(web3@1.10.4(bufferutil@4.0.8)(utf-8-validate@5.0.10))': dependencies: - '@ensdomains/ensjs': 2.1.0 + '@ensdomains/ensjs': 2.1.0(bufferutil@4.0.8)(utf-8-validate@5.0.10) '@truffle/blockchain-utils': 0.1.9 '@truffle/contract-schema': 3.4.16 '@truffle/debug-utils': 6.0.57 '@truffle/error': 0.1.1 - '@truffle/interface-adapter': 0.5.37 + '@truffle/interface-adapter': 0.5.37(bufferutil@4.0.8)(utf-8-validate@5.0.10) bignumber.js: 7.2.1 - ethereum-ens: 0.8.0 + ethereum-ens: 0.8.0(bufferutil@4.0.8)(utf-8-validate@5.0.10) ethers: 4.0.49 source-map-support: 0.5.21 - web3: 1.10.4 - web3-core-helpers: 1.10.3 - web3-core-promievent: 1.10.3 - web3-eth-abi: 1.10.4 - web3-utils: 1.10.4 + web3: 1.10.4(bufferutil@4.0.8)(utf-8-validate@5.0.10) + web3-core-helpers: 1.10.4 + web3-core-promievent: 1.10.4 + web3-eth-abi: 4.2.1(typescript@5.0.4)(zod@3.23.8) + web3-utils: 4.2.3 transitivePeerDependencies: - bufferutil - encoding - supports-color - utf-8-validate - dev: false - /@open-rpc/meta-schema@1.14.2: - resolution: {integrity: sha512-vD4Nbkrb7wYFRcSQf+j228LwOy1C6/KKpy5NADlpMElGrAWPRxhTa2yTi6xG+x88OHzg2+cydQ0GAD6o40KUcg==} - dev: true + '@open-rpc/meta-schema@1.14.2': {} - /@open-rpc/schema-utils-js@1.16.1: - resolution: {integrity: sha512-8D4OgBnHDAv7JeaYZ5v7SL4yR0YLLO4WLTWtdR8vmqSqvX3SvPzSsGYv06zqm9z1Lhm563MAcuearrc8g9eJ4w==} + '@open-rpc/schema-utils-js@1.16.1': dependencies: '@json-schema-tools/dereferencer': 1.5.4 '@json-schema-tools/meta-schema': 1.6.19 @@ -3344,11 +8419,8 @@ packages: isomorphic-fetch: 3.0.0 transitivePeerDependencies: - encoding - dev: true - /@open-rpc/typings@1.12.3: - resolution: {integrity: sha512-YxoC0WBMmxOAYNk9T6sFlOsy2H3YNnXJKFwkRb5GWg1ixOOEFm/3AYOciI/4Ieq08xNzjPhIz6XfC4u4fsmAWg==} - hasBin: true + '@open-rpc/typings@1.12.3': dependencies: '@json-schema-tools/titleizer': 1.0.8 '@json-schema-tools/transpiler': 1.10.5 @@ -3357,84 +8429,63 @@ packages: fs-extra: 10.1.0 transitivePeerDependencies: - encoding - dev: true - /@scure/base@1.1.6: - resolution: {integrity: sha512-ok9AWwhcgYuGG3Zfhyqg+zwl+Wn5uE+dwC0NV/2qQkx4dABbb/bx96vWu8NSj+BNjjSjno+JRYRjle1jV08k3g==} + '@scure/base@1.1.6': {} - /@scure/bip32@1.1.5: - resolution: {integrity: sha512-XyNh1rB0SkEqd3tXcXMi+Xe1fvg+kUIcoRIEujP1Jgv7DqW2r9lg3Ah0NkFaCs9sTkQAQA8kw7xiRXzENi9Rtw==} + '@scure/bip32@1.1.5': dependencies: '@noble/hashes': 1.2.0 '@noble/secp256k1': 1.7.1 '@scure/base': 1.1.6 - /@scure/bip32@1.3.2: - resolution: {integrity: sha512-N1ZhksgwD3OBlwTv3R6KFEcPojl/W4ElJOeCZdi+vuI5QmTFwLq3OFf2zd2ROpKvxFdgZ6hUpb0dx9bVNEwYCA==} + '@scure/bip32@1.3.2': dependencies: '@noble/curves': 1.2.0 - '@noble/hashes': 1.3.2 + '@noble/hashes': 1.3.3 '@scure/base': 1.1.6 - dev: true - /@scure/bip32@1.3.3: - resolution: {integrity: sha512-LJaN3HwRbfQK0X1xFSi0Q9amqOgzQnnDngIt+ZlsBC3Bm7/nE7K0kwshZHyaru79yIVRv/e1mQAjZyuZG6jOFQ==} + '@scure/bip32@1.3.3': dependencies: '@noble/curves': 1.3.0 '@noble/hashes': 1.3.3 '@scure/base': 1.1.6 - /@scure/bip39@1.1.1: - resolution: {integrity: sha512-t+wDck2rVkh65Hmv280fYdVdY25J9YeEUIgn2LG1WM6gxFkGzcksoDiUkWVpVp3Oex9xGC68JU2dSbUfwZ2jPg==} + '@scure/bip39@1.1.1': dependencies: '@noble/hashes': 1.2.0 '@scure/base': 1.1.6 - /@scure/bip39@1.2.1: - resolution: {integrity: sha512-Z3/Fsz1yr904dduJD0NpiyRHhRYHdcnyh73FZWiV+/qhWi83wNJ3NWolYqCEN+ZWsUz2TWwajJggcRE9r1zUYg==} + '@scure/bip39@1.2.1': dependencies: - '@noble/hashes': 1.3.2 + '@noble/hashes': 1.3.3 '@scure/base': 1.1.6 - dev: true - /@scure/bip39@1.2.2: - resolution: {integrity: sha512-HYf9TUXG80beW+hGAt3TRM8wU6pQoYur9iNypTROm42dorCGmLnFe3eWjz3gOq6G62H2WRh0FCzAR1PI+29zIA==} + '@scure/bip39@1.2.2': dependencies: '@noble/hashes': 1.3.3 '@scure/base': 1.1.6 - /@sentry/core@5.30.0: - resolution: {integrity: sha512-TmfrII8w1PQZSZgPpUESqjB+jC6MvZJZdLtE/0hZ+SrnKhW3x5WlYLvTXZpcWePYBku7rl2wn1RZu6uT0qCTeg==} - engines: {node: '>=6'} + '@sentry/core@5.30.0': dependencies: '@sentry/hub': 5.30.0 '@sentry/minimal': 5.30.0 '@sentry/types': 5.30.0 '@sentry/utils': 5.30.0 tslib: 1.14.1 - dev: false - /@sentry/hub@5.30.0: - resolution: {integrity: sha512-2tYrGnzb1gKz2EkMDQcfLrDTvmGcQPuWxLnJKXJvYTQDGLlEvi2tWz1VIHjunmOvJrB5aIQLhm+dcMRwFZDCqQ==} - engines: {node: '>=6'} + '@sentry/hub@5.30.0': dependencies: '@sentry/types': 5.30.0 '@sentry/utils': 5.30.0 tslib: 1.14.1 - dev: false - /@sentry/minimal@5.30.0: - resolution: {integrity: sha512-BwWb/owZKtkDX+Sc4zCSTNcvZUq7YcH3uAVlmh/gtR9rmUvbzAA3ewLuB3myi4wWRAMEtny6+J/FN/x+2wn9Xw==} - engines: {node: '>=6'} + '@sentry/minimal@5.30.0': dependencies: '@sentry/hub': 5.30.0 '@sentry/types': 5.30.0 tslib: 1.14.1 - dev: false - /@sentry/node@5.30.0: - resolution: {integrity: sha512-Br5oyVBF0fZo6ZS9bxbJZG4ApAjRqAnqFFurMVJJdunNb80brh7a5Qva2kjhm+U6r9NJAB5OmDyPkA1Qnt+QVg==} - engines: {node: '>=6'} + '@sentry/node@5.30.0': dependencies: '@sentry/core': 5.30.0 '@sentry/hub': 5.30.0 @@ -3447,112 +8498,69 @@ packages: tslib: 1.14.1 transitivePeerDependencies: - supports-color - dev: false - /@sentry/tracing@5.30.0: - resolution: {integrity: sha512-dUFowCr0AIMwiLD7Fs314Mdzcug+gBVo/+NCMyDw8tFxJkwWAKl7Qa2OZxLQ0ZHjakcj1hNKfCQJ9rhyfOl4Aw==} - engines: {node: '>=6'} + '@sentry/tracing@5.30.0': dependencies: '@sentry/hub': 5.30.0 '@sentry/minimal': 5.30.0 '@sentry/types': 5.30.0 '@sentry/utils': 5.30.0 tslib: 1.14.1 - dev: false - /@sentry/types@5.30.0: - resolution: {integrity: sha512-R8xOqlSTZ+htqrfteCWU5Nk0CDN5ApUTvrlvBuiH1DyP6czDZ4ktbZB0hAgBlVcK0U+qpD3ag3Tqqpa5Q67rPw==} - engines: {node: '>=6'} - dev: false + '@sentry/types@5.30.0': {} - /@sentry/utils@5.30.0: - resolution: {integrity: sha512-zaYmoH0NWWtvnJjC9/CBseXMtKHm/tm40sz3YfJRxeQjyzRqNQPgivpd9R/oDJCYj999mzdW382p/qi2ypjLww==} - engines: {node: '>=6'} + '@sentry/utils@5.30.0': dependencies: '@sentry/types': 5.30.0 tslib: 1.14.1 - dev: false - /@sinclair/typebox@0.27.8: - resolution: {integrity: sha512-+Fj43pSMwJs4KRrH/938Uf+uAELIgVBmQzg/q1YG10djyfA3TnrU8N8XzqCh/okZdszqBQTZf96idMfE5lnwTA==} - dev: true + '@sinclair/typebox@0.27.8': {} - /@sindresorhus/is@4.6.0: - resolution: {integrity: sha512-t09vSN3MdfsyCHoFcTRCH/iUtG7OJ0CsjzB8cjAmKc/va/kIgeDI/TxsigdncE/4be734m0cvIYwNaV4i2XqAw==} - engines: {node: '>=10'} + '@sindresorhus/is@4.6.0': {} - /@sinonjs/commons@1.8.6: - resolution: {integrity: sha512-Ky+XkAkqPZSm3NLBeUng77EBQl3cmeJhITaGHdYH8kjVB+aun3S4XBRti2zt17mtt0mIUDiNxYeoJm6drVvBJQ==} + '@sinonjs/commons@1.8.6': dependencies: type-detect: 4.0.8 - dev: true - /@sinonjs/fake-timers@6.0.1: - resolution: {integrity: sha512-MZPUxrmFubI36XS1DI3qmI0YdN1gks62JtFZvxR67ljjSNCeK6U08Zx4msEWOXuofgqUt6zPHSi1H9fbjR/NRA==} + '@sinonjs/fake-timers@6.0.1': dependencies: '@sinonjs/commons': 1.8.6 - dev: true - /@sinonjs/samsam@5.3.1: - resolution: {integrity: sha512-1Hc0b1TtyfBu8ixF/tpfSHTVWKwCBLY4QJbkgnE7HcwyvT2xArDxb4K7dMgqRm3szI+LJbzmW/s4xxEhv6hwDg==} + '@sinonjs/samsam@5.3.1': dependencies: '@sinonjs/commons': 1.8.6 lodash.get: 4.4.2 type-detect: 4.0.8 - dev: true - /@sinonjs/text-encoding@0.7.2: - resolution: {integrity: sha512-sXXKG+uL9IrKqViTtao2Ws6dy0znu9sOaP1di/jKGW1M6VssO8vlpXCQcpZ+jisQ1tTFAC5Jo/EOzFbggBagFQ==} - dev: true + '@sinonjs/text-encoding@0.7.2': {} - /@solidity-parser/parser@0.14.5: - resolution: {integrity: sha512-6dKnHZn7fg/iQATVEzqyUOyEidbn05q7YA2mQ9hC0MMXhhV3/JrsxmFSYZAcr7j1yUP700LLhTruvJ3MiQmjJg==} + '@solidity-parser/parser@0.14.5': dependencies: antlr4ts: 0.5.0-alpha.4 - dev: true - /@solidity-parser/parser@0.16.2: - resolution: {integrity: sha512-PI9NfoA3P8XK2VBkK5oIfRgKDsicwDZfkVq9ZTBCQYGOP1N2owgY2dyLGyU5/J/hQs8KRk55kdmvTLjy3Mu3vg==} + '@solidity-parser/parser@0.16.2': dependencies: antlr4ts: 0.5.0-alpha.4 - dev: false - /@solidity-parser/parser@0.18.0: - resolution: {integrity: sha512-yfORGUIPgLck41qyN7nbwJRAx17/jAIXCTanHOJZhB6PJ1iAk/84b/xlsVKFSyNyLXIj0dhppoE0+CRws7wlzA==} - dev: true + '@solidity-parser/parser@0.18.0': {} - /@szmarczak/http-timer@4.0.6: - resolution: {integrity: sha512-4BAffykYOgO+5nzBWYwE3W90sBgLJoUPRWWcL8wlyiM8IB8ipJz3UMJ9KXQd1RKQXpKp8Tutn80HZtWsu2u76w==} - engines: {node: '>=10'} + '@szmarczak/http-timer@4.0.6': dependencies: defer-to-connect: 2.0.1 - /@szmarczak/http-timer@5.0.1: - resolution: {integrity: sha512-+PmQX0PiAYPMeVYe237LJAYvOMYW1j2rH5YROyS3b4CTVJum34HfRvKvAzozHAQG0TnHNdUfY9nCeUyRAs//cw==} - engines: {node: '>=14.16'} + '@szmarczak/http-timer@5.0.1': dependencies: defer-to-connect: 2.0.1 - /@truffle/abi-utils@1.0.3: - resolution: {integrity: sha512-AWhs01HCShaVKjml7Z4AbVREr/u4oiWxCcoR7Cktm0mEvtT04pvnxW5xB/cI4znRkrbPdFQlFt67kgrAjesYkw==} - engines: {node: ^16.20 || ^18.16 || >=20} - deprecated: Package no longer supported. Contact Support at https://www.npmjs.com/support for more info. + '@truffle/abi-utils@1.0.3': dependencies: change-case: 3.0.2 fast-check: 3.1.1 web3-utils: 1.10.0 - dev: false - /@truffle/blockchain-utils@0.1.9: - resolution: {integrity: sha512-RHfumgbIVo68Rv9ofDYfynjnYZIfP/f1vZy4RoqkfYAO+fqfc58PDRzB1WAGq2U6GPuOnipOJxQhnqNnffORZg==} - engines: {node: ^16.20 || ^18.16 || >=20} - deprecated: Package no longer supported. Contact Support at https://www.npmjs.com/support for more info. - dev: false + '@truffle/blockchain-utils@0.1.9': {} - /@truffle/codec@0.17.3: - resolution: {integrity: sha512-Ko/+dsnntNyrJa57jUD9u4qx9nQby+H4GsUO6yjiCPSX0TQnEHK08XWqBSg0WdmCH2+h0y1nr2CXSx8gbZapxg==} - engines: {node: ^16.20 || ^18.16 || >=20} - deprecated: Package no longer supported. Contact Support at https://www.npmjs.com/support for more info. + '@truffle/codec@0.17.3': dependencies: '@truffle/abi-utils': 1.0.3 '@truffle/compile-common': 0.9.8 @@ -3566,32 +8574,20 @@ packages: web3-utils: 1.10.0 transitivePeerDependencies: - supports-color - dev: false - /@truffle/compile-common@0.9.8: - resolution: {integrity: sha512-DTpiyo32t/YhLI1spn84D3MHYHrnoVqO+Gp7ZHrYNwDs86mAxtNiH5lsVzSb8cPgiqlvNsRCU9nm9R0YmKMTBQ==} - engines: {node: ^16.20 || ^18.16 || >=20} - deprecated: Package no longer supported. Contact Support at https://www.npmjs.com/support for more info. + '@truffle/compile-common@0.9.8': dependencies: '@truffle/error': 0.2.2 colors: 1.4.0 - dev: false - /@truffle/contract-schema@3.4.16: - resolution: {integrity: sha512-g0WNYR/J327DqtJPI70ubS19K1Fth/1wxt2jFqLsPmz5cGZVjCwuhiie+LfBde4/Mc9QR8G+L3wtmT5cyoBxAg==} - engines: {node: ^16.20 || ^18.16 || >=20} - deprecated: Package no longer supported. Contact Support at https://www.npmjs.com/support for more info. + '@truffle/contract-schema@3.4.16': dependencies: ajv: 6.12.6 debug: 4.3.4(supports-color@8.1.1) transitivePeerDependencies: - supports-color - dev: false - /@truffle/debug-utils@6.0.57: - resolution: {integrity: sha512-Q6oI7zLaeNLB69ixjwZk2UZEWBY6b2OD1sjLMGDKBGR7GaHYiw96GLR2PFgPH1uwEeLmV4N78LYaQCrDsHbNeA==} - engines: {node: ^16.20 || ^18.16 || >=20} - deprecated: Package no longer supported. Contact Support at https://www.npmjs.com/support for more info. + '@truffle/debug-utils@6.0.57': dependencies: '@truffle/codec': 0.17.3 '@trufflesuite/chromafi': 3.0.0 @@ -3601,36 +8597,23 @@ packages: highlightjs-solidity: 2.0.6 transitivePeerDependencies: - supports-color - dev: false - /@truffle/error@0.1.1: - resolution: {integrity: sha512-sE7c9IHIGdbK4YayH4BC8i8qMjoAOeg6nUXUDZZp8wlU21/EMpaG+CLx+KqcIPyR+GSWIW3Dm0PXkr2nlggFDA==} - deprecated: Package no longer supported. Contact Support at https://www.npmjs.com/support for more info. - dev: false + '@truffle/error@0.1.1': {} - /@truffle/error@0.2.2: - resolution: {integrity: sha512-TqbzJ0O8DHh34cu8gDujnYl4dUl6o2DE4PR6iokbybvnIm/L2xl6+Gv1VC+YJS45xfH83Yo3/Zyg/9Oq8/xZWg==} - engines: {node: ^16.20 || ^18.16 || >=20} - deprecated: Package no longer supported. Contact Support at https://www.npmjs.com/support for more info. - dev: false + '@truffle/error@0.2.2': {} - /@truffle/interface-adapter@0.5.37: - resolution: {integrity: sha512-lPH9MDgU+7sNDlJSClwyOwPCfuOimqsCx0HfGkznL3mcFRymc1pukAR1k17zn7ErHqBwJjiKAZ6Ri72KkS+IWw==} - engines: {node: ^16.20 || ^18.16 || >=20} - deprecated: Package no longer supported. Contact Support at https://www.npmjs.com/support for more info. + '@truffle/interface-adapter@0.5.37(bufferutil@4.0.8)(utf-8-validate@5.0.10)': dependencies: bn.js: 5.2.1 ethers: 4.0.49 - web3: 1.10.0 + web3: 1.10.0(bufferutil@4.0.8)(utf-8-validate@5.0.10) transitivePeerDependencies: - bufferutil - encoding - supports-color - utf-8-validate - dev: false - /@trufflesuite/chromafi@3.0.0: - resolution: {integrity: sha512-oqWcOqn8nT1bwlPPfidfzS55vqcIDdpfzo3HbU9EnUmcSTX+I8z0UyUFI3tZQjByVJulbzxHxUGS3ZJPwK/GPQ==} + '@trufflesuite/chromafi@3.0.0': dependencies: camelcase: 4.1.0 chalk: 2.4.2 @@ -3640,310 +8623,190 @@ packages: lodash.merge: 4.6.2 strip-ansi: 4.0.0 strip-indent: 2.0.0 - dev: false - /@tsconfig/node10@1.0.11: - resolution: {integrity: sha512-DcRjDCujK/kCk/cUe8Xz8ZSpm8mS3mNNpta+jGCA6USEDfktlNvm1+IuZ9eTcDbNk41BHwpHHeW+N1lKCz4zOw==} - dev: true + '@tsconfig/node10@1.0.11': {} - /@tsconfig/node12@1.0.11: - resolution: {integrity: sha512-cqefuRsh12pWyGsIoBKJA9luFu3mRxCA+ORZvA4ktLSzIuCUtWVxGIuXigEwO5/ywWFMZ2QEGKWvkZG1zDMTag==} - dev: true + '@tsconfig/node12@1.0.11': {} - /@tsconfig/node14@1.0.3: - resolution: {integrity: sha512-ysT8mhdixWK6Hw3i1V2AeRqZ5WfXg1G43mqoYlM2nc6388Fq5jcXyr5mRsqViLx/GJYdoL0bfXD8nmF+Zn/Iow==} - dev: true + '@tsconfig/node14@1.0.3': {} - /@tsconfig/node16@1.0.4: - resolution: {integrity: sha512-vxhUy4J8lyeyinH7Azl1pdd43GJhZH/tP2weN8TntQblOY+A0XbT8DJk1/oCPuOOyg/Ja757rG0CgHcWC8OfMA==} - dev: true + '@tsconfig/node16@1.0.4': {} - /@typechain/ethers-v6@0.5.1(ethers@6.12.1)(typechain@8.3.2)(typescript@5.0.4): - resolution: {integrity: sha512-F+GklO8jBWlsaVV+9oHaPh5NJdd6rAKN4tklGfInX1Q7h0xPgVLP39Jl3eCulPB5qexI71ZFHwbljx4ZXNfouA==} - peerDependencies: - ethers: 6.x - typechain: ^8.3.2 - typescript: '>=4.7.0' + '@typechain/ethers-v6@0.5.1(ethers@6.12.1(bufferutil@4.0.8)(utf-8-validate@5.0.10))(typechain@8.3.2(typescript@5.0.4))(typescript@5.0.4)': dependencies: - ethers: 6.12.1 + ethers: 6.12.1(bufferutil@4.0.8)(utf-8-validate@5.0.10) lodash: 4.17.21 ts-essentials: 7.0.3(typescript@5.0.4) typechain: 8.3.2(typescript@5.0.4) typescript: 5.0.4 - dev: true - /@typechain/hardhat@9.1.0(@typechain/ethers-v6@0.5.1)(ethers@6.12.1)(hardhat@packages+hardhat-core)(typechain@8.3.2): - resolution: {integrity: sha512-mtaUlzLlkqTlfPwB3FORdejqBskSnh+Jl8AIJGjXNAQfRQ4ofHADPl1+oU7Z3pAJzmZbUXII8MhOLQltcHgKnA==} - peerDependencies: - '@typechain/ethers-v6': ^0.5.1 - ethers: ^6.1.0 - hardhat: ^2.9.9 - typechain: ^8.3.2 + '@typechain/hardhat@9.1.0(@typechain/ethers-v6@0.5.1(ethers@6.12.1(bufferutil@4.0.8)(utf-8-validate@5.0.10))(typechain@8.3.2(typescript@5.0.4))(typescript@5.0.4))(ethers@6.12.1(bufferutil@4.0.8)(utf-8-validate@5.0.10))(hardhat@packages+hardhat-core)(typechain@8.3.2(typescript@5.0.4))': dependencies: - '@typechain/ethers-v6': 0.5.1(ethers@6.12.1)(typechain@8.3.2)(typescript@5.0.4) - ethers: 6.12.1 + '@typechain/ethers-v6': 0.5.1(ethers@6.12.1(bufferutil@4.0.8)(utf-8-validate@5.0.10))(typechain@8.3.2(typescript@5.0.4))(typescript@5.0.4) + ethers: 6.12.1(bufferutil@4.0.8)(utf-8-validate@5.0.10) fs-extra: 9.1.0 hardhat: link:packages/hardhat-core typechain: 8.3.2(typescript@5.0.4) - dev: true - /@types/async-eventemitter@0.2.4: - resolution: {integrity: sha512-2Bq61VD01kgLf1XkK2xPtoBcu7fgn/km5JyEX9v0BlG5VQBzA+BlF9umFk+8gR8S4+eK7MgDY2oyVZCu6ar3Jw==} + '@types/async-eventemitter@0.2.4': dependencies: '@types/events': 3.0.3 - dev: true - /@types/bignumber.js@5.0.0: - resolution: {integrity: sha512-0DH7aPGCClywOFaxxjE6UwpN2kQYe9LwuDQMv+zYA97j5GkOMo8e66LYT+a8JYU7jfmUFRZLa9KycxHDsKXJCA==} - deprecated: This is a stub types definition for bignumber.js (https://github.com/MikeMcl/bignumber.js/). bignumber.js provides its own type definitions, so you don't need @types/bignumber.js installed! + '@types/bignumber.js@5.0.0': dependencies: bignumber.js: 9.1.2 - dev: false - /@types/bn.js@4.11.6: - resolution: {integrity: sha512-pqr857jrp2kPuO9uRjZ3PwnJTjoQy+fcdxvBTvHm6dkmEL9q+hDD/2j/0ELOBPtPnS8LjCX0gI9nbl8lVkadpg==} + '@types/bn.js@4.11.6': dependencies: '@types/node': 18.19.33 - dev: false - /@types/bn.js@5.1.5: - resolution: {integrity: sha512-V46N0zwKRF5Q00AZ6hWtN0T8gGmDUaUzLWQvHFo5yThtVwK/VCenFY3wXVbOvNfajEpsTfQM4IN9k/d6gUVX3A==} + '@types/bn.js@5.1.5': dependencies: '@types/node': 18.19.33 - /@types/cacheable-request@6.0.3: - resolution: {integrity: sha512-IQ3EbTzGxIigb1I3qPZc1rWJnH0BmSKv5QYTalEwweFvyBDLSAe24zP0le/hyi7ecGfZVlIVAg4BZqb8WBwKqw==} + '@types/cacheable-request@6.0.3': dependencies: '@types/http-cache-semantics': 4.0.4 '@types/keyv': 3.1.4 '@types/node': 18.19.33 '@types/responselike': 1.0.3 - /@types/chai-as-promised@7.1.8: - resolution: {integrity: sha512-ThlRVIJhr69FLlh6IctTXFkmhtP3NpMZ2QGq69StYLyKZFp/HOp1VdKZj7RvfNWYYcJ1xlbLGLLWj1UvP5u/Gw==} + '@types/chai-as-promised@7.1.8': dependencies: '@types/chai': 4.3.16 - /@types/chai@4.3.16: - resolution: {integrity: sha512-PatH4iOdyh3MyWtmHVFXLWCCIhUbopaltqddG9BzB+gMIzee2MJrvd+jouii9Z3wzQJruGWAm7WOMjgfG8hQlQ==} + '@types/chai@4.3.16': {} - /@types/ci-info@2.0.0: - resolution: {integrity: sha512-5R2/MHILQLDCzTuhs1j4Qqq8AaKUf7Ma4KSSkCtc12+fMs47zfa34qhto9goxpyX00tQK1zxB885VCiawZ5Qhg==} - dev: true + '@types/ci-info@2.0.0': {} - /@types/concat-stream@1.6.1: - resolution: {integrity: sha512-eHE4cQPoj6ngxBZMvVf6Hw7Mh4jMW4U9lpGmS5GBPB9RYxlFg+CHaVN7ErNY4W9XfLIEn20b4VDYaIrbq0q4uA==} + '@types/concat-stream@1.6.1': dependencies: '@types/node': 18.19.33 - dev: true - /@types/debug@4.1.12: - resolution: {integrity: sha512-vIChWdVG3LG1SMxEvI/AK+FWJthlrqlTu7fbrlywTkkaONwk/UAGaULXRlf8vkzFBLVm0zkMdCquhL5aOjhXPQ==} + '@types/debug@4.1.12': dependencies: '@types/ms': 0.7.34 - dev: true - /@types/events@3.0.3: - resolution: {integrity: sha512-trOc4AAUThEz9hapPtSd7wf5tiQKvTtu5b371UxXdTuqzIh0ArcRspRP0i0Viu+LXstIQ1z96t1nsPxT9ol01g==} - dev: true + '@types/events@3.0.3': {} - /@types/find-up@2.1.1: - resolution: {integrity: sha512-60LC501bQRN9/3yfVaEEMd7IndaufffL56PBRAejPpUrY304Ps1jfnjNqPw5jmM5R8JHWiKBAe5IHzNcPV41AA==} - dev: true + '@types/find-up@2.1.1': {} - /@types/form-data@0.0.33: - resolution: {integrity: sha512-8BSvG1kGm83cyJITQMZSulnl6QV8jqAGreJsc5tPu1Jq0vTSOiY/k24Wx82JRpWwZSqrala6sd5rWi6aNXvqcw==} + '@types/form-data@0.0.33': dependencies: '@types/node': 18.19.33 - dev: true - /@types/fs-extra@5.1.0: - resolution: {integrity: sha512-AInn5+UBFIK9FK5xc9yP5e3TQSPNNgjHByqYcj9g5elVBnDQcQL7PlO1CIRy2gWlbwK7UPYqi7vRvFA44dCmYQ==} + '@types/fs-extra@5.1.0': dependencies: '@types/node': 18.19.33 - dev: true - /@types/glob@7.2.0: - resolution: {integrity: sha512-ZUxbzKl0IfJILTS6t7ip5fQQM/J3TJYubDm3nMbgubNNYS62eXeUpoLUC8/7fJNiFYHTrGPQn7hspDUzIHX3UA==} + '@types/glob@7.2.0': dependencies: '@types/minimatch': 5.1.2 '@types/node': 18.19.33 - dev: true - /@types/http-cache-semantics@4.0.4: - resolution: {integrity: sha512-1m0bIFVc7eJWyve9S0RnuRgcQqF/Xd5QsUZAZeQFr1Q3/p9JWoQQEqmVy+DPTNpGXwhgIetAoYF8JSc33q29QA==} + '@types/http-cache-semantics@4.0.4': {} - /@types/json-schema@7.0.15: - resolution: {integrity: sha512-5+fP8P8MFNC+AyZCDxrB2pkZFPGzqQWUzpSeuuVLvm8VMcorNYavBqoFcxK8bQz4Qsbn4oUEEem4wDLfcysGHA==} + '@types/json-schema@7.0.15': {} - /@types/json5@0.0.29: - resolution: {integrity: sha512-dRLjCWHYg4oaA77cxO64oO+7JwCwnIzkZPdrrC71jQmQtlhM556pwKo5bUzqvZndkVbeFLIIi+9TC40JNF5hNQ==} - dev: true + '@types/json5@0.0.29': {} - /@types/keccak@3.0.4: - resolution: {integrity: sha512-hdnkmbie7tE0yXnQQvlIOqCyjEsoXDVEZ3ACqO+F305XgUOW4Z9ElWdogCXXRAW/khnZ7GxM0t/BGB5bORKt/g==} + '@types/keccak@3.0.4': dependencies: '@types/node': 18.19.33 - dev: true - /@types/keyv@3.1.4: - resolution: {integrity: sha512-BQ5aZNSCpj7D6K2ksrRCTmKRLEpnPvWDiLPfoGyhZ++8YtiK9d/3DBKPJgry359X/P1PfruyYwvnvwFjuEiEIg==} + '@types/keyv@3.1.4': dependencies: '@types/node': 18.19.33 - /@types/lodash.clonedeep@4.5.9: - resolution: {integrity: sha512-19429mWC+FyaAhOLzsS8kZUsI+/GmBAQ0HFiCPsKGU+7pBXOQWhyrY6xNNDwUSX8SMZMJvuFVMF9O5dQOlQK9Q==} + '@types/lodash.clonedeep@4.5.9': dependencies: '@types/lodash': 4.17.1 - dev: true - /@types/lodash.isequal@4.5.8: - resolution: {integrity: sha512-uput6pg4E/tj2LGxCZo9+y27JNyB2OZuuI/T5F+ylVDYuqICLG2/ktjxx0v6GvVntAf8TvEzeQLcV0ffRirXuA==} + '@types/lodash.isequal@4.5.8': dependencies: '@types/lodash': 4.17.1 - dev: true - /@types/lodash.memoize@4.1.9: - resolution: {integrity: sha512-glY1nQuoqX4Ft8Uk+KfJudOD7DQbbEDF6k9XpGncaohW3RW4eSWBlx6AA0fZCrh40tZcQNH4jS/Oc59J6Eq+aw==} + '@types/lodash.memoize@4.1.9': dependencies: '@types/lodash': 4.17.1 - dev: true - /@types/lodash@4.17.1: - resolution: {integrity: sha512-X+2qazGS3jxLAIz5JDXDzglAF3KpijdhFxlf/V1+hEsOUc+HnWi81L/uv/EvGuV90WY+7mPGFCUDGfQC3Gj95Q==} - dev: true + '@types/lodash@4.17.1': {} - /@types/lru-cache@5.1.1: - resolution: {integrity: sha512-ssE3Vlrys7sdIzs5LOxCzTVMsU7i9oa/IaW92wF32JFb3CVczqOkru2xspuKczHEbG3nvmPY7IFqVmGGHdNbYw==} - dev: false + '@types/lru-cache@5.1.1': {} - /@types/minimatch@5.1.2: - resolution: {integrity: sha512-K0VQKziLUWkVKiRVrx4a40iPaxTUefQmjtkQofBkYRcoaaL/8rhwDWww9qWbrgicNOgnpIsMxyNIUM4+n6dUIA==} - dev: true + '@types/minimatch@5.1.2': {} - /@types/minimist@1.2.5: - resolution: {integrity: sha512-hov8bUuiLiyFPGyFPE1lwWhmzYbirOXQNNo40+y3zow8aFVTeyn3VWL0VFFfdNddA8S4Vf0Tc062rzyNr7Paag==} - dev: true + '@types/minimist@1.2.5': {} - /@types/mocha@10.0.6: - resolution: {integrity: sha512-dJvrYWxP/UcXm36Qn36fxhUKu8A/xMRXVT2cliFF1Z7UA9liG5Psj3ezNSZw+5puH2czDXRLcXQxf8JbJt0ejg==} - dev: true + '@types/mocha@10.0.6': {} - /@types/ms@0.7.34: - resolution: {integrity: sha512-nG96G3Wp6acyAgJqGasjODb+acrI7KltPiRxzHPXnP3NgI28bpQDRv53olbqGXbfcgF5aiiHmO3xpwEpS5Ld9g==} - dev: true + '@types/ms@0.7.34': {} - /@types/node@10.17.60: - resolution: {integrity: sha512-F0KIgDJfy2nA3zMLmWGKxcH2ZVEtCZXHHdOQs2gSaQ27+lNeEfGxzkIw90aXswATX7AZ33tahPbzy6KAfUreVw==} - dev: true + '@types/node@10.17.60': {} - /@types/node@12.20.55: - resolution: {integrity: sha512-J8xLz7q2OFulZ2cyGTLE1TbbZcjpno7FaN6zdJNrgAdrJ+DZzh/uFR6YrTb4C+nXakvud8Q4+rbhoIWlYQbUFQ==} + '@types/node@12.20.55': {} - /@types/node@18.15.13: - resolution: {integrity: sha512-N+0kuo9KgrUQ1Sn/ifDXsvg0TTleP7rIy4zOBGECxAljqvqfqpTfzx0Q1NUedOixRMBfe2Whhb056a42cWs26Q==} + '@types/node@18.15.13': {} - /@types/node@18.19.33: - resolution: {integrity: sha512-NR9+KrpSajr2qBVp/Yt5TU/rp+b5Mayi3+OlMlcg2cVCfRmcG5PWZ7S4+MG9PZ5gWBoc9Pd0BKSRViuBCRPu0A==} + '@types/node@18.19.33': dependencies: undici-types: 5.26.5 - /@types/node@8.10.66: - resolution: {integrity: sha512-tktOkFUA4kXx2hhhrB8bIFb5TbwzS4uOhKEmwiD+NoiL0qtP2OQ9mFldbgD4dV1djrlBYP6eBuQZiWjuHUpqFw==} - dev: true + '@types/node@8.10.66': {} - /@types/normalize-package-data@2.4.4: - resolution: {integrity: sha512-37i+OaWTh9qeK4LSHPsyRC7NahnGotNuZvjLSgcPzblpHB3rrCJxAOgI5gCdKm7coonsaX1Of0ILiTcnZjbfxA==} - dev: true + '@types/normalize-package-data@2.4.4': {} - /@types/pbkdf2@3.1.2: - resolution: {integrity: sha512-uRwJqmiXmh9++aSu1VNEn3iIxWOhd8AHXNSdlaLfdAAdSTY9jYVeGWnzejM3dvrkbqE3/hyQkQQ29IFATEGlew==} + '@types/pbkdf2@3.1.2': dependencies: '@types/node': 18.19.33 - /@types/prettier@2.7.3: - resolution: {integrity: sha512-+68kP9yzs4LMp7VNh8gdzMSPZFL44MLGqiHWvttYJe+6qnuVr4Ek9wSBQoveqY/r+LwjCcU29kNVkidwim+kYA==} - dev: true + '@types/prettier@2.7.3': {} - /@types/qs@6.9.15: - resolution: {integrity: sha512-uXHQKES6DQKKCLh441Xv/dwxOq1TVS3JPUMlEqoEglvlhR6Mxnlew/Xq/LRVHpLyk7iK3zODe1qYHIMltO7XGg==} - dev: true + '@types/qs@6.9.15': {} - /@types/readable-stream@2.3.15: - resolution: {integrity: sha512-oM5JSKQCcICF1wvGgmecmHldZ48OZamtMxcGGVICOJA8o8cahXC1zEVAif8iwoc5j8etxFaRFnf095+CDsuoFQ==} + '@types/readable-stream@2.3.15': dependencies: '@types/node': 18.19.33 safe-buffer: 5.1.2 - dev: true - /@types/resolve@1.20.6: - resolution: {integrity: sha512-A4STmOXPhMUtHH+S6ymgE2GiBSMqf4oTvcQZMcHzokuTLVYzXTB8ttjcgxOVaAp2lGwEdzZ0J+cRbbeevQj1UQ==} - dev: true + '@types/resolve@1.20.6': {} - /@types/responselike@1.0.3: - resolution: {integrity: sha512-H/+L+UkTV33uf49PH5pCAUBVPNj2nDBXTN+qS1dOwyyg24l3CcicicCA7ca+HMvJBZcFgl5r8e+RR6elsb4Lyw==} + '@types/responselike@1.0.3': dependencies: '@types/node': 18.19.33 - /@types/secp256k1@4.0.6: - resolution: {integrity: sha512-hHxJU6PAEUn0TP4S/ZOzuTUvJWuZ6eIKeNKb5RBpODvSl6hp1Wrw4s7ATY50rklRCScUDpHzVA/DQdSjJ3UoYQ==} + '@types/secp256k1@4.0.6': dependencies: '@types/node': 18.19.33 - /@types/semver@6.2.7: - resolution: {integrity: sha512-blctEWbzUFzQx799RZjzzIdBJOXmE37YYEyDtKkx5Dg+V7o/zyyAxLPiI98A2jdTtDgxZleMdfV+7p8WbRJ1OQ==} - dev: true + '@types/semver@6.2.7': {} - /@types/semver@7.5.8: - resolution: {integrity: sha512-I8EUhyrgfLrcTkzV3TSsGyl1tSuPrEDzr0yd5m90UgNxQkyDXULk3b6MlQqTCpZpNtWe1K0hzclnZkTcLBe2UQ==} + '@types/semver@7.5.8': {} - /@types/sinon-chai@3.2.12: - resolution: {integrity: sha512-9y0Gflk3b0+NhQZ/oxGtaAJDvRywCa5sIyaVnounqLvmf93yBF4EgIRspePtkMs3Tr844nCclYMlcCNmLCvjuQ==} + '@types/sinon-chai@3.2.12': dependencies: '@types/chai': 4.3.16 '@types/sinon': 9.0.11 - dev: true - /@types/sinon@9.0.11: - resolution: {integrity: sha512-PwP4UY33SeeVKodNE37ZlOsR9cReypbMJOhZ7BVE0lB+Hix3efCOxiJWiE5Ia+yL9Cn2Ch72EjFTRze8RZsNtg==} + '@types/sinon@9.0.11': dependencies: '@types/sinonjs__fake-timers': 8.1.5 - dev: true - /@types/sinonjs__fake-timers@8.1.5: - resolution: {integrity: sha512-mQkU2jY8jJEF7YHjHvsQO8+3ughTL1mcnn96igfhONmR+fUPSKIkefQYpSe8bsly2Ep7oQbn/6VG5/9/0qcArQ==} - dev: true + '@types/sinonjs__fake-timers@8.1.5': {} - /@types/uuid@8.3.4: - resolution: {integrity: sha512-c/I8ZRb51j+pYGAu5CrFMRxqZ2ke4y2grEBO5AUjgSkSk+qT2Ea+OdWElz/OiMf5MNpn2b17kuVBwZLQJXzihw==} - dev: true + '@types/uuid@8.3.4': {} - /@types/w3c-web-usb@1.0.10: - resolution: {integrity: sha512-CHgUI5kTc/QLMP8hODUHhge0D4vx+9UiAwIGiT0sTy/B2XpdX1U5rJt6JSISgr6ikRT7vxV9EVAFeYZqUnl1gQ==} - dev: false + '@types/w3c-web-usb@1.0.10': {} - /@types/ws@7.4.7: - resolution: {integrity: sha512-JQbbmxZTZehdc2iszGKs5oC3NFnjeay7mtAWrdt7qNtAVK0g19muApzAy4bm9byz79xa2ZnO/BOBC2R8RC5Lww==} + '@types/ws@7.4.7': dependencies: '@types/node': 18.19.33 - dev: true - /@types/ws@8.5.3: - resolution: {integrity: sha512-6YOoWjruKj1uLf3INHH7D3qTXwFfEsg1kf3c0uDdSBJwfa/llkwIjrAGV7j7mVgGNbzTQ3HiHKKDXl6bJPD97w==} + '@types/ws@8.5.3': dependencies: '@types/node': 18.19.33 - dev: true - /@typescript-eslint/eslint-plugin@5.61.0(@typescript-eslint/parser@5.61.0)(eslint@8.57.0)(typescript@5.0.4): - resolution: {integrity: sha512-A5l/eUAug103qtkwccSCxn8ZRwT+7RXWkFECdA4Cvl1dOlDUgTpAOfSEElZn2uSUxhdDpnCdetrf0jvU4qrL+g==} - engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0} - peerDependencies: - '@typescript-eslint/parser': ^5.0.0 - eslint: ^6.0.0 || ^7.0.0 || ^8.0.0 - typescript: '*' - peerDependenciesMeta: - typescript: - optional: true + '@typescript-eslint/eslint-plugin@5.61.0(@typescript-eslint/parser@5.61.0(eslint@8.57.0)(typescript@5.0.4))(eslint@8.57.0)(typescript@5.0.4)': dependencies: '@eslint-community/regexpp': 4.10.0 '@typescript-eslint/parser': 5.61.0(eslint@8.57.0)(typescript@5.0.4) @@ -3957,80 +8820,50 @@ packages: natural-compare-lite: 1.4.0 semver: 7.6.2 tsutils: 3.21.0(typescript@5.0.4) + optionalDependencies: typescript: 5.0.4 transitivePeerDependencies: - supports-color - dev: true - /@typescript-eslint/parser@5.61.0(eslint@8.57.0)(typescript@5.0.4): - resolution: {integrity: sha512-yGr4Sgyh8uO6fSi9hw3jAFXNBHbCtKKFMdX2IkT3ZqpKmtAq3lHS4ixB/COFuAIJpwl9/AqF7j72ZDWYKmIfvg==} - engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0} - peerDependencies: - eslint: ^6.0.0 || ^7.0.0 || ^8.0.0 - typescript: '*' - peerDependenciesMeta: - typescript: - optional: true + '@typescript-eslint/parser@5.61.0(eslint@8.57.0)(typescript@5.0.4)': dependencies: '@typescript-eslint/scope-manager': 5.61.0 '@typescript-eslint/types': 5.61.0 '@typescript-eslint/typescript-estree': 5.61.0(typescript@5.0.4) debug: 4.3.4(supports-color@8.1.1) eslint: 8.57.0 + optionalDependencies: typescript: 5.0.4 transitivePeerDependencies: - supports-color - /@typescript-eslint/scope-manager@5.61.0: - resolution: {integrity: sha512-W8VoMjoSg7f7nqAROEmTt6LoBpn81AegP7uKhhW5KzYlehs8VV0ZW0fIDVbcZRcaP3aPSW+JZFua+ysQN+m/Nw==} - engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0} + '@typescript-eslint/scope-manager@5.61.0': dependencies: '@typescript-eslint/types': 5.61.0 '@typescript-eslint/visitor-keys': 5.61.0 - /@typescript-eslint/scope-manager@5.62.0: - resolution: {integrity: sha512-VXuvVvZeQCQb5Zgf4HAxc04q5j+WrNAtNh9OwCsCgpKqESMTu3tF/jhZ3xG6T4NZwWl65Bg8KuS2uEvhSfLl0w==} - engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0} + '@typescript-eslint/scope-manager@5.62.0': dependencies: '@typescript-eslint/types': 5.62.0 '@typescript-eslint/visitor-keys': 5.62.0 - /@typescript-eslint/type-utils@5.61.0(eslint@8.57.0)(typescript@5.0.4): - resolution: {integrity: sha512-kk8u//r+oVK2Aj3ph/26XdH0pbAkC2RiSjUYhKD+PExemG4XSjpGFeyZ/QM8lBOa7O8aGOU+/yEbMJgQv/DnCg==} - engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0} - peerDependencies: - eslint: '*' - typescript: '*' - peerDependenciesMeta: - typescript: - optional: true + '@typescript-eslint/type-utils@5.61.0(eslint@8.57.0)(typescript@5.0.4)': dependencies: '@typescript-eslint/typescript-estree': 5.61.0(typescript@5.0.4) '@typescript-eslint/utils': 5.61.0(eslint@8.57.0)(typescript@5.0.4) debug: 4.3.4(supports-color@8.1.1) eslint: 8.57.0 tsutils: 3.21.0(typescript@5.0.4) + optionalDependencies: typescript: 5.0.4 transitivePeerDependencies: - supports-color - dev: true - /@typescript-eslint/types@5.61.0: - resolution: {integrity: sha512-ldyueo58KjngXpzloHUog/h9REmHl59G1b3a5Sng1GfBo14BkS3ZbMEb3693gnP1k//97lh7bKsp6/V/0v1veQ==} - engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0} + '@typescript-eslint/types@5.61.0': {} - /@typescript-eslint/types@5.62.0: - resolution: {integrity: sha512-87NVngcbVXUahrRTqIK27gD2t5Cu1yuCXxbLcFtCzZGlfyVWWh8mLHkoxzjsB6DDNnvdL+fW8MiwPEJyGJQDgQ==} - engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0} + '@typescript-eslint/types@5.62.0': {} - /@typescript-eslint/typescript-estree@5.61.0(typescript@5.0.4): - resolution: {integrity: sha512-Fud90PxONnnLZ36oR5ClJBLTLfU4pIWBmnvGwTbEa2cXIqj70AEDEmOmpkFComjBZ/037ueKrOdHuYmSFVD7Rw==} - engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0} - peerDependencies: - typescript: '*' - peerDependenciesMeta: - typescript: - optional: true + '@typescript-eslint/typescript-estree@5.61.0(typescript@5.0.4)': dependencies: '@typescript-eslint/types': 5.61.0 '@typescript-eslint/visitor-keys': 5.61.0 @@ -4039,18 +8872,12 @@ packages: is-glob: 4.0.3 semver: 7.6.2 tsutils: 3.21.0(typescript@5.0.4) + optionalDependencies: typescript: 5.0.4 transitivePeerDependencies: - supports-color - /@typescript-eslint/typescript-estree@5.62.0(typescript@5.0.4): - resolution: {integrity: sha512-CmcQ6uY7b9y694lKdRB8FEel7JbU/40iSAPomu++SjLMntB+2Leay2LO6i8VnJk58MtE9/nQSFIH6jpyRWyYzA==} - engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0} - peerDependencies: - typescript: '*' - peerDependenciesMeta: - typescript: - optional: true + '@typescript-eslint/typescript-estree@5.62.0(typescript@5.0.4)': dependencies: '@typescript-eslint/types': 5.62.0 '@typescript-eslint/visitor-keys': 5.62.0 @@ -4059,15 +8886,12 @@ packages: is-glob: 4.0.3 semver: 7.6.2 tsutils: 3.21.0(typescript@5.0.4) + optionalDependencies: typescript: 5.0.4 transitivePeerDependencies: - supports-color - /@typescript-eslint/utils@5.61.0(eslint@8.57.0)(typescript@5.0.4): - resolution: {integrity: sha512-mV6O+6VgQmVE6+xzlA91xifndPW9ElFW8vbSF0xCT/czPXVhwDewKila1jOyRwa9AE19zKnrr7Cg5S3pJVrTWQ==} - engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0} - peerDependencies: - eslint: ^6.0.0 || ^7.0.0 || ^8.0.0 + '@typescript-eslint/utils@5.61.0(eslint@8.57.0)(typescript@5.0.4)': dependencies: '@eslint-community/eslint-utils': 4.4.0(eslint@8.57.0) '@types/json-schema': 7.0.15 @@ -4081,13 +8905,8 @@ packages: transitivePeerDependencies: - supports-color - typescript - dev: true - /@typescript-eslint/utils@5.62.0(eslint@8.57.0)(typescript@5.0.4): - resolution: {integrity: sha512-n8oxjeb5aIbPFEtmQxQYOLI0i9n5ySBEY/ZEHHZqKQSFnxio1rv6dthascc9dLuwrL0RC5mPCxB7vnAVGAYWAQ==} - engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0} - peerDependencies: - eslint: ^6.0.0 || ^7.0.0 || ^8.0.0 + '@typescript-eslint/utils@5.62.0(eslint@8.57.0)(typescript@5.0.4)': dependencies: '@eslint-community/eslint-utils': 4.4.0(eslint@8.57.0) '@types/json-schema': 7.0.15 @@ -4102,285 +8921,163 @@ packages: - supports-color - typescript - /@typescript-eslint/visitor-keys@5.61.0: - resolution: {integrity: sha512-50XQ5VdbWrX06mQXhy93WywSFZZGsv3EOjq+lqp6WC2t+j3mb6A9xYVdrRxafvK88vg9k9u+CT4l6D8PEatjKg==} - engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0} + '@typescript-eslint/visitor-keys@5.61.0': dependencies: '@typescript-eslint/types': 5.61.0 eslint-visitor-keys: 3.4.3 - /@typescript-eslint/visitor-keys@5.62.0: - resolution: {integrity: sha512-07ny+LHRzQXepkGg6w0mFY41fVUNBrL2Roj/++7V1txKugfjm/Ci/qSND03r2RhlJhJYMcTn9AhhSSqQp0Ysyw==} - engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0} + '@typescript-eslint/visitor-keys@5.62.0': dependencies: '@typescript-eslint/types': 5.62.0 eslint-visitor-keys: 3.4.3 - /@ungap/structured-clone@1.2.0: - resolution: {integrity: sha512-zuVdFrMJiuCDQUMCzQaD6KL28MjnqqN8XnAqiEq9PNm/hCPTSGfrXCOfwj1ow4LFb/tNymJPwsNbVePc1xFqrQ==} + '@ungap/structured-clone@1.2.0': {} - /abbrev@1.0.9: - resolution: {integrity: sha512-LEyx4aLEC3x6T0UguF6YILf+ntvmOaWsVfENmIW0E9H09vKlLDGelMjjSm0jkDHALj8A8quZ/HapKNigzwge+Q==} - dev: true + abbrev@1.0.9: {} - /abitype@0.7.1(typescript@5.0.4): - resolution: {integrity: sha512-VBkRHTDZf9Myaek/dO3yMmOzB/y2s3Zo6nVU7yaw1G+TvCHAjwaJzNGN9yo4K5D8bU/VZXKP1EJpRhFr862PlQ==} - peerDependencies: - typescript: '>=4.9.4' - zod: ^3 >=3.19.1 - peerDependenciesMeta: - zod: - optional: true + abitype@0.7.1(typescript@5.0.4)(zod@3.23.8): dependencies: typescript: 5.0.4 - dev: true + optionalDependencies: + zod: 3.23.8 - /abitype@0.9.10(typescript@5.0.4): - resolution: {integrity: sha512-FIS7U4n7qwAT58KibwYig5iFG4K61rbhAqaQh/UWj8v1Y8mjX3F8TC9gd8cz9yT1TYel9f8nS5NO5kZp2RW0jQ==} - peerDependencies: - typescript: '>=5.0.4' - zod: ^3 >=3.22.0 - peerDependenciesMeta: - typescript: - optional: true - zod: - optional: true - dependencies: + abitype@0.9.10(typescript@5.0.4)(zod@3.23.8): + optionalDependencies: typescript: 5.0.4 - dev: false + zod: 3.23.8 - /abitype@1.0.0(typescript@5.0.4): - resolution: {integrity: sha512-NMeMah//6bJ56H5XRj8QCV4AwuW6hB6zqz2LnhhLdcWVQOsXki6/Pn3APeqxCma62nXIcmZWdu1DlHWS74umVQ==} - peerDependencies: - typescript: '>=5.0.4' - zod: ^3 >=3.22.0 - peerDependenciesMeta: - typescript: - optional: true - zod: - optional: true - dependencies: + abitype@1.0.0(typescript@5.0.4)(zod@3.23.8): + optionalDependencies: typescript: 5.0.4 - dev: true + zod: 3.23.8 - /abortcontroller-polyfill@1.7.5: - resolution: {integrity: sha512-JMJ5soJWP18htbbxJjG7bG6yuI6pRhgJ0scHHTfkUjf6wjP912xZWvM+A4sJK3gqd9E8fcPbDnOefbA9Th/FIQ==} + abortcontroller-polyfill@1.7.5: {} - /accepts@1.3.8: - resolution: {integrity: sha512-PYAthTa2m2VKxuvSD3DPC/Gy+U+sOA1LAuT8mkmRuvw+NACSaeXEQ+NHcVF7rONl6qcaxV3Uuemwawk+7+SJLw==} - engines: {node: '>= 0.6'} + accepts@1.3.8: dependencies: mime-types: 2.1.35 negotiator: 0.6.3 - /acorn-jsx@5.3.2(acorn@8.11.3): - resolution: {integrity: sha512-rq9s+JNhf0IChjtDXxllJ7g41oZk5SlXtp0LHwyA5cejwn7vKmKp4pPri6YEePv2PU65sAsegbXtIinmDFDXgQ==} - peerDependencies: - acorn: ^6.0.0 || ^7.0.0 || ^8.0.0 + acorn-jsx@5.3.2(acorn@8.11.3): dependencies: acorn: 8.11.3 - /acorn-walk@8.3.2: - resolution: {integrity: sha512-cjkyv4OtNCIeqhHrfS81QWXoCBPExR/J62oyEqepVw8WaQeSqpW2uhuLPh1m9eWhDuOo/jUXVTlifvesOWp/4A==} - engines: {node: '>=0.4.0'} - dev: true + acorn-walk@8.3.2: {} - /acorn@8.11.3: - resolution: {integrity: sha512-Y9rRfJG5jcKOE0CLisYbojUjIrIEE7AGMzA/Sm4BslANhbS+cDMpgBdcPT91oJ7OuJ9hYJBx59RjbhxVnrF8Xg==} - engines: {node: '>=0.4.0'} - hasBin: true + acorn@8.11.3: {} - /address@1.2.2: - resolution: {integrity: sha512-4B/qKCfeE/ODUaAUpSwfzazo5x29WD4r3vXiWsB7I2mSDAihwEqKO+g8GELZUQSSAo5e1XTYh3ZVfLyxBc12nA==} - engines: {node: '>= 10.0.0'} - dev: true + address@1.2.2: {} - /adm-zip@0.4.16: - resolution: {integrity: sha512-TFi4HBKSGfIKsK5YCkKaaFG2m4PEDyViZmEwof3MTIgzimHLto6muaHVpbrljdIvIrFZzEq/p4nafOeLcYegrg==} - engines: {node: '>=0.3.0'} - dev: false + adm-zip@0.4.16: {} - /aes-js@3.0.0: - resolution: {integrity: sha512-H7wUZRn8WpTq9jocdxQ2c8x2sKo9ZVmzfRE13GiNJXfp7NcKYEdvl3vspKjXox6RIG2VtaRe4JFvxG4rqp2Zuw==} + aes-js@3.0.0: {} - /aes-js@4.0.0-beta.5: - resolution: {integrity: sha512-G965FqalsNyrPqgEGON7nIx1e/OVENSgiEIzyC63haUMuvNnwIgIjMs52hlTCKhkBny7A2ORNlfY9Zu+jmGk1Q==} + aes-js@4.0.0-beta.5: {} - /agent-base@6.0.2: - resolution: {integrity: sha512-RZNwNclF7+MS/8bDg70amg32dyeZGZxiDuQmZxKLAlQjr3jGyLx+4Kkk58UO7D2QdgFIQCovuSuZESne6RG6XQ==} - engines: {node: '>= 6.0.0'} + agent-base@6.0.2: dependencies: debug: 4.3.4(supports-color@8.1.1) transitivePeerDependencies: - supports-color - dev: false - /aggregate-error@3.1.0: - resolution: {integrity: sha512-4I7Td01quW/RpocfNayFdFVk1qSuoh0E7JrbRJ16nH01HhKFQ88INq9Sd+nd72zqRySlr9BmDA8xlEJ6vJMrYA==} - engines: {node: '>=8'} + aggregate-error@3.1.0: dependencies: clean-stack: 2.2.0 indent-string: 4.0.0 - /ajv@5.5.2: - resolution: {integrity: sha512-Ajr4IcMXq/2QmMkEmSvxqfLN5zGmJ92gHXAeOXq1OekoH2rfDNsgdDoL2f7QaRCy7G/E6TpxBVdRuNraMztGHw==} + ajv@5.5.2: dependencies: co: 4.6.0 fast-deep-equal: 1.1.0 fast-json-stable-stringify: 2.1.0 json-schema-traverse: 0.3.1 - dev: false - /ajv@6.12.6: - resolution: {integrity: sha512-j3fVLgvTo527anyYyJOGTYJbG+vnnQYvE0m5mmkc1TK+nxAppkCLMIL0aZ4dblVCNoGShhm+kzE4ZUykBoMg4g==} + ajv@6.12.6: dependencies: fast-deep-equal: 3.1.3 fast-json-stable-stringify: 2.1.0 json-schema-traverse: 0.4.1 uri-js: 4.4.1 - /ajv@8.13.0: - resolution: {integrity: sha512-PRA911Blj99jR5RMeTunVbNXMF6Lp4vZXnk5GQjcnUWUTsrXtekg/pnmFFI2u/I36Y/2bITGS30GZCXei6uNkA==} + ajv@8.13.0: dependencies: fast-deep-equal: 3.1.3 json-schema-traverse: 1.0.0 require-from-string: 2.0.2 uri-js: 4.4.1 - /amdefine@1.0.1: - resolution: {integrity: sha512-S2Hw0TtNkMJhIabBwIojKL9YHO5T0n5eNqWJ7Lrlel/zDbftQpxpapi8tZs3X1HWa+u+QeydGmzzNU0m09+Rcg==} - engines: {node: '>=0.4.2'} - requiresBuild: true - dev: true + amdefine@1.0.1: optional: true - /ansi-align@3.0.1: - resolution: {integrity: sha512-IOfwwBF5iczOjp/WeY4YxyjqAFMQoZufdQWDd19SEExbVLNXqvpzSJ/M7Za4/sCPmQ0+GRquoA7bGcINcxew6w==} + ansi-align@3.0.1: dependencies: string-width: 4.2.3 - dev: false - /ansi-colors@4.1.1: - resolution: {integrity: sha512-JoX0apGbHaUJBNl6yF+p6JAFYZ666/hhCGKN5t9QFjbJQKUU/g8MNbFDbvfrgKXvI1QpZplPOnwIo99lX/AAmA==} - engines: {node: '>=6'} + ansi-colors@4.1.1: {} - /ansi-colors@4.1.3: - resolution: {integrity: sha512-/6w/C21Pm1A7aZitlI5Ni/2J6FFQN8i1Cvz3kHABAAbw93v/NlvKdVOqz7CCWz/3iv/JplRSEEZ83XION15ovw==} - engines: {node: '>=6'} + ansi-colors@4.1.3: {} - /ansi-escapes@4.3.2: - resolution: {integrity: sha512-gKXj5ALrKWQLsYG9jlTRmR/xKluxHV+Z9QEwNIgCfM1/uwPMCuzVVnh5mwTd+OuBZcwSIMbqssNWRm1lE51QaQ==} - engines: {node: '>=8'} + ansi-escapes@4.3.2: dependencies: type-fest: 0.21.3 - dev: false - /ansi-regex@2.1.1: - resolution: {integrity: sha512-TIGnTpdo+E3+pCyAluZvtED5p5wCqLdezCyhPZzKPcxvFplEt4i+W7OONCKgeZFT3+y5NZZfOOS/Bdcanm1MYA==} - engines: {node: '>=0.10.0'} - dev: false + ansi-regex@2.1.1: {} - /ansi-regex@3.0.1: - resolution: {integrity: sha512-+O9Jct8wf++lXxxFc4hc8LsjaSq0HFzzL7cVsw8pRDIPdjKD2mT4ytDZlLuSBZ4cLKZFXIrMGO7DbQCtMJJMKw==} - engines: {node: '>=4'} + ansi-regex@3.0.1: {} - /ansi-regex@5.0.1: - resolution: {integrity: sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ==} - engines: {node: '>=8'} + ansi-regex@5.0.1: {} - /ansi-styles@1.0.0: - resolution: {integrity: sha512-3iF4FIKdxaVYT3JqQuY3Wat/T2t7TRbbQ94Fu50ZUCbLy4TFbTzr90NOHQodQkNqmeEGCw8WbeP78WNi6SKYUA==} - engines: {node: '>=0.8.0'} - dev: true + ansi-styles@1.0.0: {} - /ansi-styles@3.2.1: - resolution: {integrity: sha512-VT0ZI6kZRdTh8YyJw3SMbYm/u+NqfsAxEpWO0Pf9sq8/e94WxxOpPKx9FR1FlyCtOVDNOQ+8ntlqFxiRc+r5qA==} - engines: {node: '>=4'} + ansi-styles@3.2.1: dependencies: color-convert: 1.9.3 - /ansi-styles@4.3.0: - resolution: {integrity: sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==} - engines: {node: '>=8'} + ansi-styles@4.3.0: dependencies: color-convert: 2.0.1 - /ansi-styles@5.2.0: - resolution: {integrity: sha512-Cxwpt2SfTzTtXcfOlzGEee8O+c+MmUgGrNiBcXnuWxuFJHe6a5Hz7qwhwe5OgaSYI0IJvkLqWX1ASG+cJOkEiA==} - engines: {node: '>=10'} - dev: true + ansi-styles@5.2.0: {} - /antlr4@4.13.1: - resolution: {integrity: sha512-kiXTspaRYvnIArgE97z5YVVf/cDVQABr3abFRR6mE7yesLMkgu4ujuyV/sgxafQ8wgve0DJQUJ38Z8tkgA2izA==} - engines: {node: '>=16'} - dev: false + antlr4@4.13.1: {} - /antlr4@4.8.0: - resolution: {integrity: sha512-en/MxQ4OkPgGJQ3wD/muzj1uDnFSzdFIhc2+c6bHZokWkuBb6RRvFjpWhPxWLbgQvaEzldJZ0GSQpfSAaE3hqg==} - dev: false + antlr4@4.8.0: {} - /antlr4ts@0.5.0-alpha.4: - resolution: {integrity: sha512-WPQDt1B74OfPv/IMS2ekXAKkTZIHl88uMetg6q3OTqgFxZ/dxDXI0EWLyZid/1Pe6hTftyg5N7gel5wNAGxXyQ==} + antlr4ts@0.5.0-alpha.4: {} - /any-promise@1.3.0: - resolution: {integrity: sha512-7UvmKalWRt1wgjL1RrGxoSJW/0QZFIegpeGvZG9kjp8vrRu55XTHbwnqq2GpXm9uLbcuhxm3IqX9OB4MZR1b2A==} - dev: false + any-promise@1.3.0: {} - /anymatch@3.1.3: - resolution: {integrity: sha512-KMReFUr0B4t+D+OBkjR3KYqvocp2XaSzO55UcB6mgQMd3KbcE+mWTyvVV7D/zsdEbNnV6acZUutkiHQXvTr1Rw==} - engines: {node: '>= 8'} + anymatch@3.1.3: dependencies: normalize-path: 3.0.0 picomatch: 2.3.1 - - /append-transform@2.0.0: - resolution: {integrity: sha512-7yeyCEurROLQJFv5Xj4lEGTy0borxepjFv1g22oAdqFu//SrAlDl1O1Nxx15SH1RoliUml6p8dwJW9jvZughhg==} - engines: {node: '>=8'} + + append-transform@2.0.0: dependencies: default-require-extensions: 3.0.1 - dev: true - /archy@1.0.0: - resolution: {integrity: sha512-Xg+9RwCg/0p32teKdGMPTPnVXKD0w3DfHnFTficozsAgsvq2XenPJq/MYpzzQ/v8zrOyJn6Ds39VA4JIDwFfqw==} - dev: true + archy@1.0.0: {} - /arg@4.1.3: - resolution: {integrity: sha512-58S9QDqG0Xx27YwPSt9fJxivjYl432YCwfDMfZ+71RAqUrZef7LrKQZ3LHLOwCS4FLNBplP533Zx895SeOCHvA==} - dev: true + arg@4.1.3: {} - /argparse@1.0.10: - resolution: {integrity: sha512-o5Roy6tNG4SL/FOkCAN6RzjiakZS25RLYFrcMttJqbdd8BWrnA+fGz57iN5Pb06pvBGvl5gQ0B48dJlslXvoTg==} + argparse@1.0.10: dependencies: sprintf-js: 1.0.3 - dev: true - /argparse@2.0.1: - resolution: {integrity: sha512-8+9WqebbFzpX9OR+Wa6O29asIogeRMzcGtAINdpMHHyAg10f05aSFVBbcEqGf/PXw1EjAZ+q2/bEBg3DvurK3Q==} + argparse@2.0.1: {} - /array-back@3.1.0: - resolution: {integrity: sha512-TkuxA4UCOvxuDK6NZYXCalszEzj+TLszyASooky+i742l9TqsOdYCMJJupxRic61hwquNtppB3hgcuq9SVSH1Q==} - engines: {node: '>=6'} - dev: true + array-back@3.1.0: {} - /array-back@4.0.2: - resolution: {integrity: sha512-NbdMezxqf94cnNfWLL7V/im0Ub+Anbb0IoZhvzie8+4HJ4nMQuzHuy49FkGYCJK2yAloZ3meiB6AVMClbrI1vg==} - engines: {node: '>=8'} - dev: true + array-back@4.0.2: {} - /array-buffer-byte-length@1.0.1: - resolution: {integrity: sha512-ahC5W1xgou+KTXix4sAO8Ki12Q+jf4i0+tmk3sC+zgcynshkHxzpXdImBehiUYKKKDwvfFiJl1tZt6ewscS1Mg==} - engines: {node: '>= 0.4'} + array-buffer-byte-length@1.0.1: dependencies: call-bind: 1.0.7 is-array-buffer: 3.0.4 - dev: true - /array-flatten@1.1.1: - resolution: {integrity: sha512-PCVAQswWemu6UdxsDFFX/+gVeYqKAod3D3UVm91jHwynguOwAvYPhx8nNlM++NqRcK6CxxpUafjmhIdKiHibqg==} + array-flatten@1.1.1: {} - /array-includes@3.1.8: - resolution: {integrity: sha512-itaWrbYbqpGXkGhZPGUulwnhVf5Hpy1xiCFsGqyIGglbBxmG5vSjxQen3/WGOjPpNEv1RtBLKxbmVXm8HpJStQ==} - engines: {node: '>= 0.4'} + array-includes@3.1.8: dependencies: call-bind: 1.0.7 define-properties: 1.2.1 @@ -4388,40 +9085,26 @@ packages: es-object-atoms: 1.0.0 get-intrinsic: 1.2.4 is-string: 1.0.7 - dev: true - /array-union@2.1.0: - resolution: {integrity: sha512-HGyxoOTYUyCM6stUe6EJgnd4EoewAI7zMdfqO+kGjnlZmBDz/cR5pf8r/cR4Wq60sL/p0IkcjUEEPwS3GFrIyw==} - engines: {node: '>=8'} + array-union@2.1.0: {} - /array-uniq@1.0.3: - resolution: {integrity: sha512-MNha4BWQ6JbwhFhj03YK552f7cb3AzoE8SzeljgChvL1dl3IcvggXVz1DilzySZkCja+CXuZbdW7yATchWn8/Q==} - engines: {node: '>=0.10.0'} - dev: true + array-uniq@1.0.3: {} - /array.prototype.flat@1.3.2: - resolution: {integrity: sha512-djYB+Zx2vLewY8RWlNCUdHjDXs2XOgm602S9E7P/UpHgfeHL00cRiIF+IN/G/aUJ7kGPb6yO/ErDI5V2s8iycA==} - engines: {node: '>= 0.4'} + array.prototype.flat@1.3.2: dependencies: call-bind: 1.0.7 define-properties: 1.2.1 es-abstract: 1.23.3 es-shim-unscopables: 1.0.2 - dev: true - /array.prototype.flatmap@1.3.2: - resolution: {integrity: sha512-Ewyx0c9PmpcsByhSW4r+9zDU7sGjFc86qf/kKtuSCRdhfbk0SNLLkaT5qvcHnRGgc5NP/ly/y+qkXkqONX54CQ==} - engines: {node: '>= 0.4'} + array.prototype.flatmap@1.3.2: dependencies: call-bind: 1.0.7 define-properties: 1.2.1 es-abstract: 1.23.3 es-shim-unscopables: 1.0.2 - dev: true - /arraybuffer.prototype.slice@1.0.3: - resolution: {integrity: sha512-bMxMKAjg13EBSVscxTaYA4mRc5t1UAXa2kXiGTNfZ079HIWXEkKmkgFrh/nJqamaLSrXO5H4WFFkPEaLJWbs3A==} - engines: {node: '>= 0.4'} + arraybuffer.prototype.slice@1.0.3: dependencies: array-buffer-byte-length: 1.0.1 call-bind: 1.0.7 @@ -4431,75 +9114,46 @@ packages: get-intrinsic: 1.2.4 is-array-buffer: 3.0.4 is-shared-array-buffer: 1.0.3 - dev: true - /arrify@1.0.1: - resolution: {integrity: sha512-3CYzex9M9FGQjCGMGyi6/31c8GJbgb0qGyrx5HWxPd0aCwh4cB2YjMb2Xf9UuoogrMrlO9cTqnB5rI5GHZTcUA==} - engines: {node: '>=0.10.0'} - dev: true + arrify@1.0.1: {} - /asap@2.0.6: - resolution: {integrity: sha512-BSHWgDSAiKs50o2Re8ppvp3seVHXSRM44cdSsT9FfNEUUZLOGWVCsiWaRPWM1Znn+mqZ1OfVZ3z3DWEzSp7hRA==} - dev: true + asap@2.0.6: {} - /asn1@0.2.6: - resolution: {integrity: sha512-ix/FxPn0MDjeyJ7i/yoHGFt/EX6LyNbxSEhPPXODPL+KB0VPk86UYfL0lMdy+KCnv+fmvIzySwaK5COwqVbWTQ==} + asn1@0.2.6: dependencies: safer-buffer: 2.1.2 - /assert-plus@1.0.0: - resolution: {integrity: sha512-NfJ4UzBCcQGLDlQq7nHxH+tv3kyZ0hHQqF5BO6J7tNJeP5do1llPr8dZ8zHonfhAu0PHAdMkSo+8o0wxg9lZWw==} - engines: {node: '>=0.8'} + assert-plus@1.0.0: {} - /assertion-error@1.1.0: - resolution: {integrity: sha512-jgsaNduz+ndvGyFt3uSuWqvy4lCnIJiovtouQN5JZHOKCS2QuhEdbcQHFhVksz2N2U9hXJo8odG7ETyWlEeuDw==} + assertion-error@1.1.0: {} - /ast-parents@0.0.1: - resolution: {integrity: sha512-XHusKxKz3zoYk1ic8Un640joHbFMhbqneyoZfoKnEGtf2ey9Uh/IdpcQplODdO/kENaMIWsD0nJm4+wX3UNLHA==} - dev: false + ast-parents@0.0.1: {} - /astral-regex@2.0.0: - resolution: {integrity: sha512-Z7tMw1ytTXt5jqMcOP+OQteU1VuNK9Y02uuJtKQ1Sv69jXQKKg5cibLwGJow8yzZP+eAc18EmLGPal0bp36rvQ==} - engines: {node: '>=8'} - dev: false + astral-regex@2.0.0: {} - /async-limiter@1.0.1: - resolution: {integrity: sha512-csOlWGAcRFJaI6m+F2WKdnMKr4HhdhFVBk0H/QbJFMCr+uO2kwohwXQPxw/9OCxp05r5ghVBFSyioixx3gfkNQ==} + async-limiter@1.0.1: {} - /async@1.5.2: - resolution: {integrity: sha512-nSVgobk4rv61R9PUSDtYt7mPVB2olxNR5RWJcAsH676/ef11bUZwvu7+RGYrYauVdDPcO519v68wRhXQtxsV9w==} - dev: true + async@1.5.2: {} - /asynckit@0.4.0: - resolution: {integrity: sha512-Oei9OH4tRh0YqU3GxhX79dM/mwVgvbZJaSNaRk+bshkj0S5cfHcgYakreBjrHwatXKbz+IoIdYLxrKim2MjW0Q==} + asynckit@0.4.0: {} - /at-least-node@1.0.0: - resolution: {integrity: sha512-+q/t7Ekv1EDY2l6Gda6LLiX14rU9TV20Wa3ofeQmwPFZbOMo9DXrLbOjFaaclkXKWidIaopwAObQDqwWtGUjqg==} - engines: {node: '>= 4.0.0'} - dev: true + at-least-node@1.0.0: {} - /available-typed-arrays@1.0.7: - resolution: {integrity: sha512-wvUjBtSGN7+7SjNpq/9M2Tg350UZD3q62IFZLbRAR1bSMlCo1ZaeW+BJ+D090e4hIIZLBcTDWe4Mh4jvUDajzQ==} - engines: {node: '>= 0.4'} + available-typed-arrays@1.0.7: dependencies: possible-typed-array-names: 1.0.0 - /aws-sign2@0.7.0: - resolution: {integrity: sha512-08kcGqnYf/YmjoRhfxyu+CLxBjUtHLXLXX/vUfx9l2LYzG3c1m61nrpyFUZI6zeS+Li/wWMMidD9KgrqtGq3mA==} + aws-sign2@0.7.0: {} - /aws4@1.12.0: - resolution: {integrity: sha512-NmWvPnx0F1SfrQbYwOi7OeaNGokp9XhzNioJ/CSBs8Qa4vxug81mhJEAVZwxXuBmYB5KDRfMq/F3RR0BIU7sWg==} + aws4@1.12.0: {} - /axios@0.21.4: - resolution: {integrity: sha512-ut5vewkiu8jjGBdqpM44XxjuCjq9LAKeHVmoVfHVzy8eHgxxq8SbAVQNovDA8mVi05kP0Ea/n/UzcSHcTJQfNg==} + axios@0.21.4: dependencies: follow-redirects: 1.15.6(debug@4.3.4) transitivePeerDependencies: - debug - dev: false - /axios@1.6.8(debug@4.3.4): - resolution: {integrity: sha512-v/ZHtJDU39mDpyBoFVkETcd/uNdxrWRrg3bKpOKzXFA6Bvqopts6ALSMU3y6ijYxbw2B+wPrIv46egTzJXCLGQ==} + axios@1.6.8(debug@4.3.4): dependencies: follow-redirects: 1.15.6(debug@4.3.4) form-data: 4.0.0 @@ -4507,91 +9161,62 @@ packages: transitivePeerDependencies: - debug - /balanced-match@1.0.2: - resolution: {integrity: sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw==} + balanced-match@1.0.2: {} - /base-x@3.0.9: - resolution: {integrity: sha512-H7JU6iBHTal1gp56aKoaa//YUxEaAOUiydvrV/pILqIHXTtqxSkATOnDA2u+jZ/61sD+L/412+7kzXRtWukhpQ==} + base-x@3.0.9: dependencies: safe-buffer: 5.2.1 - /base64-js@1.5.1: - resolution: {integrity: sha512-AKpaYlHn8t4SVbOHCy+b5+KKgvR4vrsD8vbvrbiQJps7fKDTkjkDry6ji0rUJjC0kzbNePLwzxq8iypo41qeWA==} + base64-js@1.5.1: {} - /bcrypt-pbkdf@1.0.2: - resolution: {integrity: sha512-qeFIXtP4MSoi6NLqO12WfqARWWuCKi2Rn/9hJLEmtB5yTNr9DqFWkJRCf2qShWzPeAMRnOgCrq0sg/KLv5ES9w==} + bcrypt-pbkdf@1.0.2: dependencies: tweetnacl: 0.14.5 - /bech32@1.1.4: - resolution: {integrity: sha512-s0IrSOzLlbvX7yp4WBfPITzpAU8sqQcpsmwXDiKwrG4r491vwCO/XpejasRNl0piBMe/DvP4Tz0mIS/X1DPJBQ==} + bech32@1.1.4: {} - /better-path-resolve@1.0.0: - resolution: {integrity: sha512-pbnl5XzGBdrFU/wT4jqmJVPn2B6UHPBOhzMQkY/SPUPB6QtUXtmBHBIwCbXJol93mOpGMnQyP/+BB19q04xj7g==} - engines: {node: '>=4'} + better-path-resolve@1.0.0: dependencies: is-windows: 1.0.2 - dev: true - /big-integer@1.6.36: - resolution: {integrity: sha512-t70bfa7HYEA1D9idDbmuv7YbsbVkQ+Hp+8KFSul4aE5e/i1bjCNIRYJZlA8Q8p0r9T8cF/RVvwUgRA//FydEyg==} - engines: {node: '>=0.6'} - dev: false + big-integer@1.6.36: {} - /big.js@6.2.1: - resolution: {integrity: sha512-bCtHMwL9LeDIozFn+oNhhFoq+yQ3BNdnsLSASUxLciOb1vgvpHsIO1dsENiGMgbb4SkP5TrzWzRiLddn8ahVOQ==} - dev: false + big.js@6.2.1: {} - /bignumber.js@7.2.1: - resolution: {integrity: sha512-S4XzBk5sMB+Rcb/LNcpzXr57VRTxgAvaAEDAl1AwRx27j00hT84O6OkteE7u8UB3NuaaygCRrEpqox4uDOrbdQ==} - dev: false + bignumber.js@7.2.1: {} - /bignumber.js@9.1.2: - resolution: {integrity: sha512-2/mKyZH9K85bzOEfhXDBFZTGd1CTs+5IHpeFQo9luiBG7hghdC851Pj2WAhb6E3R6b9tZj/XKhbg4fum+Kepug==} + bignumber.js@9.1.2: {} - /binary-extensions@2.3.0: - resolution: {integrity: sha512-Ceh+7ox5qe7LJuLHoY0feh3pHuUDHAcRUeyL2VYghZwfpkNIy/+8Ocg0a3UuSoYzavmylwuLWQOf3hl0jjMMIw==} - engines: {node: '>=8'} + bignumber.js@https://codeload.github.com/frozeman/bignumber.js-nolookahead/tar.gz/57692b3ecfc98bbdd6b3a516cb2353652ea49934: {} - /bindings@1.5.0: - resolution: {integrity: sha512-p2q/t/mhvuOj/UeLlV6566GD/guowlr0hHxClI0W9m7MWYkL1F0hLo+0Aexs9HSPCtR1SXQ0TD3MMKrXZajbiQ==} + binary-extensions@2.3.0: {} + + bindings@1.5.0: dependencies: file-uri-to-path: 1.0.0 - dev: false - /bl@4.1.0: - resolution: {integrity: sha512-1W07cM9gS6DcLperZfFSj+bWLtaPGSOHWhPiGzXmvVJbRLdG82sH/Kn8EtW1VqWVA54AKf2h5k5BbnIbwF3h6w==} + bl@4.1.0: dependencies: buffer: 5.7.1 inherits: 2.0.4 readable-stream: 3.6.2 - dev: false - /blakejs@1.2.1: - resolution: {integrity: sha512-QXUSXI3QVc/gJME0dBpXrag1kbzOqCjCX8/b54ntNyW6sjtoqxqRk3LTmXzaJoh71zMsDCjM+47jS7XiwN/+fQ==} + blakejs@1.2.1: {} - /bluebird@3.7.2: - resolution: {integrity: sha512-XpNj6GDQzdfW+r2Wnn7xiSAd7TM3jzkxGXBGTtWKuSXv1xUV+azxAm8jdWZN06QTQk+2N2XB9jRDkvbmQmcRtg==} + bluebird@3.7.2: {} - /bn-str-256@1.9.1: - resolution: {integrity: sha512-u3muv3WO5sYv9nUQsPnDGLg731yNt/MOlKPK5pmBVqClcl7tY97tyfKxw8ed44HVrpi+7dkgJgQpbXP47a3GoQ==} + bn-str-256@1.9.1: dependencies: decimal.js-light: 2.5.1 lodash: 4.17.21 - dev: false - /bn.js@4.11.6: - resolution: {integrity: sha512-XWwnNNFCuuSQ0m3r3C4LE3EiORltHd9M05pq6FOlVeiophzRbMo50Sbz1ehl8K3Z+jw9+vmgnXefY1hz8X+2wA==} + bn.js@4.11.6: {} - /bn.js@4.12.0: - resolution: {integrity: sha512-c98Bf3tPniI+scsdk237ku1Dc3ujXQTSgyiPUDEOe7tRkhrqridvh8klBv0HCEso1OLOYcHuCv/cS6DNxKH+ZA==} + bn.js@4.12.0: {} - /bn.js@5.2.1: - resolution: {integrity: sha512-eXRvHzWyYPBuB4NBy0cmYQjGitUrtqwbvlzP3G6VFnNRbsZQIxQ10PbKKHt8gZ/HW/D/747aDl+QkDqg3KQLMQ==} + bn.js@5.2.1: {} - /body-parser@1.20.2: - resolution: {integrity: sha512-ml9pReCu3M61kGlqoTm2umSXTlRTuGTx0bfYj+uIUKKYycG5NtSbeetV3faSU6R7ajOPw0g/J1PvK4qNy7s5bA==} - engines: {node: '>= 0.8', npm: 1.2.8000 || >= 1.4.16} + body-parser@1.20.2: dependencies: bytes: 3.1.2 content-type: 1.0.5 @@ -4608,17 +9233,11 @@ packages: transitivePeerDependencies: - supports-color - /boolbase@1.0.0: - resolution: {integrity: sha512-JZOSA7Mo9sNGB8+UjSgzdLtokWAky1zbztM3WRLCbZ70/3cTANmQmOdR7y2g+J0e2WXywy1yS468tY+IruqEww==} - dev: false + boolbase@1.0.0: {} - /boolean@3.2.0: - resolution: {integrity: sha512-d0II/GO9uf9lfUHH2BQsjxzRJZBdsjgsBiW4BvhWk/3qoKwQFjIDVN19PfX8F2D/r9PCMTtLWjYVCFrpeYUzsw==} - dev: true + boolean@3.2.0: {} - /boxen@5.1.2: - resolution: {integrity: sha512-9gYgQKXx+1nP8mP7CzFyaUARhg7D3n1dF/FnErWmu9l6JvGpNUN278h0aSb+QjoiKSWG+iZ3uHrcqk0qrY9RQQ==} - engines: {node: '>=10'} + boxen@5.1.2: dependencies: ansi-align: 3.0.1 camelcase: 6.3.0 @@ -4628,39 +9247,29 @@ packages: type-fest: 0.20.2 widest-line: 3.1.0 wrap-ansi: 7.0.0 - dev: false - /brace-expansion@1.1.11: - resolution: {integrity: sha512-iCuPHDFgrHX7H2vEI/5xpz07zSHB00TpugqhmYtVmMO6518mCuRMoOYFldEBl0g187ufozdaHgWKcYFb61qGiA==} + brace-expansion@1.1.11: dependencies: balanced-match: 1.0.2 concat-map: 0.0.1 - /brace-expansion@2.0.1: - resolution: {integrity: sha512-XnAIvQ8eM+kC6aULx6wuQiwVsnzsi9d3WxzV3FpWTGA19F621kwdbsAcFKXgKUHZWsy+mY6iL1sHTxWEFCytDA==} + brace-expansion@2.0.1: dependencies: balanced-match: 1.0.2 - /braces@3.0.2: - resolution: {integrity: sha512-b8um+L1RzM3WDSzvhm6gIz1yfTbBt6YTlcEKAvsmqCZZFw46z626lVj9j1yEPW33H5H+lBQpZMP1k8l+78Ha0A==} - engines: {node: '>=8'} + braces@3.0.2: dependencies: fill-range: 7.0.1 - /breakword@1.0.6: - resolution: {integrity: sha512-yjxDAYyK/pBvws9H4xKYpLDpYKEH6CzrBPAuXq3x18I+c/2MkVtT3qAr7Oloi6Dss9qNhPVueAAVU1CSeNDIXw==} + breakword@1.0.6: dependencies: wcwidth: 1.0.1 - dev: true - /brorand@1.1.0: - resolution: {integrity: sha512-cKV8tMCEpQs4hK/ik71d6LrPOnpkpGBR0wzxqr68g2m/LB2GxVYQroAjMJZRVM1Y4BCjCKc3vAamxSzOY2RP+w==} + brorand@1.1.0: {} - /browser-stdout@1.3.1: - resolution: {integrity: sha512-qhAVI1+Av2X7qelOfAIYwXONood6XlZE/fXaBSmW/T5SzLAmCgzi+eiWE7fUvbHaeNBQH13UftjpXxsfLkMpgw==} + browser-stdout@1.3.1: {} - /browserify-aes@1.2.0: - resolution: {integrity: sha512-+7CHXqGuspUn/Sl5aO7Ea0xWGAtETPXNSAjHo48JfLdPWcMng33Xe4znFvQweqc/uzk5zSOI3H52CYnjCfb5hA==} + browserify-aes@1.2.0: dependencies: buffer-xor: 1.0.3 cipher-base: 1.0.4 @@ -4669,83 +9278,56 @@ packages: inherits: 2.0.4 safe-buffer: 5.2.1 - /browserslist@4.23.0: - resolution: {integrity: sha512-QW8HiM1shhT2GuzkvklfjcKDiWFXHOeFCIA/huJPwHsslwcydgk7X+z2zXpEijP98UCY7HbubZt5J2Zgvf0CaQ==} - engines: {node: ^6 || ^7 || ^8 || ^9 || ^10 || ^11 || ^12 || >=13.7} - hasBin: true + browserslist@4.23.0: dependencies: caniuse-lite: 1.0.30001617 electron-to-chromium: 1.4.761 node-releases: 2.0.14 update-browserslist-db: 1.0.15(browserslist@4.23.0) - dev: true - /bs58@4.0.1: - resolution: {integrity: sha512-Ok3Wdf5vOIlBrgCvTq96gBkJw+JUEzdBgyaza5HLtPm7yTHkjRy8+JzNyHF7BHa0bNWOQIp3m5YF0nnFcOIKLw==} + bs58@4.0.1: dependencies: base-x: 3.0.9 - /bs58check@2.1.2: - resolution: {integrity: sha512-0TS1jicxdU09dwJMNZtVAfzPi6Q6QeN0pM1Fkzrjn+XYHvzMKPU3pHVpva+769iNVSfIYWf7LJ6WR+BuuMf8cA==} + bs58check@2.1.2: dependencies: bs58: 4.0.1 create-hash: 1.2.0 safe-buffer: 5.2.1 - /buffer-from@1.1.2: - resolution: {integrity: sha512-E+XQCRwSbaaiChtv6k6Dwgc+bx+Bs6vuKJHHl5kox/BaKbhiXzqQOwK4cO22yElGp2OCmjwVhT3HmxgyPGnJfQ==} + buffer-from@1.1.2: {} - /buffer-to-arraybuffer@0.0.5: - resolution: {integrity: sha512-3dthu5CYiVB1DEJp61FtApNnNndTckcqe4pFcLdvHtrpG+kcyekCJKg4MRiDcFW7A6AODnXB9U4dwQiCW5kzJQ==} + buffer-to-arraybuffer@0.0.5: {} - /buffer-xor@1.0.3: - resolution: {integrity: sha512-571s0T7nZWK6vB67HI5dyUF7wXiNcfaPPPTl6zYCNApANjIvYJTg7hlud/+cJpdAhS7dVzqMLmfhfHR3rAcOjQ==} + buffer-xor@1.0.3: {} - /buffer@5.7.1: - resolution: {integrity: sha512-EHcyIPBQ4BSGlvjB16k5KgAJ27CIsHY/2JBmCRReo48y9rQ3MaUzWX3KVlBa4U7MyX02HdVj0K7C3WaB3ju7FQ==} + buffer@5.7.1: dependencies: base64-js: 1.5.1 ieee754: 1.2.1 - /buffer@6.0.3: - resolution: {integrity: sha512-FTiCpNxtwiZZHEZbcbTIcZjERVICn9yq/pDFkTl95/AxzD1naBctN7YO68riM/gLSDY7sdrMby8hofADYuuqOA==} + buffer@6.0.3: dependencies: base64-js: 1.5.1 ieee754: 1.2.1 - /bufferutil@4.0.8: - resolution: {integrity: sha512-4T53u4PdgsXqKaIctwF8ifXlRTTmEPJ8iEPWFdGZvcf7sbwYo6FKFEX9eNNAnzFZ7EzJAQ3CJeOtCRA4rDp7Pw==} - engines: {node: '>=6.14.2'} - requiresBuild: true + bufferutil@4.0.8: dependencies: node-gyp-build: 4.8.1 - /builtin-modules@3.3.0: - resolution: {integrity: sha512-zhaCDicdLuWN5UbN5IMnFqNMhNfo919sH85y2/ea+5Yg9TsTkeZxpL+JLbp6cgYFS4sRLp3YV4S6yDuqVWHYOw==} - engines: {node: '>=6'} - dev: true + builtin-modules@3.3.0: {} - /builtins@5.1.0: - resolution: {integrity: sha512-SW9lzGTLvWTP1AY8xeAMZimqDrIaSdLQUcVr9DMef51niJ022Ri87SwRRKYm4A6iHfkPaiVUu/Duw2Wc4J7kKg==} + builtins@5.1.0: dependencies: semver: 7.6.2 - dev: true - /bytes@3.1.2: - resolution: {integrity: sha512-/Nf7TyzTx6S3yRJObOAV7956r8cr2+Oj8AC5dt8wSP3BQAoeX58NoHyCU8P8zGkNXStjTSi6fzO6F0pBdcYbEg==} - engines: {node: '>= 0.8'} + bytes@3.1.2: {} - /cacheable-lookup@5.0.4: - resolution: {integrity: sha512-2/kNscPhpcxrOigMZzbiWF7dz8ilhb/nIHU3EyZiXWXpeq/au8qJ8VhdftMkty3n7Gj6HIGalQG8oiBNB3AJgA==} - engines: {node: '>=10.6.0'} + cacheable-lookup@5.0.4: {} - /cacheable-lookup@6.1.0: - resolution: {integrity: sha512-KJ/Dmo1lDDhmW2XDPMo+9oiy/CeqosPguPCrgcVzKyZrL6pM1gU2GmPY/xo6OQPTUaA/c0kwHuywB4E6nmT9ww==} - engines: {node: '>=10.6.0'} + cacheable-lookup@6.1.0: {} - /cacheable-request@7.0.4: - resolution: {integrity: sha512-v+p6ongsrp0yTGbJXjgxPow2+DL93DASP4kXCDKb8/bwRtt9OEF3whggkkDkGNzgcWy2XaF4a8nZglC7uElscg==} - engines: {node: '>=8'} + cacheable-request@7.0.4: dependencies: clone-response: 1.0.3 get-stream: 5.2.0 @@ -4755,19 +9337,14 @@ packages: normalize-url: 6.1.0 responselike: 2.0.1 - /caching-transform@4.0.0: - resolution: {integrity: sha512-kpqOvwXnjjN44D89K5ccQC+RUrsy7jB/XLlRrx0D7/2HNcTPqzsb6XgYoErwko6QsV184CA2YgS1fxDiiDZMWA==} - engines: {node: '>=8'} + caching-transform@4.0.0: dependencies: hasha: 5.2.2 make-dir: 3.1.0 package-hash: 4.0.0 write-file-atomic: 3.0.3 - dev: true - /call-bind@1.0.7: - resolution: {integrity: sha512-GHTSNSYICQ7scH7sZ+M2rFopRoLh8t2bLSW6BbgrtLsahOIB5iyAVJf9GjWK3cYTDaMj4XdBpM1cA6pIS0Kv2w==} - engines: {node: '>= 0.4'} + call-bind@1.0.7: dependencies: es-define-property: 1.0.0 es-errors: 1.3.0 @@ -4775,85 +9352,50 @@ packages: get-intrinsic: 1.2.4 set-function-length: 1.2.2 - /callsites@3.1.0: - resolution: {integrity: sha512-P8BjAsXvZS+VIDUI11hHCQEv74YT67YUi5JJFNWIqL235sBmjX4+qx9Muvls5ivyNENctx46xQLQ3aTuE7ssaQ==} - engines: {node: '>=6'} + callsites@3.1.0: {} - /camel-case@3.0.0: - resolution: {integrity: sha512-+MbKztAYHXPr1jNTSKQF52VpcFjwY5RkR7fxksV8Doo4KAYc5Fl4UJRgthBbTmEx8C54DqahhbLJkDwjI3PI/w==} + camel-case@3.0.0: dependencies: no-case: 2.3.2 upper-case: 1.1.3 - dev: false - /camelcase-keys@6.2.2: - resolution: {integrity: sha512-YrwaA0vEKazPBkn0ipTiMpSajYDSe+KjQfrjhcBMxJt/znbvlHd8Pw/Vamaz5EB4Wfhs3SUR3Z9mwRu/P3s3Yg==} - engines: {node: '>=8'} + camelcase-keys@6.2.2: dependencies: camelcase: 5.3.1 map-obj: 4.3.0 quick-lru: 4.0.1 - dev: true - /camelcase@3.0.0: - resolution: {integrity: sha512-4nhGqUkc4BqbBBB4Q6zLuD7lzzrHYrjKGeYaEji/3tFR5VdJu9v+LilhGIVe8wxEJPPOeWo7eg8dwY13TZ1BNg==} - engines: {node: '>=0.10.0'} - dev: false + camelcase@3.0.0: {} - /camelcase@4.1.0: - resolution: {integrity: sha512-FxAv7HpHrXbh3aPo4o2qxHay2lkLY3x5Mw3KeE4KQE8ysVfziWeRZDwcjauvwBSGEC/nXUPzZy8zeh4HokqOnw==} - engines: {node: '>=4'} - dev: false + camelcase@4.1.0: {} - /camelcase@5.3.1: - resolution: {integrity: sha512-L28STB170nwWS63UjtlEOE3dldQApaJXZkOI1uMFfzf3rRuPegHaHesyee+YxQ+W6SvRDQV6UrdOdRiR153wJg==} - engines: {node: '>=6'} - dev: true + camelcase@5.3.1: {} - /camelcase@6.3.0: - resolution: {integrity: sha512-Gmy6FhYlCY7uOElZUSbxo2UCDH8owEk996gkbrpsgGtrJLM3J7jGxl9Ic7Qwwj4ivOE5AWZWRMecDdF7hqGjFA==} - engines: {node: '>=10'} + camelcase@6.3.0: {} - /caniuse-lite@1.0.30001617: - resolution: {integrity: sha512-mLyjzNI9I+Pix8zwcrpxEbGlfqOkF9kM3ptzmKNw5tizSyYwMe+nGLTqMK9cO+0E+Bh6TsBxNAaHWEM8xwSsmA==} - dev: true + caniuse-lite@1.0.30001617: {} - /caseless@0.12.0: - resolution: {integrity: sha512-4tYFyifaFfGacoiObjJegolkwSU4xQNGbVgUiNYVUxbQ2x2lUsFvY4hVgVzGiIe6WLOPqycWXA40l+PWsxthUw==} + caseless@0.12.0: {} - /cbor@5.2.0: - resolution: {integrity: sha512-5IMhi9e1QU76ppa5/ajP1BmMWZ2FHkhAhjeVKQ/EFCgYSEaeVaoGtL7cxJskf9oCCk+XjzaIdc3IuU/dbA/o2A==} - engines: {node: '>=6.0.0'} + cbor@5.2.0: dependencies: bignumber.js: 9.1.2 nofilter: 1.0.4 - dev: false - /cbor@8.1.0: - resolution: {integrity: sha512-DwGjNW9omn6EwP70aXsn7FQJx5kO12tX0bZkaTjzdVFM6/7nhA4t0EENocKGx6D2Bch9PE2KzCUf5SceBdeijg==} - engines: {node: '>=12.19'} + cbor@8.1.0: dependencies: nofilter: 3.1.0 - dev: false - /cbor@9.0.2: - resolution: {integrity: sha512-JPypkxsB10s9QOWwa6zwPzqE1Md3vqpPc+cai4sAecuCsRyAtAl/pMyhPlMbT/xtPnm2dznJZYRLui57qiRhaQ==} - engines: {node: '>=16'} + cbor@9.0.2: dependencies: nofilter: 3.1.0 - dev: true - /chai-as-promised@7.1.1(chai@4.4.1): - resolution: {integrity: sha512-azL6xMoi+uxu6z4rhWQ1jbdUhOMhis2PvscD/xjLqNMkv3BPPp2JyyuTHOrf9BOosGpNQ11v6BKv/g57RXbiaA==} - peerDependencies: - chai: '>= 2.1.2 < 5' + chai-as-promised@7.1.1(chai@4.4.1): dependencies: chai: 4.4.1 check-error: 1.0.3 - /chai@4.4.1: - resolution: {integrity: sha512-13sOfMv2+DWduEU+/xbun3LScLoqN17nBeTLUsmDfKdoiC1fr0n9PU4guu4AhRcOVFk/sW8LyZWHuhWtQZiF+g==} - engines: {node: '>=4'} + chai@4.4.1: dependencies: assertion-error: 1.1.0 check-error: 1.0.3 @@ -4863,32 +9405,24 @@ packages: pathval: 1.1.1 type-detect: 4.0.8 - /chalk@0.4.0: - resolution: {integrity: sha512-sQfYDlfv2DGVtjdoQqxS0cEZDroyG8h6TamA6rvxwlrU5BaSLDx9xhatBYl2pxZ7gmpNaPFVwBtdGdu5rQ+tYQ==} - engines: {node: '>=0.8.0'} + chalk@0.4.0: dependencies: ansi-styles: 1.0.0 has-color: 0.1.7 strip-ansi: 0.1.1 - dev: true - /chalk@2.4.2: - resolution: {integrity: sha512-Mti+f9lpJNcwF4tWV8/OrTTtF1gZi+f8FqlyAdouralcFWFQWF2+NgCHShjkCb+IFBLq9buZwE1xckQU4peSuQ==} - engines: {node: '>=4'} + chalk@2.4.2: dependencies: ansi-styles: 3.2.1 escape-string-regexp: 1.0.5 supports-color: 5.5.0 - /chalk@4.1.2: - resolution: {integrity: sha512-oKnbhFyRIXpUuez8iBMmyEa4nbj4IOQyuhc/wy9kY7/WVPcwIO9VA668Pu8RkO7+0G76SLROeyw9CpQ061i4mA==} - engines: {node: '>=10'} + chalk@4.1.2: dependencies: ansi-styles: 4.3.0 supports-color: 7.2.0 - /change-case@3.0.2: - resolution: {integrity: sha512-Mww+SLF6MZ0U6kdg11algyKd5BARbyM4TbFBepwowYSR5ClfQGCGtxNXgykpN0uF/bstWeaGDT4JWaDh8zWAHA==} + change-case@3.0.2: dependencies: camel-case: 3.0.0 constant-case: 2.0.0 @@ -4908,23 +9442,16 @@ packages: title-case: 2.1.1 upper-case: 1.1.3 upper-case-first: 1.1.2 - dev: false - /chardet@0.7.0: - resolution: {integrity: sha512-mT8iDcrh03qDGRRmoA2hmBJnxpllMR+0/0qlzjqZES6NdiWDcZkCNAk4rPFZ9Q85r27unkiNNg8ZOiwZXBHwcA==} - dev: true + chardet@0.7.0: {} - /charenc@0.0.2: - resolution: {integrity: sha512-yrLQ/yVUFXkzg7EDQsPieE/53+0RlaWTs+wBrvW36cyilJ2SaDWfl4Yj7MtLTXleV9uEKefbAGUPv2/iWSooRA==} - dev: true + charenc@0.0.2: {} - /check-error@1.0.3: - resolution: {integrity: sha512-iKEoDYaRmd1mxM90a2OEfWhjsjPpYPuQ+lMYsoxB126+t8fw7ySEO48nmDg5COTjxDI65/Y2OWpeEHk3ZOe8zg==} + check-error@1.0.3: dependencies: get-func-name: 2.0.2 - /cheerio-select@2.1.0: - resolution: {integrity: sha512-9v9kG0LvzrlcungtnJtpGNxY+fzECQKhK4EGJX2vByejiMX84MFNQw4UxPJl3bFbTMw+Dfs37XaIkCwTZfLh4g==} + cheerio-select@2.1.0: dependencies: boolbase: 1.0.0 css-select: 5.1.0 @@ -4932,11 +9459,8 @@ packages: domelementtype: 2.3.0 domhandler: 5.0.3 domutils: 3.1.0 - dev: false - /cheerio@1.0.0-rc.12: - resolution: {integrity: sha512-VqR8m68vM46BNnuZ5NtnGBKIE/DfN0cRIzg9n40EIq9NOv90ayxLBXA8fXC5gquFRGJSTRqBq25Jt2ECLR431Q==} - engines: {node: '>= 6'} + cheerio@1.0.0-rc.12: dependencies: cheerio-select: 2.1.0 dom-serializer: 2.0.0 @@ -4945,11 +9469,8 @@ packages: htmlparser2: 8.0.2 parse5: 7.1.2 parse5-htmlparser2-tree-adapter: 7.0.0 - dev: false - /chokidar@3.5.3: - resolution: {integrity: sha512-Dr3sfKRP6oTcjf2JmUmFJfeVMvXBdegxB0iVQ5eb2V10uFJUCAS8OByZdVAyVb8xXNz3GjjTgj9kLWsZTqE6kw==} - engines: {node: '>= 8.10.0'} + chokidar@3.5.3: dependencies: anymatch: 3.1.3 braces: 3.0.2 @@ -4961,9 +9482,7 @@ packages: optionalDependencies: fsevents: 2.3.3 - /chokidar@3.6.0: - resolution: {integrity: sha512-7VT13fmjotKpGipCW9JEQAusEPE+Ei8nl6/g4FBAmIm0GOOLMua9NDDo/DWp0ZAxCr3cPq5ZpBqmPAQgDda2Pw==} - engines: {node: '>= 8.10.0'} + chokidar@3.6.0: dependencies: anymatch: 3.1.3 braces: 3.0.2 @@ -4974,24 +9493,14 @@ packages: readdirp: 3.6.0 optionalDependencies: fsevents: 2.3.3 - dev: false - /chownr@1.1.4: - resolution: {integrity: sha512-jJ0bqzaylmJtVnNgzTeSOs8DPavpbYgEr/b0YL8/2GO3xJEhInFmhKMUnEJQjZumK7KXGFhUy89PrsJWlakBVg==} + chownr@1.1.4: {} - /ci-info@2.0.0: - resolution: {integrity: sha512-5tK7EtrZ0N+OLFMthtqOj4fI2Jeb88C4CAZPu25LDVUgXJ0A3Js4PMGqrn0JU1W0Mh1/Z8wZzYPxqUrXeBboCQ==} - dev: false + ci-info@2.0.0: {} - /ci-info@3.9.0: - resolution: {integrity: sha512-NIxF55hv4nSqQswkAeiOi1r83xy8JldOFDTWiug55KBu9Jnblncd2U6ViHmYgHf01TPZS77NJBhBMKdWj9HQMQ==} - engines: {node: '>=8'} - dev: true + ci-info@3.9.0: {} - /cids@0.7.5: - resolution: {integrity: sha512-zT7mPeghoWAu+ppn8+BS1tQ5qGmbMfB4AregnQjA/qHY3GC1m1ptI9GkWNlgeu38r7CuRdXB47uY2XgAYt6QVA==} - engines: {node: '>=4.0.0', npm: '>=3.0.0'} - deprecated: This module has been superseded by the multiformats module + cids@0.7.5: dependencies: buffer: 5.7.1 class-is: 1.1.0 @@ -4999,266 +9508,167 @@ packages: multicodec: 1.0.4 multihashes: 0.4.21 - /cipher-base@1.0.4: - resolution: {integrity: sha512-Kkht5ye6ZGmwv40uUDZztayT2ThLQGfnj/T71N/XzeZeo3nf8foyW7zGTsPYkEya3m5f3cAypH+qe7YOrM1U2Q==} + cipher-base@1.0.4: dependencies: inherits: 2.0.4 safe-buffer: 5.2.1 - /class-is@1.1.0: - resolution: {integrity: sha512-rhjH9AG1fvabIDoGRVH587413LPjTZgmDF9fOFCbFJQV4yuocX1mHxxvXI4g3cGwbVY9wAYIoKlg1N79frJKQw==} + class-is@1.1.0: {} - /clean-stack@2.2.0: - resolution: {integrity: sha512-4diC9HaTE+KRAMWhDhrGOECgWZxoevMc5TlkObMqNSsVU62PYzXZ/SMTjzyGAFF1YusgxGcSWTEXBhp0CPwQ1A==} - engines: {node: '>=6'} + clean-stack@2.2.0: {} - /cli-boxes@2.2.1: - resolution: {integrity: sha512-y4coMcylgSCdVinjiDBuR8PCC2bLjyGTwEmPb9NHR/QaNU6EUOXcTY/s6VjGMD6ENSEaeQYHCY0GNGS5jfMwPw==} - engines: {node: '>=6'} - dev: false + cli-boxes@2.2.1: {} - /cli-cursor@3.1.0: - resolution: {integrity: sha512-I/zHAwsKf9FqGoXM4WWRACob9+SNukZTd94DWF57E4toouRulbCxcUh6RKUEOQlYTHJnzkPMySvPNaaSLNfLZw==} - engines: {node: '>=8'} + cli-cursor@3.1.0: dependencies: restore-cursor: 3.1.0 - dev: false - /cli-spinners@2.9.2: - resolution: {integrity: sha512-ywqV+5MmyL4E7ybXgKys4DugZbX0FC6LnwrhjuykIjnK9k8OQacQ7axGKnjDXWNhns0xot3bZI5h55H8yo9cJg==} - engines: {node: '>=6'} - dev: false + cli-spinners@2.9.2: {} - /cli-table3@0.5.1: - resolution: {integrity: sha512-7Qg2Jrep1S/+Q3EceiZtQcDPWxhAvBw+ERf1162v4sikJrvojMHFqXt8QIVha8UlH9rgU0BeWPytZ9/TzYqlUw==} - engines: {node: '>=6'} + cli-table3@0.5.1: dependencies: object-assign: 4.1.1 string-width: 2.1.1 optionalDependencies: colors: 1.4.0 - dev: true - /cliui@3.2.0: - resolution: {integrity: sha512-0yayqDxWQbqk3ojkYqUKqaAQ6AfNKeKWRNA8kR0WXzAsdHpP4BIaOmMAG87JGuO6qcobyW4GjxHd9PmhEd+T9w==} + cliui@3.2.0: dependencies: string-width: 1.0.2 strip-ansi: 3.0.1 wrap-ansi: 2.1.0 - dev: false - /cliui@6.0.0: - resolution: {integrity: sha512-t6wbgtoCXvAzst7QgXxJYqPt0usEfbgQdftEPbLL/cvv6HPE5VgvqCuAIDR0NgU52ds6rFwqrgakNLrHEjCbrQ==} + cliui@6.0.0: dependencies: string-width: 4.2.3 strip-ansi: 6.0.1 wrap-ansi: 6.2.0 - dev: true - /cliui@7.0.4: - resolution: {integrity: sha512-OcRE68cOsVMXp1Yvonl/fzkQOyjLSu/8bhPDfQt0e0/Eb283TKP20Fs2MqoPsr9SwA595rRCA+QMzYc9nBP+JQ==} + cliui@7.0.4: dependencies: string-width: 4.2.3 strip-ansi: 6.0.1 wrap-ansi: 7.0.0 - /cliui@8.0.1: - resolution: {integrity: sha512-BSeNnyus75C4//NQ9gQt1/csTXyo/8Sb+afLAkzAptFuMsod9HFokGNudZpi/oQV73hnVK+sR+5PVRMd+Dr7YQ==} - engines: {node: '>=12'} + cliui@8.0.1: dependencies: string-width: 4.2.3 strip-ansi: 6.0.1 wrap-ansi: 7.0.0 - dev: true - /clone-response@1.0.3: - resolution: {integrity: sha512-ROoL94jJH2dUVML2Y/5PEDNaSHgeOdSDicUyS7izcF63G6sTc/FTjLub4b8Il9S8S0beOfYt0TaA5qvFK+w0wA==} + clone-response@1.0.3: dependencies: mimic-response: 1.0.1 - /clone@1.0.4: - resolution: {integrity: sha512-JQHZ2QMW6l3aH/j6xCqQThY/9OH4D/9ls34cgkUBiEeocRTU04tHfKPBsUK1PqZCUQM7GiA0IIXJSuXHI64Kbg==} - engines: {node: '>=0.8'} + clone@1.0.4: {} - /co@4.6.0: - resolution: {integrity: sha512-QVb0dM5HvG+uaxitm8wONl7jltx8dqhfU33DcqtOZcLSVIKSDDLDi7+0LbAKiyI8hD9u42m2YxXSkMGWThaecQ==} - engines: {iojs: '>= 1.0.0', node: '>= 0.12.0'} - dev: false + co@4.6.0: {} - /code-point-at@1.1.0: - resolution: {integrity: sha512-RpAVKQA5T63xEj6/giIbUEtZwJ4UFIc3ZtvEkiaUERylqe8xb5IvqcgOurZLahv93CLKfxcw5YI+DZcUBRyLXA==} - engines: {node: '>=0.10.0'} - dev: false + code-point-at@1.1.0: {} - /color-convert@1.9.3: - resolution: {integrity: sha512-QfAUtd+vFdAtFQcC8CCyYt1fYWxSqAiK2cSD6zDB8N3cpsEBAvRxp9zOGg6G/SHHJYAT88/az/IuDGALsNVbGg==} + color-convert@1.9.3: dependencies: color-name: 1.1.3 - /color-convert@2.0.1: - resolution: {integrity: sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ==} - engines: {node: '>=7.0.0'} + color-convert@2.0.1: dependencies: color-name: 1.1.4 - /color-name@1.1.3: - resolution: {integrity: sha512-72fSenhMw2HZMTVHeCA9KCmpEIbzWiQsjN+BHcBbS9vr1mtt+vJjPdksIBNUmKAW8TFUDPJK5SUU3QhE9NEXDw==} + color-name@1.1.3: {} - /color-name@1.1.4: - resolution: {integrity: sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA==} + color-name@1.1.4: {} - /colors@1.4.0: - resolution: {integrity: sha512-a+UqTh4kgZg/SlGvfbzDHpgRu7AAQOmmqRHJnxhRZICKFUT91brVhNNt58CMWU9PsBbv3PDCZUHbVxuDiH2mtA==} - engines: {node: '>=0.1.90'} + colors@1.4.0: {} - /combined-stream@1.0.8: - resolution: {integrity: sha512-FQN4MRfuJeHf7cBbBMJFXhKSDq+2kAArBlmRBvcvFE5BB1HZKXtSFASDhdlz9zOYwxh8lDdnvmMOe/+5cdoEdg==} - engines: {node: '>= 0.8'} + combined-stream@1.0.8: dependencies: delayed-stream: 1.0.0 - /command-exists@1.2.9: - resolution: {integrity: sha512-LTQ/SGc+s0Xc0Fu5WaKnR0YiygZkm9eKFvyS+fRsU7/ZWFF8ykFM6Pc9aCVf1+xasOOZpO3BAVgVrKvsqKHV7w==} - dev: false + command-exists@1.2.9: {} - /command-line-args@5.2.1: - resolution: {integrity: sha512-H4UfQhZyakIjC74I9d34fGYDwk3XpSr17QhEd0Q3I9Xq1CETHo4Hcuo87WyWHpAF1aSLjLRf5lD9ZGX2qStUvg==} - engines: {node: '>=4.0.0'} + command-line-args@5.2.1: dependencies: array-back: 3.1.0 find-replace: 3.0.0 lodash.camelcase: 4.3.0 typical: 4.0.0 - dev: true - /command-line-usage@6.1.3: - resolution: {integrity: sha512-sH5ZSPr+7UStsloltmDh7Ce5fb8XPlHyoPzTpyyMuYCtervL65+ubVZ6Q61cFtFl62UyJlc8/JwERRbAFPUqgw==} - engines: {node: '>=8.0.0'} + command-line-usage@6.1.3: dependencies: array-back: 4.0.2 chalk: 2.4.2 table-layout: 1.0.2 typical: 5.2.0 - dev: true - /commander@10.0.1: - resolution: {integrity: sha512-y4Mg2tXshplEbSGzx7amzPwKKOCGuoSRP/CjEdwwk0FOGlUbq6lKuoyDZTNZkmxHdJtp54hdfY/JUrdL7Xfdug==} - engines: {node: '>=14'} + commander@10.0.1: {} - /commander@2.20.3: - resolution: {integrity: sha512-GpVkmM8vF2vQUkj2LvZmD35JxeJOLCwJ9cUkugyk2nuhbv3+mJvpLYYt+0+USMxE+oj+ey/lJEnhZw75x/OMcQ==} - dev: false + commander@2.20.3: {} - /commander@3.0.2: - resolution: {integrity: sha512-Gar0ASD4BDyKC4hl4DwHqDrmvjoxWKZigVnAbn5H1owvm4CxCPdb0HQDehwNYMJpla5+M2tPmPARzhtYuwpHow==} - dev: false + commander@3.0.2: {} - /commander@6.2.1: - resolution: {integrity: sha512-U7VdrJFnJgo4xjrHpTzu0yrHPGImdsmD95ZlgYSEajAn2JKzDhDTPG9kBTefmObL2w/ngeZnilk+OV9CG3d7UA==} - engines: {node: '>= 6'} - dev: true + commander@6.2.1: {} - /commondir@1.0.1: - resolution: {integrity: sha512-W9pAhw0ja1Edb5GVdIF1mjZw/ASI0AlShXM83UUGe2DVr5TdAPEA1OA8m/g8zWp9x6On7gqufY+FatDbC3MDQg==} - dev: true + commondir@1.0.1: {} - /concat-map@0.0.1: - resolution: {integrity: sha512-/Srv4dswyQNBfohGpz9o6Yb3Gz3SrUDqBH5rTuhGR7ahtlbYKnVxw2bCFMRljaA7EXHaXZ8wsHdodFvbkhKmqg==} + concat-map@0.0.1: {} - /concat-stream@1.6.2: - resolution: {integrity: sha512-27HBghJxjiZtIk3Ycvn/4kbJk/1uZuJFfuPEns6LaEvpvG1f0hTea8lilrouyo9mVc2GWdcEZ8OLoGmSADlrCw==} - engines: {'0': node >= 0.8} + concat-stream@1.6.2: dependencies: buffer-from: 1.1.2 inherits: 2.0.4 readable-stream: 2.3.8 typedarray: 0.0.6 - dev: true - /constant-case@2.0.0: - resolution: {integrity: sha512-eS0N9WwmjTqrOmR3o83F5vW8Z+9R1HnVz3xmzT2PMFug9ly+Au/fxRWlEBSb6LcZwspSsEn9Xs1uw9YgzAg1EQ==} + constant-case@2.0.0: dependencies: snake-case: 2.1.0 upper-case: 1.1.3 - dev: false - /content-disposition@0.5.4: - resolution: {integrity: sha512-FveZTNuGw04cxlAiWbzi6zTAL/lhehaWbTtgluJh4/E95DqMwTmha3KZN1aAWA8cFIhHzMZUvLevkw5Rqk+tSQ==} - engines: {node: '>= 0.6'} + content-disposition@0.5.4: dependencies: safe-buffer: 5.2.1 - /content-hash@2.5.2: - resolution: {integrity: sha512-FvIQKy0S1JaWV10sMsA7TRx8bpU+pqPkhbsfvOJAdjRXvYxEckAwQWGwtRjiaJfh+E0DvcWUGqcdjwMGFjsSdw==} + content-hash@2.5.2: dependencies: cids: 0.7.5 multicodec: 0.5.7 multihashes: 0.4.21 - /content-type@1.0.5: - resolution: {integrity: sha512-nTjqfcBFEipKdXCv4YDQWCfmcLZKm81ldF0pAopTvyrFGVbcR6P/VAAd5G7N+0tTr8QqiU0tFadD6FK4NtJwOA==} - engines: {node: '>= 0.6'} + content-type@1.0.5: {} - /convert-source-map@1.9.0: - resolution: {integrity: sha512-ASFBup0Mz1uyiIjANan1jzLQami9z1PoYSZCiiYW2FczPbenXc45FZdBZLzOT+r6+iciuEModtmCti+hjaAk0A==} - dev: true + convert-source-map@1.9.0: {} - /convert-source-map@2.0.0: - resolution: {integrity: sha512-Kvp459HrV2FEJ1CAsi1Ku+MY3kasH19TFykTz2xWmMeq6bk2NU3XXvfJ+Q61m0xktWwt+1HSYf3JZsTms3aRJg==} - dev: true + convert-source-map@2.0.0: {} - /cookie-signature@1.0.6: - resolution: {integrity: sha512-QADzlaHc8icV8I7vbaJXJwod9HWYp8uCqf1xa4OfNu1T7JVxQIrUgOWtHdNDtPiywmFbiS12VjotIXLrKM3orQ==} + cookie-signature@1.0.6: {} - /cookie@0.4.2: - resolution: {integrity: sha512-aSWTXFzaKWkvHO1Ny/s+ePFpvKsPnjc551iI41v3ny/ow6tBG5Vd+FuqGNhh1LxOmVzOlGUriIlOaokOvhaStA==} - engines: {node: '>= 0.6'} - dev: false + cookie@0.4.2: {} - /cookie@0.6.0: - resolution: {integrity: sha512-U71cyTamuh1CRNCfpGY6to28lxvNwPG4Guz/EVjgf3Jmzv0vlDp1atT9eS5dDjMYHucpHbWns6Lwf3BKz6svdw==} - engines: {node: '>= 0.6'} + cookie@0.6.0: {} - /cookiejar@2.1.4: - resolution: {integrity: sha512-LDx6oHrK+PhzLKJU9j5S7/Y3jM/mUHvD/DeI1WQmJn652iPC5Y4TBzC9l+5OMOXlyTTA+SmVUPm0HQUwpD5Jqw==} - dev: true + cookiejar@2.1.4: {} - /core-util-is@1.0.2: - resolution: {integrity: sha512-3lqz5YjWTYnW6dlDa5TLaTCcShfar1e40rmcJVwCBJC6mWlFuj0eCHIElmG1g5kyuJ/GD+8Wn4FFCcz4gJPfaQ==} + core-util-is@1.0.2: {} - /core-util-is@1.0.3: - resolution: {integrity: sha512-ZQBvi1DcpJ4GDqanjucZ2Hj3wEO5pZDS89BWbkcrvdxksJorwUDDZamX9ldFkp9aw2lmBDLgkObEA4DWNJ9FYQ==} - dev: true + core-util-is@1.0.3: {} - /cors@2.8.5: - resolution: {integrity: sha512-KIHbLJqu73RGr/hnbrO9uBeixNGuvSQjul/jdFvS/KFSIH1hWVd1ng7zOHx+YrEfInLG7q4n6GHQ9cDtxv/P6g==} - engines: {node: '>= 0.10'} + cors@2.8.5: dependencies: object-assign: 4.1.1 vary: 1.1.2 - /cosmiconfig@8.3.6(typescript@5.0.4): - resolution: {integrity: sha512-kcZ6+W5QzcJ3P1Mt+83OUv/oHFqZHIx8DuxG6eZ5RGMERoLqp4BuGjhHLYGK+Kf5XVkQvqBSmAy/nGWN3qDgEA==} - engines: {node: '>=14'} - peerDependencies: - typescript: '>=4.9.5' - peerDependenciesMeta: - typescript: - optional: true + cosmiconfig@8.3.6(typescript@5.0.4): dependencies: import-fresh: 3.3.0 js-yaml: 4.1.0 parse-json: 5.2.0 path-type: 4.0.0 + optionalDependencies: typescript: 5.0.4 - /crc-32@1.2.2: - resolution: {integrity: sha512-ROmzCKrTnOwybPcJApAA6WBWij23HVfGVNKqqrZpuyZOHqK2CwHSvpGuyt/UNNvaIjEd8X5IFGp4Mh+Ie1IHJQ==} - engines: {node: '>=0.8'} - hasBin: true + crc-32@1.2.2: {} - /create-hash@1.2.0: - resolution: {integrity: sha512-z00bCGNHDG8mHAkP7CtT1qVu+bFQUPjYq/4Iv3C3kWjTFV10zIjfSoeqXo9Asws8gwSHDGj/hl2u4OGIjapeCg==} + create-hash@1.2.0: dependencies: cipher-base: 1.0.4 inherits: 2.0.4 @@ -5266,8 +9676,7 @@ packages: ripemd160: 2.0.2 sha.js: 2.4.11 - /create-hmac@1.1.7: - resolution: {integrity: sha512-MJG9liiZ+ogc4TzUwuvbER1JRdgvUFSB5+VR/g5h82fGaIRWMWddtKBHi7/sVhfjQZ6SehlyhvQYrcYkaUIpLg==} + create-hmac@1.1.7: dependencies: cipher-base: 1.0.4 create-hash: 1.2.0 @@ -5276,47 +9685,35 @@ packages: safe-buffer: 5.2.1 sha.js: 2.4.11 - /create-require@1.1.1: - resolution: {integrity: sha512-dcKFX3jn0MpIaXjisoRvexIJVEKzaq7z2rZKxf+MSr9TkdmHmsU4m2lcLojrj/FHl8mk5VxMmYA+ftRkP/3oKQ==} - dev: true + create-require@1.1.1: {} - /cross-fetch@3.1.8: - resolution: {integrity: sha512-cvA+JwZoU0Xq+h6WkMvAUqPEYy92Obet6UdKLfW60qn99ftItKjB5T+BkyWOFWe2pUyfQ+IJHmpOTznqk1M6Kg==} + cross-fetch@3.1.8: dependencies: node-fetch: 2.7.0 transitivePeerDependencies: - encoding - dev: false - /cross-fetch@4.0.0: - resolution: {integrity: sha512-e4a5N8lVvuLgAWgnCrLr2PP0YyDOTHa9H/Rj54dirp61qXnNq46m82bRhNqIA5VccJtWBvPTFRV3TtvHUKPB1g==} + cross-fetch@4.0.0: dependencies: node-fetch: 2.7.0 transitivePeerDependencies: - encoding - /cross-spawn@5.1.0: - resolution: {integrity: sha512-pTgQJ5KC0d2hcY8eyL1IzlBPYjTkyH72XRZPnLyKus2mBfNjQs3klqbJU2VILqZryAZUt9JOb3h/mWMy23/f5A==} + cross-spawn@5.1.0: dependencies: lru-cache: 4.1.5 shebang-command: 1.2.0 which: 1.3.1 - dev: true - /cross-spawn@7.0.3: - resolution: {integrity: sha512-iRDPJKUPVEND7dHPO8rkbOnPpyDygcDFtWjpeWNCgy8WP2rXcxXL8TskReQl6OrB2G7+UJrags1q15Fudc7G6w==} - engines: {node: '>= 8'} + cross-spawn@7.0.3: dependencies: path-key: 3.1.1 shebang-command: 2.0.0 which: 2.0.2 - /crypt@0.0.2: - resolution: {integrity: sha512-mCxBlsHFYh9C+HVpiEacem8FEBnMXgU9gy4zmNC+SXAZNB/1idgp/aulFJ4FgCi7GPEVbfyng092GqL2k2rmow==} - dev: true + crypt@0.0.2: {} - /crypto-addr-codec@0.1.8: - resolution: {integrity: sha512-GqAK90iLLgP3FvhNmHbpT3wR6dEdaM8hZyZtLX29SPardh3OA13RFLHDR6sntGCgRWOfiHqW6sIyohpNqOtV/g==} + crypto-addr-codec@0.1.8: dependencies: base-x: 3.0.9 big-integer: 1.6.36 @@ -5325,365 +9722,217 @@ packages: ripemd160-min: 0.0.6 safe-buffer: 5.2.1 sha3: 2.1.4 - dev: false - /crypto-js@3.3.0: - resolution: {integrity: sha512-DIT51nX0dCfKltpRiXV+/TVZq+Qq2NgF4644+K7Ttnla7zEzqc+kjJyiB96BHNyUTBxyjzRcZYpUdZa+QAqi6Q==} + crypto-js@3.3.0: {} - /crypto-js@4.2.0: - resolution: {integrity: sha512-KALDyEYgpY+Rlob/iriUtjV6d5Eq+Y191A5g4UqLAi8CyGP9N1+FdVbkc1SxKc2r4YAYqG8JzO2KGL+AizD70Q==} - dev: false + crypto-js@4.2.0: {} - /css-select@5.1.0: - resolution: {integrity: sha512-nwoRF1rvRRnnCqqY7updORDsuqKzqYJ28+oSMaJMMgOauh3fvwHqMS7EZpIPqK8GL+g9mKxF1vP/ZjSeNjEVHg==} + css-select@5.1.0: dependencies: boolbase: 1.0.0 css-what: 6.1.0 domhandler: 5.0.3 domutils: 3.1.0 nth-check: 2.1.1 - dev: false - /css-what@6.1.0: - resolution: {integrity: sha512-HTUrgRJ7r4dsZKU6GjmpfRK1O76h97Z8MfS1G0FozR+oF2kG6Vfe8JE6zwrkbxigziPHinCJ+gCPjA9EaBDtRw==} - engines: {node: '>= 6'} - dev: false + css-what@6.1.0: {} - /csv-generate@3.4.3: - resolution: {integrity: sha512-w/T+rqR0vwvHqWs/1ZyMDWtHHSJaN06klRqJXBEpDJaM/+dZkso0OKh1VcuuYvK3XM53KysVNq8Ko/epCK8wOw==} - dev: true + csv-generate@3.4.3: {} - /csv-parse@4.16.3: - resolution: {integrity: sha512-cO1I/zmz4w2dcKHVvpCr7JVRu8/FymG5OEpmvsZYlccYolPBLoVGKUHgNoc4ZGkFeFlWGEDmMyBM+TTqRdW/wg==} - dev: true + csv-parse@4.16.3: {} - /csv-stringify@5.6.5: - resolution: {integrity: sha512-PjiQ659aQ+fUTQqSrd1XEDnOr52jh30RBurfzkscaE2tPaFsDH5wOAHJiw8XAHphRknCwMUE9KRayc4K/NbO8A==} - dev: true + csv-stringify@5.6.5: {} - /csv@5.5.3: - resolution: {integrity: sha512-QTaY0XjjhTQOdguARF0lGKm5/mEq9PD9/VhZZegHDIBq2tQwgNpHc3dneD4mGo2iJs+fTKv5Bp0fZ+BRuY3Z0g==} - engines: {node: '>= 0.1.90'} + csv@5.5.3: dependencies: csv-generate: 3.4.3 csv-parse: 4.16.3 csv-stringify: 5.6.5 stream-transform: 2.1.3 - dev: true - /d@1.0.2: - resolution: {integrity: sha512-MOqHvMWF9/9MX6nza0KgvFH4HpMU0EF5uUDXqX/BtxtU8NfB0QzRtJ8Oe/6SuS4kbhyzVJwjd97EA4PKrzJ8bw==} - engines: {node: '>=0.12'} + d@1.0.2: dependencies: es5-ext: 0.10.64 type: 2.7.2 - /dashdash@1.14.1: - resolution: {integrity: sha512-jRFi8UDGo6j+odZiEpjazZaWqEal3w/basFjQHQEwVtZJGDpxbH1MeYluwCS8Xq5wmLJooDlMgvVarmWfGM44g==} - engines: {node: '>=0.10'} + dashdash@1.14.1: dependencies: assert-plus: 1.0.0 - /data-view-buffer@1.0.1: - resolution: {integrity: sha512-0lht7OugA5x3iJLOWFhWK/5ehONdprk0ISXqVFn/NFrDu+cuc8iADFrGQz5BnRK7LLU3JmkbXSxaqX+/mXYtUA==} - engines: {node: '>= 0.4'} + data-view-buffer@1.0.1: dependencies: call-bind: 1.0.7 es-errors: 1.3.0 is-data-view: 1.0.1 - dev: true - /data-view-byte-length@1.0.1: - resolution: {integrity: sha512-4J7wRJD3ABAzr8wP+OcIcqq2dlUKp4DVflx++hs5h5ZKydWMI6/D/fAot+yh6g2tHh8fLFTvNOaVN357NvSrOQ==} - engines: {node: '>= 0.4'} + data-view-byte-length@1.0.1: dependencies: call-bind: 1.0.7 es-errors: 1.3.0 is-data-view: 1.0.1 - dev: true - /data-view-byte-offset@1.0.0: - resolution: {integrity: sha512-t/Ygsytq+R995EJ5PZlD4Cu56sWa8InXySaViRzw9apusqsOO2bQP+SbYzAhR0pFKoB+43lYy8rWban9JSuXnA==} - engines: {node: '>= 0.4'} + data-view-byte-offset@1.0.0: dependencies: call-bind: 1.0.7 es-errors: 1.3.0 is-data-view: 1.0.1 - dev: true - /date-time@0.1.1: - resolution: {integrity: sha512-p4psdkgdNA6x0600SKbfWiOomNb33ADBMRHf49GMhYVgJsPefZlMSLXXVWWUpbqSxB3DL5/cxKa6a8i3XPK5Xg==} - engines: {node: '>=0.10.0'} - dev: true + date-time@0.1.1: {} - /death@1.1.0: - resolution: {integrity: sha512-vsV6S4KVHvTGxbEcij7hkWRv0It+sGGWVOM67dQde/o5Xjnr+KmLjxWJii2uEObIrt1CcM9w0Yaovx+iOlIL+w==} - dev: true + death@1.1.0: {} - /debug@2.6.9: - resolution: {integrity: sha512-bC7ElrdJaJnPbAP+1EotYvqZsb3ecl5wi6Bfi6BJTUcNowp6cvspg0jXznRTKDjm/E7AdgFBVeAPVMNcKGsHMA==} - peerDependencies: - supports-color: '*' - peerDependenciesMeta: - supports-color: - optional: true + debug@2.6.9: dependencies: ms: 2.0.0 - /debug@3.2.7: - resolution: {integrity: sha512-CFjzYYAi4ThfiQvizrFQevTTXHtnCqWfe7x1AhgEscTz6ZbLbfoLRLPugTQyBth6f8ZERVUSyWHFD/7Wu4t1XQ==} - peerDependencies: - supports-color: '*' - peerDependenciesMeta: - supports-color: - optional: true + debug@3.2.7: dependencies: ms: 2.1.3 - /debug@4.3.4(supports-color@8.1.1): - resolution: {integrity: sha512-PRWFHuSU3eDtQJPvnNY7Jcket1j0t5OuOsFzPPzsekD52Zl8qUfFIPEiswXqIvHWGVHOgX+7G/vCNNhehwxfkQ==} - engines: {node: '>=6.0'} - peerDependencies: - supports-color: '*' - peerDependenciesMeta: - supports-color: - optional: true + debug@4.3.4(supports-color@8.1.1): dependencies: ms: 2.1.2 + optionalDependencies: supports-color: 8.1.1 - /decamelize-keys@1.1.1: - resolution: {integrity: sha512-WiPxgEirIV0/eIOMcnFBA3/IJZAZqKnwAwWyvvdi4lsr1WCN22nhdf/3db3DoZcUjTV2SqfzIwNyp6y2xs3nmg==} - engines: {node: '>=0.10.0'} + decamelize-keys@1.1.1: dependencies: decamelize: 1.2.0 map-obj: 1.0.1 - dev: true - /decamelize@1.2.0: - resolution: {integrity: sha512-z2S+W9X73hAUUki+N+9Za2lBlun89zigOyGrsax+KUQ6wKW4ZoWpEYBkGhQjwAjjDCkWxhY0VKEhk8wzY7F5cA==} - engines: {node: '>=0.10.0'} + decamelize@1.2.0: {} - /decamelize@4.0.0: - resolution: {integrity: sha512-9iE1PgSik9HeIIw2JO94IidnE3eBoQrFJ3w7sFuzSX4DpmZ3v5sZpUiV5Swcf6mQEF+Y0ru8Neo+p+nyh2J+hQ==} - engines: {node: '>=10'} + decamelize@4.0.0: {} - /decimal.js-light@2.5.1: - resolution: {integrity: sha512-qIMFpTMZmny+MMIitAB6D7iVPEorVw6YQRWkvarTkT4tBeSLLiHzcwj6q0MmYSFCiVpiqPJTJEYIrpcPzVEIvg==} - dev: false + decimal.js-light@2.5.1: {} - /decode-uri-component@0.2.2: - resolution: {integrity: sha512-FqUYQ+8o158GyGTrMFJms9qh3CqTKvAqgqsTnkLI8sKu0028orqBhxNMFkFen0zGyg6epACD32pjVk58ngIErQ==} - engines: {node: '>=0.10'} + decode-uri-component@0.2.2: {} - /decompress-response@3.3.0: - resolution: {integrity: sha512-BzRPQuY1ip+qDonAOz42gRm/pg9F768C+npV/4JOsxRC2sq+Rlk+Q4ZCAsOhnIaMrgarILY+RMUIvMmmX1qAEA==} - engines: {node: '>=4'} + decompress-response@3.3.0: dependencies: mimic-response: 1.0.1 - /decompress-response@6.0.0: - resolution: {integrity: sha512-aW35yZM6Bb/4oJlZncMH2LCoZtJXTRxES17vE3hoRiowU2kWHaJKFkSBDnDR+cm9J+9QhXmREyIfv0pji9ejCQ==} - engines: {node: '>=10'} + decompress-response@6.0.0: dependencies: mimic-response: 3.1.0 - /deep-eql@4.1.3: - resolution: {integrity: sha512-WaEtAOpRA1MQ0eohqZjpGD8zdI0Ovsm8mmFhaDN8dvDZzyoUMcYDnf5Y6iu7HTXxf8JDS23qWa4a+hKCDyOPzw==} - engines: {node: '>=6'} + deep-eql@4.1.3: dependencies: type-detect: 4.0.8 - /deep-extend@0.6.0: - resolution: {integrity: sha512-LOHxIOaPYdHlJRtCQfDIVZtfw/ufM8+rVj649RIHzcm/vGwQRXFt6OPqIFWsm2XEMrNIEtWR64sY1LEKD2vAOA==} - engines: {node: '>=4.0.0'} + deep-extend@0.6.0: {} - /deep-is@0.1.4: - resolution: {integrity: sha512-oIPzksmTg4/MriiaYGO+okXDT7ztn/w3Eptv/+gSIdMdKsJo0u4CfYNFJPy+4SKMuCqGw2wxnA+URMg3t8a/bQ==} + deep-is@0.1.4: {} - /deepmerge@4.3.1: - resolution: {integrity: sha512-3sUqbMEc77XqpdNO7FRyRog+eW3ph+GYCbj+rK+uYyRMuwsVy0rMiVtPn+QJlKFvWP/1PYpapqYn0Me2knFn+A==} - engines: {node: '>=0.10.0'} - dev: true + deepmerge@4.3.1: {} - /default-require-extensions@3.0.1: - resolution: {integrity: sha512-eXTJmRbm2TIt9MgWTsOH1wEuhew6XGZcMeGKCtLedIg/NCsg1iBePXkceTdK4Fii7pzmN9tGsZhKzZ4h7O/fxw==} - engines: {node: '>=8'} + default-require-extensions@3.0.1: dependencies: strip-bom: 4.0.0 - dev: true - /defaults@1.0.4: - resolution: {integrity: sha512-eFuaLoy/Rxalv2kr+lqMlUnrDWV+3j4pljOIJgLIhI058IQfWJ7vXhyEIHu+HtC738klGALYxOKDO0bQP3tg8A==} + defaults@1.0.4: dependencies: clone: 1.0.4 - /defer-to-connect@2.0.1: - resolution: {integrity: sha512-4tvttepXG1VaYGrRibk5EwJd1t4udunSOVMdLSAL6mId1ix438oPwPZMALY41FCijukO1L0twNcGsdzS7dHgDg==} - engines: {node: '>=10'} + defer-to-connect@2.0.1: {} - /define-data-property@1.1.4: - resolution: {integrity: sha512-rBMvIzlpA8v6E+SJZoo++HAYqsLrkg7MSfIinMPFhmkorw7X+dOXVJQs+QT69zGkzMyfDnIMN2Wid1+NbL3T+A==} - engines: {node: '>= 0.4'} + define-data-property@1.1.4: dependencies: es-define-property: 1.0.0 es-errors: 1.3.0 gopd: 1.0.1 - /define-properties@1.2.1: - resolution: {integrity: sha512-8QmQKqEASLd5nx0U1B1okLElbUuuttJ/AnYmRXbbbGDWh6uS208EjD4Xqq/I9wK7u0v6O08XhTWnt5XtEbR6Dg==} - engines: {node: '>= 0.4'} + define-properties@1.2.1: dependencies: define-data-property: 1.1.4 has-property-descriptors: 1.0.2 object-keys: 1.1.1 - dev: true - /delayed-stream@1.0.0: - resolution: {integrity: sha512-ZySD7Nf91aLB0RxL4KGrKHBXl7Eds1DAmEdcoVawXnLD7SDhpNgtuII2aAkg7a7QS41jxPSZ17p4VdGnMHk3MQ==} - engines: {node: '>=0.4.0'} + delayed-stream@1.0.0: {} - /depd@2.0.0: - resolution: {integrity: sha512-g7nH6P6dyDioJogAAGprGpCtVImJhpPk/roCzdb3fIh61/s/nPsfR6onyMwkCAR/OlC3yBC0lESvUoQEAssIrw==} - engines: {node: '>= 0.8'} + depd@2.0.0: {} - /destroy@1.2.0: - resolution: {integrity: sha512-2sJGJTaXIIaR1w4iJSNoN0hnMY7Gpc/n8D4qSCJw8QqFWXf7cuAgnEHxBpweaVcPevC2l3KpjYCx3NypQQgaJg==} - engines: {node: '>= 0.8', npm: 1.2.8000 || >= 1.4.16} + destroy@1.2.0: {} - /detect-indent@5.0.0: - resolution: {integrity: sha512-rlpvsxUtM0PQvy9iZe640/IWwWYyBsTApREbA1pHOpmOUIl9MkP/U4z7vTtg4Oaojvqhxt7sdufnT0EzGaR31g==} - engines: {node: '>=4'} - dev: false + detect-indent@5.0.0: {} - /detect-indent@6.1.0: - resolution: {integrity: sha512-reYkTUJAZb9gUuZ2RvVCNhVHdg62RHnJ7WJl8ftMi4diZ6NWlciOzQN88pUhSELEwflJht4oQDv0F0BMlwaYtA==} - engines: {node: '>=8'} - dev: true + detect-indent@6.1.0: {} - /detect-libc@2.0.3: - resolution: {integrity: sha512-bwy0MGW55bG41VqxxypOsdSdGqLwXPI/focwgTYCFMbdUiBAxLg9CFzG08sz2aqzknwiX7Hkl0bQENjg8iLByw==} - engines: {node: '>=8'} - dev: false + detect-libc@2.0.3: {} - /detect-node@2.1.0: - resolution: {integrity: sha512-T0NIuQpnTvFDATNuHN5roPwSBG83rFsuO+MXXH9/3N1eFbn4wcPjttvjMLEPWJ0RGUYgQE7cGgS3tNxbqCGM7g==} - dev: true + detect-node@2.1.0: {} - /detect-port@1.6.1: - resolution: {integrity: sha512-CmnVc+Hek2egPx1PeTFVta2W78xy2K/9Rkf6cC4T59S50tVnzKj+tnx5mmx5lwvCkujZ4uRrpRSuV+IVs3f90Q==} - engines: {node: '>= 4.0.0'} - hasBin: true + detect-port@1.6.1: dependencies: address: 1.2.2 debug: 4.3.4(supports-color@8.1.1) transitivePeerDependencies: - supports-color - dev: true - /diff-sequences@29.6.3: - resolution: {integrity: sha512-EjePK1srD3P08o2j4f0ExnylqRs5B9tJjcp9t1krH2qRi8CCdsYfwe9JgSLurFBWwq4uOlipzfk5fHNvwFKr8Q==} - engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0} - dev: true + diff-sequences@29.6.3: {} - /diff@4.0.2: - resolution: {integrity: sha512-58lmxKSA4BNyLz+HHMUzlOEpg09FV+ev6ZMe3vJihgdxzgcwZ8VoEEPmALCZG9LmqfVoNMMKpttIYTVG6uDY7A==} - engines: {node: '>=0.3.1'} - dev: true + diff@4.0.2: {} - /diff@5.0.0: - resolution: {integrity: sha512-/VTCrvm5Z0JGty/BWHljh+BAiw3IK+2j87NGMu8Nwc/f48WoDAC395uomO9ZD117ZOBaHmkX1oyLvkVM/aIT3w==} - engines: {node: '>=0.3.1'} + diff@5.0.0: {} - /difflib@0.2.4: - resolution: {integrity: sha512-9YVwmMb0wQHQNr5J9m6BSj6fk4pfGITGQOOs+D9Fl+INODWFOfvhIU1hNv6GgR1RBoC/9NJcwu77zShxV0kT7w==} + difflib@0.2.4: dependencies: heap: 0.2.7 - dev: true - /dir-glob@3.0.1: - resolution: {integrity: sha512-WkrWp9GR4KXfKGYzOLmTuGVi1UWFfws377n9cc55/tb6DuqyF6pcQ5AbiHEshaDpY9v6oaSr2XCDidGmMwdzIA==} - engines: {node: '>=8'} + dir-glob@3.0.1: dependencies: path-type: 4.0.0 - /doctrine@2.1.0: - resolution: {integrity: sha512-35mSku4ZXK0vfCuHEDAwt55dg2jNajHZ1odvF+8SSr82EsZY4QmXfuWso8oEd8zRhVObSN18aM0CjSdoBX7zIw==} - engines: {node: '>=0.10.0'} + doctrine@2.1.0: dependencies: esutils: 2.0.3 - dev: true - /doctrine@3.0.0: - resolution: {integrity: sha512-yS+Q5i3hBf7GBkd4KG8a7eBNNWNGLTaEwwYWUijIYM7zrlYDM0BFXHjjPWlWZ1Rg7UaddZeIDmi9jF3HmqiQ2w==} - engines: {node: '>=6.0.0'} + doctrine@3.0.0: dependencies: esutils: 2.0.3 - /dom-serializer@2.0.0: - resolution: {integrity: sha512-wIkAryiqt/nV5EQKqQpo3SToSOV9J0DnbJqwK7Wv/Trc92zIAYZ4FlMu+JPFW1DfGFt81ZTCGgDEabffXeLyJg==} + dom-serializer@2.0.0: dependencies: domelementtype: 2.3.0 domhandler: 5.0.3 entities: 4.5.0 - dev: false - /dom-walk@0.1.2: - resolution: {integrity: sha512-6QvTW9mrGeIegrFXdtQi9pk7O/nSK6lSdXW2eqUspN5LWD7UTji2Fqw5V2YLjBpHEoU9Xl/eUWNpDeZvoyOv2w==} + dom-walk@0.1.2: {} - /domelementtype@2.3.0: - resolution: {integrity: sha512-OLETBj6w0OsagBwdXnPdN0cnMfF9opN69co+7ZrbfPGrdpPVNBUj02spi6B1N7wChLQiPn4CSH/zJvXw56gmHw==} - dev: false + domelementtype@2.3.0: {} - /domhandler@5.0.3: - resolution: {integrity: sha512-cgwlv/1iFQiFnU96XXgROh8xTeetsnJiDsTc7TYCLFd9+/WNkIqPTxiM/8pSd8VIrhXGTf1Ny1q1hquVqDJB5w==} - engines: {node: '>= 4'} + domhandler@5.0.3: dependencies: domelementtype: 2.3.0 - dev: false - /domutils@3.1.0: - resolution: {integrity: sha512-H78uMmQtI2AhgDJjWeQmHwJJ2bLPD3GMmO7Zja/ZZh84wkm+4ut+IUnUdRa8uCGX88DiVx1j6FRe1XfxEgjEZA==} + domutils@3.1.0: dependencies: dom-serializer: 2.0.0 domelementtype: 2.3.0 domhandler: 5.0.3 - dev: false - /dot-case@2.1.1: - resolution: {integrity: sha512-HnM6ZlFqcajLsyudHq7LeeLDr2rFAVYtDv/hV5qchQEidSck8j9OPUsXY9KwJv/lHMtYlX4DjRQqwFYa+0r8Ug==} + dot-case@2.1.1: dependencies: no-case: 2.3.2 - dev: false - /dot-prop@7.2.0: - resolution: {integrity: sha512-Ol/IPXUARn9CSbkrdV4VJo7uCy1I3VuSiWCaFSg+8BdUOzF9n3jefIpcgAydvUZbTdEBZs2vEiTiS9m61ssiDA==} - engines: {node: ^12.20.0 || ^14.13.1 || >=16.0.0} + dot-prop@7.2.0: dependencies: type-fest: 2.19.0 - dev: true - /ecc-jsbn@0.1.2: - resolution: {integrity: sha512-eh9O+hwRHNbG4BLTjEl3nw044CkGm5X6LoaCf7LPp7UU8Qrt47JYNi6nPX8xjW97TKGKm1ouctg0QSpZe9qrnw==} + ecc-jsbn@0.1.2: dependencies: jsbn: 0.1.1 safer-buffer: 2.1.2 - /ee-first@1.1.1: - resolution: {integrity: sha512-WMwm9LhRUo+WUaRN+vRuETqG89IgZphVSNkdFgeb6sS/E4OrDIN7t48CAewSHXc6C8lefD8KKfr5vY61brQlow==} + ee-first@1.1.1: {} - /eip55@2.1.1: - resolution: {integrity: sha512-WcagVAmNu2Ww2cDUfzuWVntYwFxbvZ5MvIyLZpMjTTkjD6sCvkGOiS86jTppzu9/gWsc8isLHAeMBWK02OnZmA==} + eip55@2.1.1: dependencies: keccak: 3.0.4 - dev: false - /electron-to-chromium@1.4.761: - resolution: {integrity: sha512-PIbxpiJGx6Bb8dQaonNc6CGTRlVntdLg/2nMa1YhnrwYOORY9a3ZgGN0UQYE6lAcj/lkyduJN7BPt/JiY+jAQQ==} - dev: true + electron-to-chromium@1.4.761: {} - /elliptic@6.5.4: - resolution: {integrity: sha512-iLhC6ULemrljPZb+QutR5TQGB+pdW6KGD5RSegS+8sorOZT+rdQFbsQFJgvN3eRqNALqJer4oQ16YvJHlU8hzQ==} + elliptic@6.5.4: dependencies: bn.js: 4.12.0 brorand: 1.1.0 @@ -5693,8 +9942,7 @@ packages: minimalistic-assert: 1.0.1 minimalistic-crypto-utils: 1.0.1 - /elliptic@6.5.5: - resolution: {integrity: sha512-7EjbcmUm17NQFu4Pmgmq2olYMj8nwMnpcddByChSUjArp8F5DQWcIcpriwO4ZToLNAJig0yiyjswfyGNje/ixw==} + elliptic@6.5.5: dependencies: bn.js: 4.12.0 brorand: 1.1.0 @@ -5704,43 +9952,28 @@ packages: minimalistic-assert: 1.0.1 minimalistic-crypto-utils: 1.0.1 - /emoji-regex@8.0.0: - resolution: {integrity: sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A==} + emoji-regex@8.0.0: {} - /encodeurl@1.0.2: - resolution: {integrity: sha512-TPJXq8JqFaVYm2CWmPvnP2Iyo4ZSM7/QKcSmuMLDObfpH5fi7RUGmd/rTDf+rut/saiDiQEeVTNgAmJEdAOx0w==} - engines: {node: '>= 0.8'} + encodeurl@1.0.2: {} - /end-of-stream@1.4.4: - resolution: {integrity: sha512-+uw1inIHVPQoaVuHzRyXd21icM+cnt4CzD5rW+NC1wjOUSTOs+Te7FOv7AhN7vS9x/oIyhLP5PR1H+phQAHu5Q==} + end-of-stream@1.4.4: dependencies: once: 1.4.0 - /enquirer@2.4.1: - resolution: {integrity: sha512-rRqJg/6gd538VHvR3PSrdRBb/1Vy2YfzHqzvbhGIQpDRKIa4FgV/54b5Q1xYSxOOwKvjXweS26E0Q+nAMwp2pQ==} - engines: {node: '>=8.6'} + enquirer@2.4.1: dependencies: ansi-colors: 4.1.3 strip-ansi: 6.0.1 - /entities@4.5.0: - resolution: {integrity: sha512-V0hjH4dGPh9Ao5p0MoRY6BVqtwCjhz6vI5LT8AJ55H+4g9/4vbHx1I54fS0XuclLhDHArPQCiMjDxjaL8fPxhw==} - engines: {node: '>=0.12'} - dev: false + entities@4.5.0: {} - /env-paths@2.2.1: - resolution: {integrity: sha512-+h1lkLKhZMTYjog1VEpJNG7NZJWcuc2DDk/qsqSTRRCOXiLjeQ1d1/udrUGhqMxUgAlwKNZ0cf2uqan5GLuS2A==} - engines: {node: '>=6'} - dev: false + env-paths@2.2.1: {} - /error-ex@1.3.2: - resolution: {integrity: sha512-7dFHNmqeFSEt2ZBsCriorKnn3Z2pj+fd9kmI6QoWw4//DL+icEBfc0U7qJCisqrTsKTjw4fNFy2pW9OqStD84g==} + error-ex@1.3.2: dependencies: is-arrayish: 0.2.1 - /es-abstract@1.23.3: - resolution: {integrity: sha512-e+HfNH61Bj1X9/jLc5v1owaLYuHdeHHSQlkhCBiTK8rBvKaULl/beGMxwrMXjpYrv4pz22BlY570vVePA2ho4A==} - engines: {node: '>= 0.4'} + es-abstract@1.23.3: dependencies: array-buffer-byte-length: 1.0.1 arraybuffer.prototype.slice: 1.0.3 @@ -5788,99 +10021,64 @@ packages: typed-array-length: 1.0.6 unbox-primitive: 1.0.2 which-typed-array: 1.1.15 - dev: true - /es-define-property@1.0.0: - resolution: {integrity: sha512-jxayLKShrEqqzJ0eumQbVhTYQM27CfT1T35+gCgDFoL82JLsXqTJ76zv6A0YLOgEnLUMvLzsDsGIrl8NFpT2gQ==} - engines: {node: '>= 0.4'} + es-define-property@1.0.0: dependencies: get-intrinsic: 1.2.4 - /es-errors@1.3.0: - resolution: {integrity: sha512-Zf5H2Kxt2xjTvbJvP2ZWLEICxA6j+hAmMzIlypy4xcBg1vKVnx89Wy0GbS+kf5cwCVFFzdCFh2XSCFNULS6csw==} - engines: {node: '>= 0.4'} + es-errors@1.3.0: {} - /es-object-atoms@1.0.0: - resolution: {integrity: sha512-MZ4iQ6JwHOBQjahnjwaC1ZtIBH+2ohjamzAO3oaHcXYup7qxjF2fixyH+Q71voWHeOkI2q/TnJao/KfXYIZWbw==} - engines: {node: '>= 0.4'} + es-object-atoms@1.0.0: dependencies: es-errors: 1.3.0 - dev: true - /es-set-tostringtag@2.0.3: - resolution: {integrity: sha512-3T8uNMC3OQTHkFUsFq8r/BwAXLHvU/9O9mE0fBc/MY5iq/8H7ncvO947LmYA6ldWw9Uh8Yhf25zu6n7nML5QWQ==} - engines: {node: '>= 0.4'} + es-set-tostringtag@2.0.3: dependencies: get-intrinsic: 1.2.4 has-tostringtag: 1.0.2 hasown: 2.0.2 - dev: true - /es-shim-unscopables@1.0.2: - resolution: {integrity: sha512-J3yBRXCzDu4ULnQwxyToo/OjdMx6akgVC7K6few0a7F/0wLtmKKN7I73AH5T2836UuXRqN7Qg+IIUw/+YJksRw==} + es-shim-unscopables@1.0.2: dependencies: hasown: 2.0.2 - dev: true - /es-to-primitive@1.2.1: - resolution: {integrity: sha512-QCOllgZJtaUo9miYBcLChTUaHNjJF3PYs1VidD7AwiEj1kYxKeQTctLAezAOH5ZKRH0g2IgPn6KwB4IT8iRpvA==} - engines: {node: '>= 0.4'} + es-to-primitive@1.2.1: dependencies: is-callable: 1.2.7 is-date-object: 1.0.5 is-symbol: 1.0.4 - dev: true - /es5-ext@0.10.64: - resolution: {integrity: sha512-p2snDhiLaXe6dahss1LddxqEm+SkuDvV8dnIQG0MWjyHpcMNfXKPE+/Cc0y+PhxJX3A4xGNeFCj5oc0BUh6deg==} - engines: {node: '>=0.10'} - requiresBuild: true + es5-ext@0.10.64: dependencies: es6-iterator: 2.0.3 es6-symbol: 3.1.4 esniff: 2.0.1 next-tick: 1.1.0 - /es6-error@4.1.1: - resolution: {integrity: sha512-Um/+FxMr9CISWh0bi5Zv0iOD+4cFh5qLeks1qhAopKVAJw3drgKbKySikp7wGhDL0HPeaja0P5ULZrxLkniUVg==} - dev: true + es6-error@4.1.1: {} - /es6-iterator@2.0.3: - resolution: {integrity: sha512-zw4SRzoUkd+cl+ZoE15A9o1oQd920Bb0iOJMQkQhl3jNc03YqVjAhG7scf9C5KWRU/R13Orf588uCC6525o02g==} + es6-iterator@2.0.3: dependencies: d: 1.0.2 es5-ext: 0.10.64 es6-symbol: 3.1.4 - /es6-promise@4.2.8: - resolution: {integrity: sha512-HJDGx5daxeIvxdBxvG2cb9g4tEvwIk3i8+nhX0yGrYmZUzbkdg8QbDevheDB8gd0//uPj4c1EQua8Q+MViT0/w==} + es6-promise@4.2.8: {} - /es6-symbol@3.1.4: - resolution: {integrity: sha512-U9bFFjX8tFiATgtkJ1zg25+KviIXpgRvRHS8sau3GfhVzThRQrOeksPeT0BWW2MNZs1OEWJ1DPXOQMn0KKRkvg==} - engines: {node: '>=0.12'} + es6-symbol@3.1.4: dependencies: d: 1.0.2 ext: 1.7.0 - /escalade@3.1.2: - resolution: {integrity: sha512-ErCHMCae19vR8vQGe50xIsVomy19rg6gFu3+r3jkEO46suLMWBksvVyoGgQV+jOfl84ZSOSlmv6Gxa89PmTGmA==} - engines: {node: '>=6'} + escalade@3.1.2: {} - /escape-html@1.0.3: - resolution: {integrity: sha512-NiSupZ4OeuGwr68lGIeym/ksIZMJodUGOSCZ/FSnTxcrekbvqrgdUxlJOMpijaKZVjAJrWrGs/6Jy8OMuyj9ow==} + escape-html@1.0.3: {} - /escape-string-regexp@1.0.5: - resolution: {integrity: sha512-vbRorB5FUQWvla16U8R/qgaFIya2qGzwDrNmCZuYKrbdSUMG6I1ZCGQRefkRVhuOkIGVne7BQ35DSfo1qvJqFg==} - engines: {node: '>=0.8.0'} + escape-string-regexp@1.0.5: {} - /escape-string-regexp@4.0.0: - resolution: {integrity: sha512-TtpcNJ3XAzx3Gq8sWRzJaVajRs0uVxA2YAkdb1jm2YkPz4G6egUFAyA3n5vtEIZefPk5Wa4UXbKuS5fKkJWdgA==} - engines: {node: '>=10'} + escape-string-regexp@4.0.0: {} - /escodegen@1.8.1: - resolution: {integrity: sha512-yhi5S+mNTOuRvyW4gWlg5W1byMaQGWWSYHXsuFZ7GBo7tpyOwi2EdzMP/QWxh9hwkD2m+wDVHJsxhRIj+v/b/A==} - engines: {node: '>=0.12.0'} - hasBin: true + escodegen@1.8.1: dependencies: esprima: 2.7.3 estraverse: 1.9.3 @@ -5888,33 +10086,17 @@ packages: optionator: 0.8.3 optionalDependencies: source-map: 0.2.0 - dev: true - /eslint-compat-utils@0.5.0(eslint@8.57.0): - resolution: {integrity: sha512-dc6Y8tzEcSYZMHa+CMPLi/hyo1FzNeonbhJL7Ol0ccuKQkwopJcJBA9YL/xmMTLU1eKigXo9vj9nALElWYSowg==} - engines: {node: '>=12'} - peerDependencies: - eslint: '>=6.0.0' + eslint-compat-utils@0.5.0(eslint@8.57.0): dependencies: eslint: 8.57.0 semver: 7.6.2 - dev: true - /eslint-config-prettier@8.3.0(eslint@8.57.0): - resolution: {integrity: sha512-BgZuLUSeKzvlL/VUjx/Yb787VQ26RU3gGjA3iiFvdsp/2bMfVIWUVP7tjxtjS0e+HP409cPlPvNkQloz8C91ew==} - hasBin: true - peerDependencies: - eslint: '>=7.0.0' + eslint-config-prettier@8.3.0(eslint@8.57.0): dependencies: eslint: 8.57.0 - dev: true - /eslint-doc-generator@1.7.1(eslint@8.57.0)(typescript@5.0.4): - resolution: {integrity: sha512-i1Zjl+Xcy712SZhbceCeMVaIdhbFqY27i8d7f9gyb9P/6AQNnPA0VCWynAFVGYa0hpeR5kwUI09+GBELgC2nnA==} - engines: {node: ^14.18.0 || ^16.0.0 || >=18.0.0} - hasBin: true - peerDependencies: - eslint: '>= 7' + eslint-doc-generator@1.7.1(eslint@8.57.0)(typescript@5.0.4): dependencies: '@typescript-eslint/utils': 5.62.0(eslint@8.57.0)(typescript@5.0.4) ajv: 8.13.0 @@ -5932,10 +10114,8 @@ packages: transitivePeerDependencies: - supports-color - typescript - dev: true - /eslint-import-resolver-node@0.3.9: - resolution: {integrity: sha512-WFj2isz22JahUv+B788TlO3N6zL3nNJGU8CcZbPZvVEkBPaJdCV4vy5wyghty5ROFbCRnm132v8BScu5/1BQ8g==} + eslint-import-resolver-node@0.3.9: dependencies: debug: 3.2.7 is-core-module: 2.13.1 @@ -5943,68 +10123,31 @@ packages: transitivePeerDependencies: - supports-color - /eslint-module-utils@2.8.1(@typescript-eslint/parser@5.61.0)(eslint-import-resolver-node@0.3.9)(eslint@8.57.0): - resolution: {integrity: sha512-rXDXR3h7cs7dy9RNpUlQf80nX31XWJEyGq1tRMo+6GsO5VmTe4UTwtmonAD4ZkAsrfMVDA2wlGJ3790Ys+D49Q==} - engines: {node: '>=4'} - peerDependencies: - '@typescript-eslint/parser': '*' - eslint: '*' - eslint-import-resolver-node: '*' - eslint-import-resolver-typescript: '*' - eslint-import-resolver-webpack: '*' - peerDependenciesMeta: - '@typescript-eslint/parser': - optional: true - eslint: - optional: true - eslint-import-resolver-node: - optional: true - eslint-import-resolver-typescript: - optional: true - eslint-import-resolver-webpack: - optional: true + eslint-module-utils@2.8.1(@typescript-eslint/parser@5.61.0(eslint@8.57.0)(typescript@5.0.4))(eslint-import-resolver-node@0.3.9)(eslint@8.57.0): dependencies: - '@typescript-eslint/parser': 5.61.0(eslint@8.57.0)(typescript@5.0.4) debug: 3.2.7 + optionalDependencies: + '@typescript-eslint/parser': 5.61.0(eslint@8.57.0)(typescript@5.0.4) eslint: 8.57.0 eslint-import-resolver-node: 0.3.9 transitivePeerDependencies: - supports-color - /eslint-plugin-es-x@7.6.0(eslint@8.57.0): - resolution: {integrity: sha512-I0AmeNgevgaTR7y2lrVCJmGYF0rjoznpDvqV/kIkZSZbZ8Rw3eu4cGlvBBULScfkSOCzqKbff5LR4CNrV7mZHA==} - engines: {node: ^14.18.0 || >=16.0.0} - peerDependencies: - eslint: '>=8' + eslint-plugin-es-x@7.6.0(eslint@8.57.0): dependencies: '@eslint-community/eslint-utils': 4.4.0(eslint@8.57.0) '@eslint-community/regexpp': 4.10.0 eslint: 8.57.0 eslint-compat-utils: 0.5.0(eslint@8.57.0) - dev: true - /eslint-plugin-eslint-plugin@5.5.1(eslint@8.57.0): - resolution: {integrity: sha512-9AmfZzcQ7QHwpzfAQpZ7xdtwHYViylmlnruCH0aV64/tuoH3igGXg91vr0e6ShLf/mrAYGqLw5LZ/gOxJeRXnw==} - engines: {node: ^14.17.0 || ^16.0.0 || >= 18.0.0} - peerDependencies: - eslint: '>=7.0.0' + eslint-plugin-eslint-plugin@5.5.1(eslint@8.57.0): dependencies: eslint: 8.57.0 eslint-utils: 3.0.0(eslint@8.57.0) estraverse: 5.3.0 - dev: true - /eslint-plugin-import@2.27.5(@typescript-eslint/parser@5.61.0)(eslint@8.57.0): - resolution: {integrity: sha512-LmEt3GVofgiGuiE+ORpnvP+kAm3h6MLZJ4Q5HCyHADofsb4VzXFsRiWj3c0OFiV+3DWFh0qg3v9gcPlfc3zRow==} - engines: {node: '>=4'} - peerDependencies: - '@typescript-eslint/parser': '*' - eslint: ^2 || ^3 || ^4 || ^5 || ^6 || ^7.2.0 || ^8 - peerDependenciesMeta: - '@typescript-eslint/parser': - optional: true + eslint-plugin-import@2.27.5(@typescript-eslint/parser@5.61.0(eslint@8.57.0)(typescript@5.0.4))(eslint@8.57.0): dependencies: - '@typescript-eslint/parser': 5.61.0(eslint@8.57.0)(typescript@5.0.4) array-includes: 3.1.8 array.prototype.flat: 1.3.2 array.prototype.flatmap: 1.3.2 @@ -6012,7 +10155,7 @@ packages: doctrine: 2.1.0 eslint: 8.57.0 eslint-import-resolver-node: 0.3.9 - eslint-module-utils: 2.8.1(@typescript-eslint/parser@5.61.0)(eslint-import-resolver-node@0.3.9)(eslint@8.57.0) + eslint-module-utils: 2.8.1(@typescript-eslint/parser@5.61.0(eslint@8.57.0)(typescript@5.0.4))(eslint-import-resolver-node@0.3.9)(eslint@8.57.0) has: 1.0.4 is-core-module: 2.13.1 is-glob: 4.0.3 @@ -6021,29 +10164,21 @@ packages: resolve: 1.22.8 semver: 6.3.1 tsconfig-paths: 3.15.0 + optionalDependencies: + '@typescript-eslint/parser': 5.61.0(eslint@8.57.0)(typescript@5.0.4) transitivePeerDependencies: - eslint-import-resolver-typescript - eslint-import-resolver-webpack - supports-color - dev: true - /eslint-plugin-mocha@10.4.1(eslint@8.57.0): - resolution: {integrity: sha512-G85ALUgKaLzuEuHhoW3HVRgPTmia6njQC3qCG6CEvA8/Ja9PDZnRZOuzekMki+HaViEQXINuYsmhp5WR5/4MfA==} - engines: {node: '>=14.0.0'} - peerDependencies: - eslint: '>=7.0.0' + eslint-plugin-mocha@10.4.1(eslint@8.57.0): dependencies: eslint: 8.57.0 eslint-utils: 3.0.0(eslint@8.57.0) globals: 13.24.0 rambda: 7.5.0 - dev: true - /eslint-plugin-n@16.6.2(eslint@8.57.0): - resolution: {integrity: sha512-6TyDmZ1HXoFQXnhCTUjVFULReoBPOAjpuiKELMkeP40yffI/1ZRO+d9ug/VC6fqISo2WkuIBk3cvuRPALaWlOQ==} - engines: {node: '>=16.0.0'} - peerDependencies: - eslint: '>=7.0.0' + eslint-plugin-n@16.6.2(eslint@8.57.0): dependencies: '@eslint-community/eslint-utils': 4.4.0(eslint@8.57.0) builtins: 5.1.0 @@ -6057,62 +10192,43 @@ packages: minimatch: 3.1.2 resolve: 1.22.8 semver: 7.6.2 - dev: true - /eslint-plugin-prettier@3.4.0(eslint-config-prettier@8.3.0)(eslint@8.57.0)(prettier@2.4.1): - resolution: {integrity: sha512-UDK6rJT6INSfcOo545jiaOwB701uAIt2/dR7WnFQoGCVl1/EMqdANBmwUaqqQ45aXprsTGzSa39LI1PyuRBxxw==} - engines: {node: '>=6.0.0'} - peerDependencies: - eslint: '>=5.0.0' - eslint-config-prettier: '*' - prettier: '>=1.13.0' - peerDependenciesMeta: - eslint-config-prettier: - optional: true + eslint-plugin-prettier@3.4.0(eslint-config-prettier@8.3.0(eslint@8.57.0))(eslint@8.57.0)(prettier@2.4.1): dependencies: eslint: 8.57.0 - eslint-config-prettier: 8.3.0(eslint@8.57.0) prettier: 2.4.1 prettier-linter-helpers: 1.0.0 - dev: true + optionalDependencies: + eslint-config-prettier: 8.3.0(eslint@8.57.0) - /eslint-scope@5.1.1: - resolution: {integrity: sha512-2NxwbF/hZ0KpepYN0cNbo+FN6XoK7GaHlQhgx/hIZl6Va0bF45RQOOwhLIy8lQDbuCiadSLCBnH2CFYquit5bw==} - engines: {node: '>=8.0.0'} + eslint-plugin-prettier@3.4.0(eslint-config-prettier@8.3.0(eslint@8.57.0))(eslint@8.57.0)(prettier@2.8.8): + dependencies: + eslint: 8.57.0 + prettier: 2.8.8 + prettier-linter-helpers: 1.0.0 + optionalDependencies: + eslint-config-prettier: 8.3.0(eslint@8.57.0) + + eslint-scope@5.1.1: dependencies: esrecurse: 4.3.0 estraverse: 4.3.0 - /eslint-scope@7.2.2: - resolution: {integrity: sha512-dOt21O7lTMhDM+X9mB4GX+DZrZtCUJPL/wlcTqxyrx5IvO0IYtILdtrQGQp+8n5S0gwSVmOf9NQrjMOgfQZlIg==} - engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0} + eslint-scope@7.2.2: dependencies: esrecurse: 4.3.0 estraverse: 5.3.0 - /eslint-utils@3.0.0(eslint@8.57.0): - resolution: {integrity: sha512-uuQC43IGctw68pJA1RgbQS8/NP7rch6Cwd4j3ZBtgo4/8Flj4eGE7ZYSZRN3iq5pVUv6GPdW5Z1RFleo84uLDA==} - engines: {node: ^10.0.0 || ^12.0.0 || >= 14.0.0} - peerDependencies: - eslint: '>=5' + eslint-utils@3.0.0(eslint@8.57.0): dependencies: eslint: 8.57.0 eslint-visitor-keys: 2.1.0 - dev: true - /eslint-visitor-keys@2.1.0: - resolution: {integrity: sha512-0rSmRBzXgDzIsD6mGdJgevzgezI534Cer5L/vyMX0kHzT/jiB43jRhd9YUlMGYLQy2zprNmoT8qasCGtY+QaKw==} - engines: {node: '>=10'} - dev: true + eslint-visitor-keys@2.1.0: {} - /eslint-visitor-keys@3.4.3: - resolution: {integrity: sha512-wpc+LXeiyiisxPlEkUzU6svyS1frIO3Mgxj1fdy7Pm8Ygzguax2N3Fa/D/ag1WqbOprdI+uY6wMUl8/a2G+iag==} - engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0} + eslint-visitor-keys@3.4.3: {} - /eslint@8.57.0: - resolution: {integrity: sha512-dZ6+mexnaTIbSBZWgou51U6OmzIhYM2VcNdtiTtI7qPNZm35Akpr0f6vtw3w1Kmn5PYo+tZVfh13WrhpS6oLqQ==} - engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0} - hasBin: true + eslint@8.57.0: dependencies: '@eslint-community/eslint-utils': 4.4.0(eslint@8.57.0) '@eslint-community/regexpp': 4.10.0 @@ -6155,88 +10271,54 @@ packages: transitivePeerDependencies: - supports-color - /esniff@2.0.1: - resolution: {integrity: sha512-kTUIGKQ/mDPFoJ0oVfcmyJn4iBDRptjNVIzwIFR7tqWXdVI9xfA2RMwY/gbSpJG3lkdWNEjLap/NqVHZiJsdfg==} - engines: {node: '>=0.10'} + esniff@2.0.1: dependencies: d: 1.0.2 es5-ext: 0.10.64 event-emitter: 0.3.5 type: 2.7.2 - /espree@9.6.1: - resolution: {integrity: sha512-oruZaFkjorTpF32kDSI5/75ViwGeZginGGy2NoOSg3Q9bnwlnmDm4HLnkl0RE3n+njDXR037aY1+x58Z/zFdwQ==} - engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0} + espree@9.6.1: dependencies: acorn: 8.11.3 acorn-jsx: 5.3.2(acorn@8.11.3) eslint-visitor-keys: 3.4.3 - /esprima@2.7.3: - resolution: {integrity: sha512-OarPfz0lFCiW4/AV2Oy1Rp9qu0iusTKqykwTspGCZtPxmF81JR4MmIebvF1F9+UOKth2ZubLQ4XGGaU+hSn99A==} - engines: {node: '>=0.10.0'} - hasBin: true - dev: true + esprima@2.7.3: {} - /esprima@4.0.1: - resolution: {integrity: sha512-eGuFFw7Upda+g4p+QHvnW0RyTX/SVeJBDM/gCtMARO0cLuT2HcEKnTPvhjV6aGeqrCB/sbNop0Kszm0jsaWU4A==} - engines: {node: '>=4'} - hasBin: true - dev: true + esprima@4.0.1: {} - /esquery@1.5.0: - resolution: {integrity: sha512-YQLXUplAwJgCydQ78IMJywZCceoqk1oH01OERdSAJc/7U2AylwjhSCLDEtqwg811idIS/9fIU5GjG73IgjKMVg==} - engines: {node: '>=0.10'} + esquery@1.5.0: dependencies: estraverse: 5.3.0 - /esrecurse@4.3.0: - resolution: {integrity: sha512-KmfKL3b6G+RXvP8N1vr3Tq1kL/oCFgn2NYXEtqP8/L3pKapUA4G8cFVaoF3SU323CD4XypR/ffioHmkti6/Tag==} - engines: {node: '>=4.0'} + esrecurse@4.3.0: dependencies: estraverse: 5.3.0 - /estraverse@1.9.3: - resolution: {integrity: sha512-25w1fMXQrGdoquWnScXZGckOv+Wes+JDnuN/+7ex3SauFRS72r2lFDec0EKPt2YD1wUJ/IrfEex+9yp4hfSOJA==} - engines: {node: '>=0.10.0'} - dev: true + estraverse@1.9.3: {} - /estraverse@4.3.0: - resolution: {integrity: sha512-39nnKffWz8xN1BU/2c79n9nB9HDzo0niYUqx6xyqUnyoAnQyyWpOTdZEeiCch8BBu515t4wp9ZmgVfVhn9EBpw==} - engines: {node: '>=4.0'} + estraverse@4.3.0: {} - /estraverse@5.3.0: - resolution: {integrity: sha512-MMdARuVEQziNTeJD8DgMqmhwR11BRQ/cBP+pLtYdSTnf3MIO8fFeiINEbX36ZdNlfU/7A9f3gUw49B3oQsvwBA==} - engines: {node: '>=4.0'} + estraverse@5.3.0: {} - /esutils@2.0.3: - resolution: {integrity: sha512-kVscqXk4OCp68SZ0dkgEKVi6/8ij300KBWTJq32P/dYeWTSwK41WyTxalN1eRmA5Z9UU/LX9D7FWSmV9SAYx6g==} - engines: {node: '>=0.10.0'} + esutils@2.0.3: {} - /etag@1.8.1: - resolution: {integrity: sha512-aIL5Fx7mawVa300al2BnEE4iNvo1qETxLrPI/o05L7z6go7fCw1J6EQmbK4FmJ2AS7kgVF/KEZWufBfdClMcPg==} - engines: {node: '>= 0.6'} + etag@1.8.1: {} - /eth-ens-namehash@2.0.8: - resolution: {integrity: sha512-VWEI1+KJfz4Km//dadyvBBoBeSQ0MHTXPvr8UIXiLW6IanxvAV+DmlZAijZwAyggqGUfwQBeHf7tc9wzc1piSw==} + eth-ens-namehash@2.0.8: dependencies: idna-uts46-hx: 2.3.1 js-sha3: 0.5.7 - /eth-gas-reporter@0.2.27: - resolution: {integrity: sha512-femhvoAM7wL0GcI8ozTdxfuBtBFJ9qsyIAsmKVjlWAHUbdnnXHt+lKzz/kmldM5lA9jLuNHGwuIxorNpLbR1Zw==} - peerDependencies: - '@codechecks/client': ^0.1.0 - peerDependenciesMeta: - '@codechecks/client': - optional: true + eth-gas-reporter@0.2.27(bufferutil@4.0.8)(utf-8-validate@5.0.10): dependencies: '@solidity-parser/parser': 0.14.5 axios: 1.6.8(debug@4.3.4) cli-table3: 0.5.1 colors: 1.4.0 ethereum-cryptography: 1.2.0 - ethers: 5.7.2 + ethers: 5.7.2(bufferutil@4.0.8)(utf-8-validate@5.0.10) fs-readdir-recursive: 1.1.0 lodash: 4.17.21 markdown-table: 1.1.3 @@ -6248,36 +10330,31 @@ packages: - bufferutil - debug - utf-8-validate - dev: true - /eth-lib@0.1.29: - resolution: {integrity: sha512-bfttrr3/7gG4E02HoWTDUcDDslN003OlOoBxk9virpAZQ1ja/jDgwkWB8QfJF7ojuEowrqy+lzp9VcJG7/k5bQ==} + eth-lib@0.1.29(bufferutil@4.0.8)(utf-8-validate@5.0.10): dependencies: bn.js: 4.12.0 elliptic: 6.5.5 nano-json-stream-parser: 0.1.2 servify: 0.1.12 - ws: 3.3.3 + ws: 3.3.3(bufferutil@4.0.8)(utf-8-validate@5.0.10) xhr-request-promise: 0.1.3 transitivePeerDependencies: - bufferutil - supports-color - utf-8-validate - /eth-lib@0.2.8: - resolution: {integrity: sha512-ArJ7x1WcWOlSpzdoTBX8vkwlkSQ85CjjifSZtV4co64vWxSV8geWfPI9x4SVYu3DSxnX4yWFVTtGL+j9DUFLNw==} + eth-lib@0.2.8: dependencies: bn.js: 4.12.0 elliptic: 6.5.5 xhr-request-promise: 0.1.3 - /ethereum-bloom-filters@1.1.0: - resolution: {integrity: sha512-J1gDRkLpuGNvWYzWslBQR9cDV4nd4kfvVTE/Wy4Kkm4yb3EYRSlyi0eB/inTsSTTVyA0+HyzHgbr95Fn/Z1fSw==} + ethereum-bloom-filters@1.1.0: dependencies: '@noble/hashes': 1.4.0 - /ethereum-cryptography@0.1.3: - resolution: {integrity: sha512-w8/4x1SGGzc+tO97TASLja6SLd3fRIK2tLVcV2Gx4IB21hE19atll5Cq9o3d0ZmAYC/8aw0ipieTSiekAea4SQ==} + ethereum-cryptography@0.1.3: dependencies: '@types/pbkdf2': 3.1.2 '@types/secp256k1': 4.0.6 @@ -6295,47 +10372,40 @@ packages: secp256k1: 4.0.3 setimmediate: 1.0.5 - /ethereum-cryptography@1.2.0: - resolution: {integrity: sha512-6yFQC9b5ug6/17CQpCyE3k9eKBMdhyVjzUy1WkiuY/E4vj/SXDBbCw8QEIaXqf0Mf2SnY6RmpDcwlUmBSS0EJw==} + ethereum-cryptography@1.2.0: dependencies: '@noble/hashes': 1.2.0 '@noble/secp256k1': 1.7.1 '@scure/bip32': 1.1.5 '@scure/bip39': 1.1.1 - /ethereum-cryptography@2.1.3: - resolution: {integrity: sha512-BlwbIL7/P45W8FGW2r7LGuvoEZ+7PWsniMvQ4p5s2xCyw9tmaDlpfsN9HjAucbF+t/qpVHwZUisgfK24TCW8aA==} + ethereum-cryptography@2.1.3: dependencies: '@noble/curves': 1.3.0 '@noble/hashes': 1.3.3 '@scure/bip32': 1.3.3 '@scure/bip39': 1.2.2 - /ethereum-ens@0.8.0: - resolution: {integrity: sha512-a8cBTF4AWw1Q1Y37V1LSCS9pRY4Mh3f8vCg5cbXCCEJ3eno1hbI/+Ccv9SZLISYpqQhaglP3Bxb/34lS4Qf7Bg==} + ethereum-ens@0.8.0(bufferutil@4.0.8)(utf-8-validate@5.0.10): dependencies: bluebird: 3.7.2 eth-ens-namehash: 2.0.8 js-sha3: 0.5.7 pako: 1.0.11 underscore: 1.13.6 - web3: 1.10.4 + web3: 1.10.4(bufferutil@4.0.8)(utf-8-validate@5.0.10) transitivePeerDependencies: - bufferutil - encoding - supports-color - utf-8-validate - dev: false - /ethereumjs-abi@0.6.8: - resolution: {integrity: sha512-Tx0r/iXI6r+lRsdvkFDlut0N08jWMnKRZ6Gkq+Nmw75lZe4e6o3EkSnkaBP5NF6+m5PTGAr9JP43N3LyeoglsA==} + ethereumjs-abi@0.6.8: dependencies: bn.js: 4.12.0 ethereumjs-util: 6.2.1 - dev: false - /ethereumjs-util@6.2.1: - resolution: {integrity: sha512-W2Ktez4L01Vexijrm5EB6w7dg4n/TgpoYU4avuT5T3Vmnw/eCRtiBrJfQYS/DCSvDIOLn2k57GcHdeBcgVxAqw==} + ethereumjs-util@6.2.1: dependencies: '@types/bn.js': 4.11.6 bn.js: 4.12.0 @@ -6344,11 +10414,8 @@ packages: ethereum-cryptography: 0.1.3 ethjs-util: 0.1.6 rlp: 2.2.7 - dev: false - /ethereumjs-util@7.1.5: - resolution: {integrity: sha512-SDl5kKrQAudFBUe5OJM9Ac6WmMyYmXX/6sTmLZ3ffG2eY6ZIGBes3pEDxNN6V72WyOw4CPD5RomKdsa8DAAwLg==} - engines: {node: '>=10.0.0'} + ethereumjs-util@7.1.5: dependencies: '@types/bn.js': 5.1.5 bn.js: 5.2.1 @@ -6356,8 +10423,7 @@ packages: ethereum-cryptography: 0.1.3 rlp: 2.2.7 - /ethers@4.0.49: - resolution: {integrity: sha512-kPltTvWiyu+OktYy1IStSO16i2e7cS9D9OxZ81q2UUaiNPVrm/RTcbxamCXF9VUSKzJIdJV68EAIhTEVBalRWg==} + ethers@4.0.49: dependencies: aes-js: 3.0.0 bn.js: 4.12.0 @@ -6368,10 +10434,8 @@ packages: setimmediate: 1.0.4 uuid: 2.0.1 xmlhttprequest: 1.8.0 - dev: false - /ethers@5.7.2: - resolution: {integrity: sha512-wswUsmWo1aOK8rR7DIKiWSw9DbLWe6x98Jrn8wcTflTVvaXhAMaB5zGAXy0GYQEQp9iO1iSHWVyARQm11zUtyg==} + ethers@5.7.2(bufferutil@4.0.8)(utf-8-validate@5.0.10): dependencies: '@ethersproject/abi': 5.7.0 '@ethersproject/abstract-provider': 5.7.0 @@ -6391,7 +10455,7 @@ packages: '@ethersproject/networks': 5.7.1 '@ethersproject/pbkdf2': 5.7.0 '@ethersproject/properties': 5.7.0 - '@ethersproject/providers': 5.7.2 + '@ethersproject/providers': 5.7.2(bufferutil@4.0.8)(utf-8-validate@5.0.10) '@ethersproject/random': 5.7.0 '@ethersproject/rlp': 5.7.0 '@ethersproject/sha2': 5.7.0 @@ -6407,9 +10471,7 @@ packages: - bufferutil - utf-8-validate - /ethers@6.12.1: - resolution: {integrity: sha512-j6wcVoZf06nqEcBbDWkKg8Fp895SS96dSnTCjiXT+8vt2o02raTn4Lo9ERUuIVU5bAjoPYeA+7ytQFexFmLuVw==} - engines: {node: '>=14.0.0'} + ethers@6.12.1(bufferutil@4.0.8)(utf-8-validate@5.0.10): dependencies: '@adraffy/ens-normalize': 1.10.1 '@noble/curves': 1.2.0 @@ -6417,67 +10479,46 @@ packages: '@types/node': 18.15.13 aes-js: 4.0.0-beta.5 tslib: 2.4.0 - ws: 8.5.0 + ws: 8.5.0(bufferutil@4.0.8)(utf-8-validate@5.0.10) transitivePeerDependencies: - bufferutil - utf-8-validate - /ethjs-abi@0.1.8: - resolution: {integrity: sha512-3SIJpF+LCVJrNht9OjSJ7+3B9ABZf6dEATMj1PaslL0BW547Cz6/kGyuDvvrcEBlSsbGpCWYrJX5B8OjhcAMFQ==} - engines: {node: '>=6.5.0', npm: '>=3'} + ethjs-abi@0.1.8: dependencies: bn.js: 4.11.6 js-sha3: 0.5.5 number-to-bn: 1.7.0 - dev: false - /ethjs-unit@0.1.6: - resolution: {integrity: sha512-/Sn9Y0oKl0uqQuvgFk/zQgR7aw1g36qX/jzSQ5lSwlO0GigPymk4eGQfeNTD03w1dPOqfz8V77Cy43jH56pagw==} - engines: {node: '>=6.5.0', npm: '>=3'} + ethjs-unit@0.1.6: dependencies: bn.js: 4.11.6 number-to-bn: 1.7.0 - /ethjs-util@0.1.6: - resolution: {integrity: sha512-CUnVOQq7gSpDHZVVrQW8ExxUETWrnrvXYvYz55wOU8Uj4VCgw56XC2B/fVqQN+f7gmrnRHSLVnFAwsCuNwji8w==} - engines: {node: '>=6.5.0', npm: '>=3'} + ethjs-util@0.1.6: dependencies: is-hex-prefixed: 1.0.0 strip-hex-prefix: 1.0.0 - dev: false - /event-emitter@0.3.5: - resolution: {integrity: sha512-D9rRn9y7kLPnJ+hMq7S/nhvoKwwvVJahBi2BPmx3bvbsEdK3W9ii8cBSGjP+72/LnM4n6fo3+dkCX5FeTQruXA==} + event-emitter@0.3.5: dependencies: d: 1.0.2 es5-ext: 0.10.64 - /eventemitter3@4.0.4: - resolution: {integrity: sha512-rlaVLnVxtxvoyLsQQFBx53YmXHDxRIzzTLbdfxqi4yocpSjAxXwkU0cScM5JgSKMqEhrZpnvQ2D9gjylR0AimQ==} + eventemitter3@4.0.4: {} - /eventemitter3@5.0.1: - resolution: {integrity: sha512-GWkBvjiSZK87ELrYOSESUYeVIc9mvLLf/nXalMOS5dYrgZq9o5OVkbZAVM06CVxYsCwH9BDZFPlQTlPA1j4ahA==} - dev: true + eventemitter3@5.0.1: {} - /events@3.3.0: - resolution: {integrity: sha512-mQw+2fkQbALzQ7V0MY0IqdnXNOeTtP4r0lN9z7AAawCXgqea7bDii20AYrIBrFd/Hx0M2Ocz6S111CaFkUcb0Q==} - engines: {node: '>=0.8.x'} - dev: false + events@3.3.0: {} - /evp_bytestokey@1.0.3: - resolution: {integrity: sha512-/f2Go4TognH/KvCISP7OUsHn85hT9nUkxxA9BEWxFn+Oj9o8ZNLm/40hdlgSLyuOimsrTKLUMEorQexp/aPQeA==} + evp_bytestokey@1.0.3: dependencies: md5.js: 1.3.5 safe-buffer: 5.2.1 - /expand-template@2.0.3: - resolution: {integrity: sha512-XYfuKMvj4O35f/pOXLObndIRvyQ+/+6AhODh+OKWj9S9498pHHn/IMszH+gt0fBCRWMNfk1ZSp5x3AifmnI2vg==} - engines: {node: '>=6'} - dev: false + expand-template@2.0.3: {} - /express@4.19.2: - resolution: {integrity: sha512-5T6nhjsT+EOMzuck8JjBHARTHfMht0POzlA60WV2pMD3gyXw2LZnZ+ueGdNxG+0calOJcWKbpFcuzLZ91YWq9Q==} - engines: {node: '>= 0.10.0'} + express@4.19.2: dependencies: accepts: 1.3.8 array-flatten: 1.1.1 @@ -6513,51 +10554,33 @@ packages: transitivePeerDependencies: - supports-color - /ext@1.7.0: - resolution: {integrity: sha512-6hxeJYaL110a9b5TEJSj0gojyHQAmA2ch5Os+ySCiA1QGdS697XWY1pzsrSjqA9LDEEgdB/KypIlR59RcLuHYw==} + ext@1.7.0: dependencies: type: 2.7.2 - /extend@3.0.2: - resolution: {integrity: sha512-fjquC59cD7CyW6urNXK0FBufkZcoiGG80wTuPujX590cB5Ttln20E2UB4S/WARVqhXffZl2LNgS+gQdPIIim/g==} + extend@3.0.2: {} - /extendable-error@0.1.7: - resolution: {integrity: sha512-UOiS2in6/Q0FK0R0q6UY9vYpQ21mr/Qn1KOnte7vsACuNJf514WvCCUHSRCPcgjPT2bAhNIJdlE6bVap1GKmeg==} - dev: true + extendable-error@0.1.7: {} - /external-editor@3.1.0: - resolution: {integrity: sha512-hMQ4CX1p1izmuLYyZqLMO/qGNw10wSv9QDCPfzXfyFrOaCSSoRfqE1Kf1s5an66J5JZC62NewG+mK49jOCtQew==} - engines: {node: '>=4'} + external-editor@3.1.0: dependencies: chardet: 0.7.0 iconv-lite: 0.4.24 tmp: 0.0.33 - dev: true - /extsprintf@1.3.0: - resolution: {integrity: sha512-11Ndz7Nv+mvAC1j0ktTa7fAb0vLyGGX+rMHNBYQviQDGU0Hw7lhctJANqbPhu9nV9/izT/IntTgZ7Im/9LJs9g==} - engines: {'0': node >=0.6.0} + extsprintf@1.3.0: {} - /fast-check@3.1.1: - resolution: {integrity: sha512-3vtXinVyuUKCKFKYcwXhGE6NtGWkqF8Yh3rvMZNzmwz8EPrgoc/v4pDdLHyLnCyCI5MZpZZkDEwFyXyEONOxpA==} - engines: {node: '>=8.0.0'} + fast-check@3.1.1: dependencies: pure-rand: 5.0.5 - dev: false - /fast-deep-equal@1.1.0: - resolution: {integrity: sha512-fueX787WZKCV0Is4/T2cyAdM4+x1S3MXXOAhavE1ys/W42SHAPacLTQhucja22QBYrfGw50M2sRiXPtTGv9Ymw==} - dev: false + fast-deep-equal@1.1.0: {} - /fast-deep-equal@3.1.3: - resolution: {integrity: sha512-f3qQ9oQy9j2AhBe/H9VC91wLmKBCCU/gDOnKNAYG5hswO7BLKj09Hc5HYNz9cGI++xlpDCIgDaitVs03ATR84Q==} + fast-deep-equal@3.1.3: {} - /fast-diff@1.3.0: - resolution: {integrity: sha512-VxPP4NqbUjj6MaAOafWeUn2cXWLcCtljklUtZf0Ind4XQ+QPtmA0b18zZy0jIQx+ExRVCR/ZQpBmik5lXshNsw==} + fast-diff@1.3.0: {} - /fast-glob@3.3.2: - resolution: {integrity: sha512-oX2ruAFQwf/Orj8m737Y5adxDQO0LAB7/S5MnxCdTNDd4p6BsyIVsv9JQsATbTSq8KHRpLwIHbVlUNatxd+1Ow==} - engines: {node: '>=8.6.0'} + fast-glob@3.3.2: dependencies: '@nodelib/fs.stat': 2.0.5 '@nodelib/fs.walk': 1.2.8 @@ -6565,40 +10588,27 @@ packages: merge2: 1.4.1 micromatch: 4.0.5 - /fast-json-stable-stringify@2.1.0: - resolution: {integrity: sha512-lhd/wF+Lk98HZoTCtlVraHtfh5XYijIjalXck7saUtuanSDyLMxnHhSXEDJqHxD7msR8D0uCmqlkwjCV8xvwHw==} + fast-json-stable-stringify@2.1.0: {} - /fast-levenshtein@2.0.6: - resolution: {integrity: sha512-DCXu6Ifhqcks7TZKY3Hxp3y6qphY5SJZmrWMDrKcERSOXWQdMhU9Ig/PYrzyw/ul9jOIyh0N4M0tbC5hodg8dw==} + fast-levenshtein@2.0.6: {} - /fast-safe-stringify@2.1.1: - resolution: {integrity: sha512-W+KJc2dmILlPplD/H4K9l9LcAHAfPtP6BY84uVLXQ6Evcz9Lcg33Y2z1IVblT6xdY54PXYVHEv+0Wpq8Io6zkA==} - dev: true + fast-safe-stringify@2.1.1: {} - /fastq@1.17.1: - resolution: {integrity: sha512-sRVD3lWVIXWg6By68ZN7vho9a1pQcN/WBFaAAsDDFzlJjvoGx0P8z7V1t72grFJfJhu3YPZBuu25f7Kaw2jN1w==} + fastq@1.17.1: dependencies: reusify: 1.0.4 - /file-entry-cache@6.0.1: - resolution: {integrity: sha512-7Gps/XWymbLk2QLYK4NzpMOrYjMhdIxXuIvy2QBsLE6ljuodKvdkWs/cpyJJ3CVIVpH0Oi1Hvg1ovbMzLdFBBg==} - engines: {node: ^10.12.0 || >=12.0.0} + file-entry-cache@6.0.1: dependencies: flat-cache: 3.2.0 - /file-uri-to-path@1.0.0: - resolution: {integrity: sha512-0Zt+s3L7Vf1biwWZ29aARiVYLx7iMGnEUl9x33fbB/j3jR81u/O2LbqK+Bm1CDSNDKVtJ/YjwY7TUd5SkeLQLw==} - dev: false + file-uri-to-path@1.0.0: {} - /fill-range@7.0.1: - resolution: {integrity: sha512-qOo9F+dMUmC2Lcb4BbVvnKJxTPjCm+RRpe4gDuGrzkL7mEVl/djYSu2OdQ2Pa302N4oqkSg9ir6jaLWJ2USVpQ==} - engines: {node: '>=8'} + fill-range@7.0.1: dependencies: to-regex-range: 5.0.1 - /finalhandler@1.2.0: - resolution: {integrity: sha512-5uXcUVftlQMFnWC9qu/svkWv3GTd2PfUhK/3PLkYNAe7FbqJMt3515HaxE6eRL74GdsriiwujiawdaB1BpEISg==} - engines: {node: '>= 0.8'} + finalhandler@1.2.0: dependencies: debug: 2.6.9 encodeurl: 1.0.2 @@ -6610,267 +10620,167 @@ packages: transitivePeerDependencies: - supports-color - /find-cache-dir@3.3.2: - resolution: {integrity: sha512-wXZV5emFEjrridIgED11OoUKLxiYjAcqot/NJdAkOhlJ+vGzwhOAfcG5OX1jP+S0PcjEn8bdMJv+g2jwQ3Onig==} - engines: {node: '>=8'} + find-cache-dir@3.3.2: dependencies: commondir: 1.0.1 make-dir: 3.1.0 pkg-dir: 4.2.0 - dev: true - /find-replace@3.0.0: - resolution: {integrity: sha512-6Tb2myMioCAgv5kfvP5/PkZZ/ntTpVK39fHY7WkWBgvbeE+VHd/tZuZ4mrC+bxh4cfOZeYKVPaJIZtZXV7GNCQ==} - engines: {node: '>=4.0.0'} + find-replace@3.0.0: dependencies: array-back: 3.1.0 - dev: true - /find-up@1.1.2: - resolution: {integrity: sha512-jvElSjyuo4EMQGoTwo1uJU5pQMwTW5lS1x05zzfJuTIyLR3zwO27LYrxNg+dlvKpGOuGy/MzBdXh80g0ve5+HA==} - engines: {node: '>=0.10.0'} + find-up@1.1.2: dependencies: path-exists: 2.1.0 pinkie-promise: 2.0.1 - dev: false - /find-up@2.1.0: - resolution: {integrity: sha512-NWzkk0jSJtTt08+FBFMvXoeZnOJD+jTtsRmBYbAIzJdX6l7dLgR7CTubCM5/eDdPUBvLCeVasP1brfVR/9/EZQ==} - engines: {node: '>=4'} + find-up@2.1.0: dependencies: locate-path: 2.0.0 - dev: false - /find-up@4.1.0: - resolution: {integrity: sha512-PpOwAdQ/YlXQ2vj8a3h8IipDuYRi3wceVQQGYWxNINccq40Anw7BlsEXCMbt1Zt+OLA6Fq9suIpIWD0OsnISlw==} - engines: {node: '>=8'} + find-up@4.1.0: dependencies: locate-path: 5.0.0 path-exists: 4.0.0 - dev: true - /find-up@5.0.0: - resolution: {integrity: sha512-78/PXT1wlLLDgTzDs7sjq9hzz0vXD+zn+7wypEe4fXQxCmdmqfGsEPQxmiCSQI3ajFV91bVSsvNtrJRiW6nGng==} - engines: {node: '>=10'} + find-up@5.0.0: dependencies: locate-path: 6.0.0 path-exists: 4.0.0 - /find-yarn-workspace-root2@1.2.16: - resolution: {integrity: sha512-hr6hb1w8ePMpPVUK39S4RlwJzi+xPLuVuG8XlwXU3KD5Yn3qgBWVfy3AzNlDhWvE1EORCE65/Qm26rFQt3VLVA==} + find-yarn-workspace-root2@1.2.16: dependencies: micromatch: 4.0.5 pkg-dir: 4.2.0 - dev: true - /flat-cache@3.2.0: - resolution: {integrity: sha512-CYcENa+FtcUKLmhhqyctpclsq7QF38pKjZHsGNiSQF5r4FtoKDWabFDl3hzaEQMvT1LHEysw5twgLvpYYb4vbw==} - engines: {node: ^10.12.0 || >=12.0.0} + flat-cache@3.2.0: dependencies: flatted: 3.3.1 keyv: 4.5.4 rimraf: 3.0.2 - /flat@5.0.2: - resolution: {integrity: sha512-b6suED+5/3rTpUBdG1gupIl8MPFCAMA0QXwmljLhvCUKcUvdE4gWky9zpuGCcXHOsz4J9wPGNWq6OKpmIzz3hQ==} - hasBin: true + flat@5.0.2: {} - /flatted@3.3.1: - resolution: {integrity: sha512-X8cqMLLie7KsNUDSdzeN8FYK9rEt4Dt67OsG/DNGnYTSDBG4uFAJFBnUeiV+zCVAvwFy56IjM9sH51jVaEhNxw==} + flatted@3.3.1: {} - /follow-redirects@1.15.6(debug@4.3.4): - resolution: {integrity: sha512-wWN62YITEaOpSK584EZXJafH1AGpO8RVgElfkuXbTOrPX4fIfOyEpW/CsiNd8JdYrAoOvafRTOEnvsO++qCqFA==} - engines: {node: '>=4.0'} - peerDependencies: - debug: '*' - peerDependenciesMeta: - debug: - optional: true - dependencies: + follow-redirects@1.15.6(debug@4.3.4): + optionalDependencies: debug: 4.3.4(supports-color@8.1.1) - /for-each@0.3.3: - resolution: {integrity: sha512-jqYfLp7mo9vIyQf8ykW2v7A+2N4QjeCeI5+Dz9XraiO1ign81wjiH7Fb9vSOWvQfNtmSa4H2RoQTrrXivdUZmw==} + for-each@0.3.3: dependencies: is-callable: 1.2.7 - /foreground-child@2.0.0: - resolution: {integrity: sha512-dCIq9FpEcyQyXKCkyzmlPTFNgrCzPudOe+mhvJU5zAtlBnGVy2yKxtfsxK2tQBThwq225jcvBjpw1Gr40uzZCA==} - engines: {node: '>=8.0.0'} + foreground-child@2.0.0: dependencies: cross-spawn: 7.0.3 signal-exit: 3.0.7 - dev: true - /forever-agent@0.6.1: - resolution: {integrity: sha512-j0KLYPhm6zeac4lz3oJ3o65qvgQCcPubiyotZrXqEaG4hNagNYO8qdlUrX5vwqv9ohqeT/Z3j6+yW067yWWdUw==} + forever-agent@0.6.1: {} - /form-data-encoder@1.7.1: - resolution: {integrity: sha512-EFRDrsMm/kyqbTQocNvRXMLjc7Es2Vk+IQFx/YW7hkUH1eBl4J1fqiP34l74Yt0pFLCNpc06fkbVk00008mzjg==} + form-data-encoder@1.7.1: {} - /form-data@2.3.3: - resolution: {integrity: sha512-1lLKB2Mu3aGP1Q/2eCOx0fNbRMe7XdwktwOruhfqqd0rIJWwN4Dh+E3hrPSlDCXnSR7UtZ1N38rVXm+6+MEhJQ==} - engines: {node: '>= 0.12'} + form-data@2.3.3: dependencies: asynckit: 0.4.0 combined-stream: 1.0.8 mime-types: 2.1.35 - /form-data@2.5.1: - resolution: {integrity: sha512-m21N3WOmEEURgk6B9GLOE4RuWOFf28Lhh9qGYeNlGq4VDXUlJy2th2slBNU8Gp8EzloYZOibZJ7t5ecIrFSjVA==} - engines: {node: '>= 0.12'} + form-data@2.5.1: dependencies: asynckit: 0.4.0 combined-stream: 1.0.8 mime-types: 2.1.35 - dev: true - /form-data@4.0.0: - resolution: {integrity: sha512-ETEklSGi5t0QMZuiXoA/Q6vcnxcLQP5vdugSpuAyi6SVGi2clPPp+xgEhuMaHC+zGgn31Kd235W35f7Hykkaww==} - engines: {node: '>= 6'} + form-data@4.0.0: dependencies: asynckit: 0.4.0 combined-stream: 1.0.8 mime-types: 2.1.35 - /forwarded@0.2.0: - resolution: {integrity: sha512-buRG0fpBtRHSTCOASe6hD258tEubFoRLb4ZNA6NxMVHNw2gOcwHo9wyablzMzOA5z9xA9L1KNjk/Nt6MT9aYow==} - engines: {node: '>= 0.6'} + forwarded@0.2.0: {} - /fp-ts@1.19.3: - resolution: {integrity: sha512-H5KQDspykdHuztLTg+ajGN0Z2qUjcEf3Ybxc6hLt0k7/zPkn29XnKnxlBPyW2XIddWrGaJBzBl4VLYOtk39yZg==} - dev: false + fp-ts@1.19.3: {} - /fresh@0.5.2: - resolution: {integrity: sha512-zJ2mQYM18rEFOudeV4GShTGIQ7RbzA7ozbU9I/XBpm7kqgMywgmylMwXHxZJmkVoYkna9d2pVXVXPdYTP9ej8Q==} - engines: {node: '>= 0.6'} + fresh@0.5.2: {} - /fromentries@1.3.2: - resolution: {integrity: sha512-cHEpEQHUg0f8XdtZCc2ZAhrHzKzT0MrFUTcvx+hfxYu7rGMDc5SKoXFh+n4YigxsHXRzc6OrCshdR1bWH6HHyg==} - dev: true + fromentries@1.3.2: {} - /fs-constants@1.0.0: - resolution: {integrity: sha512-y6OAwoSIf7FyjMIv94u+b5rdheZEjzR63GTyZJm5qh4Bi+2YgwLCcI/fPFZkL5PSixOt6ZNKm+w+Hfp/Bciwow==} - dev: false + fs-constants@1.0.0: {} - /fs-extra@0.30.0: - resolution: {integrity: sha512-UvSPKyhMn6LEd/WpUaV9C9t3zATuqoqfWc3QdPhPLb58prN9tqYPlPWi8Krxi44loBoUzlobqZ3+8tGpxxSzwA==} + fs-extra@0.30.0: dependencies: graceful-fs: 4.2.11 jsonfile: 2.4.0 klaw: 1.3.1 path-is-absolute: 1.0.1 rimraf: 2.7.1 - dev: false - /fs-extra@10.1.0: - resolution: {integrity: sha512-oRXApq54ETRj4eMiFzGnHWGy+zo5raudjuxN0b8H7s/RU2oW0Wvsx9O0ACRN/kRq9E8Vu/ReskGB5o3ji+FzHQ==} - engines: {node: '>=12'} + fs-extra@10.1.0: dependencies: graceful-fs: 4.2.11 jsonfile: 6.1.0 universalify: 2.0.1 - dev: true - /fs-extra@4.0.3: - resolution: {integrity: sha512-q6rbdDd1o2mAnQreO7YADIxf/Whx4AHBiRf6d+/cVT8h44ss+lHgxf1FemcqDnQt9X3ct4McHr+JMGlYSsK7Cg==} + fs-extra@4.0.3: dependencies: graceful-fs: 4.2.11 jsonfile: 4.0.0 universalify: 0.1.2 - /fs-extra@7.0.1: - resolution: {integrity: sha512-YJDaCJZEnBmcbw13fvdAM9AwNOJwOzrE4pqMqBq5nFiEqXUqHwlK4B+3pUw6JNvfSPtX05xFHtYy/1ni01eGCw==} - engines: {node: '>=6 <7 || >=8'} + fs-extra@7.0.1: dependencies: graceful-fs: 4.2.11 jsonfile: 4.0.0 universalify: 0.1.2 - /fs-extra@8.1.0: - resolution: {integrity: sha512-yhlQgA6mnOJUKOsRUFsgJdQCvkKhcz8tlZG5HBQfReYZy46OwLcY+Zia0mtdHsOo9y/hP+CxMN0TU9QxoOtG4g==} - engines: {node: '>=6 <7 || >=8'} + fs-extra@8.1.0: dependencies: graceful-fs: 4.2.11 jsonfile: 4.0.0 universalify: 0.1.2 - dev: true - /fs-extra@9.1.0: - resolution: {integrity: sha512-hcg3ZmepS30/7BSFqRvoo3DOMQu7IjqxO5nCDt+zM9XWjb33Wg7ziNT+Qvqbuc3+gWpzO02JubVyk2G4Zvo1OQ==} - engines: {node: '>=10'} + fs-extra@9.1.0: dependencies: at-least-node: 1.0.0 graceful-fs: 4.2.11 jsonfile: 6.1.0 universalify: 2.0.1 - dev: true - /fs-minipass@1.2.7: - resolution: {integrity: sha512-GWSSJGFy4e9GUeCcbIkED+bgAoFyj7XF1mV8rma3QW4NIqX9Kyx79N/PF61H5udOV3aY1IaMLs6pGbH71nlCTA==} + fs-minipass@1.2.7: dependencies: minipass: 2.9.0 - /fs-readdir-recursive@1.1.0: - resolution: {integrity: sha512-GNanXlVr2pf02+sPN40XN8HG+ePaNcvM0q5mZBd668Obwb0yD5GiUbZOFgwn8kGMY6I3mdyDJzieUy3PTYyTRA==} - dev: true + fs-readdir-recursive@1.1.0: {} - /fs.realpath@1.0.0: - resolution: {integrity: sha512-OO0pH2lK6a0hZnAdau5ItzHPI6pUlvI7jMVnxUQRtw4owF2wk8lOSabtGDCTP4Ggrg2MbGnWO9X8K1t4+fGMDw==} + fs.realpath@1.0.0: {} - /fsevents@2.3.3: - resolution: {integrity: sha512-5xoDfX+fL7faATnagmWPpbFtwh/R77WmMMqqHGS65C3vvB0YHrgF+B1YmZ3441tMj5n63k0212XNoJwzlhffQw==} - engines: {node: ^8.16.0 || ^10.6.0 || >=11.0.0} - os: [darwin] - requiresBuild: true + fsevents@2.3.3: optional: true - /function-bind@1.1.2: - resolution: {integrity: sha512-7XHNxH7qX9xG5mIwxkhumTox/MIRNcOgDrxWsMt2pAr23WHp6MrRlN7FBSFpCpr+oVO0F744iUgR82nJMfG2SA==} + function-bind@1.1.2: {} - /function.prototype.name@1.1.6: - resolution: {integrity: sha512-Z5kx79swU5P27WEayXM1tBi5Ze/lbIyiNgU3qyXUOf9b2rgXYyF9Dy9Cx+IQv/Lc8WCG6L82zwUPpSS9hGehIg==} - engines: {node: '>= 0.4'} + function.prototype.name@1.1.6: dependencies: call-bind: 1.0.7 define-properties: 1.2.1 es-abstract: 1.23.3 functions-have-names: 1.2.3 - dev: true - /functions-have-names@1.2.3: - resolution: {integrity: sha512-xckBUXyTIqT97tq2x2AMb+g163b5JFysYk0x4qxNFwbfQkmNZoiRHb6sPzI9/QV33WeuvVYBUIiD4NzNIyqaRQ==} - dev: true + functions-have-names@1.2.3: {} - /ganache-cli@6.12.2: - resolution: {integrity: sha512-bnmwnJDBDsOWBUP8E/BExWf85TsdDEFelQSzihSJm9VChVO1SHp94YXLP5BlA4j/OTxp0wR4R1Tje9OHOuAJVw==} - deprecated: ganache-cli is now ganache; visit https://trfl.io/g7 for details - hasBin: true - dev: true - bundledDependencies: - - source-map-support - - yargs - - ethereumjs-util + ganache-cli@6.12.2: {} - /gensync@1.0.0-beta.2: - resolution: {integrity: sha512-3hN7NaskYvMDLQY55gnW3NQ+mesEAepTqlg+VEbj7zzqEMBVNhzcGYYeqFo/TlYz6eQiFcp1HcsCZO+nGgS8zg==} - engines: {node: '>=6.9.0'} - dev: true + gensync@1.0.0-beta.2: {} - /get-caller-file@1.0.3: - resolution: {integrity: sha512-3t6rVToeoZfYSGd8YoLFR2DJkiQrIiUrGcjvFX2mDw3bn6k2OtwHN0TNCLbBO+w8qTvimhDkv+LSscbJY1vE6w==} - dev: false + get-caller-file@1.0.3: {} - /get-caller-file@2.0.5: - resolution: {integrity: sha512-DyFP3BM/3YHTQOCUL/w0OZHR0lpKeGrxotcHWcqNEdnltqFwXVfhEBQ94eIo34AfQpo0rGki4cyIiftY06h2Fg==} - engines: {node: 6.* || 8.* || >= 10.*} + get-caller-file@2.0.5: {} - /get-func-name@2.0.2: - resolution: {integrity: sha512-8vXOvuE167CtIc3OyItco7N/dpRtBbYOsPsXCz7X/PMnlGjYjSGuZJgM1Y7mmew7BKf9BqvLX2tnOVy1BBUsxQ==} + get-func-name@2.0.2: {} - /get-intrinsic@1.2.4: - resolution: {integrity: sha512-5uYhsJH8VJBTv7oslg4BznJYhDoRI6waYCxMmCdnTrcCrHA/fCFKoTFz2JKKE0HdDFUF7/oQuhzumXJK7paBRQ==} - engines: {node: '>= 0.4'} + get-intrinsic@1.2.4: dependencies: es-errors: 1.3.0 function-bind: 1.1.2 @@ -6878,87 +10788,56 @@ packages: has-symbols: 1.0.3 hasown: 2.0.2 - /get-package-type@0.1.0: - resolution: {integrity: sha512-pjzuKtY64GYfWizNAJ0fr9VqttZkNiK2iS430LtIHzjBEr6bX8Am2zm4sW4Ro5wjWW5cAlRL1qAMTcXbjNAO2Q==} - engines: {node: '>=8.0.0'} - dev: true + get-package-type@0.1.0: {} - /get-port@3.2.0: - resolution: {integrity: sha512-x5UJKlgeUiNT8nyo/AcnwLnZuZNcSjSw0kogRB+Whd1fjjFq4B1hySFxSFWWSn4mIBzg3sRNUDFYc4g5gjPoLg==} - engines: {node: '>=4'} - dev: true + get-port@3.2.0: {} - /get-port@5.1.1: - resolution: {integrity: sha512-g/Q1aTSDOxFpchXC4i8ZWvxA1lnPqx/JHqcpIw0/LX9T8x/GBbi6YnlN5nhaKIFkT8oFsscUKgDJYxfwfS6QsQ==} - engines: {node: '>=8'} - dev: true + get-port@5.1.1: {} - /get-stream@5.2.0: - resolution: {integrity: sha512-nBF+F1rAZVCu/p7rjzgA+Yb4lfYXrpl7a6VmJrU8wF9I1CKvP/QwPNZHnOlwbTkY6dvtFIzFMSyQXbLoTQPRpA==} - engines: {node: '>=8'} + get-stream@5.2.0: dependencies: pump: 3.0.0 - /get-stream@6.0.1: - resolution: {integrity: sha512-ts6Wi+2j3jQjqi70w5AlN8DFnkSwC+MqmxEzdEALB2qXZYV3X/b1CTfgPLGJNMeAWxdPfU8FO1ms3NUfaHCPYg==} - engines: {node: '>=10'} + get-stream@6.0.1: {} - /get-symbol-description@1.0.2: - resolution: {integrity: sha512-g0QYk1dZBxGwk+Ngc+ltRH2IBp2f7zBkBMBJZCDerh6EhlhSR6+9irMCuT/09zD6qkarHUSn529sK/yL4S27mg==} - engines: {node: '>= 0.4'} + get-symbol-description@1.0.2: dependencies: call-bind: 1.0.7 es-errors: 1.3.0 get-intrinsic: 1.2.4 - dev: true - /get-tsconfig@4.7.5: - resolution: {integrity: sha512-ZCuZCnlqNzjb4QprAzXKdpp/gh6KTxSJuw3IBsPnV/7fV4NxC9ckB+vPTt8w7fJA0TaSD7c55BR47JD6MEDyDw==} + get-tsconfig@4.7.5: dependencies: resolve-pkg-maps: 1.0.0 - dev: true - /getpass@0.1.7: - resolution: {integrity: sha512-0fzj9JxOLfJ+XGLhR8ze3unN0KZCgZwiSSDz168VERjK8Wl8kVSdcu2kspd4s4wtAa1y/qrVRiAA0WclVsu0ng==} + getpass@0.1.7: dependencies: assert-plus: 1.0.0 - /ghost-testrpc@0.0.2: - resolution: {integrity: sha512-i08dAEgJ2g8z5buJIrCTduwPIhih3DP+hOCTyyryikfV8T0bNvHnGXO67i0DD1H4GBDETTclPy9njZbfluQYrQ==} - hasBin: true + ghost-testrpc@0.0.2: dependencies: chalk: 2.4.2 node-emoji: 1.11.0 - dev: true - /github-from-package@0.0.0: - resolution: {integrity: sha512-SyHy3T1v2NUXn29OsWdxmK6RwHD+vkj3v8en8AOBZ1wBQ/hCAQ5bAQTD02kW4W9tUp/3Qh6J8r9EvntiyCmOOw==} - dev: false + github-from-package@0.0.0: {} - /glob-parent@5.1.2: - resolution: {integrity: sha512-AOIgSQCepiJYwP3ARnGx+5VnTu2HBYdzbGP45eLw1vr3zB3vZLeyed1sC9hnbcOc9/SrMyM5RPQrkGz4aS9Zow==} - engines: {node: '>= 6'} + glob-parent@5.1.2: dependencies: is-glob: 4.0.3 - /glob-parent@6.0.2: - resolution: {integrity: sha512-XxwI8EOhVQgWp6iDL+3b0r86f4d6AX6zSU55HfB4ydCEuXLXc5FcYeOu+nnGftS4TEju/11rt4KJPTMgbfmv4A==} - engines: {node: '>=10.13.0'} + glob-parent@6.0.2: dependencies: is-glob: 4.0.3 - /glob@5.0.15: - resolution: {integrity: sha512-c9IPMazfRITpmAAKi22dK1VKxGDX9ehhqfABDriL/lzO92xcUKEJPQHrVA/2YHSNFB4iFlykVmWvwo48nr3OxA==} + glob@5.0.15: dependencies: inflight: 1.0.6 inherits: 2.0.4 minimatch: 3.1.2 once: 1.4.0 path-is-absolute: 1.0.1 - dev: true - /glob@7.1.7: - resolution: {integrity: sha512-OvD9ENzPLbegENnYP5UUfJIirTg4+XwMWGaQfQTY0JenxNvvIKP3U3/tAQSPIu/lHxXYSZmpXlUHeqAIdKzBLQ==} + glob@7.1.7: dependencies: fs.realpath: 1.0.0 inflight: 1.0.6 @@ -6966,10 +10845,8 @@ packages: minimatch: 3.1.2 once: 1.4.0 path-is-absolute: 1.0.1 - dev: true - /glob@7.2.0: - resolution: {integrity: sha512-lmLf6gtyrPq8tTjSmrO94wBeQbFR3HbLHbuyD69wuyQkImp2hWqMGB47OX65FBkPffO641IP9jWa1z4ivqG26Q==} + glob@7.2.0: dependencies: fs.realpath: 1.0.0 inflight: 1.0.6 @@ -6978,9 +10855,7 @@ packages: once: 1.4.0 path-is-absolute: 1.0.1 - /glob@8.1.0: - resolution: {integrity: sha512-r8hpEjiQEYlF2QU0df3dS+nxxSIreXQS1qRhMJM0Q5NDdR386C7jb7Hwwod8Fgiuex+k0GFjgft18yvxm5XoCQ==} - engines: {node: '>=12'} + glob@8.1.0: dependencies: fs.realpath: 1.0.0 inflight: 1.0.6 @@ -6988,50 +10863,33 @@ packages: minimatch: 5.0.1 once: 1.4.0 - /global-modules@2.0.0: - resolution: {integrity: sha512-NGbfmJBp9x8IxyJSd1P+otYK8vonoJactOogrVfFRIAEY1ukil8RSKDz2Yo7wh1oihl51l/r6W4epkeKJHqL8A==} - engines: {node: '>=6'} + global-modules@2.0.0: dependencies: global-prefix: 3.0.0 - dev: true - /global-prefix@3.0.0: - resolution: {integrity: sha512-awConJSVCHVGND6x3tmMaKcQvwXLhjdkmomy2W+Goaui8YPgYgXJZewhg3fWC+DlfqqQuWg8AwqjGTD2nAPVWg==} - engines: {node: '>=6'} + global-prefix@3.0.0: dependencies: ini: 1.3.8 kind-of: 6.0.3 which: 1.3.1 - dev: true - /global@4.4.0: - resolution: {integrity: sha512-wv/LAoHdRE3BeTGz53FAamhGlPLhlssK45usmGFThIi4XqnBmjKQ16u+RNbP7WvigRZDxUsM0J3gcQ5yicaL0w==} + global@4.4.0: dependencies: min-document: 2.19.0 process: 0.11.10 - /globals@11.12.0: - resolution: {integrity: sha512-WOBp/EEGUiIsJSp7wcv/y6MO+lV9UoncWqxuFfm8eBwzWNgyfBd6Gz+IeKQ9jCmyhoH99g15M3T+QaVHFjizVA==} - engines: {node: '>=4'} - dev: true + globals@11.12.0: {} - /globals@13.24.0: - resolution: {integrity: sha512-AhO5QUcj8llrbG09iWhPU2B204J1xnPeL8kQmVorSsy+Sjj1sk8gIyh6cUocGmH4L0UuhAJy+hJMRA4mgA4mFQ==} - engines: {node: '>=8'} + globals@13.24.0: dependencies: type-fest: 0.20.2 - /globalthis@1.0.4: - resolution: {integrity: sha512-DpLKbNU4WylpxJykQujfCcwYWiV/Jhm50Goo0wrVILAv5jOr9d+H+UR3PhSCD2rCCEIg0uc+G+muBTwD54JhDQ==} - engines: {node: '>= 0.4'} + globalthis@1.0.4: dependencies: define-properties: 1.2.1 gopd: 1.0.1 - dev: true - /globby@10.0.2: - resolution: {integrity: sha512-7dUi7RvCoT/xast/o/dLN53oqND4yk0nsHkhRgn9w65C4PofCLOoJ39iSOg+qVDdWQPIEj+eszMHQ+aLVwwQSg==} - engines: {node: '>=8'} + globby@10.0.2: dependencies: '@types/glob': 7.2.0 array-union: 2.1.0 @@ -7041,11 +10899,8 @@ packages: ignore: 5.3.1 merge2: 1.4.1 slash: 3.0.0 - dev: true - /globby@11.1.0: - resolution: {integrity: sha512-jhIXaOzy1sb8IyocaruWSn1TjmnBVs8Ayhcy83rmxNJ8q2uWKCAj3CnJY+KpGSXCueAPc0i05kVvVKtP1t9S3g==} - engines: {node: '>=10'} + globby@11.1.0: dependencies: array-union: 2.1.0 dir-glob: 3.0.1 @@ -7054,14 +10909,11 @@ packages: merge2: 1.4.1 slash: 3.0.0 - /gopd@1.0.1: - resolution: {integrity: sha512-d65bNlIadxvpb/A2abVdlqKqV563juRnZ1Wtk6s1sIR8uNsXR70xqIzVqxVf1eTqDunwT2MkczEeaezCKTZhwA==} + gopd@1.0.1: dependencies: get-intrinsic: 1.2.4 - /got@11.8.6: - resolution: {integrity: sha512-6tfZ91bOr7bOXnK7PRDCGBLa1H4U080YHNaAQ2KsMGlLEzRbk44nsZF2E1IeRc3vtJHPVbKCYgdFbaGO2ljd8g==} - engines: {node: '>=10.19.0'} + got@11.8.6: dependencies: '@sindresorhus/is': 4.6.0 '@szmarczak/http-timer': 4.0.6 @@ -7075,9 +10927,7 @@ packages: p-cancelable: 2.1.1 responselike: 2.0.1 - /got@12.1.0: - resolution: {integrity: sha512-hBv2ty9QN2RdbJJMK3hesmSkFTjVIHyIDDbssCKnSmq62edGgImJWD10Eb1k77TiV1bxloxqcFAVK8+9pkhOig==} - engines: {node: '>=14.16'} + got@12.1.0: dependencies: '@sindresorhus/is': 4.6.0 '@szmarczak/http-timer': 5.0.1 @@ -7093,20 +10943,13 @@ packages: p-cancelable: 3.0.0 responselike: 2.0.1 - /graceful-fs@4.2.11: - resolution: {integrity: sha512-RbJ5/jmFcNNCcDV5o9eTnBLJ/HszWV0P73bc+Ff4nS/rJj+YaS6IGyiOL0VoBYX+l1Wrl3k63h/KrH+nhJ0XvQ==} + graceful-fs@4.2.11: {} - /grapheme-splitter@1.0.4: - resolution: {integrity: sha512-bzh50DW9kTPM00T8y4o8vQg89Di9oLJVLW/KaOGIXJWP/iqCN6WKYkbNOF04vFLJhwcpYUh9ydh/+5vpOqV4YQ==} - dev: true + grapheme-splitter@1.0.4: {} - /graphemer@1.4.0: - resolution: {integrity: sha512-EtKwoO6kxCL9WO5xipiHTZlSzBm7WLT627TqC/uVRd0HKmq8NXyebnNYxDoBi7wt8eTWrUrKXCOVaFq9x1kgag==} + graphemer@1.4.0: {} - /handlebars@4.7.8: - resolution: {integrity: sha512-vafaFqs8MZkRrSX7sFVUdo3ap/eNiLnb4IakshzvP56X5Nr1iGKAIqdX6tMlm6HcNRIkr6AxO5jFEoJzzpT8aQ==} - engines: {node: '>=0.4.7'} - hasBin: true + handlebars@4.7.8: dependencies: minimist: 1.2.8 neo-async: 2.6.2 @@ -7114,32 +10957,20 @@ packages: wordwrap: 1.0.0 optionalDependencies: uglify-js: 3.17.4 - dev: true - /har-schema@2.0.0: - resolution: {integrity: sha512-Oqluz6zhGX8cyRaTQlFMPw80bSJVG2x/cFb8ZPhUILGgHka9SsokCCOQgpveePerqidZOrT14ipqfJb7ILcW5Q==} - engines: {node: '>=4'} + har-schema@2.0.0: {} - /har-validator@5.1.5: - resolution: {integrity: sha512-nmT2T0lljbxdQZfspsno9hgrG3Uir6Ks5afism62poxqBM6sDnMEuPmzTq8XN0OEwqKLLdh1jQI3qyE66Nzb3w==} - engines: {node: '>=6'} - deprecated: this library is no longer supported + har-validator@5.1.5: dependencies: ajv: 6.12.6 har-schema: 2.0.0 - /hard-rejection@2.1.0: - resolution: {integrity: sha512-VIZB+ibDhx7ObhAe7OVtoEbuP4h/MuOTHJ+J8h/eBXotJYl0fBgR72xDFCKgIh22OJZIOVNxBMWuhAr10r8HdA==} - engines: {node: '>=6'} - dev: true + hard-rejection@2.1.0: {} - /hardhat-gas-reporter@1.0.10(hardhat@packages+hardhat-core): - resolution: {integrity: sha512-02N4+So/fZrzJ88ci54GqwVA3Zrf0C9duuTyGt0CFRIh/CdNwbnTgkXkRfojOMLBQ+6t+lBIkgbsOtqMvNwikA==} - peerDependencies: - hardhat: ^2.0.2 + hardhat-gas-reporter@1.0.10(bufferutil@4.0.8)(hardhat@packages+hardhat-core)(utf-8-validate@5.0.10): dependencies: array-uniq: 1.0.3 - eth-gas-reporter: 0.2.27 + eth-gas-reporter: 0.2.27(bufferutil@4.0.8)(utf-8-validate@5.0.10) hardhat: link:packages/hardhat-core sha1: 1.1.1 transitivePeerDependencies: @@ -7147,151 +10978,96 @@ packages: - bufferutil - debug - utf-8-validate - dev: true - /has-bigints@1.0.2: - resolution: {integrity: sha512-tSvCKtBr9lkF0Ex0aQiP9N+OpV4zi2r/Nee5VkRDbaqv35RLYMzbwQfFSZZH0kR+Rd6302UJZ2p/bJCEoR3VoQ==} - dev: true + has-bigints@1.0.2: {} - /has-color@0.1.7: - resolution: {integrity: sha512-kaNz5OTAYYmt646Hkqw50/qyxP2vFnTVu5AQ1Zmk22Kk5+4Qx6BpO8+u7IKsML5fOsFk0ZT0AcCJNYwcvaLBvw==} - engines: {node: '>=0.10.0'} - dev: true + has-color@0.1.7: {} - /has-flag@1.0.0: - resolution: {integrity: sha512-DyYHfIYwAJmjAjSSPKANxI8bFY9YtFrgkAfinBojQ8YJTOuOuav64tMUJv584SES4xl74PmuaevIyaLESHdTAA==} - engines: {node: '>=0.10.0'} - dev: true + has-flag@1.0.0: {} - /has-flag@3.0.0: - resolution: {integrity: sha512-sKJf1+ceQBr4SMkvQnBDNDtf4TXpVhVGateu0t918bl30FnbE2m4vNLX+VWe/dpjlb+HugGYzW7uQXH98HPEYw==} - engines: {node: '>=4'} + has-flag@3.0.0: {} - /has-flag@4.0.0: - resolution: {integrity: sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ==} - engines: {node: '>=8'} + has-flag@4.0.0: {} - /has-property-descriptors@1.0.2: - resolution: {integrity: sha512-55JNKuIW+vq4Ke1BjOTjM2YctQIvCT7GFzHwmfZPGo5wnrgkid0YQtnAleFSqumZm4az3n2BS+erby5ipJdgrg==} + has-property-descriptors@1.0.2: dependencies: es-define-property: 1.0.0 - /has-proto@1.0.3: - resolution: {integrity: sha512-SJ1amZAJUiZS+PhsVLf5tGydlaVB8EdFpaSO4gmiUKUOxk8qzn5AIy4ZeJUmh22znIdk/uMAUT2pl3FxzVUH+Q==} - engines: {node: '>= 0.4'} + has-proto@1.0.3: {} - /has-symbols@1.0.3: - resolution: {integrity: sha512-l3LCuF6MgDNwTDKkdYGEihYjt5pRPbEg46rtlmnSPlUbgmB8LOIrKJbYYFBSbnPaJexMKtiPO8hmeRjRz2Td+A==} - engines: {node: '>= 0.4'} + has-symbols@1.0.3: {} - /has-tostringtag@1.0.2: - resolution: {integrity: sha512-NqADB8VjPFLM2V0VvHUewwwsw0ZWBaIdgo+ieHtK3hasLz4qeCRjYcqfB6AQrBggRKppKF8L52/VqdVsO47Dlw==} - engines: {node: '>= 0.4'} + has-tostringtag@1.0.2: dependencies: has-symbols: 1.0.3 - /has@1.0.4: - resolution: {integrity: sha512-qdSAmqLF6209RFj4VVItywPMbm3vWylknmB3nvNiUIs72xAimcM8nVYxYr7ncvZq5qzk9MKIZR8ijqD/1QuYjQ==} - engines: {node: '>= 0.4.0'} - dev: true + has@1.0.4: {} - /hash-base@3.1.0: - resolution: {integrity: sha512-1nmYp/rhMDiE7AYkDw+lLwlAzz0AntGIe51F3RfFfEqyQ3feY2eI/NcwC6umIQVOASPMsWJLJScWKSSvzL9IVA==} - engines: {node: '>=4'} + hash-base@3.1.0: dependencies: inherits: 2.0.4 readable-stream: 3.6.2 safe-buffer: 5.2.1 - /hash.js@1.1.3: - resolution: {integrity: sha512-/UETyP0W22QILqS+6HowevwhEFJ3MBJnwTf75Qob9Wz9t0DPuisL8kW8YZMK62dHAKE1c1p+gY1TtOLY+USEHA==} + hash.js@1.1.3: dependencies: inherits: 2.0.4 minimalistic-assert: 1.0.1 - dev: false - /hash.js@1.1.7: - resolution: {integrity: sha512-taOaskGt4z4SOANNseOviYDvjEJinIkRgmp7LbKP2YTTmVxWBl87s/uzK9r+44BclBSp2X7K1hqeNfz9JbBeXA==} + hash.js@1.1.7: dependencies: inherits: 2.0.4 minimalistic-assert: 1.0.1 - /hasha@5.2.2: - resolution: {integrity: sha512-Hrp5vIK/xr5SkeN2onO32H0MgNZ0f17HRNH39WfL0SYUNOTZ5Lz1TJ8Pajo/87dYGEFlLMm7mIc/k/s6Bvz9HQ==} - engines: {node: '>=8'} + hasha@5.2.2: dependencies: is-stream: 2.0.1 type-fest: 0.8.1 - dev: true - /hasown@2.0.2: - resolution: {integrity: sha512-0hJU9SCPvmMzIBdZFqNPXWa6dqh7WdH0cII9y+CyS8rG3nL48Bclra9HmKhVVUHyPWNH5Y7xDwAB7bfgSjkUMQ==} - engines: {node: '>= 0.4'} + hasown@2.0.2: dependencies: function-bind: 1.1.2 - /he@1.2.0: - resolution: {integrity: sha512-F/1DnUGPopORZi0ni+CvrCgHQ5FyEAHRLSApuYWMmrbSwoN2Mn/7k+Gl38gJnR7yyDZk6WLXwiGod1JOWNDKGw==} - hasBin: true + he@1.2.0: {} - /header-case@1.0.1: - resolution: {integrity: sha512-i0q9mkOeSuhXw6bGgiQCCBgY/jlZuV/7dZXyZ9c6LcBrqwvT8eT719E9uxE5LiZftdl+z81Ugbg/VvXV4OJOeQ==} + header-case@1.0.1: dependencies: no-case: 2.3.2 upper-case: 1.1.3 - dev: false - /heap@0.2.7: - resolution: {integrity: sha512-2bsegYkkHO+h/9MGbn6KWcE45cHZgPANo5LXF7EvWdT0yT2EguSVO1nDgU5c8+ZOPwp2vMNa7YFsJhVcDR9Sdg==} - dev: true + heap@0.2.7: {} - /highlight.js@10.7.3: - resolution: {integrity: sha512-tzcUFauisWKNHaRkN4Wjl/ZA07gENAjFl3J/c480dprkGTg5EQstgaNFqBfUqCq54kZRIEcreTsAgF/m2quD7A==} - dev: false + highlight.js@10.7.3: {} - /highlightjs-solidity@2.0.6: - resolution: {integrity: sha512-DySXWfQghjm2l6a/flF+cteroJqD4gI8GSdL4PtvxZSsAHie8m3yVe2JFoRg03ROKT6hp2Lc/BxXkqerNmtQYg==} - dev: false + highlightjs-solidity@2.0.6: {} - /hmac-drbg@1.0.1: - resolution: {integrity: sha512-Tti3gMqLdZfhOQY1Mzf/AanLiqh1WTiJgEj26ZuYQ9fbkLomzGchCws4FyrSd4VkpBfiNhaE1On+lOz894jvXg==} + hmac-drbg@1.0.1: dependencies: hash.js: 1.1.7 minimalistic-assert: 1.0.1 minimalistic-crypto-utils: 1.0.1 - /hosted-git-info@2.8.9: - resolution: {integrity: sha512-mxIDAb9Lsm6DoOJ7xH+5+X4y1LU/4Hi50L9C5sIswK3JzULS4bwk1FvjdBgvYR4bzT4tuUQiC15FE2f5HbLvYw==} + hosted-git-info@2.8.9: {} - /html-escaper@2.0.2: - resolution: {integrity: sha512-H2iMtd0I4Mt5eYiapRdIDjp+XzelXQ0tFE4JS7YFwFevXXMmOp9myNrUvCg0D6ws8iqkRPBfKHgbwig1SmlLfg==} - dev: true + html-escaper@2.0.2: {} - /htmlparser2@8.0.2: - resolution: {integrity: sha512-GYdjWKDkbRLkZ5geuHs5NY1puJ+PXwP7+fHPRz06Eirsb9ugf6d8kkXav6ADhcODhFFPMIXyxkxSuMf3D6NCFA==} + htmlparser2@8.0.2: dependencies: domelementtype: 2.3.0 domhandler: 5.0.3 domutils: 3.1.0 entities: 4.5.0 - dev: false - - /http-basic@8.1.3: - resolution: {integrity: sha512-/EcDMwJZh3mABI2NhGfHOGOeOZITqfkEO4p/xK+l3NpyncIHUQBoMvCSF/b5GqvKtySC2srL/GGG3+EtlqlmCw==} - engines: {node: '>=6.0.0'} + + http-basic@8.1.3: dependencies: caseless: 0.12.0 concat-stream: 1.6.2 http-response-object: 3.0.2 parse-cache-control: 1.0.1 - dev: true - /http-cache-semantics@4.1.1: - resolution: {integrity: sha512-er295DKPVsV82j5kw1Gjt+ADA/XYHsajl82cGNQG2eyoPkvgUhX+nDIyelzhIWbbsXP39EHcI6l5tYs2FYqYXQ==} + http-cache-semantics@4.1.1: {} - /http-errors@2.0.0: - resolution: {integrity: sha512-FtwrG/euBzaEjYeRqOgly7G0qviiXoJWnvEH2Z1plBdXgbyjv34pHTSb9zoeHMyDy33+DWy5Wt9Wo+TURtOYSQ==} - engines: {node: '>= 0.8'} + http-errors@2.0.0: dependencies: depd: 2.0.0 inherits: 2.0.4 @@ -7299,424 +11075,253 @@ packages: statuses: 2.0.1 toidentifier: 1.0.1 - /http-https@1.0.0: - resolution: {integrity: sha512-o0PWwVCSp3O0wS6FvNr6xfBCHgt0m1tvPLFOCc2iFDKTRAXhB7m8klDf7ErowFH8POa6dVdGatKU5I1YYwzUyg==} + http-https@1.0.0: {} - /http-response-object@3.0.2: - resolution: {integrity: sha512-bqX0XTF6fnXSQcEJ2Iuyr75yVakyjIDCqroJQ/aHfSdlM743Cwqoi2nDYMzLGWUcuTWGWy8AAvOKXTfiv6q9RA==} + http-response-object@3.0.2: dependencies: '@types/node': 10.17.60 - dev: true - /http-signature@1.2.0: - resolution: {integrity: sha512-CAbnr6Rz4CYQkLYUtSNXxQPUH2gK8f3iWexVlsnMeD+GjlsQ0Xsy1cOX+mN3dtxYomRy21CiOzU8Uhw6OwncEQ==} - engines: {node: '>=0.8', npm: '>=1.3.7'} + http-signature@1.2.0: dependencies: assert-plus: 1.0.0 jsprim: 1.4.2 sshpk: 1.18.0 - /http2-wrapper@1.0.3: - resolution: {integrity: sha512-V+23sDMr12Wnz7iTcDeJr3O6AIxlnvT/bmaAAAP/Xda35C90p9599p0F1eHR/N1KILWSoWVAiOMFjBBXaXSMxg==} - engines: {node: '>=10.19.0'} + http2-wrapper@1.0.3: dependencies: quick-lru: 5.1.1 resolve-alpn: 1.2.1 - /http2-wrapper@2.2.1: - resolution: {integrity: sha512-V5nVw1PAOgfI3Lmeaj2Exmeg7fenjhRUgz1lPSezy1CuhPYbgQtbQj4jZfEAEMlaL+vupsvhjqCyjzob0yxsmQ==} - engines: {node: '>=10.19.0'} + http2-wrapper@2.2.1: dependencies: quick-lru: 5.1.1 resolve-alpn: 1.2.1 - /https-proxy-agent@5.0.1: - resolution: {integrity: sha512-dFcAjpTQFgoLMzC2VwU+C/CbS7uRL0lWmxDITmqm7C+7F0Odmj6s9l6alZc6AELXhrnggM2CeWSXHGOdX2YtwA==} - engines: {node: '>= 6'} + https-proxy-agent@5.0.1: dependencies: agent-base: 6.0.2 debug: 4.3.4(supports-color@8.1.1) transitivePeerDependencies: - supports-color - dev: false - /human-id@1.0.2: - resolution: {integrity: sha512-UNopramDEhHJD+VR+ehk8rOslwSfByxPIZyJRfV739NDhN5LF1fa1MqnzKm2lGTQRjNrjK19Q5fhkgIfjlVUKw==} - dev: true + human-id@1.0.2: {} - /iconv-lite@0.4.24: - resolution: {integrity: sha512-v3MXnZAcvnywkTUEZomIActle7RXXeedOR31wwl7VlyoXO4Qi9arvSenNQWne1TcRwhCL1HwLI21bEqdpj8/rA==} - engines: {node: '>=0.10.0'} + iconv-lite@0.4.24: dependencies: safer-buffer: 2.1.2 - /idna-uts46-hx@2.3.1: - resolution: {integrity: sha512-PWoF9Keq6laYdIRwwCdhTPl60xRqAloYNMQLiyUnG42VjT53oW07BXIRM+NK7eQjzXjAk2gUvX9caRxlnF9TAA==} - engines: {node: '>=4.0.0'} + idna-uts46-hx@2.3.1: dependencies: punycode: 2.1.0 - /ieee754@1.2.1: - resolution: {integrity: sha512-dcyqhDvX1C46lXZcVqCpK+FtMRQVdIMN6/Df5js2zouUsqG7I6sFxitIC+7KYK29KdXOLHdu9zL4sFnoVQnqaA==} + ieee754@1.2.1: {} - /ignore@5.3.1: - resolution: {integrity: sha512-5Fytz/IraMjqpwfd34ke28PTVMjZjJG2MPn5t7OE4eUCUNf8BAa7b5WUS9/Qvr6mwOQS7Mk6vdsMno5he+T8Xw==} - engines: {node: '>= 4'} + ignore@5.3.1: {} - /immer@10.0.2: - resolution: {integrity: sha512-Rx3CqeqQ19sxUtYV9CU911Vhy8/721wRFnJv3REVGWUmoAcIwzifTsdmJte/MV+0/XpM35LZdQMBGkRIoLPwQA==} - dev: true + immer@10.0.2: {} - /immutable@4.3.5: - resolution: {integrity: sha512-8eabxkth9gZatlwl5TBuJnCsoTADlL6ftEr7A4qgdaTsPyreilDSnUk57SO+jfKcNtxPa22U5KK6DSeAYhpBJw==} - dev: false + immutable@4.3.5: {} - /import-fresh@3.3.0: - resolution: {integrity: sha512-veYYhQa+D1QBKznvhUHxb8faxlrwUnxseDAbAp457E0wLNio2bOSKnjYDhMj+YiAq61xrMGhQk9iXVk5FzgQMw==} - engines: {node: '>=6'} + import-fresh@3.3.0: dependencies: parent-module: 1.0.1 resolve-from: 4.0.0 - /imurmurhash@0.1.4: - resolution: {integrity: sha512-JmXMZ6wuvDmLiHEml9ykzqO6lwFbof0GG4IkcGaENdCRDDmMVnny7s5HsIgHCbaq0w2MyPhDqkhTUgS2LU2PHA==} - engines: {node: '>=0.8.19'} + imurmurhash@0.1.4: {} - /indent-string@4.0.0: - resolution: {integrity: sha512-EdDDZu4A2OyIK7Lr/2zG+w5jmbuk1DVBnEwREQvBzspBJkCEbRa8GxU1lghYcaGJCnRWibjDXlq779X1/y5xwg==} - engines: {node: '>=8'} + indent-string@4.0.0: {} - /inflight@1.0.6: - resolution: {integrity: sha512-k92I/b08q4wvFscXCLvqfsHCrjrF7yiXsQuIVvVE7N82W3+aqpzuUdBbfhWcy/FZR3/4IgflMgKLOsvPDrGCJA==} + inflight@1.0.6: dependencies: once: 1.4.0 wrappy: 1.0.2 - /inherits@2.0.4: - resolution: {integrity: sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ==} + inherits@2.0.4: {} - /ini@1.3.8: - resolution: {integrity: sha512-JV/yugV2uzW5iMRSiZAyDtQd+nxtUnjeLt0acNdw98kKLrvuRVyB80tsREOE7yvGVgalhZ6RNXCmEHkUKBKxew==} + ini@1.3.8: {} - /internal-slot@1.0.7: - resolution: {integrity: sha512-NGnrKwXzSms2qUUih/ILZ5JBqNTSa1+ZmP6flaIp6KmSElgE9qdndzS3cqjrDovwFdmwsGsLdeFgB6suw+1e9g==} - engines: {node: '>= 0.4'} + internal-slot@1.0.7: dependencies: es-errors: 1.3.0 hasown: 2.0.2 side-channel: 1.0.6 - dev: true - /interpret@1.4.0: - resolution: {integrity: sha512-agE4QfB2Lkp9uICn7BAqoscw4SZP9kTE2hxiFI3jBPmXJfdqiahTbUuKGsMoN2GtqL9AxhYioAcVvgsb1HvRbA==} - engines: {node: '>= 0.10'} - dev: true + interpret@1.4.0: {} - /invariant@2.2.4: - resolution: {integrity: sha512-phJfQVBuaJM5raOpJjSfkiD6BpbCE4Ns//LaXl6wGYtUBY83nWS6Rf9tXm2e8VaK60JEjYldbPif/A2B1C2gNA==} + invariant@2.2.4: dependencies: loose-envify: 1.4.0 - dev: false - /invert-kv@1.0.0: - resolution: {integrity: sha512-xgs2NH9AE66ucSq4cNG1nhSFghr5l6tdL15Pk+jl46bmmBapgoaY/AacXyaDznAqmGL99TiLSQgO/XazFSKYeQ==} - engines: {node: '>=0.10.0'} - dev: false + invert-kv@1.0.0: {} - /io-ts@1.10.4: - resolution: {integrity: sha512-b23PteSnYXSONJ6JQXRAlvJhuw8KOtkqa87W4wDtvMrud/DTJd5X+NpOOI+O/zZwVq6v0VLAaJ+1EDViKEuN9g==} + io-ts@1.10.4: dependencies: fp-ts: 1.19.3 - dev: false - /ipaddr.js@1.9.1: - resolution: {integrity: sha512-0KI/607xoxSToH7GjN1FfSbLoU0+btTicjsQSWQlh/hZykN8KpmMf7uYwPW3R+akZ6R/w18ZlXSHBYXiYUPO3g==} - engines: {node: '>= 0.10'} + ipaddr.js@1.9.1: {} - /is-arguments@1.1.1: - resolution: {integrity: sha512-8Q7EARjzEnKpt/PCD7e1cgUS0a6X8u5tdSiMqXhojOdoV9TsMsiO+9VLC5vAmO8N7/GmXn7yjR8qnA6bVAEzfA==} - engines: {node: '>= 0.4'} + is-arguments@1.1.1: dependencies: call-bind: 1.0.7 has-tostringtag: 1.0.2 - /is-array-buffer@3.0.4: - resolution: {integrity: sha512-wcjaerHw0ydZwfhiKbXJWLDY8A7yV7KhjQOpb83hGgGfId/aQa4TOvwyzn2PuswW2gPCYEL/nEAiSVpdOj1lXw==} - engines: {node: '>= 0.4'} + is-array-buffer@3.0.4: dependencies: call-bind: 1.0.7 get-intrinsic: 1.2.4 - dev: true - /is-arrayish@0.2.1: - resolution: {integrity: sha512-zz06S8t0ozoDXMG+ube26zeCTNXcKIPJZJi8hBrF4idCLms4CG9QtK7qBl1boi5ODzFpjswb5JPmHCbMpjaYzg==} + is-arrayish@0.2.1: {} - /is-bigint@1.0.4: - resolution: {integrity: sha512-zB9CruMamjym81i2JZ3UMn54PKGsQzsJeo6xvN3HJJ4CAsQNB6iRutp2To77OfCNuoxspsIhzaPoO1zyCEhFOg==} + is-bigint@1.0.4: dependencies: has-bigints: 1.0.2 - dev: true - /is-binary-path@2.1.0: - resolution: {integrity: sha512-ZMERYes6pDydyuGidse7OsHxtbI7WVeUEozgR/g7rd0xUimYNlvZRE/K2MgZTjWy725IfelLeVcEM97mmtRGXw==} - engines: {node: '>=8'} + is-binary-path@2.1.0: dependencies: binary-extensions: 2.3.0 - /is-boolean-object@1.1.2: - resolution: {integrity: sha512-gDYaKHJmnj4aWxyj6YHyXVpdQawtVLHU5cb+eztPGczf6cjuTdwve5ZIEfgXqH4e57An1D1AKf8CZ3kYrQRqYA==} - engines: {node: '>= 0.4'} + is-boolean-object@1.1.2: dependencies: call-bind: 1.0.7 has-tostringtag: 1.0.2 - dev: true - /is-builtin-module@3.2.1: - resolution: {integrity: sha512-BSLE3HnV2syZ0FK0iMA/yUGplUeMmNz4AW5fnTunbCIqZi4vG3WjJT9FHMy5D69xmAYBHXQhJdALdpwVxV501A==} - engines: {node: '>=6'} + is-builtin-module@3.2.1: dependencies: builtin-modules: 3.3.0 - dev: true - /is-callable@1.2.7: - resolution: {integrity: sha512-1BC0BVFhS/p0qtw6enp8e+8OD0UrK0oFLztSjNzhcKA3WDuJxxAPXzPuPtKkjEY9UUoEWlX/8fgKeu2S8i9JTA==} - engines: {node: '>= 0.4'} + is-callable@1.2.7: {} - /is-core-module@2.13.1: - resolution: {integrity: sha512-hHrIjvZsftOsvKSn2TRYl63zvxsgE0K+0mYMoH6gD4omR5IWB2KynivBQczo3+wF1cCkjzvptnI9Q0sPU66ilw==} + is-core-module@2.13.1: dependencies: hasown: 2.0.2 - /is-data-view@1.0.1: - resolution: {integrity: sha512-AHkaJrsUVW6wq6JS8y3JnM/GJF/9cf+k20+iDzlSaJrinEo5+7vRiteOSwBhHRiAyQATN1AmY4hwzxJKPmYf+w==} - engines: {node: '>= 0.4'} + is-data-view@1.0.1: dependencies: is-typed-array: 1.1.13 - dev: true - /is-date-object@1.0.5: - resolution: {integrity: sha512-9YQaSxsAiSwcvS33MBk3wTCVnWK+HhF8VZR2jRxehM16QcVOdHqPn4VPHmRK4lSr38n9JriurInLcP90xsYNfQ==} - engines: {node: '>= 0.4'} + is-date-object@1.0.5: dependencies: has-tostringtag: 1.0.2 - dev: true - /is-extglob@2.1.1: - resolution: {integrity: sha512-SbKbANkN603Vi4jEZv49LeVJMn4yGwsbzZworEoyEiutsN3nJYdbO36zfhGJ6QEDpOZIFkDtnq5JRxmvl3jsoQ==} - engines: {node: '>=0.10.0'} + is-extglob@2.1.1: {} - /is-fullwidth-code-point@1.0.0: - resolution: {integrity: sha512-1pqUqRjkhPJ9miNq9SwMfdvi6lBJcd6eFxvfaivQhaH3SgisfiuudvFntdKOmxuee/77l+FPjKrQjWvmPjWrRw==} - engines: {node: '>=0.10.0'} + is-fullwidth-code-point@1.0.0: dependencies: number-is-nan: 1.0.1 - dev: false - /is-fullwidth-code-point@2.0.0: - resolution: {integrity: sha512-VHskAKYM8RfSFXwee5t5cbN5PZeq1Wrh6qd5bkyiXIf6UQcN6w/A0eXM9r6t8d+GYOh+o6ZhiEnb88LN/Y8m2w==} - engines: {node: '>=4'} - dev: true + is-fullwidth-code-point@2.0.0: {} - /is-fullwidth-code-point@3.0.0: - resolution: {integrity: sha512-zymm5+u+sCsSWyD9qNaejV3DFvhCKclKdizYaJUuHA83RLjb7nSuGnddCHGv0hk+KY7BMAlsWeK4Ueg6EV6XQg==} - engines: {node: '>=8'} + is-fullwidth-code-point@3.0.0: {} - /is-function@1.0.2: - resolution: {integrity: sha512-lw7DUp0aWXYg+CBCN+JKkcE0Q2RayZnSvnZBlwgxHBQhqt5pZNVy4Ri7H9GmmXkdu7LUthszM+Tor1u/2iBcpQ==} + is-function@1.0.2: {} - /is-generator-function@1.0.10: - resolution: {integrity: sha512-jsEjy9l3yiXEQ+PsXdmBwEPcOxaXWLspKdplFUVI9vq1iZgIekeC0L167qeu86czQaxed3q/Uzuw0swL0irL8A==} - engines: {node: '>= 0.4'} + is-generator-function@1.0.10: dependencies: has-tostringtag: 1.0.2 - /is-glob@4.0.3: - resolution: {integrity: sha512-xelSayHH36ZgE7ZWhli7pW34hNbNl8Ojv5KVmkJD4hBdD3th8Tfk9vYasLM+mXWOZhFkgZfxhLSnrwRr4elSSg==} - engines: {node: '>=0.10.0'} + is-glob@4.0.3: dependencies: is-extglob: 2.1.1 - /is-hex-prefixed@1.0.0: - resolution: {integrity: sha512-WvtOiug1VFrE9v1Cydwm+FnXd3+w9GaeVUss5W4v/SLy3UW00vP+6iNF2SdnfiBoLy4bTqVdkftNGTUeOFVsbA==} - engines: {node: '>=6.5.0', npm: '>=3'} + is-hex-prefixed@1.0.0: {} - /is-interactive@1.0.0: - resolution: {integrity: sha512-2HvIEKRoqS62guEC+qBjpvRubdX910WCMuJTZ+I9yvqKU2/12eSL549HMwtabb4oupdj2sMP50k+XJfB/8JE6w==} - engines: {node: '>=8'} - dev: false + is-interactive@1.0.0: {} - /is-lower-case@1.1.3: - resolution: {integrity: sha512-+5A1e/WJpLLXZEDlgz4G//WYSHyQBD32qa4Jd3Lw06qQlv3fJHnp3YIHjTQSGzHMgzmVKz2ZP3rBxTHkPw/lxA==} + is-lower-case@1.1.3: dependencies: lower-case: 1.1.4 - dev: false - /is-negative-zero@2.0.3: - resolution: {integrity: sha512-5KoIu2Ngpyek75jXodFvnafB6DJgr3u8uuK0LEZJjrU19DrMD3EVERaR8sjz8CCGgpZvxPl9SuE1GMVPFHx1mw==} - engines: {node: '>= 0.4'} - dev: true + is-negative-zero@2.0.3: {} - /is-number-object@1.0.7: - resolution: {integrity: sha512-k1U0IRzLMo7ZlYIfzRu23Oh6MiIFasgpb9X76eqfFZAqwH44UI4KTBvBYIZ1dSL9ZzChTB9ShHfLkR4pdW5krQ==} - engines: {node: '>= 0.4'} + is-number-object@1.0.7: dependencies: has-tostringtag: 1.0.2 - dev: true - /is-number@7.0.0: - resolution: {integrity: sha512-41Cifkg6e8TylSpdtTpeLVMqvSBEVzTttHvERD741+pnZ8ANv0004MRL43QKPDlK9cGvNp6NZWZUBlbGXYxxng==} - engines: {node: '>=0.12.0'} + is-number@7.0.0: {} - /is-path-inside@3.0.3: - resolution: {integrity: sha512-Fd4gABb+ycGAmKou8eMftCupSir5lRxqf4aD/vd0cD2qc4HL07OjCeuHMr8Ro4CoMaeCKDB0/ECBOVWjTwUvPQ==} - engines: {node: '>=8'} + is-path-inside@3.0.3: {} - /is-plain-obj@1.1.0: - resolution: {integrity: sha512-yvkRyxmFKEOQ4pNXCmJG5AEQNlXJS5LaONXo5/cLdTZdWvsZ1ioJEonLGAosKlMWE8lwUy/bJzMjcw8az73+Fg==} - engines: {node: '>=0.10.0'} - dev: true + is-plain-obj@1.1.0: {} - /is-plain-obj@2.1.0: - resolution: {integrity: sha512-YWnfyRwxL/+SsrWYfOpUtz5b3YD+nyfkHvjbcanzk8zgyO4ASD67uVMRt8k5bM4lLMDnXfriRhOpemw+NfT1eA==} - engines: {node: '>=8'} + is-plain-obj@2.1.0: {} - /is-regex@1.1.4: - resolution: {integrity: sha512-kvRdxDsxZjhzUX07ZnLydzS1TU/TJlTUHHY4YLL87e37oUA49DfkLqgy+VjFocowy29cKvcSiu+kIv728jTTVg==} - engines: {node: '>= 0.4'} + is-regex@1.1.4: dependencies: call-bind: 1.0.7 has-tostringtag: 1.0.2 - dev: true - /is-shared-array-buffer@1.0.3: - resolution: {integrity: sha512-nA2hv5XIhLR3uVzDDfCIknerhx8XUKnstuOERPNNIinXG7v9u+ohXF67vxm4TPTEPU6lm61ZkwP3c9PCB97rhg==} - engines: {node: '>= 0.4'} + is-shared-array-buffer@1.0.3: dependencies: call-bind: 1.0.7 - dev: true - /is-stream@2.0.1: - resolution: {integrity: sha512-hFoiJiTl63nn+kstHGBtewWSKnQLpyb155KHheA1l39uvtO9nWIop1p3udqPcUd/xbF1VLMO4n7OI6p7RbngDg==} - engines: {node: '>=8'} - dev: true + is-stream@2.0.1: {} - /is-string@1.0.7: - resolution: {integrity: sha512-tE2UXzivje6ofPW7l23cjDOMa09gb7xlAqG6jG5ej6uPV32TlWP3NKPigtaGeHNu9fohccRYvIiZMfOOnOYUtg==} - engines: {node: '>= 0.4'} + is-string@1.0.7: dependencies: has-tostringtag: 1.0.2 - dev: true - /is-subdir@1.2.0: - resolution: {integrity: sha512-2AT6j+gXe/1ueqbW6fLZJiIw3F8iXGJtt0yDrZaBhAZEG1raiTxKWU+IPqMCzQAXOUCKdA4UDMgacKH25XG2Cw==} - engines: {node: '>=4'} + is-subdir@1.2.0: dependencies: better-path-resolve: 1.0.0 - dev: true - /is-symbol@1.0.4: - resolution: {integrity: sha512-C/CPBqKWnvdcxqIARxyOh4v1UUEOCHpgDa0WYgpKDFMszcrPcffg5uhwSgPCLD2WWxmq6isisz87tzT01tuGhg==} - engines: {node: '>= 0.4'} + is-symbol@1.0.4: dependencies: has-symbols: 1.0.3 - dev: true - /is-typed-array@1.1.13: - resolution: {integrity: sha512-uZ25/bUAlUY5fR4OKT4rZQEBrzQWYV9ZJYGGsUmEJ6thodVJ1HX64ePQ6Z0qPWP+m+Uq6e9UugrE38jeYsDSMw==} - engines: {node: '>= 0.4'} + is-typed-array@1.1.13: dependencies: which-typed-array: 1.1.15 - /is-typedarray@1.0.0: - resolution: {integrity: sha512-cyA56iCMHAh5CdzjJIa4aohJyeO1YbwLi3Jc35MmRU6poroFjIGZzUzupGiRPOjgHg9TLu43xbpwXk523fMxKA==} + is-typedarray@1.0.0: {} - /is-unicode-supported@0.1.0: - resolution: {integrity: sha512-knxG2q4UC3u8stRGyAVJCOdxFmv5DZiRcdlIaAQXAbSfJya+OhopNotLQrstBhququ4ZpuKbDc/8S6mgXgPFPw==} - engines: {node: '>=10'} + is-unicode-supported@0.1.0: {} - /is-upper-case@1.1.2: - resolution: {integrity: sha512-GQYSJMgfeAmVwh9ixyk888l7OIhNAGKtY6QA+IrWlu9MDTCaXmeozOZ2S9Knj7bQwBO/H6J2kb+pbyTUiMNbsw==} + is-upper-case@1.1.2: dependencies: upper-case: 1.1.3 - dev: false - /is-url@1.2.4: - resolution: {integrity: sha512-ITvGim8FhRiYe4IQ5uHSkj7pVaPDrCTkNd3yq3cV7iZAcJdHTUMPMEHcqSOy9xZ9qFenQCvi+2wjH9a1nXqHww==} - dev: true + is-url@1.2.4: {} - /is-utf8@0.2.1: - resolution: {integrity: sha512-rMYPYvCzsXywIsldgLaSoPlw5PfoB/ssr7hY4pLfcodrA5M/eArza1a9VmTiNIBNMjOGr1Ow9mTyU2o69U6U9Q==} - dev: false + is-utf8@0.2.1: {} - /is-weakref@1.0.2: - resolution: {integrity: sha512-qctsuLZmIQ0+vSSMfoVvyFe2+GSEvnmZ2ezTup1SBse9+twCCeial6EEi3Nc2KFcf6+qz2FBPnjXsk8xhKSaPQ==} + is-weakref@1.0.2: dependencies: call-bind: 1.0.7 - dev: true - /is-windows@1.0.2: - resolution: {integrity: sha512-eXK1UInq2bPmjyX6e3VHIzMLobc4J94i4AWn+Hpq3OU5KkrRC96OAcR3PRJ/pGu6m8TRnBHP9dkXQVsT/COVIA==} - engines: {node: '>=0.10.0'} - dev: true + is-windows@1.0.2: {} - /isarray@0.0.1: - resolution: {integrity: sha512-D2S+3GLxWH+uhrNEcoh/fnmYeP8E8/zHl644d/jdA0g2uyXvy3sb0qxotE+ne0LtccHknQzWwZEzhak7oJ0COQ==} - dev: true + isarray@0.0.1: {} - /isarray@1.0.0: - resolution: {integrity: sha512-VLghIWNM6ELQzo7zwmcg0NmTVyWKYjvIeM83yjp0wRDTmUnrM678fQbcKBo6n2CJEF0szoG//ytg+TKla89ALQ==} - dev: true + isarray@1.0.0: {} - /isarray@2.0.5: - resolution: {integrity: sha512-xHjhDr3cNBK0BzdUJSPXZntQUx/mwMS5Rw4A7lPJ90XGAO6ISP/ePDNuo0vhqOZU+UD5JoodwCAAoZQd3FeAKw==} - dev: true + isarray@2.0.5: {} - /isexe@2.0.0: - resolution: {integrity: sha512-RHxMLp9lnKHGHRng9QFhRCMbYAcVpn69smSGcq3f36xjgVVWThj4qqLbTLlq7Ssj8B+fIQ1EuCEGI2lKsyQeIw==} + isexe@2.0.0: {} - /isomorphic-fetch@3.0.0: - resolution: {integrity: sha512-qvUtwJ3j6qwsF3jLxkZ72qCgjMysPzDfeV240JHiGZsANBYd+EEuu35v7dfrJ9Up0Ak07D7GGSkGhCHTqg/5wA==} + isomorphic-fetch@3.0.0: dependencies: node-fetch: 2.7.0 whatwg-fetch: 3.6.20 transitivePeerDependencies: - encoding - dev: true - /isomorphic-ws@5.0.0(ws@8.17.0): - resolution: {integrity: sha512-muId7Zzn9ywDsyXgTIafTry2sV3nySZeUDe6YedVd1Hvuuep5AsIlqK+XefWpYTyJG5e503F2xIuT2lcU6rCSw==} - peerDependencies: - ws: '*' + isomorphic-ws@5.0.0(ws@8.17.0(bufferutil@4.0.8)(utf-8-validate@5.0.10)): dependencies: - ws: 8.17.0 - dev: true + ws: 8.17.0(bufferutil@4.0.8)(utf-8-validate@5.0.10) - /isows@1.0.3(ws@8.13.0): - resolution: {integrity: sha512-2cKei4vlmg2cxEjm3wVSqn8pcoRF/LX/wpifuuNquFO4SQmPwarClT+SUCA2lt+l581tTeZIPIZuIDo2jWN1fg==} - peerDependencies: - ws: '*' + isows@1.0.3(ws@8.13.0(bufferutil@4.0.8)(utf-8-validate@5.0.10)): dependencies: - ws: 8.13.0 - dev: true + ws: 8.13.0(bufferutil@4.0.8)(utf-8-validate@5.0.10) - /isstream@0.1.2: - resolution: {integrity: sha512-Yljz7ffyPbrLpLngrMtZ7NduUgVvi6wG9RJ9IUcyCd59YQ911PBJphODUcbOVbqYfxe1wuYf/LJ8PauMRwsM/g==} + isstream@0.1.2: {} - /istanbul-lib-coverage@3.2.2: - resolution: {integrity: sha512-O8dpsF+r0WV/8MNRKfnmrtCWhuKjxrq2w+jpzBL5UZKTi2LeVWnWOmWRxFlesJONmc+wLAGvKQZEOanko0LFTg==} - engines: {node: '>=8'} - dev: true + istanbul-lib-coverage@3.2.2: {} - /istanbul-lib-hook@3.0.0: - resolution: {integrity: sha512-Pt/uge1Q9s+5VAZ+pCo16TYMWPBIl+oaNIjgLQxcX0itS6ueeaA+pEfThZpH8WxhFgCiEb8sAJY6MdUKgiIWaQ==} - engines: {node: '>=8'} + istanbul-lib-hook@3.0.0: dependencies: append-transform: 2.0.0 - dev: true - /istanbul-lib-instrument@4.0.3: - resolution: {integrity: sha512-BXgQl9kf4WTCPCCpmFGoJkz/+uhvm7h7PFKUYxh7qarQd3ER33vHG//qaE8eN25l07YqZPpHXU9I09l/RD5aGQ==} - engines: {node: '>=8'} + istanbul-lib-instrument@4.0.3: dependencies: '@babel/core': 7.24.5 '@istanbuljs/schema': 0.1.3 @@ -7724,11 +11329,8 @@ packages: semver: 6.3.1 transitivePeerDependencies: - supports-color - dev: true - /istanbul-lib-processinfo@2.0.3: - resolution: {integrity: sha512-NkwHbo3E00oybX6NGJi6ar0B29vxyvNwoC7eJ4G4Yq28UfY758Hgn/heV8VRFhevPED4LXfFz0DQ8z/0kw9zMg==} - engines: {node: '>=8'} + istanbul-lib-processinfo@2.0.3: dependencies: archy: 1.0.0 cross-spawn: 7.0.3 @@ -7736,437 +11338,264 @@ packages: p-map: 3.0.0 rimraf: 3.0.2 uuid: 8.3.2 - dev: true - /istanbul-lib-report@3.0.1: - resolution: {integrity: sha512-GCfE1mtsHGOELCU8e/Z7YWzpmybrx/+dSTfLrvY8qRmaY6zXTKWn6WQIjaAFw069icm6GVMNkgu0NzI4iPZUNw==} - engines: {node: '>=10'} + istanbul-lib-report@3.0.1: dependencies: istanbul-lib-coverage: 3.2.2 make-dir: 4.0.0 supports-color: 7.2.0 - dev: true - /istanbul-lib-source-maps@4.0.1: - resolution: {integrity: sha512-n3s8EwkdFIJCG3BPKBYvskgXGoy88ARzvegkitk60NxRdwltLOTaH7CUiMRXvwYorl0Q712iEjcWB+fK/MrWVw==} - engines: {node: '>=10'} + istanbul-lib-source-maps@4.0.1: dependencies: debug: 4.3.4(supports-color@8.1.1) istanbul-lib-coverage: 3.2.2 source-map: 0.6.1 transitivePeerDependencies: - supports-color - dev: true - /istanbul-reports@3.1.7: - resolution: {integrity: sha512-BewmUXImeuRk2YY0PVbxgKAysvhRPUQE0h5QRM++nVWyubKGV0l8qQ5op8+B2DOmwSe63Jivj0BjkPQVf8fP5g==} - engines: {node: '>=8'} + istanbul-reports@3.1.7: dependencies: html-escaper: 2.0.2 istanbul-lib-report: 3.0.1 - dev: true - /jest-diff@29.7.0: - resolution: {integrity: sha512-LMIgiIrhigmPrs03JHpxUh2yISK3vLFPkAodPeo0+BuF7wA2FoQbkEg1u8gBYBThncu7e1oEDUfIXVuTqLRUjw==} - engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0} + jest-diff@29.7.0: dependencies: chalk: 4.1.2 diff-sequences: 29.6.3 jest-get-type: 29.6.3 pretty-format: 29.7.0 - dev: true - /jest-get-type@29.6.3: - resolution: {integrity: sha512-zrteXnqYxfQh7l5FHyL38jL39di8H8rHoecLH3JNxH3BwOrBsNeabdap5e0I23lD4HHI8W5VFBZqG4Eaq5LNcw==} - engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0} - dev: true + jest-get-type@29.6.3: {} - /js-sha3@0.5.5: - resolution: {integrity: sha512-yLLwn44IVeunwjpDVTDZmQeVbB0h+dZpY2eO68B/Zik8hu6dH+rKeLxwua79GGIvW6xr8NBAcrtiUbYrTjEFTA==} - dev: false + js-sha3@0.5.5: {} - /js-sha3@0.5.7: - resolution: {integrity: sha512-GII20kjaPX0zJ8wzkTbNDYMY7msuZcTWk8S5UOh6806Jq/wz1J8/bnr8uGU0DAUmYDjj2Mr4X1cW8v/GLYnR+g==} + js-sha3@0.5.7: {} - /js-sha3@0.8.0: - resolution: {integrity: sha512-gF1cRrHhIzNfToc802P800N8PpXS+evLLXfsVpowqmAFR9uwbi89WvXg2QspOmXL8QL86J4T1EpFu+yUkwJY3Q==} + js-sha3@0.8.0: {} - /js-tokens@4.0.0: - resolution: {integrity: sha512-RdJUflcE3cUzKiMqQgsCu06FPu9UdIJO0beYbPhHN4k6apgJtifcoCtT9bcxOpYBtpD2kCM6Sbzg4CausW/PKQ==} + js-tokens@4.0.0: {} - /js-yaml@3.14.1: - resolution: {integrity: sha512-okMH7OXXJ7YrN9Ok3/SXrnu4iX9yOk+25nqX4imS2npuvTYDmo/QEZoqwZkYaIDk3jVvBOTOIEgEhaLOynBS9g==} - hasBin: true + js-yaml@3.14.1: dependencies: argparse: 1.0.10 esprima: 4.0.1 - dev: true - /js-yaml@4.1.0: - resolution: {integrity: sha512-wpxZs9NoxZaJESJGIZTyDEaYpl0FKSA+FB9aJiyemKhMwkxQg63h4T1KJgUGHpTqPDNRcmmYLugrRjJlBtWvRA==} - hasBin: true + js-yaml@4.1.0: dependencies: argparse: 2.0.1 - /jsbn@0.1.1: - resolution: {integrity: sha512-UVU9dibq2JcFWxQPA6KCqj5O42VOmAY3zQUfEKxU0KpTGXwNoCjkX1e13eHNvw/xPynt6pU0rZ1htjWTNTSXsg==} + jsbn@0.1.1: {} - /jsesc@2.5.2: - resolution: {integrity: sha512-OYu7XEzjkCQ3C5Ps3QIZsQfNpqoJyZZA99wd9aWd05NCtC5pWOkShK2mkL6HXQR6/Cy2lbNdPlZBpuQHXE63gA==} - engines: {node: '>=4'} - hasBin: true - dev: true + jsesc@2.5.2: {} - /json-buffer@3.0.1: - resolution: {integrity: sha512-4bV5BfR2mqfQTJm+V5tPPdf+ZpuhiIvTuAB5g8kcrXOZpTT/QwwVRWBywX1ozr6lEuPdbHxwaJlm9G6mI2sfSQ==} + json-buffer@3.0.1: {} - /json-parse-even-better-errors@2.3.1: - resolution: {integrity: sha512-xyFwyhro/JEof6Ghe2iz2NcXoj2sloNsWr/XsERDK/oiPCfaNhl5ONfp+jQdAZRQQ0IJWNzH9zIZF7li91kh2w==} + json-parse-even-better-errors@2.3.1: {} - /json-schema-traverse@0.3.1: - resolution: {integrity: sha512-4JD/Ivzg7PoW8NzdrBSr3UFwC9mHgvI7Z6z3QGBsSHgKaRTUDmyZAAKJo2UbG1kUVfS9WS8bi36N49U1xw43DA==} - dev: false + json-schema-traverse@0.3.1: {} - /json-schema-traverse@0.4.1: - resolution: {integrity: sha512-xbbCH5dCYU5T8LcEhhuh7HJ88HXuW3qsI3Y0zOZFKfZEHcpWiHU/Jxzk629Brsab/mMiHQti9wMP+845RPe3Vg==} + json-schema-traverse@0.4.1: {} - /json-schema-traverse@1.0.0: - resolution: {integrity: sha512-NM8/P9n3XjXhIZn1lLhkFaACTOURQXjWhV4BA/RnOv8xvgqtqpAX9IO4mRQxSx1Rlo4tqzeqb0sOlruaOy3dug==} + json-schema-traverse@1.0.0: {} - /json-schema@0.4.0: - resolution: {integrity: sha512-es94M3nTIfsEPisRafak+HDLfHXnKBhV3vU5eqPcS3flIWqcxJWgXHXiey3YrpaNsanY5ei1VoYEbOzijuq9BA==} + json-schema@0.4.0: {} - /json-stable-stringify-without-jsonify@1.0.1: - resolution: {integrity: sha512-Bdboy+l7tA3OGW6FjyFHWkP5LuByj1Tk33Ljyq0axyzdk9//JSi2u3fP1QSmd1KNwq6VOKYGlAu87CisVir6Pw==} + json-stable-stringify-without-jsonify@1.0.1: {} - /json-stringify-safe@5.0.1: - resolution: {integrity: sha512-ZClg6AaYvamvYEE82d3Iyd3vSSIjQ+odgjaTzRuO3s7toCdFKczob2i0zCh7JE8kWn17yvAWhUVxvqGwUalsRA==} + json-stringify-safe@5.0.1: {} - /json5@1.0.2: - resolution: {integrity: sha512-g1MWMLBiz8FKi1e4w0UyVL3w+iJceWAFBAaBnnGKOpNa5f8TLktkbre1+s6oICydWAm+HRUGTmI+//xv2hvXYA==} - hasBin: true + json5@1.0.2: dependencies: minimist: 1.2.8 - dev: true - /json5@2.2.3: - resolution: {integrity: sha512-XmOWe7eyHYH14cLdVPoyg+GOH3rYX++KpzrylJwSW98t3Nk+U8XOl8FWKOgwtzdb8lXGf6zYwDUzeHMWfxasyg==} - engines: {node: '>=6'} - hasBin: true - dev: true + json5@2.2.3: {} - /jsonfile@2.4.0: - resolution: {integrity: sha512-PKllAqbgLgxHaj8TElYymKCAgrASebJrWpTnEkOaTowt23VKXXN0sUeriJ+eh7y6ufb/CC5ap11pz71/cM0hUw==} + jsonfile@2.4.0: optionalDependencies: graceful-fs: 4.2.11 - dev: false - /jsonfile@4.0.0: - resolution: {integrity: sha512-m6F1R3z8jjlf2imQHS2Qez5sjKWQzbuuhuJ/FKYFRZvPE3PuHcSMVZzfsLhGVOkfd20obL5SWEBew5ShlquNxg==} + jsonfile@4.0.0: optionalDependencies: graceful-fs: 4.2.11 - /jsonfile@6.1.0: - resolution: {integrity: sha512-5dgndWOriYSm5cnYaJNhalLNDKOqFwyDB/rr1E9ZsGciGvKPs8R2xYGCacuf3z6K1YKDz182fd+fY3cn3pMqXQ==} + jsonfile@6.1.0: dependencies: universalify: 2.0.1 optionalDependencies: graceful-fs: 4.2.11 - dev: true - /jsonschema@1.4.1: - resolution: {integrity: sha512-S6cATIPVv1z0IlxdN+zUk5EPjkGCdnhN4wVSBlvoUO1tOLJootbo9CquNJmbIh4yikWHiUedhRYrNPn1arpEmQ==} - dev: true + jsonschema@1.4.1: {} - /jsprim@1.4.2: - resolution: {integrity: sha512-P2bSOMAc/ciLz6DzgjVlGJP9+BrJWu5UDGK70C2iweC5QBIeFf0ZXRvGjEj2uYgrY2MkAAhsSWHDWlFtEroZWw==} - engines: {node: '>=0.6.0'} + jsprim@1.4.2: dependencies: assert-plus: 1.0.0 extsprintf: 1.3.0 json-schema: 0.4.0 verror: 1.10.0 - /just-extend@4.2.1: - resolution: {integrity: sha512-g3UB796vUFIY90VIv/WX3L2c8CS2MdWUww3CNrYmqza1Fg0DURc2K/O4YrnklBdQarSJ/y8JnJYDGc+1iumQjg==} - dev: true + just-extend@4.2.1: {} - /keccak@3.0.4: - resolution: {integrity: sha512-3vKuW0jV8J3XNTzvfyicFR5qvxrSAGl7KIhvgOu5cmWwM7tZRj3fMbj/pfIf4be7aznbc+prBWGjywox/g2Y6Q==} - engines: {node: '>=10.0.0'} - requiresBuild: true + keccak@3.0.4: dependencies: node-addon-api: 2.0.2 node-gyp-build: 4.8.1 readable-stream: 3.6.2 - /keyv@4.5.4: - resolution: {integrity: sha512-oxVHkHR/EJf2CNXnWxRLW6mg7JyCCUcG0DtEGmL2ctUo1PNTin1PUil+r/+4r5MpVgC/fn1kjsx7mjSujKqIpw==} + keyv@4.5.4: dependencies: json-buffer: 3.0.1 - /kind-of@6.0.3: - resolution: {integrity: sha512-dcS1ul+9tmeD95T+x28/ehLgd9mENa3LsvDTtzm3vyBEO7RPptvAD+t44WVXaUjTBRcrpFeFlC8WCruUR456hw==} - engines: {node: '>=0.10.0'} - dev: true + kind-of@6.0.3: {} - /klaw@1.3.1: - resolution: {integrity: sha512-TED5xi9gGQjGpNnvRWknrwAB1eL5GciPfVFOt3Vk1OJCVDQbzuSfrF3hkUQKlsgKrG1F+0t5W0m+Fje1jIt8rw==} + klaw@1.3.1: optionalDependencies: graceful-fs: 4.2.11 - dev: false - /kleur@3.0.3: - resolution: {integrity: sha512-eTIzlVOSUR+JxdDFepEYcBMtZ9Qqdef+rnzWdRZuMbOywu5tO2w2N7rqjoANZ5k9vywhL6Br1VRjUIgTQx4E8w==} - engines: {node: '>=6'} - dev: true + kleur@3.0.3: {} - /kleur@4.1.5: - resolution: {integrity: sha512-o+NO+8WrRiQEE4/7nwRJhN1HWpVmJm511pBHUxPLtp0BUISzlBplORYSmTclCnJvQq2tKu/sgl3xVpkc7ZWuQQ==} - engines: {node: '>=6'} - dev: true + kleur@4.1.5: {} - /lcid@1.0.0: - resolution: {integrity: sha512-YiGkH6EnGrDGqLMITnGjXtGmNtjoXw9SVUzcaos8RBi7Ps0VBylkq+vOcY9QE5poLasPCR849ucFUkl0UzUyOw==} - engines: {node: '>=0.10.0'} + lcid@1.0.0: dependencies: invert-kv: 1.0.0 - dev: false - /levn@0.3.0: - resolution: {integrity: sha512-0OO4y2iOHix2W6ujICbKIaEQXvFQHue65vUG3pb5EUomzPI90z9hsA1VsO/dbIIpC53J8gxM9Q4Oho0jrCM/yA==} - engines: {node: '>= 0.8.0'} + levn@0.3.0: dependencies: prelude-ls: 1.1.2 type-check: 0.3.2 - dev: true - /levn@0.4.1: - resolution: {integrity: sha512-+bT2uH4E5LGE7h/n3evcS/sQlJXCpIp6ym8OWJ5eV6+67Dsql/LaaT7qJBAt2rzfoa/5QBGBhxDix1dMt2kQKQ==} - engines: {node: '>= 0.8.0'} + levn@0.4.1: dependencies: prelude-ls: 1.2.1 type-check: 0.4.0 - /lines-and-columns@1.2.4: - resolution: {integrity: sha512-7ylylesZQ/PV29jhEDl3Ufjo6ZX7gCqJr5F7PKrqc93v7fzSymt1BpwEU8nAUXs8qzzvqhbjhK5QZg6Mt/HkBg==} + lines-and-columns@1.2.4: {} - /load-json-file@1.1.0: - resolution: {integrity: sha512-cy7ZdNRXdablkXYNI049pthVeXFurRyb9+hA/dZzerZ0pGTx42z+y+ssxBaVV2l70t1muq5IdKhn4UtcoGUY9A==} - engines: {node: '>=0.10.0'} + load-json-file@1.1.0: dependencies: graceful-fs: 4.2.11 parse-json: 2.2.0 pify: 2.3.0 pinkie-promise: 2.0.1 strip-bom: 2.0.0 - dev: false - /load-yaml-file@0.2.0: - resolution: {integrity: sha512-OfCBkGEw4nN6JLtgRidPX6QxjBQGQf72q3si2uvqyFEMbycSFFHwAZeXx6cJgFM9wmLrf9zBwCP3Ivqa+LLZPw==} - engines: {node: '>=6'} + load-yaml-file@0.2.0: dependencies: graceful-fs: 4.2.11 js-yaml: 3.14.1 pify: 4.0.1 strip-bom: 3.0.0 - dev: true - /locate-path@2.0.0: - resolution: {integrity: sha512-NCI2kiDkyR7VeEKm27Kda/iQHyKJe1Bu0FlTbYp3CqJu+9IFe9bLyAjMxf5ZDDbEg+iMPzB5zYyUTSm8wVTKmA==} - engines: {node: '>=4'} + locate-path@2.0.0: dependencies: p-locate: 2.0.0 path-exists: 3.0.0 - dev: false - /locate-path@5.0.0: - resolution: {integrity: sha512-t7hw9pI+WvuwNJXwk5zVHpyhIqzg2qTlklJOf0mVxGSbe3Fp2VieZcduNYjaLDoy6p9uGpQEGWG87WpMKlNq8g==} - engines: {node: '>=8'} + locate-path@5.0.0: dependencies: p-locate: 4.1.0 - dev: true - /locate-path@6.0.0: - resolution: {integrity: sha512-iPZK6eYjbxRu3uB4/WZ3EsEIMJFMqAoopl3R+zuq0UjcAm/MO6KCweDgPfP3elTztoKP3KtnVHxTn2NHBSDVUw==} - engines: {node: '>=10'} + locate-path@6.0.0: dependencies: p-locate: 5.0.0 - /lodash.assign@4.2.0: - resolution: {integrity: sha512-hFuH8TY+Yji7Eja3mGiuAxBqLagejScbG8GbG0j6o9vzn0YL14My+ktnqtZgFTosKymC9/44wP6s7xyuLfnClw==} - dev: false + lodash.assign@4.2.0: {} - /lodash.camelcase@4.3.0: - resolution: {integrity: sha512-TwuEnCnxbc3rAvhf/LbG7tJUDzhqXyFnv3dtzLOPgCG/hODL7WFnsbwktkD7yUV0RrreP/l1PALq/YSg6VvjlA==} - dev: true + lodash.camelcase@4.3.0: {} - /lodash.clonedeep@4.5.0: - resolution: {integrity: sha512-H5ZhCF25riFd9uB5UCkVKo61m3S/xZk1x4wA6yp/L3RFP6Z/eHH1ymQcGLo7J3GMPfm0V/7m1tryHuGVxpqEBQ==} - dev: false + lodash.clonedeep@4.5.0: {} - /lodash.deburr@4.1.0: - resolution: {integrity: sha512-m/M1U1f3ddMCs6Hq2tAsYThTBDaAKFDX3dwDo97GEYzamXi9SqUpjWi/Rrj/gf3X2n8ktwgZrlP1z6E3v/IExQ==} - dev: true + lodash.deburr@4.1.0: {} - /lodash.flattendeep@4.4.0: - resolution: {integrity: sha512-uHaJFihxmJcEX3kT4I23ABqKKalJ/zDrDg0lsFtc1h+3uw49SIJ5beyhx5ExVRti3AvKoOJngIj7xz3oylPdWQ==} - dev: true + lodash.flattendeep@4.4.0: {} - /lodash.get@4.4.2: - resolution: {integrity: sha512-z+Uw/vLuy6gQe8cfaFWD7p0wVv8fJl3mbzXh33RS+0oW2wvUqiRXiQ69gLWSLpgB5/6sU+r6BlQR0MBILadqTQ==} - dev: true + lodash.get@4.4.2: {} - /lodash.isequal@4.5.0: - resolution: {integrity: sha512-pDo3lu8Jhfjqls6GkMgpahsF9kCyayhgykjyLMNFTKWrpVdAQtYyB4muAMWozBB4ig/dtWAmsMxLEI8wuz+DYQ==} - dev: false + lodash.isequal@4.5.0: {} - /lodash.memoize@4.1.2: - resolution: {integrity: sha512-t7j+NzmgnQzTAYXcsHYLgimltOV1MXHtlOWf6GjL9Kj8GK5FInw5JotxvbOs+IvV1/Dzo04/fCGfLVs7aXb4Ag==} - dev: false + lodash.memoize@4.1.2: {} - /lodash.merge@4.6.2: - resolution: {integrity: sha512-0KpjqXRVvrYyCsX1swR/XTK0va6VQkQM6MNo7PqW77ByjAhoARA8EfrP1N4+KlKj8YS0ZUCtRT/YUuhyYDujIQ==} + lodash.merge@4.6.2: {} - /lodash.snakecase@4.1.1: - resolution: {integrity: sha512-QZ1d4xoBHYUeuouhEq3lk3Uq7ldgyFXGBhg04+oRLnIz8o9T65Eh+8YdroUwn846zchkA9yDsDl5CVVaV2nqYw==} - dev: true + lodash.snakecase@4.1.1: {} - /lodash.startcase@4.4.0: - resolution: {integrity: sha512-+WKqsK294HMSc2jEbNgpHpd0JfIBhp7rEV4aqXWqFr6AlXov+SlcgB1Fv01y2kGe3Gc8nMW7VA0SrGuSkRfIEg==} - dev: true + lodash.startcase@4.4.0: {} - /lodash.trim@4.5.1: - resolution: {integrity: sha512-nJAlRl/K+eiOehWKDzoBVrSMhK0K3A3YQsUNXHQa5yIrKBAhsZgSu3KoAFoFT+mEgiyBHddZ0pRk1ITpIp90Wg==} - dev: true + lodash.trim@4.5.1: {} - /lodash.truncate@4.4.2: - resolution: {integrity: sha512-jttmRe7bRse52OsWIMDLaXxWqRAmtIUccAQ3garviCqJjafXOfNMO0yMfNpdD6zbGaTU0P5Nz7e7gAT6cKmJRw==} - dev: false + lodash.truncate@4.4.2: {} - /lodash@4.17.21: - resolution: {integrity: sha512-v2kDEe57lecTulaDIuNTPy3Ry4gLGJ6Z1O3vE1krgXZNrsQ+LFTGHVxVjcXPs17LhbZVGedAJv8XZ1tvj5FvSg==} + lodash@4.17.21: {} - /log-symbols@4.1.0: - resolution: {integrity: sha512-8XPvpAA8uyhfteu8pIvQxpJZ7SYYdpUivZpGy6sFsBuKRY/7rQGavedeB8aK+Zkyq6upMFVL/9AW6vOYzfRyLg==} - engines: {node: '>=10'} + log-symbols@4.1.0: dependencies: chalk: 4.1.2 is-unicode-supported: 0.1.0 - /loose-envify@1.4.0: - resolution: {integrity: sha512-lyuxPGr/Wfhrlem2CL/UcnUc1zcqKAImBDzukY7Y5F/yQiNdko6+fRLevlw1HgMySw7f611UIY408EtxRSoK3Q==} - hasBin: true + loose-envify@1.4.0: dependencies: js-tokens: 4.0.0 - dev: false - /loupe@2.3.7: - resolution: {integrity: sha512-zSMINGVYkdpYSOBmLi0D1Uo7JU9nVdQKrHxC8eYlV+9YKK9WePqAlL7lSlorG/U2Fw1w0hTBmaa/jrQ3UbPHtA==} + loupe@2.3.7: dependencies: get-func-name: 2.0.2 - /lower-case-first@1.0.2: - resolution: {integrity: sha512-UuxaYakO7XeONbKrZf5FEgkantPf5DUqDayzP5VXZrtRPdH86s4kN47I8B3TW10S4QKiE3ziHNf3kRN//okHjA==} + lower-case-first@1.0.2: dependencies: lower-case: 1.1.4 - dev: false - /lower-case@1.1.4: - resolution: {integrity: sha512-2Fgx1Ycm599x+WGpIYwJOvsjmXFzTSc34IwDWALRA/8AopUKAVPwfJ+h5+f85BCp0PWmmJcWzEpxOpoXycMpdA==} - dev: false + lower-case@1.1.4: {} - /lower-case@2.0.2: - resolution: {integrity: sha512-7fm3l3NAF9WfN6W3JOmf5drwpVqX78JtoGJ3A6W0a6ZnldM41w2fV5D490psKFTpMds8TJse/eHLFFsNHHjHgg==} + lower-case@2.0.2: dependencies: tslib: 2.6.2 - dev: true - /lowercase-keys@2.0.0: - resolution: {integrity: sha512-tqNXrS78oMOE73NMxK4EMLQsQowWf8jKooH9g7xPavRT706R6bkQJ6DY2Te7QukaZsulxa30wQ7bk0pm4XiHmA==} - engines: {node: '>=8'} + lowercase-keys@2.0.0: {} - /lowercase-keys@3.0.0: - resolution: {integrity: sha512-ozCC6gdQ+glXOQsveKD0YsDy8DSQFjDTz4zyzEHNV5+JP5D62LmfDZ6o1cycFx9ouG940M5dE8C8CTewdj2YWQ==} - engines: {node: ^12.20.0 || ^14.13.1 || >=16.0.0} + lowercase-keys@3.0.0: {} - /lru-cache@10.2.2: - resolution: {integrity: sha512-9hp3Vp2/hFQUiIwKo8XCeFVnrg8Pk3TYNPIR7tJADKi5YfcF7vEaK7avFHTlSy3kOKYaJQaalfEo6YuXdceBOQ==} - engines: {node: 14 || >=16.14} - dev: true + lru-cache@10.2.2: {} - /lru-cache@4.1.5: - resolution: {integrity: sha512-sWZlbEP2OsHNkXrMl5GYk/jKk70MBng6UU4YI/qGDYbgf6YbP4EvmqISbXCoJiRKs+1bSpFHVgQxvJ17F2li5g==} + lru-cache@4.1.5: dependencies: pseudomap: 1.0.2 yallist: 2.1.2 - dev: true - /lru-cache@5.1.1: - resolution: {integrity: sha512-KpNARQA3Iwv+jTA0utUVVbrh+Jlrr1Fv0e56GGzAFOXN7dk/FviaDW8LHmK52DlcH4WP2n6gI8vN1aesBFgo9w==} + lru-cache@5.1.1: dependencies: yallist: 3.1.1 - dev: true - /lru_map@0.3.3: - resolution: {integrity: sha512-Pn9cox5CsMYngeDbmChANltQl+5pi6XmTrraMSzhPmMBbmgcxmqWry0U3PGapCU1yB4/LqCcom7qhHZiF/jGfQ==} - dev: false + lru_map@0.3.3: {} - /make-dir@3.1.0: - resolution: {integrity: sha512-g3FeP20LNwhALb/6Cz6Dd4F2ngze0jz7tbzrD2wAV+o9FeNHe4rL+yK2md0J/fiSf1sa1ADhXqi5+oVwOM/eGw==} - engines: {node: '>=8'} + make-dir@3.1.0: dependencies: semver: 6.3.1 - dev: true - /make-dir@4.0.0: - resolution: {integrity: sha512-hXdUTZYIVOt1Ex//jAQi+wTZZpUpwBj/0QsOzqegb3rGMMeJiSEu5xLHnYfBrRV4RH2+OCSOO95Is/7x1WJ4bw==} - engines: {node: '>=10'} + make-dir@4.0.0: dependencies: semver: 7.6.2 - dev: true - /make-error@1.3.6: - resolution: {integrity: sha512-s8UhlNe7vPKomQhC1qFelMokr/Sc3AgNbso3n74mVPA5LTZwkB9NlXf4XPamLxJE8h0gh73rM94xvwRT2CVInw==} - dev: true + make-error@1.3.6: {} - /map-obj@1.0.1: - resolution: {integrity: sha512-7N/q3lyZ+LVCp7PzuxrJr4KMbBE2hW7BT7YNia330OFxIf4d3r5zVpicP2650l7CPN6RM9zOJRl3NGpqSiw3Eg==} - engines: {node: '>=0.10.0'} - dev: true + map-obj@1.0.1: {} - /map-obj@4.3.0: - resolution: {integrity: sha512-hdN1wVrZbb29eBGiGjJbeP8JbKjq1urkHJ/LIP/NY48MZ1QVXUsQBV1G1zvYFHn1XE06cwjBsOI2K3Ulnj1YXQ==} - engines: {node: '>=8'} - dev: true + map-obj@4.3.0: {} - /markdown-table@1.1.3: - resolution: {integrity: sha512-1RUZVgQlpJSPWYbFSpmudq5nHY1doEIv89gBtF0s4gW1GF2XorxcA/70M5vq7rLv0a6mhOUccRsqkwhwLCIQ2Q==} - dev: true + markdown-table@1.1.3: {} - /markdown-table@3.0.3: - resolution: {integrity: sha512-Z1NL3Tb1M9wH4XESsCDEksWoKTdlUafKc4pt0GRwjUyXaCFZ+dc3g2erqB6zm3szA2IUSi7VnPI+o/9jnxh9hw==} - dev: true + markdown-table@3.0.3: {} - /md5.js@1.3.5: - resolution: {integrity: sha512-xitP+WxNPcTTOgnTJcrhM0xvdPepipPSf3I8EIpGKeFLjt3PlJLIDG3u8EX53ZIubkb+5U2+3rELYpEhHhzdkg==} + md5.js@1.3.5: dependencies: hash-base: 3.1.0 inherits: 2.0.4 safe-buffer: 5.2.1 - /media-typer@0.3.0: - resolution: {integrity: sha512-dq+qelQ9akHpcOl/gUVRTxVIOkAJ1wR3QAvb4RsVjS8oVoFjDGTc679wJYmUmknUF5HwMLOgb5O+a3KxfWapPQ==} - engines: {node: '>= 0.6'} + media-typer@0.3.0: {} - /memorystream@0.3.1: - resolution: {integrity: sha512-S3UwM3yj5mtUSEfP41UZmt/0SCoVYUcU1rkXv+BQ5Ig8ndL4sPoJNBUJERafdPb5jjHJGuMgytgKvKIf58XNBw==} - engines: {node: '>= 0.10.0'} - dev: false + memorystream@0.3.1: {} - /meow@6.1.1: - resolution: {integrity: sha512-3YffViIt2QWgTy6Pale5QpopX/IvU3LPL03jOTqp6pGj3VjesdO/U8CuHMKpnQr4shCNCM5fd5XFFvIIl6JBHg==} - engines: {node: '>=8'} + meow@6.1.1: dependencies: '@types/minimist': 1.2.5 camelcase-keys: 6.2.2 @@ -8179,149 +11608,90 @@ packages: trim-newlines: 3.0.1 type-fest: 0.13.1 yargs-parser: 18.1.3 - dev: true - /merge-descriptors@1.0.1: - resolution: {integrity: sha512-cCi6g3/Zr1iqQi6ySbseM1Xvooa98N0w31jzUYrXPX2xqObmFGHJ0tQ5u74H3mVh7wLouTseZyYIq39g8cNp1w==} + merge-descriptors@1.0.1: {} - /merge2@1.4.1: - resolution: {integrity: sha512-8q7VEgMJW4J8tcfVPy8g09NcQwZdbwFEqhe/WZkoIzjn/3TGDwtOCYtXGxA3O8tPzpczCCDgv+P2P5y00ZJOOg==} - engines: {node: '>= 8'} + merge2@1.4.1: {} - /methods@1.1.2: - resolution: {integrity: sha512-iclAHeNqNm68zFtnZ0e+1L2yUIdvzNoauKU4WBA3VvH/vPFieF7qfRlwUZU+DA9P9bPXIS90ulxoUoCH23sV2w==} - engines: {node: '>= 0.6'} + methods@1.1.2: {} - /micro-ftch@0.3.1: - resolution: {integrity: sha512-/0LLxhzP0tfiR5hcQebtudP56gUurs2CLkGarnCiB/OqEyUFQ6U3paQi/tgLv0hBJYt2rnr9MNpxz4fiiugstg==} + micro-ftch@0.3.1: {} - /micromatch@4.0.5: - resolution: {integrity: sha512-DMy+ERcEW2q8Z2Po+WNXuw3c5YaUSFjAO5GsJqfEl7UjvtIuFKO6ZrKvcItdy98dwFI2N1tg3zNIdKaQT+aNdA==} - engines: {node: '>=8.6'} + micromatch@4.0.5: dependencies: braces: 3.0.2 picomatch: 2.3.1 - /mime-db@1.52.0: - resolution: {integrity: sha512-sPU4uV7dYlvtWJxwwxHD0PuihVNiE7TyAbQ5SWxDCB9mUYvOgroQOwYQQOKPJ8CIbE+1ETVlOoK1UC2nU3gYvg==} - engines: {node: '>= 0.6'} + mime-db@1.52.0: {} - /mime-types@2.1.35: - resolution: {integrity: sha512-ZDY+bPm5zTTF+YpCrAU9nK0UgICYPT0QtT1NZWFv4s++TNkcgVaT0g6+4R2uI4MjQjzysHB1zxuWL50hzaeXiw==} - engines: {node: '>= 0.6'} + mime-types@2.1.35: dependencies: mime-db: 1.52.0 - /mime@1.6.0: - resolution: {integrity: sha512-x0Vn8spI+wuJ1O6S7gnbaQg8Pxh4NNHb7KSINmEWKiPE4RKOplvijn+NkmYmmRgP68mc70j2EbeTFRsrswaQeg==} - engines: {node: '>=4'} - hasBin: true + mime@1.6.0: {} - /mimic-fn@2.1.0: - resolution: {integrity: sha512-OqbOk5oEQeAZ8WXWydlu9HJjz9WVdEIvamMCcXmuqUYjTknH/sqsWvhQ3vgwKFRR1HpjvNBKQ37nbJgYzGqGcg==} - engines: {node: '>=6'} - dev: false + mimic-fn@2.1.0: {} - /mimic-response@1.0.1: - resolution: {integrity: sha512-j5EctnkH7amfV/q5Hgmoal1g2QHFJRraOtmx0JpIqkxhBhI/lJSl1nMpQ45hVarwNETOoWEimndZ4QK0RHxuxQ==} - engines: {node: '>=4'} + mimic-response@1.0.1: {} - /mimic-response@3.1.0: - resolution: {integrity: sha512-z0yWI+4FDrrweS8Zmt4Ej5HdJmky15+L2e6Wgn3+iK5fWzb6T3fhNFq2+MeTRb064c6Wr4N/wv0DzQTjNzHNGQ==} - engines: {node: '>=10'} + mimic-response@3.1.0: {} - /min-document@2.19.0: - resolution: {integrity: sha512-9Wy1B3m3f66bPPmU5hdA4DR4PB2OfDU/+GS3yAB7IQozE3tqXaVv2zOjgla7MEGSRv95+ILmOuvhLkOK6wJtCQ==} + min-document@2.19.0: dependencies: dom-walk: 0.1.2 - /min-indent@1.0.1: - resolution: {integrity: sha512-I9jwMn07Sy/IwOj3zVkVik2JTvgpaykDZEigL6Rx6N9LbMywwUSMtxET+7lVoDLLd3O3IXwJwvuuns8UB/HeAg==} - engines: {node: '>=4'} - dev: true + min-indent@1.0.1: {} - /minimalistic-assert@1.0.1: - resolution: {integrity: sha512-UtJcAD4yEaGtjPezWuO9wC4nwUnVH/8/Im3yEHQP4b67cXlD/Qr9hdITCU1xDbSEXg2XKNaP8jsReV7vQd00/A==} + minimalistic-assert@1.0.1: {} - /minimalistic-crypto-utils@1.0.1: - resolution: {integrity: sha512-JIYlbt6g8i5jKfJ3xz7rF0LXmv2TkDxBLUkiBeZ7bAx4GnnNMr8xFpGnOxn6GhTEHx3SjRrZEoU+j04prX1ktg==} + minimalistic-crypto-utils@1.0.1: {} - /minimatch@3.1.2: - resolution: {integrity: sha512-J7p63hRiAjw1NDEww1W7i37+ByIrOWO5XQQAzZ3VOcL0PNybwpfmV/N05zFAzwQ9USyEcX6t3UO+K5aqBQOIHw==} + minimatch@3.1.2: dependencies: brace-expansion: 1.1.11 - /minimatch@5.0.1: - resolution: {integrity: sha512-nLDxIFRyhDblz3qMuq+SoRZED4+miJ/G+tdDrjkkkRnjAsBexeGpgjLEQ0blJy7rHhR2b93rhQY4SvyWu9v03g==} - engines: {node: '>=10'} + minimatch@5.0.1: dependencies: brace-expansion: 2.0.1 - /minimist-options@4.1.0: - resolution: {integrity: sha512-Q4r8ghd80yhO/0j1O3B2BjweX3fiHg9cdOwjJd2J76Q135c+NDxGCqdYKQ1SKBuFfgWbAUzBfvYjPUEeNgqN1A==} - engines: {node: '>= 6'} + minimist-options@4.1.0: dependencies: arrify: 1.0.1 is-plain-obj: 1.1.0 kind-of: 6.0.3 - dev: true - /minimist@1.2.8: - resolution: {integrity: sha512-2yyAR8qBkN3YuheJanUpWC5U3bb5osDywNB8RzDVlDwDHbocAJveqqj1u8+SVD7jkWT4yvsHCpWqqWqAxb0zCA==} + minimist@1.2.8: {} - /minipass@2.9.0: - resolution: {integrity: sha512-wxfUjg9WebH+CUDX/CdbRlh5SmfZiy/hpkxaRI16Y9W56Pa75sWgd/rvFilSgrauD9NyFymP/+JFV3KwzIsJeg==} + minipass@2.9.0: dependencies: safe-buffer: 5.2.1 yallist: 3.1.1 - /minizlib@1.3.3: - resolution: {integrity: sha512-6ZYMOEnmVsdCeTJVE0W9ZD+pVnE8h9Hma/iOwwRDsdQoePpoX56/8B6z3P9VNwppJuBKNRuFDRNRqRWexT9G9Q==} + minizlib@1.3.3: dependencies: minipass: 2.9.0 - /mixme@0.5.10: - resolution: {integrity: sha512-5H76ANWinB1H3twpJ6JY8uvAtpmFvHNArpilJAjXRKXSDDLPIMoZArw5SH0q9z+lLs8IrMw7Q2VWpWimFKFT1Q==} - engines: {node: '>= 8.0.0'} - dev: true + mixme@0.5.10: {} - /mkdirp-classic@0.5.3: - resolution: {integrity: sha512-gKLcREMhtuZRwRAfqP3RFW+TK4JqApVBtOIftVgjuABpAtpxhPGaDcfvbhNvD0B8iD1oUr/txX35NjcaY6Ns/A==} - dev: false + mkdirp-classic@0.5.3: {} - /mkdirp-promise@5.0.1: - resolution: {integrity: sha512-Hepn5kb1lJPtVW84RFT40YG1OddBNTOVUZR2bzQUHc+Z03en8/3uX0+060JDhcEzyO08HmipsN9DcnFMxhIL9w==} - engines: {node: '>=4'} - deprecated: This package is broken and no longer maintained. 'mkdirp' itself supports promises now, please switch to that. + mkdirp-promise@5.0.1: dependencies: mkdirp: 3.0.1 - /mkdirp@0.5.6: - resolution: {integrity: sha512-FP+p8RB8OWpF3YZBCrP5gtADmtXApB5AMLn+vdyA+PyxCjrCs00mjyUozssO33cwDeT3wNGdLxJ5M//YqtHAJw==} - hasBin: true + mkdirp@0.5.6: dependencies: minimist: 1.2.8 - /mkdirp@1.0.4: - resolution: {integrity: sha512-vVqVZQyf3WLx2Shd0qJ9xuvqgAyKPLAiqITEtqW0oIUjzo3PePDd6fW9iFz30ef7Ysp/oiWqbhszeGWW2T6Gzw==} - engines: {node: '>=10'} - hasBin: true + mkdirp@1.0.4: {} - /mkdirp@3.0.1: - resolution: {integrity: sha512-+NsyUUAZDmo6YVHzL/stxSu3t9YS1iljliy3BSDrXJ/dkn1KYdmtZODGGjLcc9XLgVVpH4KshHB8XmZgMhaBXg==} - engines: {node: '>=10'} - hasBin: true + mkdirp@3.0.1: {} - /mnemonist@0.38.5: - resolution: {integrity: sha512-bZTFT5rrPKtPJxj8KSV0WkPyNxl72vQepqqVUAW2ARUpUSF2qXMB6jZj7hW5/k7C1rtpzqbD/IIbJwLXUjCHeg==} + mnemonist@0.38.5: dependencies: obliterator: 2.0.4 - dev: false - /mocha@10.4.0: - resolution: {integrity: sha512-eqhGB8JKapEYcC4ytX/xrzKforgEc3j1pGlAXVy3eRwrtAy5/nIfT1SvgGzfN0XZZxeLq0aQWkOUAmqIJiv+bA==} - engines: {node: '>= 14.0.0'} - hasBin: true + mocha@10.4.0: dependencies: ansi-colors: 4.1.1 browser-stdout: 1.3.1 @@ -8344,239 +11714,149 @@ packages: yargs-parser: 20.2.4 yargs-unparser: 2.0.0 - /mock-fs@4.14.0: - resolution: {integrity: sha512-qYvlv/exQ4+svI3UOvPUpLDF0OMX5euvUH0Ny4N5QyRyhNdgAgUrVH3iUINSzEPLvx0kbo/Bp28GJKIqvE7URw==} + mock-fs@4.14.0: {} - /ms@2.0.0: - resolution: {integrity: sha512-Tpp60P6IUJDTuOq/5Z8cdskzJujfwqfOTkrwIwj7IRISpnkJnT6SyJ4PCPnGMoFjC9ddhal5KVIYtAt97ix05A==} + ms@2.0.0: {} - /ms@2.1.2: - resolution: {integrity: sha512-sGkPx+VjMtmA6MX27oA4FBFELFCZZ4S4XqeGOXCv68tT+jb3vk/RyaKWP0PTKyWtmLSM0b+adUTEvbs1PEaH2w==} + ms@2.1.2: {} - /ms@2.1.3: - resolution: {integrity: sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==} + ms@2.1.3: {} - /multibase@0.6.1: - resolution: {integrity: sha512-pFfAwyTjbbQgNc3G7D48JkJxWtoJoBMaR4xQUOuB8RnCgRqaYmWNFeJTTvrJ2w51bjLq2zTby6Rqj9TQ9elSUw==} - deprecated: This module has been superseded by the multiformats module + multibase@0.6.1: dependencies: base-x: 3.0.9 buffer: 5.7.1 - /multibase@0.7.0: - resolution: {integrity: sha512-TW8q03O0f6PNFTQDvh3xxH03c8CjGaaYrjkl9UQPG6rz53TQzzxJVCIWVjzcbN/Q5Y53Zd0IBQBMVktVgNx4Fg==} - deprecated: This module has been superseded by the multiformats module + multibase@0.7.0: dependencies: base-x: 3.0.9 buffer: 5.7.1 - /multicodec@0.5.7: - resolution: {integrity: sha512-PscoRxm3f+88fAtELwUnZxGDkduE2HD9Q6GHUOywQLjOGT/HAdhjLDYNZ1e7VR0s0TP0EwZ16LNUTFpoBGivOA==} - deprecated: This module has been superseded by the multiformats module + multicodec@0.5.7: dependencies: varint: 5.0.2 - /multicodec@1.0.4: - resolution: {integrity: sha512-NDd7FeS3QamVtbgfvu5h7fd1IlbaC4EQ0/pgU4zqE2vdHCmBGsUa0TiM8/TdSeG6BMPC92OOCf8F1ocE/Wkrrg==} - deprecated: This module has been superseded by the multiformats module + multicodec@1.0.4: dependencies: buffer: 5.7.1 varint: 5.0.2 - /multihashes@0.4.21: - resolution: {integrity: sha512-uVSvmeCWf36pU2nB4/1kzYZjsXD9vofZKpgudqkceYY5g2aZZXJ5r9lxuzoRLl1OAp28XljXsEJ/X/85ZsKmKw==} + multihashes@0.4.21: dependencies: buffer: 5.7.1 multibase: 0.7.0 varint: 5.0.2 - /mz@2.7.0: - resolution: {integrity: sha512-z81GNO7nnYMEhrGh9LeymoE4+Yr0Wn5McHIZMK5cfQCl+NDX08sCZgUc9/6MHni9IWuFLm1Z3HTCXu2z9fN62Q==} + mz@2.7.0: dependencies: any-promise: 1.3.0 object-assign: 4.1.1 thenify-all: 1.6.0 - dev: false - /nano-base32@1.0.1: - resolution: {integrity: sha512-sxEtoTqAPdjWVGv71Q17koMFGsOMSiHsIFEvzOM7cNp8BXB4AnEwmDabm5dorusJf/v1z7QxaZYxUorU9RKaAw==} - dev: false + nano-base32@1.0.1: {} - /nano-json-stream-parser@0.1.2: - resolution: {integrity: sha512-9MqxMH/BSJC7dnLsEMPyfN5Dvoo49IsPFYMcHw3Bcfc2kN0lpHRBSzlMSVx4HGyJ7s9B31CyBTVehWJoQ8Ctew==} + nano-json-stream-parser@0.1.2: {} - /napi-build-utils@1.0.2: - resolution: {integrity: sha512-ONmRUqK7zj7DWX0D9ADe03wbwOBZxNAfF20PlGfCWQcD3+/MakShIHrMqx9YwPTfxDdF1zLeL+RGZiR9kGMLdg==} - dev: false + napi-build-utils@1.0.2: {} - /natural-compare-lite@1.4.0: - resolution: {integrity: sha512-Tj+HTDSJJKaZnfiuw+iaF9skdPpTo2GtEly5JHnWV/hfv2Qj/9RKsGISQtLh2ox3l5EAGw487hnBee0sIJ6v2g==} - dev: true + natural-compare-lite@1.4.0: {} - /natural-compare@1.4.0: - resolution: {integrity: sha512-OWND8ei3VtNC9h7V60qff3SVobHr996CTwgxubgyQYEpg290h9J0buyECNNJexkFm5sOajh5G116RYA1c8ZMSw==} + natural-compare@1.4.0: {} - /ndjson@2.0.0: - resolution: {integrity: sha512-nGl7LRGrzugTtaFcJMhLbpzJM6XdivmbkdlaGcrk/LXg2KL/YBC6z1g70xh0/al+oFuVFP8N8kiWRucmeEH/qQ==} - engines: {node: '>=10'} - hasBin: true + ndjson@2.0.0: dependencies: json-stringify-safe: 5.0.1 minimist: 1.2.8 readable-stream: 3.6.2 split2: 3.2.2 through2: 4.0.2 - dev: true - /negotiator@0.6.3: - resolution: {integrity: sha512-+EUsqGPLsM+j/zdChZjsnX51g4XrHFOIXwfnCVPGlQk/k5giakcKsuxCObBRu6DSm9opw/O6slWbJdghQM4bBg==} - engines: {node: '>= 0.6'} + negotiator@0.6.3: {} - /neo-async@2.6.2: - resolution: {integrity: sha512-Yd3UES5mWCSqR+qNT93S3UoYUkqAZ9lLg8a7g9rimsWmYGK8cVToA4/sF3RrshdyV3sAGMXVUmpMYOw+dLpOuw==} - dev: true + neo-async@2.6.2: {} - /next-tick@1.1.0: - resolution: {integrity: sha512-CXdUiJembsNjuToQvxayPZF9Vqht7hewsvy2sOWafLvi2awflj9mOC6bHIg50orX8IJvWKY9wYQ/zB2kogPslQ==} + next-tick@1.1.0: {} - /nise@4.1.0: - resolution: {integrity: sha512-eQMEmGN/8arp0xsvGoQ+B1qvSkR73B1nWSCh7nOt5neMCtwcQVYQGdzQMhcNscktTsWB54xnlSQFzOAPJD8nXA==} + nise@4.1.0: dependencies: '@sinonjs/commons': 1.8.6 '@sinonjs/fake-timers': 6.0.1 '@sinonjs/text-encoding': 0.7.2 just-extend: 4.2.1 path-to-regexp: 1.8.0 - dev: true - /no-case@2.3.2: - resolution: {integrity: sha512-rmTZ9kz+f3rCvK2TD1Ue/oZlns7OGoIWP4fc3llxxRXlOkHKoWPPWJOfFYpITabSow43QJbRIoHQXtt10VldyQ==} + no-case@2.3.2: dependencies: lower-case: 1.1.4 - dev: false - /no-case@3.0.4: - resolution: {integrity: sha512-fgAN3jGAh+RoxUGZHTSOLJIqUc2wmoBwGR4tbpNAKmmovFoWq0OdRkb0VkldReO2a2iBT/OEulG9XSUc10r3zg==} + no-case@3.0.4: dependencies: lower-case: 2.0.2 tslib: 2.6.2 - dev: true - /node-abi@3.62.0: - resolution: {integrity: sha512-CPMcGa+y33xuL1E0TcNIu4YyaZCxnnvkVaEXrsosR3FxN+fV8xvb7Mzpb7IgKler10qeMkE6+Dp8qJhpzdq35g==} - engines: {node: '>=10'} + node-abi@3.62.0: dependencies: semver: 7.6.2 - dev: false - /node-addon-api@2.0.2: - resolution: {integrity: sha512-Ntyt4AIXyaLIuMHF6IOoTakB3K+RWxwtsHNRxllEoA6vPwP9o4866g6YWDLUdnucilZhmkxiHwHr11gAENw+QA==} + node-addon-api@2.0.2: {} - /node-addon-api@3.2.1: - resolution: {integrity: sha512-mmcei9JghVNDYydghQmeDX8KoAm0FAiYyIcUt/N4nhyAipB17pllZQDOJD2fotxABnt4Mdz+dKTO7eftLg4d0A==} - dev: false + node-addon-api@3.2.1: {} - /node-addon-api@6.1.0: - resolution: {integrity: sha512-+eawOlIgy680F0kBzPUNFhMZGtJ1YmqM6l4+Crf4IkImjYrO/mqPwRMh352g23uIaQKFItcQ64I7KMaJxHgAVA==} - dev: false + node-addon-api@6.1.0: {} - /node-emoji@1.11.0: - resolution: {integrity: sha512-wo2DpQkQp7Sjm2A0cq+sN7EHKO6Sl0ctXeBdFZrL9T9+UywORbufTcTZxom8YqpLQt/FqNMUkOpkZrJVYSKD3A==} + node-emoji@1.11.0: dependencies: lodash: 4.17.21 - dev: true - /node-fetch@2.7.0: - resolution: {integrity: sha512-c4FRfUm/dbcWZ7U+1Wq0AwCyFL+3nt2bEw05wfxSz+DWpWsitgmSgYmy2dQdWyKC1694ELPqMs/YzUSNozLt8A==} - engines: {node: 4.x || >=6.0.0} - peerDependencies: - encoding: ^0.1.0 - peerDependenciesMeta: - encoding: - optional: true + node-fetch@2.7.0: dependencies: whatwg-url: 5.0.0 - /node-gyp-build@4.8.1: - resolution: {integrity: sha512-OSs33Z9yWr148JZcbZd5WiAXhh/n9z8TxQcdMhIOlpN9AhWpLfvVFO73+m77bBABQMaY9XSvIa+qk0jlI7Gcaw==} - hasBin: true + node-gyp-build@4.8.1: {} - /node-hid@2.2.0: - resolution: {integrity: sha512-vj48zh9j555DZzUhMc8tk/qw6xPFrDyPBH1ST1Z/hWaA/juBJw7IuSxPeOgpzNFNU36mGYj+THioRMt1xOdm/g==} - engines: {node: '>=10'} - hasBin: true - requiresBuild: true + node-hid@2.2.0: dependencies: bindings: 1.5.0 node-addon-api: 3.2.1 prebuild-install: 7.1.2 - dev: false - /node-preload@0.2.1: - resolution: {integrity: sha512-RM5oyBy45cLEoHqCeh+MNuFAxO0vTFBLskvQbOKnEE7YTTSN4tbN8QWDIPQ6L+WvKsB/qLEGpYe2ZZ9d4W9OIQ==} - engines: {node: '>=8'} + node-preload@0.2.1: dependencies: process-on-spawn: 1.0.0 - dev: true - /node-releases@2.0.14: - resolution: {integrity: sha512-y10wOWt8yZpqXmOgRo77WaHEmhYQYGNA6y421PKsKYWEK8aW+cqAphborZDhqfyKrbZEN92CN1X2KbafY2s7Yw==} - dev: true + node-releases@2.0.14: {} - /nofilter@1.0.4: - resolution: {integrity: sha512-N8lidFp+fCz+TD51+haYdbDGrcBWwuHX40F5+z0qkUjMJ5Tp+rdSuAkMJ9N9eoolDlEVTf6u5icM+cNKkKW2mA==} - engines: {node: '>=8'} - dev: false + nofilter@1.0.4: {} - /nofilter@3.1.0: - resolution: {integrity: sha512-l2NNj07e9afPnhAhvgVrCD/oy2Ai1yfLpuo3EpiO1jFTsB4sFz6oIfAfSZyQzVpkZQ9xS8ZS5g1jCBgq4Hwo0g==} - engines: {node: '>=12.19'} + nofilter@3.1.0: {} - /nopt@3.0.6: - resolution: {integrity: sha512-4GUt3kSEYmk4ITxzB/b9vaIDfUVWN/Ml1Fwl11IlnIG2iaJ9O6WXZ9SrYM9NLI8OCBieN2Y8SWC2oJV0RQ7qYg==} - hasBin: true + nopt@3.0.6: dependencies: abbrev: 1.0.9 - dev: true - /normalize-package-data@2.5.0: - resolution: {integrity: sha512-/5CMN3T0R4XTj4DcGaexo+roZSdSFW/0AOOTROrjxzCG1wrWXEsGbRKevjlIL+ZDE4sZlJr5ED4YW0yqmkK+eA==} + normalize-package-data@2.5.0: dependencies: hosted-git-info: 2.8.9 resolve: 1.17.0 semver: 5.7.2 validate-npm-package-license: 3.0.4 - /normalize-path@3.0.0: - resolution: {integrity: sha512-6eZs5Ls3WtCisHWp9S2GUy8dqkpGi4BVSz3GaqiE6ezub0512ESztXUwUB6C6IKbQkY2Pnb/mD4WYojCRwcwLA==} - engines: {node: '>=0.10.0'} + normalize-path@3.0.0: {} - /normalize-url@6.1.0: - resolution: {integrity: sha512-DlL+XwOy3NxAQ8xuC0okPgK46iuVNAK01YN7RueYBqqFeGsBjV9XmCAzAdgt+667bCl5kPh9EqKKDwnaPG1I7A==} - engines: {node: '>=10'} + normalize-url@6.1.0: {} - /nth-check@2.1.1: - resolution: {integrity: sha512-lqjrjmaOoAnWfMmBPL+XNnynZh2+swxiX3WUE0s4yEHI6m+AwrK2UZOimIRl3X/4QctVqS8AiZjFqyOGrMXb/w==} + nth-check@2.1.1: dependencies: boolbase: 1.0.0 - dev: false - /number-is-nan@1.0.1: - resolution: {integrity: sha512-4jbtZXNAsfZbAHiiqjLPBiCl16dES1zI4Hpzzxw61Tk+loF+sBDBKx1ICKKKwIqQ7M0mFn1TmkN7euSncWgHiQ==} - engines: {node: '>=0.10.0'} - dev: false + number-is-nan@1.0.1: {} - /number-to-bn@1.7.0: - resolution: {integrity: sha512-wsJ9gfSz1/s4ZsJN01lyonwuxA1tml6X1yBDnfpMglypcBRFZZkus26EdPSlqS5GJfYddVZa22p3VNb3z5m5Ig==} - engines: {node: '>=6.5.0', npm: '>=3'} + number-to-bn@1.7.0: dependencies: bn.js: 4.11.6 strip-hex-prefix: 1.0.0 - /nyc@15.1.0: - resolution: {integrity: sha512-jMW04n9SxKdKi1ZMGhvUTHBN0EICCRkHemEoE5jm6mTYcqcdas0ATzgUgejlQUHMvpnOZqGB5Xxsv9KxJW1j8A==} - engines: {node: '>=8.9'} - hasBin: true + nyc@15.1.0: dependencies: '@istanbuljs/load-nyc-config': 1.1.0 '@istanbuljs/schema': 0.1.3 @@ -8607,72 +11887,47 @@ packages: yargs: 15.4.1 transitivePeerDependencies: - supports-color - dev: true - /oauth-sign@0.9.0: - resolution: {integrity: sha512-fexhUFFPTGV8ybAtSIGbV6gOkSv8UtRbDBnAyLQw4QPKkgNlsH2ByPGtMUqdWkos6YCRmAqViwgZrJc/mRDzZQ==} + oauth-sign@0.9.0: {} - /object-assign@4.1.1: - resolution: {integrity: sha512-rJgTQnkUnH1sFw8yT6VSU3zD3sWmu6sZhIseY8VX+GRu3P6F7Fu+JNDoXfklElbLJSnc3FUQHVe4cU5hj+BcUg==} - engines: {node: '>=0.10.0'} + object-assign@4.1.1: {} - /object-inspect@1.13.1: - resolution: {integrity: sha512-5qoj1RUiKOMsCCNLV1CBiPYE10sziTsnmNxkAI/rZhiD63CF7IqdFGC/XzjWjpSgLf0LxXX3bDFIh0E18f6UhQ==} + object-inspect@1.13.1: {} - /object-keys@1.1.1: - resolution: {integrity: sha512-NuAESUOUMrlIXOfHKzD6bpPu3tYt3xvjNdRIQ+FeT0lNb4K8WR70CaDxhuNguS2XG+GjkyMwOzsN5ZktImfhLA==} - engines: {node: '>= 0.4'} - dev: true + object-keys@1.1.1: {} - /object.assign@4.1.5: - resolution: {integrity: sha512-byy+U7gp+FVwmyzKPYhW2h5l3crpmGsxl7X2s8y43IgxvG4g3QZ6CffDtsNQy1WsmZpQbO+ybo0AlW7TY6DcBQ==} - engines: {node: '>= 0.4'} + object.assign@4.1.5: dependencies: call-bind: 1.0.7 define-properties: 1.2.1 has-symbols: 1.0.3 object-keys: 1.1.1 - dev: true - /object.values@1.2.0: - resolution: {integrity: sha512-yBYjY9QX2hnRmZHAjG/f13MzmBzxzYgQhFrke06TTyKY5zSTEqkOeukBzIdVA3j3ulu8Qa3MbVFShV7T2RmGtQ==} - engines: {node: '>= 0.4'} + object.values@1.2.0: dependencies: call-bind: 1.0.7 define-properties: 1.2.1 es-object-atoms: 1.0.0 - dev: true - /obliterator@2.0.4: - resolution: {integrity: sha512-lgHwxlxV1qIg1Eap7LgIeoBWIMFibOjbrYPIPJZcI1mmGAI2m3lNYpK12Y+GBdPQ0U1hRwSord7GIaawz962qQ==} - dev: false + obliterator@2.0.4: {} - /oboe@2.1.5: - resolution: {integrity: sha512-zRFWiF+FoicxEs3jNI/WYUrVEgA7DeET/InK0XQuudGHRg8iIob3cNPrJTKaz4004uaA9Pbe+Dwa8iluhjLZWA==} + oboe@2.1.5: dependencies: http-https: 1.0.0 - /on-finished@2.4.1: - resolution: {integrity: sha512-oVlzkg3ENAhCk2zdv7IJwd/QUD4z2RxRwpkcGY8psCVcCYZNq4wYnVWALHM+brtuJjePWiYF/ClmuDr8Ch5+kg==} - engines: {node: '>= 0.8'} + on-finished@2.4.1: dependencies: ee-first: 1.1.1 - /once@1.4.0: - resolution: {integrity: sha512-lNaJgI+2Q5URQBkccEKHTQOPaXdUxnZZElQTZY0MFUAuaEqe1E+Nyvgdz/aIyNi6Z9MzO5dv1H8n58/GELp3+w==} + once@1.4.0: dependencies: wrappy: 1.0.2 - /onetime@5.1.2: - resolution: {integrity: sha512-kbpaSSGJTWdAY5KPVeMOKXSrPtr8C8C7wodJbcsd51jRnmD+GZu8Y0VoU6Dm5Z4vWr0Ig/1NKuWRKf7j5aaYSg==} - engines: {node: '>=6'} + onetime@5.1.2: dependencies: mimic-fn: 2.1.0 - dev: false - /optionator@0.8.3: - resolution: {integrity: sha512-+IW9pACdk3XWmmTXG8m3upGUJst5XRGzxMRjXzAuJ1XnIFNvfhjjIuYkDvysnPQ7qzqVzLt78BCruntqRhWQbA==} - engines: {node: '>= 0.8.0'} + optionator@0.8.3: dependencies: deep-is: 0.1.4 fast-levenshtein: 2.0.6 @@ -8680,11 +11935,8 @@ packages: prelude-ls: 1.1.2 type-check: 0.3.2 word-wrap: 1.2.5 - dev: true - /optionator@0.9.4: - resolution: {integrity: sha512-6IpQ7mKUxRcZNLIObR0hz7lxsapSSIYNZJwXPGeF0mTVqGKFIXj1DQcMoT22S3ROcLyY/rz0PWaWZ9ayWmad9g==} - engines: {node: '>= 0.8.0'} + optionator@0.9.4: dependencies: deep-is: 0.1.4 fast-levenshtein: 2.0.6 @@ -8693,9 +11945,7 @@ packages: type-check: 0.4.0 word-wrap: 1.2.5 - /ora@5.4.1: - resolution: {integrity: sha512-5b6Y85tPxZZ7QytO+BQzysW31HJku27cRIlkbAXaNx+BdcVi+LlRFmVXzeF6a7JCwJpyw5c4b+YSVImQIrBpuQ==} - engines: {node: '>=10'} + ora@5.4.1: dependencies: bl: 4.1.0 chalk: 4.1.2 @@ -8706,250 +11956,148 @@ packages: log-symbols: 4.1.0 strip-ansi: 6.0.1 wcwidth: 1.0.1 - dev: false - /ordinal@1.0.3: - resolution: {integrity: sha512-cMddMgb2QElm8G7vdaa02jhUNbTSrhsgAGUz1OokD83uJTwSUn+nKoNoKVVaRa08yF6sgfO7Maou1+bgLd9rdQ==} - dev: false + ordinal@1.0.3: {} - /os-locale@1.4.0: - resolution: {integrity: sha512-PRT7ZORmwu2MEFt4/fv3Q+mEfN4zetKxufQrkShY2oGvUms9r8otu5HfdyIFHkYXjO7laNsoVGmM2MANfuTA8g==} - engines: {node: '>=0.10.0'} + os-locale@1.4.0: dependencies: lcid: 1.0.0 - dev: false - /os-tmpdir@1.0.2: - resolution: {integrity: sha512-D2FR03Vir7FIu45XBY20mTb+/ZSWB00sjU9jdQXt83gDrI4Ztz5Fs7/yy74g2N5SVQY4xY1qDr4rNddwYRVX0g==} - engines: {node: '>=0.10.0'} + os-tmpdir@1.0.2: {} - /outdent@0.5.0: - resolution: {integrity: sha512-/jHxFIzoMXdqPzTaCpFzAAWhpkSjZPF4Vsn6jAfNpmbH/ymsmd7Qc6VE9BGn0L6YMj6uwpQLxCECpus4ukKS9Q==} - dev: true + outdent@0.5.0: {} - /p-cancelable@2.1.1: - resolution: {integrity: sha512-BZOr3nRQHOntUjTrH8+Lh54smKHoHyur8We1V8DSMVrl5A2malOOwuJRnKRDjSnkoeBh4at6BwEnb5I7Jl31wg==} - engines: {node: '>=8'} + p-cancelable@2.1.1: {} - /p-cancelable@3.0.0: - resolution: {integrity: sha512-mlVgR3PGuzlo0MmTdk4cXqXWlwQDLnONTAg6sm62XkMJEiRxN3GL3SffkYvqwonbkJBcrI7Uvv5Zh9yjvn2iUw==} - engines: {node: '>=12.20'} + p-cancelable@3.0.0: {} - /p-filter@2.1.0: - resolution: {integrity: sha512-ZBxxZ5sL2HghephhpGAQdoskxplTwr7ICaehZwLIlfL6acuVgZPm8yBNuRAFBGEqtD/hmUeq9eqLg2ys9Xr/yw==} - engines: {node: '>=8'} + p-filter@2.1.0: dependencies: p-map: 2.1.0 - dev: true - /p-limit@1.3.0: - resolution: {integrity: sha512-vvcXsLAJ9Dr5rQOPk7toZQZJApBl2K4J6dANSsEuh6QI41JYcsS/qhTGa9ErIUUgK3WNQoJYvylxvjqmiqEA9Q==} - engines: {node: '>=4'} + p-limit@1.3.0: dependencies: p-try: 1.0.0 - dev: false - /p-limit@2.3.0: - resolution: {integrity: sha512-//88mFWSJx8lxCzwdAABTJL2MyWB12+eIY7MDL2SqLmAkeKU9qxRvWuSyTjm3FUmpBEMuFfckAIqEaVGUDxb6w==} - engines: {node: '>=6'} + p-limit@2.3.0: dependencies: p-try: 2.2.0 - dev: true - /p-limit@3.1.0: - resolution: {integrity: sha512-TYOanM3wGwNGsZN2cVTYPArw454xnXj5qmWF1bEoAc4+cU/ol7GVh7odevjp1FNHduHc3KZMcFduxU5Xc6uJRQ==} - engines: {node: '>=10'} + p-limit@3.1.0: dependencies: yocto-queue: 0.1.0 - /p-locate@2.0.0: - resolution: {integrity: sha512-nQja7m7gSKuewoVRen45CtVfODR3crN3goVQ0DDZ9N3yHxgpkuBhZqsaiotSQRrADUrne346peY7kT3TSACykg==} - engines: {node: '>=4'} + p-locate@2.0.0: dependencies: p-limit: 1.3.0 - dev: false - /p-locate@4.1.0: - resolution: {integrity: sha512-R79ZZ/0wAxKGu3oYMlz8jy/kbhsNrS7SKZ7PxEHBgJ5+F2mtFW2fK2cOtBh1cHYkQsbzFV7I+EoRKe6Yt0oK7A==} - engines: {node: '>=8'} + p-locate@4.1.0: dependencies: p-limit: 2.3.0 - dev: true - /p-locate@5.0.0: - resolution: {integrity: sha512-LaNjtRWUBY++zB5nE/NwcaoMylSPk+S+ZHNB1TzdbMJMny6dynpAGt7X/tl/QYq3TIeE6nxHppbo2LGymrG5Pw==} - engines: {node: '>=10'} + p-locate@5.0.0: dependencies: p-limit: 3.1.0 - /p-map@2.1.0: - resolution: {integrity: sha512-y3b8Kpd8OAN444hxfBbFfj1FY/RjtTd8tzYwhUqNYXx0fXx2iX4maP4Qr6qhIKbQXI02wTLAda4fYUbDagTUFw==} - engines: {node: '>=6'} - dev: true + p-map@2.1.0: {} - /p-map@3.0.0: - resolution: {integrity: sha512-d3qXVTF/s+W+CdJ5A29wywV2n8CQQYahlgz2bFiA+4eVNJbHJodPZ+/gXwPGh0bOqA+j8S+6+ckmvLGPk1QpxQ==} - engines: {node: '>=8'} + p-map@3.0.0: dependencies: aggregate-error: 3.1.0 - dev: true - /p-map@4.0.0: - resolution: {integrity: sha512-/bjOqmgETBYB5BoEeGVea8dmvHb2m9GLy1E9W43yeyfP6QQCZGFNa+XRceJEuDB6zqr+gKpIAmlLebMpykw/MQ==} - engines: {node: '>=10'} + p-map@4.0.0: dependencies: aggregate-error: 3.1.0 - dev: false - /p-try@1.0.0: - resolution: {integrity: sha512-U1etNYuMJoIz3ZXSrrySFjsXQTWOx2/jdi86L+2pRvph/qMKL6sbcCYdH23fqsbm8TH2Gn0OybpT4eSFlCVHww==} - engines: {node: '>=4'} - dev: false + p-try@1.0.0: {} - /p-try@2.2.0: - resolution: {integrity: sha512-R4nPAVTAU0B9D35/Gk3uJf/7XYbQcyohSKdvAxIRSNghFl4e71hVoGnBNQz9cWaXxO2I10KTC+3jMdvvoKw6dQ==} - engines: {node: '>=6'} - dev: true + p-try@2.2.0: {} - /package-hash@4.0.0: - resolution: {integrity: sha512-whdkPIooSu/bASggZ96BWVvZTRMOFxnyUG5PnTSGKoJE2gd5mbVNmR2Nj20QFzxYYgAXpoqC+AiXzl+UMRh7zQ==} - engines: {node: '>=8'} + package-hash@4.0.0: dependencies: graceful-fs: 4.2.11 hasha: 5.2.2 lodash.flattendeep: 4.4.0 release-zalgo: 1.0.0 - dev: true - /pako@1.0.11: - resolution: {integrity: sha512-4hLB8Py4zZce5s4yd9XzopqwVv/yGNhV1Bl8NTmCq1763HeK2+EwVTv+leGeL13Dnh2wfbqowVPXCIO0z4taYw==} - dev: false + pako@1.0.11: {} - /param-case@2.1.1: - resolution: {integrity: sha512-eQE845L6ot89sk2N8liD8HAuH4ca6Vvr7VWAWwt7+kvvG5aBcPmmphQ68JsEG2qa9n1TykS2DLeMt363AAH8/w==} + param-case@2.1.1: dependencies: no-case: 2.3.2 - dev: false - /parent-module@1.0.1: - resolution: {integrity: sha512-GQ2EWRpQV8/o+Aw8YqtfZZPfNRWZYkbidE9k5rpl/hC3vtHHBfGm2Ifi6qWV+coDGkrUKZAxE3Lot5kcsRlh+g==} - engines: {node: '>=6'} + parent-module@1.0.1: dependencies: callsites: 3.1.0 - /parse-cache-control@1.0.1: - resolution: {integrity: sha512-60zvsJReQPX5/QP0Kzfd/VrpjScIQ7SHBW6bFCYfEP+fp0Eppr1SHhIO5nd1PjZtvclzSzES9D/p5nFJurwfWg==} - dev: true + parse-cache-control@1.0.1: {} - /parse-headers@2.0.5: - resolution: {integrity: sha512-ft3iAoLOB/MlwbNXgzy43SWGP6sQki2jQvAyBg/zDFAgr9bfNWZIUj42Kw2eJIl8kEi4PbgE6U1Zau/HwI75HA==} + parse-headers@2.0.5: {} - /parse-json@2.2.0: - resolution: {integrity: sha512-QR/GGaKCkhwk1ePQNYDRKYZ3mwU9ypsKhB0XyFnLQdomyEqk3e8wpW3V5Jp88zbxK4n5ST1nqo+g9juTpownhQ==} - engines: {node: '>=0.10.0'} + parse-json@2.2.0: dependencies: error-ex: 1.3.2 - dev: false - /parse-json@5.2.0: - resolution: {integrity: sha512-ayCKvm/phCGxOkYRSCM82iDwct8/EonSEgCSxWxD7ve6jHggsFl4fZVQBPRNgQoKiuV/odhFrGzQXZwbifC8Rg==} - engines: {node: '>=8'} + parse-json@5.2.0: dependencies: '@babel/code-frame': 7.24.2 error-ex: 1.3.2 json-parse-even-better-errors: 2.3.1 lines-and-columns: 1.2.4 - /parse-ms@0.1.2: - resolution: {integrity: sha512-VwMglE9412ifMHcRFEVJePEpreQh90wjIiOdP0UQQGKV4l+QprdKI+p5noXTkmGjznBMb40s+VymcclATAVvYA==} - engines: {node: '>=0.10.0'} - dev: true + parse-ms@0.1.2: {} - /parse5-htmlparser2-tree-adapter@7.0.0: - resolution: {integrity: sha512-B77tOZrqqfUfnVcOrUvfdLbz4pu4RopLD/4vmu3HUPswwTA8OH0EMW9BlWR2B0RCoiZRAHEUu7IxeP1Pd1UU+g==} + parse5-htmlparser2-tree-adapter@7.0.0: dependencies: domhandler: 5.0.3 parse5: 7.1.2 - dev: false - /parse5@7.1.2: - resolution: {integrity: sha512-Czj1WaSVpaoj0wbhMzLmWD69anp2WH7FXMB9n1Sy8/ZFF9jolSQVMu1Ij5WIyGmcBmhk7EOndpO4mIpihVqAXw==} + parse5@7.1.2: dependencies: entities: 4.5.0 - dev: false - /parseurl@1.3.3: - resolution: {integrity: sha512-CiyeOxFT/JZyN5m0z9PfXw4SCBJ6Sygz1Dpl0wqjlhDEGGBP1GnsUVEL0p63hoG1fcj3fHynXi9NYO4nWOL+qQ==} - engines: {node: '>= 0.8'} + parseurl@1.3.3: {} - /pascal-case@2.0.1: - resolution: {integrity: sha512-qjS4s8rBOJa2Xm0jmxXiyh1+OFf6ekCWOvUaRgAQSktzlTbMotS0nmG9gyYAybCWBcuP4fsBeRCKNwGBnMe2OQ==} + pascal-case@2.0.1: dependencies: camel-case: 3.0.0 upper-case-first: 1.1.2 - dev: false - /path-case@2.1.1: - resolution: {integrity: sha512-Ou0N05MioItesaLr9q8TtHVWmJ6fxWdqKB2RohFmNWVyJ+2zeKIeDNWAN6B/Pe7wpzWChhZX6nONYmOnMeJQ/Q==} + path-case@2.1.1: dependencies: no-case: 2.3.2 - dev: false - /path-exists@2.1.0: - resolution: {integrity: sha512-yTltuKuhtNeFJKa1PiRzfLAU5182q1y4Eb4XCJ3PBqyzEDkAZRzBrKKBct682ls9reBVHf9udYLN5Nd+K1B9BQ==} - engines: {node: '>=0.10.0'} + path-exists@2.1.0: dependencies: pinkie-promise: 2.0.1 - dev: false - /path-exists@3.0.0: - resolution: {integrity: sha512-bpC7GYwiDYQ4wYLe+FA8lhRjhQCMcQGuSgGGqDkg/QerRWw9CmGRT0iSOVRSZJ29NMLZgIzqaljJ63oaL4NIJQ==} - engines: {node: '>=4'} - dev: false + path-exists@3.0.0: {} - /path-exists@4.0.0: - resolution: {integrity: sha512-ak9Qy5Q7jYb2Wwcey5Fpvg2KoAc/ZIhLSLOSBmRmygPsGwkVVt0fZa0qrtMz+m6tJTAHfZQ8FnmB4MG4LWy7/w==} - engines: {node: '>=8'} + path-exists@4.0.0: {} - /path-is-absolute@1.0.1: - resolution: {integrity: sha512-AVbw3UJ2e9bq64vSaS9Am0fje1Pa8pbGqTTsmXfaIiMpnr5DlDhfJOuLj9Sf95ZPVDAUerDfEk88MPmPe7UCQg==} - engines: {node: '>=0.10.0'} + path-is-absolute@1.0.1: {} - /path-key@3.1.1: - resolution: {integrity: sha512-ojmeN0qd+y0jszEtoY48r0Peq5dwMEkIlCOu6Q5f41lfkswXuKtYrhgoTpLnyIcHm24Uhqx+5Tqm2InSwLhE6Q==} - engines: {node: '>=8'} + path-key@3.1.1: {} - /path-parse@1.0.7: - resolution: {integrity: sha512-LDJzPVEEEPR+y48z93A0Ed0yXb8pAByGWo/k5YYdYgpY2/2EsOsksJrq7lOHxryrVOn1ejG6oAp8ahvOIQD8sw==} + path-parse@1.0.7: {} - /path-to-regexp@0.1.7: - resolution: {integrity: sha512-5DFkuoqlv1uYQKxy8omFBeJPQcdoE07Kv2sferDCrAq1ohOU+MSDswDIbnx3YAM60qIOnYa53wBhXW0EbMonrQ==} + path-to-regexp@0.1.7: {} - /path-to-regexp@1.8.0: - resolution: {integrity: sha512-n43JRhlUKUAlibEJhPeir1ncUID16QnEjNpwzNdO3Lm4ywrBpBZ5oLD0I6br9evr1Y9JTqwRtAh7JLoOzAQdVA==} + path-to-regexp@1.8.0: dependencies: isarray: 0.0.1 - dev: true - /path-type@1.1.0: - resolution: {integrity: sha512-S4eENJz1pkiQn9Znv33Q+deTOKmbl+jj1Fl+qiP/vYezj+S8x+J3Uo0ISrx/QoEvIlOaDWJhPaRd1flJ9HXZqg==} - engines: {node: '>=0.10.0'} + path-type@1.1.0: dependencies: graceful-fs: 4.2.11 pify: 2.3.0 pinkie-promise: 2.0.1 - dev: false - /path-type@4.0.0: - resolution: {integrity: sha512-gDKb8aZMDeD/tZWs9P6+q0J9Mwkdl6xMV8TjnGP3qJVJ06bdMgkbBlLU8IdfOsIsFz2BW1rNVT3XuNEl8zPAvw==} - engines: {node: '>=8'} + path-type@4.0.0: {} - /pathval@1.1.1: - resolution: {integrity: sha512-Dp6zGqpTdETdR63lehJYPeIOqpiNBNtc7BpWSLrOje7UaIsE5aY92r/AunQA7rsXvet3lrJ3JnZX29UPTKXyKQ==} + pathval@1.1.1: {} - /pbkdf2@3.1.2: - resolution: {integrity: sha512-iuh7L6jA7JEGu2WxDwtQP1ddOpaJNC4KlDEFfdQajSGgGPNi4OyDc2R7QnbY2bR9QjBVGwgvTdNJZoE7RaxUMA==} - engines: {node: '>=0.12'} + pbkdf2@3.1.2: dependencies: create-hash: 1.2.0 create-hmac: 1.1.7 @@ -8957,58 +12105,31 @@ packages: safe-buffer: 5.2.1 sha.js: 2.4.11 - /performance-now@2.1.0: - resolution: {integrity: sha512-7EAHlyLHI56VEIdK57uwHdHKIaAGbnXPiw0yWbarQZOKaKpvUIgW0jWRVLiatnM+XXlSwsanIBH/hzGMJulMow==} + performance-now@2.1.0: {} - /picocolors@1.0.0: - resolution: {integrity: sha512-1fygroTLlHu66zi26VoTDv8yRgm0Fccecssto+MhsZ0D/DGW2sm8E8AjW7NU5VVTRt5GxbeZ5qBuJr+HyLYkjQ==} + picocolors@1.0.0: {} - /picomatch@2.3.1: - resolution: {integrity: sha512-JU3teHTNjmE2VCGFzuY8EXzCDVwEqB2a8fsIvwaStHhAWJEeVd1o1QD80CU6+ZdEXXSLbSsuLwJjkCBWqRQUVA==} - engines: {node: '>=8.6'} + picomatch@2.3.1: {} - /pify@2.3.0: - resolution: {integrity: sha512-udgsAY+fTnvv7kI7aaxbqwWNb0AHiB0qBO89PZKPkoTmGOgdbrHDKD+0B2X4uTfJ/FT1R09r9gTsjUjNJotuog==} - engines: {node: '>=0.10.0'} - dev: false + pify@2.3.0: {} - /pify@4.0.1: - resolution: {integrity: sha512-uB80kBFb/tfd68bVleG9T5GGsGPjJrLAUpR5PZIrhBnIaRTQRjqdJSsIKkOP6OAIFbj7GOrcudc5pNjZ+geV2g==} - engines: {node: '>=6'} - dev: true + pify@4.0.1: {} - /pinkie-promise@2.0.1: - resolution: {integrity: sha512-0Gni6D4UcLTbv9c57DfxDGdr41XfgUjqWZu492f0cIGr16zDU06BWP/RAEvOuo7CQ0CNjHaLlM59YJJFm3NWlw==} - engines: {node: '>=0.10.0'} + pinkie-promise@2.0.1: dependencies: pinkie: 2.0.4 - dev: false - /pinkie@2.0.4: - resolution: {integrity: sha512-MnUuEycAemtSaeFSjXKW/aroV7akBbY+Sv+RkyqFjgAe73F+MR0TBWKBRDkmfWq/HiFmdavfZ1G7h4SPZXaCSg==} - engines: {node: '>=0.10.0'} - dev: false + pinkie@2.0.4: {} - /pkg-dir@4.2.0: - resolution: {integrity: sha512-HRDzbaKjC+AOWVXxAU/x54COGeIv9eb+6CkDSQoNTt4XyWoIJvuPsXizxu/Fr23EiekbtZwmh1IcIG/l/a10GQ==} - engines: {node: '>=8'} + pkg-dir@4.2.0: dependencies: find-up: 4.1.0 - dev: true - /pluralize@8.0.0: - resolution: {integrity: sha512-Nc3IT5yHzflTfbjgqWcCPpo7DaKy4FnpB0l/zCAW0Tc7jxAiuqSxHasntB3D7887LSrA93kDJ9IXovxJYxyLCA==} - engines: {node: '>=4'} - dev: false + pluralize@8.0.0: {} - /possible-typed-array-names@1.0.0: - resolution: {integrity: sha512-d7Uw+eZoloe0EHDIYoe+bQ5WXnGMOpmiZFTuMWCwpjzzkL2nTjcKiAk4hh8TjnGye2TwWOk3UXucZ+3rbmBa8Q==} - engines: {node: '>= 0.4'} + possible-typed-array-names@1.0.0: {} - /prebuild-install@7.1.2: - resolution: {integrity: sha512-UnNke3IQb6sgarcZIDU3gbMeTp/9SSU1DAIkil7PrqG1vZlBtY5msYccSKSHDqa3hNg436IXK+SNImReuA1wEQ==} - engines: {node: '>=10'} - hasBin: true + prebuild-install@7.1.2: dependencies: detect-libc: 2.0.3 expand-template: 2.0.3 @@ -9022,264 +12143,163 @@ packages: simple-get: 4.0.1 tar-fs: 2.1.1 tunnel-agent: 0.6.0 - dev: false - /preferred-pm@3.1.3: - resolution: {integrity: sha512-MkXsENfftWSRpzCzImcp4FRsCc3y1opwB73CfCNWyzMqArju2CrlMHlqB7VexKiPEOjGMbttv1r9fSCn5S610w==} - engines: {node: '>=10'} + preferred-pm@3.1.3: dependencies: find-up: 5.0.0 find-yarn-workspace-root2: 1.2.16 path-exists: 4.0.0 which-pm: 2.0.0 - dev: true - /prelude-ls@1.1.2: - resolution: {integrity: sha512-ESF23V4SKG6lVSGZgYNpbsiaAkdab6ZgOxe52p7+Kid3W3u3bxR4Vfd/o21dmN7jSt0IwgZ4v5MUd26FEtXE9w==} - engines: {node: '>= 0.8.0'} - dev: true + prelude-ls@1.1.2: {} - /prelude-ls@1.2.1: - resolution: {integrity: sha512-vkcDPrRZo1QZLbn5RLGPpg/WmIQ65qoWWhcGKf/b5eplkkarX0m9z8ppCat4mlOqUsWpyNuYgO3VRyrYHSzX5g==} - engines: {node: '>= 0.8.0'} + prelude-ls@1.2.1: {} - /prettier-linter-helpers@1.0.0: - resolution: {integrity: sha512-GbK2cP9nraSSUF9N2XwUwqfzlAFlMNYYl+ShE/V+H8a9uNl/oUqB1w2EL54Jh0OlyRSd8RfWYJ3coVS4TROP2w==} - engines: {node: '>=6.0.0'} + prettier-linter-helpers@1.0.0: dependencies: fast-diff: 1.3.0 - dev: true - /prettier@2.4.1: - resolution: {integrity: sha512-9fbDAXSBcc6Bs1mZrDYb3XKzDLm4EXXL9sC1LqKP5rZkT6KRr/rf9amVUcODVXgguK/isJz0d0hP72WeaKWsvA==} - engines: {node: '>=10.13.0'} - hasBin: true - dev: true + prettier@2.4.1: {} - /prettier@2.8.8: - resolution: {integrity: sha512-tdN8qQGvNjw4CHbY+XXk0JgCXn9QiF21a55rBe5LJAU+kDyC4WQn4+awm2Xfk2lQMk5fKup9XgzTZtGkjBdP9Q==} - engines: {node: '>=10.13.0'} - hasBin: true + prettier@2.8.8: {} - /pretty-format@29.7.0: - resolution: {integrity: sha512-Pdlw/oPxN+aXdmM9R00JVC9WVFoCLTKJvDVLgmJ+qAffBMxsV85l/Lu7sNx4zSzPyoL2euImuEwHhOXdEgNFZQ==} - engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0} + pretty-format@29.7.0: dependencies: '@jest/schemas': 29.6.3 ansi-styles: 5.2.0 react-is: 18.3.1 - dev: true - /pretty-ms@0.2.2: - resolution: {integrity: sha512-ah/vWDJAT0arxQwVcSGp6etaLTZr4IsrXTy/khfjimzdYgSxYWzTMByrtpJUWinAnVY8szDg+qQhsE5MUMz3lQ==} - engines: {node: '>=0.10.0'} - hasBin: true + pretty-ms@0.2.2: dependencies: parse-ms: 0.1.2 - dev: true - /process-nextick-args@2.0.1: - resolution: {integrity: sha512-3ouUOpQhtgrbOa17J7+uxOTpITYWaGP7/AhoR3+A+/1e9skrzelGi/dXzEYyvbxubEF6Wn2ypscTKiKJFFn1ag==} - dev: true + process-nextick-args@2.0.1: {} - /process-on-spawn@1.0.0: - resolution: {integrity: sha512-1WsPDsUSMmZH5LeMLegqkPDrsGgsWwk1Exipy2hvB0o/F0ASzbpIctSCcZIK1ykJvtTJULEH+20WOFjMvGnCTg==} - engines: {node: '>=8'} + process-on-spawn@1.0.0: dependencies: fromentries: 1.3.2 - dev: true - /process@0.11.10: - resolution: {integrity: sha512-cdGef/drWFoydD1JsMzuFf8100nZl+GT+yacc2bEced5f9Rjk4z+WtFUTBu9PhOi9j/jfmBPu0mMEY4wIdAF8A==} - engines: {node: '>= 0.6.0'} + process@0.11.10: {} - /promise@8.3.0: - resolution: {integrity: sha512-rZPNPKTOYVNEEKFaq1HqTgOwZD+4/YHS5ukLzQCypkj+OkYx7iv0mA91lJlpPPZ8vMau3IIGj5Qlwrx+8iiSmg==} + promise@8.3.0: dependencies: asap: 2.0.6 - dev: true - /prompts@2.4.2: - resolution: {integrity: sha512-NxNv/kLguCA7p3jE8oL2aEBsrJWgAakBpgmgK6lpPWV+WuOmY6r2/zbAVnP+T8bQlA0nzHXSJSJW0Hq7ylaD2Q==} - engines: {node: '>= 6'} + prompts@2.4.2: dependencies: kleur: 3.0.3 sisteransi: 1.0.5 - dev: true - /proxy-addr@2.0.7: - resolution: {integrity: sha512-llQsMLSUDUPT44jdrU/O37qlnifitDP+ZwrmmZcoSKyLKvtZxpyV0n2/bD/N4tBAAZ/gJEdZU7KMraoK1+XYAg==} - engines: {node: '>= 0.10'} + proxy-addr@2.0.7: dependencies: forwarded: 0.2.0 ipaddr.js: 1.9.1 - /proxy-from-env@1.1.0: - resolution: {integrity: sha512-D+zkORCbA9f1tdWRK0RaCR3GPv50cMxcrz4X8k5LTSUD1Dkw47mKJEZQNunItRTkWwgtaUSo1RVFRIG9ZXiFYg==} + proxy-from-env@1.1.0: {} - /pseudomap@1.0.2: - resolution: {integrity: sha512-b/YwNhb8lk1Zz2+bXXpS/LK9OisiZZ1SNsSLxN1x2OXVEhW2Ckr/7mWE5vrC1ZTiJlD9g19jWszTmJsB+oEpFQ==} - dev: true + pseudomap@1.0.2: {} - /psl@1.9.0: - resolution: {integrity: sha512-E/ZsdU4HLs/68gYzgGTkMicWTLPdAftJLfJFlLUAAKZGkStNU72sZjT66SnMDVOfOWY/YAoiD7Jxa9iHvngcag==} + psl@1.9.0: {} - /pump@3.0.0: - resolution: {integrity: sha512-LwZy+p3SFs1Pytd/jYct4wpv49HiYCqd9Rlc5ZVdk0V+8Yzv6jR5Blk3TRmPL1ft69TxP0IMZGJ+WPFU2BFhww==} + pump@3.0.0: dependencies: end-of-stream: 1.4.4 once: 1.4.0 - /punycode@2.1.0: - resolution: {integrity: sha512-Yxz2kRwT90aPiWEMHVYnEf4+rhwF1tBmmZ4KepCP+Wkium9JxtWnUm1nqGwpiAHr/tnTSeHqr3wb++jgSkXjhA==} - engines: {node: '>=6'} + punycode@2.1.0: {} - /punycode@2.3.1: - resolution: {integrity: sha512-vYt7UD1U9Wg6138shLtLOvdAu+8DsC/ilFtEVHcH+wydcSpNE20AfSOduf6MkRFahL5FY7X1oU7nKVZFtfq8Fg==} - engines: {node: '>=6'} + punycode@2.3.1: {} - /pure-rand@5.0.5: - resolution: {integrity: sha512-BwQpbqxSCBJVpamI6ydzcKqyFmnd5msMWUGvzXLm1aXvusbbgkbOto/EUPM00hjveJEaJtdbhUjKSzWRhQVkaw==} - dev: false + pure-rand@5.0.5: {} - /qs@6.11.0: - resolution: {integrity: sha512-MvjoMCJwEarSbUYk5O+nmoSzSutSsTwF85zcHPQ9OrlFoZOYIjaqBAJIqIXjptyD5vThxGq52Xu/MaJzRkIk4Q==} - engines: {node: '>=0.6'} + qs@6.11.0: dependencies: side-channel: 1.0.6 - /qs@6.12.1: - resolution: {integrity: sha512-zWmv4RSuB9r2mYQw3zxQuHWeU+42aKi1wWig/j4ele4ygELZ7PEO6MM7rim9oAQH2A5MWfsAVf/jPvTPgCbvUQ==} - engines: {node: '>=0.6'} + qs@6.12.1: dependencies: side-channel: 1.0.6 - dev: true - /qs@6.5.3: - resolution: {integrity: sha512-qxXIEh4pCGfHICj1mAJQ2/2XVZkjCDTcEgfoSQxc/fYivUZxTkk7L3bDBJSoNrEzXI17oUO5Dp07ktqE5KzczA==} - engines: {node: '>=0.6'} + qs@6.5.3: {} - /query-string@5.1.1: - resolution: {integrity: sha512-gjWOsm2SoGlgLEdAGt7a6slVOk9mGiXmPFMqrEhLQ68rhQuBnpfs3+EmlvqKyxnCo9/PPlF+9MtY02S1aFg+Jw==} - engines: {node: '>=0.10.0'} + query-string@5.1.1: dependencies: decode-uri-component: 0.2.2 object-assign: 4.1.1 strict-uri-encode: 1.1.0 - /queue-microtask@1.2.3: - resolution: {integrity: sha512-NuaNSa6flKT5JaSYQzJok04JzTL1CA6aGhv5rfLW3PgqA+M2ChpZQnAC8h8i4ZFkBS8X5RqkDBHA7r4hej3K9A==} + queue-microtask@1.2.3: {} - /quick-lru@4.0.1: - resolution: {integrity: sha512-ARhCpm70fzdcvNQfPoy49IaanKkTlRWF2JMzqhcJbhSFRZv7nPTvZJdcY7301IPmvW+/p0RgIWnQDLJxifsQ7g==} - engines: {node: '>=8'} - dev: true + quick-lru@4.0.1: {} - /quick-lru@5.1.1: - resolution: {integrity: sha512-WuyALRjWPDGtt/wzJiadO5AXY+8hZ80hVpe6MyivgraREW751X3SbhRvG3eLKOYN+8VEvqLcf3wdnt44Z4S4SA==} - engines: {node: '>=10'} + quick-lru@5.1.1: {} - /rambda@7.5.0: - resolution: {integrity: sha512-y/M9weqWAH4iopRd7EHDEQQvpFPHj1AA3oHozE9tfITHUtTR7Z9PSlIRRG2l1GuW7sefC1cXFfIcF+cgnShdBA==} - dev: true + rambda@7.5.0: {} - /randombytes@2.1.0: - resolution: {integrity: sha512-vYl3iOX+4CKUWuxGi9Ukhie6fsqXqS9FE2Zaic4tNFD2N2QQaXOMFbuKK4QmDHC0JO6B1Zp41J0LpT0oR68amQ==} + randombytes@2.1.0: dependencies: safe-buffer: 5.2.1 - /range-parser@1.2.1: - resolution: {integrity: sha512-Hrgsx+orqoygnmhFbKaHE6c296J+HTAQXoxEF6gNupROmmGJRoyzfG3ccAveqCBrwr/2yxQ5BVd/GTl5agOwSg==} - engines: {node: '>= 0.6'} + range-parser@1.2.1: {} - /raw-body@2.5.2: - resolution: {integrity: sha512-8zGqypfENjCIqGhgXToC8aB2r7YrBX+AQAfIPs/Mlk+BtPTztOvTS01NRW/3Eh60J+a48lt8qsCzirQ6loCVfA==} - engines: {node: '>= 0.8'} + raw-body@2.5.2: dependencies: bytes: 3.1.2 http-errors: 2.0.0 iconv-lite: 0.4.24 unpipe: 1.0.0 - /rc@1.2.8: - resolution: {integrity: sha512-y3bGgqKj3QBdxLbLkomlohkvsA8gdAiUQlSBJnBhfn+BPxg4bc62d8TcBW15wavDfgexCgccckhcZvywyQYPOw==} - hasBin: true + rc@1.2.8: dependencies: deep-extend: 0.6.0 ini: 1.3.8 minimist: 1.2.8 strip-json-comments: 2.0.1 - dev: false - /react-dom@18.3.1(react@18.3.1): - resolution: {integrity: sha512-5m4nQKp+rZRb09LNH59GM4BxTh9251/ylbKIbpe7TpGxfJ+9kv6BLkLBXIjjspbgbnIBNqlI23tRnTWT0snUIw==} - peerDependencies: - react: ^18.3.1 + react-dom@18.3.1(react@18.3.1): dependencies: loose-envify: 1.4.0 react: 18.3.1 scheduler: 0.23.2 - dev: false - /react-is@18.3.1: - resolution: {integrity: sha512-/LLMVyas0ljjAtoYiPqYiL8VWXzUUdThrmU5+n20DZv+a+ClRoevUzw5JxU+Ieh5/c87ytoTBV9G1FiKfNJdmg==} - dev: true + react-is@18.3.1: {} - /react@18.3.1: - resolution: {integrity: sha512-wS+hAgJShR0KhEvPJArfuPVN1+Hz1t0Y6n5jLrGQbkb4urgPE/0Rve+1kMB1v/oWgHgm4WIcV+i7F2pTVj+2iQ==} - engines: {node: '>=0.10.0'} + react@18.3.1: dependencies: loose-envify: 1.4.0 - dev: false - /read-pkg-up@1.0.1: - resolution: {integrity: sha512-WD9MTlNtI55IwYUS27iHh9tK3YoIVhxis8yKhLpTqWtml739uXc9NWTpxoHkfZf3+DkCCsXox94/VWZniuZm6A==} - engines: {node: '>=0.10.0'} + read-pkg-up@1.0.1: dependencies: find-up: 1.1.2 read-pkg: 1.1.0 - dev: false - /read-pkg-up@7.0.1: - resolution: {integrity: sha512-zK0TB7Xd6JpCLmlLmufqykGE+/TlOePD6qKClNW7hHDKFh/J7/7gCWGR7joEQEW1bKq3a3yUZSObOoWLFQ4ohg==} - engines: {node: '>=8'} + read-pkg-up@7.0.1: dependencies: find-up: 4.1.0 read-pkg: 5.2.0 type-fest: 0.8.1 - dev: true - /read-pkg@1.1.0: - resolution: {integrity: sha512-7BGwRHqt4s/uVbuyoeejRn4YmFnYZiFl4AuaeXHlgZf3sONF0SOGlxs2Pw8g6hCKupo08RafIO5YXFNOKTfwsQ==} - engines: {node: '>=0.10.0'} + read-pkg@1.1.0: dependencies: load-json-file: 1.1.0 normalize-package-data: 2.5.0 path-type: 1.1.0 - dev: false - /read-pkg@5.2.0: - resolution: {integrity: sha512-Ug69mNOpfvKDAc2Q8DRpMjjzdtrnv9HcSMX+4VsZxD1aZ6ZzrIE7rlzXBtWTyhULSMKg076AW6WR5iZpD0JiOg==} - engines: {node: '>=8'} + read-pkg@5.2.0: dependencies: '@types/normalize-package-data': 2.4.4 normalize-package-data: 2.5.0 parse-json: 5.2.0 type-fest: 0.6.0 - dev: true - /read-yaml-file@1.1.0: - resolution: {integrity: sha512-VIMnQi/Z4HT2Fxuwg5KrY174U1VdUIASQVWXXyqtNRtxSr9IYkn1rsI6Tb6HsrHCmB7gVpNwX6JxPTHcH6IoTA==} - engines: {node: '>=6'} + read-yaml-file@1.1.0: dependencies: graceful-fs: 4.2.11 js-yaml: 3.14.1 pify: 4.0.1 strip-bom: 3.0.0 - dev: true - /readable-stream@2.3.8: - resolution: {integrity: sha512-8p0AUk4XODgIewSi0l8Epjs+EVnWiK7NoDIEGU0HhE7+ZyY8D1IMY7odu5lRrFXGg71L15KG8QrPmum45RTtdA==} + readable-stream@2.3.8: dependencies: core-util-is: 1.0.3 inherits: 2.0.4 @@ -9288,87 +12308,54 @@ packages: safe-buffer: 5.1.2 string_decoder: 1.1.1 util-deprecate: 1.0.2 - dev: true - /readable-stream@3.6.2: - resolution: {integrity: sha512-9u/sniCrY3D5WdsERHzHE4G2YCXqoG5FTHUiCC4SIbr6XcLZBY05ya9EKjYek9O5xOAwjGq+1JdGBAS7Q9ScoA==} - engines: {node: '>= 6'} + readable-stream@3.6.2: dependencies: inherits: 2.0.4 string_decoder: 1.3.0 util-deprecate: 1.0.2 - /readdirp@3.6.0: - resolution: {integrity: sha512-hOS089on8RduqdbhvQ5Z37A0ESjsqz6qnRcffsMU3495FuTdqSm+7bhJ29JvIOsBDEEnan5DPu9t3To9VRlMzA==} - engines: {node: '>=8.10.0'} + readdirp@3.6.0: dependencies: picomatch: 2.3.1 - /rechoir@0.6.2: - resolution: {integrity: sha512-HFM8rkZ+i3zrV+4LQjwQ0W+ez98pApMGM3HUrN04j3CqzPOzl9nmP15Y8YXNm8QHGv/eacOVEjqhmWpkRV0NAw==} - engines: {node: '>= 0.10'} + rechoir@0.6.2: dependencies: resolve: 1.17.0 - dev: true - /recursive-readdir@2.2.3: - resolution: {integrity: sha512-8HrF5ZsXk5FAH9dgsx3BlUer73nIhuj+9OrQwEbLTPOBzGkL1lsFCR01am+v+0m2Cmbs1nP12hLDl5FA7EszKA==} - engines: {node: '>=6.0.0'} + recursive-readdir@2.2.3: dependencies: minimatch: 3.1.2 - dev: true - /redent@3.0.0: - resolution: {integrity: sha512-6tDA8g98We0zd0GvVeMT9arEOnTw9qM03L9cJXaCjrip1OO764RDBLBfrB4cwzNGDj5OA5ioymC9GkizgWJDUg==} - engines: {node: '>=8'} + redent@3.0.0: dependencies: indent-string: 4.0.0 strip-indent: 3.0.0 - dev: true - /reduce-flatten@2.0.0: - resolution: {integrity: sha512-EJ4UNY/U1t2P/2k6oqotuX2Cc3T6nxJwsM0N0asT7dhrtH1ltUxDn4NalSYmPE2rCkVpcf/X6R0wDwcFpzhd4w==} - engines: {node: '>=6'} - dev: true + reduce-flatten@2.0.0: {} - /regenerator-runtime@0.14.1: - resolution: {integrity: sha512-dYnhHh0nJoMfnkZs6GmmhFknAGRrLznOu5nc9ML+EJxGvrx6H7teuevqVqCuPcPK//3eDrrjQhehXVx9cnkGdw==} + regenerator-runtime@0.14.1: {} - /regexp.prototype.flags@1.5.2: - resolution: {integrity: sha512-NcDiDkTLuPR+++OCKB0nWafEmhg/Da8aUPLPMQbK+bxKKCm1/S5he+AqYa4PlMCVBalb4/yxIRub6qkEx5yJbw==} - engines: {node: '>= 0.4'} + regexp.prototype.flags@1.5.2: dependencies: call-bind: 1.0.7 define-properties: 1.2.1 es-errors: 1.3.0 set-function-name: 2.0.2 - dev: true - /release-zalgo@1.0.0: - resolution: {integrity: sha512-gUAyHVHPPC5wdqX/LG4LWtRYtgjxyX78oanFNTMMyFEfOqdC54s3eE82imuWKbOeqYht2CrNf64Qb8vgmmtZGA==} - engines: {node: '>=4'} + release-zalgo@1.0.0: dependencies: es6-error: 4.1.1 - dev: true - /req-cwd@2.0.0: - resolution: {integrity: sha512-ueoIoLo1OfB6b05COxAA9UpeoscNpYyM+BqYlA7H6LVF4hKGPXQQSSaD2YmvDVJMkk4UDpAHIeU1zG53IqjvlQ==} - engines: {node: '>=4'} + req-cwd@2.0.0: dependencies: req-from: 2.0.0 - dev: true - /req-from@2.0.0: - resolution: {integrity: sha512-LzTfEVDVQHBRfjOUMgNBA+V6DWsSnoeKzf42J7l0xa/B4jyPOuuF5MlNSmomLNGemWTnV2TIdjSSLnEn95fOQA==} - engines: {node: '>=4'} + req-from@2.0.0: dependencies: resolve-from: 3.0.0 - dev: true - /request@2.88.2: - resolution: {integrity: sha512-MsvtOrfG9ZcrOwAW+Qi+F6HbD0CWXEh9ou77uOb7FM2WPhwT7smM833PzanhJLsgXjN89Ir6V2PczXNnMpwKhw==} - engines: {node: '>= 6'} - deprecated: request has been deprecated, see https://github.com/request/request/issues/3142 + request@2.88.2: dependencies: aws-sign2: 0.7.0 aws4: 1.12.0 @@ -9391,159 +12378,98 @@ packages: tunnel-agent: 0.6.0 uuid: 3.4.0 - /require-directory@2.1.1: - resolution: {integrity: sha512-fGxEI7+wsG9xrvdjsrlmL22OMTTiHRwAMroiEeMgq8gzoLC/PQr7RsRDSTLUg/bZAZtF+TVIkHc6/4RIKrui+Q==} - engines: {node: '>=0.10.0'} + require-directory@2.1.1: {} - /require-from-string@1.2.1: - resolution: {integrity: sha512-H7AkJWMobeskkttHyhTVtS0fxpFLjxhbfMa6Bk3wimP7sdPRGL3EyCg3sAQenFfAe+xQ+oAc85Nmtvq0ROM83Q==} - engines: {node: '>=0.10.0'} - dev: false + require-from-string@1.2.1: {} - /require-from-string@2.0.2: - resolution: {integrity: sha512-Xf0nWe6RseziFMu+Ap9biiUbmplq6S9/p+7w7YXP/JBHhrUDDUhwa+vANyubuqfZWTveU//DYVGsDG7RKL/vEw==} - engines: {node: '>=0.10.0'} + require-from-string@2.0.2: {} - /require-main-filename@1.0.1: - resolution: {integrity: sha512-IqSUtOVP4ksd1C/ej5zeEh/BIP2ajqpn8c5x+q99gvcIG/Qf0cud5raVnE/Dwd0ua9TXYDoDc0RE5hBSdz22Ug==} - dev: false + require-main-filename@1.0.1: {} - /require-main-filename@2.0.0: - resolution: {integrity: sha512-NKN5kMDylKuldxYLSUfrbo5Tuzh4hd+2E8NPPX02mZtn1VuREQToYe/ZdlJy+J3uCpfaiGF05e7B8W0iXbQHmg==} - dev: true + require-main-filename@2.0.0: {} - /requireindex@1.2.0: - resolution: {integrity: sha512-L9jEkOi3ASd9PYit2cwRfyppc9NoABujTP8/5gFcbERmo5jUoAKovIC3fsF17pkTnGsrByysqX+Kxd2OTNI1ww==} - engines: {node: '>=0.10.5'} - dev: false + requireindex@1.2.0: {} - /resolve-alpn@1.2.1: - resolution: {integrity: sha512-0a1F4l73/ZFZOakJnQ3FvkJ2+gSTQWz/r2KE5OdDY0TxPm5h4GkqkWWfM47T7HsbnOtcJVEF4epCVy6u7Q3K+g==} + resolve-alpn@1.2.1: {} - /resolve-from@3.0.0: - resolution: {integrity: sha512-GnlH6vxLymXJNMBo7XP1fJIzBFbdYt49CuTwmB/6N53t+kMPRMFKz783LlQ4tv28XoQfMWinAJX6WCGf2IlaIw==} - engines: {node: '>=4'} - dev: true + resolve-from@3.0.0: {} - /resolve-from@4.0.0: - resolution: {integrity: sha512-pb/MYmXstAkysRFx8piNI1tGFNQIFA3vkE3Gq4EuA1dF6gHp/+vgZqsCGJapvy8N3Q+4o7FwvquPJcnZ7RYy4g==} - engines: {node: '>=4'} + resolve-from@4.0.0: {} - /resolve-from@5.0.0: - resolution: {integrity: sha512-qYg9KP24dD5qka9J47d0aVky0N+b4fTU89LN9iDnjB5waksiC49rvMB0PrUJQGoTmH50XPiqOvAjDfaijGxYZw==} - engines: {node: '>=8'} - dev: true + resolve-from@5.0.0: {} - /resolve-pkg-maps@1.0.0: - resolution: {integrity: sha512-seS2Tj26TBVOC2NIc2rOe2y2ZO7efxITtLZcGSOnHHNOQ7CkiUBfw0Iw2ck6xkIhPwLhKNLS8BO+hEpngQlqzw==} - dev: true + resolve-pkg-maps@1.0.0: {} - /resolve@1.1.7: - resolution: {integrity: sha512-9znBF0vBcaSN3W2j7wKvdERPwqTxSpCq+if5C0WoTCyV9n24rua28jeuQ2pL/HOf+yUe/Mef+H/5p60K0Id3bg==} - dev: true + resolve@1.1.7: {} - /resolve@1.17.0: - resolution: {integrity: sha512-ic+7JYiV8Vi2yzQGFWOkiZD5Z9z7O2Zhm9XMaTxdJExKasieFCr+yXZ/WmXsckHiKl12ar0y6XiXDx3m4RHn1w==} + resolve@1.17.0: dependencies: path-parse: 1.0.7 - /resolve@1.22.8: - resolution: {integrity: sha512-oKWePCxqpd6FlLvGV1VU0x7bkPmmCNolxzjMf4NczoDnQcIWrAF+cPtZn5i6n+RfD2d9i0tzpKnG6Yk168yIyw==} - hasBin: true + resolve@1.22.8: dependencies: is-core-module: 2.13.1 path-parse: 1.0.7 supports-preserve-symlinks-flag: 1.0.0 - /responselike@2.0.1: - resolution: {integrity: sha512-4gl03wn3hj1HP3yzgdI7d3lCkF95F21Pz4BPGvKHinyQzALR5CapwC8yIi0Rh58DEMQ/SguC03wFj2k0M/mHhw==} + responselike@2.0.1: dependencies: lowercase-keys: 2.0.0 - /restore-cursor@3.1.0: - resolution: {integrity: sha512-l+sSefzHpj5qimhFSE5a8nufZYAM3sBSVMAPtYkmC+4EH2anSGaEMXSD0izRQbu9nfyQ9y5JrVmp7E8oZrUjvA==} - engines: {node: '>=8'} + restore-cursor@3.1.0: dependencies: onetime: 5.1.2 signal-exit: 3.0.7 - dev: false - /reusify@1.0.4: - resolution: {integrity: sha512-U9nH88a3fc/ekCF1l0/UP1IosiuIjyTh7hBvXVMHYgVcfGvt897Xguj2UOLDeI5BG2m7/uwyaLVT6fbtCwTyzw==} - engines: {iojs: '>=1.0.0', node: '>=0.10.0'} + reusify@1.0.4: {} - /rimraf@2.7.1: - resolution: {integrity: sha512-uWjbaKIK3T1OSVptzX7Nl6PvQ3qAGtKEtVRjRuazjfL3Bx5eI409VZSqgND+4UNnmzLVdPj9FqFJNPqBZFve4w==} - hasBin: true + rimraf@2.7.1: dependencies: glob: 7.2.0 - dev: false - /rimraf@3.0.2: - resolution: {integrity: sha512-JZkJMZkAGFFPP2YqXZXPbMlMBgsxzE8ILs4lMIX/2o0L9UBw9O/Y3o6wFw/i9YLapcUJWwqbi3kdxIPdC62TIA==} - hasBin: true + rimraf@3.0.2: dependencies: glob: 7.2.0 - /ripemd160-min@0.0.6: - resolution: {integrity: sha512-+GcJgQivhs6S9qvLogusiTcS9kQUfgR75whKuy5jIhuiOfQuJ8fjqxV6EGD5duH1Y/FawFUMtMhyeq3Fbnib8A==} - engines: {node: '>=8'} - dev: false + ripemd160-min@0.0.6: {} - /ripemd160@2.0.2: - resolution: {integrity: sha512-ii4iagi25WusVoiC4B4lq7pbXfAp3D9v5CwfkY33vffw2+pkDjY1D8GaN7spsxvCSx8dkPqOZCEZyfxcmJG2IA==} + ripemd160@2.0.2: dependencies: hash-base: 3.1.0 inherits: 2.0.4 - /rlp@2.2.7: - resolution: {integrity: sha512-d5gdPmgQ0Z+AklL2NVXr/IoSjNZFfTVvQWzL/AM2AOcSzYP2xjlb0AC8YyCLc41MSNf6P6QVtjgPdmVtzb+4lQ==} - hasBin: true + rlp@2.2.7: dependencies: bn.js: 5.2.1 - /run-parallel@1.2.0: - resolution: {integrity: sha512-5l4VyZR86LZ/lDxZTR6jqL8AFE2S0IFLMP26AbjsLVADxHdhB/c0GUsH+y39UfCi3dzz8OlQuPmnaJOMoDHQBA==} + run-parallel@1.2.0: dependencies: queue-microtask: 1.2.3 - /rxjs@7.8.1: - resolution: {integrity: sha512-AA3TVj+0A2iuIoQkWEK/tqFjBq2j+6PO6Y0zJcvzLAFhEFIO3HL0vls9hWLncZbAAbK0mar7oZ4V079I/qPMxg==} + rxjs@7.8.1: dependencies: tslib: 2.6.2 - dev: false - /safe-array-concat@1.1.2: - resolution: {integrity: sha512-vj6RsCsWBCf19jIeHEfkRMw8DPiBb+DMXklQ/1SGDHOMlHdPUkZXFQ2YdplS23zESTijAcurb1aSgJA3AgMu1Q==} - engines: {node: '>=0.4'} + safe-array-concat@1.1.2: dependencies: call-bind: 1.0.7 get-intrinsic: 1.2.4 has-symbols: 1.0.3 isarray: 2.0.5 - dev: true - /safe-buffer@5.1.2: - resolution: {integrity: sha512-Gd2UZBJDkXlY7GbJxfsE8/nvKkUEU1G38c1siN6QP6a9PT9MmHB8GnpscSmMJSoF8LOIrt8ud/wPtojys4G6+g==} + safe-buffer@5.1.2: {} - /safe-buffer@5.2.1: - resolution: {integrity: sha512-rp3So07KcdmmKbGvgaNxQSJr7bGVSVk5S9Eq1F+ppbRo70+YeaDxkw5Dd8NPN+GD6bjnYm2VuPuCXmpuYvmCXQ==} + safe-buffer@5.2.1: {} - /safe-regex-test@1.0.3: - resolution: {integrity: sha512-CdASjNJPvRa7roO6Ra/gLYBTzYzzPyyBXxIMdGW3USQLyjWEls2RgW5UBTXaQVp+OrpeCK3bLem8smtmheoRuw==} - engines: {node: '>= 0.4'} + safe-regex-test@1.0.3: dependencies: call-bind: 1.0.7 es-errors: 1.3.0 is-regex: 1.1.4 - dev: true - /safer-buffer@2.1.2: - resolution: {integrity: sha512-YZo3K82SD7Riyi0E1EQPojLz7kpepnSQI9IyPbHHg1XXXevb5dJI7tpyN2ADxGcQbHG7vcyRHk0cbwqcQriUtg==} + safer-buffer@2.1.2: {} - /sc-istanbul@0.4.6: - resolution: {integrity: sha512-qJFF/8tW/zJsbyfh/iT/ZM5QNHE3CXxtLJbZsL+CzdJLBsPD7SedJZoUA4d8iAcN2IoMp/Dx80shOOd2x96X/g==} - hasBin: true + sc-istanbul@0.4.6: dependencies: abbrev: 1.0.9 async: 1.5.2 @@ -9559,46 +12485,28 @@ packages: supports-color: 3.2.3 which: 1.3.1 wordwrap: 1.0.0 - dev: true - /scheduler@0.23.2: - resolution: {integrity: sha512-UOShsPwz7NrMUqhR6t0hWjFduvOzbtv7toDH1/hIrfRNIDBnnBWd0CwJTGvTpngVlmwGCdP9/Zl/tVrDqcuYzQ==} + scheduler@0.23.2: dependencies: loose-envify: 1.4.0 - dev: false - /scrypt-js@2.0.4: - resolution: {integrity: sha512-4KsaGcPnuhtCZQCxFxN3GVYIhKFPTdLd8PLC552XwbMndtD0cjRFAhDuuydXQ0h08ZfPgzqe6EKHozpuH74iDw==} - dev: false + scrypt-js@2.0.4: {} - /scrypt-js@3.0.1: - resolution: {integrity: sha512-cdwTTnqPu0Hyvf5in5asVdZocVDTNRmR7XEcJuIzMjJeSHybHl7vpB66AzwTaIg6CLSbtjcxc8fqcySfnTkccA==} + scrypt-js@3.0.1: {} - /secp256k1@4.0.3: - resolution: {integrity: sha512-NLZVf+ROMxwtEj3Xa562qgv2BK5e2WNmXPiOdVIPLgs6lyTzMvBq0aWTYMI5XCP9jZMVKOcqZLw/Wc4vDkuxhA==} - engines: {node: '>=10.0.0'} - requiresBuild: true + secp256k1@4.0.3: dependencies: elliptic: 6.5.5 node-addon-api: 2.0.2 node-gyp-build: 4.8.1 - /semver@5.7.2: - resolution: {integrity: sha512-cBznnQ9KjJqU67B52RMC65CMarK2600WFnbkcaiwWq3xy/5haFJlshgnpjovMVJ+Hff49d8GEn0b87C5pDQ10g==} - hasBin: true + semver@5.7.2: {} - /semver@6.3.1: - resolution: {integrity: sha512-BR7VvDCVHO+q2xBEWskxS6DJE1qRnb7DxzUrogb71CWoSficBxYsiAGd+Kl0mmq/MprG9yArRkyrQxTO6XjMzA==} - hasBin: true + semver@6.3.1: {} - /semver@7.6.2: - resolution: {integrity: sha512-FNAIBWCx9qcRhoHcgcJ0gvU7SN1lYU2ZXuSfl04bSC5OpvDHFyJCjdNHomPXxjQlCBU67YW64PzY7/VIEH7F2w==} - engines: {node: '>=10'} - hasBin: true + semver@7.6.2: {} - /send@0.18.0: - resolution: {integrity: sha512-qqWzuOjSFOuqPjFe4NOsMLafToQQwBSOEpS+FwEt3A2V3vKubTquT3vmLTQpFgMXp8AlFWFuP1qKaJZOtPpVXg==} - engines: {node: '>= 0.8.0'} + send@0.18.0: dependencies: debug: 2.6.9 depd: 2.0.0 @@ -9616,21 +12524,16 @@ packages: transitivePeerDependencies: - supports-color - /sentence-case@2.1.1: - resolution: {integrity: sha512-ENl7cYHaK/Ktwk5OTD+aDbQ3uC8IByu/6Bkg+HDv8Mm+XnBnppVNalcfJTNsp1ibstKh030/JKQQWglDvtKwEQ==} + sentence-case@2.1.1: dependencies: no-case: 2.3.2 upper-case-first: 1.1.2 - dev: false - /serialize-javascript@6.0.0: - resolution: {integrity: sha512-Qr3TosvguFt8ePWqsvRfrKyQXIiW+nGbYpy8XK24NQHE83caxWt+mIymTT19DGFbNWNLfEwsrkSmN64lVWB9ag==} + serialize-javascript@6.0.0: dependencies: randombytes: 2.1.0 - /serve-static@1.15.0: - resolution: {integrity: sha512-XGuRDNjXUijsUL0vl6nSD7cwURuzEgglbOaFuZM9g3kwDXOWVTck0jLzjPzGD+TazWbboZYu52/9/XPdUgne9g==} - engines: {node: '>= 0.8.0'} + serve-static@1.15.0: dependencies: encodeurl: 1.0.2 escape-html: 1.0.3 @@ -9639,9 +12542,7 @@ packages: transitivePeerDependencies: - supports-color - /servify@0.1.12: - resolution: {integrity: sha512-/xE6GvsKKqyo1BAY+KxOWXcLpPsUUyji7Qg3bVD7hh1eRze5bR1uYiuDA/k3Gof1s9BTzQZEJK8sNcNGFIzeWw==} - engines: {node: '>=6'} + servify@0.1.12: dependencies: body-parser: 1.20.2 cors: 2.8.5 @@ -9651,12 +12552,9 @@ packages: transitivePeerDependencies: - supports-color - /set-blocking@2.0.0: - resolution: {integrity: sha512-KiKBS8AnWGEyLzofFfmvKwpdPzqiy16LvQfK3yv/fVH7Bj13/wl3JSR1J+rfgRE9q7xUJK4qvgS8raSOeLUehw==} + set-blocking@2.0.0: {} - /set-function-length@1.2.2: - resolution: {integrity: sha512-pgRc4hJ4/sNjWCSS9AmnS40x3bNMDTknHgL5UaMBTMyJnU90EgWh1Rz+MC9eFu4BuN/UwZjKQuY/1v3rM7HMfg==} - engines: {node: '>= 0.4'} + set-function-length@1.2.2: dependencies: define-data-property: 1.1.4 es-errors: 1.3.0 @@ -9665,120 +12563,80 @@ packages: gopd: 1.0.1 has-property-descriptors: 1.0.2 - /set-function-name@2.0.2: - resolution: {integrity: sha512-7PGFlmtwsEADb0WYyvCMa1t+yke6daIG4Wirafur5kcf+MhUnPms1UeR0CKQdTZD81yESwMHbtn+TR+dMviakQ==} - engines: {node: '>= 0.4'} + set-function-name@2.0.2: dependencies: define-data-property: 1.1.4 es-errors: 1.3.0 functions-have-names: 1.2.3 has-property-descriptors: 1.0.2 - dev: true - /setimmediate@1.0.4: - resolution: {integrity: sha512-/TjEmXQVEzdod/FFskf3o7oOAsGhHf2j1dZqRFbDzq4F3mvvxflIIi4Hd3bLQE9y/CpwqfSQam5JakI/mi3Pog==} - dev: false + setimmediate@1.0.4: {} - /setimmediate@1.0.5: - resolution: {integrity: sha512-MATJdZp8sLqDl/68LfQmbP8zKPLQNV6BIZoIgrscFDQ+RsvK/BxeDQOgyxKKoh0y/8h3BqVFnCqQ/gd+reiIXA==} + setimmediate@1.0.5: {} - /setprototypeof@1.2.0: - resolution: {integrity: sha512-E5LDX7Wrp85Kil5bhZv46j8jOeboKq5JMmYM3gVGdGH8xFpPWXUMsNrlODCrkoxMEeNi/XZIwuRvY4XNwYMJpw==} + setprototypeof@1.2.0: {} - /sha.js@2.4.11: - resolution: {integrity: sha512-QMEp5B7cftE7APOjk5Y6xgrbWu+WkLVQwk8JNjZ8nKRciZaByEW6MubieAiToS7+dwvrjGhH8jRXz3MVd0AYqQ==} - hasBin: true + sha.js@2.4.11: dependencies: inherits: 2.0.4 safe-buffer: 5.2.1 - /sha1@1.1.1: - resolution: {integrity: sha512-dZBS6OrMjtgVkopB1Gmo4RQCDKiZsqcpAQpkV/aaj+FCrCg8r4I4qMkDPQjBgLIxlmu9k4nUbWq6ohXahOneYA==} + sha1@1.1.1: dependencies: charenc: 0.0.2 crypt: 0.0.2 - dev: true - /sha3@2.1.4: - resolution: {integrity: sha512-S8cNxbyb0UGUM2VhRD4Poe5N58gJnJsLJ5vC7FYWGUmGhcsj4++WaIOBFVDxlG0W3To6xBuiRh+i0Qp2oNCOtg==} + sha3@2.1.4: dependencies: buffer: 6.0.3 - /shebang-command@1.2.0: - resolution: {integrity: sha512-EV3L1+UQWGor21OmnvojK36mhg+TyIKDh3iFBKBohr5xeXIhNBcx8oWdgkTEEQ+BEFFYdLRuqMfd5L84N1V5Vg==} - engines: {node: '>=0.10.0'} + shebang-command@1.2.0: dependencies: shebang-regex: 1.0.0 - dev: true - /shebang-command@2.0.0: - resolution: {integrity: sha512-kHxr2zZpYtdmrN1qDjrrX/Z1rR1kG8Dx+gkpK1G4eXmvXswmcE1hTWBWYUzlraYw1/yZp6YuDY77YtvbN0dmDA==} - engines: {node: '>=8'} + shebang-command@2.0.0: dependencies: shebang-regex: 3.0.0 - /shebang-regex@1.0.0: - resolution: {integrity: sha512-wpoSFAxys6b2a2wHZ1XpDSgD7N9iVjg29Ph9uV/uaP9Ex/KXlkTZTeddxDPSYQpgvzKLGJke2UU0AzoGCjNIvQ==} - engines: {node: '>=0.10.0'} - dev: true + shebang-regex@1.0.0: {} - /shebang-regex@3.0.0: - resolution: {integrity: sha512-7++dFhtcx3353uBaq8DDR4NuxBetBzC7ZQOhmTQInHEd6bSrXdiEyzCvG07Z44UYdLShWUyXt5M/yhz8ekcb1A==} - engines: {node: '>=8'} + shebang-regex@3.0.0: {} - /shelljs@0.8.5: - resolution: {integrity: sha512-TiwcRcrkhHvbrZbnRcFYMLl30Dfov3HKqzp5tO5b4pt6G/SezKcYhmDg15zXVBswHmctSAQKznqNW2LO5tTDow==} - engines: {node: '>=4'} - hasBin: true + shelljs@0.8.5: dependencies: glob: 7.2.0 interpret: 1.4.0 rechoir: 0.6.2 - dev: true - /side-channel@1.0.6: - resolution: {integrity: sha512-fDW/EZ6Q9RiO8eFG8Hj+7u/oW+XrPTIChwCOM2+th2A6OblDtYYIpve9m+KvI9Z4C9qSEXlaGR6bTEYHReuglA==} - engines: {node: '>= 0.4'} + side-channel@1.0.6: dependencies: call-bind: 1.0.7 es-errors: 1.3.0 get-intrinsic: 1.2.4 object-inspect: 1.13.1 - /signal-exit@3.0.7: - resolution: {integrity: sha512-wnD2ZE+l+SPC/uoS0vXeE9L1+0wuaMqKlfz9AMUo38JsyLSBWSFcHR1Rri62LZc12vLr1gb3jl7iwQhgwpAbGQ==} + signal-exit@3.0.7: {} - /simple-concat@1.0.1: - resolution: {integrity: sha512-cSFtAPtRhljv69IK0hTVZQ+OfE9nePi/rtJmw5UjHeVyVroEqJXP1sFztKUy1qU+xvz3u/sfYJLa947b7nAN2Q==} + simple-concat@1.0.1: {} - /simple-get@2.8.2: - resolution: {integrity: sha512-Ijd/rV5o+mSBBs4F/x9oDPtTx9Zb6X9brmnXvMW4J7IR15ngi9q5xxqWBKU744jTZiaXtxaPL7uHG6vtN8kUkw==} + simple-get@2.8.2: dependencies: decompress-response: 3.3.0 once: 1.4.0 simple-concat: 1.0.1 - /simple-get@4.0.1: - resolution: {integrity: sha512-brv7p5WgH0jmQJr1ZDDfKDOSeWWg+OVypG99A/5vYGPqJ6pxiaHLy8nxtFjBA7oMa01ebA9gfh1uMCFqOuXxvA==} + simple-get@4.0.1: dependencies: decompress-response: 6.0.0 once: 1.4.0 simple-concat: 1.0.1 - dev: false - /sinon-chai@3.7.0(chai@4.4.1)(sinon@9.2.4): - resolution: {integrity: sha512-mf5NURdUaSdnatJx3uhoBOrY9dtL19fiOtAdT1Azxg3+lNJFiuN0uzaU3xX1LeAfL17kHQhTAJgpsfhbMJMY2g==} - peerDependencies: - chai: ^4.0.0 - sinon: '>=4.0.0' + sinon-chai@3.7.0(chai@4.4.1)(sinon@9.2.4): dependencies: chai: 4.4.1 sinon: 9.2.4 - dev: true - /sinon@9.2.4: - resolution: {integrity: sha512-zljcULZQsJxVra28qIAL6ow1Z9tpattkCTEJR4RBP3TGc00FcttsP5pK284Nas5WjMZU5Yzy3kAIp3B3KRf5Yg==} - deprecated: 16.1.1 + sinon@9.2.4: dependencies: '@sinonjs/commons': 1.8.6 '@sinonjs/fake-timers': 6.0.1 @@ -9786,29 +12644,18 @@ packages: diff: 4.0.2 nise: 4.1.0 supports-color: 7.2.0 - dev: true - /sisteransi@1.0.5: - resolution: {integrity: sha512-bLGGlR1QxBcynn2d5YmDX4MGjlZvy2MRBDRNHLJ8VI6l6+9FUiyTFNJ0IveOSP0bcXgVDPRcfGqA0pjaqUpfVg==} - dev: true + sisteransi@1.0.5: {} - /slash@3.0.0: - resolution: {integrity: sha512-g9Q1haeby36OSStwb4ntCGGGaKsaVSjQ68fBxoQcutl5fS1vuY18H3wSt3jFyFtrkx+Kz0V1G85A4MyAdDMi2Q==} - engines: {node: '>=8'} + slash@3.0.0: {} - /slice-ansi@4.0.0: - resolution: {integrity: sha512-qMCMfhY040cVHT43K9BFygqYbUPFZKHOg7K73mtTWJRb8pyP3fzf4Ixd5SzdEJQ6MRUg/WBnOLxghZtKKurENQ==} - engines: {node: '>=10'} + slice-ansi@4.0.0: dependencies: ansi-styles: 4.3.0 astral-regex: 2.0.0 is-fullwidth-code-point: 3.0.0 - dev: false - /smartwrap@2.0.2: - resolution: {integrity: sha512-vCsKNQxb7PnCNd2wY1WClWifAc2lwqsG8OaswpJkVJsvMGcnEntdTCDajZCkk93Ay1U3t/9puJmb525Rg5MZBA==} - engines: {node: '>=6'} - hasBin: true + smartwrap@2.0.2: dependencies: array.prototype.flat: 1.3.2 breakword: 1.0.6 @@ -9816,29 +12663,20 @@ packages: strip-ansi: 6.0.1 wcwidth: 1.0.1 yargs: 15.4.1 - dev: true - /snake-case@2.1.0: - resolution: {integrity: sha512-FMR5YoPFwOLuh4rRz92dywJjyKYZNLpMn1R5ujVpIYkbA9p01fq8RMg0FkO4M+Yobt4MjHeLTJVm5xFFBHSV2Q==} + snake-case@2.1.0: dependencies: no-case: 2.3.2 - dev: false - /solc@0.4.26: - resolution: {integrity: sha512-o+c6FpkiHd+HPjmjEVpQgH7fqZ14tJpXhho+/bQXlXbliLIS/xjXb42Vxh+qQY1WCSTMQ0+a5vR9vi0MfhU6mA==} - hasBin: true + solc@0.4.26: dependencies: fs-extra: 0.30.0 memorystream: 0.3.1 require-from-string: 1.2.1 semver: 5.7.2 yargs: 4.8.1 - dev: false - /solc@0.7.3(debug@4.3.4): - resolution: {integrity: sha512-GAsWNAjGzIDg7VxzP6mPjdurby3IkGCjQcM8GFYZT6RyaoUZKmMU6Y7YwG+tFGhv7dwZ8rmR4iwFDrrD99JwqA==} - engines: {node: '>=8.0.0'} - hasBin: true + solc@0.7.3(debug@4.3.4): dependencies: command-exists: 1.2.9 commander: 3.0.2 @@ -9851,11 +12689,8 @@ packages: tmp: 0.0.33 transitivePeerDependencies: - debug - dev: false - /solhint@3.6.2(typescript@5.0.4): - resolution: {integrity: sha512-85EeLbmkcPwD+3JR7aEMKsVC9YrRSxd4qkXuMzrlf7+z2Eqdfm1wHWq1ffTuo5aDhoZxp2I9yF3QkxZOxOL7aQ==} - hasBin: true + solhint@3.6.2(typescript@5.0.4): dependencies: '@solidity-parser/parser': 0.16.2 ajv: 6.12.6 @@ -9878,13 +12713,8 @@ packages: prettier: 2.8.8 transitivePeerDependencies: - typescript - dev: false - /solidity-coverage@0.8.12(hardhat@packages+hardhat-core): - resolution: {integrity: sha512-8cOB1PtjnjFRqOgwFiD8DaUsYJtVJ6+YdXQtSZDrLGf8cdhhh8xzTtGzVTGeBf15kTv0v7lYPJlV/az7zLEPJw==} - hasBin: true - peerDependencies: - hardhat: ^2.11.0 + solidity-coverage@0.8.12(hardhat@packages+hardhat-core): dependencies: '@ethersproject/abi': 5.7.0 '@solidity-parser/parser': 0.18.0 @@ -9906,12 +12736,8 @@ packages: semver: 7.6.2 shelljs: 0.8.5 web3-utils: 1.10.4 - dev: true - /solpp@0.11.5: - resolution: {integrity: sha512-LjzCGMrTDXtera2C4mbQGZSpBznP+o3/82L2CneAAMNbm+t4xPsvfrgJkIaY+IZ5YLrB8IXn7cYthwHMKvAWnQ==} - engines: {node: '>=8.15.1'} - hasBin: true + solpp@0.11.5: dependencies: antlr4: 4.8.0 axios: 0.21.4 @@ -9924,31 +12750,20 @@ packages: semver: 5.7.2 transitivePeerDependencies: - debug - dev: false - /source-map-support@0.5.21: - resolution: {integrity: sha512-uBHU3L3czsIyYXKX88fdrGovxdSCoTGDRZ6SYXtSRxLZUzHg5P/66Ht6uoUlHu9EZod+inXhKo3qQgwXUT/y1w==} + source-map-support@0.5.21: dependencies: buffer-from: 1.1.2 source-map: 0.6.1 - dev: false - /source-map@0.2.0: - resolution: {integrity: sha512-CBdZ2oa/BHhS4xj5DlhjWNHcan57/5YuvfdLf17iVmIpd9KRm+DFLmC6nBNj+6Ua7Kt3TmOjDpQT1aTYOQtoUA==} - engines: {node: '>=0.8.0'} - requiresBuild: true + source-map@0.2.0: dependencies: amdefine: 1.0.1 - dev: true optional: true - /source-map@0.6.1: - resolution: {integrity: sha512-UjgapumWlbMhkBgzT7Ykc5YXUT46F0iKu8SGXq0bcwP5dz/h0Plj6enJqjz1Zbq2l5WaqYnrVbwWOWMyF3F47g==} - engines: {node: '>=0.10.0'} + source-map@0.6.1: {} - /spawn-wrap@2.0.0: - resolution: {integrity: sha512-EeajNjfN9zMnULLwhZZQU3GWBoFNkbngTUPfaawT4RkMiviTxcX0qfhVbGey39mfctfDHkWtuecgQ8NJcyQWHg==} - engines: {node: '>=8'} + spawn-wrap@2.0.0: dependencies: foreground-child: 2.0.0 is-windows: 1.0.2 @@ -9956,47 +12771,33 @@ packages: rimraf: 3.0.2 signal-exit: 3.0.7 which: 2.0.2 - dev: true - /spawndamnit@2.0.0: - resolution: {integrity: sha512-j4JKEcncSjFlqIwU5L/rp2N5SIPsdxaRsIv678+TZxZ0SRDJTm8JrxJMjE/XuiEZNEir3S8l0Fa3Ke339WI4qA==} + spawndamnit@2.0.0: dependencies: cross-spawn: 5.1.0 signal-exit: 3.0.7 - dev: true - /spdx-correct@3.2.0: - resolution: {integrity: sha512-kN9dJbvnySHULIluDHy32WHRUu3Og7B9sbY7tsFLctQkIqnMh3hErYgdMjTYuqmcXX+lK5T1lnUt3G7zNswmZA==} + spdx-correct@3.2.0: dependencies: spdx-expression-parse: 3.0.1 spdx-license-ids: 3.0.17 - /spdx-exceptions@2.5.0: - resolution: {integrity: sha512-PiU42r+xO4UbUS1buo3LPJkjlO7430Xn5SVAhdpzzsPHsjbYVflnnFdATgabnLude+Cqu25p6N+g2lw/PFsa4w==} + spdx-exceptions@2.5.0: {} - /spdx-expression-parse@3.0.1: - resolution: {integrity: sha512-cbqHunsQWnJNE6KhVSMsMeH5H/L9EpymbzqTQ3uLwNCLZ1Q481oWaofqH7nO6V07xlXwY6PhQdQ2IedWx/ZK4Q==} + spdx-expression-parse@3.0.1: dependencies: spdx-exceptions: 2.5.0 spdx-license-ids: 3.0.17 - /spdx-license-ids@3.0.17: - resolution: {integrity: sha512-sh8PWc/ftMqAAdFiBu6Fy6JUOYjqDJBJvIhpfDMyHrr0Rbp5liZqd4TjtQ/RgfLjKFZb+LMx5hpml5qOWy0qvg==} + spdx-license-ids@3.0.17: {} - /split2@3.2.2: - resolution: {integrity: sha512-9NThjpgZnifTkJpzTZ7Eue85S49QwpNhZTq6GRJwObb6jnLFNGB7Qm73V5HewTROPyxD0C29xqmaI68bQtV+hg==} + split2@3.2.2: dependencies: readable-stream: 3.6.2 - dev: true - /sprintf-js@1.0.3: - resolution: {integrity: sha512-D9cPgkvLlV3t3IzL0D0YLvGA9Ahk4PcvVwUbN0dSGr1aP0Nrt4AEnTUbuGvquEC0mA64Gqt1fzirlRs5ibXx8g==} - dev: true + sprintf-js@1.0.3: {} - /sshpk@1.18.0: - resolution: {integrity: sha512-2p2KJZTSqQ/I3+HX42EpYOa2l3f8Erv8MWKsy2I9uf4wA7yFIkXRffYdsx86y6z4vHtV8u7g+pPlr8/4ouAxsQ==} - engines: {node: '>=0.10.0'} - hasBin: true + sshpk@1.18.0: dependencies: asn1: 0.2.6 assert-plus: 1.0.0 @@ -10008,205 +12809,128 @@ packages: safer-buffer: 2.1.2 tweetnacl: 0.14.5 - /stacktrace-parser@0.1.10: - resolution: {integrity: sha512-KJP1OCML99+8fhOHxwwzyWrlUuVX5GQ0ZpJTd1DFXhdkrvg1szxfHhawXUZ3g9TkXORQd4/WG68jMlQZ2p8wlg==} - engines: {node: '>=6'} + stacktrace-parser@0.1.10: dependencies: type-fest: 0.7.1 - dev: false - /statuses@2.0.1: - resolution: {integrity: sha512-RwNA9Z/7PrK06rYLIzFMlaF+l73iwpzsqRIFgbMLbTcLD6cOao82TaWefPXQvB2fOC4AjuYSEndS7N/mTCbkdQ==} - engines: {node: '>= 0.8'} + statuses@2.0.1: {} - /stream-transform@2.1.3: - resolution: {integrity: sha512-9GHUiM5hMiCi6Y03jD2ARC1ettBXkQBoQAe7nJsPknnI0ow10aXjTnew8QtYQmLjzn974BnmWEAJgCY6ZP1DeQ==} + stream-transform@2.1.3: dependencies: mixme: 0.5.10 - dev: true - /strict-uri-encode@1.1.0: - resolution: {integrity: sha512-R3f198pcvnB+5IpnBlRkphuE9n46WyVl8I39W/ZUTZLz4nqSP/oLYUrcnJrw462Ds8he4YKMov2efsTIw1BDGQ==} - engines: {node: '>=0.10.0'} + strict-uri-encode@1.1.0: {} - /string-format@2.0.0: - resolution: {integrity: sha512-bbEs3scLeYNXLecRRuk6uJxdXUSj6le/8rNPHChIJTn2V79aXVTR1EH2OH5zLKKoz0V02fOUKZZcw01pLUShZA==} - dev: true + string-format@2.0.0: {} - /string-width@1.0.2: - resolution: {integrity: sha512-0XsVpQLnVCXHJfyEs8tC0zpTVIr5PKKsQtkT29IwupnPTjtPmQ3xT/4yCREF9hYkV/3M3kzcUTSAZT6a6h81tw==} - engines: {node: '>=0.10.0'} + string-width@1.0.2: dependencies: code-point-at: 1.1.0 is-fullwidth-code-point: 1.0.0 strip-ansi: 3.0.1 - dev: false - /string-width@2.1.1: - resolution: {integrity: sha512-nOqH59deCq9SRHlxq1Aw85Jnt4w6KvLKqWVik6oA9ZklXLNIOlqg4F2yrT1MVaTjAqvVwdfeZ7w7aCvJD7ugkw==} - engines: {node: '>=4'} + string-width@2.1.1: dependencies: is-fullwidth-code-point: 2.0.0 strip-ansi: 4.0.0 - dev: true - /string-width@4.2.3: - resolution: {integrity: sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g==} - engines: {node: '>=8'} + string-width@4.2.3: dependencies: emoji-regex: 8.0.0 is-fullwidth-code-point: 3.0.0 strip-ansi: 6.0.1 - /string.prototype.trim@1.2.9: - resolution: {integrity: sha512-klHuCNxiMZ8MlsOihJhJEBJAiMVqU3Z2nEXWfWnIqjN0gEFS9J9+IxKozWWtQGcgoa1WUZzLjKPTr4ZHNFTFxw==} - engines: {node: '>= 0.4'} + string.prototype.trim@1.2.9: dependencies: call-bind: 1.0.7 define-properties: 1.2.1 es-abstract: 1.23.3 es-object-atoms: 1.0.0 - dev: true - /string.prototype.trimend@1.0.8: - resolution: {integrity: sha512-p73uL5VCHCO2BZZ6krwwQE3kCzM7NKmis8S//xEC6fQonchbum4eP6kR4DLEjQFO3Wnj3Fuo8NM0kOSjVdHjZQ==} + string.prototype.trimend@1.0.8: dependencies: call-bind: 1.0.7 define-properties: 1.2.1 es-object-atoms: 1.0.0 - dev: true - /string.prototype.trimstart@1.0.8: - resolution: {integrity: sha512-UXSH262CSZY1tfu3G3Secr6uGLCFVPMhIqHjlgCUtCCcgihYc/xKs9djMTMUOb2j1mVSeU8EU6NWc/iQKU6Gfg==} - engines: {node: '>= 0.4'} + string.prototype.trimstart@1.0.8: dependencies: call-bind: 1.0.7 define-properties: 1.2.1 es-object-atoms: 1.0.0 - dev: true - /string_decoder@1.1.1: - resolution: {integrity: sha512-n/ShnvDi6FHbbVfviro+WojiFzv+s8MPMHBczVePfUpDJLwoLT0ht1l4YwBCbi8pJAveEEdnkHyPyTP/mzRfwg==} + string_decoder@1.1.1: dependencies: safe-buffer: 5.1.2 - dev: true - /string_decoder@1.3.0: - resolution: {integrity: sha512-hkRX8U1WjJFd8LsDJ2yQ/wWWxaopEsABU1XfkM8A+j0+85JAGppt16cr1Whg6KIbb4okU6Mql6BOj+uup/wKeA==} + string_decoder@1.3.0: dependencies: safe-buffer: 5.2.1 - /strip-ansi@0.1.1: - resolution: {integrity: sha512-behete+3uqxecWlDAm5lmskaSaISA+ThQ4oNNBDTBJt0x2ppR6IPqfZNuj6BLaLJ/Sji4TPZlcRyOis8wXQTLg==} - engines: {node: '>=0.8.0'} - hasBin: true - dev: true + strip-ansi@0.1.1: {} - /strip-ansi@3.0.1: - resolution: {integrity: sha512-VhumSSbBqDTP8p2ZLKj40UjBCV4+v8bUSEpUb4KjRgWk9pbqGF4REFj6KEagidb2f/M6AzC0EmFyDNGaw9OCzg==} - engines: {node: '>=0.10.0'} + strip-ansi@3.0.1: dependencies: ansi-regex: 2.1.1 - dev: false - /strip-ansi@4.0.0: - resolution: {integrity: sha512-4XaJ2zQdCzROZDivEVIDPkcQn8LMFSa8kj8Gxb/Lnwzv9A8VctNZ+lfivC/sV3ivW8ElJTERXZoPBRrZKkNKow==} - engines: {node: '>=4'} + strip-ansi@4.0.0: dependencies: ansi-regex: 3.0.1 - /strip-ansi@6.0.1: - resolution: {integrity: sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A==} - engines: {node: '>=8'} + strip-ansi@6.0.1: dependencies: ansi-regex: 5.0.1 - /strip-bom@2.0.0: - resolution: {integrity: sha512-kwrX1y7czp1E69n2ajbG65mIo9dqvJ+8aBQXOGVxqwvNbsXdFM6Lq37dLAY3mknUwru8CfcCbfOLL/gMo+fi3g==} - engines: {node: '>=0.10.0'} + strip-bom@2.0.0: dependencies: is-utf8: 0.2.1 - dev: false - /strip-bom@3.0.0: - resolution: {integrity: sha512-vavAMRXOgBVNF6nyEEmL3DBK19iRpDcoIwW+swQ+CbGiu7lju6t+JklA1MHweoWtadgt4ISVUsXLyDq34ddcwA==} - engines: {node: '>=4'} - dev: true + strip-bom@3.0.0: {} - /strip-bom@4.0.0: - resolution: {integrity: sha512-3xurFv5tEgii33Zi8Jtp55wEIILR9eh34FAW00PZf+JnSsTmV/ioewSgQl97JHvgjoRGwPShsWm+IdrxB35d0w==} - engines: {node: '>=8'} - dev: true + strip-bom@4.0.0: {} - /strip-hex-prefix@1.0.0: - resolution: {integrity: sha512-q8d4ue7JGEiVcypji1bALTos+0pWtyGlivAWyPuTkHzuTCJqrK9sWxYQZUq6Nq3cuyv3bm734IhHvHtGGURU6A==} - engines: {node: '>=6.5.0', npm: '>=3'} + strip-hex-prefix@1.0.0: dependencies: is-hex-prefixed: 1.0.0 - /strip-indent@2.0.0: - resolution: {integrity: sha512-RsSNPLpq6YUL7QYy44RnPVTn/lcVZtb48Uof3X5JLbF4zD/Gs7ZFDv2HWol+leoQN2mT86LAzSshGfkTlSOpsA==} - engines: {node: '>=4'} - dev: false + strip-indent@2.0.0: {} - /strip-indent@3.0.0: - resolution: {integrity: sha512-laJTa3Jb+VQpaC6DseHhF7dXVqHTfJPCRDaEbid/drOhgitgYku/letMUqOXFoWV0zIIUbjpdH2t+tYj4bQMRQ==} - engines: {node: '>=8'} + strip-indent@3.0.0: dependencies: min-indent: 1.0.1 - dev: true - /strip-json-comments@2.0.1: - resolution: {integrity: sha512-4gB8na07fecVVkOI6Rs4e7T6NOTki5EmL7TUduTs6bu3EdnSycntVJ4re8kgZA+wx9IueI2Y11bfbgwtzuE0KQ==} - engines: {node: '>=0.10.0'} - dev: false + strip-json-comments@2.0.1: {} - /strip-json-comments@3.1.1: - resolution: {integrity: sha512-6fPc+R4ihwqP6N/aIv2f1gMH8lOVtWQHoqC4yK6oSDVVocumAsfCqjkXnqiYMhmMwS/mEHLp7Vehlt3ql6lEig==} - engines: {node: '>=8'} + strip-json-comments@3.1.1: {} - /supports-color@3.2.3: - resolution: {integrity: sha512-Jds2VIYDrlp5ui7t8abHN2bjAu4LV/q4N2KivFPpGH0lrka0BMq/33AmECUXlKPcHigkNaqfXRENFju+rlcy+A==} - engines: {node: '>=0.8.0'} + supports-color@3.2.3: dependencies: has-flag: 1.0.0 - dev: true - /supports-color@5.5.0: - resolution: {integrity: sha512-QjVjwdXIt408MIiAqCX4oUKsgU2EqAGzs2Ppkm4aQYbjm+ZEWEcW4SfFNTr4uMNZma0ey4f5lgLrkB0aX0QMow==} - engines: {node: '>=4'} + supports-color@5.5.0: dependencies: has-flag: 3.0.0 - /supports-color@7.2.0: - resolution: {integrity: sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw==} - engines: {node: '>=8'} + supports-color@7.2.0: dependencies: has-flag: 4.0.0 - /supports-color@8.1.1: - resolution: {integrity: sha512-MpUEN2OodtUzxvKQl72cUF7RQ5EiHsGvSsVG0ia9c5RbWGL2CI4C7EpPS8UTBIplnlzZiNuV56w+FuNxy3ty2Q==} - engines: {node: '>=10'} + supports-color@8.1.1: dependencies: has-flag: 4.0.0 - /supports-preserve-symlinks-flag@1.0.0: - resolution: {integrity: sha512-ot0WnXS9fgdkgIcePe6RHNk1WA8+muPa6cSjeR3V8K27q9BB1rTE3R1p7Hv0z1ZyAc8s6Vvv8DIyWf681MAt0w==} - engines: {node: '>= 0.4'} + supports-preserve-symlinks-flag@1.0.0: {} - /swap-case@1.1.2: - resolution: {integrity: sha512-BAmWG6/bx8syfc6qXPprof3Mn5vQgf5dwdUNJhsNqU9WdPt5P+ES/wQ5bxfijy8zwZgZZHslC3iAsxsuQMCzJQ==} + swap-case@1.1.2: dependencies: lower-case: 1.1.4 upper-case: 1.1.3 - dev: false - /swarm-js@0.1.42: - resolution: {integrity: sha512-BV7c/dVlA3R6ya1lMlSSNPLYrntt0LUq4YMgy3iwpCIc6rZnS5W2wUoctarZ5pXlpKtxDDf9hNziEkcfrxdhqQ==} + swarm-js@0.1.42(bufferutil@4.0.8)(utf-8-validate@5.0.10): dependencies: bluebird: 3.7.2 buffer: 5.7.1 - eth-lib: 0.1.29 + eth-lib: 0.1.29(bufferutil@4.0.8)(utf-8-validate@5.0.10) fs-extra: 4.0.3 got: 11.8.6 mime-types: 2.1.35 @@ -10220,65 +12944,47 @@ packages: - supports-color - utf-8-validate - /sync-request@6.1.0: - resolution: {integrity: sha512-8fjNkrNlNCrVc/av+Jn+xxqfCjYaBoHqCsDz6mt030UMxJGr+GSfCV1dQt2gRtlL63+VPidwDVLr7V2OcTSdRw==} - engines: {node: '>=8.0.0'} + sync-request@6.1.0: dependencies: http-response-object: 3.0.2 sync-rpc: 1.3.6 then-request: 6.0.2 - dev: true - /sync-rpc@1.3.6: - resolution: {integrity: sha512-J8jTXuZzRlvU7HemDgHi3pGnh/rkoqR/OZSjhTyyZrEkkYQbk7Z33AXp37mkPfPpfdOuj7Ex3H/TJM1z48uPQw==} + sync-rpc@1.3.6: dependencies: get-port: 3.2.0 - dev: true - /table-layout@1.0.2: - resolution: {integrity: sha512-qd/R7n5rQTRFi+Zf2sk5XVVd9UQl6ZkduPFC3S7WEGJAmetDTjY3qPN50eSKzwuzEyQKy5TN2TiZdkIjos2L6A==} - engines: {node: '>=8.0.0'} + table-layout@1.0.2: dependencies: array-back: 4.0.2 deep-extend: 0.6.0 typical: 5.2.0 wordwrapjs: 4.0.1 - dev: true - /table@6.8.2: - resolution: {integrity: sha512-w2sfv80nrAh2VCbqR5AK27wswXhqcck2AhfnNW76beQXskGZ1V12GwS//yYVa3d3fcvAip2OUnbDAjW2k3v9fA==} - engines: {node: '>=10.0.0'} + table@6.8.2: dependencies: ajv: 8.13.0 lodash.truncate: 4.4.2 slice-ansi: 4.0.0 string-width: 4.2.3 strip-ansi: 6.0.1 - dev: false - /tar-fs@2.1.1: - resolution: {integrity: sha512-V0r2Y9scmbDRLCNex/+hYzvp/zyYjvFbHPNgVTKfQvVrb6guiE/fxP+XblDNR011utopbkex2nM4dHNV6GDsng==} + tar-fs@2.1.1: dependencies: chownr: 1.1.4 mkdirp-classic: 0.5.3 pump: 3.0.0 tar-stream: 2.2.0 - dev: false - /tar-stream@2.2.0: - resolution: {integrity: sha512-ujeqbceABgwMZxEJnk2HDY2DlnUZ+9oEcb1KzTVfYHio0UE6dG71n60d8D2I4qNvleWrrXpmjpt7vZeF1LnMZQ==} - engines: {node: '>=6'} + tar-stream@2.2.0: dependencies: bl: 4.1.0 end-of-stream: 1.4.4 fs-constants: 1.0.0 inherits: 2.0.4 readable-stream: 3.6.2 - dev: false - /tar@4.4.19: - resolution: {integrity: sha512-a20gEsvHnWe0ygBY8JbxoM4w3SJdhc7ZAuxkLqh+nvNQN2IOt0B5lLgM490X5Hl8FF0dl0tOf2ewFYAlIFgzVA==} - engines: {node: '>=4.5'} + tar@4.4.19: dependencies: chownr: 1.1.4 fs-minipass: 1.2.7 @@ -10288,31 +12994,19 @@ packages: safe-buffer: 5.2.1 yallist: 3.1.1 - /term-size@2.2.1: - resolution: {integrity: sha512-wK0Ri4fOGjv/XPy8SBHZChl8CM7uMc5VML7SqiQ0zG7+J5Vr+RMQDoHa2CNT6KHUnTGIXH34UDMkPzAUyapBZg==} - engines: {node: '>=8'} - dev: true + term-size@2.2.1: {} - /test-exclude@6.0.0: - resolution: {integrity: sha512-cAGWPIyOHU6zlmg88jwm7VRyXnMN7iV68OGAbYDk/Mh/xC/pzVPlQtY6ngoIH/5/tciuhGfvESU8GrHrcxD56w==} - engines: {node: '>=8'} + test-exclude@6.0.0: dependencies: '@istanbuljs/schema': 0.1.3 glob: 7.2.0 minimatch: 3.1.2 - dev: true - /testrpc@0.0.1: - resolution: {integrity: sha512-afH1hO+SQ/VPlmaLUFj2636QMeDvPCeQMc/9RBMW0IfjNe9gFD9Ra3ShqYkB7py0do1ZcCna/9acHyzTJ+GcNA==} - deprecated: testrpc has been renamed to ganache-cli, please use this package from now on. - dev: false + testrpc@0.0.1: {} - /text-table@0.2.0: - resolution: {integrity: sha512-N+8UisAXDGk8PFXP4HAzVR9nbfmVJ3zYLAWiTIoqC5v5isinhr+r5uaO8+7r3BMfuNIufIsA7RdpVgacC2cSpw==} + text-table@0.2.0: {} - /then-request@6.0.2: - resolution: {integrity: sha512-3ZBiG7JvP3wbDzA9iNY5zJQcHL4jn/0BWtXIkagfz7QgOL/LqjCEOBQuJNZfu0XYnv5JhKh+cDxCPM4ILrqruA==} - engines: {node: '>=6.0.0'} + then-request@6.0.2: dependencies: '@types/concat-stream': 1.6.1 '@types/form-data': 0.0.33 @@ -10325,103 +13019,65 @@ packages: http-response-object: 3.0.2 promise: 8.3.0 qs: 6.12.1 - dev: true - /thenify-all@1.6.0: - resolution: {integrity: sha512-RNxQH/qI8/t3thXJDwcstUO4zeqo64+Uy/+sNVRBx4Xn2OX+OZ9oP+iJnNFqplFra2ZUVeKCSa2oVWi3T4uVmA==} - engines: {node: '>=0.8'} + thenify-all@1.6.0: dependencies: thenify: 3.3.1 - dev: false - /thenify@3.3.1: - resolution: {integrity: sha512-RVZSIV5IG10Hk3enotrhvz0T9em6cyHBLkH/YAZuKqd8hRkKhSfCGIcP2KUY0EPxndzANBmNllzWPwak+bheSw==} + thenify@3.3.1: dependencies: any-promise: 1.3.0 - dev: false - /through2@4.0.2: - resolution: {integrity: sha512-iOqSav00cVxEEICeD7TjLB1sueEL+81Wpzp2bY17uZjZN0pWZPuo4suZ/61VujxmqSGFfgOcNuTZ85QJwNZQpw==} + through2@4.0.2: dependencies: readable-stream: 3.6.2 - dev: true - /time-require@0.1.2: - resolution: {integrity: sha512-IqcSpa1sVNleRbC9eHnN7p7vwEHNmsjsXUDqjlnvo4+2VLJ7/gIY2XACTBuRhMB4weYbDYKsR3av2ySykRhDIA==} - engines: {node: '>= 0.10.0'} + time-require@0.1.2: dependencies: chalk: 0.4.0 date-time: 0.1.1 pretty-ms: 0.2.2 text-table: 0.2.0 - dev: true - /timed-out@4.0.1: - resolution: {integrity: sha512-G7r3AhovYtr5YKOWQkta8RKAPb+J9IsO4uVmzjl8AZwfhs8UcUwTiD6gcJYSgOtzyjvQKrKYn41syHbUWMkafA==} - engines: {node: '>=0.10.0'} + timed-out@4.0.1: {} - /title-case@2.1.1: - resolution: {integrity: sha512-EkJoZ2O3zdCz3zJsYCsxyq2OC5hrxR9mfdd5I+w8h/tmFfeOxJ+vvkxsKxdmN0WtS9zLdHEgfgVOiMVgv+Po4Q==} + title-case@2.1.1: dependencies: no-case: 2.3.2 upper-case: 1.1.3 - dev: false - /tmp@0.0.33: - resolution: {integrity: sha512-jRCJlojKnZ3addtTOjdIqoRuPEKBvNXcGYqzO6zWZX8KfKEpnGY5jfggJQ3EjKuu8D4bJRr0y+cYJFmYbImXGw==} - engines: {node: '>=0.6.0'} + tmp@0.0.33: dependencies: os-tmpdir: 1.0.2 - /to-fast-properties@2.0.0: - resolution: {integrity: sha512-/OaKK0xYrs3DmxRYqL/yDc+FxFUVYhDlXMhRmv3z915w2HF1tnN1omB354j8VUGO/hbRzyD6Y3sA7v7GS/ceog==} - engines: {node: '>=4'} - dev: true + to-fast-properties@2.0.0: {} - /to-regex-range@5.0.1: - resolution: {integrity: sha512-65P7iz6X5yEr1cwcgvQxbbIw7Uk3gOy5dIdtZ4rDveLqhrdJP+Li/Hx6tyK0NEb+2GCyneCMJiGqrADCSNk8sQ==} - engines: {node: '>=8.0'} + to-regex-range@5.0.1: dependencies: is-number: 7.0.0 - /toidentifier@1.0.1: - resolution: {integrity: sha512-o5sSPKEkg/DIQNmH43V0/uerLrpzVedkUh8tGNvaeXpfpuwjKenlSox/2O/BTlZUtEe+JG7s5YhEz608PlAHRA==} - engines: {node: '>=0.6'} + toidentifier@1.0.1: {} - /tough-cookie@2.5.0: - resolution: {integrity: sha512-nlLsUzgm1kfLXSXfRZMc1KLAugd4hqJHDTvc2hDIwS3mZAfMEuMbc03SujMF+GEcpaX/qboeycw6iO8JwVv2+g==} - engines: {node: '>=0.8'} + tough-cookie@2.5.0: dependencies: psl: 1.9.0 punycode: 2.3.1 - /tr46@0.0.3: - resolution: {integrity: sha512-N3WMsuqV66lT30CrXNbEjx4GEwlow3v6rr4mCcv6prnfwhS01rkgyFdjPNBYd9br7LpXV1+Emh01fHnq2Gdgrw==} + tr46@0.0.3: {} - /trim-newlines@3.0.1: - resolution: {integrity: sha512-c1PTsA3tYrIsLGkJkzHF+w9F2EyxfXGo4UyJc4pFL++FMjnq0HJS69T3M7d//gKrFKwy429bouPescbjecU+Zw==} - engines: {node: '>=8'} - dev: true + trim-newlines@3.0.1: {} - /truffle-blockchain-utils@0.0.5: - resolution: {integrity: sha512-eCCV8FbYOuKagRY5NiqJCZrrh9GjWX2573ahqZPvUrzxYGIvCpSsHpGCub2e00YefpMfBqwscbsDTK7WNVfwoA==} - deprecated: 'WARNING: This package has been renamed to @truffle/blockchain-utils.' - dev: false + truffle-blockchain-utils@0.0.5: {} - /truffle-contract-schema@2.0.3: - resolution: {integrity: sha512-eI5cFifbB3zpcO4RsXSnjN9JMSlJ4M50GQPdrfbrIXRTXHsyQ433SkgFjIATUwfq++TXWkCRfKMjN8eA7YQ3+Q==} - deprecated: 'WARNING: This package has been renamed to @truffle/contract-schema.' + truffle-contract-schema@2.0.3: dependencies: ajv: 5.5.2 crypto-js: 3.3.0 debug: 3.2.7 transitivePeerDependencies: - supports-color - dev: false - /truffle-contract@3.0.8: - resolution: {integrity: sha512-uhXb/G4dORU4RjFlwZZbFT0n5BS8akify+MaRsnWWs4SA/bo6x4/bQs1xtdO3b5Cl9nXiOX88wdQzRj3xtPVUg==} - deprecated: 'WARNING: This package has been renamed to @truffle/contract.' + truffle-contract@3.0.8: dependencies: ethjs-abi: 0.1.8 truffle-blockchain-utils: 0.0.5 @@ -10430,44 +13086,21 @@ packages: web3: 0.20.6 transitivePeerDependencies: - supports-color - dev: false - /truffle-error@0.0.3: - resolution: {integrity: sha512-9gxs1z6BUn7MqrE4NPm/jcYe8rLok3Z57aweGIh1+CoRJSttzYqwcXCqaPRSNrTFnsTeZMBukkYr/PUcADoihw==} - deprecated: 'WARNING: This package has been renamed to @truffle/error.' - dev: false + truffle-error@0.0.3: {} - /ts-command-line-args@2.5.1: - resolution: {integrity: sha512-H69ZwTw3rFHb5WYpQya40YAX2/w7Ut75uUECbgBIsLmM+BNuYnxsltfyyLMxy6sEeKxgijLTnQtLd0nKd6+IYw==} - hasBin: true + ts-command-line-args@2.5.1: dependencies: chalk: 4.1.2 command-line-args: 5.2.1 command-line-usage: 6.1.3 string-format: 2.0.0 - dev: true - /ts-essentials@7.0.3(typescript@5.0.4): - resolution: {integrity: sha512-8+gr5+lqO3G84KdiTSMRLtuyJ+nTBVRKuCrK4lidMPdVeEp0uqC875uE5NMcaA7YYMN7XsNiFQuMvasF8HT/xQ==} - peerDependencies: - typescript: '>=3.7.0' + ts-essentials@7.0.3(typescript@5.0.4): dependencies: typescript: 5.0.4 - dev: true - /ts-node@10.9.2(@types/node@18.19.33)(typescript@5.0.4): - resolution: {integrity: sha512-f0FFpIdcHgn8zcPSbf1dRevwt047YMnaiJM3u2w2RewrB+fob/zePZcrOyQoLMMO7aBIddLcQIEK5dYjkLnGrQ==} - hasBin: true - peerDependencies: - '@swc/core': '>=1.2.50' - '@swc/wasm': '>=1.2.50' - '@types/node': '*' - typescript: '>=2.7' - peerDependenciesMeta: - '@swc/core': - optional: true - '@swc/wasm': - optional: true + ts-node@10.9.2(@types/node@18.19.33)(typescript@5.0.4): dependencies: '@cspotcode/source-map-support': 0.8.1 '@tsconfig/node10': 1.0.11 @@ -10484,43 +13117,28 @@ packages: typescript: 5.0.4 v8-compile-cache-lib: 3.0.1 yn: 3.1.1 - dev: true - /tsconfig-paths@3.15.0: - resolution: {integrity: sha512-2Ac2RgzDe/cn48GvOe3M+o82pEFewD3UPbyoUHHdKasHwJKjds4fLXWf/Ux5kATBKN20oaFGu+jbElp1pos0mg==} + tsconfig-paths@3.15.0: dependencies: '@types/json5': 0.0.29 json5: 1.0.2 minimist: 1.2.8 strip-bom: 3.0.0 - dev: true - /tslib@1.14.1: - resolution: {integrity: sha512-Xni35NKzjgMrwevysHTCArtLDpPvye8zV/0E4EyYn43P7/7qvQwPh9BGkHewbMulVntbigmcT7rdX3BNo9wRJg==} + tslib@1.14.1: {} - /tslib@2.4.0: - resolution: {integrity: sha512-d6xOpEDfsi2CZVlPQzGeux8XMwLT9hssAsaPYExaQMuYskwb+x1x7J371tWlbBdWHroy99KnVB6qIkUbs5X3UQ==} + tslib@2.4.0: {} - /tslib@2.6.2: - resolution: {integrity: sha512-AEYxH93jGFPn/a2iVAwW87VuUIkR1FVUKB77NwMF7nBTDkDrrT/Hpt/IrCJ0QXhW27jTBDcf5ZY7w6RiqTMw2Q==} + tslib@2.6.2: {} - /tsort@0.0.1: - resolution: {integrity: sha512-Tyrf5mxF8Ofs1tNoxA13lFeZ2Zrbd6cKbuH3V+MQ5sb6DtBj5FjrXVsRWT8YvNAQTqNoz66dz1WsbigI22aEnw==} - dev: false + tsort@0.0.1: {} - /tsutils@3.21.0(typescript@5.0.4): - resolution: {integrity: sha512-mHKK3iUXL+3UF6xL5k0PEhKRUBKPBCv/+RkEOpjRWxxx27KKRBmmA60A9pgOUvMi8GKhRMPEmjBRPzs2W7O1OA==} - engines: {node: '>= 6'} - peerDependencies: - typescript: '>=2.8.0 || >= 3.2.0-dev || >= 3.3.0-dev || >= 3.4.0-dev || >= 3.5.0-dev || >= 3.6.0-dev || >= 3.6.0-beta || >= 3.7.0-dev || >= 3.7.0-beta' + tsutils@3.21.0(typescript@5.0.4): dependencies: tslib: 1.14.1 typescript: 5.0.4 - /tty-table@4.2.3: - resolution: {integrity: sha512-Fs15mu0vGzCrj8fmJNP7Ynxt5J7praPXqFN0leZeZBXJwkMxv9cb2D454k1ltrtUSJbZ4yH4e0CynsHLxmUfFA==} - engines: {node: '>=8.0.0'} - hasBin: true + tty-table@4.2.3: dependencies: chalk: 4.1.2 csv: 5.5.3 @@ -10529,95 +13147,51 @@ packages: strip-ansi: 6.0.1 wcwidth: 1.0.1 yargs: 17.7.2 - dev: true - /tunnel-agent@0.6.0: - resolution: {integrity: sha512-McnNiV1l8RYeY8tBgEpuodCC1mLUdbSN+CYBL7kJsJNInOP8UjDDEwdk6Mw60vdLLrr5NHKZhMAOSrR2NZuQ+w==} + tunnel-agent@0.6.0: dependencies: safe-buffer: 5.2.1 - /tweetnacl-util@0.15.1: - resolution: {integrity: sha512-RKJBIj8lySrShN4w6i/BonWp2Z/uxwC3h4y7xsRrpP59ZboCd0GpEVsOnMDYLMmKBpYhb5TgHzZXy7wTfYFBRw==} - dev: false + tweetnacl-util@0.15.1: {} - /tweetnacl@0.14.5: - resolution: {integrity: sha512-KXXFFdAbFXY4geFIwoyNK+f5Z1b7swfXABfL7HXCmoIWMKU3dmS26672A4EeQtDzLKy7SXmfBu51JolvEKwtGA==} + tweetnacl@0.14.5: {} - /tweetnacl@1.0.3: - resolution: {integrity: sha512-6rt+RN7aOi1nGMyC4Xa5DdYiukl2UWCbcJft7YhxReBGQD7OAM8Pbxw6YMo4r2diNEA8FEmu32YOn9rhaiE5yw==} - dev: false + tweetnacl@1.0.3: {} - /type-check@0.3.2: - resolution: {integrity: sha512-ZCmOJdvOWDBYJlzAoFkC+Q0+bUyEOS1ltgp1MGU03fqHG+dbi9tBFU2Rd9QKiDZFAYrhPh2JUf7rZRIuHRKtOg==} - engines: {node: '>= 0.8.0'} + type-check@0.3.2: dependencies: prelude-ls: 1.1.2 - dev: true - /type-check@0.4.0: - resolution: {integrity: sha512-XleUoc9uwGXqjWwXaUTZAmzMcFZ5858QA2vvx1Ur5xIcixXIP+8LnFDgRplU30us6teqdlskFfu+ae4K79Ooew==} - engines: {node: '>= 0.8.0'} + type-check@0.4.0: dependencies: prelude-ls: 1.2.1 - /type-detect@4.0.8: - resolution: {integrity: sha512-0fr/mIH1dlO+x7TlcMy+bIDqKPsw/70tVyeHW787goQjhmqaZe10uwLujubK9q9Lg6Fiho1KUKDYz0Z7k7g5/g==} - engines: {node: '>=4'} + type-detect@4.0.8: {} - /type-fest@0.13.1: - resolution: {integrity: sha512-34R7HTnG0XIJcBSn5XhDd7nNFPRcXYRZrBB2O2jdKqYODldSzBAqzsWoZYYvduky73toYS/ESqxPvkDf/F0XMg==} - engines: {node: '>=10'} - dev: true + type-fest@0.13.1: {} - /type-fest@0.20.2: - resolution: {integrity: sha512-Ne+eE4r0/iWnpAxD852z3A+N0Bt5RN//NjJwRd2VFHEmrywxf5vsZlh4R6lixl6B+wz/8d+maTSAkN1FIkI3LQ==} - engines: {node: '>=10'} + type-fest@0.20.2: {} - /type-fest@0.21.3: - resolution: {integrity: sha512-t0rzBq87m3fVcduHDUFhKmyyX+9eo6WQjZvf51Ea/M0Q7+T374Jp1aUiyUl0GKxp8M/OETVHSDvmkyPgvX+X2w==} - engines: {node: '>=10'} - dev: false + type-fest@0.21.3: {} - /type-fest@0.6.0: - resolution: {integrity: sha512-q+MB8nYR1KDLrgr4G5yemftpMC7/QLqVndBmEEdqzmNj5dcFOO4Oo8qlwZE3ULT3+Zim1F8Kq4cBnikNhlCMlg==} - engines: {node: '>=8'} - dev: true + type-fest@0.6.0: {} - /type-fest@0.7.1: - resolution: {integrity: sha512-Ne2YiiGN8bmrmJJEuTWTLJR32nh/JdL1+PSicowtNb0WFpn59GK8/lfD61bVtzguz7b3PBt74nxpv/Pw5po5Rg==} - engines: {node: '>=8'} - dev: false + type-fest@0.7.1: {} - /type-fest@0.8.1: - resolution: {integrity: sha512-4dbzIzqvjtgiM5rw1k5rEHtBANKmdudhGyBEajN01fEyhaAIhsoKNy6y7+IN93IfpFtwY9iqi7kD+xwKhQsNJA==} - engines: {node: '>=8'} - dev: true + type-fest@0.8.1: {} - /type-fest@2.19.0: - resolution: {integrity: sha512-RAH822pAdBgcNMAfWnCBU3CFZcfZ/i1eZjwFU/dsLKumyuuP3niueg2UAukXYF0E2AAoc82ZSSf9J0WQBinzHA==} - engines: {node: '>=12.20'} - dev: true + type-fest@2.19.0: {} - /type-fest@3.13.1: - resolution: {integrity: sha512-tLq3bSNx+xSpwvAJnzrK0Ep5CLNWjvFTOp71URMaAEWBfRb9nnJiBoUe0tF8bI4ZFO3omgBR6NvnbzVUT3Ly4g==} - engines: {node: '>=14.16'} - dev: true + type-fest@3.13.1: {} - /type-is@1.6.18: - resolution: {integrity: sha512-TkRKr9sUTxEH8MdfuCSP7VizJyzRNMjj2J2do2Jr3Kym598JVdEksuzPQCnlFPW4ky9Q+iA+ma9BGm06XQBy8g==} - engines: {node: '>= 0.6'} + type-is@1.6.18: dependencies: media-typer: 0.3.0 mime-types: 2.1.35 - /type@2.7.2: - resolution: {integrity: sha512-dzlvlNlt6AXU7EBSfpAscydQ7gXB+pPGsPnfJnZpiNJBDj7IaJzQlBZYGdEi4R9HmPdBv2XmWJ6YUtoTa7lmCw==} + type@2.7.2: {} - /typechain@8.3.2(typescript@5.0.4): - resolution: {integrity: sha512-x/sQYr5w9K7yv3es7jo4KTX05CLxOf7TRWwoHlrjRh8H82G64g+k7VuWPJlgMo6qrjfCulOdfBjiaDtmhFYD/Q==} - hasBin: true - peerDependencies: - typescript: '>=4.3.0' + typechain@8.3.2(typescript@5.0.4): dependencies: '@types/prettier': 2.7.3 debug: 4.3.4(supports-color@8.1.1) @@ -10632,31 +13206,22 @@ packages: typescript: 5.0.4 transitivePeerDependencies: - supports-color - dev: true - /typed-array-buffer@1.0.2: - resolution: {integrity: sha512-gEymJYKZtKXzzBzM4jqa9w6Q1Jjm7x2d+sh19AdsD4wqnMPDYyvwpsIc2Q/835kHuo3BEQ7CjelGhfTsoBb2MQ==} - engines: {node: '>= 0.4'} + typed-array-buffer@1.0.2: dependencies: call-bind: 1.0.7 es-errors: 1.3.0 is-typed-array: 1.1.13 - dev: true - /typed-array-byte-length@1.0.1: - resolution: {integrity: sha512-3iMJ9q0ao7WE9tWcaYKIptkNBuOIcZCCT0d4MRvuuH88fEoEH62IuQe0OtraD3ebQEoTRk8XCBoknUNc1Y67pw==} - engines: {node: '>= 0.4'} + typed-array-byte-length@1.0.1: dependencies: call-bind: 1.0.7 for-each: 0.3.3 gopd: 1.0.1 has-proto: 1.0.3 is-typed-array: 1.1.13 - dev: true - /typed-array-byte-offset@1.0.2: - resolution: {integrity: sha512-Ous0vodHa56FviZucS2E63zkgtgrACj7omjwd/8lTEMEPFFyjfixMZ1ZXenpgCFBBt4EC1J2XsyVS2gkG0eTFA==} - engines: {node: '>= 0.4'} + typed-array-byte-offset@1.0.2: dependencies: available-typed-arrays: 1.0.7 call-bind: 1.0.7 @@ -10664,11 +13229,8 @@ packages: gopd: 1.0.1 has-proto: 1.0.3 is-typed-array: 1.1.13 - dev: true - /typed-array-length@1.0.6: - resolution: {integrity: sha512-/OxDN6OtAk5KBpGb28T+HZc2M+ADtvRxXrKKbUwtsLgdoxgX13hyy7ek6bFRl5+aBs2yZzB0c4CnQfAtVypW/g==} - engines: {node: '>= 0.4'} + typed-array-length@1.0.6: dependencies: call-bind: 1.0.7 for-each: 0.3.3 @@ -10676,141 +13238,82 @@ packages: has-proto: 1.0.3 is-typed-array: 1.1.13 possible-typed-array-names: 1.0.0 - dev: true - /typedarray-to-buffer@3.1.5: - resolution: {integrity: sha512-zdu8XMNEDepKKR+XYOXAVPtWui0ly0NtohUscw+UmaHiAWT8hrV1rr//H6V+0DvJ3OQ19S979M0laLfX8rm82Q==} + typedarray-to-buffer@3.1.5: dependencies: is-typedarray: 1.0.0 - /typedarray@0.0.6: - resolution: {integrity: sha512-/aCDEGatGvZ2BIk+HmLf4ifCJFwvKFNb9/JeZPMulfgFracn9QFcAf5GO8B/mweUjSoblS5In0cWhqpfs/5PQA==} - dev: true + typedarray@0.0.6: {} - /typescript@5.0.4: - resolution: {integrity: sha512-cW9T5W9xY37cc+jfEnaUvX91foxtHkza3Nw3wkoF4sSlKn0MONdkdEndig/qPBWXNkmplh3NzayQzCiHM4/hqw==} - engines: {node: '>=12.20'} - hasBin: true + typescript@5.0.4: {} - /typical@4.0.0: - resolution: {integrity: sha512-VAH4IvQ7BDFYglMd7BPRDfLgxZZX4O4TFcRDA6EN5X7erNJJq+McIEp8np9aVtxrCJ6qx4GTYVfOWNjcqwZgRw==} - engines: {node: '>=8'} - dev: true + typical@4.0.0: {} - /typical@5.2.0: - resolution: {integrity: sha512-dvdQgNDNJo+8B2uBQoqdb11eUCE1JQXhvjC/CZtgvZseVd5TYMXnq0+vuUemXbd/Se29cTaUuPX3YIc2xgbvIg==} - engines: {node: '>=8'} - dev: true + typical@5.2.0: {} - /uglify-js@3.17.4: - resolution: {integrity: sha512-T9q82TJI9e/C1TAxYvfb16xO120tMVFZrGA3f9/P4424DNu6ypK103y0GPFVa17yotwSyZW5iYXgjYHkGrJW/g==} - engines: {node: '>=0.8.0'} - hasBin: true - requiresBuild: true - dev: true + uglify-js@3.17.4: optional: true - /ultron@1.1.1: - resolution: {integrity: sha512-UIEXBNeYmKptWH6z8ZnqTeS8fV74zG0/eRU9VGkpzz+LIJNs8W/zM/L+7ctCkRrgbNnnR0xxw4bKOr0cW0N0Og==} + ultron@1.1.1: {} - /unbox-primitive@1.0.2: - resolution: {integrity: sha512-61pPlCD9h51VoreyJ0BReideM3MDKMKnh6+V9L08331ipq6Q8OFXZYiqP6n/tbHx4s5I9uRhcye6BrbkizkBDw==} + unbox-primitive@1.0.2: dependencies: call-bind: 1.0.7 has-bigints: 1.0.2 has-symbols: 1.0.3 which-boxed-primitive: 1.0.2 - dev: true - /underscore@1.13.6: - resolution: {integrity: sha512-+A5Sja4HP1M08MaXya7p5LvjuM7K6q/2EaC0+iovj/wOcMsTzMvDFbasi/oSapiwOlt252IqsKqPjCl7huKS0A==} - dev: false + underscore@1.13.6: {} - /undici-types@5.26.5: - resolution: {integrity: sha512-JlCMO+ehdEIKqlFxk6IfVoAUVmgz7cU7zD/h9XZ0qzeosSHmUJVOzSQvvYSYWXkFXC+IfLKSIffhv0sVZup6pA==} + undici-types@5.26.5: {} - /undici@5.28.4: - resolution: {integrity: sha512-72RFADWFqKmUb2hmmvNODKL3p9hcB6Gt2DOQMis1SEBaV6a4MH8soBvzg+95CYhCKPFedut2JY9bMfrDl9D23g==} - engines: {node: '>=14.0'} + undici@5.28.4: dependencies: '@fastify/busboy': 2.1.1 - dev: false - /universalify@0.1.2: - resolution: {integrity: sha512-rBJeI5CXAlmy1pV+617WB9J63U6XcazHHF2f2dbJix4XzpUF0RS3Zbj0FGIOCAva5P/d/GBOYaACQ1w+0azUkg==} - engines: {node: '>= 4.0.0'} + universalify@0.1.2: {} - /universalify@2.0.1: - resolution: {integrity: sha512-gptHNQghINnc/vTGIk0SOFGFNXw7JVrlRUtConJRlvaw6DuX0wO5Jeko9sWrMBhh+PsYAZ7oXAiOnf/UKogyiw==} - engines: {node: '>= 10.0.0'} - dev: true + universalify@2.0.1: {} - /unpipe@1.0.0: - resolution: {integrity: sha512-pjy2bYhSsufwWlKwPc+l3cN7+wuJlK6uz0YdJEOlQDbl6jo/YlPi4mb8agUkVC8BF7V8NuzeyPNqRksA3hztKQ==} - engines: {node: '>= 0.8'} + unpipe@1.0.0: {} - /untildify@4.0.0: - resolution: {integrity: sha512-KK8xQ1mkzZeg9inewmFVDNkg3l5LUhoq9kN6iWYB/CC9YMG8HA+c1Q8HwDe6dEX7kErrEVNVBO3fWsVq5iDgtw==} - engines: {node: '>=8'} - dev: false + untildify@4.0.0: {} - /update-browserslist-db@1.0.15(browserslist@4.23.0): - resolution: {integrity: sha512-K9HWH62x3/EalU1U6sjSZiylm9C8tgq2mSvshZpqc7QE69RaA2qjhkW2HlNA0tFpEbtyFz7HTqbSdN4MSwUodA==} - hasBin: true - peerDependencies: - browserslist: '>= 4.21.0' + update-browserslist-db@1.0.15(browserslist@4.23.0): dependencies: browserslist: 4.23.0 escalade: 3.1.2 picocolors: 1.0.0 - dev: true - /upper-case-first@1.1.2: - resolution: {integrity: sha512-wINKYvI3Db8dtjikdAqoBbZoP6Q+PZUyfMR7pmwHzjC2quzSkUq5DmPrTtPEqHaz8AGtmsB4TqwapMTM1QAQOQ==} + upper-case-first@1.1.2: dependencies: upper-case: 1.1.3 - dev: false - /upper-case@1.1.3: - resolution: {integrity: sha512-WRbjgmYzgXkCV7zNVpy5YgrHgbBv126rMALQQMrmzOVC4GM2waQ9x7xtm8VU+1yF2kWyPzI9zbZ48n4vSxwfSA==} - dev: false + upper-case@1.1.3: {} - /uri-js@4.4.1: - resolution: {integrity: sha512-7rKUyy33Q1yc98pQ1DAmLtwX109F7TIfWlW1Ydo8Wl1ii1SeHieeh0HHfPeL2fMXK6z0s8ecKs9frCuLJvndBg==} + uri-js@4.4.1: dependencies: punycode: 2.3.1 - /url-set-query@1.0.0: - resolution: {integrity: sha512-3AChu4NiXquPfeckE5R5cGdiHCMWJx1dwCWOmWIL4KHAziJNOFIYJlpGFeKDvwLPHovZRCxK3cYlwzqI9Vp+Gg==} + url-set-query@1.0.0: {} - /usb@2.9.0: - resolution: {integrity: sha512-G0I/fPgfHUzWH8xo2KkDxTTFruUWfppgSFJ+bQxz/kVY2x15EQ/XDB7dqD1G432G4gBG4jYQuF3U7j/orSs5nw==} - engines: {node: '>=10.20.0 <11.x || >=12.17.0 <13.0 || >=14.0.0'} - requiresBuild: true + usb@2.9.0: dependencies: '@types/w3c-web-usb': 1.0.10 node-addon-api: 6.1.0 node-gyp-build: 4.8.1 - dev: false - /utf-8-validate@5.0.10: - resolution: {integrity: sha512-Z6czzLq4u8fPOyx7TU6X3dvUZVvoJmxSQ+IcrlmagKhilxlhZgxPK6C5Jqbkw1IDUmFTM+cz9QDnnLTwDz/2gQ==} - engines: {node: '>=6.14.2'} - requiresBuild: true + utf-8-validate@5.0.10: dependencies: node-gyp-build: 4.8.1 - /utf8@2.1.2: - resolution: {integrity: sha512-QXo+O/QkLP/x1nyi54uQiG0XrODxdysuQvE5dtVqv7F5K2Qb6FsN+qbr6KhF5wQ20tfcV3VQp0/2x1e1MRSPWg==} + utf8@2.1.2: {} - /utf8@3.0.0: - resolution: {integrity: sha512-E8VjFIQ/TyQgp+TZfS6l8yp/xWppSAHzidGiRrqe4bK4XP9pTRyKFgGJpO3SN7zdX4DeomTrwaseCHovfpFcqQ==} + utf8@3.0.0: {} - /util-deprecate@1.0.2: - resolution: {integrity: sha512-EPD5q1uXyFxJpCrLnCc1nHnq3gOa6DZBocAIiI2TaSCA7VCJ1UJDMagCzIkXNsUYfD1daK//LTEQ8xiIbrHtcw==} + util-deprecate@1.0.2: {} - /util@0.12.5: - resolution: {integrity: sha512-kZf/K6hEIrWHI6XqOFUiiMa+79wE/D8Q+NCNAWclkyg3b4d2k7s0QGepNjiABc+aR3N1PAyHL7p6UcLY6LmrnA==} + util@0.12.5: dependencies: inherits: 2.0.4 is-arguments: 1.1.1 @@ -10818,145 +13321,93 @@ packages: is-typed-array: 1.1.13 which-typed-array: 1.1.15 - /utils-merge@1.0.1: - resolution: {integrity: sha512-pMZTvIkT1d+TFGvDOqodOclx0QWkkgi6Tdoa8gC8ffGAAqz9pzPTZWAybbsHHoED/ztMtkv/VoYTYyShUn81hA==} - engines: {node: '>= 0.4.0'} + utils-merge@1.0.1: {} - /uuid@2.0.1: - resolution: {integrity: sha512-nWg9+Oa3qD2CQzHIP4qKUqwNfzKn8P0LtFhotaCTFchsV7ZfDhAybeip/HZVeMIpZi9JgY1E3nUlwaCmZT1sEg==} - deprecated: Please upgrade to version 7 or higher. Older versions may use Math.random() in certain circumstances, which is known to be problematic. See https://v8.dev/blog/math-random for details. - dev: false + uuid@2.0.1: {} - /uuid@3.4.0: - resolution: {integrity: sha512-HjSDRw6gZE5JMggctHBcjVak08+KEVhSIiDzFnT9S9aegmp85S/bReBVTb4QTFaRNptJ9kuYaNhnbNEOkbKb/A==} - deprecated: Please upgrade to version 7 or higher. Older versions may use Math.random() in certain circumstances, which is known to be problematic. See https://v8.dev/blog/math-random for details. - hasBin: true + uuid@3.4.0: {} - /uuid@8.3.2: - resolution: {integrity: sha512-+NYs2QeMWy+GWFOEm9xnn6HCDp0l7QBD7ml8zLUmJ+93Q5NF0NocErnwkTkXVFNiX3/fpC6afS8Dhb/gz7R7eg==} - hasBin: true + uuid@8.3.2: {} - /uuid@9.0.1: - resolution: {integrity: sha512-b+1eJOlsR9K8HJpow9Ok3fiWOWSIcIzXodvv0rQjVoOVNpWMpxf1wZNpt4y9h10odCNrqnYp1OBzRktckBe3sA==} - hasBin: true + uuid@9.0.1: {} - /v8-compile-cache-lib@3.0.1: - resolution: {integrity: sha512-wa7YjyUGfNZngI/vtK0UHAN+lgDCxBPCylVXGp0zu59Fz5aiGtNXaq3DhIov063MorB+VfufLh3JlF2KdTK3xg==} - dev: true + v8-compile-cache-lib@3.0.1: {} - /validate-npm-package-license@3.0.4: - resolution: {integrity: sha512-DpKm2Ui/xN7/HQKCtpZxoRWBhZ9Z0kqtygG8XCgNQ8ZlDnxuQmWhj566j8fN4Cu3/JmbhsDo7fcAJq4s9h27Ew==} + validate-npm-package-license@3.0.4: dependencies: spdx-correct: 3.2.0 spdx-expression-parse: 3.0.1 - /varint@5.0.2: - resolution: {integrity: sha512-lKxKYG6H03yCZUpAGOPOsMcGxd1RHCu1iKvEHYDPmTyq2HueGhD73ssNBqqQWfvYs04G9iUFRvmAVLW20Jw6ow==} + varint@5.0.2: {} - /vary@1.1.2: - resolution: {integrity: sha512-BNGbWLfd0eUPabhkXUVm0j8uuvREyTh5ovRa/dyow/BqAbZJyC+5fU+IzQOzmAKzYqYRAISoRhdQr3eIZ/PXqg==} - engines: {node: '>= 0.8'} + vary@1.1.2: {} - /verror@1.10.0: - resolution: {integrity: sha512-ZZKSmDAEFOijERBLkmYfJ+vmk3w+7hOLYDNkRCuRuMJGEmqYNCNLyBBFwWKVMhfwaEF3WOd0Zlw86U/WC/+nYw==} - engines: {'0': node >=0.6.0} + verror@1.10.0: dependencies: assert-plus: 1.0.0 core-util-is: 1.0.2 extsprintf: 1.3.0 - /viem@2.10.3(typescript@5.0.4): - resolution: {integrity: sha512-GmPMH+D/SDSXpVSjLM0GN1H1/h4NUPHaIqnFLwAit8nkfCiDuajKflGFiMPCIs1h7QZlBICuKvON/rc09H+w6Q==} - peerDependencies: - typescript: '>=5.0.4' - peerDependenciesMeta: - typescript: - optional: true + viem@2.10.3(bufferutil@4.0.8)(typescript@5.0.4)(utf-8-validate@5.0.10)(zod@3.23.8): dependencies: '@adraffy/ens-normalize': 1.10.0 '@noble/curves': 1.2.0 '@noble/hashes': 1.3.2 '@scure/bip32': 1.3.2 '@scure/bip39': 1.2.1 - abitype: 1.0.0(typescript@5.0.4) - isows: 1.0.3(ws@8.13.0) + abitype: 1.0.0(typescript@5.0.4)(zod@3.23.8) + isows: 1.0.3(ws@8.13.0(bufferutil@4.0.8)(utf-8-validate@5.0.10)) + ws: 8.13.0(bufferutil@4.0.8)(utf-8-validate@5.0.10) + optionalDependencies: typescript: 5.0.4 - ws: 8.13.0 transitivePeerDependencies: - bufferutil - utf-8-validate - zod - dev: true - /wcwidth@1.0.1: - resolution: {integrity: sha512-XHPEwS0q6TaxcvG85+8EYkbiCux2XtWG2mkc47Ng2A77BQu9+DqIOJldST4HgPkuea7dvKSj5VgX3P1d4rW8Tg==} + wcwidth@1.0.1: dependencies: defaults: 1.0.4 - /web3-bzz@1.10.0: - resolution: {integrity: sha512-o9IR59io3pDUsXTsps5pO5hW1D5zBmg46iNc2t4j2DkaYHNdDLwk2IP9ukoM2wg47QILfPEJYzhTfkS/CcX0KA==} - engines: {node: '>=8.0.0'} - requiresBuild: true + web3-bzz@1.10.0(bufferutil@4.0.8)(utf-8-validate@5.0.10): dependencies: '@types/node': 12.20.55 got: 12.1.0 - swarm-js: 0.1.42 + swarm-js: 0.1.42(bufferutil@4.0.8)(utf-8-validate@5.0.10) transitivePeerDependencies: - bufferutil - supports-color - utf-8-validate - dev: false - /web3-bzz@1.10.4: - resolution: {integrity: sha512-ZZ/X4sJ0Uh2teU9lAGNS8EjveEppoHNQiKlOXAjedsrdWuaMErBPdLQjXfcrYvN6WM6Su9PMsAxf3FXXZ+HwQw==} - engines: {node: '>=8.0.0'} - requiresBuild: true + web3-bzz@1.10.4(bufferutil@4.0.8)(utf-8-validate@5.0.10): dependencies: '@types/node': 12.20.55 got: 12.1.0 - swarm-js: 0.1.42 + swarm-js: 0.1.42(bufferutil@4.0.8)(utf-8-validate@5.0.10) transitivePeerDependencies: - bufferutil - supports-color - utf-8-validate - /web3-core-helpers@1.10.0: - resolution: {integrity: sha512-pIxAzFDS5vnbXvfvLSpaA1tfRykAe9adw43YCKsEYQwH0gCLL0kMLkaCX3q+Q8EVmAh+e1jWL/nl9U0de1+++g==} - engines: {node: '>=8.0.0'} + web3-core-helpers@1.10.0: dependencies: web3-eth-iban: 1.10.0 web3-utils: 1.10.0 - dev: false - - /web3-core-helpers@1.10.3: - resolution: {integrity: sha512-Yv7dQC3B9ipOc5sWm3VAz1ys70Izfzb8n9rSiQYIPjpqtJM+3V4EeK6ghzNR6CO2es0+Yu9CtCkw0h8gQhrTxA==} - engines: {node: '>=8.0.0'} - dependencies: - web3-eth-iban: 1.10.3 - web3-utils: 1.10.3 - dev: false - /web3-core-helpers@1.10.4: - resolution: {integrity: sha512-r+L5ylA17JlD1vwS8rjhWr0qg7zVoVMDvWhajWA5r5+USdh91jRUYosp19Kd1m2vE034v7Dfqe1xYRoH2zvG0g==} - engines: {node: '>=8.0.0'} + web3-core-helpers@1.10.4: dependencies: web3-eth-iban: 1.10.4 web3-utils: 1.10.4 - /web3-core-method@1.10.0: - resolution: {integrity: sha512-4R700jTLAMKDMhQ+nsVfIXvH6IGJlJzGisIfMKWAIswH31h5AZz7uDUW2YctI+HrYd+5uOAlS4OJeeT9bIpvkA==} - engines: {node: '>=8.0.0'} + web3-core-method@1.10.0: dependencies: '@ethersproject/transactions': 5.7.0 web3-core-helpers: 1.10.0 web3-core-promievent: 1.10.0 web3-core-subscriptions: 1.10.0 web3-utils: 1.10.0 - dev: false - /web3-core-method@1.10.4: - resolution: {integrity: sha512-uZTb7flr+Xl6LaDsyTeE2L1TylokCJwTDrIVfIfnrGmnwLc6bmTWCCrm71sSrQ0hqs6vp/MKbQYIYqUN0J8WyA==} - engines: {node: '>=8.0.0'} + web3-core-method@1.10.4: dependencies: '@ethersproject/transactions': 5.7.0 web3-core-helpers: 1.10.4 @@ -10964,29 +13415,15 @@ packages: web3-core-subscriptions: 1.10.4 web3-utils: 1.10.4 - /web3-core-promievent@1.10.0: - resolution: {integrity: sha512-68N7k5LWL5R38xRaKFrTFT2pm2jBNFaM4GioS00YjAKXRQ3KjmhijOMG3TICz6Aa5+6GDWYelDNx21YAeZ4YTg==} - engines: {node: '>=8.0.0'} - dependencies: - eventemitter3: 4.0.4 - dev: false - - /web3-core-promievent@1.10.3: - resolution: {integrity: sha512-HgjY+TkuLm5uTwUtaAfkTgRx/NzMxvVradCi02gy17NxDVdg/p6svBHcp037vcNpkuGeFznFJgULP+s2hdVgUQ==} - engines: {node: '>=8.0.0'} + web3-core-promievent@1.10.0: dependencies: eventemitter3: 4.0.4 - dev: false - /web3-core-promievent@1.10.4: - resolution: {integrity: sha512-2de5WnJQ72YcIhYwV/jHLc4/cWJnznuoGTJGD29ncFQHAfwW/MItHFSVKPPA5v8AhJe+r6y4Y12EKvZKjQVBvQ==} - engines: {node: '>=8.0.0'} + web3-core-promievent@1.10.4: dependencies: eventemitter3: 4.0.4 - /web3-core-requestmanager@1.10.0: - resolution: {integrity: sha512-3z/JKE++Os62APml4dvBM+GAuId4h3L9ckUrj7ebEtS2AR0ixyQPbrBodgL91Sv7j7cQ3Y+hllaluqjguxvSaQ==} - engines: {node: '>=8.0.0'} + web3-core-requestmanager@1.10.0: dependencies: util: 0.12.5 web3-core-helpers: 1.10.0 @@ -10996,11 +13433,8 @@ packages: transitivePeerDependencies: - encoding - supports-color - dev: false - /web3-core-requestmanager@1.10.4: - resolution: {integrity: sha512-vqP6pKH8RrhT/2MoaU+DY/OsYK9h7HmEBNCdoMj+4ZwujQtw/Mq2JifjwsJ7gits7Q+HWJwx8q6WmQoVZAWugg==} - engines: {node: '>=8.0.0'} + web3-core-requestmanager@1.10.4: dependencies: util: 0.12.5 web3-core-helpers: 1.10.4 @@ -11011,24 +13445,17 @@ packages: - encoding - supports-color - /web3-core-subscriptions@1.10.0: - resolution: {integrity: sha512-HGm1PbDqsxejI075gxBc5OSkwymilRWZufIy9zEpnWKNmfbuv5FfHgW1/chtJP6aP3Uq2vHkvTDl3smQBb8l+g==} - engines: {node: '>=8.0.0'} + web3-core-subscriptions@1.10.0: dependencies: eventemitter3: 4.0.4 web3-core-helpers: 1.10.0 - dev: false - /web3-core-subscriptions@1.10.4: - resolution: {integrity: sha512-o0lSQo/N/f7/L76C0HV63+S54loXiE9fUPfHFcTtpJRQNDBVsSDdWRdePbWwR206XlsBqD5VHApck1//jEafTw==} - engines: {node: '>=8.0.0'} + web3-core-subscriptions@1.10.4: dependencies: eventemitter3: 4.0.4 web3-core-helpers: 1.10.4 - /web3-core@1.10.0: - resolution: {integrity: sha512-fWySwqy2hn3TL89w5TM8wXF1Z2Q6frQTKHWmP0ppRQorEK8NcHJRfeMiv/mQlSKoTS1F6n/nv2uyZsixFycjYQ==} - engines: {node: '>=8.0.0'} + web3-core@1.10.0: dependencies: '@types/bn.js': 5.1.5 '@types/node': 12.20.55 @@ -11040,11 +13467,8 @@ packages: transitivePeerDependencies: - encoding - supports-color - dev: false - /web3-core@1.10.4: - resolution: {integrity: sha512-B6elffYm81MYZDTrat7aEhnhdtVE3lDBUZft16Z8awYMZYJDbnykEbJVS+l3mnA7AQTnSDr/1MjWofGDLBJPww==} - engines: {node: '>=8.0.0'} + web3-core@1.10.4: dependencies: '@types/bn.js': 5.1.5 '@types/node': 12.20.55 @@ -11057,15 +13481,13 @@ packages: - encoding - supports-color - /web3-core@4.3.2: - resolution: {integrity: sha512-uIMVd/j4BgOnwfpY8ZT+QKubOyM4xohEhFZXz9xB8wimXWMMlYVlIK/TbfHqFolS9uOerdSGhsMbcK9lETae8g==} - engines: {node: '>=14', npm: '>=6.12.0'} + web3-core@4.3.2(bufferutil@4.0.8)(utf-8-validate@5.0.10): dependencies: web3-errors: 1.1.4 web3-eth-accounts: 4.1.2 web3-eth-iban: 4.0.7 web3-providers-http: 4.1.0 - web3-providers-ws: 4.0.7 + web3-providers-ws: 4.0.7(bufferutil@4.0.8)(utf-8-validate@5.0.10) web3-types: 1.6.0 web3-utils: 4.2.3 web3-validator: 2.0.5 @@ -11075,35 +13497,24 @@ packages: - bufferutil - encoding - utf-8-validate - dev: true - /web3-errors@1.1.4: - resolution: {integrity: sha512-WahtszSqILez+83AxGecVroyZsMuuRT+KmQp4Si5P4Rnqbczno1k748PCrZTS1J4UCPmXMG2/Vt+0Bz2zwXkwQ==} - engines: {node: '>=14', npm: '>=6.12.0'} + web3-errors@1.1.4: dependencies: web3-types: 1.6.0 - dev: true - /web3-eth-abi@1.10.0: - resolution: {integrity: sha512-cwS+qRBWpJ43aI9L3JS88QYPfFcSJJ3XapxOQ4j40v6mk7ATpA8CVK1vGTzpihNlOfMVRBkR95oAj7oL6aiDOg==} - engines: {node: '>=8.0.0'} + web3-eth-abi@1.10.0: dependencies: '@ethersproject/abi': 5.7.0 web3-utils: 1.10.0 - dev: false - /web3-eth-abi@1.10.4: - resolution: {integrity: sha512-cZ0q65eJIkd/jyOlQPDjr8X4fU6CRL1eWgdLwbWEpo++MPU/2P4PFk5ZLAdye9T5Sdp+MomePPJ/gHjLMj2VfQ==} - engines: {node: '>=8.0.0'} + web3-eth-abi@1.10.4: dependencies: '@ethersproject/abi': 5.7.0 web3-utils: 1.10.4 - /web3-eth-abi@4.2.1(typescript@5.0.4): - resolution: {integrity: sha512-IE91WUhhiDpBtbkl/DHUoZz7z7T5FXvl3zPLkrxT+dNlOT+wni+US/67jQCLvJRbqf9ApQ26lVYry0bovFgyqA==} - engines: {node: '>=14', npm: '>=6.12.0'} + web3-eth-abi@4.2.1(typescript@5.0.4)(zod@3.23.8): dependencies: - abitype: 0.7.1(typescript@5.0.4) + abitype: 0.7.1(typescript@5.0.4)(zod@3.23.8) web3-errors: 1.1.4 web3-types: 1.6.0 web3-utils: 4.2.3 @@ -11111,11 +13522,8 @@ packages: transitivePeerDependencies: - typescript - zod - dev: true - /web3-eth-accounts@1.10.0: - resolution: {integrity: sha512-wiq39Uc3mOI8rw24wE2n15hboLE0E9BsQLdlmsL4Zua9diDS6B5abXG0XhFcoNsXIGMWXVZz4TOq3u4EdpXF/Q==} - engines: {node: '>=8.0.0'} + web3-eth-accounts@1.10.0: dependencies: '@ethereumjs/common': 2.5.0 '@ethereumjs/tx': 3.3.2 @@ -11130,11 +13538,8 @@ packages: transitivePeerDependencies: - encoding - supports-color - dev: false - /web3-eth-accounts@1.10.4: - resolution: {integrity: sha512-ysy5sVTg9snYS7tJjxVoQAH6DTOTkRGR8emEVCWNGLGiB9txj+qDvSeT0izjurS/g7D5xlMAgrEHLK1Vi6I3yg==} - engines: {node: '>=8.0.0'} + web3-eth-accounts@1.10.4: dependencies: '@ethereumjs/common': 2.6.5 '@ethereumjs/tx': 3.5.2 @@ -11150,9 +13555,7 @@ packages: - encoding - supports-color - /web3-eth-accounts@4.1.2: - resolution: {integrity: sha512-y0JynDeTDnclyuE9mShXLeEj+BCrPHxPHOyPCgTchUBQsALF9+0OhP7WiS3IqUuu0Hle5bjG2f5ddeiPtNEuLg==} - engines: {node: '>=14', npm: '>=6.12.0'} + web3-eth-accounts@4.1.2: dependencies: '@ethereumjs/rlp': 4.0.1 crc-32: 1.2.2 @@ -11161,11 +13564,8 @@ packages: web3-types: 1.6.0 web3-utils: 4.2.3 web3-validator: 2.0.5 - dev: true - /web3-eth-contract@1.10.0: - resolution: {integrity: sha512-MIC5FOzP/+2evDksQQ/dpcXhSqa/2hFNytdl/x61IeWxhh6vlFeSjq0YVTAyIzdjwnL7nEmZpjfI6y6/Ufhy7w==} - engines: {node: '>=8.0.0'} + web3-eth-contract@1.10.0: dependencies: '@types/bn.js': 5.1.5 web3-core: 1.10.0 @@ -11178,11 +13578,8 @@ packages: transitivePeerDependencies: - encoding - supports-color - dev: false - /web3-eth-contract@1.10.4: - resolution: {integrity: sha512-Q8PfolOJ4eV9TvnTj1TGdZ4RarpSLmHnUnzVxZ/6/NiTfe4maJz99R0ISgwZkntLhLRtw0C7LRJuklzGYCNN3A==} - engines: {node: '>=8.0.0'} + web3-eth-contract@1.10.4: dependencies: '@types/bn.js': 5.1.5 web3-core: 1.10.4 @@ -11196,14 +13593,12 @@ packages: - encoding - supports-color - /web3-eth-contract@4.4.0(typescript@5.0.4): - resolution: {integrity: sha512-pZ/w6Lb6ZDUUs7f5GCKXiHDAGGvt2tdwiHkvgmQTRnq9b0MEsUpteDyPYspHxKzQWLgbeK37jPb8zbQe4kE/Hg==} - engines: {node: '>=14', npm: '>=6.12.0'} + web3-eth-contract@4.4.0(bufferutil@4.0.8)(typescript@5.0.4)(utf-8-validate@5.0.10)(zod@3.23.8): dependencies: - web3-core: 4.3.2 + web3-core: 4.3.2(bufferutil@4.0.8)(utf-8-validate@5.0.10) web3-errors: 1.1.4 - web3-eth: 4.6.0(typescript@5.0.4) - web3-eth-abi: 4.2.1(typescript@5.0.4) + web3-eth: 4.6.0(bufferutil@4.0.8)(typescript@5.0.4)(utf-8-validate@5.0.10)(zod@3.23.8) + web3-eth-abi: 4.2.1(typescript@5.0.4)(zod@3.23.8) web3-types: 1.6.0 web3-utils: 4.2.3 web3-validator: 2.0.5 @@ -11213,11 +13608,8 @@ packages: - typescript - utf-8-validate - zod - dev: true - /web3-eth-ens@1.10.0: - resolution: {integrity: sha512-3hpGgzX3qjgxNAmqdrC2YUQMTfnZbs4GeLEmy8aCWziVwogbuqQZ+Gzdfrym45eOZodk+lmXyLuAdqkNlvkc1g==} - engines: {node: '>=8.0.0'} + web3-eth-ens@1.10.0: dependencies: content-hash: 2.5.2 eth-ens-namehash: 2.0.8 @@ -11230,11 +13622,8 @@ packages: transitivePeerDependencies: - encoding - supports-color - dev: false - /web3-eth-ens@1.10.4: - resolution: {integrity: sha512-LLrvxuFeVooRVZ9e5T6OWKVflHPFgrVjJ/jtisRWcmI7KN/b64+D/wJzXqgmp6CNsMQcE7rpmf4CQmJCrTdsgg==} - engines: {node: '>=8.0.0'} + web3-eth-ens@1.10.4: dependencies: content-hash: 2.5.2 eth-ens-namehash: 2.0.8 @@ -11248,16 +13637,14 @@ packages: - encoding - supports-color - /web3-eth-ens@4.2.0(typescript@5.0.4): - resolution: {integrity: sha512-qYj34te2UctoObt8rlEIY/t2MuTMiMiiHhO2JAHRGqSLCQ7b8DM3RpvkiiSB0N0ZyEn+CetZqJCTYb8DNKBS/g==} - engines: {node: '>=14', npm: '>=6.12.0'} + web3-eth-ens@4.2.0(bufferutil@4.0.8)(typescript@5.0.4)(utf-8-validate@5.0.10)(zod@3.23.8): dependencies: '@adraffy/ens-normalize': 1.10.1 - web3-core: 4.3.2 + web3-core: 4.3.2(bufferutil@4.0.8)(utf-8-validate@5.0.10) web3-errors: 1.1.4 - web3-eth: 4.6.0(typescript@5.0.4) - web3-eth-contract: 4.4.0(typescript@5.0.4) - web3-net: 4.0.7 + web3-eth: 4.6.0(bufferutil@4.0.8)(typescript@5.0.4)(utf-8-validate@5.0.10)(zod@3.23.8) + web3-eth-contract: 4.4.0(bufferutil@4.0.8)(typescript@5.0.4)(utf-8-validate@5.0.10)(zod@3.23.8) + web3-net: 4.0.7(bufferutil@4.0.8)(utf-8-validate@5.0.10) web3-types: 1.6.0 web3-utils: 4.2.3 web3-validator: 2.0.5 @@ -11267,44 +13654,25 @@ packages: - typescript - utf-8-validate - zod - dev: true - /web3-eth-iban@1.10.0: - resolution: {integrity: sha512-0l+SP3IGhInw7Q20LY3IVafYEuufo4Dn75jAHT7c2aDJsIolvf2Lc6ugHkBajlwUneGfbRQs/ccYPQ9JeMUbrg==} - engines: {node: '>=8.0.0'} + web3-eth-iban@1.10.0: dependencies: bn.js: 5.2.1 web3-utils: 1.10.0 - dev: false - - /web3-eth-iban@1.10.3: - resolution: {integrity: sha512-ZCfOjYKAjaX2TGI8uif5ah+J3BYFuo+47JOIV1RIz2l7kD9VfnxvRH5UiQDRyMALQC7KFd2hUqIEtHklapNyKA==} - engines: {node: '>=8.0.0'} - dependencies: - bn.js: 5.2.1 - web3-utils: 1.10.3 - dev: false - /web3-eth-iban@1.10.4: - resolution: {integrity: sha512-0gE5iNmOkmtBmbKH2aTodeompnNE8jEyvwFJ6s/AF6jkw9ky9Op9cqfzS56AYAbrqEFuClsqB/AoRves7LDELw==} - engines: {node: '>=8.0.0'} + web3-eth-iban@1.10.4: dependencies: bn.js: 5.2.1 web3-utils: 1.10.4 - /web3-eth-iban@4.0.7: - resolution: {integrity: sha512-8weKLa9KuKRzibC87vNLdkinpUE30gn0IGY027F8doeJdcPUfsa4IlBgNC4k4HLBembBB2CTU0Kr/HAOqMeYVQ==} - engines: {node: '>=14', npm: '>=6.12.0'} + web3-eth-iban@4.0.7: dependencies: web3-errors: 1.1.4 web3-types: 1.6.0 web3-utils: 4.2.3 web3-validator: 2.0.5 - dev: true - /web3-eth-personal@1.10.0: - resolution: {integrity: sha512-anseKn98w/d703eWq52uNuZi7GhQeVjTC5/svrBWEKob0WZ5kPdo+EZoFN0sp5a5ubbrk/E0xSl1/M5yORMtpg==} - engines: {node: '>=8.0.0'} + web3-eth-personal@1.10.0: dependencies: '@types/node': 12.20.55 web3-core: 1.10.0 @@ -11315,11 +13683,8 @@ packages: transitivePeerDependencies: - encoding - supports-color - dev: false - /web3-eth-personal@1.10.4: - resolution: {integrity: sha512-BRa/hs6jU1hKHz+AC/YkM71RP3f0Yci1dPk4paOic53R4ZZG4MgwKRkJhgt3/GPuPliwS46f/i5A7fEGBT4F9w==} - engines: {node: '>=8.0.0'} + web3-eth-personal@1.10.4: dependencies: '@types/node': 12.20.55 web3-core: 1.10.4 @@ -11331,13 +13696,11 @@ packages: - encoding - supports-color - /web3-eth-personal@4.0.8(typescript@5.0.4): - resolution: {integrity: sha512-sXeyLKJ7ddQdMxz1BZkAwImjqh7OmKxhXoBNF3isDmD4QDpMIwv/t237S3q4Z0sZQamPa/pHebJRWVuvP8jZdw==} - engines: {node: '>=14', npm: '>=6.12.0'} + web3-eth-personal@4.0.8(bufferutil@4.0.8)(typescript@5.0.4)(utf-8-validate@5.0.10)(zod@3.23.8): dependencies: - web3-core: 4.3.2 - web3-eth: 4.6.0(typescript@5.0.4) - web3-rpc-methods: 1.2.0 + web3-core: 4.3.2(bufferutil@4.0.8)(utf-8-validate@5.0.10) + web3-eth: 4.6.0(bufferutil@4.0.8)(typescript@5.0.4)(utf-8-validate@5.0.10)(zod@3.23.8) + web3-rpc-methods: 1.2.0(bufferutil@4.0.8)(utf-8-validate@5.0.10) web3-types: 1.6.0 web3-utils: 4.2.3 web3-validator: 2.0.5 @@ -11347,11 +13710,8 @@ packages: - typescript - utf-8-validate - zod - dev: true - /web3-eth@1.10.0: - resolution: {integrity: sha512-Z5vT6slNMLPKuwRyKGbqeGYC87OAy8bOblaqRTgg94CXcn/mmqU7iPIlG4506YdcdK3x6cfEDG7B6w+jRxypKA==} - engines: {node: '>=8.0.0'} + web3-eth@1.10.0: dependencies: web3-core: 1.10.0 web3-core-helpers: 1.10.0 @@ -11368,11 +13728,8 @@ packages: transitivePeerDependencies: - encoding - supports-color - dev: false - /web3-eth@1.10.4: - resolution: {integrity: sha512-Sql2kYKmgt+T/cgvg7b9ce24uLS7xbFrxE4kuuor1zSCGrjhTJ5rRNG8gTJUkAJGKJc7KgnWmgW+cOfMBPUDSA==} - engines: {node: '>=8.0.0'} + web3-eth@1.10.4: dependencies: web3-core: 1.10.4 web3-core-helpers: 1.10.4 @@ -11390,18 +13747,16 @@ packages: - encoding - supports-color - /web3-eth@4.6.0(typescript@5.0.4): - resolution: {integrity: sha512-8KtxlGsomovoFULqEpfixgmCpaJ2YIJGxbXUfezh2coXHjVgEopQhARYtKGClyV5kkdCIqwHS8Gvsm6TVNqH6Q==} - engines: {node: '>=14', npm: '>=6.12.0'} + web3-eth@4.6.0(bufferutil@4.0.8)(typescript@5.0.4)(utf-8-validate@5.0.10)(zod@3.23.8): dependencies: setimmediate: 1.0.5 - web3-core: 4.3.2 + web3-core: 4.3.2(bufferutil@4.0.8)(utf-8-validate@5.0.10) web3-errors: 1.1.4 - web3-eth-abi: 4.2.1(typescript@5.0.4) + web3-eth-abi: 4.2.1(typescript@5.0.4)(zod@3.23.8) web3-eth-accounts: 4.1.2 - web3-net: 4.0.7 - web3-providers-ws: 4.0.7 - web3-rpc-methods: 1.2.0 + web3-net: 4.0.7(bufferutil@4.0.8)(utf-8-validate@5.0.10) + web3-providers-ws: 4.0.7(bufferutil@4.0.8)(utf-8-validate@5.0.10) + web3-rpc-methods: 1.2.0(bufferutil@4.0.8)(utf-8-validate@5.0.10) web3-types: 1.6.0 web3-utils: 4.2.3 web3-validator: 2.0.5 @@ -11411,11 +13766,8 @@ packages: - typescript - utf-8-validate - zod - dev: true - /web3-net@1.10.0: - resolution: {integrity: sha512-NLH/N3IshYWASpxk4/18Ge6n60GEvWBVeM8inx2dmZJVmRI6SJIlUxbL8jySgiTn3MMZlhbdvrGo8fpUW7a1GA==} - engines: {node: '>=8.0.0'} + web3-net@1.10.0: dependencies: web3-core: 1.10.0 web3-core-method: 1.10.0 @@ -11423,11 +13775,8 @@ packages: transitivePeerDependencies: - encoding - supports-color - dev: false - /web3-net@1.10.4: - resolution: {integrity: sha512-mKINnhOOnZ4koA+yV2OT5s5ztVjIx7IY9a03w6s+yao/BUn+Luuty0/keNemZxTr1E8Ehvtn28vbOtW7Ids+Ow==} - engines: {node: '>=8.0.0'} + web3-net@1.10.4: dependencies: web3-core: 1.10.4 web3-core-method: 1.10.4 @@ -11436,23 +13785,18 @@ packages: - encoding - supports-color - /web3-net@4.0.7: - resolution: {integrity: sha512-SzEaXFrBjY25iQGk5myaOfO9ZyfTwQEa4l4Ps4HDNVMibgZji3WPzpjq8zomVHMwi8bRp6VV7YS71eEsX7zLow==} - engines: {node: '>=14', npm: '>=6.12.0'} + web3-net@4.0.7(bufferutil@4.0.8)(utf-8-validate@5.0.10): dependencies: - web3-core: 4.3.2 - web3-rpc-methods: 1.2.0 + web3-core: 4.3.2(bufferutil@4.0.8)(utf-8-validate@5.0.10) + web3-rpc-methods: 1.2.0(bufferutil@4.0.8)(utf-8-validate@5.0.10) web3-types: 1.6.0 web3-utils: 4.2.3 transitivePeerDependencies: - bufferutil - encoding - utf-8-validate - dev: true - /web3-providers-http@1.10.0: - resolution: {integrity: sha512-eNr965YB8a9mLiNrkjAWNAPXgmQWfpBfkkn7tpEFlghfww0u3I0tktMZiaToJVcL2+Xq+81cxbkpeWJ5XQDwOA==} - engines: {node: '>=8.0.0'} + web3-providers-http@1.10.0: dependencies: abortcontroller-polyfill: 1.7.5 cross-fetch: 3.1.8 @@ -11460,11 +13804,8 @@ packages: web3-core-helpers: 1.10.0 transitivePeerDependencies: - encoding - dev: false - /web3-providers-http@1.10.4: - resolution: {integrity: sha512-m2P5Idc8hdiO0l60O6DSCPw0kw64Zgi0pMjbEFRmxKIck2Py57RQMu4bxvkxJwkF06SlGaEQF8rFZBmuX7aagQ==} - engines: {node: '>=8.0.0'} + web3-providers-http@1.10.4: dependencies: abortcontroller-polyfill: 1.7.5 cross-fetch: 4.0.0 @@ -11473,9 +13814,7 @@ packages: transitivePeerDependencies: - encoding - /web3-providers-http@4.1.0: - resolution: {integrity: sha512-6qRUGAhJfVQM41E5t+re5IHYmb5hSaLc02BE2MaRQsz2xKA6RjmHpOA5h/+ojJxEpI9NI2CrfDKOAgtJfoUJQg==} - engines: {node: '>=14', npm: '>=6.12.0'} + web3-providers-http@4.1.0: dependencies: cross-fetch: 4.0.0 web3-errors: 1.1.4 @@ -11483,48 +13822,33 @@ packages: web3-utils: 4.2.3 transitivePeerDependencies: - encoding - dev: true - /web3-providers-ipc@1.10.0: - resolution: {integrity: sha512-OfXG1aWN8L1OUqppshzq8YISkWrYHaATW9H8eh0p89TlWMc1KZOL9vttBuaBEi96D/n0eYDn2trzt22bqHWfXA==} - engines: {node: '>=8.0.0'} + web3-providers-ipc@1.10.0: dependencies: oboe: 2.1.5 web3-core-helpers: 1.10.0 - dev: false - /web3-providers-ipc@1.10.4: - resolution: {integrity: sha512-YRF/bpQk9z3WwjT+A6FI/GmWRCASgd+gC0si7f9zbBWLXjwzYAKG73bQBaFRAHex1hl4CVcM5WUMaQXf3Opeuw==} - engines: {node: '>=8.0.0'} + web3-providers-ipc@1.10.4: dependencies: oboe: 2.1.5 web3-core-helpers: 1.10.4 - /web3-providers-ipc@4.0.7: - resolution: {integrity: sha512-YbNqY4zUvIaK2MHr1lQFE53/8t/ejHtJchrWn9zVbFMGXlTsOAbNoIoZWROrg1v+hCBvT2c9z8xt7e/+uz5p1g==} - engines: {node: '>=14', npm: '>=6.12.0'} - requiresBuild: true + web3-providers-ipc@4.0.7: dependencies: web3-errors: 1.1.4 web3-types: 1.6.0 web3-utils: 4.2.3 - dev: true optional: true - /web3-providers-ws@1.10.0: - resolution: {integrity: sha512-sK0fNcglW36yD5xjnjtSGBnEtf59cbw4vZzJ+CmOWIKGIR96mP5l684g0WD0Eo+f4NQc2anWWXG74lRc9OVMCQ==} - engines: {node: '>=8.0.0'} + web3-providers-ws@1.10.0: dependencies: eventemitter3: 4.0.4 web3-core-helpers: 1.10.0 websocket: 1.0.34 transitivePeerDependencies: - supports-color - dev: false - /web3-providers-ws@1.10.4: - resolution: {integrity: sha512-j3FBMifyuFFmUIPVQR4pj+t5ILhAexAui0opgcpu9R5LxQrLRUZxHSnU+YO25UycSOa/NAX8A+qkqZNpcFAlxA==} - engines: {node: '>=8.0.0'} + web3-providers-ws@1.10.4: dependencies: eventemitter3: 4.0.4 web3-core-helpers: 1.10.4 @@ -11532,38 +13856,29 @@ packages: transitivePeerDependencies: - supports-color - /web3-providers-ws@4.0.7: - resolution: {integrity: sha512-n4Dal9/rQWjS7d6LjyEPM2R458V8blRm0eLJupDEJOOIBhGYlxw5/4FthZZ/cqB7y/sLVi7K09DdYx2MeRtU5w==} - engines: {node: '>=14', npm: '>=6.12.0'} + web3-providers-ws@4.0.7(bufferutil@4.0.8)(utf-8-validate@5.0.10): dependencies: '@types/ws': 8.5.3 - isomorphic-ws: 5.0.0(ws@8.17.0) + isomorphic-ws: 5.0.0(ws@8.17.0(bufferutil@4.0.8)(utf-8-validate@5.0.10)) web3-errors: 1.1.4 web3-types: 1.6.0 web3-utils: 4.2.3 - ws: 8.17.0 + ws: 8.17.0(bufferutil@4.0.8)(utf-8-validate@5.0.10) transitivePeerDependencies: - bufferutil - utf-8-validate - dev: true - /web3-rpc-methods@1.2.0: - resolution: {integrity: sha512-CWJ/g4I4WyYvLkf21wCZAehdhU/VjX/OAPHnqF5/FPDJlogOsOnGXHqi1Z5AP+ocdt395PNubd8jyMMJoYGSBA==} - engines: {node: '>=14', npm: '>=6.12.0'} + web3-rpc-methods@1.2.0(bufferutil@4.0.8)(utf-8-validate@5.0.10): dependencies: - web3-core: 4.3.2 + web3-core: 4.3.2(bufferutil@4.0.8)(utf-8-validate@5.0.10) web3-types: 1.6.0 web3-validator: 2.0.5 transitivePeerDependencies: - bufferutil - encoding - utf-8-validate - dev: true - /web3-shh@1.10.0: - resolution: {integrity: sha512-uNUUuNsO2AjX41GJARV9zJibs11eq6HtOe6Wr0FtRUcj8SN6nHeYIzwstAvJ4fXA53gRqFMTxdntHEt9aXVjpg==} - engines: {node: '>=8.0.0'} - requiresBuild: true + web3-shh@1.10.0: dependencies: web3-core: 1.10.0 web3-core-method: 1.10.0 @@ -11572,12 +13887,8 @@ packages: transitivePeerDependencies: - encoding - supports-color - dev: false - /web3-shh@1.10.4: - resolution: {integrity: sha512-cOH6iFFM71lCNwSQrC3niqDXagMqrdfFW85hC9PFUrAr3PUrIem8TNstTc3xna2bwZeWG6OBy99xSIhBvyIACw==} - engines: {node: '>=8.0.0'} - requiresBuild: true + web3-shh@1.10.4: dependencies: web3-core: 1.10.4 web3-core-method: 1.10.4 @@ -11587,14 +13898,9 @@ packages: - encoding - supports-color - /web3-types@1.6.0: - resolution: {integrity: sha512-qgOtADqlD5hw+KPKBUGaXAcdNLL0oh6qTeVgXwewCfbL/lG9R+/GrgMQB1gbTJ3cit8hMwtH8KX2Em6OwO0HRw==} - engines: {node: '>=14', npm: '>=6.12.0'} - dev: true + web3-types@1.6.0: {} - /web3-utils@1.10.0: - resolution: {integrity: sha512-kSaCM0uMcZTNUSmn5vMEhlo02RObGNRRCkdX0V9UTAU0+lrvn0HSaudyCo6CQzuXUsnuY2ERJGCGPfeWmv19Rg==} - engines: {node: '>=8.0.0'} + web3-utils@1.10.0: dependencies: bn.js: 5.2.1 ethereum-bloom-filters: 1.1.0 @@ -11603,25 +13909,8 @@ packages: number-to-bn: 1.7.0 randombytes: 2.1.0 utf8: 3.0.0 - dev: false - - /web3-utils@1.10.3: - resolution: {integrity: sha512-OqcUrEE16fDBbGoQtZXWdavsPzbGIDc5v3VrRTZ0XrIpefC/viZ1ZU9bGEemazyS0catk/3rkOOxpzTfY+XsyQ==} - engines: {node: '>=8.0.0'} - dependencies: - '@ethereumjs/util': 8.1.0 - bn.js: 5.2.1 - ethereum-bloom-filters: 1.1.0 - ethereum-cryptography: 2.1.3 - ethjs-unit: 0.1.6 - number-to-bn: 1.7.0 - randombytes: 2.1.0 - utf8: 3.0.0 - dev: false - /web3-utils@1.10.4: - resolution: {integrity: sha512-tsu8FiKJLk2PzhDl9fXbGUWTkkVXYhtTA+SmEFkKft+9BgwLxfCRpU96sWv7ICC8zixBNd3JURVoiR3dUXgP8A==} - engines: {node: '>=8.0.0'} + web3-utils@1.10.4: dependencies: '@ethereumjs/util': 8.1.0 bn.js: 5.2.1 @@ -11632,54 +13921,41 @@ packages: randombytes: 2.1.0 utf8: 3.0.0 - /web3-utils@4.2.3: - resolution: {integrity: sha512-m5plKTC2YtQntHITQRyIePw52UVP1IrShhmA2FACtn4zmc5ADmrXOlQWiPzxFP/18eRJsAaUAw2+CQn1u4WPxQ==} - engines: {node: '>=14', npm: '>=6.12.0'} + web3-utils@4.2.3: dependencies: ethereum-cryptography: 2.1.3 eventemitter3: 5.0.1 web3-errors: 1.1.4 web3-types: 1.6.0 web3-validator: 2.0.5 - dev: true - /web3-validator@2.0.5: - resolution: {integrity: sha512-2gLOSW8XqEN5pw5jVUm20EB7A8SbQiekpAtiI0JBmCIV0a2rp97v8FgWY5E3UEqnw5WFfEqvcDVW92EyynDTyQ==} - engines: {node: '>=14', npm: '>=6.12.0'} + web3-validator@2.0.5: dependencies: ethereum-cryptography: 2.1.3 util: 0.12.5 web3-errors: 1.1.4 web3-types: 1.6.0 zod: 3.23.8 - dev: true - /web3@0.20.6: - resolution: {integrity: sha512-diON1+Y8sPQ33htuTMZfyo+qlsmCBSYwi+MVTRneS8anqZUaTrGaBkTpPkPUvfX1X+NK+Y2spLaaei3HfXeSuw==} + web3@0.20.6: dependencies: - bignumber.js: github.com/frozeman/bignumber.js-nolookahead/57692b3ecfc98bbdd6b3a516cb2353652ea49934 + bignumber.js: https://codeload.github.com/frozeman/bignumber.js-nolookahead/tar.gz/57692b3ecfc98bbdd6b3a516cb2353652ea49934 crypto-js: 3.3.0 utf8: 2.1.2 xhr2: 0.2.1 xmlhttprequest: 1.8.0 - dev: false - /web3@0.20.7: - resolution: {integrity: sha512-VU6/DSUX93d1fCzBz7WP/SGCQizO1rKZi4Px9j/3yRyfssHyFcZamMw2/sj4E8TlfMXONvZLoforR8B4bRoyTQ==} + web3@0.20.7: dependencies: - bignumber.js: github.com/frozeman/bignumber.js-nolookahead/57692b3ecfc98bbdd6b3a516cb2353652ea49934 + bignumber.js: https://codeload.github.com/frozeman/bignumber.js-nolookahead/tar.gz/57692b3ecfc98bbdd6b3a516cb2353652ea49934 crypto-js: 3.3.0 utf8: 2.1.2 xhr2-cookies: 1.1.0 xmlhttprequest: 1.8.0 - dev: true - /web3@1.10.0: - resolution: {integrity: sha512-YfKY9wSkGcM8seO+daR89oVTcbu18NsVfvOngzqMYGUU0pPSQmE57qQDvQzUeoIOHAnXEBNzrhjQJmm8ER0rng==} - engines: {node: '>=8.0.0'} - requiresBuild: true + web3@1.10.0(bufferutil@4.0.8)(utf-8-validate@5.0.10): dependencies: - web3-bzz: 1.10.0 + web3-bzz: 1.10.0(bufferutil@4.0.8)(utf-8-validate@5.0.10) web3-core: 1.10.0 web3-eth: 1.10.0 web3-eth-personal: 1.10.0 @@ -11691,14 +13967,10 @@ packages: - encoding - supports-color - utf-8-validate - dev: false - /web3@1.10.4: - resolution: {integrity: sha512-kgJvQZjkmjOEKimx/tJQsqWfRDPTTcBfYPa9XletxuHLpHcXdx67w8EFn5AW3eVxCutE9dTVHgGa9VYe8vgsEA==} - engines: {node: '>=8.0.0'} - requiresBuild: true + web3@1.10.4(bufferutil@4.0.8)(utf-8-validate@5.0.10): dependencies: - web3-bzz: 1.10.4 + web3-bzz: 1.10.4(bufferutil@4.0.8)(utf-8-validate@5.0.10) web3-core: 1.10.4 web3-eth: 1.10.4 web3-eth-personal: 1.10.4 @@ -11711,23 +13983,21 @@ packages: - supports-color - utf-8-validate - /web3@4.8.0(typescript@5.0.4): - resolution: {integrity: sha512-kQSF2NlHk8yjS3SRiJW3S+U5ibkEmVRhB4/GYsVwGvdAkFC2b+EIE1Ob7J56OmqW9VBZgkx1+SuWqo5JTIJSYQ==} - engines: {node: '>=14.0.0', npm: '>=6.12.0'} + web3@4.8.0(bufferutil@4.0.8)(typescript@5.0.4)(utf-8-validate@5.0.10)(zod@3.23.8): dependencies: - web3-core: 4.3.2 + web3-core: 4.3.2(bufferutil@4.0.8)(utf-8-validate@5.0.10) web3-errors: 1.1.4 - web3-eth: 4.6.0(typescript@5.0.4) - web3-eth-abi: 4.2.1(typescript@5.0.4) + web3-eth: 4.6.0(bufferutil@4.0.8)(typescript@5.0.4)(utf-8-validate@5.0.10)(zod@3.23.8) + web3-eth-abi: 4.2.1(typescript@5.0.4)(zod@3.23.8) web3-eth-accounts: 4.1.2 - web3-eth-contract: 4.4.0(typescript@5.0.4) - web3-eth-ens: 4.2.0(typescript@5.0.4) + web3-eth-contract: 4.4.0(bufferutil@4.0.8)(typescript@5.0.4)(utf-8-validate@5.0.10)(zod@3.23.8) + web3-eth-ens: 4.2.0(bufferutil@4.0.8)(typescript@5.0.4)(utf-8-validate@5.0.10)(zod@3.23.8) web3-eth-iban: 4.0.7 - web3-eth-personal: 4.0.8(typescript@5.0.4) - web3-net: 4.0.7 + web3-eth-personal: 4.0.8(bufferutil@4.0.8)(typescript@5.0.4)(utf-8-validate@5.0.10)(zod@3.23.8) + web3-net: 4.0.7(bufferutil@4.0.8)(utf-8-validate@5.0.10) web3-providers-http: 4.1.0 - web3-providers-ws: 4.0.7 - web3-rpc-methods: 1.2.0 + web3-providers-ws: 4.0.7(bufferutil@4.0.8)(utf-8-validate@5.0.10) + web3-rpc-methods: 1.2.0(bufferutil@4.0.8)(utf-8-validate@5.0.10) web3-types: 1.6.0 web3-utils: 4.2.3 web3-validator: 2.0.5 @@ -11737,14 +14007,10 @@ packages: - typescript - utf-8-validate - zod - dev: true - /webidl-conversions@3.0.1: - resolution: {integrity: sha512-2JAn3z8AR6rjK8Sm8orRC0h/bcl/DqL7tRPdGZ4I1CjdF+EaMLmYxBHyXuKL849eucPFhvBoxMsflfOb8kxaeQ==} + webidl-conversions@3.0.1: {} - /websocket@1.0.34: - resolution: {integrity: sha512-PRDso2sGwF6kM75QykIesBijKSVceR6jL2G8NGYyq2XrItNC2P5/qL5XeR056GhA+Ly7JMFvJb9I312mJfmqnQ==} - engines: {node: '>=4.0.0'} + websocket@1.0.34: dependencies: bufferutil: 4.0.8 debug: 2.6.9 @@ -11755,45 +14021,31 @@ packages: transitivePeerDependencies: - supports-color - /whatwg-fetch@3.6.20: - resolution: {integrity: sha512-EqhiFU6daOA8kpjOWTL0olhVOF3i7OrFzSYiGsEMB8GcXS+RrzauAERX65xMeNWVqxA6HXH2m69Z9LaKKdisfg==} - dev: true + whatwg-fetch@3.6.20: {} - /whatwg-url@5.0.0: - resolution: {integrity: sha512-saE57nupxk6v3HY35+jzBwYa0rKSy0XR8JSxZPwgLr7ys0IBzhGviA1/TUGJLmSVqs8pb9AnvICXEuOHLprYTw==} + whatwg-url@5.0.0: dependencies: tr46: 0.0.3 webidl-conversions: 3.0.1 - /which-boxed-primitive@1.0.2: - resolution: {integrity: sha512-bwZdv0AKLpplFY2KZRX6TvyuN7ojjr7lwkg6ml0roIy9YeuSr7JS372qlNW18UQYzgYK9ziGcerWqZOmEn9VNg==} + which-boxed-primitive@1.0.2: dependencies: is-bigint: 1.0.4 is-boolean-object: 1.1.2 is-number-object: 1.0.7 is-string: 1.0.7 is-symbol: 1.0.4 - dev: true - /which-module@1.0.0: - resolution: {integrity: sha512-F6+WgncZi/mJDrammbTuHe1q0R5hOXv/mBaiNA2TCNT/LTHusX0V+CJnj9XT8ki5ln2UZyyddDgHfCzyrOH7MQ==} - dev: false + which-module@1.0.0: {} - /which-module@2.0.1: - resolution: {integrity: sha512-iBdZ57RDvnOR9AGBhML2vFZf7h8vmBjhoaZqODJBFWHVtKkDmKuHai3cx5PgVMrX5YDNp27AofYbAwctSS+vhQ==} - dev: true + which-module@2.0.1: {} - /which-pm@2.0.0: - resolution: {integrity: sha512-Lhs9Pmyph0p5n5Z3mVnN0yWcbQYUAD7rbQUiMsQxOJ3T57k7RFe35SUwWMf7dsbDZks1uOmw4AecB/JMDj3v/w==} - engines: {node: '>=8.15'} + which-pm@2.0.0: dependencies: load-yaml-file: 0.2.0 path-exists: 4.0.0 - dev: true - /which-typed-array@1.1.15: - resolution: {integrity: sha512-oV0jmFtUky6CXfkqehVvBP/LSWJ2sy4vWMioiENyJLePrBO/yKyV9OyJySfAKosh+RYkIl5zJCNZ8/4JncrpdA==} - engines: {node: '>= 0.4'} + which-typed-array@1.1.15: dependencies: available-typed-arrays: 1.0.7 call-bind: 1.0.7 @@ -11801,174 +14053,96 @@ packages: gopd: 1.0.1 has-tostringtag: 1.0.2 - /which@1.3.1: - resolution: {integrity: sha512-HxJdYWq1MTIQbJ3nw0cqssHoTNU267KlrDuGZ1WYlxDStUtKUhOaJmh112/TZmHxxUfuJqPXSOm7tDyas0OSIQ==} - hasBin: true + which@1.3.1: dependencies: isexe: 2.0.0 - dev: true - /which@2.0.2: - resolution: {integrity: sha512-BLI3Tl1TW3Pvl70l3yq3Y64i+awpwXqsGBYWkkqMtnbXgrMD+yj7rhW0kuEDxzJaYXGjEW5ogapKNMEKNMjibA==} - engines: {node: '>= 8'} - hasBin: true + which@2.0.2: dependencies: isexe: 2.0.0 - /widest-line@3.1.0: - resolution: {integrity: sha512-NsmoXalsWVDMGupxZ5R08ka9flZjjiLvHVAWYOKtiKM8ujtZWr9cRffak+uSE48+Ob8ObalXpwyeUiyDD6QFgg==} - engines: {node: '>=8'} + widest-line@3.1.0: dependencies: string-width: 4.2.3 - dev: false - /window-size@0.2.0: - resolution: {integrity: sha512-UD7d8HFA2+PZsbKyaOCEy8gMh1oDtHgJh1LfgjQ4zVXmYjAT/kvz3PueITKuqDiIXQe7yzpPnxX3lNc+AhQMyw==} - engines: {node: '>= 0.10.0'} - hasBin: true - dev: false + window-size@0.2.0: {} - /word-wrap@1.2.5: - resolution: {integrity: sha512-BN22B5eaMMI9UMtjrGd5g5eCYPpCPDUy0FJXbYsaT5zYxjFOckS53SQDE3pWkVoWpHXVb3BrYcEN4Twa55B5cA==} - engines: {node: '>=0.10.0'} + word-wrap@1.2.5: {} - /wordwrap@1.0.0: - resolution: {integrity: sha512-gvVzJFlPycKc5dZN4yPkP8w7Dc37BtP1yczEneOb4uq34pXZcvrtRTmWV8W+Ume+XCxKgbjM+nevkyFPMybd4Q==} - dev: true + wordwrap@1.0.0: {} - /wordwrapjs@4.0.1: - resolution: {integrity: sha512-kKlNACbvHrkpIw6oPeYDSmdCTu2hdMHoyXLTcUKala++lx5Y+wjJ/e474Jqv5abnVmwxw08DiTuHmw69lJGksA==} - engines: {node: '>=8.0.0'} + wordwrapjs@4.0.1: dependencies: reduce-flatten: 2.0.0 typical: 5.2.0 - dev: true - /workerpool@6.2.1: - resolution: {integrity: sha512-ILEIE97kDZvF9Wb9f6h5aXK4swSlKGUcOEGiIYb2OOu/IrDU9iwj0fD//SsA6E5ibwJxpEvhullJY4Sl4GcpAw==} + workerpool@6.2.1: {} - /wrap-ansi@2.1.0: - resolution: {integrity: sha512-vAaEaDM946gbNpH5pLVNR+vX2ht6n0Bt3GXwVB1AuAqZosOvHNF3P7wDnh8KLkSqgUh0uh77le7Owgoz+Z9XBw==} - engines: {node: '>=0.10.0'} + wrap-ansi@2.1.0: dependencies: string-width: 1.0.2 strip-ansi: 3.0.1 - dev: false - /wrap-ansi@6.2.0: - resolution: {integrity: sha512-r6lPcBGxZXlIcymEu7InxDMhdW0KDxpLgoFLcguasxCaJ/SOIZwINatK9KY/tf+ZrlywOKU0UDj3ATXUBfxJXA==} - engines: {node: '>=8'} + wrap-ansi@6.2.0: dependencies: ansi-styles: 4.3.0 string-width: 4.2.3 strip-ansi: 6.0.1 - dev: true - /wrap-ansi@7.0.0: - resolution: {integrity: sha512-YVGIj2kamLSTxw6NsZjoBxfSwsn0ycdesmc4p+Q21c5zPuZ1pl+NfxVdxPtdHvmNVOQ6XSYG4AUtyt/Fi7D16Q==} - engines: {node: '>=10'} + wrap-ansi@7.0.0: dependencies: ansi-styles: 4.3.0 string-width: 4.2.3 strip-ansi: 6.0.1 - /wrappy@1.0.2: - resolution: {integrity: sha512-l4Sp/DRseor9wL6EvV2+TuQn63dMkPjZ/sp9XkghTEbV9KlPS1xUsZ3u7/IQO4wxtcFB4bgpQPRcR3QCvezPcQ==} + wrappy@1.0.2: {} - /write-file-atomic@3.0.3: - resolution: {integrity: sha512-AvHcyZ5JnSfq3ioSyjrBkH9yW4m7Ayk8/9My/DD9onKeu/94fwrMocemO2QAJFAlnnDN+ZDS+ZjAR5ua1/PV/Q==} + write-file-atomic@3.0.3: dependencies: imurmurhash: 0.1.4 is-typedarray: 1.0.0 signal-exit: 3.0.7 typedarray-to-buffer: 3.1.5 - dev: true - /ws@3.3.3: - resolution: {integrity: sha512-nnWLa/NwZSt4KQJu51MYlCcSQ5g7INpOrOMt4XV8j4dqTXdmlUmSHQ8/oLC069ckre0fRsgfvsKwbTdtKLCDkA==} - peerDependencies: - bufferutil: ^4.0.1 - utf-8-validate: ^5.0.2 - peerDependenciesMeta: - bufferutil: - optional: true - utf-8-validate: - optional: true + ws@3.3.3(bufferutil@4.0.8)(utf-8-validate@5.0.10): dependencies: async-limiter: 1.0.1 safe-buffer: 5.1.2 ultron: 1.1.1 + optionalDependencies: + bufferutil: 4.0.8 + utf-8-validate: 5.0.10 - /ws@7.4.6: - resolution: {integrity: sha512-YmhHDO4MzaDLB+M9ym/mDA5z0naX8j7SIlT8f8z+I0VtzsRbekxEutHSme7NPS2qE8StCYQNUnfWdXta/Yu85A==} - engines: {node: '>=8.3.0'} - peerDependencies: - bufferutil: ^4.0.1 - utf-8-validate: ^5.0.2 - peerDependenciesMeta: - bufferutil: - optional: true - utf-8-validate: - optional: true + ws@7.4.6(bufferutil@4.0.8)(utf-8-validate@5.0.10): + optionalDependencies: + bufferutil: 4.0.8 + utf-8-validate: 5.0.10 - /ws@7.5.9: - resolution: {integrity: sha512-F+P9Jil7UiSKSkppIiD94dN07AwvFixvLIj1Og1Rl9GGMuNipJnV9JzjD6XuqmAeiswGvUmNLjr5cFuXwNS77Q==} - engines: {node: '>=8.3.0'} - peerDependencies: - bufferutil: ^4.0.1 - utf-8-validate: ^5.0.2 - peerDependenciesMeta: - bufferutil: - optional: true - utf-8-validate: - optional: true - dev: false + ws@7.5.9(bufferutil@4.0.8)(utf-8-validate@5.0.10): + optionalDependencies: + bufferutil: 4.0.8 + utf-8-validate: 5.0.10 - /ws@8.13.0: - resolution: {integrity: sha512-x9vcZYTrFPC7aSIbj7sRCYo7L/Xb8Iy+pW0ng0wt2vCJv7M9HOMy0UoN3rr+IFC7hb7vXoqS+P9ktyLLLhO+LA==} - engines: {node: '>=10.0.0'} - peerDependencies: - bufferutil: ^4.0.1 - utf-8-validate: '>=5.0.2' - peerDependenciesMeta: - bufferutil: - optional: true - utf-8-validate: - optional: true - dev: true + ws@8.13.0(bufferutil@4.0.8)(utf-8-validate@5.0.10): + optionalDependencies: + bufferutil: 4.0.8 + utf-8-validate: 5.0.10 - /ws@8.17.0: - resolution: {integrity: sha512-uJq6108EgZMAl20KagGkzCKfMEjxmKvZHG7Tlq0Z6nOky7YF7aq4mOx6xK8TJ/i1LeK4Qus7INktacctDgY8Ow==} - engines: {node: '>=10.0.0'} - peerDependencies: - bufferutil: ^4.0.1 - utf-8-validate: '>=5.0.2' - peerDependenciesMeta: - bufferutil: - optional: true - utf-8-validate: - optional: true - dev: true + ws@8.17.0(bufferutil@4.0.8)(utf-8-validate@5.0.10): + optionalDependencies: + bufferutil: 4.0.8 + utf-8-validate: 5.0.10 - /ws@8.5.0: - resolution: {integrity: sha512-BWX0SWVgLPzYwF8lTzEy1egjhS4S4OEAHfsO8o65WOVsrnSRGaSiUaa9e0ggGlkMTtBlmOpEXiie9RUcBO86qg==} - engines: {node: '>=10.0.0'} - peerDependencies: - bufferutil: ^4.0.1 - utf-8-validate: ^5.0.2 - peerDependenciesMeta: - bufferutil: - optional: true - utf-8-validate: - optional: true + ws@8.5.0(bufferutil@4.0.8)(utf-8-validate@5.0.10): + optionalDependencies: + bufferutil: 4.0.8 + utf-8-validate: 5.0.10 - /xhr-request-promise@0.1.3: - resolution: {integrity: sha512-YUBytBsuwgitWtdRzXDDkWAXzhdGB8bYm0sSzMPZT7Z2MBjMSTHFsyCT1yCRATY+XC69DUrQraRAEgcoCRaIPg==} + xhr-request-promise@0.1.3: dependencies: xhr-request: 1.1.0 - /xhr-request@1.1.0: - resolution: {integrity: sha512-Y7qzEaR3FDtL3fP30k9wO/e+FBnBByZeybKOhASsGP30NIkRAAkKD/sCnLvgEfAIEC1rcmK7YG8f4oEnIrrWzA==} + xhr-request@1.1.0: dependencies: buffer-to-arraybuffer: 0.0.5 object-assign: 4.1.1 @@ -11978,92 +14152,57 @@ packages: url-set-query: 1.0.0 xhr: 2.6.0 - /xhr2-cookies@1.1.0: - resolution: {integrity: sha512-hjXUA6q+jl/bd8ADHcVfFsSPIf+tyLIjuO9TwJC9WI6JP2zKcS7C+p56I9kCLLsaCiNT035iYvEUUzdEFj/8+g==} + xhr2-cookies@1.1.0: dependencies: cookiejar: 2.1.4 - dev: true - /xhr2@0.2.1: - resolution: {integrity: sha512-sID0rrVCqkVNUn8t6xuv9+6FViXjUVXq8H5rWOH2rz9fDNQEd4g0EA2XlcEdJXRz5BMEn4O1pJFdT+z4YHhoWw==} - engines: {node: '>= 6'} - dev: false + xhr2@0.2.1: {} - /xhr@2.6.0: - resolution: {integrity: sha512-/eCGLb5rxjx5e3mF1A7s+pLlR6CGyqWN91fv1JgER5mVWg1MZmlhBvy9kjcsOdRk8RrIujotWyJamfyrp+WIcA==} + xhr@2.6.0: dependencies: global: 4.4.0 is-function: 1.0.2 parse-headers: 2.0.5 xtend: 4.0.2 - /xmlhttprequest@1.8.0: - resolution: {integrity: sha512-58Im/U0mlVBLM38NdZjHyhuMtCqa61469k2YP/AaPbvCoV9aQGUpbJBj1QRm2ytRiVQBD/fsw7L2bJGDVQswBA==} - engines: {node: '>=0.4.0'} + xmlhttprequest@1.8.0: {} - /xtend@4.0.2: - resolution: {integrity: sha512-LKYU1iAXJXUgAXn9URjiu+MWhyUXHsvfp7mcuYm9dSUKK0/CjtrUwFAxD82/mCWbtLsGjFIad0wIsod4zrTAEQ==} - engines: {node: '>=0.4'} + xtend@4.0.2: {} - /y18n@3.2.2: - resolution: {integrity: sha512-uGZHXkHnhF0XeeAPgnKfPv1bgKAYyVvmNL1xlKsPYZPaIHxGti2hHqvOCQv71XMsLxu1QjergkqogUnms5D3YQ==} - dev: false + y18n@3.2.2: {} - /y18n@4.0.3: - resolution: {integrity: sha512-JKhqTOwSrqNA1NY5lSztJ1GrBiUodLMmIZuLiDaMRJ+itFd+ABVE8XBjOvIWL+rSqNDC74LCSFmlb/U4UZ4hJQ==} - dev: true + y18n@4.0.3: {} - /y18n@5.0.8: - resolution: {integrity: sha512-0pfFzegeDWJHJIAmTLRP2DwHjdF5s7jo9tuztdQxAhINCdvS+3nGINqPd00AphqJR/0LhANUS6/+7SCb98YOfA==} - engines: {node: '>=10'} + y18n@5.0.8: {} - /yaeti@0.0.6: - resolution: {integrity: sha512-MvQa//+KcZCUkBTIC9blM+CU9J2GzuTytsOUwf2lidtvkx/6gnEp1QvJv34t9vdjhFmha/mUiNDbN0D0mJWdug==} - engines: {node: '>=0.10.32'} + yaeti@0.0.6: {} - /yallist@2.1.2: - resolution: {integrity: sha512-ncTzHV7NvsQZkYe1DW7cbDLm0YpzHmZF5r/iyP3ZnQtMiJ+pjzisCiMNI+Sj+xQF5pXhSHxSB3uDbsBTzY/c2A==} - dev: true + yallist@2.1.2: {} - /yallist@3.1.1: - resolution: {integrity: sha512-a4UGQaWPH59mOXUYnAG2ewncQS4i4F43Tv3JoAM+s2VDAmS9NsK8GpDMLrCHPksFT7h3K6TOoUNn2pb7RoXx4g==} + yallist@3.1.1: {} - /yargs-parser@18.1.3: - resolution: {integrity: sha512-o50j0JeToy/4K6OZcaQmW6lyXXKhq7csREXcDwk2omFPJEwUNOVtJKvmDr9EI1fAJZUyZcRF7kxGBWmRXudrCQ==} - engines: {node: '>=6'} + yargs-parser@18.1.3: dependencies: camelcase: 5.3.1 decamelize: 1.2.0 - dev: true - /yargs-parser@2.4.1: - resolution: {integrity: sha512-9pIKIJhnI5tonzG6OnCFlz/yln8xHYcGl+pn3xR0Vzff0vzN1PbNRaelgfgRUwZ3s4i3jvxT9WhmUGL4whnasA==} + yargs-parser@2.4.1: dependencies: camelcase: 3.0.0 lodash.assign: 4.2.0 - dev: false - /yargs-parser@20.2.4: - resolution: {integrity: sha512-WOkpgNhPTlE73h4VFAFsOnomJVaovO8VqLDzy5saChRBFQFBoMYirowyW+Q9HB4HFF4Z7VZTiG3iSzJJA29yRA==} - engines: {node: '>=10'} + yargs-parser@20.2.4: {} - /yargs-parser@21.1.1: - resolution: {integrity: sha512-tVpsJW7DdjecAiFpbIB1e3qxIQsE6NoPc5/eTdrbbIC4h0LVsWhnoa3g+m2HclBIujHzsxZ4VJVA+GUuc2/LBw==} - engines: {node: '>=12'} - dev: true + yargs-parser@21.1.1: {} - /yargs-unparser@2.0.0: - resolution: {integrity: sha512-7pRTIA9Qc1caZ0bZ6RYRGbHJthJWuakf+WmHK0rVeLkNrrGhfoabBNdue6kdINI6r4if7ocq9aD/n7xwKOdzOA==} - engines: {node: '>=10'} + yargs-unparser@2.0.0: dependencies: camelcase: 6.3.0 decamelize: 4.0.0 flat: 5.0.2 is-plain-obj: 2.1.0 - /yargs@15.4.1: - resolution: {integrity: sha512-aePbxDmcYW++PaqBsJ+HYUFwCdv4LVvdnhBy78E57PIor8/OVvhMrADFFEDh8DHDFRv/O9i3lPhsENjO7QX0+A==} - engines: {node: '>=8'} + yargs@15.4.1: dependencies: cliui: 6.0.0 decamelize: 1.2.0 @@ -12076,11 +14215,8 @@ packages: which-module: 2.0.1 y18n: 4.0.3 yargs-parser: 18.1.3 - dev: true - /yargs@16.2.0: - resolution: {integrity: sha512-D1mvvtDG0L5ft/jGWkLpG1+m0eQxOfaBvTNELraWj22wSVUMWxZUvYgJYcKh6jGGIkJFhH4IZPQhR4TKpc8mBw==} - engines: {node: '>=10'} + yargs@16.2.0: dependencies: cliui: 7.0.4 escalade: 3.1.2 @@ -12090,9 +14226,7 @@ packages: y18n: 5.0.8 yargs-parser: 20.2.4 - /yargs@17.7.2: - resolution: {integrity: sha512-7dSzzRQ++CKnNI/krKnYRV7JKKPUXMEh61soaHKg9mrWEhzFWhFnxPxGl+69cD1Ou63C13NUPCnmIcrvqCuM6w==} - engines: {node: '>=12'} + yargs@17.7.2: dependencies: cliui: 8.0.1 escalade: 3.1.2 @@ -12101,10 +14235,8 @@ packages: string-width: 4.2.3 y18n: 5.0.8 yargs-parser: 21.1.1 - dev: true - /yargs@4.8.1: - resolution: {integrity: sha512-LqodLrnIDM3IFT+Hf/5sxBnEGECrfdC1uIbgZeJmESCSo4HoCAaKEus8MylXHAkdacGc0ye+Qa+dpkuom8uVYA==} + yargs@4.8.1: dependencies: cliui: 3.2.0 decamelize: 1.2.0 @@ -12120,22 +14252,9 @@ packages: window-size: 0.2.0 y18n: 3.2.2 yargs-parser: 2.4.1 - dev: false - /yn@3.1.1: - resolution: {integrity: sha512-Ux4ygGWsu2c7isFWe8Yu1YluJmqVhxqK2cLXNQA5AcC3QfbGNpM7fu0Y8b/z16pXLnFxZYvWhd3fhBY9DLmC6Q==} - engines: {node: '>=6'} - dev: true - - /yocto-queue@0.1.0: - resolution: {integrity: sha512-rVksvsnNCdJ/ohGc6xgPwyN8eheCxsiLM8mxuE/t/mOVqJewPuO1miLpTHQiRgTKCLexL4MeAFVagts7HmNZ2Q==} - engines: {node: '>=10'} + yn@3.1.1: {} - /zod@3.23.8: - resolution: {integrity: sha512-XBx9AXhXktjUqnepgTiE5flcKIYWi/rme0Eaj+5Y0lftuGBq+jyRu/md4WnuxqgP1ubdpNCsYEYPxrzVHD8d6g==} - dev: true + yocto-queue@0.1.0: {} - github.com/frozeman/bignumber.js-nolookahead/57692b3ecfc98bbdd6b3a516cb2353652ea49934: - resolution: {tarball: https://codeload.github.com/frozeman/bignumber.js-nolookahead/tar.gz/57692b3ecfc98bbdd6b3a516cb2353652ea49934} - name: bignumber.js - version: 2.0.7 + zod@3.23.8: {} From 3cb2e307af8d87dbfb0e3129bdab77c0ce925abd Mon Sep 17 00:00:00 2001 From: johnpm-12 <39016062+johnpm-12@users.noreply.github.com> Date: Fri, 17 May 2024 22:05:58 -0700 Subject: [PATCH 04/18] add reverted tests --- .../test/helpers.ts | 2 +- .../test/reverted/reverted.ts | 110 ++++++++---------- .../test/reverted/revertedWithCustomError.ts | 2 +- 3 files changed, 50 insertions(+), 64 deletions(-) diff --git a/packages/hardhat-chai-matchers-viem/test/helpers.ts b/packages/hardhat-chai-matchers-viem/test/helpers.ts index 565cbd5c5e..4da9142703 100644 --- a/packages/hardhat-chai-matchers-viem/test/helpers.ts +++ b/packages/hardhat-chai-matchers-viem/test/helpers.ts @@ -190,9 +190,9 @@ async function mineBlocksUntilTxIsIncluded( ) { let i = 0; + const publicClient = await hre.viem.getPublicClient(); while (true) { try { - const publicClient = await hre.viem.getPublicClient(); await publicClient.getTransactionReceipt({ hash: txHash, }); diff --git a/packages/hardhat-chai-matchers-viem/test/reverted/reverted.ts b/packages/hardhat-chai-matchers-viem/test/reverted/reverted.ts index 7d32cb391b..1d86f8c20e 100644 --- a/packages/hardhat-chai-matchers-viem/test/reverted/reverted.ts +++ b/packages/hardhat-chai-matchers-viem/test/reverted/reverted.ts @@ -1,7 +1,9 @@ +import type { HardhatRuntimeEnvironment } from "hardhat/types/runtime"; import type { MatchersContract } from "../contracts"; import { AssertionError, expect } from "chai"; -import { ProviderError } from "hardhat/internal/core/providers/errors"; +import { TransactionExecutionError } from "viem"; +import { privateKeyToAccount } from "viem/accounts"; import path from "path"; import util from "util"; @@ -22,7 +24,8 @@ describe("INTEGRATION: Reverted", function () { runTests(); }); - describe("connected to a hardhat node", function () { + // external hardhat node with viem does not include error data in many cases + describe.skip("connected to a hardhat node", function () { useEnvironmentWithNode("hardhat-project"); runTests(); @@ -32,11 +35,7 @@ describe("INTEGRATION: Reverted", function () { // deploy Matchers contract before each test let matchers: MatchersContract; beforeEach("deploy matchers contract", async function () { - const Matchers = await this.hre.ethers.getContractFactory< - [], - MatchersContract - >("Matchers"); - matchers = await Matchers.deploy(); + matchers = await this.hre.viem.deployContract("Matchers"); }); // helpers @@ -44,9 +43,17 @@ describe("INTEGRATION: Reverted", function () { return expect(x).to.be.eventually.rejectedWith(AssertionError, message); }; + async function getTransactionReceipt( + hre: HardhatRuntimeEnvironment, + hash: `0x${string}` + ) { + const publicClient = await hre.viem.getPublicClient(); + return publicClient.waitForTransactionReceipt({ hash }); + } + describe("with a string as its subject", function () { it("hash of a successful transaction", async function () { - const { hash } = await mineSuccessfulTransaction(this.hre); + const hash = await mineSuccessfulTransaction(this.hre); await expectAssertionError( expect(hash).to.be.reverted, @@ -56,7 +63,7 @@ describe("INTEGRATION: Reverted", function () { }); it("hash of a reverted transaction", async function () { - const { hash } = await mineRevertedTransaction(this.hre, matchers); + const hash = await mineRevertedTransaction(this.hre, matchers); await expect(hash).to.be.reverted; await expectAssertionError( @@ -78,7 +85,7 @@ describe("INTEGRATION: Reverted", function () { }); it("promise of a hash of a successful transaction", async function () { - const { hash } = await mineSuccessfulTransaction(this.hre); + const hash = await mineSuccessfulTransaction(this.hre); await expectAssertionError( expect(Promise.resolve(hash)).to.be.reverted, @@ -88,7 +95,7 @@ describe("INTEGRATION: Reverted", function () { }); it("promise of a hash of a reverted transaction", async function () { - const { hash } = await mineRevertedTransaction(this.hre, matchers); + const hash = await mineRevertedTransaction(this.hre, matchers); await expect(Promise.resolve(hash)).to.be.reverted; await expectAssertionError( @@ -155,21 +162,20 @@ describe("INTEGRATION: Reverted", function () { ); }); - it("reverted: should throw if chained to another non-chainable method", function () { - const txPromise = mineRevertedTransaction(this.hre, matchers); + it("reverted: should throw if chained to another non-chainable method", async function () { + const tx = await mineRevertedTransaction(this.hre, matchers); expect( () => - expect(txPromise).to.be.revertedWith("an error message").and.to.be - .reverted + expect(tx).to.be.revertedWith("an error message").and.to.be.reverted ).to.throw( /The matcher 'reverted' cannot be chained after 'revertedWith'./ ); }); - it("revertedWith: should throw if chained to another non-chainable method", function () { - const txPromise = mineRevertedTransaction(this.hre, matchers); + it("revertedWith: should throw if chained to another non-chainable method", async function () { + const tx = await mineRevertedTransaction(this.hre, matchers); expect(() => - expect(txPromise) + expect(tx) .to.be.revertedWithCustomError(matchers, "SomeCustomError") .and.to.be.revertedWith("an error message") ).to.throw( @@ -177,10 +183,10 @@ describe("INTEGRATION: Reverted", function () { ); }); - it("revertedWithCustomError: should throw if chained to another non-chainable method", function () { - const txPromise = mineRevertedTransaction(this.hre, matchers); + it("revertedWithCustomError: should throw if chained to another non-chainable method", async function () { + const tx = await mineRevertedTransaction(this.hre, matchers); expect(() => - expect(txPromise) + expect(tx) .to.be.revertedWithoutReason() .and.to.be.revertedWithCustomError(matchers, "SomeCustomError") ).to.throw( @@ -188,22 +194,20 @@ describe("INTEGRATION: Reverted", function () { ); }); - it("revertedWithoutReason: should throw if chained to another non-chainable method", function () { - const txPromise = mineRevertedTransaction(this.hre, matchers); + it("revertedWithoutReason: should throw if chained to another non-chainable method", async function () { + const tx = await mineRevertedTransaction(this.hre, matchers); expect(() => - expect(txPromise) - .to.be.revertedWithPanic() - .and.to.be.revertedWithoutReason() + expect(tx).to.be.revertedWithPanic().and.to.be.revertedWithoutReason() ).to.throw( /The matcher 'revertedWithoutReason' cannot be chained after 'revertedWithPanic'./ ); }); it("revertedWithPanic: should throw if chained to another non-chainable method", async function () { - const [sender] = await this.hre.ethers.getSigners(); - const txPromise = mineRevertedTransaction(this.hre, matchers); + const [sender] = await this.hre.viem.getWalletClients(); + const tx = await mineRevertedTransaction(this.hre, matchers); expect(() => - expect(txPromise) + expect(tx) .to.changeEtherBalance(sender, "-200") .and.to.be.revertedWithPanic() ).to.throw( @@ -215,7 +219,7 @@ describe("INTEGRATION: Reverted", function () { describe("with a TxReceipt as its subject", function () { it("TxReceipt of a successful transaction", async function () { const tx = await mineSuccessfulTransaction(this.hre); - const receipt = await tx.wait(); + const receipt = await getTransactionReceipt(this.hre, tx); await expectAssertionError( expect(receipt).to.be.reverted, @@ -226,9 +230,7 @@ describe("INTEGRATION: Reverted", function () { it("TxReceipt of a reverted transaction", async function () { const tx = await mineRevertedTransaction(this.hre, matchers); - const receipt = await this.hre.ethers.provider.getTransactionReceipt( - tx.hash - ); // tx.wait rejects, so we use provider.getTransactionReceipt + const receipt = await getTransactionReceipt(this.hre, tx); await expect(receipt).to.be.reverted; await expectAssertionError( @@ -239,7 +241,7 @@ describe("INTEGRATION: Reverted", function () { it("promise of a TxReceipt of a successful transaction", async function () { const tx = await mineSuccessfulTransaction(this.hre); - const receiptPromise = tx.wait(); + const receiptPromise = getTransactionReceipt(this.hre, tx); await expectAssertionError( expect(receiptPromise).to.be.reverted, @@ -250,9 +252,7 @@ describe("INTEGRATION: Reverted", function () { it("promise of a TxReceipt of a reverted transaction", async function () { const tx = await mineRevertedTransaction(this.hre, matchers); - const receiptPromise = this.hre.ethers.provider.getTransactionReceipt( - tx.hash - ); // tx.wait rejects, so we use provider.getTransactionReceipt + const receiptPromise = getTransactionReceipt(this.hre, tx); await expect(receiptPromise).to.be.reverted; await expectAssertionError( @@ -267,7 +267,6 @@ describe("INTEGRATION: Reverted", function () { await runSuccessfulAsserts({ matchers, method: "succeeds", - args: [], successfulAssert: (x) => expect(x).to.not.be.reverted, }); }); @@ -276,7 +275,6 @@ describe("INTEGRATION: Reverted", function () { await runFailedAsserts({ matchers, method: "succeeds", - args: [], failedAssert: (x) => expect(x).to.be.reverted, failedAssertReason: "Expected transaction to be reverted", }); @@ -284,24 +282,18 @@ describe("INTEGRATION: Reverted", function () { }); describe("calling a method that reverts without a reason", function () { - // depends on a bug being fixed on ethers.js - // see https://github.com/NomicFoundation/hardhat/issues/3446 - it.skip("successful asserts", async function () { + it("successful asserts", async function () { await runSuccessfulAsserts({ matchers, method: "revertsWithoutReason", - args: [], successfulAssert: (x) => expect(x).to.be.reverted, }); }); - // depends on a bug being fixed on ethers.js - // see https://github.com/NomicFoundation/hardhat/issues/3446 - it.skip("failed asserts", async function () { + it("failed asserts", async function () { await runFailedAsserts({ matchers, method: "revertsWithoutReason", - args: [], failedAssert: (x) => expect(x).not.to.be.reverted, failedAssertReason: "Expected transaction NOT to be reverted", }); @@ -335,7 +327,6 @@ describe("INTEGRATION: Reverted", function () { await runSuccessfulAsserts({ matchers, method: "panicAssert", - args: [], successfulAssert: (x) => expect(x).to.be.reverted, }); }); @@ -344,7 +335,6 @@ describe("INTEGRATION: Reverted", function () { await runFailedAsserts({ matchers, method: "panicAssert", - args: [], failedAssert: (x) => expect(x).not.to.be.reverted, failedAssertReason: "Expected transaction NOT to be reverted, but it reverted with panic code 0x01 (Assertion error)", @@ -357,7 +347,6 @@ describe("INTEGRATION: Reverted", function () { await runSuccessfulAsserts({ matchers, method: "revertWithSomeCustomError", - args: [], successfulAssert: (x) => expect(x).to.be.reverted, }); }); @@ -366,7 +355,6 @@ describe("INTEGRATION: Reverted", function () { await runFailedAsserts({ matchers, method: "revertWithSomeCustomError", - args: [], failedAssert: (x) => expect(x).not.to.be.reverted, failedAssertReason: "Expected transaction NOT to be reverted", }); @@ -385,24 +373,22 @@ describe("INTEGRATION: Reverted", function () { // use an address that almost surely doesn't have balance const randomPrivateKey = "0xc5c587cc6e48e9692aee0bf07474118e6d830c11905f7ec7ff32c09c99eba5f9"; - const signer = new this.hre.ethers.Wallet( - randomPrivateKey, - this.hre.ethers.provider - ); - const matchersFromSenderWithoutFunds = matchers.connect( - signer - ) as MatchersContract; + const account = privateKeyToAccount(randomPrivateKey); + const wallet = await this.hre.viem.getWalletClient(account.address, { + account, + }); // this transaction will fail because of lack of funds, not because of a // revert await expect( expect( - matchersFromSenderWithoutFunds.revertsWithoutReason({ - gasLimit: 1_000_000, + matchers.write.revertsWithoutReason({ + gas: 1_000_000n, + account: wallet.account, }) ).to.not.be.reverted ).to.be.eventually.rejectedWith( - ProviderError, + TransactionExecutionError, "Sender doesn't have enough funds to send tx" ); }); @@ -412,7 +398,7 @@ describe("INTEGRATION: Reverted", function () { // smoke test for stack traces it("includes test file", async function () { try { - await expect(matchers.succeeds()).to.be.reverted; + await expect(matchers.write.succeeds()).to.be.reverted; } catch (e: any) { const errorString = util.inspect(e); expect(errorString).to.include("Expected transaction to be reverted"); diff --git a/packages/hardhat-chai-matchers-viem/test/reverted/revertedWithCustomError.ts b/packages/hardhat-chai-matchers-viem/test/reverted/revertedWithCustomError.ts index d16dc928e0..1742660cc5 100644 --- a/packages/hardhat-chai-matchers-viem/test/reverted/revertedWithCustomError.ts +++ b/packages/hardhat-chai-matchers-viem/test/reverted/revertedWithCustomError.ts @@ -16,7 +16,7 @@ import "../../src/internal/add-chai-matchers"; import { anyUint, anyValue } from "../../src/withArgs"; import { MatchersContract } from "../contracts"; -describe.only("INTEGRATION: Reverted with custom error", function () { +describe("INTEGRATION: Reverted with custom error", function () { describe("with the in-process hardhat network", function () { useEnvironment("hardhat-project"); From 1c614850754b401ee1cb9bed2d8aaf449a43269b Mon Sep 17 00:00:00 2001 From: johnpm-12 <39016062+johnpm-12@users.noreply.github.com> Date: Sat, 18 May 2024 09:29:34 -0700 Subject: [PATCH 05/18] improve parity with original package --- .../src/internal/changeEtherBalance.ts | 6 +- .../src/internal/changeEtherBalances.ts | 4 +- .../src/internal/changeTokenBalance.ts | 4 +- .../src/internal/emit.ts | 4 +- .../src/internal/reverted/reverted.ts | 24 ++++-- .../src/internal/utils.ts | 2 +- .../test/changeEtherBalance.ts | 40 +++++----- .../test/helpers.ts | 43 ++++++++--- .../test/reverted/reverted.ts | 74 ++++++++++--------- .../test/reverted/revertedWithCustomError.ts | 2 +- .../test/reverted/revertedWithPanic.ts | 29 ++++---- 11 files changed, 136 insertions(+), 96 deletions(-) diff --git a/packages/hardhat-chai-matchers-viem/src/internal/changeEtherBalance.ts b/packages/hardhat-chai-matchers-viem/src/internal/changeEtherBalance.ts index d00f42e07d..20f3f13951 100644 --- a/packages/hardhat-chai-matchers-viem/src/internal/changeEtherBalance.ts +++ b/packages/hardhat-chai-matchers-viem/src/internal/changeEtherBalance.ts @@ -8,7 +8,7 @@ import { getAddressOf } from "./misc/account"; import { CHANGE_ETHER_BALANCE_MATCHER } from "./constants"; import { assertIsNotNull, - getTransactionReceipt, + waitForTransactionReceipt, preventAsyncMatcherChaining, } from "./utils"; @@ -67,7 +67,7 @@ export async function getBalanceChange( account: WalletClient | { address: `0x${string}` } | `0x${string}`, options?: BalanceChangeOptions ): Promise { - const { network, viem } = await import("hardhat"); + const { network } = await import("hardhat"); const provider = network.provider; let hash: `0x${string}`; @@ -78,7 +78,7 @@ export async function getBalanceChange( hash = await transaction; } - const txReceipt = await getTransactionReceipt(hash); + const txReceipt = await waitForTransactionReceipt(hash); assertIsNotNull(txReceipt, "txReceipt"); const txBlockNumber = txReceipt.blockNumber; diff --git a/packages/hardhat-chai-matchers-viem/src/internal/changeEtherBalances.ts b/packages/hardhat-chai-matchers-viem/src/internal/changeEtherBalances.ts index 6ac17f9af1..4d8dd1d315 100644 --- a/packages/hardhat-chai-matchers-viem/src/internal/changeEtherBalances.ts +++ b/packages/hardhat-chai-matchers-viem/src/internal/changeEtherBalances.ts @@ -9,7 +9,7 @@ import { getAddresses, getBalances } from "./misc/balance"; import { CHANGE_ETHER_BALANCES_MATCHER } from "./constants"; import { assertIsNotNull, - getTransactionReceipt, + waitForTransactionReceipt, preventAsyncMatcherChaining, } from "./utils"; @@ -108,7 +108,7 @@ export async function getBalanceChanges( ): Promise { const hash = await transaction; - const txReceipt = await getTransactionReceipt(hash); + const txReceipt = await waitForTransactionReceipt(hash); assertIsNotNull(txReceipt, "txReceipt"); const txBlockNumber = txReceipt.blockNumber; diff --git a/packages/hardhat-chai-matchers-viem/src/internal/changeTokenBalance.ts b/packages/hardhat-chai-matchers-viem/src/internal/changeTokenBalance.ts index 7271bf79a7..68793112db 100644 --- a/packages/hardhat-chai-matchers-viem/src/internal/changeTokenBalance.ts +++ b/packages/hardhat-chai-matchers-viem/src/internal/changeTokenBalance.ts @@ -14,7 +14,7 @@ import { } from "./constants"; import { assertIsNotNull, - getTransactionReceipt, + waitForTransactionReceipt, preventAsyncMatcherChaining, } from "./utils"; @@ -185,7 +185,7 @@ export async function getBalanceChange( const publicClient = await viem.getPublicClient(); const hash = await transaction; - const txReceipt = await getTransactionReceipt(hash); + const txReceipt = await waitForTransactionReceipt(hash); assertIsNotNull(txReceipt, "txReceipt"); const txBlockNumber = txReceipt.blockNumber; const transactionCount = await publicClient.getBlockTransactionCount({ diff --git a/packages/hardhat-chai-matchers-viem/src/internal/emit.ts b/packages/hardhat-chai-matchers-viem/src/internal/emit.ts index 5a883ffd1f..f7b35d587f 100644 --- a/packages/hardhat-chai-matchers-viem/src/internal/emit.ts +++ b/packages/hardhat-chai-matchers-viem/src/internal/emit.ts @@ -12,7 +12,7 @@ import { assertArgsArraysEqual, assertIsNotNull, preventAsyncMatcherChaining, - getTransactionReceipt, + waitForTransactionReceipt, } from "./utils"; export const EMIT_CALLED = "emitAssertionCalled"; @@ -28,7 +28,7 @@ async function waitForPendingTransaction( } else { throw new Error(`${JSON.stringify(tx)} is not a valid transaction`); } - return getTransactionReceipt(hash); + return waitForTransactionReceipt(hash); } type Contract = GetContractReturnType; diff --git a/packages/hardhat-chai-matchers-viem/src/internal/reverted/reverted.ts b/packages/hardhat-chai-matchers-viem/src/internal/reverted/reverted.ts index 2e81dfe73c..800db66b5e 100644 --- a/packages/hardhat-chai-matchers-viem/src/internal/reverted/reverted.ts +++ b/packages/hardhat-chai-matchers-viem/src/internal/reverted/reverted.ts @@ -3,7 +3,7 @@ import { REVERTED_MATCHER } from "../constants"; import { assertIsNotNull, preventAsyncMatcherChaining, - getTransactionReceipt, + waitForTransactionReceipt, } from "../utils"; import { decodeReturnData, getReturnDataFromError, toBeHex } from "./utils"; @@ -27,14 +27,16 @@ export function supportReverted( const onSuccess = async (value: unknown) => { const assert = buildAssert(negated, onSuccess); - if (typeof value === "string") { - if (!isValidTransactionHash(value)) { + if (isTransactionResponse(value) || typeof value === "string") { + const hash = typeof value === "string" ? value : value.hash; + + if (!isValidTransactionHash(hash)) { throw new TypeError( - `Expected a valid transaction hash, but got '${value}'` + `Expected a valid transaction hash, but got '${hash}'` ); } - const receipt = await getTransactionReceipt(value); + const receipt = await waitForTransactionReceipt(hash); assertIsNotNull(receipt, "receipt"); assert( @@ -43,8 +45,10 @@ export function supportReverted( "Expected transaction NOT to be reverted" ); } else if (isTransactionReceipt(value)) { + const receipt = value; + assert( - value.status === "reverted", + receipt.status === "reverted", "Expected transaction to be reverted", "Expected transaction NOT to be reverted" ); @@ -101,6 +105,14 @@ export function supportReverted( }); } +function isTransactionResponse(x: unknown): x is { hash: string } { + if (typeof x === "object" && x !== null) { + return "hash" in x && typeof x.hash === "string"; + } + + return false; +} + function isTransactionReceipt( x: unknown ): x is { status: "reverted" | "success" } { diff --git a/packages/hardhat-chai-matchers-viem/src/internal/utils.ts b/packages/hardhat-chai-matchers-viem/src/internal/utils.ts index 6a9d9e600e..f172e03264 100644 --- a/packages/hardhat-chai-matchers-viem/src/internal/utils.ts +++ b/packages/hardhat-chai-matchers-viem/src/internal/utils.ts @@ -179,7 +179,7 @@ function innerAssertArgEqual( } } -export async function getTransactionReceipt(hash: `0x${string}`) { +export async function waitForTransactionReceipt(hash: `0x${string}`) { const { viem } = await import("hardhat"); const publicClient = await viem.getPublicClient(); return publicClient.waitForTransactionReceipt({ hash }); diff --git a/packages/hardhat-chai-matchers-viem/test/changeEtherBalance.ts b/packages/hardhat-chai-matchers-viem/test/changeEtherBalance.ts index 0b116708d2..e6d372b2fe 100644 --- a/packages/hardhat-chai-matchers-viem/test/changeEtherBalance.ts +++ b/packages/hardhat-chai-matchers-viem/test/changeEtherBalance.ts @@ -5,7 +5,11 @@ import path from "path"; import util from "util"; import "../src/internal/add-chai-matchers"; -import { useEnvironment, useEnvironmentWithNode } from "./helpers"; +import { + getTransaction, + useEnvironment, + useEnvironmentWithNode, +} from "./helpers"; describe("INTEGRATION: changeEtherBalance matcher", function () { describe("with the in-process hardhat network", function () { @@ -407,25 +411,25 @@ describe("INTEGRATION: changeEtherBalance matcher", function () { describe("Transaction Response", () => { describe("Change balance, one account", () => { - it("Should pass when expected balance change is passed as string and is equal to an actual", async () => { - await expect( - await sender.sendTransaction({ - to: receiver.account.address, - value: 200n, - }) - ).to.changeEtherBalance(sender, "-200"); + it("Should pass when expected balance change is passed as string and is equal to an actual", async function () { + const hash = await sender.sendTransaction({ + to: receiver.account.address, + value: 200n, + }); + const tx = await getTransaction(this.hre, hash); + await expect(tx).to.changeEtherBalance(sender, "-200"); }); - it("Should pass when expected balance change is passed as int and is equal to an actual", async () => { - await expect( - await sender.sendTransaction({ - to: receiver.account.address, - value: 200n, - }) - ).to.changeEtherBalance(receiver, 200); + it("Should pass when expected balance change is passed as int and is equal to an actual", async function () { + const hash = await sender.sendTransaction({ + to: receiver.account.address, + value: 200n, + }); + const tx = await getTransaction(this.hre, hash); + await expect(tx).to.changeEtherBalance(receiver, 200); }); - it("Should throw when expected balance change value was different from an actual", async () => { + it("Should throw when expected balance change value was different from an actual", async function () { await expect( expect( await sender.sendTransaction({ @@ -439,7 +443,7 @@ describe("INTEGRATION: changeEtherBalance matcher", function () { ); }); - it("Should throw in negative case when expected balance change value was equal to an actual", async () => { + it("Should throw in negative case when expected balance change value was equal to an actual", async function () { await expect( expect( await sender.sendTransaction({ @@ -455,7 +459,7 @@ describe("INTEGRATION: changeEtherBalance matcher", function () { }); describe("Change balance, one contract", () => { - it("Should pass when expected balance change is passed as int and is equal to an actual", async () => { + it("Should pass when expected balance change is passed as int and is equal to an actual", async function () { await expect( await sender.sendTransaction({ to: contract.address, diff --git a/packages/hardhat-chai-matchers-viem/test/helpers.ts b/packages/hardhat-chai-matchers-viem/test/helpers.ts index 4da9142703..c6906cfb3d 100644 --- a/packages/hardhat-chai-matchers-viem/test/helpers.ts +++ b/packages/hardhat-chai-matchers-viem/test/helpers.ts @@ -158,13 +158,13 @@ export async function mineSuccessfulTransaction( await hre.network.provider.send("evm_setAutomine", [false]); const [signer] = await hre.viem.getWalletClients(); - const txHash = await signer.sendTransaction({ to: signer.account.address }); + const hash = await signer.sendTransaction({ to: signer.account.address }); - await mineBlocksUntilTxIsIncluded(hre, txHash); + await mineBlocksUntilTxIsIncluded(hre, hash); await hre.network.provider.send("evm_setAutomine", [true]); - return txHash; + return { hash }; } export async function mineRevertedTransaction( @@ -173,29 +173,26 @@ export async function mineRevertedTransaction( ) { await hre.network.provider.send("evm_setAutomine", [false]); - const txHash = await matchers.write.revertsWithoutReason({ + const hash = await matchers.write.revertsWithoutReason({ gas: 1_000_000n, }); - await mineBlocksUntilTxIsIncluded(hre, txHash); + await mineBlocksUntilTxIsIncluded(hre, hash); await hre.network.provider.send("evm_setAutomine", [true]); - return txHash; + return { hash }; } async function mineBlocksUntilTxIsIncluded( hre: HardhatRuntimeEnvironment, - txHash: `0x${string}` + hash: `0x${string}` ) { let i = 0; - const publicClient = await hre.viem.getPublicClient(); while (true) { try { - await publicClient.getTransactionReceipt({ - hash: txHash, - }); + await getTransactionReceipt(hre, hash); return; } catch (e) { if (!(e instanceof TransactionReceiptNotFoundError)) { @@ -211,3 +208,27 @@ async function mineBlocksUntilTxIsIncluded( } } } + +export async function getTransaction( + hre: HardhatRuntimeEnvironment, + hash: `0x${string}` +) { + const publicClient = await hre.viem.getPublicClient(); + return publicClient.getTransaction({ hash }); +} + +export async function getTransactionReceipt( + hre: HardhatRuntimeEnvironment, + hash: `0x${string}` +) { + const publicClient = await hre.viem.getPublicClient(); + return publicClient.getTransactionReceipt({ hash }); +} + +export async function waitForTransactionReceipt( + hre: HardhatRuntimeEnvironment, + hash: `0x${string}` +) { + const publicClient = await hre.viem.getPublicClient(); + return publicClient.waitForTransactionReceipt({ hash }); +} diff --git a/packages/hardhat-chai-matchers-viem/test/reverted/reverted.ts b/packages/hardhat-chai-matchers-viem/test/reverted/reverted.ts index 1d86f8c20e..d25c4dff47 100644 --- a/packages/hardhat-chai-matchers-viem/test/reverted/reverted.ts +++ b/packages/hardhat-chai-matchers-viem/test/reverted/reverted.ts @@ -15,6 +15,8 @@ import { useEnvironmentWithNode, mineSuccessfulTransaction, mineRevertedTransaction, + waitForTransactionReceipt, + getTransaction, } from "../helpers"; describe("INTEGRATION: Reverted", function () { @@ -43,17 +45,9 @@ describe("INTEGRATION: Reverted", function () { return expect(x).to.be.eventually.rejectedWith(AssertionError, message); }; - async function getTransactionReceipt( - hre: HardhatRuntimeEnvironment, - hash: `0x${string}` - ) { - const publicClient = await hre.viem.getPublicClient(); - return publicClient.waitForTransactionReceipt({ hash }); - } - describe("with a string as its subject", function () { it("hash of a successful transaction", async function () { - const hash = await mineSuccessfulTransaction(this.hre); + const { hash } = await mineSuccessfulTransaction(this.hre); await expectAssertionError( expect(hash).to.be.reverted, @@ -63,7 +57,7 @@ describe("INTEGRATION: Reverted", function () { }); it("hash of a reverted transaction", async function () { - const hash = await mineRevertedTransaction(this.hre, matchers); + const { hash } = await mineRevertedTransaction(this.hre, matchers); await expect(hash).to.be.reverted; await expectAssertionError( @@ -85,7 +79,7 @@ describe("INTEGRATION: Reverted", function () { }); it("promise of a hash of a successful transaction", async function () { - const hash = await mineSuccessfulTransaction(this.hre); + const { hash } = await mineSuccessfulTransaction(this.hre); await expectAssertionError( expect(Promise.resolve(hash)).to.be.reverted, @@ -95,7 +89,7 @@ describe("INTEGRATION: Reverted", function () { }); it("promise of a hash of a reverted transaction", async function () { - const hash = await mineRevertedTransaction(this.hre, matchers); + const { hash } = await mineRevertedTransaction(this.hre, matchers); await expect(Promise.resolve(hash)).to.be.reverted; await expectAssertionError( @@ -123,7 +117,8 @@ describe("INTEGRATION: Reverted", function () { describe("with a TxResponse as its subject", function () { it("TxResponse of a successful transaction", async function () { - const tx = await mineSuccessfulTransaction(this.hre); + const { hash } = await mineSuccessfulTransaction(this.hre); + const tx = await getTransaction(this.hre, hash); await expectAssertionError( expect(tx).to.be.reverted, @@ -133,7 +128,8 @@ describe("INTEGRATION: Reverted", function () { }); it("TxResponse of a reverted transaction", async function () { - const tx = await mineRevertedTransaction(this.hre, matchers); + const { hash } = await mineRevertedTransaction(this.hre, matchers); + const tx = await getTransaction(this.hre, hash); await expect(tx).to.be.reverted; await expectAssertionError( @@ -143,7 +139,8 @@ describe("INTEGRATION: Reverted", function () { }); it("promise of a TxResponse of a successful transaction", async function () { - const txPromise = mineSuccessfulTransaction(this.hre); + const { hash } = await mineSuccessfulTransaction(this.hre); + const txPromise = getTransaction(this.hre, hash); await expectAssertionError( expect(txPromise).to.be.reverted, @@ -153,7 +150,8 @@ describe("INTEGRATION: Reverted", function () { }); it("promise of a TxResponse of a reverted transaction", async function () { - const txPromise = mineRevertedTransaction(this.hre, matchers); + const { hash } = await mineRevertedTransaction(this.hre, matchers); + const txPromise = getTransaction(this.hre, hash); await expect(txPromise).to.be.reverted; await expectAssertionError( @@ -163,19 +161,22 @@ describe("INTEGRATION: Reverted", function () { }); it("reverted: should throw if chained to another non-chainable method", async function () { - const tx = await mineRevertedTransaction(this.hre, matchers); + const { hash } = await mineRevertedTransaction(this.hre, matchers); + const txPromise = getTransaction(this.hre, hash); expect( () => - expect(tx).to.be.revertedWith("an error message").and.to.be.reverted + expect(txPromise).to.be.revertedWith("an error message").and.to.be + .reverted ).to.throw( /The matcher 'reverted' cannot be chained after 'revertedWith'./ ); }); it("revertedWith: should throw if chained to another non-chainable method", async function () { - const tx = await mineRevertedTransaction(this.hre, matchers); + const { hash } = await mineRevertedTransaction(this.hre, matchers); + const txPromise = getTransaction(this.hre, hash); expect(() => - expect(tx) + expect(txPromise) .to.be.revertedWithCustomError(matchers, "SomeCustomError") .and.to.be.revertedWith("an error message") ).to.throw( @@ -184,9 +185,10 @@ describe("INTEGRATION: Reverted", function () { }); it("revertedWithCustomError: should throw if chained to another non-chainable method", async function () { - const tx = await mineRevertedTransaction(this.hre, matchers); + const { hash } = await mineRevertedTransaction(this.hre, matchers); + const txPromise = getTransaction(this.hre, hash); expect(() => - expect(tx) + expect(txPromise) .to.be.revertedWithoutReason() .and.to.be.revertedWithCustomError(matchers, "SomeCustomError") ).to.throw( @@ -195,9 +197,12 @@ describe("INTEGRATION: Reverted", function () { }); it("revertedWithoutReason: should throw if chained to another non-chainable method", async function () { - const tx = await mineRevertedTransaction(this.hre, matchers); + const { hash } = await mineRevertedTransaction(this.hre, matchers); + const txPromise = getTransaction(this.hre, hash); expect(() => - expect(tx).to.be.revertedWithPanic().and.to.be.revertedWithoutReason() + expect(txPromise) + .to.be.revertedWithPanic() + .and.to.be.revertedWithoutReason() ).to.throw( /The matcher 'revertedWithoutReason' cannot be chained after 'revertedWithPanic'./ ); @@ -205,9 +210,10 @@ describe("INTEGRATION: Reverted", function () { it("revertedWithPanic: should throw if chained to another non-chainable method", async function () { const [sender] = await this.hre.viem.getWalletClients(); - const tx = await mineRevertedTransaction(this.hre, matchers); + const { hash } = await mineRevertedTransaction(this.hre, matchers); + const txPromise = getTransaction(this.hre, hash); expect(() => - expect(tx) + expect(txPromise) .to.changeEtherBalance(sender, "-200") .and.to.be.revertedWithPanic() ).to.throw( @@ -218,8 +224,8 @@ describe("INTEGRATION: Reverted", function () { describe("with a TxReceipt as its subject", function () { it("TxReceipt of a successful transaction", async function () { - const tx = await mineSuccessfulTransaction(this.hre); - const receipt = await getTransactionReceipt(this.hre, tx); + const { hash } = await mineSuccessfulTransaction(this.hre); + const receipt = await waitForTransactionReceipt(this.hre, hash); await expectAssertionError( expect(receipt).to.be.reverted, @@ -229,8 +235,8 @@ describe("INTEGRATION: Reverted", function () { }); it("TxReceipt of a reverted transaction", async function () { - const tx = await mineRevertedTransaction(this.hre, matchers); - const receipt = await getTransactionReceipt(this.hre, tx); + const { hash } = await mineRevertedTransaction(this.hre, matchers); + const receipt = await waitForTransactionReceipt(this.hre, hash); await expect(receipt).to.be.reverted; await expectAssertionError( @@ -240,8 +246,8 @@ describe("INTEGRATION: Reverted", function () { }); it("promise of a TxReceipt of a successful transaction", async function () { - const tx = await mineSuccessfulTransaction(this.hre); - const receiptPromise = getTransactionReceipt(this.hre, tx); + const { hash } = await mineSuccessfulTransaction(this.hre); + const receiptPromise = waitForTransactionReceipt(this.hre, hash); await expectAssertionError( expect(receiptPromise).to.be.reverted, @@ -251,8 +257,8 @@ describe("INTEGRATION: Reverted", function () { }); it("promise of a TxReceipt of a reverted transaction", async function () { - const tx = await mineRevertedTransaction(this.hre, matchers); - const receiptPromise = getTransactionReceipt(this.hre, tx); + const { hash } = await mineRevertedTransaction(this.hre, matchers); + const receiptPromise = waitForTransactionReceipt(this.hre, hash); await expect(receiptPromise).to.be.reverted; await expectAssertionError( diff --git a/packages/hardhat-chai-matchers-viem/test/reverted/revertedWithCustomError.ts b/packages/hardhat-chai-matchers-viem/test/reverted/revertedWithCustomError.ts index 1742660cc5..feec45a67d 100644 --- a/packages/hardhat-chai-matchers-viem/test/reverted/revertedWithCustomError.ts +++ b/packages/hardhat-chai-matchers-viem/test/reverted/revertedWithCustomError.ts @@ -455,7 +455,7 @@ describe("INTEGRATION: Reverted with custom error", function () { }); it("non-string as expectation", async function () { - const hash = await mineSuccessfulTransaction(this.hre); + const { hash } = await mineSuccessfulTransaction(this.hre); expect(() => // @ts-expect-error diff --git a/packages/hardhat-chai-matchers-viem/test/reverted/revertedWithPanic.ts b/packages/hardhat-chai-matchers-viem/test/reverted/revertedWithPanic.ts index 23ff116b7a..a2fb23f758 100644 --- a/packages/hardhat-chai-matchers-viem/test/reverted/revertedWithPanic.ts +++ b/packages/hardhat-chai-matchers-viem/test/reverted/revertedWithPanic.ts @@ -2,6 +2,7 @@ import { AssertionError, expect } from "chai"; import { ProviderError } from "hardhat/internal/core/providers/errors"; import path from "path"; import util from "util"; +import { privateKeyToAccount } from "viem/accounts"; import "../../src/internal/add-chai-matchers"; import { PANIC_CODES } from "../../src/panic"; @@ -31,11 +32,7 @@ describe("INTEGRATION: Reverted with panic", function () { // deploy Matchers contract before each test let matchers: MatchersContract; beforeEach("deploy matchers contract", async function () { - const Matchers = await this.hre.ethers.getContractFactory< - [], - MatchersContract - >("Matchers"); - matchers = await Matchers.deploy(); + matchers = await this.hre.viem.deployContract("Matchers"); }); describe("calling a method that succeeds", function () { @@ -276,7 +273,7 @@ describe("INTEGRATION: Reverted with panic", function () { }); it("non-number as expectation, subject is a rejected promise", async function () { - const tx = matchers.revertsWithoutReason(); + const tx = matchers.write.revertsWithoutReason(); expect(() => expect(tx).to.be.revertedWithPanic("invalid")).to.throw( TypeError, @@ -288,20 +285,18 @@ describe("INTEGRATION: Reverted with panic", function () { // use an address that almost surely doesn't have balance const randomPrivateKey = "0xc5c587cc6e48e9692aee0bf07474118e6d830c11905f7ec7ff32c09c99eba5f9"; - const signer = new this.hre.ethers.Wallet( - randomPrivateKey, - this.hre.ethers.provider - ); - const matchersFromSenderWithoutFunds = matchers.connect( - signer - ) as MatchersContract; + const account = privateKeyToAccount(randomPrivateKey); + const wallet = await this.hre.viem.getWalletClient(account.address, { + account, + }); // this transaction will fail because of lack of funds, not because of a // revert await expect( expect( - matchersFromSenderWithoutFunds.revertsWithoutReason({ - gasLimit: 1_000_000, + matchers.write.revertsWithoutReason({ + gas: 1_000_000n, + account: wallet.account, }) ).to.not.be.revertedWithPanic() ).to.be.eventually.rejectedWith( @@ -315,7 +310,9 @@ describe("INTEGRATION: Reverted with panic", function () { // smoke test for stack traces it("includes test file", async function () { try { - await expect(matchers.panicAssert()).to.not.be.revertedWithPanic(); + await expect( + matchers.write.panicAssert() + ).to.not.be.revertedWithPanic(); } catch (e: any) { const errorString = util.inspect(e); expect(errorString).to.include( From 58bec4ba24a39da817598d0b1d91203c833f7b3b Mon Sep 17 00:00:00 2001 From: johnpm-12 <39016062+johnpm-12@users.noreply.github.com> Date: Sat, 18 May 2024 14:30:26 -0700 Subject: [PATCH 06/18] improve parity with forked package --- .../test/changeEtherBalance.ts | 40 +++++----- .../test/helpers.ts | 12 +-- .../test/reverted/reverted.ts | 78 ++++++++----------- 3 files changed, 54 insertions(+), 76 deletions(-) diff --git a/packages/hardhat-chai-matchers-viem/test/changeEtherBalance.ts b/packages/hardhat-chai-matchers-viem/test/changeEtherBalance.ts index e6d372b2fe..0b116708d2 100644 --- a/packages/hardhat-chai-matchers-viem/test/changeEtherBalance.ts +++ b/packages/hardhat-chai-matchers-viem/test/changeEtherBalance.ts @@ -5,11 +5,7 @@ import path from "path"; import util from "util"; import "../src/internal/add-chai-matchers"; -import { - getTransaction, - useEnvironment, - useEnvironmentWithNode, -} from "./helpers"; +import { useEnvironment, useEnvironmentWithNode } from "./helpers"; describe("INTEGRATION: changeEtherBalance matcher", function () { describe("with the in-process hardhat network", function () { @@ -411,25 +407,25 @@ describe("INTEGRATION: changeEtherBalance matcher", function () { describe("Transaction Response", () => { describe("Change balance, one account", () => { - it("Should pass when expected balance change is passed as string and is equal to an actual", async function () { - const hash = await sender.sendTransaction({ - to: receiver.account.address, - value: 200n, - }); - const tx = await getTransaction(this.hre, hash); - await expect(tx).to.changeEtherBalance(sender, "-200"); + it("Should pass when expected balance change is passed as string and is equal to an actual", async () => { + await expect( + await sender.sendTransaction({ + to: receiver.account.address, + value: 200n, + }) + ).to.changeEtherBalance(sender, "-200"); }); - it("Should pass when expected balance change is passed as int and is equal to an actual", async function () { - const hash = await sender.sendTransaction({ - to: receiver.account.address, - value: 200n, - }); - const tx = await getTransaction(this.hre, hash); - await expect(tx).to.changeEtherBalance(receiver, 200); + it("Should pass when expected balance change is passed as int and is equal to an actual", async () => { + await expect( + await sender.sendTransaction({ + to: receiver.account.address, + value: 200n, + }) + ).to.changeEtherBalance(receiver, 200); }); - it("Should throw when expected balance change value was different from an actual", async function () { + it("Should throw when expected balance change value was different from an actual", async () => { await expect( expect( await sender.sendTransaction({ @@ -443,7 +439,7 @@ describe("INTEGRATION: changeEtherBalance matcher", function () { ); }); - it("Should throw in negative case when expected balance change value was equal to an actual", async function () { + it("Should throw in negative case when expected balance change value was equal to an actual", async () => { await expect( expect( await sender.sendTransaction({ @@ -459,7 +455,7 @@ describe("INTEGRATION: changeEtherBalance matcher", function () { }); describe("Change balance, one contract", () => { - it("Should pass when expected balance change is passed as int and is equal to an actual", async function () { + it("Should pass when expected balance change is passed as int and is equal to an actual", async () => { await expect( await sender.sendTransaction({ to: contract.address, diff --git a/packages/hardhat-chai-matchers-viem/test/helpers.ts b/packages/hardhat-chai-matchers-viem/test/helpers.ts index c6906cfb3d..ebca84ae45 100644 --- a/packages/hardhat-chai-matchers-viem/test/helpers.ts +++ b/packages/hardhat-chai-matchers-viem/test/helpers.ts @@ -164,7 +164,7 @@ export async function mineSuccessfulTransaction( await hre.network.provider.send("evm_setAutomine", [true]); - return { hash }; + return hash; } export async function mineRevertedTransaction( @@ -181,7 +181,7 @@ export async function mineRevertedTransaction( await hre.network.provider.send("evm_setAutomine", [true]); - return { hash }; + return hash; } async function mineBlocksUntilTxIsIncluded( @@ -209,14 +209,6 @@ async function mineBlocksUntilTxIsIncluded( } } -export async function getTransaction( - hre: HardhatRuntimeEnvironment, - hash: `0x${string}` -) { - const publicClient = await hre.viem.getPublicClient(); - return publicClient.getTransaction({ hash }); -} - export async function getTransactionReceipt( hre: HardhatRuntimeEnvironment, hash: `0x${string}` diff --git a/packages/hardhat-chai-matchers-viem/test/reverted/reverted.ts b/packages/hardhat-chai-matchers-viem/test/reverted/reverted.ts index d25c4dff47..c67de60117 100644 --- a/packages/hardhat-chai-matchers-viem/test/reverted/reverted.ts +++ b/packages/hardhat-chai-matchers-viem/test/reverted/reverted.ts @@ -16,7 +16,6 @@ import { mineSuccessfulTransaction, mineRevertedTransaction, waitForTransactionReceipt, - getTransaction, } from "../helpers"; describe("INTEGRATION: Reverted", function () { @@ -47,7 +46,7 @@ describe("INTEGRATION: Reverted", function () { describe("with a string as its subject", function () { it("hash of a successful transaction", async function () { - const { hash } = await mineSuccessfulTransaction(this.hre); + const hash = await mineSuccessfulTransaction(this.hre); await expectAssertionError( expect(hash).to.be.reverted, @@ -57,7 +56,7 @@ describe("INTEGRATION: Reverted", function () { }); it("hash of a reverted transaction", async function () { - const { hash } = await mineRevertedTransaction(this.hre, matchers); + const hash = await mineRevertedTransaction(this.hre, matchers); await expect(hash).to.be.reverted; await expectAssertionError( @@ -79,7 +78,7 @@ describe("INTEGRATION: Reverted", function () { }); it("promise of a hash of a successful transaction", async function () { - const { hash } = await mineSuccessfulTransaction(this.hre); + const hash = await mineSuccessfulTransaction(this.hre); await expectAssertionError( expect(Promise.resolve(hash)).to.be.reverted, @@ -89,7 +88,7 @@ describe("INTEGRATION: Reverted", function () { }); it("promise of a hash of a reverted transaction", async function () { - const { hash } = await mineRevertedTransaction(this.hre, matchers); + const hash = await mineRevertedTransaction(this.hre, matchers); await expect(Promise.resolve(hash)).to.be.reverted; await expectAssertionError( @@ -117,66 +116,60 @@ describe("INTEGRATION: Reverted", function () { describe("with a TxResponse as its subject", function () { it("TxResponse of a successful transaction", async function () { - const { hash } = await mineSuccessfulTransaction(this.hre); - const tx = await getTransaction(this.hre, hash); + const hash = await mineSuccessfulTransaction(this.hre); await expectAssertionError( - expect(tx).to.be.reverted, + expect(hash).to.be.reverted, "Expected transaction to be reverted" ); - await expect(tx).to.not.be.reverted; + await expect(hash).to.not.be.reverted; }); it("TxResponse of a reverted transaction", async function () { - const { hash } = await mineRevertedTransaction(this.hre, matchers); - const tx = await getTransaction(this.hre, hash); + const hash = await mineRevertedTransaction(this.hre, matchers); - await expect(tx).to.be.reverted; + await expect(hash).to.be.reverted; await expectAssertionError( - expect(tx).to.not.be.reverted, + expect(hash).to.not.be.reverted, "Expected transaction NOT to be reverted" ); }); it("promise of a TxResponse of a successful transaction", async function () { - const { hash } = await mineSuccessfulTransaction(this.hre); - const txPromise = getTransaction(this.hre, hash); + const hashPromise = mineSuccessfulTransaction(this.hre); await expectAssertionError( - expect(txPromise).to.be.reverted, + expect(hashPromise).to.be.reverted, "Expected transaction to be reverted" ); - await expect(txPromise).to.not.be.reverted; + await expect(hashPromise).to.not.be.reverted; }); it("promise of a TxResponse of a reverted transaction", async function () { - const { hash } = await mineRevertedTransaction(this.hre, matchers); - const txPromise = getTransaction(this.hre, hash); + const hashPromise = mineRevertedTransaction(this.hre, matchers); - await expect(txPromise).to.be.reverted; + await expect(hashPromise).to.be.reverted; await expectAssertionError( - expect(txPromise).to.not.be.reverted, + expect(hashPromise).to.not.be.reverted, "Expected transaction NOT to be reverted" ); }); - it("reverted: should throw if chained to another non-chainable method", async function () { - const { hash } = await mineRevertedTransaction(this.hre, matchers); - const txPromise = getTransaction(this.hre, hash); + it("reverted: should throw if chained to another non-chainable method", function () { + const hashPromise = mineRevertedTransaction(this.hre, matchers); expect( () => - expect(txPromise).to.be.revertedWith("an error message").and.to.be + expect(hashPromise).to.be.revertedWith("an error message").and.to.be .reverted ).to.throw( /The matcher 'reverted' cannot be chained after 'revertedWith'./ ); }); - it("revertedWith: should throw if chained to another non-chainable method", async function () { - const { hash } = await mineRevertedTransaction(this.hre, matchers); - const txPromise = getTransaction(this.hre, hash); + it("revertedWith: should throw if chained to another non-chainable method", function () { + const hashPromise = mineRevertedTransaction(this.hre, matchers); expect(() => - expect(txPromise) + expect(hashPromise) .to.be.revertedWithCustomError(matchers, "SomeCustomError") .and.to.be.revertedWith("an error message") ).to.throw( @@ -184,11 +177,10 @@ describe("INTEGRATION: Reverted", function () { ); }); - it("revertedWithCustomError: should throw if chained to another non-chainable method", async function () { - const { hash } = await mineRevertedTransaction(this.hre, matchers); - const txPromise = getTransaction(this.hre, hash); + it("revertedWithCustomError: should throw if chained to another non-chainable method", function () { + const hashPromise = mineRevertedTransaction(this.hre, matchers); expect(() => - expect(txPromise) + expect(hashPromise) .to.be.revertedWithoutReason() .and.to.be.revertedWithCustomError(matchers, "SomeCustomError") ).to.throw( @@ -196,11 +188,10 @@ describe("INTEGRATION: Reverted", function () { ); }); - it("revertedWithoutReason: should throw if chained to another non-chainable method", async function () { - const { hash } = await mineRevertedTransaction(this.hre, matchers); - const txPromise = getTransaction(this.hre, hash); + it("revertedWithoutReason: should throw if chained to another non-chainable method", function () { + const hashPromise = mineRevertedTransaction(this.hre, matchers); expect(() => - expect(txPromise) + expect(hashPromise) .to.be.revertedWithPanic() .and.to.be.revertedWithoutReason() ).to.throw( @@ -210,10 +201,9 @@ describe("INTEGRATION: Reverted", function () { it("revertedWithPanic: should throw if chained to another non-chainable method", async function () { const [sender] = await this.hre.viem.getWalletClients(); - const { hash } = await mineRevertedTransaction(this.hre, matchers); - const txPromise = getTransaction(this.hre, hash); + const hashPromise = mineRevertedTransaction(this.hre, matchers); expect(() => - expect(txPromise) + expect(hashPromise) .to.changeEtherBalance(sender, "-200") .and.to.be.revertedWithPanic() ).to.throw( @@ -224,7 +214,7 @@ describe("INTEGRATION: Reverted", function () { describe("with a TxReceipt as its subject", function () { it("TxReceipt of a successful transaction", async function () { - const { hash } = await mineSuccessfulTransaction(this.hre); + const hash = await mineSuccessfulTransaction(this.hre); const receipt = await waitForTransactionReceipt(this.hre, hash); await expectAssertionError( @@ -235,7 +225,7 @@ describe("INTEGRATION: Reverted", function () { }); it("TxReceipt of a reverted transaction", async function () { - const { hash } = await mineRevertedTransaction(this.hre, matchers); + const hash = await mineRevertedTransaction(this.hre, matchers); const receipt = await waitForTransactionReceipt(this.hre, hash); await expect(receipt).to.be.reverted; @@ -246,7 +236,7 @@ describe("INTEGRATION: Reverted", function () { }); it("promise of a TxReceipt of a successful transaction", async function () { - const { hash } = await mineSuccessfulTransaction(this.hre); + const hash = await mineSuccessfulTransaction(this.hre); const receiptPromise = waitForTransactionReceipt(this.hre, hash); await expectAssertionError( @@ -257,7 +247,7 @@ describe("INTEGRATION: Reverted", function () { }); it("promise of a TxReceipt of a reverted transaction", async function () { - const { hash } = await mineRevertedTransaction(this.hre, matchers); + const hash = await mineRevertedTransaction(this.hre, matchers); const receiptPromise = waitForTransactionReceipt(this.hre, hash); await expect(receiptPromise).to.be.reverted; From 7f02ee079870e6398786e3d238c0c78686346f20 Mon Sep 17 00:00:00 2001 From: johnpm-12 <39016062+johnpm-12@users.noreply.github.com> Date: Sat, 18 May 2024 15:48:25 -0700 Subject: [PATCH 07/18] support predicates aligning with forked package --- .../src/internal/changeEtherBalance.ts | 21 ++- .../src/internal/changeEtherBalances.ts | 116 +++++++++++------ .../src/internal/changeTokenBalance.ts | 71 ++++++---- .../hardhat-chai-matchers-viem/src/types.ts | 4 +- .../test/bigNumber.ts | 64 +++++---- .../test/changeEtherBalance.ts | 70 +++++++++- .../test/changeEtherBalances.ts | 79 +++++++++++- .../test/changeTokenBalance.ts | 121 +++++++++++++++++- .../test/reverted/revertedWithPanic.ts | 2 +- 9 files changed, 439 insertions(+), 109 deletions(-) diff --git a/packages/hardhat-chai-matchers-viem/src/internal/changeEtherBalance.ts b/packages/hardhat-chai-matchers-viem/src/internal/changeEtherBalance.ts index 20f3f13951..a69ebae905 100644 --- a/packages/hardhat-chai-matchers-viem/src/internal/changeEtherBalance.ts +++ b/packages/hardhat-chai-matchers-viem/src/internal/changeEtherBalance.ts @@ -21,7 +21,7 @@ export function supportChangeEtherBalance( function ( this: any, account: WalletClient | { address: `0x${string}` } | `0x${string}`, - balanceChange: bigint | number | string, + balanceChange: bigint | number | string | ((change: bigint) => boolean), options?: BalanceChangeOptions ) { // capture negated flag before async code executes; see buildAssert's jsdoc @@ -40,11 +40,20 @@ export function supportChangeEtherBalance( ]) => { const assert = buildAssert(negated, checkBalanceChange); - assert( - actualChange === BigInt(balanceChange), - `Expected the ether balance of "${address}" to change by ${balanceChange.toString()} wei, but it changed by ${actualChange.toString()} wei`, - `Expected the ether balance of "${address}" NOT to change by ${balanceChange.toString()} wei, but it did` - ); + if (typeof balanceChange === "function") { + assert( + balanceChange(actualChange), + `Expected the ether balance change of "${address}" to satisfy the predicate, but it didn't (balance change: ${actualChange.toString()} wei)`, + `Expected the ether balance change of "${address}" to NOT satisfy the predicate, but it did (balance change: ${actualChange.toString()} wei)` + ); + } else { + const expectedChange = BigInt(balanceChange); + assert( + actualChange === expectedChange, + `Expected the ether balance of "${address}" to change by ${balanceChange.toString()} wei, but it changed by ${actualChange.toString()} wei`, + `Expected the ether balance of "${address}" NOT to change by ${balanceChange.toString()} wei, but it did` + ); + } }; const derivedPromise = Promise.all([ diff --git a/packages/hardhat-chai-matchers-viem/src/internal/changeEtherBalances.ts b/packages/hardhat-chai-matchers-viem/src/internal/changeEtherBalances.ts index 4d8dd1d315..3f6428d1f2 100644 --- a/packages/hardhat-chai-matchers-viem/src/internal/changeEtherBalances.ts +++ b/packages/hardhat-chai-matchers-viem/src/internal/changeEtherBalances.ts @@ -24,7 +24,9 @@ export function supportChangeEtherBalances( accounts: Array< WalletClient | { address: `0x${string}` } | `0x${string}` >, - balanceChanges: Array, + balanceChanges: + | Array + | ((changes: bigint[]) => boolean), options?: BalanceChangeOptions ) { const ordinal = require("ordinal") as typeof OrdinalT; @@ -42,51 +44,61 @@ export function supportChangeEtherBalances( chaiUtils ); + validateInput(this._obj, accounts, balanceChanges); + const checkBalanceChanges = ([actualChanges, accountAddresses]: [ bigint[], string[] ]) => { const assert = buildAssert(negated, checkBalanceChanges); - assert( - actualChanges.every( - (change, ind) => change === BigInt(balanceChanges[ind]) - ), - () => { - const lines: string[] = []; - actualChanges.forEach((change: bigint, i) => { - if (change !== BigInt(balanceChanges[i])) { - lines.push( - `Expected the ether balance of ${ - accountAddresses[i] - } (the ${ordinal( - i + 1 - )} address in the list) to change by ${balanceChanges[ - i - ].toString()} wei, but it changed by ${change.toString()} wei` - ); - } - }); - return lines.join("\n"); - }, - () => { - const lines: string[] = []; - actualChanges.forEach((change: bigint, i) => { - if (change === BigInt(balanceChanges[i])) { - lines.push( - `Expected the ether balance of ${ - accountAddresses[i] - } (the ${ordinal( - i + 1 - )} address in the list) NOT to change by ${balanceChanges[ - i - ].toString()} wei, but it did` - ); - } - }); - return lines.join("\n"); - } - ); + if (typeof balanceChanges === "function") { + assert( + balanceChanges(actualChanges), + "Expected the balance changes of the accounts to satisfy the predicate, but they didn't", + "Expected the balance changes of the accounts to NOT satisfy the predicate, but they did" + ); + } else { + assert( + actualChanges.every( + (change, ind) => change === BigInt(balanceChanges[ind]) + ), + () => { + const lines: string[] = []; + actualChanges.forEach((change: bigint, i) => { + if (change !== BigInt(balanceChanges[i])) { + lines.push( + `Expected the ether balance of ${ + accountAddresses[i] + } (the ${ordinal( + i + 1 + )} address in the list) to change by ${balanceChanges[ + i + ].toString()} wei, but it changed by ${change.toString()} wei` + ); + } + }); + return lines.join("\n"); + }, + () => { + const lines: string[] = []; + actualChanges.forEach((change: bigint, i) => { + if (change === BigInt(balanceChanges[i])) { + lines.push( + `Expected the ether balance of ${ + accountAddresses[i] + } (the ${ordinal( + i + 1 + )} address in the list) NOT to change by ${balanceChanges[ + i + ].toString()} wei, but it did` + ); + } + }); + return lines.join("\n"); + } + ); + } }; const derivedPromise = Promise.all([ @@ -101,6 +113,30 @@ export function supportChangeEtherBalances( ); } +function validateInput( + obj: any, + accounts: Array, + balanceChanges: + | Array + | ((changes: bigint[]) => boolean) +) { + try { + if ( + Array.isArray(balanceChanges) && + accounts.length !== balanceChanges.length + ) { + throw new Error( + `The number of accounts (${accounts.length}) is different than the number of expected balance changes (${balanceChanges.length})` + ); + } + } catch (e) { + // if the input validation fails, we discard the subject since it could + // potentially be a rejected promise + Promise.resolve(obj).catch(() => {}); + throw e; + } +} + export async function getBalanceChanges( transaction: `0x${string}` | Promise<`0x${string}`>, accounts: Array, diff --git a/packages/hardhat-chai-matchers-viem/src/internal/changeTokenBalance.ts b/packages/hardhat-chai-matchers-viem/src/internal/changeTokenBalance.ts index 68793112db..45755ab2db 100644 --- a/packages/hardhat-chai-matchers-viem/src/internal/changeTokenBalance.ts +++ b/packages/hardhat-chai-matchers-viem/src/internal/changeTokenBalance.ts @@ -30,7 +30,7 @@ export function supportChangeTokenBalance( this: any, token: TokenContract, account: WalletClient | { address: `0x${string}` } | `0x${string}`, - balanceChange: bigint | number | string + balanceChange: bigint | number | string | ((change: bigint) => boolean) ) { // capture negated flag before async code executes; see buildAssert's jsdoc const negated = this.__flags.negate; @@ -55,11 +55,19 @@ export function supportChangeTokenBalance( ]) => { const assert = buildAssert(negated, checkBalanceChange); - assert( - actualChange === BigInt(balanceChange), - `Expected the balance of ${tokenDescription} tokens for "${address}" to change by ${balanceChange.toString()}, but it changed by ${actualChange.toString()}`, - `Expected the balance of ${tokenDescription} tokens for "${address}" NOT to change by ${balanceChange.toString()}, but it did` - ); + if (typeof balanceChange === "function") { + assert( + balanceChange(actualChange), + `Expected the balance of ${tokenDescription} tokens for "${address}" to satisfy the predicate, but it didn't (token balance change: ${actualChange.toString()} wei)`, + `Expected the balance of ${tokenDescription} tokens for "${address}" to NOT satisfy the predicate, but it did (token balance change: ${actualChange.toString()} wei)` + ); + } else { + assert( + actualChange === BigInt(balanceChange), + `Expected the balance of ${tokenDescription} tokens for "${address}" to change by ${balanceChange.toString()}, but it changed by ${actualChange.toString()}`, + `Expected the balance of ${tokenDescription} tokens for "${address}" NOT to change by ${balanceChange.toString()}, but it did` + ); + } }; const derivedPromise = Promise.all([ @@ -83,7 +91,9 @@ export function supportChangeTokenBalance( accounts: Array< WalletClient | { address: `0x${string}` } | `0x${string}` >, - balanceChanges: Array + balanceChanges: + | Array + | ((changes: bigint[]) => boolean) ) { // capture negated flag before async code executes; see buildAssert's jsdoc const negated = this.__flags.negate; @@ -113,21 +123,29 @@ export function supportChangeTokenBalance( ]: [bigint[], string[], string]) => { const assert = buildAssert(negated, checkBalanceChanges); - assert( - actualChanges.every( - (change, ind) => change === BigInt(balanceChanges[ind]) - ), - `Expected the balances of ${tokenDescription} tokens for ${ - addresses as any - } to change by ${ - balanceChanges as any - }, respectively, but they changed by ${actualChanges as any}`, - `Expected the balances of ${tokenDescription} tokens for ${ - addresses as any - } NOT to change by ${ - balanceChanges as any - }, respectively, but they did` - ); + if (typeof balanceChanges === "function") { + assert( + balanceChanges(actualChanges), + `Expected the balance changes of ${tokenDescription} to satisfy the predicate, but they didn't`, + `Expected the balance changes of ${tokenDescription} to NOT satisfy the predicate, but they did` + ); + } else { + assert( + actualChanges.every( + (change, ind) => change === BigInt(balanceChanges[ind]) + ), + `Expected the balances of ${tokenDescription} tokens for ${ + addresses as any + } to change by ${ + balanceChanges as any + }, respectively, but they changed by ${actualChanges as any}`, + `Expected the balances of ${tokenDescription} tokens for ${ + addresses as any + } NOT to change by ${ + balanceChanges as any + }, respectively, but they did` + ); + } }; const derivedPromise = Promise.all([ @@ -148,12 +166,17 @@ function validateInput( obj: any, token: TokenContract, accounts: Array, - balanceChanges: Array + balanceChanges: + | Array + | ((changes: bigint[]) => boolean) ) { try { checkToken(token, CHANGE_TOKEN_BALANCES_MATCHER); - if (accounts.length !== balanceChanges.length) { + if ( + Array.isArray(balanceChanges) && + accounts.length !== balanceChanges.length + ) { throw new Error( `The number of accounts (${accounts.length}) is different than the number of expected balance changes (${balanceChanges.length})` ); diff --git a/packages/hardhat-chai-matchers-viem/src/types.ts b/packages/hardhat-chai-matchers-viem/src/types.ts index 4b8d6f7ada..fe4e21f5a2 100644 --- a/packages/hardhat-chai-matchers-viem/src/types.ts +++ b/packages/hardhat-chai-matchers-viem/src/types.ts @@ -24,14 +24,14 @@ declare namespace Chai { ): AsyncAssertion; changeEtherBalances( accounts: any[], - balances: any[], + balances: any[] | ((changes: bigint[]) => boolean), options?: any ): AsyncAssertion; changeTokenBalance(token: any, account: any, balance: any): AsyncAssertion; changeTokenBalances( token: any, account: any[], - balance: any[] + balance: any[] | ((changes: bigint[]) => boolean) ): AsyncAssertion; } diff --git a/packages/hardhat-chai-matchers-viem/test/bigNumber.ts b/packages/hardhat-chai-matchers-viem/test/bigNumber.ts index c80ab0d328..ef0afb8895 100644 --- a/packages/hardhat-chai-matchers-viem/test/bigNumber.ts +++ b/packages/hardhat-chai-matchers-viem/test/bigNumber.ts @@ -815,13 +815,13 @@ describe("BigNumber matchers", function () { describe(`when using .to.${operator}`, function () { it("with an unsafe int as the first param", function () { - expect(() => expect(unsafeInt).to[operator](BigInt(1))).to.throw( + expect(() => expect(unsafeInt).to[operator](1n)).to.throw( HardhatError, msg ); }); it("with an unsafe int as the second param", function () { - expect(() => expect(BigInt(1)).to[operator](unsafeInt)).to.throw( + expect(() => expect(1n).to[operator](unsafeInt)).to.throw( HardhatError, msg ); @@ -830,14 +830,16 @@ describe("BigNumber matchers", function () { describe(`when using .not.to.${operator}`, function () { it("with an unsafe int as the first param", function () { - expect(() => - expect(unsafeInt).not.to[operator](BigInt(1)) - ).to.throw(HardhatError, msg); + expect(() => expect(unsafeInt).not.to[operator](1n)).to.throw( + HardhatError, + msg + ); }); it("with an unsafe int as the second param", function () { - expect(() => - expect(BigInt(1)).not.to[operator](unsafeInt) - ).to.throw(HardhatError, msg); + expect(() => expect(1n).not.to[operator](unsafeInt)).to.throw( + HardhatError, + msg + ); }); }); }); @@ -1136,37 +1138,43 @@ describe("BigNumber matchers", function () { describe(`when using .to.${operator}`, function () { it("with an unsafe int as the first param", function () { - expect(() => - expect(unsafeInt).to[operator](BigInt(1), BigInt(1)) - ).to.throw(HardhatError, msg); + expect(() => expect(unsafeInt).to[operator](1n, 1n)).to.throw( + HardhatError, + msg + ); }); it("with an unsafe int as the second param", function () { - expect(() => - expect(BigInt(1)).to[operator](unsafeInt, BigInt(1)) - ).to.throw(HardhatError, msg); + expect(() => expect(1n).to[operator](unsafeInt, 1n)).to.throw( + HardhatError, + msg + ); }); it("with an unsafe int as the third param", function () { - expect(() => - expect(BigInt(1)).to[operator](BigInt(1), unsafeInt) - ).to.throw(HardhatError, msg); + expect(() => expect(1n).to[operator](1n, unsafeInt)).to.throw( + HardhatError, + msg + ); }); }); describe(`when using not.to.${operator}`, function () { it("with an unsafe int as the first param", function () { - expect(() => - expect(unsafeInt).not.to[operator](BigInt(1), BigInt(1)) - ).to.throw(HardhatError, msg); + expect(() => expect(unsafeInt).not.to[operator](1n, 1n)).to.throw( + HardhatError, + msg + ); }); it("with an unsafe int as the second param", function () { - expect(() => - expect(BigInt(1)).not.to[operator](unsafeInt, BigInt(1)) - ).to.throw(HardhatError, msg); + expect(() => expect(1n).not.to[operator](unsafeInt, 1n)).to.throw( + HardhatError, + msg + ); }); it("with an unsafe int as the third param", function () { - expect(() => - expect(BigInt(1)).not.to[operator](BigInt(1), unsafeInt) - ).to.throw(HardhatError, msg); + expect(() => expect(1n).not.to[operator](1n, unsafeInt)).to.throw( + HardhatError, + msg + ); }); }); }); @@ -1181,7 +1189,7 @@ describe("BigNumber matchers", function () { ); // number and bigint - expect(() => expect(1).to.equal(BigInt(2), "custom message")).to.throw( + expect(() => expect(1).to.equal(2n, "custom message")).to.throw( AssertionError, "custom message" ); @@ -1193,7 +1201,7 @@ describe("BigNumber matchers", function () { ); // number and bigint - expect(() => expect([1]).to.equal([BigInt(2)], "custom message")).to.throw( + expect(() => expect([1]).to.equal([2n], "custom message")).to.throw( AssertionError, "custom message" ); diff --git a/packages/hardhat-chai-matchers-viem/test/changeEtherBalance.ts b/packages/hardhat-chai-matchers-viem/test/changeEtherBalance.ts index 0b116708d2..f7e917889b 100644 --- a/packages/hardhat-chai-matchers-viem/test/changeEtherBalance.ts +++ b/packages/hardhat-chai-matchers-viem/test/changeEtherBalance.ts @@ -91,7 +91,16 @@ describe("INTEGRATION: changeEtherBalance matcher", function () { to: receiver.account.address, value: 200n, }) - ).to.changeEtherBalance(sender, BigInt("-200")); + ).to.changeEtherBalance(sender, -200n); + }); + + it("Should pass when given a predicate", async () => { + await expect(() => + sender.sendTransaction({ + to: receiver.account.address, + value: 200n, + }) + ).to.changeEtherBalance(sender, (diff: bigint) => diff === -200n); }); it("Should pass when expected balance change is passed as int and is equal to an actual", async () => { @@ -115,6 +124,22 @@ describe("INTEGRATION: changeEtherBalance matcher", function () { }); }); + it("Should take into account transaction fee when given a predicate", async () => { + await expect(() => + sender.sendTransaction({ + to: receiver.account.address, + gasPrice: 1n, + value: 200n, + }) + ).to.changeEtherBalance( + sender, + (diff: bigint) => diff === -(BigInt(txGasFees) + 200n), + { + includeFee: true, + } + ); + }); + it("Should ignore fee if receiver's wallet is being checked and includeFee was set", async () => { await expect(() => sender.sendTransaction({ @@ -135,6 +160,18 @@ describe("INTEGRATION: changeEtherBalance matcher", function () { ).to.changeEtherBalance(sender, -200); }); + it("Should pass on negative case when expected balance does not satisfy the predicate", async () => { + await expect(() => + sender.sendTransaction({ + to: receiver.account.address, + value: 200n, + }) + ).to.not.changeEtherBalance( + receiver, + (diff: bigint) => diff === 300n + ); + }); + it("Should throw when fee was not calculated correctly", async () => { await expect( expect(() => @@ -166,6 +203,20 @@ describe("INTEGRATION: changeEtherBalance matcher", function () { ); }); + it("Should throw when actual balance change value does not satisfy the predicate", async () => { + await expect( + expect(() => + sender.sendTransaction({ + to: receiver.account.address, + value: 200n, + }) + ).to.changeEtherBalance(sender, (diff: bigint) => diff === -500n) + ).to.be.eventually.rejectedWith( + AssertionError, + `Expected the ether balance change of "${sender.account.address}" to satisfy the predicate, but it didn't (balance change: -200 wei)` + ); + }); + it("Should throw in negative case when expected balance change value was equal to an actual", async () => { await expect( expect(() => @@ -180,6 +231,23 @@ describe("INTEGRATION: changeEtherBalance matcher", function () { ); }); + it("Should throw in negative case when expected balance change value satisfies the predicate", async () => { + await expect( + expect(() => + sender.sendTransaction({ + to: receiver.account.address, + value: 200n, + }) + ).to.not.changeEtherBalance( + sender, + (diff: bigint) => diff === -200n + ) + ).to.be.eventually.rejectedWith( + AssertionError, + `Expected the ether balance change of "${sender.account.address}" to NOT satisfy the predicate, but it did (balance change: -200 wei)` + ); + }); + it("Should pass when given zero value tx", async () => { await expect(() => sender.sendTransaction({ to: receiver.account.address, value: 0n }) diff --git a/packages/hardhat-chai-matchers-viem/test/changeEtherBalances.ts b/packages/hardhat-chai-matchers-viem/test/changeEtherBalances.ts index 2e3bafaac9..b9ff0ffaf4 100644 --- a/packages/hardhat-chai-matchers-viem/test/changeEtherBalances.ts +++ b/packages/hardhat-chai-matchers-viem/test/changeEtherBalances.ts @@ -91,6 +91,16 @@ describe("INTEGRATION: changeEtherBalances matcher", function () { }); it("Should pass when given native BigInt", async () => { + await expect(() => + sender.sendTransaction({ + to: receiver.account.address, + gasPrice: 1n, + value: 200n, + }) + ).to.changeEtherBalances([sender, receiver], [-200n, 200n]); + }); + + it("Should pass when given a predicate", async () => { await expect(() => sender.sendTransaction({ to: receiver.account.address, @@ -99,7 +109,46 @@ describe("INTEGRATION: changeEtherBalances matcher", function () { }) ).to.changeEtherBalances( [sender, receiver], - [BigInt("-200"), BigInt(200)] + ([senderDiff, receiverDiff]: bigint[]) => + senderDiff === -200n && receiverDiff === 200n + ); + }); + + it("Should fail when the predicate returns false", async () => { + await expect( + expect(() => + sender.sendTransaction({ + to: receiver.account.address, + gasPrice: 1n, + value: 200n, + }) + ).to.changeEtherBalances( + [sender, receiver], + ([senderDiff, receiverDiff]: bigint[]) => + senderDiff === -201n && receiverDiff === 200n + ) + ).to.be.eventually.rejectedWith( + AssertionError, + "Expected the balance changes of the accounts to satisfy the predicate, but they didn't" + ); + }); + + it("Should fail when the predicate returns true and the assertion is negated", async () => { + await expect( + expect(() => + sender.sendTransaction({ + to: receiver.account.address, + gasPrice: 1n, + value: 200n, + }) + ).to.not.changeEtherBalances( + [sender, receiver], + ([senderDiff, receiverDiff]: bigint[]) => + senderDiff === -200n && receiverDiff === 200n + ) + ).to.be.eventually.rejectedWith( + AssertionError, + "Expected the balance changes of the accounts to NOT satisfy the predicate, but they did" ); }); @@ -203,6 +252,34 @@ describe("INTEGRATION: changeEtherBalances matcher", function () { `Expected the ether balance of ${sender.account.address} (the 1st address in the list) NOT to change by -200 wei` ); }); + + it("arrays have different length", async function () { + expect(() => + expect( + sender.sendTransaction({ + to: receiver.account.address, + gasPrice: 1n, + value: 200n, + }) + ).to.changeEtherBalances([sender], ["-200", 200]) + ).to.throw( + Error, + "The number of accounts (1) is different than the number of expected balance changes (2)" + ); + + expect(() => + expect( + sender.sendTransaction({ + to: receiver.account.address, + gasPrice: 1n, + value: 200n, + }) + ).to.changeEtherBalances([sender, receiver], ["-200"]) + ).to.throw( + Error, + "The number of accounts (2) is different than the number of expected balance changes (1)" + ); + }); }); it("shouldn't run the transaction twice", async function () { diff --git a/packages/hardhat-chai-matchers-viem/test/changeTokenBalance.ts b/packages/hardhat-chai-matchers-viem/test/changeTokenBalance.ts index bf2f396d2d..9b6d8816bf 100644 --- a/packages/hardhat-chai-matchers-viem/test/changeTokenBalance.ts +++ b/packages/hardhat-chai-matchers-viem/test/changeTokenBalance.ts @@ -118,6 +118,14 @@ describe("INTEGRATION: changeTokenBalance and changeTokenBalances matchers", fun sender.sendTransaction({ to: receiver.account.address }) ).to.not.changeTokenBalance(mockToken, sender, 1); + await expect( + sender.sendTransaction({ to: receiver.account.address }) + ).to.not.changeTokenBalance( + mockToken, + sender, + (diff: bigint) => diff > 0n + ); + await expect(() => sender.sendTransaction({ to: receiver.account.address }) ).to.not.changeTokenBalances(mockToken, [sender, receiver], [0, 1]); @@ -143,6 +151,21 @@ describe("INTEGRATION: changeTokenBalance and changeTokenBalances matchers", fun ); }); + it("change balance doesn't satisfies the predicate", async function () { + await expect( + expect( + sender.sendTransaction({ to: receiver.account.address }) + ).to.changeTokenBalance( + mockToken, + sender, + (diff: bigint) => diff > 0n + ) + ).to.be.rejectedWith( + AssertionError, + /Expected the balance of MCK tokens for "0x\w{40}" to satisfy the predicate, but it didn't \(token balance change: 0 wei\)/ + ); + }); + it("changes balance in the way it was not expected", async function () { await expect( expect( @@ -154,6 +177,21 @@ describe("INTEGRATION: changeTokenBalance and changeTokenBalances matchers", fun ); }); + it("changes balance doesn't have to satisfy the predicate, but it did", async function () { + await expect( + expect( + sender.sendTransaction({ to: receiver.account.address }) + ).to.not.changeTokenBalance( + mockToken, + sender, + (diff: bigint) => diff < 1n + ) + ).to.be.rejectedWith( + AssertionError, + /Expected the balance of MCK tokens for "0x\w{40}" to NOT satisfy the predicate, but it did \(token balance change: 0 wei\)/ + ); + }); + it("the first account doesn't change its balance as expected", async function () { await expect( expect( @@ -188,6 +226,51 @@ describe("INTEGRATION: changeTokenBalance and changeTokenBalances matchers", fun }); }); + describe("Transaction Callback", function () { + it("Should pass when given predicate", async () => { + await expect(() => + mockToken.write.transfer([receiver.account.address, 75n]) + ).to.changeTokenBalances( + mockToken, + [sender, receiver], + ([senderDiff, receiverDiff]: bigint[]) => + senderDiff === -75n && receiverDiff === 75n + ); + }); + + it("Should fail when the predicate returns false", async () => { + await expect( + expect( + mockToken.write.transfer([receiver.account.address, 75n]) + ).to.changeTokenBalances( + mockToken, + [sender, receiver], + ([senderDiff, receiverDiff]: bigint[]) => + senderDiff === -74n && receiverDiff === 75n + ) + ).to.be.eventually.rejectedWith( + AssertionError, + "Expected the balance changes of MCK to satisfy the predicate, but they didn't" + ); + }); + + it("Should fail when the predicate returns true and the assertion is negated", async () => { + await expect( + expect( + mockToken.write.transfer([receiver.account.address, 75n]) + ).to.not.changeTokenBalances( + mockToken, + [sender, receiver], + ([senderDiff, receiverDiff]: bigint[]) => + senderDiff === -75n && receiverDiff === 75n + ) + ).to.be.eventually.rejectedWith( + AssertionError, + "Expected the balance changes of MCK to NOT satisfy the predicate, but they did" + ); + }); + }); + describe("transaction that transfers some tokens", function () { it("with a promise of a TxResponse", async function () { await runAllAsserts( @@ -299,6 +382,21 @@ describe("INTEGRATION: changeTokenBalance and changeTokenBalances matchers", fun ); }); + it("change balance doesn't satisfies the predicate", async function () { + await expect( + expect( + mockToken.write.transfer([receiver.account.address, 50n]) + ).to.changeTokenBalance( + mockToken, + receiver, + (diff: bigint) => diff === 500n + ) + ).to.be.rejectedWith( + AssertionError, + /Expected the balance of MCK tokens for "0x\w{40}" to satisfy the predicate, but it didn't \(token balance change: 50 wei\)/ + ); + }); + it("changes balance in the way it was not expected", async function () { await expect( expect( @@ -310,6 +408,21 @@ describe("INTEGRATION: changeTokenBalance and changeTokenBalances matchers", fun ); }); + it("changes balance doesn't have to satisfy the predicate, but it did", async function () { + await expect( + expect( + mockToken.write.transfer([receiver.account.address, 50n]) + ).to.not.changeTokenBalance( + mockToken, + receiver, + (diff: bigint) => diff === 50n + ) + ).to.be.rejectedWith( + AssertionError, + /Expected the balance of MCK tokens for "0x\w{40}" to NOT satisfy the predicate, but it did \(token balance change: 50 wei\)/ + ); + }); + it("the first account doesn't change its balance as expected", async function () { await expect( expect( @@ -589,15 +702,11 @@ describe("INTEGRATION: changeTokenBalance and changeTokenBalances matchers", fun it("native bigints are accepted", async function () { await expect( mockToken.write.transfer([receiver.account.address, 50n]) - ).to.changeTokenBalance(mockToken, sender, BigInt(-50)); + ).to.changeTokenBalance(mockToken, sender, -50n); await expect( mockToken.write.transfer([receiver.account.address, 50n]) - ).to.changeTokenBalances( - mockToken, - [sender, receiver], - [BigInt(-50), BigInt(50)] - ); + ).to.changeTokenBalances(mockToken, [sender, receiver], [-50n, 50n]); }); }); diff --git a/packages/hardhat-chai-matchers-viem/test/reverted/revertedWithPanic.ts b/packages/hardhat-chai-matchers-viem/test/reverted/revertedWithPanic.ts index a2fb23f758..c590c20c26 100644 --- a/packages/hardhat-chai-matchers-viem/test/reverted/revertedWithPanic.ts +++ b/packages/hardhat-chai-matchers-viem/test/reverted/revertedWithPanic.ts @@ -264,7 +264,7 @@ describe("INTEGRATION: Reverted with panic", function () { }); it("non-number as expectation", async function () { - const { hash } = await mineSuccessfulTransaction(this.hre); + const hash = await mineSuccessfulTransaction(this.hre); expect(() => expect(hash).to.be.revertedWithPanic("invalid")).to.throw( TypeError, From 65cb2f50da32c71f3d3fcbdc66e4ea811314ed00 Mon Sep 17 00:00:00 2001 From: johnpm-12 <39016062+johnpm-12@users.noreply.github.com> Date: Sat, 18 May 2024 16:37:27 -0700 Subject: [PATCH 08/18] fix some tests --- .../test/reverted/reverted.ts | 30 +++++++++---------- .../test/reverted/revertedWithCustomError.ts | 4 +-- .../test/reverted/revertedWithPanic.ts | 11 ++++--- 3 files changed, 22 insertions(+), 23 deletions(-) diff --git a/packages/hardhat-chai-matchers-viem/test/reverted/reverted.ts b/packages/hardhat-chai-matchers-viem/test/reverted/reverted.ts index c67de60117..a3666ff4b2 100644 --- a/packages/hardhat-chai-matchers-viem/test/reverted/reverted.ts +++ b/packages/hardhat-chai-matchers-viem/test/reverted/reverted.ts @@ -25,7 +25,7 @@ describe("INTEGRATION: Reverted", function () { runTests(); }); - // external hardhat node with viem does not include error data in many cases + // external hardhat node with viem does not include error data in some cases describe.skip("connected to a hardhat node", function () { useEnvironmentWithNode("hardhat-project"); @@ -155,21 +155,21 @@ describe("INTEGRATION: Reverted", function () { ); }); - it("reverted: should throw if chained to another non-chainable method", function () { - const hashPromise = mineRevertedTransaction(this.hre, matchers); + it("reverted: should throw if chained to another non-chainable method", async function () { + const hash = await mineRevertedTransaction(this.hre, matchers); expect( () => - expect(hashPromise).to.be.revertedWith("an error message").and.to.be + expect(hash).to.be.revertedWith("an error message").and.to.be .reverted ).to.throw( /The matcher 'reverted' cannot be chained after 'revertedWith'./ ); }); - it("revertedWith: should throw if chained to another non-chainable method", function () { - const hashPromise = mineRevertedTransaction(this.hre, matchers); + it("revertedWith: should throw if chained to another non-chainable method", async function () { + const hash = await mineRevertedTransaction(this.hre, matchers); expect(() => - expect(hashPromise) + expect(hash) .to.be.revertedWithCustomError(matchers, "SomeCustomError") .and.to.be.revertedWith("an error message") ).to.throw( @@ -177,10 +177,10 @@ describe("INTEGRATION: Reverted", function () { ); }); - it("revertedWithCustomError: should throw if chained to another non-chainable method", function () { - const hashPromise = mineRevertedTransaction(this.hre, matchers); + it("revertedWithCustomError: should throw if chained to another non-chainable method", async function () { + const hash = await mineRevertedTransaction(this.hre, matchers); expect(() => - expect(hashPromise) + expect(hash) .to.be.revertedWithoutReason() .and.to.be.revertedWithCustomError(matchers, "SomeCustomError") ).to.throw( @@ -188,10 +188,10 @@ describe("INTEGRATION: Reverted", function () { ); }); - it("revertedWithoutReason: should throw if chained to another non-chainable method", function () { - const hashPromise = mineRevertedTransaction(this.hre, matchers); + it("revertedWithoutReason: should throw if chained to another non-chainable method", async function () { + const hash = await mineRevertedTransaction(this.hre, matchers); expect(() => - expect(hashPromise) + expect(hash) .to.be.revertedWithPanic() .and.to.be.revertedWithoutReason() ).to.throw( @@ -201,9 +201,9 @@ describe("INTEGRATION: Reverted", function () { it("revertedWithPanic: should throw if chained to another non-chainable method", async function () { const [sender] = await this.hre.viem.getWalletClients(); - const hashPromise = mineRevertedTransaction(this.hre, matchers); + const hash = await mineRevertedTransaction(this.hre, matchers); expect(() => - expect(hashPromise) + expect(hash) .to.changeEtherBalance(sender, "-200") .and.to.be.revertedWithPanic() ).to.throw( diff --git a/packages/hardhat-chai-matchers-viem/test/reverted/revertedWithCustomError.ts b/packages/hardhat-chai-matchers-viem/test/reverted/revertedWithCustomError.ts index feec45a67d..534dfa7929 100644 --- a/packages/hardhat-chai-matchers-viem/test/reverted/revertedWithCustomError.ts +++ b/packages/hardhat-chai-matchers-viem/test/reverted/revertedWithCustomError.ts @@ -23,7 +23,7 @@ describe("INTEGRATION: Reverted with custom error", function () { runTests(); }); - // external hardhat node with viem does not include error data in many cases + // external hardhat node with viem does not include error data in some cases describe.skip("connected to a hardhat node", function () { useEnvironmentWithNode("hardhat-project"); @@ -455,7 +455,7 @@ describe("INTEGRATION: Reverted with custom error", function () { }); it("non-string as expectation", async function () { - const { hash } = await mineSuccessfulTransaction(this.hre); + const hash = await mineSuccessfulTransaction(this.hre); expect(() => // @ts-expect-error diff --git a/packages/hardhat-chai-matchers-viem/test/reverted/revertedWithPanic.ts b/packages/hardhat-chai-matchers-viem/test/reverted/revertedWithPanic.ts index c590c20c26..665df70b28 100644 --- a/packages/hardhat-chai-matchers-viem/test/reverted/revertedWithPanic.ts +++ b/packages/hardhat-chai-matchers-viem/test/reverted/revertedWithPanic.ts @@ -1,5 +1,5 @@ import { AssertionError, expect } from "chai"; -import { ProviderError } from "hardhat/internal/core/providers/errors"; +import { TransactionExecutionError } from "viem"; import path from "path"; import util from "util"; import { privateKeyToAccount } from "viem/accounts"; @@ -22,7 +22,8 @@ describe("INTEGRATION: Reverted with panic", function () { runTests(); }); - describe("connected to a hardhat node", function () { + // external hardhat node with viem does not include error data in some cases + describe.skip("connected to a hardhat node", function () { useEnvironmentWithNode("hardhat-project"); runTests(); @@ -87,9 +88,7 @@ describe("INTEGRATION: Reverted with panic", function () { }); }); - // depends on a bug being fixed on ethers.js - // see https://github.com/NomicFoundation/hardhat/issues/3446 - it.skip("failed asserts", async function () { + it("failed asserts", async function () { await runFailedAsserts({ matchers, method: "revertsWithoutReason", @@ -300,7 +299,7 @@ describe("INTEGRATION: Reverted with panic", function () { }) ).to.not.be.revertedWithPanic() ).to.be.eventually.rejectedWith( - ProviderError, + TransactionExecutionError, "Sender doesn't have enough funds to send tx" ); }); From 84ac3103324865e6f677bad1c3cb057e10360ecb Mon Sep 17 00:00:00 2001 From: johnpm-12 <39016062+johnpm-12@users.noreply.github.com> Date: Sat, 18 May 2024 17:02:12 -0700 Subject: [PATCH 09/18] fix more tests --- .../test/reverted/reverted.ts | 5 +-- .../test/reverted/revertedWith.ts | 39 ++++++++----------- .../test/reverted/revertedWithCustomError.ts | 5 +-- .../test/reverted/revertedWithPanic.ts | 5 +-- .../test/reverted/revertedWithoutReason.ts | 33 ++++++---------- 5 files changed, 31 insertions(+), 56 deletions(-) diff --git a/packages/hardhat-chai-matchers-viem/test/reverted/reverted.ts b/packages/hardhat-chai-matchers-viem/test/reverted/reverted.ts index a3666ff4b2..9deb425e6f 100644 --- a/packages/hardhat-chai-matchers-viem/test/reverted/reverted.ts +++ b/packages/hardhat-chai-matchers-viem/test/reverted/reverted.ts @@ -370,9 +370,6 @@ describe("INTEGRATION: Reverted", function () { const randomPrivateKey = "0xc5c587cc6e48e9692aee0bf07474118e6d830c11905f7ec7ff32c09c99eba5f9"; const account = privateKeyToAccount(randomPrivateKey); - const wallet = await this.hre.viem.getWalletClient(account.address, { - account, - }); // this transaction will fail because of lack of funds, not because of a // revert @@ -380,7 +377,7 @@ describe("INTEGRATION: Reverted", function () { expect( matchers.write.revertsWithoutReason({ gas: 1_000_000n, - account: wallet.account, + account, }) ).to.not.be.reverted ).to.be.eventually.rejectedWith( diff --git a/packages/hardhat-chai-matchers-viem/test/reverted/revertedWith.ts b/packages/hardhat-chai-matchers-viem/test/reverted/revertedWith.ts index a4c2a85dbe..956d4da5c8 100644 --- a/packages/hardhat-chai-matchers-viem/test/reverted/revertedWith.ts +++ b/packages/hardhat-chai-matchers-viem/test/reverted/revertedWith.ts @@ -1,5 +1,6 @@ import { AssertionError, expect } from "chai"; -import { ProviderError } from "hardhat/internal/core/providers/errors"; +import { TransactionExecutionError } from "viem"; +import { privateKeyToAccount } from "viem/accounts"; import path from "path"; import util from "util"; @@ -21,7 +22,8 @@ describe("INTEGRATION: Reverted with", function () { runTests(); }); - describe("connected to a hardhat node", function () { + // external hardhat node with viem does not include error data in some cases + describe.skip("connected to a hardhat node", function () { useEnvironmentWithNode("hardhat-project"); runTests(); @@ -32,11 +34,7 @@ describe("INTEGRATION: Reverted with", function () { let matchers: MatchersContract; beforeEach("deploy matchers contract", async function () { - const Matchers = await this.hre.ethers.getContractFactory< - [], - MatchersContract - >("Matchers"); - matchers = await Matchers.deploy(); + matchers = await this.hre.viem.deployContract("Matchers"); }); describe("calling a method that succeeds", function () { @@ -70,9 +68,7 @@ describe("INTEGRATION: Reverted with", function () { }); }); - // depends on a bug being fixed on ethers.js - // see https://github.com/NomicFoundation/hardhat/issues/3446 - it.skip("failed asserts", async function () { + it("failed asserts", async function () { await runFailedAsserts({ matchers, method: "revertsWithoutReason", @@ -194,7 +190,7 @@ describe("INTEGRATION: Reverted with", function () { }); it("non-string as expectation", async function () { - const { hash } = await mineSuccessfulTransaction(this.hre); + const hash = await mineSuccessfulTransaction(this.hre); expect(() => // @ts-expect-error @@ -206,7 +202,7 @@ describe("INTEGRATION: Reverted with", function () { }); it("non-string as expectation, subject is a rejected promise", async function () { - const tx = matchers.revertsWithoutReason(); + const tx = matchers.write.revertsWithoutReason(); expect(() => // @ts-expect-error @@ -221,24 +217,19 @@ describe("INTEGRATION: Reverted with", function () { // use an address that almost surely doesn't have balance const randomPrivateKey = "0xc5c587cc6e48e9692aee0bf07474118e6d830c11905f7ec7ff32c09c99eba5f9"; - const signer = new this.hre.ethers.Wallet( - randomPrivateKey, - this.hre.ethers.provider - ); - const matchersFromSenderWithoutFunds = matchers.connect( - signer - ) as MatchersContract; + const account = privateKeyToAccount(randomPrivateKey); // this transaction will fail because of lack of funds, not because of a // revert await expect( expect( - matchersFromSenderWithoutFunds.revertsWithoutReason({ - gasLimit: 1_000_000, + matchers.write.revertsWithoutReason({ + gas: 1_000_000n, + account, }) ).to.not.be.revertedWith("some reason") ).to.be.eventually.rejectedWith( - ProviderError, + TransactionExecutionError, "Sender doesn't have enough funds to send tx" ); }); @@ -248,7 +239,9 @@ describe("INTEGRATION: Reverted with", function () { // smoke test for stack traces it("includes test file", async function () { try { - await expect(matchers.revertsWith("bar")).to.be.revertedWith("foo"); + await expect(matchers.write.revertsWith(["bar"])).to.be.revertedWith( + "foo" + ); } catch (e: any) { const errorString = util.inspect(e); expect(errorString).to.include( diff --git a/packages/hardhat-chai-matchers-viem/test/reverted/revertedWithCustomError.ts b/packages/hardhat-chai-matchers-viem/test/reverted/revertedWithCustomError.ts index 534dfa7929..884420d697 100644 --- a/packages/hardhat-chai-matchers-viem/test/reverted/revertedWithCustomError.ts +++ b/packages/hardhat-chai-matchers-viem/test/reverted/revertedWithCustomError.ts @@ -490,9 +490,6 @@ describe("INTEGRATION: Reverted with custom error", function () { const randomPrivateKey = "0xc5c587cc6e48e9692aee0bf07474118e6d830c11905f7ec7ff32c09c99eba5f9"; const account = privateKeyToAccount(randomPrivateKey); - const wallet = await this.hre.viem.getWalletClient(account.address, { - account, - }); // this transaction will fail because of lack of funds, not because of a // revert @@ -500,7 +497,7 @@ describe("INTEGRATION: Reverted with custom error", function () { expect( matchers.write.revertsWithoutReason({ gas: 1_000_000n, - account: wallet.account, + account, }) ).to.not.be.revertedWithCustomError(matchers, "SomeCustomError") ).to.be.eventually.rejectedWith( diff --git a/packages/hardhat-chai-matchers-viem/test/reverted/revertedWithPanic.ts b/packages/hardhat-chai-matchers-viem/test/reverted/revertedWithPanic.ts index 665df70b28..36d26db882 100644 --- a/packages/hardhat-chai-matchers-viem/test/reverted/revertedWithPanic.ts +++ b/packages/hardhat-chai-matchers-viem/test/reverted/revertedWithPanic.ts @@ -285,9 +285,6 @@ describe("INTEGRATION: Reverted with panic", function () { const randomPrivateKey = "0xc5c587cc6e48e9692aee0bf07474118e6d830c11905f7ec7ff32c09c99eba5f9"; const account = privateKeyToAccount(randomPrivateKey); - const wallet = await this.hre.viem.getWalletClient(account.address, { - account, - }); // this transaction will fail because of lack of funds, not because of a // revert @@ -295,7 +292,7 @@ describe("INTEGRATION: Reverted with panic", function () { expect( matchers.write.revertsWithoutReason({ gas: 1_000_000n, - account: wallet.account, + account, }) ).to.not.be.revertedWithPanic() ).to.be.eventually.rejectedWith( diff --git a/packages/hardhat-chai-matchers-viem/test/reverted/revertedWithoutReason.ts b/packages/hardhat-chai-matchers-viem/test/reverted/revertedWithoutReason.ts index 263a682735..88da8922a9 100644 --- a/packages/hardhat-chai-matchers-viem/test/reverted/revertedWithoutReason.ts +++ b/packages/hardhat-chai-matchers-viem/test/reverted/revertedWithoutReason.ts @@ -1,5 +1,6 @@ import { AssertionError, expect } from "chai"; -import { ProviderError } from "hardhat/internal/core/providers/errors"; +import { TransactionExecutionError } from "viem"; +import { privateKeyToAccount } from "viem/accounts"; import path from "path"; import util from "util"; @@ -20,7 +21,8 @@ describe("INTEGRATION: Reverted without reason", function () { runTests(); }); - describe("connected to a hardhat node", function () { + // external hardhat node with viem does not include error data in some cases + describe.skip("connected to a hardhat node", function () { useEnvironmentWithNode("hardhat-project"); runTests(); @@ -30,11 +32,7 @@ describe("INTEGRATION: Reverted without reason", function () { // deploy Matchers contract before each test let matchers: MatchersContract; beforeEach("deploy matchers contract", async function () { - const Matchers = await this.hre.ethers.getContractFactory< - [], - MatchersContract - >("Matchers"); - matchers = await Matchers.deploy(); + matchers = await this.hre.viem.deployContract("Matchers"); }); // helpers @@ -58,9 +56,7 @@ describe("INTEGRATION: Reverted without reason", function () { }); }); - // depends on a bug being fixed on ethers.js - // see https://github.com/NomicFoundation/hardhat/issues/3446 - describe.skip("calling a method that reverts without a reason", function () { + describe("calling a method that reverts without a reason", function () { it("successful asserts", async function () { await runSuccessfulAsserts({ matchers, @@ -155,24 +151,19 @@ describe("INTEGRATION: Reverted without reason", function () { // use an address that almost surely doesn't have balance const randomPrivateKey = "0xc5c587cc6e48e9692aee0bf07474118e6d830c11905f7ec7ff32c09c99eba5f9"; - const signer = new this.hre.ethers.Wallet( - randomPrivateKey, - this.hre.ethers.provider - ); - const matchersFromSenderWithoutFunds = matchers.connect( - signer - ) as MatchersContract; + const account = privateKeyToAccount(randomPrivateKey); // this transaction will fail because of lack of funds, not because of a // revert await expect( expect( - matchersFromSenderWithoutFunds.revertsWithoutReason({ - gasLimit: 1_000_000, + matchers.write.revertsWithoutReason({ + gas: 1_000_000n, + account, }) ).to.not.be.revertedWithoutReason() ).to.be.eventually.rejectedWith( - ProviderError, + TransactionExecutionError, "Sender doesn't have enough funds to send tx" ); }); @@ -183,7 +174,7 @@ describe("INTEGRATION: Reverted without reason", function () { it("includes test file", async function () { try { await expect( - matchers.revertsWithoutReason() + matchers.write.revertsWithoutReason() ).to.not.be.revertedWithoutReason(); } catch (e: any) { const errorString = util.inspect(e); From d9f223d367d1e6edcb7fab4ca335928c01db6e83 Mon Sep 17 00:00:00 2001 From: johnpm-12 <39016062+johnpm-12@users.noreply.github.com> Date: Sat, 18 May 2024 17:21:09 -0700 Subject: [PATCH 10/18] change version --- packages/hardhat-chai-matchers-viem/CHANGELOG.md | 4 ++-- packages/hardhat-chai-matchers-viem/package.json | 2 +- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/packages/hardhat-chai-matchers-viem/CHANGELOG.md b/packages/hardhat-chai-matchers-viem/CHANGELOG.md index 4875b2a0be..ed78334d07 100644 --- a/packages/hardhat-chai-matchers-viem/CHANGELOG.md +++ b/packages/hardhat-chai-matchers-viem/CHANGELOG.md @@ -1,7 +1,7 @@ # @nomicfoundation/hardhat-chai-matchers-viem -## 3.0.0 +## 2.0.7 ### Major Changes -- : Initial release, forked from @nomicfoundation/hardhat-chai-matchers +- : Initial release, forked from @nomicfoundation/hardhat-chai-matchers@2.0.6 diff --git a/packages/hardhat-chai-matchers-viem/package.json b/packages/hardhat-chai-matchers-viem/package.json index a4d5eda20d..855e15a428 100644 --- a/packages/hardhat-chai-matchers-viem/package.json +++ b/packages/hardhat-chai-matchers-viem/package.json @@ -1,6 +1,6 @@ { "name": "@nomicfoundation/hardhat-chai-matchers-viem", - "version": "3.0.0", + "version": "2.0.7", "description": "Hardhat utils for testing", "homepage": "https://github.com/nomicfoundation/hardhat/tree/main/packages/hardhat-chai-matchers-viem", "repository": "github:nomicfoundation/hardhat", From d270fc9816f22da67b625a91a9813cf947e236a9 Mon Sep 17 00:00:00 2001 From: johnpm-12 <39016062+johnpm-12@users.noreply.github.com> Date: Sat, 18 May 2024 18:09:29 -0700 Subject: [PATCH 11/18] fix lint --- packages/hardhat-chai-matchers-viem/.eslintrc.js | 1 + .../scripts/check-subpath-exports.js | 4 +++- .../hardhat-chai-matchers-viem/src/internal/addressable.ts | 4 ++-- .../src/internal/misc/account.ts | 4 ++-- .../src/internal/reverted/utils.ts | 7 ++----- .../hardhat-chai-matchers-viem/src/internal/withArgs.ts | 4 ++-- .../hardhat-chai-matchers-viem/test/reverted/reverted.ts | 1 - 7 files changed, 12 insertions(+), 13 deletions(-) diff --git a/packages/hardhat-chai-matchers-viem/.eslintrc.js b/packages/hardhat-chai-matchers-viem/.eslintrc.js index fb4faa04b9..3441575dfd 100644 --- a/packages/hardhat-chai-matchers-viem/.eslintrc.js +++ b/packages/hardhat-chai-matchers-viem/.eslintrc.js @@ -22,6 +22,7 @@ module.exports = { ...slowImportsCommonIgnoredModules, "chai", "chai-as-promised", + "@nomicfoundation/hardhat-viem", ], }, ], diff --git a/packages/hardhat-chai-matchers-viem/scripts/check-subpath-exports.js b/packages/hardhat-chai-matchers-viem/scripts/check-subpath-exports.js index e28c0794f4..0a147063c4 100644 --- a/packages/hardhat-chai-matchers-viem/scripts/check-subpath-exports.js +++ b/packages/hardhat-chai-matchers-viem/scripts/check-subpath-exports.js @@ -5,7 +5,9 @@ const assert = require("assert"); // run as part of the "test" script to avoid having to build the project // every time the tests are run. -const { PANIC_CODES } = require("@nomicfoundation/hardhat-chai-matchers-viem/panic"); +const { + PANIC_CODES, +} = require("@nomicfoundation/hardhat-chai-matchers-viem/panic"); assert(PANIC_CODES !== undefined); diff --git a/packages/hardhat-chai-matchers-viem/src/internal/addressable.ts b/packages/hardhat-chai-matchers-viem/src/internal/addressable.ts index fd31a72b01..2f6e63e48d 100644 --- a/packages/hardhat-chai-matchers-viem/src/internal/addressable.ts +++ b/packages/hardhat-chai-matchers-viem/src/internal/addressable.ts @@ -28,9 +28,9 @@ function override( function tryGetAddressSync(value: any): string | undefined { const { isAddress } = require("viem") as typeof ViemT; - if (value?.address) { + if (typeof value?.address !== "undefined") { value = value.address; - } else if (value?.account?.address) { + } else if (typeof value?.account?.address !== "undefined") { value = value.account.address; } if (isAddress(value)) { diff --git a/packages/hardhat-chai-matchers-viem/src/internal/misc/account.ts b/packages/hardhat-chai-matchers-viem/src/internal/misc/account.ts index bccf33fe30..1db1c01c05 100644 --- a/packages/hardhat-chai-matchers-viem/src/internal/misc/account.ts +++ b/packages/hardhat-chai-matchers-viem/src/internal/misc/account.ts @@ -11,7 +11,7 @@ export async function getAddressOf( return account; } - if ("account" in account && account.account?.address) { + if ("account" in account && typeof account.account?.address !== "undefined") { assert( /^0x[0-9a-fA-F]{40}$/.test(account.account.address), `Invalid address ${account.account.address}` @@ -19,7 +19,7 @@ export async function getAddressOf( return account.account.address; } - if ("address" in account && account.address) { + if ("address" in account && typeof account.address !== "undefined") { assert( /^0x[0-9a-fA-F]{40}$/.test(account.address), `Invalid address ${account.address}` diff --git a/packages/hardhat-chai-matchers-viem/src/internal/reverted/utils.ts b/packages/hardhat-chai-matchers-viem/src/internal/reverted/utils.ts index 21a4f5f99a..39057afcaa 100644 --- a/packages/hardhat-chai-matchers-viem/src/internal/reverted/utils.ts +++ b/packages/hardhat-chai-matchers-viem/src/internal/reverted/utils.ts @@ -42,10 +42,7 @@ export function getReturnDataFromError(error: any): `0x${string}` { error?.cause?.cause?.data?.data, error?.cause?.cause?.cause?.data, error?.cause?.cause?.cause?.data?.data, - ].find( - (returnData: any) => - typeof returnData === "string" && returnData.startsWith("0x") - ); + ].find((data: any) => typeof data === "string" && data.startsWith("0x")); if (typeof returnData !== "string") { throw error; @@ -148,7 +145,7 @@ export function resultToArray(result: Result): any[] { export function toBeHex(value: bigint) { let result = value.toString(16); // Ensure the value is of even length - if (result.length % 2) { + if (result.length % 2 === 1) { result = `0${result}`; } return `0x${result}`; diff --git a/packages/hardhat-chai-matchers-viem/src/internal/withArgs.ts b/packages/hardhat-chai-matchers-viem/src/internal/withArgs.ts index ab5f5aa3ae..c1898d41da 100644 --- a/packages/hardhat-chai-matchers-viem/src/internal/withArgs.ts +++ b/packages/hardhat-chai-matchers-viem/src/internal/withArgs.ts @@ -57,9 +57,9 @@ export function supportWithArgs( // Resolve arguments to their canonical form: // - WalletClient or contract → address const resolveArgument = (arg: any) => - arg?.account?.address + typeof arg?.account?.address !== "undefined" ? arg.account.address - : arg?.address + : typeof arg?.address !== "undefined" ? arg.address : typeof arg.getAddresses === "function" ? arg.getAddresses() diff --git a/packages/hardhat-chai-matchers-viem/test/reverted/reverted.ts b/packages/hardhat-chai-matchers-viem/test/reverted/reverted.ts index 9deb425e6f..2fe32243cb 100644 --- a/packages/hardhat-chai-matchers-viem/test/reverted/reverted.ts +++ b/packages/hardhat-chai-matchers-viem/test/reverted/reverted.ts @@ -1,4 +1,3 @@ -import type { HardhatRuntimeEnvironment } from "hardhat/types/runtime"; import type { MatchersContract } from "../contracts"; import { AssertionError, expect } from "chai"; From 1e231873bf2ea40a5e6a2d630c4d2adbacc8ef91 Mon Sep 17 00:00:00 2001 From: johnpm-12 <39016062+johnpm-12@users.noreply.github.com> Date: Sat, 18 May 2024 20:01:59 -0700 Subject: [PATCH 12/18] fix ts build errors before hardhat artifacts are compiled --- .../test/changeEtherBalance.ts | 12 +- .../test/changeEtherBalances.ts | 12 +- .../test/changeTokenBalance.ts | 15 +- .../test/contracts.ts | 20 - .../test/contracts/anotherContractAbi.ts | 28 + .../test/contracts/changeEtherBalanceAbi.ts | 26 + .../test/contracts/eventsAbi.ts | 518 ++++++++++++++++++ .../test/contracts/index.ts | 19 + .../test/contracts/matchersAbi.ts | 324 +++++++++++ .../hardhat-chai-matchers-viem/test/events.ts | 18 +- .../test/reverted/reverted.ts | 8 +- .../test/reverted/revertedWith.ts | 8 +- .../test/reverted/revertedWithCustomError.ts | 8 +- .../test/reverted/revertedWithPanic.ts | 8 +- .../test/reverted/revertedWithoutReason.ts | 8 +- 15 files changed, 994 insertions(+), 38 deletions(-) delete mode 100644 packages/hardhat-chai-matchers-viem/test/contracts.ts create mode 100644 packages/hardhat-chai-matchers-viem/test/contracts/anotherContractAbi.ts create mode 100644 packages/hardhat-chai-matchers-viem/test/contracts/changeEtherBalanceAbi.ts create mode 100644 packages/hardhat-chai-matchers-viem/test/contracts/eventsAbi.ts create mode 100644 packages/hardhat-chai-matchers-viem/test/contracts/index.ts create mode 100644 packages/hardhat-chai-matchers-viem/test/contracts/matchersAbi.ts diff --git a/packages/hardhat-chai-matchers-viem/test/changeEtherBalance.ts b/packages/hardhat-chai-matchers-viem/test/changeEtherBalance.ts index f7e917889b..f86a9537f6 100644 --- a/packages/hardhat-chai-matchers-viem/test/changeEtherBalance.ts +++ b/packages/hardhat-chai-matchers-viem/test/changeEtherBalance.ts @@ -29,14 +29,22 @@ describe("INTEGRATION: changeEtherBalance matcher", function () { beforeEach(async function () { [sender, receiver] = await this.hre.viem.getWalletClients(); - contract = await this.hre.viem.deployContract("ChangeEtherBalance"); + // Contract artifacts don't exist until tests are run. + // Without artifacts, ts doesn't know contract types. + // So build fails which prevents tests from being run. + // '[contract] as unknown as [Contract]' is a bandaid. + contract = (await this.hre.viem.deployContract( + "ChangeEtherBalance" + )) as unknown as ChangeEtherBalance; txGasFees = 1 * 21_000; await this.hre.network.provider.send( "hardhat_setNextBlockBaseFeePerGas", ["0x0"] ); - mockToken = await this.hre.viem.deployContract("MockToken"); + mockToken = (await this.hre.viem.deployContract( + "MockToken" + )) as unknown as Token; }); describe("Transaction Callback (legacy tx)", () => { diff --git a/packages/hardhat-chai-matchers-viem/test/changeEtherBalances.ts b/packages/hardhat-chai-matchers-viem/test/changeEtherBalances.ts index b9ff0ffaf4..9ec830120a 100644 --- a/packages/hardhat-chai-matchers-viem/test/changeEtherBalances.ts +++ b/packages/hardhat-chai-matchers-viem/test/changeEtherBalances.ts @@ -31,14 +31,22 @@ describe("INTEGRATION: changeEtherBalances matcher", function () { beforeEach(async function () { [sender, receiver] = await this.hre.viem.getWalletClients(); - contract = await this.hre.viem.deployContract("ChangeEtherBalance"); + // Contract artifacts don't exist until tests are run. + // Without artifacts, ts doesn't know contract types. + // So build fails which prevents tests from being run. + // '[contract] as unknown as [Contract]' is a bandaid. + contract = (await this.hre.viem.deployContract( + "ChangeEtherBalance" + )) as unknown as ChangeEtherBalance; txGasFees = 1 * 21_000; await this.hre.network.provider.send( "hardhat_setNextBlockBaseFeePerGas", ["0x0"] ); - mockToken = await this.hre.viem.deployContract("MockToken"); + mockToken = (await this.hre.viem.deployContract( + "MockToken" + )) as unknown as Token; }); describe("Transaction Callback", () => { diff --git a/packages/hardhat-chai-matchers-viem/test/changeTokenBalance.ts b/packages/hardhat-chai-matchers-viem/test/changeTokenBalance.ts index 9b6d8816bf..931905c57e 100644 --- a/packages/hardhat-chai-matchers-viem/test/changeTokenBalance.ts +++ b/packages/hardhat-chai-matchers-viem/test/changeTokenBalance.ts @@ -39,10 +39,17 @@ describe("INTEGRATION: changeTokenBalance and changeTokenBalances matchers", fun beforeEach(async function () { [sender, receiver] = await this.hre.viem.getWalletClients(); - - mockToken = await this.hre.viem.deployContract("MockToken"); - - matchers = await this.hre.viem.deployContract("Matchers"); + // Contract artifacts don't exist until tests are run. + // Without artifacts, ts doesn't know contract types. + // So build fails which prevents tests from being run. + // '[contract] as unknown as [Contract]' is a bandaid. + mockToken = (await this.hre.viem.deployContract( + "MockToken" + )) as unknown as Token; + + matchers = (await this.hre.viem.deployContract( + "Matchers" + )) as unknown as MatchersContract; }); describe("transaction that doesn't move tokens", () => { diff --git a/packages/hardhat-chai-matchers-viem/test/contracts.ts b/packages/hardhat-chai-matchers-viem/test/contracts.ts deleted file mode 100644 index 0a1d14ba58..0000000000 --- a/packages/hardhat-chai-matchers-viem/test/contracts.ts +++ /dev/null @@ -1,20 +0,0 @@ -import type { GetContractReturnType } from "@nomicfoundation/hardhat-viem/types"; -import type { ArtifactsMap } from "hardhat/types/artifacts"; - -export type Token = GetContractReturnType; - -export type MatchersContract = GetContractReturnType< - ArtifactsMap["Matchers"]["abi"] ->; - -export type ChangeEtherBalance = GetContractReturnType< - ArtifactsMap["ChangeEtherBalance"]["abi"] ->; - -export type EventsContract = GetContractReturnType< - ArtifactsMap["Events"]["abi"] ->; - -export type AnotherContract = GetContractReturnType< - ArtifactsMap["AnotherContract"]["abi"] ->; diff --git a/packages/hardhat-chai-matchers-viem/test/contracts/anotherContractAbi.ts b/packages/hardhat-chai-matchers-viem/test/contracts/anotherContractAbi.ts new file mode 100644 index 0000000000..bfd7f5e465 --- /dev/null +++ b/packages/hardhat-chai-matchers-viem/test/contracts/anotherContractAbi.ts @@ -0,0 +1,28 @@ +export const anotherContractAbi = [ + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "uint256", + name: "u", + type: "uint256", + }, + ], + name: "WithUintArg", + type: "event", + }, + { + inputs: [ + { + internalType: "uint256", + name: "u", + type: "uint256", + }, + ], + name: "emitUint", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, +] as const; diff --git a/packages/hardhat-chai-matchers-viem/test/contracts/changeEtherBalanceAbi.ts b/packages/hardhat-chai-matchers-viem/test/contracts/changeEtherBalanceAbi.ts new file mode 100644 index 0000000000..eaf7a69680 --- /dev/null +++ b/packages/hardhat-chai-matchers-viem/test/contracts/changeEtherBalanceAbi.ts @@ -0,0 +1,26 @@ +export const changeEtherBalanceAbi = [ + { + inputs: [], + name: "returnHalf", + outputs: [], + stateMutability: "payable", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "addr", + type: "address", + }, + ], + name: "transferTo", + outputs: [], + stateMutability: "payable", + type: "function", + }, + { + stateMutability: "payable", + type: "receive", + }, +] as const; diff --git a/packages/hardhat-chai-matchers-viem/test/contracts/eventsAbi.ts b/packages/hardhat-chai-matchers-viem/test/contracts/eventsAbi.ts new file mode 100644 index 0000000000..1a440336cb --- /dev/null +++ b/packages/hardhat-chai-matchers-viem/test/contracts/eventsAbi.ts @@ -0,0 +1,518 @@ +export const eventsAbi = [ + { + inputs: [ + { + internalType: "contract AnotherContract", + name: "c", + type: "address", + }, + ], + stateMutability: "nonpayable", + type: "constructor", + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "address", + name: "a", + type: "address", + }, + ], + name: "WithAddressArg", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "bytes32", + name: "b", + type: "bytes32", + }, + ], + name: "WithBytes32Arg", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "bytes32[2]", + name: "a", + type: "bytes32[2]", + }, + ], + name: "WithBytes32Array", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "bytes", + name: "b", + type: "bytes", + }, + ], + name: "WithBytesArg", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: "bytes32", + name: "b", + type: "bytes32", + }, + ], + name: "WithIndexedBytes32Arg", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: "bytes", + name: "b", + type: "bytes", + }, + ], + name: "WithIndexedBytesArg", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: true, + internalType: "string", + name: "s", + type: "string", + }, + ], + name: "WithIndexedStringArg", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "int256", + name: "i", + type: "int256", + }, + ], + name: "WithIntArg", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "string", + name: "s", + type: "string", + }, + ], + name: "WithStringArg", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + components: [ + { + internalType: "uint256", + name: "u", + type: "uint256", + }, + { + internalType: "uint256", + name: "v", + type: "uint256", + }, + ], + indexed: false, + internalType: "struct Events.Struct", + name: "s", + type: "tuple", + }, + ], + name: "WithStructArg", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "string", + name: "s", + type: "string", + }, + { + indexed: false, + internalType: "string", + name: "t", + type: "string", + }, + ], + name: "WithTwoStringArgs", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "uint256", + name: "u", + type: "uint256", + }, + { + indexed: false, + internalType: "uint256", + name: "v", + type: "uint256", + }, + ], + name: "WithTwoUintArgs", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "uint256", + name: "u", + type: "uint256", + }, + ], + name: "WithUintArg", + type: "event", + }, + { + anonymous: false, + inputs: [ + { + indexed: false, + internalType: "uint256[2]", + name: "a", + type: "uint256[2]", + }, + ], + name: "WithUintArray", + type: "event", + }, + { + anonymous: false, + inputs: [], + name: "WithoutArgs", + type: "event", + }, + { + inputs: [], + name: "doNotEmit", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "address", + name: "a", + type: "address", + }, + ], + name: "emitAddress", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "bytes", + name: "b", + type: "bytes", + }, + ], + name: "emitBytes", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "bytes32", + name: "b", + type: "bytes32", + }, + ], + name: "emitBytes32", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "bytes32", + name: "b", + type: "bytes32", + }, + { + internalType: "bytes32", + name: "c", + type: "bytes32", + }, + ], + name: "emitBytes32Array", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "bytes", + name: "b", + type: "bytes", + }, + ], + name: "emitIndexedBytes", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "bytes32", + name: "b", + type: "bytes32", + }, + ], + name: "emitIndexedBytes32", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "s", + type: "string", + }, + ], + name: "emitIndexedString", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "int256", + name: "i", + type: "int256", + }, + ], + name: "emitInt", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "uint256", + name: "u", + type: "uint256", + }, + ], + name: "emitNestedUintFromAnotherContract", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "uint256", + name: "u", + type: "uint256", + }, + ], + name: "emitNestedUintFromSameContract", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "s", + type: "string", + }, + ], + name: "emitString", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "uint256", + name: "u", + type: "uint256", + }, + { + internalType: "uint256", + name: "v", + type: "uint256", + }, + ], + name: "emitStruct", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "uint256", + name: "u", + type: "uint256", + }, + { + internalType: "uint256", + name: "v", + type: "uint256", + }, + ], + name: "emitTwoUints", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "uint256", + name: "u", + type: "uint256", + }, + { + internalType: "uint256", + name: "v", + type: "uint256", + }, + { + internalType: "string", + name: "s", + type: "string", + }, + { + internalType: "string", + name: "t", + type: "string", + }, + ], + name: "emitTwoUintsAndTwoStrings", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "uint256", + name: "u", + type: "uint256", + }, + ], + name: "emitUint", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "uint256", + name: "u", + type: "uint256", + }, + { + internalType: "string", + name: "s", + type: "string", + }, + ], + name: "emitUintAndString", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "uint256", + name: "u", + type: "uint256", + }, + { + internalType: "uint256", + name: "v", + type: "uint256", + }, + ], + name: "emitUintArray", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "uint256", + name: "u", + type: "uint256", + }, + { + internalType: "uint256", + name: "v", + type: "uint256", + }, + ], + name: "emitUintTwice", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [], + name: "emitWithoutArgs", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, +] as const; diff --git a/packages/hardhat-chai-matchers-viem/test/contracts/index.ts b/packages/hardhat-chai-matchers-viem/test/contracts/index.ts new file mode 100644 index 0000000000..a14689e5ea --- /dev/null +++ b/packages/hardhat-chai-matchers-viem/test/contracts/index.ts @@ -0,0 +1,19 @@ +import type { GetContractReturnType } from "@nomicfoundation/hardhat-viem/types"; +import type { erc20Abi } from "viem"; + +import type { matchersAbi } from "./matchersAbi"; +import type { changeEtherBalanceAbi } from "./changeEtherBalanceAbi"; +import type { eventsAbi } from "./eventsAbi"; +import type { anotherContractAbi } from "./anotherContractAbi"; + +export type Token = GetContractReturnType; + +export type MatchersContract = GetContractReturnType; + +export type ChangeEtherBalance = GetContractReturnType< + typeof changeEtherBalanceAbi +>; + +export type EventsContract = GetContractReturnType; + +export type AnotherContract = GetContractReturnType; diff --git a/packages/hardhat-chai-matchers-viem/test/contracts/matchersAbi.ts b/packages/hardhat-chai-matchers-viem/test/contracts/matchersAbi.ts new file mode 100644 index 0000000000..141b1d0fb0 --- /dev/null +++ b/packages/hardhat-chai-matchers-viem/test/contracts/matchersAbi.ts @@ -0,0 +1,324 @@ +export const matchersAbi = [ + { + inputs: [], + stateMutability: "nonpayable", + type: "constructor", + }, + { + inputs: [], + name: "AnotherCustomError", + type: "error", + }, + { + inputs: [ + { + internalType: "int256", + name: "", + type: "int256", + }, + ], + name: "CustomErrorWithInt", + type: "error", + }, + { + inputs: [ + { + components: [ + { + internalType: "uint256", + name: "a", + type: "uint256", + }, + { + internalType: "uint256", + name: "b", + type: "uint256", + }, + ], + internalType: "struct Matchers.Pair", + name: "", + type: "tuple", + }, + ], + name: "CustomErrorWithPair", + type: "error", + }, + { + inputs: [ + { + internalType: "uint256", + name: "nameToForceEthersToUseAnArrayLikeWithNamedProperties", + type: "uint256", + }, + ], + name: "CustomErrorWithUint", + type: "error", + }, + { + inputs: [ + { + internalType: "uint256", + name: "", + type: "uint256", + }, + { + internalType: "string", + name: "", + type: "string", + }, + ], + name: "CustomErrorWithUintAndString", + type: "error", + }, + { + inputs: [], + name: "SomeCustomError", + type: "error", + }, + { + anonymous: false, + inputs: [], + name: "SomeEvent", + type: "event", + }, + { + inputs: [], + name: "panicAssert", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [], + name: "panicAssertView", + outputs: [], + stateMutability: "pure", + type: "function", + }, + { + inputs: [], + name: "revertWithAnotherContractCustomError", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [], + name: "revertWithAnotherContractCustomErrorView", + outputs: [], + stateMutability: "view", + type: "function", + }, + { + inputs: [], + name: "revertWithAnotherCustomError", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [], + name: "revertWithAnotherCustomErrorView", + outputs: [], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "int256", + name: "i", + type: "int256", + }, + ], + name: "revertWithCustomErrorWithInt", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "int256", + name: "i", + type: "int256", + }, + ], + name: "revertWithCustomErrorWithIntView", + outputs: [], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "uint256", + name: "a", + type: "uint256", + }, + { + internalType: "uint256", + name: "b", + type: "uint256", + }, + ], + name: "revertWithCustomErrorWithPair", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "uint256", + name: "a", + type: "uint256", + }, + { + internalType: "uint256", + name: "b", + type: "uint256", + }, + ], + name: "revertWithCustomErrorWithPairView", + outputs: [], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "uint256", + name: "n", + type: "uint256", + }, + ], + name: "revertWithCustomErrorWithUint", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "uint256", + name: "n", + type: "uint256", + }, + { + internalType: "string", + name: "s", + type: "string", + }, + ], + name: "revertWithCustomErrorWithUintAndString", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "uint256", + name: "n", + type: "uint256", + }, + { + internalType: "string", + name: "s", + type: "string", + }, + ], + name: "revertWithCustomErrorWithUintAndStringView", + outputs: [], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "uint256", + name: "n", + type: "uint256", + }, + ], + name: "revertWithCustomErrorWithUintView", + outputs: [], + stateMutability: "pure", + type: "function", + }, + { + inputs: [], + name: "revertWithSomeCustomError", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [], + name: "revertWithSomeCustomErrorView", + outputs: [], + stateMutability: "pure", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "reason", + type: "string", + }, + ], + name: "revertsWith", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [ + { + internalType: "string", + name: "reason", + type: "string", + }, + ], + name: "revertsWithView", + outputs: [], + stateMutability: "pure", + type: "function", + }, + { + inputs: [], + name: "revertsWithoutReason", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [], + name: "revertsWithoutReasonView", + outputs: [], + stateMutability: "pure", + type: "function", + }, + { + inputs: [], + name: "succeeds", + outputs: [], + stateMutability: "nonpayable", + type: "function", + }, + { + inputs: [], + name: "succeedsView", + outputs: [ + { + internalType: "uint256", + name: "", + type: "uint256", + }, + ], + stateMutability: "view", + type: "function", + }, +] as const; diff --git a/packages/hardhat-chai-matchers-viem/test/events.ts b/packages/hardhat-chai-matchers-viem/test/events.ts index 0fef2abead..daf6b2742f 100644 --- a/packages/hardhat-chai-matchers-viem/test/events.ts +++ b/packages/hardhat-chai-matchers-viem/test/events.ts @@ -37,13 +37,21 @@ describe(".to.emit (contract events)", () => { function runTests() { beforeEach(async function () { - otherContract = await this.hre.viem.deployContract("AnotherContract"); - - contract = await this.hre.viem.deployContract("Events", [ + // Contract artifacts don't exist until tests are run. + // Without artifacts, ts doesn't know contract types. + // So build fails which prevents tests from being run. + // '[contract] as unknown as [Contract]' is a bandaid. + otherContract = (await this.hre.viem.deployContract( + "AnotherContract" + )) as unknown as AnotherContract; + + contract = (await this.hre.viem.deployContract("Events", [ otherContract.address, - ]); + ])) as unknown as EventsContract; - matchers = await this.hre.viem.deployContract("Matchers"); + matchers = (await this.hre.viem.deployContract( + "Matchers" + )) as unknown as MatchersContract; }); it("Should fail when expecting an event that's not in the contract", async function () { diff --git a/packages/hardhat-chai-matchers-viem/test/reverted/reverted.ts b/packages/hardhat-chai-matchers-viem/test/reverted/reverted.ts index 2fe32243cb..5ce9505518 100644 --- a/packages/hardhat-chai-matchers-viem/test/reverted/reverted.ts +++ b/packages/hardhat-chai-matchers-viem/test/reverted/reverted.ts @@ -35,7 +35,13 @@ describe("INTEGRATION: Reverted", function () { // deploy Matchers contract before each test let matchers: MatchersContract; beforeEach("deploy matchers contract", async function () { - matchers = await this.hre.viem.deployContract("Matchers"); + // Contract artifacts don't exist until tests are run. + // Without artifacts, ts doesn't know contract types. + // So build fails which prevents tests from being run. + // '[contract] as unknown as [Contract]' is a bandaid. + matchers = (await this.hre.viem.deployContract( + "Matchers" + )) as unknown as MatchersContract; }); // helpers diff --git a/packages/hardhat-chai-matchers-viem/test/reverted/revertedWith.ts b/packages/hardhat-chai-matchers-viem/test/reverted/revertedWith.ts index 956d4da5c8..7ca71ea201 100644 --- a/packages/hardhat-chai-matchers-viem/test/reverted/revertedWith.ts +++ b/packages/hardhat-chai-matchers-viem/test/reverted/revertedWith.ts @@ -34,7 +34,13 @@ describe("INTEGRATION: Reverted with", function () { let matchers: MatchersContract; beforeEach("deploy matchers contract", async function () { - matchers = await this.hre.viem.deployContract("Matchers"); + // Contract artifacts don't exist until tests are run. + // Without artifacts, ts doesn't know contract types. + // So build fails which prevents tests from being run. + // '[contract] as unknown as [Contract]' is a bandaid. + matchers = (await this.hre.viem.deployContract( + "Matchers" + )) as unknown as MatchersContract; }); describe("calling a method that succeeds", function () { diff --git a/packages/hardhat-chai-matchers-viem/test/reverted/revertedWithCustomError.ts b/packages/hardhat-chai-matchers-viem/test/reverted/revertedWithCustomError.ts index 884420d697..b88923b870 100644 --- a/packages/hardhat-chai-matchers-viem/test/reverted/revertedWithCustomError.ts +++ b/packages/hardhat-chai-matchers-viem/test/reverted/revertedWithCustomError.ts @@ -34,7 +34,13 @@ describe("INTEGRATION: Reverted with custom error", function () { // deploy Matchers contract before each test let matchers: MatchersContract; beforeEach("deploy matchers contract", async function () { - matchers = await this.hre.viem.deployContract("Matchers"); + // Contract artifacts don't exist until tests are run. + // Without artifacts, ts doesn't know contract types. + // So build fails which prevents tests from being run. + // '[contract] as unknown as [Contract]' is a bandaid. + matchers = (await this.hre.viem.deployContract( + "Matchers" + )) as unknown as MatchersContract; }); describe("calling a method that succeeds", function () { diff --git a/packages/hardhat-chai-matchers-viem/test/reverted/revertedWithPanic.ts b/packages/hardhat-chai-matchers-viem/test/reverted/revertedWithPanic.ts index 36d26db882..3d61f32aa2 100644 --- a/packages/hardhat-chai-matchers-viem/test/reverted/revertedWithPanic.ts +++ b/packages/hardhat-chai-matchers-viem/test/reverted/revertedWithPanic.ts @@ -33,7 +33,13 @@ describe("INTEGRATION: Reverted with panic", function () { // deploy Matchers contract before each test let matchers: MatchersContract; beforeEach("deploy matchers contract", async function () { - matchers = await this.hre.viem.deployContract("Matchers"); + // Contract artifacts don't exist until tests are run. + // Without artifacts, ts doesn't know contract types. + // So build fails which prevents tests from being run. + // '[contract] as unknown as [Contract]' is a bandaid. + matchers = (await this.hre.viem.deployContract( + "Matchers" + )) as unknown as MatchersContract; }); describe("calling a method that succeeds", function () { diff --git a/packages/hardhat-chai-matchers-viem/test/reverted/revertedWithoutReason.ts b/packages/hardhat-chai-matchers-viem/test/reverted/revertedWithoutReason.ts index 88da8922a9..57c6209bbb 100644 --- a/packages/hardhat-chai-matchers-viem/test/reverted/revertedWithoutReason.ts +++ b/packages/hardhat-chai-matchers-viem/test/reverted/revertedWithoutReason.ts @@ -32,7 +32,13 @@ describe("INTEGRATION: Reverted without reason", function () { // deploy Matchers contract before each test let matchers: MatchersContract; beforeEach("deploy matchers contract", async function () { - matchers = await this.hre.viem.deployContract("Matchers"); + // Contract artifacts don't exist until tests are run. + // Without artifacts, ts doesn't know contract types. + // So build fails which prevents tests from being run. + // '[contract] as unknown as [Contract]' is a bandaid. + matchers = (await this.hre.viem.deployContract( + "Matchers" + )) as unknown as MatchersContract; }); // helpers From 1bd47254dfa1d9fd1135924fb9af949c7c6ce4d8 Mon Sep 17 00:00:00 2001 From: johnpm-12 <39016062+johnpm-12@users.noreply.github.com> Date: Sun, 19 May 2024 08:52:45 -0700 Subject: [PATCH 13/18] add ci --- .../hardhat-chai-matchers-viem-ci.yml | 92 +++++++++++++++++++ 1 file changed, 92 insertions(+) create mode 100644 .github/workflows/hardhat-chai-matchers-viem-ci.yml diff --git a/.github/workflows/hardhat-chai-matchers-viem-ci.yml b/.github/workflows/hardhat-chai-matchers-viem-ci.yml new file mode 100644 index 0000000000..2425bfe1f1 --- /dev/null +++ b/.github/workflows/hardhat-chai-matchers-viem-ci.yml @@ -0,0 +1,92 @@ +name: hardhat-chai-matchers-viem CI + +on: + push: + branches: [$default-branch] + paths: + - "packages/hardhat-chai-matchers-viem/**" + - "packages/hardhat-common/**" + - "config/**" + pull_request: + branches: + - "**" + paths: + - "packages/hardhat-chai-matchers-viem/**" + - "packages/hardhat-common/**" + - "config/**" + workflow_dispatch: + +defaults: + run: + working-directory: packages/hardhat-chai-matchers-viem + +concurrency: + group: ${{github.workflow}}-${{github.ref}} + cancel-in-progress: true + +jobs: + test_on_windows: + name: Test hardhat-chai-matchers-viem on Windows with Node 18 + runs-on: windows-latest + steps: + - uses: actions/checkout@v4 + - uses: pnpm/action-setup@v2 + with: + version: 8 + - uses: actions/setup-node@v4 + with: + node-version: 18 + cache: "pnpm" + - name: Install + run: pnpm install --frozen-lockfile --prefer-offline + - name: Build + run: pnpm build + - name: Run tests + env: + FORCE_COLOR: 3 + run: pnpm test:ci + + test_on_macos: + name: Test hardhat-chai-matchers-viem on MacOS with Node 18 + runs-on: macos-latest + steps: + - uses: actions/checkout@v4 + - uses: pnpm/action-setup@v2 + with: + version: 8 + - uses: actions/setup-node@v4 + with: + node-version: 18 + cache: "pnpm" + - name: Install + run: pnpm install --frozen-lockfile --prefer-offline + - name: Build + run: pnpm build + - name: Run tests + env: + FORCE_COLOR: 3 + run: pnpm test:ci + + test_on_linux: + name: Test hardhat-chai-matchers-viem on Ubuntu with Node ${{ matrix.node }} + runs-on: ubuntu-latest + strategy: + matrix: + node: [18, 20] + steps: + - uses: actions/checkout@v4 + - uses: pnpm/action-setup@v2 + with: + version: 8 + - uses: actions/setup-node@v4 + with: + node-version: ${{ matrix.node }} + cache: "pnpm" + - name: Install + run: pnpm install --frozen-lockfile --prefer-offline + - name: Build + run: pnpm build + - name: Run tests + env: + FORCE_COLOR: 3 + run: pnpm test:ci From 0e6f83da2ea94c2874bcc41c3f087d0db819ad71 Mon Sep 17 00:00:00 2001 From: johnpm-12 <39016062+johnpm-12@users.noreply.github.com> Date: Sun, 19 May 2024 16:22:25 -0700 Subject: [PATCH 14/18] cleanup --- packages/hardhat-chai-matchers-viem/src/internal/typed.ts | 8 -------- 1 file changed, 8 deletions(-) delete mode 100644 packages/hardhat-chai-matchers-viem/src/internal/typed.ts diff --git a/packages/hardhat-chai-matchers-viem/src/internal/typed.ts b/packages/hardhat-chai-matchers-viem/src/internal/typed.ts deleted file mode 100644 index cf331ac2d7..0000000000 --- a/packages/hardhat-chai-matchers-viem/src/internal/typed.ts +++ /dev/null @@ -1,8 +0,0 @@ -export function tryDereference(value: any, type: string) { - const { Typed } = require("ethers") as typeof import("ethers"); - try { - return Typed.dereference(value, type); - } catch { - return undefined; - } -} From 59818f9acfefa02caa6bb12eec5787512e6be729 Mon Sep 17 00:00:00 2001 From: johnpm-12 <39016062+johnpm-12@users.noreply.github.com> Date: Sun, 19 May 2024 18:45:49 -0700 Subject: [PATCH 15/18] fix some package versions --- packages/hardhat-chai-matchers-viem/package.json | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/packages/hardhat-chai-matchers-viem/package.json b/packages/hardhat-chai-matchers-viem/package.json index 855e15a428..ddcfe9ab2f 100644 --- a/packages/hardhat-chai-matchers-viem/package.json +++ b/packages/hardhat-chai-matchers-viem/package.json @@ -55,19 +55,19 @@ "eslint-plugin-prettier": "3.4.0", "ethers": "^6.1.0", "get-port": "^5.1.1", - "hardhat": "workspace:^2.11.0", + "hardhat": "workspace:^2.9.4", "mocha": "^10.0.0", "prettier": "2.4.1", "rimraf": "^3.0.2", "ts-node": "^10.8.0", - "typescript": "~5.0.4", + "typescript": "~5.0.0", "viem": "^2.7.6" }, "peerDependencies": { "@nomicfoundation/hardhat-viem": "workspace:^2.0.0", "chai": "^4.2.0", "ethers": "^6.1.0", - "hardhat": "workspace:^2.11.0", + "hardhat": "workspace:^2.9.4", "viem": "^2.7.6" }, "dependencies": { From 19648db713fd297e3455bf515785654d1a1f3322 Mon Sep 17 00:00:00 2001 From: johnpm-12 <39016062+johnpm-12@users.noreply.github.com> Date: Sun, 19 May 2024 19:17:14 -0700 Subject: [PATCH 16/18] fix eslint failing on hardhat build artifacts --- packages/hardhat-chai-matchers-viem/test/.eslintrc.js | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/packages/hardhat-chai-matchers-viem/test/.eslintrc.js b/packages/hardhat-chai-matchers-viem/test/.eslintrc.js index d9238cab24..85e04645b7 100644 --- a/packages/hardhat-chai-matchers-viem/test/.eslintrc.js +++ b/packages/hardhat-chai-matchers-viem/test/.eslintrc.js @@ -4,6 +4,10 @@ module.exports = { project: `${__dirname}/../tsconfig.json`, sourceType: "module", }, + ignorePatterns: [ + "/fixture-projects/hardhat-project/artifacts", + "/fixture-projects/hardhat-project/cache", + ], rules: { "@typescript-eslint/restrict-template-expressions": "off", "import/no-extraneous-dependencies": [ From 04898f3a7a9b8e9492fafbec27624661b9bf84b9 Mon Sep 17 00:00:00 2001 From: johnpm-12 <39016062+johnpm-12@users.noreply.github.com> Date: Sun, 19 May 2024 19:28:00 -0700 Subject: [PATCH 17/18] add changeset --- .changeset/stupid-dogs-melt.md | 5 +++++ 1 file changed, 5 insertions(+) create mode 100644 .changeset/stupid-dogs-melt.md diff --git a/.changeset/stupid-dogs-melt.md b/.changeset/stupid-dogs-melt.md new file mode 100644 index 0000000000..bff10db179 --- /dev/null +++ b/.changeset/stupid-dogs-melt.md @@ -0,0 +1,5 @@ +--- +"@nomicfoundation/hardhat-chai-matchers-viem": major +--- + +Initial release, forked from @nomicfoundation/hardhat-chai-matchers@2.0.6 From bb45ca8a1e95333fc1d95678b9115a523e560984 Mon Sep 17 00:00:00 2001 From: johnpm-12 <39016062+johnpm-12@users.noreply.github.com> Date: Sun, 19 May 2024 19:38:52 -0700 Subject: [PATCH 18/18] fix incompatible lock file from wrong pnpm version --- pnpm-lock.yaml | 12327 ++++++++++++++++++++--------------------------- 1 file changed, 5148 insertions(+), 7179 deletions(-) diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml index 6bcdfdd20d..ee1f7eba90 100644 --- a/pnpm-lock.yaml +++ b/pnpm-lock.yaml @@ -1,4 +1,4 @@ -lockfileVersion: '9.0' +lockfileVersion: '6.0' settings: autoInstallPeers: true @@ -65,7 +65,7 @@ importers: version: 16.6.2(eslint@8.57.0) eslint-plugin-prettier: specifier: 3.4.0 - version: 3.4.0(eslint-config-prettier@8.3.0(eslint@8.57.0))(eslint@8.57.0)(prettier@2.8.8) + version: 3.4.0(eslint-config-prettier@8.3.0)(eslint@8.57.0)(prettier@2.4.1) mocha: specifier: ^10.0.0 version: 10.4.0 @@ -74,7 +74,7 @@ importers: dependencies: eslint-module-utils: specifier: ^2.8.0 - version: 2.8.1(@typescript-eslint/parser@5.61.0(eslint@8.57.0)(typescript@5.0.4))(eslint-import-resolver-node@0.3.9)(eslint@8.57.0) + version: 2.8.1(@typescript-eslint/parser@5.61.0)(eslint-import-resolver-node@0.3.9)(eslint@8.57.0) requireindex: specifier: ^1.2.0 version: 1.2.0 @@ -139,7 +139,7 @@ importers: version: 18.19.33 '@typescript-eslint/eslint-plugin': specifier: 5.61.0 - version: 5.61.0(@typescript-eslint/parser@5.61.0(eslint@8.57.0)(typescript@5.0.4))(eslint@8.57.0)(typescript@5.0.4) + version: 5.61.0(@typescript-eslint/parser@5.61.0)(eslint@8.57.0)(typescript@5.0.4) '@typescript-eslint/parser': specifier: 5.61.0 version: 5.61.0(eslint@8.57.0)(typescript@5.0.4) @@ -160,16 +160,16 @@ importers: version: 8.3.0(eslint@8.57.0) eslint-plugin-import: specifier: 2.27.5 - version: 2.27.5(@typescript-eslint/parser@5.61.0(eslint@8.57.0)(typescript@5.0.4))(eslint@8.57.0) + version: 2.27.5(@typescript-eslint/parser@5.61.0)(eslint@8.57.0) eslint-plugin-mocha: specifier: 10.4.1 version: 10.4.1(eslint@8.57.0) eslint-plugin-prettier: specifier: 3.4.0 - version: 3.4.0(eslint-config-prettier@8.3.0(eslint@8.57.0))(eslint@8.57.0)(prettier@2.4.1) + version: 3.4.0(eslint-config-prettier@8.3.0)(eslint@8.57.0)(prettier@2.4.1) ethers: specifier: ^6.1.0 - version: 6.12.1(bufferutil@4.0.8)(utf-8-validate@5.0.10) + version: 6.12.1 get-port: specifier: ^5.1.1 version: 5.1.1 @@ -230,7 +230,7 @@ importers: version: 18.19.33 '@typescript-eslint/eslint-plugin': specifier: 5.61.0 - version: 5.61.0(@typescript-eslint/parser@5.61.0(eslint@8.57.0)(typescript@5.0.4))(eslint@8.57.0)(typescript@5.0.4) + version: 5.61.0(@typescript-eslint/parser@5.61.0)(eslint@8.57.0)(typescript@5.0.4) '@typescript-eslint/parser': specifier: 5.61.0 version: 5.61.0(eslint@8.57.0)(typescript@5.0.4) @@ -245,21 +245,21 @@ importers: version: 8.3.0(eslint@8.57.0) eslint-plugin-import: specifier: 2.27.5 - version: 2.27.5(@typescript-eslint/parser@5.61.0(eslint@8.57.0)(typescript@5.0.4))(eslint@8.57.0) + version: 2.27.5(@typescript-eslint/parser@5.61.0)(eslint@8.57.0) eslint-plugin-mocha: specifier: 10.4.1 version: 10.4.1(eslint@8.57.0) eslint-plugin-prettier: specifier: 3.4.0 - version: 3.4.0(eslint-config-prettier@8.3.0(eslint@8.57.0))(eslint@8.57.0)(prettier@2.4.1) + version: 3.4.0(eslint-config-prettier@8.3.0)(eslint@8.57.0)(prettier@2.4.1) ethers: specifier: ^6.1.0 - version: 6.12.1(bufferutil@4.0.8)(utf-8-validate@5.0.10) + version: 6.12.1 get-port: specifier: ^5.1.1 version: 5.1.1 hardhat: - specifier: workspace:^2.11.0 + specifier: workspace:^2.9.4 version: link:../hardhat-core mocha: specifier: ^10.0.0 @@ -274,11 +274,11 @@ importers: specifier: ^10.8.0 version: 10.9.2(@types/node@18.19.33)(typescript@5.0.4) typescript: - specifier: ~5.0.4 + specifier: ~5.0.0 version: 5.0.4 viem: specifier: ^2.7.6 - version: 2.10.3(bufferutil@4.0.8)(typescript@5.0.4)(utf-8-validate@5.0.10)(zod@3.23.8) + version: 2.10.3(typescript@5.0.4) packages/hardhat-core: dependencies: @@ -410,7 +410,7 @@ importers: version: 8.3.2 ws: specifier: ^7.4.6 - version: 7.5.9(bufferutil@4.0.8)(utf-8-validate@5.0.10) + version: 7.5.9 devDependencies: '@nomicfoundation/eslint-plugin-hardhat-internal-rules': specifier: workspace:^ @@ -474,7 +474,7 @@ importers: version: 7.4.7 '@typescript-eslint/eslint-plugin': specifier: 5.61.0 - version: 5.61.0(@typescript-eslint/parser@5.61.0(eslint@8.57.0)(typescript@5.0.4))(eslint@8.57.0)(typescript@5.0.4) + version: 5.61.0(@typescript-eslint/parser@5.61.0)(eslint@8.57.0)(typescript@5.0.4) '@typescript-eslint/parser': specifier: 5.61.0 version: 5.61.0(eslint@8.57.0)(typescript@5.0.4) @@ -498,19 +498,19 @@ importers: version: 8.3.0(eslint@8.57.0) eslint-plugin-import: specifier: 2.27.5 - version: 2.27.5(@typescript-eslint/parser@5.61.0(eslint@8.57.0)(typescript@5.0.4))(eslint@8.57.0) + version: 2.27.5(@typescript-eslint/parser@5.61.0)(eslint@8.57.0) eslint-plugin-mocha: specifier: 10.4.1 version: 10.4.1(eslint@8.57.0) eslint-plugin-prettier: specifier: 3.4.0 - version: 3.4.0(eslint-config-prettier@8.3.0(eslint@8.57.0))(eslint@8.57.0)(prettier@2.4.1) + version: 3.4.0(eslint-config-prettier@8.3.0)(eslint@8.57.0)(prettier@2.4.1) ethers: specifier: ^6.1.0 - version: 6.12.1(bufferutil@4.0.8)(utf-8-validate@5.0.10) + version: 6.12.1 ethers-v5: specifier: npm:ethers@5 - version: ethers@5.7.2(bufferutil@4.0.8)(utf-8-validate@5.0.10) + version: /ethers@5.7.2 prettier: specifier: 2.4.1 version: 2.4.1 @@ -568,7 +568,7 @@ importers: version: 9.0.11 '@typescript-eslint/eslint-plugin': specifier: 5.61.0 - version: 5.61.0(@typescript-eslint/parser@5.61.0(eslint@8.57.0)(typescript@5.0.4))(eslint@8.57.0)(typescript@5.0.4) + version: 5.61.0(@typescript-eslint/parser@5.61.0)(eslint@8.57.0)(typescript@5.0.4) '@typescript-eslint/parser': specifier: 5.61.0 version: 5.61.0(eslint@8.57.0)(typescript@5.0.4) @@ -589,16 +589,16 @@ importers: version: 8.3.0(eslint@8.57.0) eslint-plugin-import: specifier: 2.27.5 - version: 2.27.5(@typescript-eslint/parser@5.61.0(eslint@8.57.0)(typescript@5.0.4))(eslint@8.57.0) + version: 2.27.5(@typescript-eslint/parser@5.61.0)(eslint@8.57.0) eslint-plugin-mocha: specifier: 10.4.1 version: 10.4.1(eslint@8.57.0) eslint-plugin-prettier: specifier: 3.4.0 - version: 3.4.0(eslint-config-prettier@8.3.0(eslint@8.57.0))(eslint@8.57.0)(prettier@2.4.1) + version: 3.4.0(eslint-config-prettier@8.3.0)(eslint@8.57.0)(prettier@2.4.1) ethers: specifier: ^6.1.0 - version: 6.12.1(bufferutil@4.0.8)(utf-8-validate@5.0.10) + version: 6.12.1 hardhat: specifier: workspace:^2.0.0 version: link:../hardhat-core @@ -644,7 +644,7 @@ importers: version: 18.19.33 '@typescript-eslint/eslint-plugin': specifier: 5.61.0 - version: 5.61.0(@typescript-eslint/parser@5.61.0(eslint@8.57.0)(typescript@5.0.4))(eslint@8.57.0)(typescript@5.0.4) + version: 5.61.0(@typescript-eslint/parser@5.61.0)(eslint@8.57.0)(typescript@5.0.4) '@typescript-eslint/parser': specifier: 5.61.0 version: 5.61.0(eslint@8.57.0)(typescript@5.0.4) @@ -659,13 +659,13 @@ importers: version: 8.3.0(eslint@8.57.0) eslint-plugin-import: specifier: 2.27.5 - version: 2.27.5(@typescript-eslint/parser@5.61.0(eslint@8.57.0)(typescript@5.0.4))(eslint@8.57.0) + version: 2.27.5(@typescript-eslint/parser@5.61.0)(eslint@8.57.0) eslint-plugin-mocha: specifier: 10.4.1 version: 10.4.1(eslint@8.57.0) eslint-plugin-prettier: specifier: 3.4.0 - version: 3.4.0(eslint-config-prettier@8.3.0(eslint@8.57.0))(eslint@8.57.0)(prettier@2.4.1) + version: 3.4.0(eslint-config-prettier@8.3.0)(eslint@8.57.0)(prettier@2.4.1) hardhat: specifier: workspace:^2.17.2 version: link:../hardhat-core @@ -713,7 +713,7 @@ importers: version: 2.2.1 ethers: specifier: ^6.1.0 - version: 6.12.1(bufferutil@4.0.8)(utf-8-validate@5.0.10) + version: 6.12.1 fs-extra: specifier: ^7.0.1 version: 7.0.1 @@ -747,7 +747,7 @@ importers: version: 9.0.11 '@typescript-eslint/eslint-plugin': specifier: 5.61.0 - version: 5.61.0(@typescript-eslint/parser@5.61.0(eslint@8.57.0)(typescript@5.0.4))(eslint@8.57.0)(typescript@5.0.4) + version: 5.61.0(@typescript-eslint/parser@5.61.0)(eslint@8.57.0)(typescript@5.0.4) '@typescript-eslint/parser': specifier: 5.61.0 version: 5.61.0(eslint@8.57.0)(typescript@5.0.4) @@ -762,13 +762,13 @@ importers: version: 8.3.0(eslint@8.57.0) eslint-plugin-import: specifier: 2.27.5 - version: 2.27.5(@typescript-eslint/parser@5.61.0(eslint@8.57.0)(typescript@5.0.4))(eslint@8.57.0) + version: 2.27.5(@typescript-eslint/parser@5.61.0)(eslint@8.57.0) eslint-plugin-mocha: specifier: 10.4.1 version: 10.4.1(eslint@8.57.0) eslint-plugin-prettier: specifier: 3.4.0 - version: 3.4.0(eslint-config-prettier@8.3.0(eslint@8.57.0))(eslint@8.57.0)(prettier@2.4.1) + version: 3.4.0(eslint-config-prettier@8.3.0)(eslint@8.57.0)(prettier@2.4.1) hardhat: specifier: workspace:^2.16.0 version: link:../hardhat-core @@ -820,7 +820,7 @@ importers: version: 18.19.33 '@typescript-eslint/eslint-plugin': specifier: 5.61.0 - version: 5.61.0(@typescript-eslint/parser@5.61.0(eslint@8.57.0)(typescript@5.0.4))(eslint@8.57.0)(typescript@5.0.4) + version: 5.61.0(@typescript-eslint/parser@5.61.0)(eslint@8.57.0)(typescript@5.0.4) '@typescript-eslint/parser': specifier: 5.61.0 version: 5.61.0(eslint@8.57.0)(typescript@5.0.4) @@ -838,16 +838,16 @@ importers: version: 8.3.0(eslint@8.57.0) eslint-plugin-import: specifier: 2.27.5 - version: 2.27.5(@typescript-eslint/parser@5.61.0(eslint@8.57.0)(typescript@5.0.4))(eslint@8.57.0) + version: 2.27.5(@typescript-eslint/parser@5.61.0)(eslint@8.57.0) eslint-plugin-mocha: specifier: 10.4.1 version: 10.4.1(eslint@8.57.0) eslint-plugin-prettier: specifier: 3.4.0 - version: 3.4.0(eslint-config-prettier@8.3.0(eslint@8.57.0))(eslint@8.57.0)(prettier@2.4.1) + version: 3.4.0(eslint-config-prettier@8.3.0)(eslint@8.57.0)(prettier@2.4.1) ethers-v5: specifier: npm:ethers@5 - version: ethers@5.7.2(bufferutil@4.0.8)(utf-8-validate@5.0.10) + version: /ethers@5.7.2 hardhat: specifier: workspace:^2.9.5 version: link:../hardhat-core @@ -905,7 +905,7 @@ importers: version: 6.2.7 '@typescript-eslint/eslint-plugin': specifier: 5.61.0 - version: 5.61.0(@typescript-eslint/parser@5.61.0(eslint@8.57.0)(typescript@5.0.4))(eslint@8.57.0)(typescript@5.0.4) + version: 5.61.0(@typescript-eslint/parser@5.61.0)(eslint@8.57.0)(typescript@5.0.4) '@typescript-eslint/parser': specifier: 5.61.0 version: 5.61.0(eslint@8.57.0)(typescript@5.0.4) @@ -920,13 +920,13 @@ importers: version: 8.3.0(eslint@8.57.0) eslint-plugin-import: specifier: 2.27.5 - version: 2.27.5(@typescript-eslint/parser@5.61.0(eslint@8.57.0)(typescript@5.0.4))(eslint@8.57.0) + version: 2.27.5(@typescript-eslint/parser@5.61.0)(eslint@8.57.0) eslint-plugin-mocha: specifier: 10.4.1 version: 10.4.1(eslint@8.57.0) eslint-plugin-prettier: specifier: 3.4.0 - version: 3.4.0(eslint-config-prettier@8.3.0(eslint@8.57.0))(eslint@8.57.0)(prettier@2.4.1) + version: 3.4.0(eslint-config-prettier@8.3.0)(eslint@8.57.0)(prettier@2.4.1) hardhat: specifier: workspace:^2.0.0 version: link:../hardhat-core @@ -975,7 +975,7 @@ importers: version: 9.0.11 '@typescript-eslint/eslint-plugin': specifier: 5.61.0 - version: 5.61.0(@typescript-eslint/parser@5.61.0(eslint@8.57.0)(typescript@5.0.4))(eslint@8.57.0)(typescript@5.0.4) + version: 5.61.0(@typescript-eslint/parser@5.61.0)(eslint@8.57.0)(typescript@5.0.4) '@typescript-eslint/parser': specifier: 5.61.0 version: 5.61.0(eslint@8.57.0)(typescript@5.0.4) @@ -990,13 +990,13 @@ importers: version: 8.3.0(eslint@8.57.0) eslint-plugin-import: specifier: 2.27.5 - version: 2.27.5(@typescript-eslint/parser@5.61.0(eslint@8.57.0)(typescript@5.0.4))(eslint@8.57.0) + version: 2.27.5(@typescript-eslint/parser@5.61.0)(eslint@8.57.0) eslint-plugin-mocha: specifier: 10.4.1 version: 10.4.1(eslint@8.57.0) eslint-plugin-prettier: specifier: 3.4.0 - version: 3.4.0(eslint-config-prettier@8.3.0(eslint@8.57.0))(eslint@8.57.0)(prettier@2.4.1) + version: 3.4.0(eslint-config-prettier@8.3.0)(eslint@8.57.0)(prettier@2.4.1) fs-extra: specifier: ^7.0.1 version: 7.0.1 @@ -1051,7 +1051,7 @@ importers: version: 18.19.33 '@typescript-eslint/eslint-plugin': specifier: 5.61.0 - version: 5.61.0(@typescript-eslint/parser@5.61.0(eslint@8.57.0)(typescript@5.0.4))(eslint@8.57.0)(typescript@5.0.4) + version: 5.61.0(@typescript-eslint/parser@5.61.0)(eslint@8.57.0)(typescript@5.0.4) '@typescript-eslint/parser': specifier: 5.61.0 version: 5.61.0(eslint@8.57.0)(typescript@5.0.4) @@ -1066,13 +1066,13 @@ importers: version: 8.3.0(eslint@8.57.0) eslint-plugin-import: specifier: 2.27.5 - version: 2.27.5(@typescript-eslint/parser@5.61.0(eslint@8.57.0)(typescript@5.0.4))(eslint@8.57.0) + version: 2.27.5(@typescript-eslint/parser@5.61.0)(eslint@8.57.0) eslint-plugin-mocha: specifier: 10.4.1 version: 10.4.1(eslint@8.57.0) eslint-plugin-prettier: specifier: 3.4.0 - version: 3.4.0(eslint-config-prettier@8.3.0(eslint@8.57.0))(eslint@8.57.0)(prettier@2.4.1) + version: 3.4.0(eslint-config-prettier@8.3.0)(eslint@8.57.0)(prettier@2.4.1) hardhat: specifier: workspace:^2.0.0 version: link:../hardhat-core @@ -1108,7 +1108,7 @@ importers: version: link:../hardhat-ethers '@nomicfoundation/hardhat-ignition-ethers': specifier: ^0.15.0 - version: 0.15.2(@nomicfoundation/hardhat-ethers@packages+hardhat-ethers)(@nomicfoundation/hardhat-ignition@0.15.2(@nomicfoundation/hardhat-verify@packages+hardhat-verify)(bufferutil@4.0.8)(hardhat@packages+hardhat-core)(utf-8-validate@5.0.10))(@nomicfoundation/ignition-core@0.15.2(bufferutil@4.0.8)(utf-8-validate@5.0.10))(ethers@6.12.1(bufferutil@4.0.8)(utf-8-validate@5.0.10))(hardhat@packages+hardhat-core) + version: 0.15.2(@nomicfoundation/hardhat-ethers@packages+hardhat-ethers)(@nomicfoundation/hardhat-ignition@0.15.2)(@nomicfoundation/ignition-core@0.15.2)(ethers@6.12.1)(hardhat@packages+hardhat-core) '@nomicfoundation/hardhat-network-helpers': specifier: workspace:^1.0.0 version: link:../hardhat-network-helpers @@ -1117,10 +1117,10 @@ importers: version: link:../hardhat-verify '@typechain/ethers-v6': specifier: ^0.5.0 - version: 0.5.1(ethers@6.12.1(bufferutil@4.0.8)(utf-8-validate@5.0.10))(typechain@8.3.2(typescript@5.0.4))(typescript@5.0.4) + version: 0.5.1(ethers@6.12.1)(typechain@8.3.2)(typescript@5.0.4) '@typechain/hardhat': specifier: ^9.0.0 - version: 9.1.0(@typechain/ethers-v6@0.5.1(ethers@6.12.1(bufferutil@4.0.8)(utf-8-validate@5.0.10))(typechain@8.3.2(typescript@5.0.4))(typescript@5.0.4))(ethers@6.12.1(bufferutil@4.0.8)(utf-8-validate@5.0.10))(hardhat@packages+hardhat-core)(typechain@8.3.2(typescript@5.0.4)) + version: 9.1.0(@typechain/ethers-v6@0.5.1)(ethers@6.12.1)(hardhat@packages+hardhat-core)(typechain@8.3.2) '@types/chai': specifier: ^4.2.0 version: 4.3.16 @@ -1132,7 +1132,7 @@ importers: version: 18.19.33 '@typescript-eslint/eslint-plugin': specifier: 5.61.0 - version: 5.61.0(@typescript-eslint/parser@5.61.0(eslint@8.57.0)(typescript@5.0.4))(eslint@8.57.0)(typescript@5.0.4) + version: 5.61.0(@typescript-eslint/parser@5.61.0)(eslint@8.57.0)(typescript@5.0.4) '@typescript-eslint/parser': specifier: 5.61.0 version: 5.61.0(eslint@8.57.0)(typescript@5.0.4) @@ -1147,22 +1147,22 @@ importers: version: 8.3.0(eslint@8.57.0) eslint-plugin-import: specifier: 2.27.5 - version: 2.27.5(@typescript-eslint/parser@5.61.0(eslint@8.57.0)(typescript@5.0.4))(eslint@8.57.0) + version: 2.27.5(@typescript-eslint/parser@5.61.0)(eslint@8.57.0) eslint-plugin-mocha: specifier: 10.4.1 version: 10.4.1(eslint@8.57.0) eslint-plugin-prettier: specifier: 3.4.0 - version: 3.4.0(eslint-config-prettier@8.3.0(eslint@8.57.0))(eslint@8.57.0)(prettier@2.4.1) + version: 3.4.0(eslint-config-prettier@8.3.0)(eslint@8.57.0)(prettier@2.4.1) ethers: specifier: ^6.4.0 - version: 6.12.1(bufferutil@4.0.8)(utf-8-validate@5.0.10) + version: 6.12.1 hardhat: specifier: workspace:^2.11.0 version: link:../hardhat-core hardhat-gas-reporter: specifier: ^1.0.8 - version: 1.0.10(bufferutil@4.0.8)(hardhat@packages+hardhat-core)(utf-8-validate@5.0.10) + version: 1.0.10(hardhat@packages+hardhat-core) mocha: specifier: ^10.0.0 version: 10.4.0 @@ -1199,7 +1199,7 @@ importers: version: link:../eslint-plugin-slow-imports '@nomicfoundation/hardhat-ignition-viem': specifier: ^0.15.0 - version: 0.15.2(@nomicfoundation/hardhat-ignition@0.15.2(@nomicfoundation/hardhat-verify@packages+hardhat-verify)(bufferutil@4.0.8)(hardhat@packages+hardhat-core)(utf-8-validate@5.0.10))(@nomicfoundation/hardhat-viem@packages+hardhat-viem)(@nomicfoundation/ignition-core@0.15.2(bufferutil@4.0.8)(utf-8-validate@5.0.10))(hardhat@packages+hardhat-core)(viem@2.10.3(bufferutil@4.0.8)(typescript@5.0.4)(utf-8-validate@5.0.10)(zod@3.23.8)) + version: 0.15.2(@nomicfoundation/hardhat-ignition@0.15.2)(@nomicfoundation/hardhat-viem@packages+hardhat-viem)(@nomicfoundation/ignition-core@0.15.2)(hardhat@packages+hardhat-core)(viem@2.10.3) '@nomicfoundation/hardhat-network-helpers': specifier: workspace:^1.0.0 version: link:../hardhat-network-helpers @@ -1223,7 +1223,7 @@ importers: version: 18.19.33 '@typescript-eslint/eslint-plugin': specifier: 5.61.0 - version: 5.61.0(@typescript-eslint/parser@5.61.0(eslint@8.57.0)(typescript@5.0.4))(eslint@8.57.0)(typescript@5.0.4) + version: 5.61.0(@typescript-eslint/parser@5.61.0)(eslint@8.57.0)(typescript@5.0.4) '@typescript-eslint/parser': specifier: 5.61.0 version: 5.61.0(eslint@8.57.0)(typescript@5.0.4) @@ -1238,19 +1238,19 @@ importers: version: 8.3.0(eslint@8.57.0) eslint-plugin-import: specifier: 2.27.5 - version: 2.27.5(@typescript-eslint/parser@5.61.0(eslint@8.57.0)(typescript@5.0.4))(eslint@8.57.0) + version: 2.27.5(@typescript-eslint/parser@5.61.0)(eslint@8.57.0) eslint-plugin-mocha: specifier: 10.4.1 version: 10.4.1(eslint@8.57.0) eslint-plugin-prettier: specifier: 3.4.0 - version: 3.4.0(eslint-config-prettier@8.3.0(eslint@8.57.0))(eslint@8.57.0)(prettier@2.4.1) + version: 3.4.0(eslint-config-prettier@8.3.0)(eslint@8.57.0)(prettier@2.4.1) hardhat: specifier: workspace:^2.11.0 version: link:../hardhat-core hardhat-gas-reporter: specifier: ^1.0.8 - version: 1.0.10(bufferutil@4.0.8)(hardhat@packages+hardhat-core)(utf-8-validate@5.0.10) + version: 1.0.10(hardhat@packages+hardhat-core) mocha: specifier: ^10.0.0 version: 10.4.0 @@ -1271,7 +1271,7 @@ importers: version: 5.0.4 viem: specifier: ^2.7.6 - version: 2.10.3(bufferutil@4.0.8)(typescript@5.0.4)(utf-8-validate@5.0.10)(zod@3.23.8) + version: 2.10.3(typescript@5.0.4) packages/hardhat-truffle4: dependencies: @@ -1314,7 +1314,7 @@ importers: version: 18.19.33 '@typescript-eslint/eslint-plugin': specifier: 5.61.0 - version: 5.61.0(@typescript-eslint/parser@5.61.0(eslint@8.57.0)(typescript@5.0.4))(eslint@8.57.0)(typescript@5.0.4) + version: 5.61.0(@typescript-eslint/parser@5.61.0)(eslint@8.57.0)(typescript@5.0.4) '@typescript-eslint/parser': specifier: 5.61.0 version: 5.61.0(eslint@8.57.0)(typescript@5.0.4) @@ -1326,13 +1326,13 @@ importers: version: 8.3.0(eslint@8.57.0) eslint-plugin-import: specifier: 2.27.5 - version: 2.27.5(@typescript-eslint/parser@5.61.0(eslint@8.57.0)(typescript@5.0.4))(eslint@8.57.0) + version: 2.27.5(@typescript-eslint/parser@5.61.0)(eslint@8.57.0) eslint-plugin-mocha: specifier: 10.4.1 version: 10.4.1(eslint@8.57.0) eslint-plugin-prettier: specifier: 3.4.0 - version: 3.4.0(eslint-config-prettier@8.3.0(eslint@8.57.0))(eslint@8.57.0)(prettier@2.4.1) + version: 3.4.0(eslint-config-prettier@8.3.0)(eslint@8.57.0)(prettier@2.4.1) hardhat: specifier: workspace:^2.6.4 version: link:../hardhat-core @@ -1359,7 +1359,7 @@ importers: dependencies: '@nomiclabs/truffle-contract': specifier: ^4.2.23 - version: 4.5.10(bufferutil@4.0.8)(utf-8-validate@5.0.10)(web3-core-helpers@1.10.4)(web3-core-promievent@1.10.4)(web3-eth-abi@4.2.1(typescript@5.0.4)(zod@3.23.8))(web3-utils@4.2.3)(web3@1.10.4(bufferutil@4.0.8)(utf-8-validate@5.0.10)) + version: 4.5.10(web3-core-helpers@1.10.3)(web3-core-promievent@1.10.3)(web3-eth-abi@1.10.4)(web3-utils@1.10.4)(web3@1.10.4) '@types/chai': specifier: ^4.2.0 version: 4.3.16 @@ -1396,7 +1396,7 @@ importers: version: 18.19.33 '@typescript-eslint/eslint-plugin': specifier: 5.61.0 - version: 5.61.0(@typescript-eslint/parser@5.61.0(eslint@8.57.0)(typescript@5.0.4))(eslint@8.57.0)(typescript@5.0.4) + version: 5.61.0(@typescript-eslint/parser@5.61.0)(eslint@8.57.0)(typescript@5.0.4) '@typescript-eslint/parser': specifier: 5.61.0 version: 5.61.0(eslint@8.57.0)(typescript@5.0.4) @@ -1408,13 +1408,13 @@ importers: version: 8.3.0(eslint@8.57.0) eslint-plugin-import: specifier: 2.27.5 - version: 2.27.5(@typescript-eslint/parser@5.61.0(eslint@8.57.0)(typescript@5.0.4))(eslint@8.57.0) + version: 2.27.5(@typescript-eslint/parser@5.61.0)(eslint@8.57.0) eslint-plugin-mocha: specifier: 10.4.1 version: 10.4.1(eslint@8.57.0) eslint-plugin-prettier: specifier: 3.4.0 - version: 3.4.0(eslint-config-prettier@8.3.0(eslint@8.57.0))(eslint@8.57.0)(prettier@2.4.1) + version: 3.4.0(eslint-config-prettier@8.3.0)(eslint@8.57.0)(prettier@2.4.1) hardhat: specifier: workspace:^2.6.4 version: link:../hardhat-core @@ -1435,7 +1435,7 @@ importers: version: 5.0.4 web3: specifier: ^1.0.0-beta.36 - version: 1.10.4(bufferutil@4.0.8)(utf-8-validate@5.0.10) + version: 1.10.4 packages/hardhat-verify: dependencies: @@ -1505,7 +1505,7 @@ importers: version: 3.2.12 '@typescript-eslint/eslint-plugin': specifier: 5.61.0 - version: 5.61.0(@typescript-eslint/parser@5.61.0(eslint@8.57.0)(typescript@5.0.4))(eslint@8.57.0)(typescript@5.0.4) + version: 5.61.0(@typescript-eslint/parser@5.61.0)(eslint@8.57.0)(typescript@5.0.4) '@typescript-eslint/parser': specifier: 5.61.0 version: 5.61.0(eslint@8.57.0)(typescript@5.0.4) @@ -1523,16 +1523,16 @@ importers: version: 8.3.0(eslint@8.57.0) eslint-plugin-import: specifier: 2.27.5 - version: 2.27.5(@typescript-eslint/parser@5.61.0(eslint@8.57.0)(typescript@5.0.4))(eslint@8.57.0) + version: 2.27.5(@typescript-eslint/parser@5.61.0)(eslint@8.57.0) eslint-plugin-mocha: specifier: 10.4.1 version: 10.4.1(eslint@8.57.0) eslint-plugin-prettier: specifier: 3.4.0 - version: 3.4.0(eslint-config-prettier@8.3.0(eslint@8.57.0))(eslint@8.57.0)(prettier@2.4.1) + version: 3.4.0(eslint-config-prettier@8.3.0)(eslint@8.57.0)(prettier@2.4.1) ethers: specifier: ^5.0.0 - version: 5.7.2(bufferutil@4.0.8)(utf-8-validate@5.0.10) + version: 5.7.2 hardhat: specifier: workspace:^2.0.4 version: link:../hardhat-core @@ -1565,7 +1565,7 @@ importers: dependencies: abitype: specifier: ^0.9.8 - version: 0.9.10(typescript@5.0.4)(zod@3.23.8) + version: 0.9.10(typescript@5.0.4) lodash.memoize: specifier: ^4.1.2 version: 4.1.2 @@ -1599,7 +1599,7 @@ importers: version: 9.0.11 '@typescript-eslint/eslint-plugin': specifier: 5.61.0 - version: 5.61.0(@typescript-eslint/parser@5.61.0(eslint@8.57.0)(typescript@5.0.4))(eslint@8.57.0)(typescript@5.0.4) + version: 5.61.0(@typescript-eslint/parser@5.61.0)(eslint@8.57.0)(typescript@5.0.4) '@typescript-eslint/parser': specifier: 5.61.0 version: 5.61.0(eslint@8.57.0)(typescript@5.0.4) @@ -1617,13 +1617,13 @@ importers: version: 8.3.0(eslint@8.57.0) eslint-plugin-import: specifier: 2.27.5 - version: 2.27.5(@typescript-eslint/parser@5.61.0(eslint@8.57.0)(typescript@5.0.4))(eslint@8.57.0) + version: 2.27.5(@typescript-eslint/parser@5.61.0)(eslint@8.57.0) eslint-plugin-mocha: specifier: 10.4.1 version: 10.4.1(eslint@8.57.0) eslint-plugin-prettier: specifier: 3.4.0 - version: 3.4.0(eslint-config-prettier@8.3.0(eslint@8.57.0))(eslint@8.57.0)(prettier@2.4.1) + version: 3.4.0(eslint-config-prettier@8.3.0)(eslint@8.57.0)(prettier@2.4.1) hardhat: specifier: workspace:^2.17.0 version: link:../hardhat-core @@ -1653,7 +1653,7 @@ importers: version: 5.0.4 viem: specifier: ^2.7.6 - version: 2.10.3(bufferutil@4.0.8)(typescript@5.0.4)(utf-8-validate@5.0.10)(zod@3.23.8) + version: 2.10.3(typescript@5.0.4) packages/hardhat-vyper: dependencies: @@ -1705,7 +1705,7 @@ importers: version: 6.2.7 '@typescript-eslint/eslint-plugin': specifier: 5.61.0 - version: 5.61.0(@typescript-eslint/parser@5.61.0(eslint@8.57.0)(typescript@5.0.4))(eslint@8.57.0)(typescript@5.0.4) + version: 5.61.0(@typescript-eslint/parser@5.61.0)(eslint@8.57.0)(typescript@5.0.4) '@typescript-eslint/parser': specifier: 5.61.0 version: 5.61.0(eslint@8.57.0)(typescript@5.0.4) @@ -1723,13 +1723,13 @@ importers: version: 8.3.0(eslint@8.57.0) eslint-plugin-import: specifier: 2.27.5 - version: 2.27.5(@typescript-eslint/parser@5.61.0(eslint@8.57.0)(typescript@5.0.4))(eslint@8.57.0) + version: 2.27.5(@typescript-eslint/parser@5.61.0)(eslint@8.57.0) eslint-plugin-mocha: specifier: 10.4.1 version: 10.4.1(eslint@8.57.0) eslint-plugin-prettier: specifier: 3.4.0 - version: 3.4.0(eslint-config-prettier@8.3.0(eslint@8.57.0))(eslint@8.57.0)(prettier@2.4.1) + version: 3.4.0(eslint-config-prettier@8.3.0)(eslint@8.57.0)(prettier@2.4.1) hardhat: specifier: workspace:^2.8.3 version: link:../hardhat-core @@ -1772,7 +1772,7 @@ importers: version: 18.19.33 '@typescript-eslint/eslint-plugin': specifier: 5.61.0 - version: 5.61.0(@typescript-eslint/parser@5.61.0(eslint@8.57.0)(typescript@5.0.4))(eslint@8.57.0)(typescript@5.0.4) + version: 5.61.0(@typescript-eslint/parser@5.61.0)(eslint@8.57.0)(typescript@5.0.4) '@typescript-eslint/parser': specifier: 5.61.0 version: 5.61.0(eslint@8.57.0)(typescript@5.0.4) @@ -1787,13 +1787,13 @@ importers: version: 8.3.0(eslint@8.57.0) eslint-plugin-import: specifier: 2.27.5 - version: 2.27.5(@typescript-eslint/parser@5.61.0(eslint@8.57.0)(typescript@5.0.4))(eslint@8.57.0) + version: 2.27.5(@typescript-eslint/parser@5.61.0)(eslint@8.57.0) eslint-plugin-mocha: specifier: 10.4.1 version: 10.4.1(eslint@8.57.0) eslint-plugin-prettier: specifier: 3.4.0 - version: 3.4.0(eslint-config-prettier@8.3.0(eslint@8.57.0))(eslint@8.57.0)(prettier@2.4.1) + version: 3.4.0(eslint-config-prettier@8.3.0)(eslint@8.57.0)(prettier@2.4.1) hardhat: specifier: workspace:^2.0.0 version: link:../hardhat-core @@ -1817,7 +1817,7 @@ importers: version: 5.0.4 web3: specifier: ^1.0.0-beta.36 - version: 1.10.4(bufferutil@4.0.8)(utf-8-validate@5.0.10) + version: 1.10.4 packages/hardhat-web3-legacy: devDependencies: @@ -1838,7 +1838,7 @@ importers: version: 18.19.33 '@typescript-eslint/eslint-plugin': specifier: 5.61.0 - version: 5.61.0(@typescript-eslint/parser@5.61.0(eslint@8.57.0)(typescript@5.0.4))(eslint@8.57.0)(typescript@5.0.4) + version: 5.61.0(@typescript-eslint/parser@5.61.0)(eslint@8.57.0)(typescript@5.0.4) '@typescript-eslint/parser': specifier: 5.61.0 version: 5.61.0(eslint@8.57.0)(typescript@5.0.4) @@ -1853,13 +1853,13 @@ importers: version: 8.3.0(eslint@8.57.0) eslint-plugin-import: specifier: 2.27.5 - version: 2.27.5(@typescript-eslint/parser@5.61.0(eslint@8.57.0)(typescript@5.0.4))(eslint@8.57.0) + version: 2.27.5(@typescript-eslint/parser@5.61.0)(eslint@8.57.0) eslint-plugin-mocha: specifier: 10.4.1 version: 10.4.1(eslint@8.57.0) eslint-plugin-prettier: specifier: 3.4.0 - version: 3.4.0(eslint-config-prettier@8.3.0(eslint@8.57.0))(eslint@8.57.0)(prettier@2.4.1) + version: 3.4.0(eslint-config-prettier@8.3.0)(eslint@8.57.0)(prettier@2.4.1) hardhat: specifier: workspace:^2.0.0 version: link:../hardhat-core @@ -1904,7 +1904,7 @@ importers: version: 18.19.33 '@typescript-eslint/eslint-plugin': specifier: 5.61.0 - version: 5.61.0(@typescript-eslint/parser@5.61.0(eslint@8.57.0)(typescript@5.0.4))(eslint@8.57.0)(typescript@5.0.4) + version: 5.61.0(@typescript-eslint/parser@5.61.0)(eslint@8.57.0)(typescript@5.0.4) '@typescript-eslint/parser': specifier: 5.61.0 version: 5.61.0(eslint@8.57.0)(typescript@5.0.4) @@ -1922,13 +1922,13 @@ importers: version: 8.3.0(eslint@8.57.0) eslint-plugin-import: specifier: 2.27.5 - version: 2.27.5(@typescript-eslint/parser@5.61.0(eslint@8.57.0)(typescript@5.0.4))(eslint@8.57.0) + version: 2.27.5(@typescript-eslint/parser@5.61.0)(eslint@8.57.0) eslint-plugin-mocha: specifier: 10.4.1 version: 10.4.1(eslint@8.57.0) eslint-plugin-prettier: specifier: 3.4.0 - version: 3.4.0(eslint-config-prettier@8.3.0(eslint@8.57.0))(eslint@8.57.0)(prettier@2.4.1) + version: 3.4.0(eslint-config-prettier@8.3.0)(eslint@8.57.0)(prettier@2.4.1) hardhat: specifier: workspace:^2.0.0 version: link:../hardhat-core @@ -1949,5780 +1949,528 @@ importers: version: 5.0.4 web3: specifier: ^4.0.1 - version: 4.8.0(bufferutil@4.0.8)(typescript@5.0.4)(utf-8-validate@5.0.10)(zod@3.23.8) + version: 4.8.0(typescript@5.0.4) packages: - '@adraffy/ens-normalize@1.10.0': + /@adraffy/ens-normalize@1.10.0: resolution: {integrity: sha512-nA9XHtlAkYfJxY7bce8DcN7eKxWWCWkU+1GR9d+U6MbNpfwQp8TI7vqOsBsMcHoT4mBu2kypKoSKnghEzOOq5Q==} + dev: true - '@adraffy/ens-normalize@1.10.1': + /@adraffy/ens-normalize@1.10.1: resolution: {integrity: sha512-96Z2IP3mYmF1Xg2cDm8f1gWGf/HUVedQ3FMifV4kG/PQ4yEP51xDtRAEfhVNt5f/uzpNkZHwWQuUcu6D6K+Ekw==} - '@ampproject/remapping@2.3.0': + /@ampproject/remapping@2.3.0: resolution: {integrity: sha512-30iZtAPgz+LTIYoeivqYo853f02jBYSd5uGnGpkFV0M3xOt9aN73erkgYAmZU43x4VfqcnLxW9Kpg3R5LC4YYw==} engines: {node: '>=6.0.0'} + dependencies: + '@jridgewell/gen-mapping': 0.3.5 + '@jridgewell/trace-mapping': 0.3.25 + dev: true - '@babel/code-frame@7.24.2': + /@babel/code-frame@7.24.2: resolution: {integrity: sha512-y5+tLQyV8pg3fsiln67BVLD1P13Eg4lh5RW9mF0zUuvLrv9uIQ4MCL+CRT+FTsBlBjcIan6PGsLcBN0m3ClUyQ==} engines: {node: '>=6.9.0'} + dependencies: + '@babel/highlight': 7.24.5 + picocolors: 1.0.0 - '@babel/compat-data@7.24.4': + /@babel/compat-data@7.24.4: resolution: {integrity: sha512-vg8Gih2MLK+kOkHJp4gBEIkyaIi00jgWot2D9QOmmfLC8jINSOzmCLta6Bvz/JSBCqnegV0L80jhxkol5GWNfQ==} engines: {node: '>=6.9.0'} + dev: true - '@babel/core@7.24.5': + /@babel/core@7.24.5: resolution: {integrity: sha512-tVQRucExLQ02Boi4vdPp49svNGcfL2GhdTCT9aldhXgCJVAI21EtRfBettiuLUwce/7r6bFdgs6JFkcdTiFttA==} engines: {node: '>=6.9.0'} + dependencies: + '@ampproject/remapping': 2.3.0 + '@babel/code-frame': 7.24.2 + '@babel/generator': 7.24.5 + '@babel/helper-compilation-targets': 7.23.6 + '@babel/helper-module-transforms': 7.24.5(@babel/core@7.24.5) + '@babel/helpers': 7.24.5 + '@babel/parser': 7.24.5 + '@babel/template': 7.24.0 + '@babel/traverse': 7.24.5 + '@babel/types': 7.24.5 + convert-source-map: 2.0.0 + debug: 4.3.4(supports-color@8.1.1) + gensync: 1.0.0-beta.2 + json5: 2.2.3 + semver: 6.3.1 + transitivePeerDependencies: + - supports-color + dev: true - '@babel/generator@7.24.5': + /@babel/generator@7.24.5: resolution: {integrity: sha512-x32i4hEXvr+iI0NEoEfDKzlemF8AmtOP8CcrRaEcpzysWuoEb1KknpcvMsHKPONoKZiDuItklgWhB18xEhr9PA==} engines: {node: '>=6.9.0'} + dependencies: + '@babel/types': 7.24.5 + '@jridgewell/gen-mapping': 0.3.5 + '@jridgewell/trace-mapping': 0.3.25 + jsesc: 2.5.2 + dev: true - '@babel/helper-compilation-targets@7.23.6': + /@babel/helper-compilation-targets@7.23.6: resolution: {integrity: sha512-9JB548GZoQVmzrFgp8o7KxdgkTGm6xs9DW0o/Pim72UDjzr5ObUQ6ZzYPqA+g9OTS2bBQoctLJrky0RDCAWRgQ==} engines: {node: '>=6.9.0'} + dependencies: + '@babel/compat-data': 7.24.4 + '@babel/helper-validator-option': 7.23.5 + browserslist: 4.23.0 + lru-cache: 5.1.1 + semver: 6.3.1 + dev: true - '@babel/helper-environment-visitor@7.22.20': + /@babel/helper-environment-visitor@7.22.20: resolution: {integrity: sha512-zfedSIzFhat/gFhWfHtgWvlec0nqB9YEIVrpuwjruLlXfUSnA8cJB0miHKwqDnQ7d32aKo2xt88/xZptwxbfhA==} engines: {node: '>=6.9.0'} + dev: true - '@babel/helper-function-name@7.23.0': + /@babel/helper-function-name@7.23.0: resolution: {integrity: sha512-OErEqsrxjZTJciZ4Oo+eoZqeW9UIiOcuYKRJA4ZAgV9myA+pOXhhmpfNCKjEH/auVfEYVFJ6y1Tc4r0eIApqiw==} engines: {node: '>=6.9.0'} + dependencies: + '@babel/template': 7.24.0 + '@babel/types': 7.24.5 + dev: true - '@babel/helper-hoist-variables@7.22.5': + /@babel/helper-hoist-variables@7.22.5: resolution: {integrity: sha512-wGjk9QZVzvknA6yKIUURb8zY3grXCcOZt+/7Wcy8O2uctxhplmUPkOdlgoNhmdVee2c92JXbf1xpMtVNbfoxRw==} engines: {node: '>=6.9.0'} + dependencies: + '@babel/types': 7.24.5 + dev: true - '@babel/helper-module-imports@7.24.3': + /@babel/helper-module-imports@7.24.3: resolution: {integrity: sha512-viKb0F9f2s0BCS22QSF308z/+1YWKV/76mwt61NBzS5izMzDPwdq1pTrzf+Li3npBWX9KdQbkeCt1jSAM7lZqg==} engines: {node: '>=6.9.0'} + dependencies: + '@babel/types': 7.24.5 + dev: true - '@babel/helper-module-transforms@7.24.5': + /@babel/helper-module-transforms@7.24.5(@babel/core@7.24.5): resolution: {integrity: sha512-9GxeY8c2d2mdQUP1Dye0ks3VDyIMS98kt/llQ2nUId8IsWqTF0l1LkSX0/uP7l7MCDrzXS009Hyhe2gzTiGW8A==} engines: {node: '>=6.9.0'} peerDependencies: '@babel/core': ^7.0.0 + dependencies: + '@babel/core': 7.24.5 + '@babel/helper-environment-visitor': 7.22.20 + '@babel/helper-module-imports': 7.24.3 + '@babel/helper-simple-access': 7.24.5 + '@babel/helper-split-export-declaration': 7.24.5 + '@babel/helper-validator-identifier': 7.24.5 + dev: true - '@babel/helper-simple-access@7.24.5': + /@babel/helper-simple-access@7.24.5: resolution: {integrity: sha512-uH3Hmf5q5n7n8mz7arjUlDOCbttY/DW4DYhE6FUsjKJ/oYC1kQQUvwEQWxRwUpX9qQKRXeqLwWxrqilMrf32sQ==} engines: {node: '>=6.9.0'} + dependencies: + '@babel/types': 7.24.5 + dev: true - '@babel/helper-split-export-declaration@7.24.5': + /@babel/helper-split-export-declaration@7.24.5: resolution: {integrity: sha512-5CHncttXohrHk8GWOFCcCl4oRD9fKosWlIRgWm4ql9VYioKm52Mk2xsmoohvm7f3JoiLSM5ZgJuRaf5QZZYd3Q==} engines: {node: '>=6.9.0'} + dependencies: + '@babel/types': 7.24.5 + dev: true - '@babel/helper-string-parser@7.24.1': + /@babel/helper-string-parser@7.24.1: resolution: {integrity: sha512-2ofRCjnnA9y+wk8b9IAREroeUP02KHp431N2mhKniy2yKIDKpbrHv9eXwm8cBeWQYcJmzv5qKCu65P47eCF7CQ==} engines: {node: '>=6.9.0'} + dev: true - '@babel/helper-validator-identifier@7.24.5': + /@babel/helper-validator-identifier@7.24.5: resolution: {integrity: sha512-3q93SSKX2TWCG30M2G2kwaKeTYgEUp5Snjuj8qm729SObL6nbtUldAi37qbxkD5gg3xnBio+f9nqpSepGZMvxA==} engines: {node: '>=6.9.0'} - '@babel/helper-validator-option@7.23.5': + /@babel/helper-validator-option@7.23.5: resolution: {integrity: sha512-85ttAOMLsr53VgXkTbkx8oA6YTfT4q7/HzXSLEYmjcSTJPMPQtvq1BD79Byep5xMUYbGRzEpDsjUf3dyp54IKw==} engines: {node: '>=6.9.0'} + dev: true - '@babel/helpers@7.24.5': + /@babel/helpers@7.24.5: resolution: {integrity: sha512-CiQmBMMpMQHwM5m01YnrM6imUG1ebgYJ+fAIW4FZe6m4qHTPaRHti+R8cggAwkdz4oXhtO4/K9JWlh+8hIfR2Q==} engines: {node: '>=6.9.0'} + dependencies: + '@babel/template': 7.24.0 + '@babel/traverse': 7.24.5 + '@babel/types': 7.24.5 + transitivePeerDependencies: + - supports-color + dev: true - '@babel/highlight@7.24.5': + /@babel/highlight@7.24.5: resolution: {integrity: sha512-8lLmua6AVh/8SLJRRVD6V8p73Hir9w5mJrhE+IPpILG31KKlI9iz5zmBYKcWPS59qSfgP9RaSBQSHHE81WKuEw==} engines: {node: '>=6.9.0'} + dependencies: + '@babel/helper-validator-identifier': 7.24.5 + chalk: 2.4.2 + js-tokens: 4.0.0 + picocolors: 1.0.0 - '@babel/parser@7.24.5': + /@babel/parser@7.24.5: resolution: {integrity: sha512-EOv5IK8arwh3LI47dz1b0tKUb/1uhHAnHJOrjgtQMIpu1uXd9mlFrJg9IUgGUgZ41Ch0K8REPTYpO7B76b4vJg==} engines: {node: '>=6.0.0'} hasBin: true + dependencies: + '@babel/types': 7.24.5 + dev: true - '@babel/runtime@7.24.5': + /@babel/runtime@7.24.5: resolution: {integrity: sha512-Nms86NXrsaeU9vbBJKni6gXiEXZ4CVpYVzEjDH9Sb8vmZ3UljyA1GSOJl/6LGPO8EHLuSF9H+IxNXHPX8QHJ4g==} engines: {node: '>=6.9.0'} + dependencies: + regenerator-runtime: 0.14.1 - '@babel/template@7.24.0': + /@babel/template@7.24.0: resolution: {integrity: sha512-Bkf2q8lMB0AFpX0NFEqSbx1OkTHf0f+0j82mkw+ZpzBnkk7e9Ql0891vlfgi+kHwOk8tQjiQHpqh4LaSa0fKEA==} engines: {node: '>=6.9.0'} + dependencies: + '@babel/code-frame': 7.24.2 + '@babel/parser': 7.24.5 + '@babel/types': 7.24.5 + dev: true - '@babel/traverse@7.24.5': + /@babel/traverse@7.24.5: resolution: {integrity: sha512-7aaBLeDQ4zYcUFDUD41lJc1fG8+5IU9DaNSJAgal866FGvmD5EbWQgnEC6kO1gGLsX0esNkfnJSndbTXA3r7UA==} engines: {node: '>=6.9.0'} + dependencies: + '@babel/code-frame': 7.24.2 + '@babel/generator': 7.24.5 + '@babel/helper-environment-visitor': 7.22.20 + '@babel/helper-function-name': 7.23.0 + '@babel/helper-hoist-variables': 7.22.5 + '@babel/helper-split-export-declaration': 7.24.5 + '@babel/parser': 7.24.5 + '@babel/types': 7.24.5 + debug: 4.3.4(supports-color@8.1.1) + globals: 11.12.0 + transitivePeerDependencies: + - supports-color + dev: true - '@babel/types@7.24.5': + /@babel/types@7.24.5: resolution: {integrity: sha512-6mQNsaLeXTw0nxYUYu+NSa4Hx4BlF1x1x8/PMFbiR+GBSr+2DkECc69b8hgy2frEodNcvPffeH8YfWd3LI6jhQ==} engines: {node: '>=6.9.0'} + dependencies: + '@babel/helper-string-parser': 7.24.1 + '@babel/helper-validator-identifier': 7.24.5 + to-fast-properties: 2.0.0 + dev: true - '@changesets/apply-release-plan@7.0.0': + /@changesets/apply-release-plan@7.0.0: resolution: {integrity: sha512-vfi69JR416qC9hWmFGSxj7N6wA5J222XNBmezSVATPWDVPIF7gkd4d8CpbEbXmRWbVrkoli3oerGS6dcL/BGsQ==} + dependencies: + '@babel/runtime': 7.24.5 + '@changesets/config': 3.0.0 + '@changesets/get-version-range-type': 0.4.0 + '@changesets/git': 3.0.0 + '@changesets/types': 6.0.0 + '@manypkg/get-packages': 1.1.3 + detect-indent: 6.1.0 + fs-extra: 7.0.1 + lodash.startcase: 4.4.0 + outdent: 0.5.0 + prettier: 2.8.8 + resolve-from: 5.0.0 + semver: 7.6.2 + dev: true - '@changesets/assemble-release-plan@6.0.0': + /@changesets/assemble-release-plan@6.0.0: resolution: {integrity: sha512-4QG7NuisAjisbW4hkLCmGW2lRYdPrKzro+fCtZaILX+3zdUELSvYjpL4GTv0E4aM9Mef3PuIQp89VmHJ4y2bfw==} + dependencies: + '@babel/runtime': 7.24.5 + '@changesets/errors': 0.2.0 + '@changesets/get-dependents-graph': 2.0.0 + '@changesets/types': 6.0.0 + '@manypkg/get-packages': 1.1.3 + semver: 7.6.2 + dev: true - '@changesets/changelog-git@0.2.0': + /@changesets/changelog-git@0.2.0: resolution: {integrity: sha512-bHOx97iFI4OClIT35Lok3sJAwM31VbUM++gnMBV16fdbtBhgYu4dxsphBF/0AZZsyAHMrnM0yFcj5gZM1py6uQ==} + dependencies: + '@changesets/types': 6.0.0 + dev: true - '@changesets/cli@2.27.1': + /@changesets/cli@2.27.1: resolution: {integrity: sha512-iJ91xlvRnnrJnELTp4eJJEOPjgpF3NOh4qeQehM6Ugiz9gJPRZ2t+TsXun6E3AMN4hScZKjqVXl0TX+C7AB3ZQ==} hasBin: true + dependencies: + '@babel/runtime': 7.24.5 + '@changesets/apply-release-plan': 7.0.0 + '@changesets/assemble-release-plan': 6.0.0 + '@changesets/changelog-git': 0.2.0 + '@changesets/config': 3.0.0 + '@changesets/errors': 0.2.0 + '@changesets/get-dependents-graph': 2.0.0 + '@changesets/get-release-plan': 4.0.0 + '@changesets/git': 3.0.0 + '@changesets/logger': 0.1.0 + '@changesets/pre': 2.0.0 + '@changesets/read': 0.6.0 + '@changesets/types': 6.0.0 + '@changesets/write': 0.3.0 + '@manypkg/get-packages': 1.1.3 + '@types/semver': 7.5.8 + ansi-colors: 4.1.3 + chalk: 2.4.2 + ci-info: 3.9.0 + enquirer: 2.4.1 + external-editor: 3.1.0 + fs-extra: 7.0.1 + human-id: 1.0.2 + meow: 6.1.1 + outdent: 0.5.0 + p-limit: 2.3.0 + preferred-pm: 3.1.3 + resolve-from: 5.0.0 + semver: 7.6.2 + spawndamnit: 2.0.0 + term-size: 2.2.1 + tty-table: 4.2.3 + dev: true - '@changesets/config@3.0.0': + /@changesets/config@3.0.0: resolution: {integrity: sha512-o/rwLNnAo/+j9Yvw9mkBQOZySDYyOr/q+wptRLcAVGlU6djOeP9v1nlalbL9MFsobuBVQbZCTp+dIzdq+CLQUA==} + dependencies: + '@changesets/errors': 0.2.0 + '@changesets/get-dependents-graph': 2.0.0 + '@changesets/logger': 0.1.0 + '@changesets/types': 6.0.0 + '@manypkg/get-packages': 1.1.3 + fs-extra: 7.0.1 + micromatch: 4.0.5 + dev: true - '@changesets/errors@0.2.0': + /@changesets/errors@0.2.0: resolution: {integrity: sha512-6BLOQUscTpZeGljvyQXlWOItQyU71kCdGz7Pi8H8zdw6BI0g3m43iL4xKUVPWtG+qrrL9DTjpdn8eYuCQSRpow==} + dependencies: + extendable-error: 0.1.7 + dev: true - '@changesets/get-dependents-graph@2.0.0': + /@changesets/get-dependents-graph@2.0.0: resolution: {integrity: sha512-cafUXponivK4vBgZ3yLu944mTvam06XEn2IZGjjKc0antpenkYANXiiE6GExV/yKdsCnE8dXVZ25yGqLYZmScA==} + dependencies: + '@changesets/types': 6.0.0 + '@manypkg/get-packages': 1.1.3 + chalk: 2.4.2 + fs-extra: 7.0.1 + semver: 7.6.2 + dev: true - '@changesets/get-release-plan@4.0.0': + /@changesets/get-release-plan@4.0.0: resolution: {integrity: sha512-9L9xCUeD/Tb6L/oKmpm8nyzsOzhdNBBbt/ZNcjynbHC07WW4E1eX8NMGC5g5SbM5z/V+MOrYsJ4lRW41GCbg3w==} + dependencies: + '@babel/runtime': 7.24.5 + '@changesets/assemble-release-plan': 6.0.0 + '@changesets/config': 3.0.0 + '@changesets/pre': 2.0.0 + '@changesets/read': 0.6.0 + '@changesets/types': 6.0.0 + '@manypkg/get-packages': 1.1.3 + dev: true - '@changesets/get-version-range-type@0.4.0': + /@changesets/get-version-range-type@0.4.0: resolution: {integrity: sha512-hwawtob9DryoGTpixy1D3ZXbGgJu1Rhr+ySH2PvTLHvkZuQ7sRT4oQwMh0hbqZH1weAooedEjRsbrWcGLCeyVQ==} + dev: true - '@changesets/git@3.0.0': + /@changesets/git@3.0.0: resolution: {integrity: sha512-vvhnZDHe2eiBNRFHEgMiGd2CT+164dfYyrJDhwwxTVD/OW0FUD6G7+4DIx1dNwkwjHyzisxGAU96q0sVNBns0w==} + dependencies: + '@babel/runtime': 7.24.5 + '@changesets/errors': 0.2.0 + '@changesets/types': 6.0.0 + '@manypkg/get-packages': 1.1.3 + is-subdir: 1.2.0 + micromatch: 4.0.5 + spawndamnit: 2.0.0 + dev: true - '@changesets/logger@0.1.0': + /@changesets/logger@0.1.0: resolution: {integrity: sha512-pBrJm4CQm9VqFVwWnSqKEfsS2ESnwqwH+xR7jETxIErZcfd1u2zBSqrHbRHR7xjhSgep9x2PSKFKY//FAshA3g==} + dependencies: + chalk: 2.4.2 + dev: true - '@changesets/parse@0.4.0': + /@changesets/parse@0.4.0: resolution: {integrity: sha512-TS/9KG2CdGXS27S+QxbZXgr8uPsP4yNJYb4BC2/NeFUj80Rni3TeD2qwWmabymxmrLo7JEsytXH1FbpKTbvivw==} + dependencies: + '@changesets/types': 6.0.0 + js-yaml: 3.14.1 + dev: true - '@changesets/pre@2.0.0': + /@changesets/pre@2.0.0: resolution: {integrity: sha512-HLTNYX/A4jZxc+Sq8D1AMBsv+1qD6rmmJtjsCJa/9MSRybdxh0mjbTvE6JYZQ/ZiQ0mMlDOlGPXTm9KLTU3jyw==} + dependencies: + '@babel/runtime': 7.24.5 + '@changesets/errors': 0.2.0 + '@changesets/types': 6.0.0 + '@manypkg/get-packages': 1.1.3 + fs-extra: 7.0.1 + dev: true - '@changesets/read@0.6.0': + /@changesets/read@0.6.0: resolution: {integrity: sha512-ZypqX8+/im1Fm98K4YcZtmLKgjs1kDQ5zHpc2U1qdtNBmZZfo/IBiG162RoP0CUF05tvp2y4IspH11PLnPxuuw==} + dependencies: + '@babel/runtime': 7.24.5 + '@changesets/git': 3.0.0 + '@changesets/logger': 0.1.0 + '@changesets/parse': 0.4.0 + '@changesets/types': 6.0.0 + chalk: 2.4.2 + fs-extra: 7.0.1 + p-filter: 2.1.0 + dev: true - '@changesets/types@4.1.0': + /@changesets/types@4.1.0: resolution: {integrity: sha512-LDQvVDv5Kb50ny2s25Fhm3d9QSZimsoUGBsUioj6MC3qbMUCuC8GPIvk/M6IvXx3lYhAs0lwWUQLb+VIEUCECw==} + dev: true - '@changesets/types@6.0.0': + /@changesets/types@6.0.0: resolution: {integrity: sha512-b1UkfNulgKoWfqyHtzKS5fOZYSJO+77adgL7DLRDr+/7jhChN+QcHnbjiQVOz/U+Ts3PGNySq7diAItzDgugfQ==} + dev: true - '@changesets/write@0.3.0': + /@changesets/write@0.3.0: resolution: {integrity: sha512-slGLb21fxZVUYbyea+94uFiD6ntQW0M2hIKNznFizDhZPDgn2c/fv1UzzlW43RVzh1BEDuIqW6hzlJ1OflNmcw==} + dependencies: + '@babel/runtime': 7.24.5 + '@changesets/types': 6.0.0 + fs-extra: 7.0.1 + human-id: 1.0.2 + prettier: 2.8.8 + dev: true - '@cspotcode/source-map-support@0.8.1': + /@cspotcode/source-map-support@0.8.1: resolution: {integrity: sha512-IchNf6dN4tHoMFIn/7OE8LWZ19Y6q/67Bmf6vnGREv8RSbBVb9LPJxEcnwrcwX6ixSvaiGoomAUvu4YSxXrVgw==} engines: {node: '>=12'} + dependencies: + '@jridgewell/trace-mapping': 0.3.9 + dev: true - '@ensdomains/address-encoder@0.1.9': + /@ensdomains/address-encoder@0.1.9: resolution: {integrity: sha512-E2d2gP4uxJQnDu2Kfg1tHNspefzbLT8Tyjrm5sEuim32UkU2sm5xL4VXtgc2X33fmPEw9+jUMpGs4veMbf+PYg==} + dependencies: + bech32: 1.1.4 + blakejs: 1.2.1 + bn.js: 4.12.0 + bs58: 4.0.1 + crypto-addr-codec: 0.1.8 + nano-base32: 1.0.1 + ripemd160: 2.0.2 + dev: false - '@ensdomains/ens@0.4.5': + /@ensdomains/ens@0.4.5: resolution: {integrity: sha512-JSvpj1iNMFjK6K+uVl4unqMoa9rf5jopb8cya5UGBWz23Nw8hSNT7efgUx4BTlAPAgpNlEioUfeTyQ6J9ZvTVw==} deprecated: Please use @ensdomains/ens-contracts + dependencies: + bluebird: 3.7.2 + eth-ens-namehash: 2.0.8 + solc: 0.4.26 + testrpc: 0.0.1 + web3-utils: 1.10.4 + dev: false - '@ensdomains/ensjs@2.1.0': + /@ensdomains/ensjs@2.1.0: resolution: {integrity: sha512-GRbGPT8Z/OJMDuxs75U/jUNEC0tbL0aj7/L/QQznGYKm/tiasp+ndLOaoULy9kKJFC0TBByqfFliEHDgoLhyog==} + dependencies: + '@babel/runtime': 7.24.5 + '@ensdomains/address-encoder': 0.1.9 + '@ensdomains/ens': 0.4.5 + '@ensdomains/resolver': 0.2.4 + content-hash: 2.5.2 + eth-ens-namehash: 2.0.8 + ethers: 5.7.2 + js-sha3: 0.8.0 + transitivePeerDependencies: + - bufferutil + - utf-8-validate + dev: false - '@ensdomains/resolver@0.2.4': + /@ensdomains/resolver@0.2.4: resolution: {integrity: sha512-bvaTH34PMCbv6anRa9I/0zjLJgY4EuznbEMgbV77JBCQ9KNC46rzi0avuxpOfu+xDjPEtSFGqVEOr5GlUSGudA==} deprecated: Please use @ensdomains/ens-contracts + dev: false - '@eslint-community/eslint-utils@4.4.0': + /@eslint-community/eslint-utils@4.4.0(eslint@8.57.0): resolution: {integrity: sha512-1/sA4dwrzBAyeUoQ6oxahHKmrZvsnLCg4RfxW3ZFGGmQkSNQPFNLV9CUEFQP1x9EYXHTo5p6xdhZM1Ne9p/AfA==} engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0} peerDependencies: eslint: ^6.0.0 || ^7.0.0 || >=8.0.0 + dependencies: + eslint: 8.57.0 + eslint-visitor-keys: 3.4.3 - '@eslint-community/regexpp@4.10.0': + /@eslint-community/regexpp@4.10.0: resolution: {integrity: sha512-Cu96Sd2By9mCNTx2iyKOmq10v22jUVQv0lQnlGNy16oE9589yE+QADPbrMGCkA51cKZSg3Pu/aTJVTGfL/qjUA==} engines: {node: ^12.0.0 || ^14.0.0 || >=16.0.0} - '@eslint/eslintrc@2.1.4': + /@eslint/eslintrc@2.1.4: resolution: {integrity: sha512-269Z39MS6wVJtsoUl10L60WdkhJVdPG24Q4eZTH3nnF6lpvSShEK3wQjDX9JRWAUPvPh7COouPpU9IrqaZFvtQ==} engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0} + dependencies: + ajv: 6.12.6 + debug: 4.3.4(supports-color@8.1.1) + espree: 9.6.1 + globals: 13.24.0 + ignore: 5.3.1 + import-fresh: 3.3.0 + js-yaml: 4.1.0 + minimatch: 3.1.2 + strip-json-comments: 3.1.1 + transitivePeerDependencies: + - supports-color - '@eslint/js@8.57.0': + /@eslint/js@8.57.0: resolution: {integrity: sha512-Ys+3g2TaW7gADOJzPt83SJtCDhMjndcDMFVQ/Tj9iA1BfJzFKD9mAUXT3OenpuPHbI6P/myECxRJrofUsDx/5g==} engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0} - '@ethereumjs/common@2.5.0': + /@ethereumjs/common@2.5.0: resolution: {integrity: sha512-DEHjW6e38o+JmB/NO3GZBpW4lpaiBpkFgXF6jLcJ6gETBYpEyaA5nTimsWBUJR3Vmtm/didUEbNjajskugZORg==} + dependencies: + crc-32: 1.2.2 + ethereumjs-util: 7.1.5 + dev: false - '@ethereumjs/common@2.6.5': + /@ethereumjs/common@2.6.5: resolution: {integrity: sha512-lRyVQOeCDaIVtgfbowla32pzeDv2Obr8oR8Put5RdUBNRGr1VGPGQNGP6elWIpgK3YdpzqTOh4GyUGOureVeeA==} - - '@ethereumjs/rlp@4.0.1': - resolution: {integrity: sha512-tqsQiBQDQdmPWE1xkkBq4rlSW5QZpLOUJ5RJh2/9fug+q9tnUhuZoVLk7s0scUIKTOzEtR72DFBXI4WiZcMpvw==} - engines: {node: '>=14'} - hasBin: true - - '@ethereumjs/tx@3.3.2': - resolution: {integrity: sha512-6AaJhwg4ucmwTvw/1qLaZUX5miWrwZ4nLOUsKyb/HtzS3BMw/CasKhdi1ims9mBKeK9sOJCH4qGKOBGyJCeeog==} - - '@ethereumjs/tx@3.5.2': - resolution: {integrity: sha512-gQDNJWKrSDGu2w7w0PzVXVBNMzb7wwdDOmOqczmhNjqFxFuIbhVJDwiGEnxFNC2/b8ifcZzY7MLcluizohRzNw==} - - '@ethereumjs/util@8.1.0': - resolution: {integrity: sha512-zQ0IqbdX8FZ9aw11vP+dZkKDkS+kgIvQPHnSAXzP9pLu+Rfu3D3XEeLbicvoXJTYnhZiPmsZUxgdzXwNKxRPbA==} - engines: {node: '>=14'} - - '@ethersproject/abi@5.7.0': - resolution: {integrity: sha512-351ktp42TiRcYB3H1OP8yajPeAQstMW/yCFokj/AthP9bLHzQFPlOrxOcwYEDkUAICmOHljvN4K39OMTMUa9RA==} - - '@ethersproject/abstract-provider@5.7.0': - resolution: {integrity: sha512-R41c9UkchKCpAqStMYUpdunjo3pkEvZC3FAwZn5S5MGbXoMQOHIdHItezTETxAO5bevtMApSyEhn9+CHcDsWBw==} - - '@ethersproject/abstract-signer@5.7.0': - resolution: {integrity: sha512-a16V8bq1/Cz+TGCkE2OPMTOUDLS3grCpdjoJCYNnVBbdYEMSgKrU0+B90s8b6H+ByYTBZN7a3g76jdIJi7UfKQ==} - - '@ethersproject/address@5.6.1': - resolution: {integrity: sha512-uOgF0kS5MJv9ZvCz7x6T2EXJSzotiybApn4XlOgoTX0xdtyVIJ7pF+6cGPxiEq/dpBiTfMiw7Yc81JcwhSYA0Q==} - - '@ethersproject/address@5.7.0': - resolution: {integrity: sha512-9wYhYt7aghVGo758POM5nqcOMaE168Q6aRLJZwUmiqSrAungkG74gSSeKEIR7ukixesdRZGPgVqme6vmxs1fkA==} - - '@ethersproject/base64@5.7.0': - resolution: {integrity: sha512-Dr8tcHt2mEbsZr/mwTPIQAf3Ai0Bks/7gTw9dSqk1mQvhW3XvRlmDJr/4n+wg1JmCl16NZue17CDh8xb/vZ0sQ==} - - '@ethersproject/basex@5.7.0': - resolution: {integrity: sha512-ywlh43GwZLv2Voc2gQVTKBoVQ1mti3d8HK5aMxsfu/nRDnMmNqaSJ3r3n85HBByT8OpoY96SXM1FogC533T4zw==} - - '@ethersproject/bignumber@5.7.0': - resolution: {integrity: sha512-n1CAdIHRWjSucQO3MC1zPSVgV/6dy/fjL9pMrPP9peL+QxEg9wOsVqwD4+818B6LUEtaXzVHQiuivzRoxPxUGw==} - - '@ethersproject/bytes@5.7.0': - resolution: {integrity: sha512-nsbxwgFXWh9NyYWo+U8atvmMsSdKJprTcICAkvbBffT75qDocbuggBU0SJiVK2MuTrp0q+xvLkTnGMPK1+uA9A==} - - '@ethersproject/constants@5.7.0': - resolution: {integrity: sha512-DHI+y5dBNvkpYUMiRQyxRBYBefZkJfo70VUkUAsRjcPs47muV9evftfZ0PJVCXYbAiCgght0DtcF9srFQmIgWA==} - - '@ethersproject/contracts@5.7.0': - resolution: {integrity: sha512-5GJbzEU3X+d33CdfPhcyS+z8MzsTrBGk/sc+G+59+tPa9yFkl6HQ9D6L0QMgNTA9q8dT0XKxxkyp883XsQvbbg==} - - '@ethersproject/hash@5.7.0': - resolution: {integrity: sha512-qX5WrQfnah1EFnO5zJv1v46a8HW0+E5xuBBDTwMFZLuVTx0tbU2kkx15NqdjxecrLGatQN9FGQKpb1FKdHCt+g==} - - '@ethersproject/hdnode@5.7.0': - resolution: {integrity: sha512-OmyYo9EENBPPf4ERhR7oj6uAtUAhYGqOnIS+jE5pTXvdKBS99ikzq1E7Iv0ZQZ5V36Lqx1qZLeak0Ra16qpeOg==} - - '@ethersproject/json-wallets@5.7.0': - resolution: {integrity: sha512-8oee5Xgu6+RKgJTkvEMl2wDgSPSAQ9MB/3JYjFV9jlKvcYHUXZC+cQp0njgmxdHkYWn8s6/IqIZYm0YWCjO/0g==} - - '@ethersproject/keccak256@5.7.0': - resolution: {integrity: sha512-2UcPboeL/iW+pSg6vZ6ydF8tCnv3Iu/8tUmLLzWWGzxWKFFqOBQFLo6uLUv6BDrLgCDfN28RJ/wtByx+jZ4KBg==} - - '@ethersproject/logger@5.7.0': - resolution: {integrity: sha512-0odtFdXu/XHtjQXJYA3u9G0G8btm0ND5Cu8M7i5vhEcE8/HmF4Lbdqanwyv4uQTr2tx6b7fQRmgLrsnpQlmnig==} - - '@ethersproject/networks@5.7.1': - resolution: {integrity: sha512-n/MufjFYv3yFcUyfhnXotyDlNdFb7onmkSy8aQERi2PjNcnWQ66xXxa3XlS8nCcA8aJKJjIIMNJTC7tu80GwpQ==} - - '@ethersproject/pbkdf2@5.7.0': - resolution: {integrity: sha512-oR/dBRZR6GTyaofd86DehG72hY6NpAjhabkhxgr3X2FpJtJuodEl2auADWBZfhDHgVCbu3/H/Ocq2uC6dpNjjw==} - - '@ethersproject/properties@5.7.0': - resolution: {integrity: sha512-J87jy8suntrAkIZtecpxEPxY//szqr1mlBaYlQ0r4RCaiD2hjheqF9s1LVE8vVuJCXisjIP+JgtK/Do54ej4Sw==} - - '@ethersproject/providers@5.7.2': - resolution: {integrity: sha512-g34EWZ1WWAVgr4aptGlVBF8mhl3VWjv+8hoAnzStu8Ah22VHBsuGzP17eb6xDVRzw895G4W7vvx60lFFur/1Rg==} - - '@ethersproject/random@5.7.0': - resolution: {integrity: sha512-19WjScqRA8IIeWclFme75VMXSBvi4e6InrUNuaR4s5pTF2qNhcGdCUwdxUVGtDDqC00sDLCO93jPQoDUH4HVmQ==} - - '@ethersproject/rlp@5.7.0': - resolution: {integrity: sha512-rBxzX2vK8mVF7b0Tol44t5Tb8gomOHkj5guL+HhzQ1yBh/ydjGnpw6at+X6Iw0Kp3OzzzkcKp8N9r0W4kYSs9w==} - - '@ethersproject/sha2@5.7.0': - resolution: {integrity: sha512-gKlH42riwb3KYp0reLsFTokByAKoJdgFCwI+CCiX/k+Jm2mbNs6oOaCjYQSlI1+XBVejwH2KrmCbMAT/GnRDQw==} - - '@ethersproject/signing-key@5.7.0': - resolution: {integrity: sha512-MZdy2nL3wO0u7gkB4nA/pEf8lu1TlFswPNmy8AiYkfKTdO6eXBJyUdmHO/ehm/htHw9K/qF8ujnTyUAD+Ry54Q==} - - '@ethersproject/solidity@5.7.0': - resolution: {integrity: sha512-HmabMd2Dt/raavyaGukF4XxizWKhKQ24DoLtdNbBmNKUOPqwjsKQSdV9GQtj9CBEea9DlzETlVER1gYeXXBGaA==} - - '@ethersproject/strings@5.7.0': - resolution: {integrity: sha512-/9nu+lj0YswRNSH0NXYqrh8775XNyEdUQAuf3f+SmOrnVewcJ5SBNAjF7lpgehKi4abvNNXyf+HX86czCdJ8Mg==} - - '@ethersproject/transactions@5.7.0': - resolution: {integrity: sha512-kmcNicCp1lp8qanMTC3RIikGgoJ80ztTyvtsFvCYpSCfkjhD0jZ2LOrnbcuxuToLIUYYf+4XwD1rP+B/erDIhQ==} - - '@ethersproject/units@5.7.0': - resolution: {integrity: sha512-pD3xLMy3SJu9kG5xDGI7+xhTEmGXlEqXU4OfNapmfnxLVY4EMSSRp7j1k7eezutBPH7RBN/7QPnwR7hzNlEFeg==} - - '@ethersproject/wallet@5.7.0': - resolution: {integrity: sha512-MhmXlJXEJFBFVKrDLB4ZdDzxcBxQ3rLyCkhNqVu3CDYvR97E+8r01UgrI+TI99Le+aYm/in/0vp86guJuM7FCA==} - - '@ethersproject/web@5.7.1': - resolution: {integrity: sha512-Gueu8lSvyjBWL4cYsWsjh6MtMwM0+H4HvqFPZfB6dV8ctbP9zFAO73VG1cMWae0FLPCtz0peKPpZY8/ugJJX2w==} - - '@ethersproject/wordlists@5.7.0': - resolution: {integrity: sha512-S2TFNJNfHWVHNE6cNDjbVlZ6MgE17MIxMbMg2zv3wn+3XSJGosL1m9ZVv3GXCf/2ymSsQ+hRI5IzoMJTG6aoVA==} - - '@fastify/busboy@2.1.1': - resolution: {integrity: sha512-vBZP4NlzfOlerQTnba4aqZoMhE/a9HY7HRqoOPaETQcSQuWEIyZMHGfVu6w9wGtGK5fED5qRs2DteVCjOH60sA==} - engines: {node: '>=14'} - - '@fvictorio/tabtab@0.0.3': - resolution: {integrity: sha512-bT/BSy8MJThrTebqTCjXRnGSgZWthHLigZ4k2AvfNtC79vPyBS1myaxw8gRU6RxIcdDD3HBtm7pOsOoyC086Zg==} - engines: {node: '>=10'} - - '@humanwhocodes/config-array@0.11.14': - resolution: {integrity: sha512-3T8LkOmg45BV5FICb15QQMsyUSWrQ8AygVfC7ZG32zOalnqrilm018ZVCw0eapXux8FtA33q8PSRSstjee3jSg==} - engines: {node: '>=10.10.0'} - - '@humanwhocodes/module-importer@1.0.1': - resolution: {integrity: sha512-bxveV4V8v5Yb4ncFTT3rPSgZBOpCkjfK0y4oVVVJwIuDVBRMDXrPyXRL988i5ap9m9bnyEEjWfm5WkBmtffLfA==} - engines: {node: '>=12.22'} - - '@humanwhocodes/object-schema@2.0.3': - resolution: {integrity: sha512-93zYdMES/c1D69yZiKDBj0V24vqNzB/koF26KPaagAfd3P/4gUlh3Dys5ogAK+Exi9QyzlD8x/08Zt7wIKcDcA==} - - '@istanbuljs/load-nyc-config@1.1.0': - resolution: {integrity: sha512-VjeHSlIzpv/NyD3N0YuHfXOPDIixcA1q2ZV98wsMqcYlPmv2n3Yb2lYP9XMElnaFVXg5A7YLTeLu6V84uQDjmQ==} - engines: {node: '>=8'} - - '@istanbuljs/schema@0.1.3': - resolution: {integrity: sha512-ZXRY4jNvVgSVQ8DL3LTcakaAtXwTVUxE81hslsyD2AtoXW/wVob10HkOJ1X/pAlcI7D+2YoZKg5do8G/w6RYgA==} - engines: {node: '>=8'} - - '@jest/schemas@29.6.3': - resolution: {integrity: sha512-mo5j5X+jIZmJQveBKeS/clAueipV7KgiX1vMgCxam1RNYiqE1w62n0/tJJnHtjW8ZHcQco5gY85jA3mi0L+nSA==} - engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0} - - '@jridgewell/gen-mapping@0.3.5': - resolution: {integrity: sha512-IzL8ZoEDIBRWEzlCcRhOaCupYyN5gdIK+Q6fbFdPDg6HqX6jpkItn7DFIpW9LQzXG6Df9sA7+OKnq0qlz/GaQg==} - engines: {node: '>=6.0.0'} - - '@jridgewell/resolve-uri@3.1.2': - resolution: {integrity: sha512-bRISgCIjP20/tbWSPWMEi54QVPRZExkuD9lJL+UIxUKtwVJA8wW1Trb1jMs1RFXo1CBTNZ/5hpC9QvmKWdopKw==} - engines: {node: '>=6.0.0'} - - '@jridgewell/set-array@1.2.1': - resolution: {integrity: sha512-R8gLRTZeyp03ymzP/6Lil/28tGeGEzhx1q2k703KGWRAI1VdvPIXdG70VJc2pAMw3NA6JKL5hhFu1sJX0Mnn/A==} - engines: {node: '>=6.0.0'} - - '@jridgewell/sourcemap-codec@1.4.15': - resolution: {integrity: sha512-eF2rxCRulEKXHTRiDrDy6erMYWqNw4LPdQ8UQA4huuxaQsVeRPFl2oM8oDGxMFhJUWZf9McpLtJasDDZb/Bpeg==} - - '@jridgewell/trace-mapping@0.3.25': - resolution: {integrity: sha512-vNk6aEwybGtawWmy/PzwnGDOjCkLWSD2wqvjGGAgOAwCGWySYXfYoxt00IJkTF+8Lb57DwOb3Aa0o9CApepiYQ==} - - '@jridgewell/trace-mapping@0.3.9': - resolution: {integrity: sha512-3Belt6tdc8bPgAtbcmdtNJlirVoTmEb5e2gC94PnkwEW9jI6CAHUeoG85tjWP5WquqfavoMtMwiG4P926ZKKuQ==} - - '@json-schema-spec/json-pointer@0.1.2': - resolution: {integrity: sha512-BYY7IavBjwsWWSmVcMz2A9mKiDD9RvacnsItgmy1xV8cmgbtxFfKmKMtkVpD7pYtkx4mIW4800yZBXueVFIWPw==} - - '@json-schema-tools/dereferencer@1.5.4': - resolution: {integrity: sha512-4cmEdRPIG7WrcSWGRV6HBDCLXEOXGkaOZnopqBxoG24mKYuCHWg4M6N9nioTQyNfKqlPkOPvT4lStQqkPnhLgA==} - - '@json-schema-tools/meta-schema@1.6.19': - resolution: {integrity: sha512-55zuWFW7tr4tf/G5AYmybcPdGOkVAreQbt2JdnogX4I2r/zkxZiimYPJESDf5je9BI2oRveak2p296HzDppeaA==} - - '@json-schema-tools/reference-resolver@1.2.4': - resolution: {integrity: sha512-Oag20zDuapO6nBQp00k8Rd5sDTb8Gfz9uH43Tf7dHKNx7nHDK/WdeTe7OxkOmLQCL6aS+mCJx1Zv+fZBCD+tzQ==} - - '@json-schema-tools/referencer@1.1.3': - resolution: {integrity: sha512-p2JU7GpHn1kMyP7gnB2Wnki+OnifsSi75Uj5PxqIg2pT4fqh+BM3rEEZKpaET4xv0ZszG46CCI9eEvs68v2rXg==} - - '@json-schema-tools/titleizer@1.0.8': - resolution: {integrity: sha512-xgsg7ghVhd+9ZrhpmakNJUMmp+R+1mB6n4zn4iRg6P47GTfN04L/GR7mjC8LvO+XaZxbIzE6EzvHeZ5+nmhjJA==} - - '@json-schema-tools/titleizer@1.0.9': - resolution: {integrity: sha512-Gwg3YTP5P+3Q+OnvEcthTnsup3AsEkxZCrRLXoWppdjtSzRnsWxtvmpKdGLbVcocPC7Sh3aqJ7Arp85Ii6q2GA==} - - '@json-schema-tools/transpiler@1.10.5': - resolution: {integrity: sha512-uRm43U8wKWQV8czvvkJYwcUERpQC+azKmqbd7RhV1gWx7s1t0frLtrWqGbXh9xMcgdtF7+Tkiwex48nW5EnX1w==} - - '@json-schema-tools/traverse@1.10.4': - resolution: {integrity: sha512-9e42zjhLIxzBONroNC4SGsTqdB877tzwH2S6lqgTav9K24kWJR9vNieeMVSuyqnY8FlclH21D8wsm/tuD9WA9Q==} - - '@ledgerhq/cryptoassets@9.13.0': - resolution: {integrity: sha512-MzGJyc48OGU/FLYGYwEJyfOgbJzlR8XJ9Oo6XpNpNUM1/E5NDqvD72V0D+0uWIJYN3e2NtyqHXShLZDu7P95YA==} - - '@ledgerhq/devices@8.3.0': - resolution: {integrity: sha512-h5Scr+yIae8yjPOViCHLdMjpqn4oC2Whrsq8LinRxe48LEGMdPqSV1yY7+3Ch827wtzNpMv+/ilKnd8rY+rTlg==} - - '@ledgerhq/domain-service@1.1.20': - resolution: {integrity: sha512-+o1cEZj9HkJeIz2eL3r52tzkOiEKMs9w5aXF+Gy4mrmBjQ3Tw0OY9b69b3jz6PjlEHwAZsDRmcvF1/hSW6ITjw==} - - '@ledgerhq/errors@6.16.4': - resolution: {integrity: sha512-M57yFaLYSN+fZCX0E0zUqOmrV6eipK+s5RhijHoUNlHUqrsvUz7iRQgpd5gRgHB5VkIjav7KdaZjKiWGcHovaQ==} - - '@ledgerhq/hw-app-eth@6.33.6': - resolution: {integrity: sha512-QzYvr5FNEWWd70Vg04A2i8CY0mtPgJrrX7/KePabjXrR8NjDyJ5Ej8qSQPBTp2dkR4TGiz5Y7+HIcWpdgYzjzg==} - - '@ledgerhq/hw-transport-mocker@6.28.6': - resolution: {integrity: sha512-JDO2kqMOTRCQWNZr1KVlyX1AqE6WBzHjJDS3FnSI8Z/Bj2KSc2/1H/4lW6+Ap64yLtlmOW3GchdafFmLgYAgqw==} - - '@ledgerhq/hw-transport-node-hid-noevents@6.29.6': - resolution: {integrity: sha512-H1cGC4TLwSCxve3rbV7qfPJBZfy7VD7k9Czc9HOMDwQ9zHFtaoeiIotIMGjzHjfPtAGauMpAYvrpmEdBBX5sHg==} - - '@ledgerhq/hw-transport-node-hid@6.28.6': - resolution: {integrity: sha512-USSTOO0zv9XtguWismP7/StnNS/s7Rz0JOGGaBhKe3Bzl7d5XPncUlmOvoNFzzY/QdasEoFs2QId1+ibJG71Vw==} - - '@ledgerhq/hw-transport@6.30.6': - resolution: {integrity: sha512-fT0Z4IywiuJuZrZE/+W0blkV5UCotDPFTYKLkKCLzYzuE6javva7D/ajRaIeR+hZ4kTmKF4EqnsmDCXwElez+w==} - - '@ledgerhq/logs@6.12.0': - resolution: {integrity: sha512-ExDoj1QV5eC6TEbMdLUMMk9cfvNKhhv5gXol4SmULRVCx/3iyCPhJ74nsb3S0Vb+/f+XujBEj3vQn5+cwS0fNA==} - - '@ledgerhq/types-live@6.46.0': - resolution: {integrity: sha512-UtI4qm13wJIv9FB/0g6Hi1NijU7PuJEGetqGQxELlKEOmjubXa52EfKVA9IVOngL25m6U8i7jzluwLsHiN2uQQ==} - - '@manypkg/find-root@1.1.0': - resolution: {integrity: sha512-mki5uBvhHzO8kYYix/WRy2WX8S3B5wdVSc9D6KcU5lQNglP2yt58/VfLuAK49glRXChosY8ap2oJ1qgma3GUVA==} - - '@manypkg/get-packages@1.1.3': - resolution: {integrity: sha512-fo+QhuU3qE/2TQMQmbVMqaQ6EWbMhi4ABWP+O4AM1NqPBuy0OrApV5LO6BrrgnhtAHS2NH6RrVk9OL181tTi8A==} - - '@metamask/eth-sig-util@4.0.1': - resolution: {integrity: sha512-tghyZKLHZjcdlDqCA3gNZmLeR0XvOE9U1qoQO9ohyAZT6Pya+H9vkBPcsyXytmYLNgVoin7CKCmweo/R43V+tQ==} - engines: {node: '>=12.0.0'} - - '@noble/curves@1.2.0': - resolution: {integrity: sha512-oYclrNgRaM9SsBUBVbb8M6DTV7ZHRTKugureoYEncY5c65HOmRzvSiTE3y5CYaPYJA/GVkrhXEoF0M3Ya9PMnw==} - - '@noble/curves@1.3.0': - resolution: {integrity: sha512-t01iSXPuN+Eqzb4eBX0S5oubSqXbK/xXa1Ne18Hj8f9pStxztHCE2gfboSp/dZRLSqfuLpRK2nDXDK+W9puocA==} - - '@noble/hashes@1.2.0': - resolution: {integrity: sha512-FZfhjEDbT5GRswV3C6uvLPHMiVD6lQBmpoX5+eSiPaMTXte/IKqI5dykDxzZB/WBeK/CDuQRBWarPdi3FNY2zQ==} - - '@noble/hashes@1.3.2': - resolution: {integrity: sha512-MVC8EAQp7MvEcm30KWENFjgR+Mkmf+D189XJTkFIlwohU5hcBbn1ZkKq7KVTi2Hme3PMGF390DaL52beVrIihQ==} - engines: {node: '>= 16'} - - '@noble/hashes@1.3.3': - resolution: {integrity: sha512-V7/fPHgl+jsVPXqqeOzT8egNj2iBIVt+ECeMMG8TdcnTikP3oaBtUVqpT/gYCR68aEBJSF+XbYUxStjbFMqIIA==} - engines: {node: '>= 16'} - - '@noble/hashes@1.4.0': - resolution: {integrity: sha512-V1JJ1WTRUqHHrOSh597hURcMqVKVGL/ea3kv0gSnEdsEZ0/+VyPghM1lMNGc00z7CIQorSvbKpuJkxvuHbvdbg==} - engines: {node: '>= 16'} - - '@noble/secp256k1@1.7.1': - resolution: {integrity: sha512-hOUk6AyBFmqVrv7k5WAw/LpszxVbj9gGN4JRkIX52fdFAj1UA61KXmZDvqVEm+pOyec3+fIeZB02LYa/pWOArw==} - - '@nodelib/fs.scandir@2.1.5': - resolution: {integrity: sha512-vq24Bq3ym5HEQm2NKCr3yXDwjc7vTsEThRDnkp2DK9p1uqLR+DHurm/NOTo0KG7HYHU7eppKZj3MyqYuMBf62g==} - engines: {node: '>= 8'} - - '@nodelib/fs.stat@2.0.5': - resolution: {integrity: sha512-RkhPPp2zrqDAQA/2jNhnztcPAlv64XdhIp7a7454A5ovI7Bukxgt7MX7udwAu3zg1DcpPU0rz3VV1SeaqvY4+A==} - engines: {node: '>= 8'} - - '@nodelib/fs.walk@1.2.8': - resolution: {integrity: sha512-oGB+UxlgWcgQkgwo8GcEGwemoTFt3FIO9ababBmaGwXIoBKZ+GTy0pP185beGg7Llih/NSHSV2XAs1lnznocSg==} - engines: {node: '>= 8'} - - '@nomicfoundation/edr-darwin-arm64@0.3.8': - resolution: {integrity: sha512-eB0leCexS8sQEmfyD72cdvLj9djkBzQGP4wSQw6SNf2I4Sw4Cnzb3d45caG2FqFFjbvfqL0t+badUUIceqQuMw==} - engines: {node: '>= 18'} - - '@nomicfoundation/edr-darwin-x64@0.3.8': - resolution: {integrity: sha512-JksVCS1N5ClwVF14EvO25HCQ+Laljh/KRfHERMVAC9ZwPbTuAd/9BtKvToCBi29uCHWqsXMI4lxCApYQv2nznw==} - engines: {node: '>= 18'} - - '@nomicfoundation/edr-linux-arm64-gnu@0.3.8': - resolution: {integrity: sha512-raCE+fOeNXhVBLUo87cgsHSGvYYRB6arih4eG6B9KGACWK5Veebtm9xtKeiD8YCsdUlUfat6F7ibpeNm91fpsA==} - engines: {node: '>= 18'} - - '@nomicfoundation/edr-linux-arm64-musl@0.3.8': - resolution: {integrity: sha512-PwiDp4wBZWMCIy29eKkv8moTKRrpiSDlrc+GQMSZLhOAm8T33JKKXPwD/2EbplbhCygJDGXZdtEKl9x9PaH66A==} - engines: {node: '>= 18'} - - '@nomicfoundation/edr-linux-x64-gnu@0.3.8': - resolution: {integrity: sha512-6AcvA/XKoipGap5jJmQ9Y6yT7Uf39D9lu2hBcDCXnXbMcXaDGw4mn1/L4R63D+9VGZyu1PqlcJixCUZlGGIWlg==} - engines: {node: '>= 18'} - - '@nomicfoundation/edr-linux-x64-musl@0.3.8': - resolution: {integrity: sha512-cxb0sEmZjlwhYWO28sPsV64VDx31ekskhC1IsDXU1p9ntjHSJRmW4KEIqJ2O3QwJap/kLKfMS6TckvY10gjc6w==} - engines: {node: '>= 18'} - - '@nomicfoundation/edr-win32-x64-msvc@0.3.8': - resolution: {integrity: sha512-yVuVPqRRNLZk7TbBMkKw7lzCvI8XO8fNTPTYxymGadjr9rEGRuNTU1yBXjfJ59I1jJU/X2TSkRk1OFX0P5tpZQ==} - engines: {node: '>= 18'} - - '@nomicfoundation/edr@0.3.8': - resolution: {integrity: sha512-u2UJ5QpznSHVkZRh6ePWoeVb6kmPrrqh08gCnZ9FHlJV9CITqlrTQHJkacd+INH31jx88pTAJnxePE4XAiH5qg==} - engines: {node: '>= 18'} - - '@nomicfoundation/ethereumjs-block@5.0.4': - resolution: {integrity: sha512-AcyacJ9eX/uPEvqsPiB+WO1ymE+kyH48qGGiGV+YTojdtas8itUTW5dehDSOXEEItWGbbzEJ4PRqnQZlWaPvDw==} - engines: {node: '>=18'} - - '@nomicfoundation/ethereumjs-common@4.0.4': - resolution: {integrity: sha512-9Rgb658lcWsjiicr5GzNCjI1llow/7r0k50dLL95OJ+6iZJcVbi15r3Y0xh2cIO+zgX0WIHcbzIu6FeQf9KPrg==} - - '@nomicfoundation/ethereumjs-rlp@5.0.4': - resolution: {integrity: sha512-8H1S3s8F6QueOc/X92SdrA4RDenpiAEqMg5vJH99kcQaCy/a3Q6fgseo75mgWlbanGJXSlAPtnCeG9jvfTYXlw==} - engines: {node: '>=18'} - hasBin: true - - '@nomicfoundation/ethereumjs-trie@6.0.4': - resolution: {integrity: sha512-3nSwQiFMvr2VFe/aZUyinuohYvtytUqZCUCvIWcPJ/BwJH6oQdZRB42aNFBJ/8nAh2s3OcroWpBLskzW01mFKA==} - engines: {node: '>=18'} - - '@nomicfoundation/ethereumjs-tx@5.0.4': - resolution: {integrity: sha512-Xjv8wAKJGMrP1f0n2PeyfFCCojHd7iS3s/Ab7qzF1S64kxZ8Z22LCMynArYsVqiFx6rzYy548HNVEyI+AYN/kw==} - engines: {node: '>=18'} - peerDependencies: - c-kzg: ^2.1.2 - peerDependenciesMeta: - c-kzg: - optional: true - - '@nomicfoundation/ethereumjs-util@9.0.4': - resolution: {integrity: sha512-sLOzjnSrlx9Bb9EFNtHzK/FJFsfg2re6bsGqinFinH1gCqVfz9YYlXiMWwDM4C/L4ywuHFCYwfKTVr/QHQcU0Q==} - engines: {node: '>=18'} - peerDependencies: - c-kzg: ^2.1.2 - peerDependenciesMeta: - c-kzg: - optional: true - - '@nomicfoundation/hardhat-ignition-ethers@0.15.2': - resolution: {integrity: sha512-rXkEpzl4ZNGfrht6ZFO+37dQvL+byrJaX7pNeSFzdKKqhEe4oboRwDWaBohQO+pCn837Qh/86xwwOFoGEv2+hg==} - peerDependencies: - '@nomicfoundation/hardhat-ethers': ^3.0.4 - '@nomicfoundation/hardhat-ignition': ^0.15.2 - '@nomicfoundation/ignition-core': ^0.15.2 - ethers: ^6.7.0 - hardhat: ^2.18.0 - - '@nomicfoundation/hardhat-ignition-viem@0.15.2': - resolution: {integrity: sha512-iYmw9vJLXY1Tum0idnNsrsEmuvHsRDVJcudgzaMY6sA2nLLhJDSReK2gVZdtx3rdfJz4QRhG2+h2s3T+Rzv0TQ==} - peerDependencies: - '@nomicfoundation/hardhat-ignition': ^0.15.2 - '@nomicfoundation/hardhat-viem': ^2.0.0 - '@nomicfoundation/ignition-core': ^0.15.2 - hardhat: ^2.18.0 - viem: ^2.7.6 - - '@nomicfoundation/hardhat-ignition@0.15.2': - resolution: {integrity: sha512-tdI+D+GwP8qBt3/sq0hGKk46lAfKnNj3ZtqxrNinOnQUfc3f9qXgZDFqWT2JudsmuQcuHFbn1FQ1zoDvjUVjRA==} - peerDependencies: - '@nomicfoundation/hardhat-verify': ^2.0.1 - hardhat: ^2.18.0 - - '@nomicfoundation/ignition-core@0.15.2': - resolution: {integrity: sha512-6kchZOBh6zSl0BgG1bs6+ZbNYlGjeH22yi72mgeOa0oNOYFqCpka9a4FEYv0gfcphsMMmKTMlxadanf02ZoE4w==} - - '@nomicfoundation/ignition-ui@0.15.2': - resolution: {integrity: sha512-NEX2prbfLEm45KbnBS0imvSgQgwLTgmT8zD3rAPmcIFZx+tLG4lKKw99k6EgEwmKwBiaO2zQMmt+FNoF7xGaiQ==} - - '@nomicfoundation/solidity-analyzer-darwin-arm64@0.1.1': - resolution: {integrity: sha512-KcTodaQw8ivDZyF+D76FokN/HdpgGpfjc/gFCImdLUyqB6eSWVaZPazMbeAjmfhx3R0zm/NYVzxwAokFKgrc0w==} - engines: {node: '>= 10'} - cpu: [arm64] - os: [darwin] - - '@nomicfoundation/solidity-analyzer-darwin-x64@0.1.1': - resolution: {integrity: sha512-XhQG4BaJE6cIbjAVtzGOGbK3sn1BO9W29uhk9J8y8fZF1DYz0Doj8QDMfpMu+A6TjPDs61lbsmeYodIDnfveSA==} - engines: {node: '>= 10'} - cpu: [x64] - os: [darwin] - - '@nomicfoundation/solidity-analyzer-freebsd-x64@0.1.1': - resolution: {integrity: sha512-GHF1VKRdHW3G8CndkwdaeLkVBi5A9u2jwtlS7SLhBc8b5U/GcoL39Q+1CSO3hYqePNP+eV5YI7Zgm0ea6kMHoA==} - engines: {node: '>= 10'} - cpu: [x64] - os: [freebsd] - - '@nomicfoundation/solidity-analyzer-linux-arm64-gnu@0.1.1': - resolution: {integrity: sha512-g4Cv2fO37ZsUENQ2vwPnZc2zRenHyAxHcyBjKcjaSmmkKrFr64yvzeNO8S3GBFCo90rfochLs99wFVGT/0owpg==} - engines: {node: '>= 10'} - cpu: [arm64] - os: [linux] - - '@nomicfoundation/solidity-analyzer-linux-arm64-musl@0.1.1': - resolution: {integrity: sha512-WJ3CE5Oek25OGE3WwzK7oaopY8xMw9Lhb0mlYuJl/maZVo+WtP36XoQTb7bW/i8aAdHW5Z+BqrHMux23pvxG3w==} - engines: {node: '>= 10'} - cpu: [arm64] - os: [linux] - - '@nomicfoundation/solidity-analyzer-linux-x64-gnu@0.1.1': - resolution: {integrity: sha512-5WN7leSr5fkUBBjE4f3wKENUy9HQStu7HmWqbtknfXkkil+eNWiBV275IOlpXku7v3uLsXTOKpnnGHJYI2qsdA==} - engines: {node: '>= 10'} - cpu: [x64] - os: [linux] - - '@nomicfoundation/solidity-analyzer-linux-x64-musl@0.1.1': - resolution: {integrity: sha512-KdYMkJOq0SYPQMmErv/63CwGwMm5XHenEna9X9aB8mQmhDBrYrlAOSsIPgFCUSL0hjxE3xHP65/EPXR/InD2+w==} - engines: {node: '>= 10'} - cpu: [x64] - os: [linux] - - '@nomicfoundation/solidity-analyzer-win32-arm64-msvc@0.1.1': - resolution: {integrity: sha512-VFZASBfl4qiBYwW5xeY20exWhmv6ww9sWu/krWSesv3q5hA0o1JuzmPHR4LPN6SUZj5vcqci0O6JOL8BPw+APg==} - engines: {node: '>= 10'} - cpu: [arm64] - os: [win32] - - '@nomicfoundation/solidity-analyzer-win32-ia32-msvc@0.1.1': - resolution: {integrity: sha512-JnFkYuyCSA70j6Si6cS1A9Gh1aHTEb8kOTBApp/c7NRTFGNMH8eaInKlyuuiIbvYFhlXW4LicqyYuWNNq9hkpQ==} - engines: {node: '>= 10'} - cpu: [ia32] - os: [win32] - - '@nomicfoundation/solidity-analyzer-win32-x64-msvc@0.1.1': - resolution: {integrity: sha512-HrVJr6+WjIXGnw3Q9u6KQcbZCtk0caVWhCdFADySvRyUxJ8PnzlaP+MhwNE8oyT8OZ6ejHBRrrgjSqDCFXGirw==} - engines: {node: '>= 10'} - cpu: [x64] - os: [win32] - - '@nomicfoundation/solidity-analyzer@0.1.1': - resolution: {integrity: sha512-1LMtXj1puAxyFusBgUIy5pZk3073cNXYnXUpuNKFghHbIit/xZgbk0AokpUADbNm3gyD6bFWl3LRFh3dhVdREg==} - engines: {node: '>= 12'} - - '@nomiclabs/truffle-contract@4.5.10': - resolution: {integrity: sha512-nF/6InFV+0hUvutyFgsdOMCoYlr//2fJbRER4itxYtQtc4/O1biTwZIKRu+5l2J5Sq6LU2WX7vZHtDgQdhWxIQ==} - peerDependencies: - web3: ^1.2.1 - web3-core-helpers: ^1.2.1 - web3-core-promievent: ^1.2.1 - web3-eth-abi: ^1.2.1 - web3-utils: ^1.2.1 - - '@open-rpc/meta-schema@1.14.2': - resolution: {integrity: sha512-vD4Nbkrb7wYFRcSQf+j228LwOy1C6/KKpy5NADlpMElGrAWPRxhTa2yTi6xG+x88OHzg2+cydQ0GAD6o40KUcg==} - - '@open-rpc/schema-utils-js@1.16.1': - resolution: {integrity: sha512-8D4OgBnHDAv7JeaYZ5v7SL4yR0YLLO4WLTWtdR8vmqSqvX3SvPzSsGYv06zqm9z1Lhm563MAcuearrc8g9eJ4w==} - - '@open-rpc/typings@1.12.3': - resolution: {integrity: sha512-YxoC0WBMmxOAYNk9T6sFlOsy2H3YNnXJKFwkRb5GWg1ixOOEFm/3AYOciI/4Ieq08xNzjPhIz6XfC4u4fsmAWg==} - hasBin: true - - '@scure/base@1.1.6': - resolution: {integrity: sha512-ok9AWwhcgYuGG3Zfhyqg+zwl+Wn5uE+dwC0NV/2qQkx4dABbb/bx96vWu8NSj+BNjjSjno+JRYRjle1jV08k3g==} - - '@scure/bip32@1.1.5': - resolution: {integrity: sha512-XyNh1rB0SkEqd3tXcXMi+Xe1fvg+kUIcoRIEujP1Jgv7DqW2r9lg3Ah0NkFaCs9sTkQAQA8kw7xiRXzENi9Rtw==} - - '@scure/bip32@1.3.2': - resolution: {integrity: sha512-N1ZhksgwD3OBlwTv3R6KFEcPojl/W4ElJOeCZdi+vuI5QmTFwLq3OFf2zd2ROpKvxFdgZ6hUpb0dx9bVNEwYCA==} - - '@scure/bip32@1.3.3': - resolution: {integrity: sha512-LJaN3HwRbfQK0X1xFSi0Q9amqOgzQnnDngIt+ZlsBC3Bm7/nE7K0kwshZHyaru79yIVRv/e1mQAjZyuZG6jOFQ==} - - '@scure/bip39@1.1.1': - resolution: {integrity: sha512-t+wDck2rVkh65Hmv280fYdVdY25J9YeEUIgn2LG1WM6gxFkGzcksoDiUkWVpVp3Oex9xGC68JU2dSbUfwZ2jPg==} - - '@scure/bip39@1.2.1': - resolution: {integrity: sha512-Z3/Fsz1yr904dduJD0NpiyRHhRYHdcnyh73FZWiV+/qhWi83wNJ3NWolYqCEN+ZWsUz2TWwajJggcRE9r1zUYg==} - - '@scure/bip39@1.2.2': - resolution: {integrity: sha512-HYf9TUXG80beW+hGAt3TRM8wU6pQoYur9iNypTROm42dorCGmLnFe3eWjz3gOq6G62H2WRh0FCzAR1PI+29zIA==} - - '@sentry/core@5.30.0': - resolution: {integrity: sha512-TmfrII8w1PQZSZgPpUESqjB+jC6MvZJZdLtE/0hZ+SrnKhW3x5WlYLvTXZpcWePYBku7rl2wn1RZu6uT0qCTeg==} - engines: {node: '>=6'} - - '@sentry/hub@5.30.0': - resolution: {integrity: sha512-2tYrGnzb1gKz2EkMDQcfLrDTvmGcQPuWxLnJKXJvYTQDGLlEvi2tWz1VIHjunmOvJrB5aIQLhm+dcMRwFZDCqQ==} - engines: {node: '>=6'} - - '@sentry/minimal@5.30.0': - resolution: {integrity: sha512-BwWb/owZKtkDX+Sc4zCSTNcvZUq7YcH3uAVlmh/gtR9rmUvbzAA3ewLuB3myi4wWRAMEtny6+J/FN/x+2wn9Xw==} - engines: {node: '>=6'} - - '@sentry/node@5.30.0': - resolution: {integrity: sha512-Br5oyVBF0fZo6ZS9bxbJZG4ApAjRqAnqFFurMVJJdunNb80brh7a5Qva2kjhm+U6r9NJAB5OmDyPkA1Qnt+QVg==} - engines: {node: '>=6'} - - '@sentry/tracing@5.30.0': - resolution: {integrity: sha512-dUFowCr0AIMwiLD7Fs314Mdzcug+gBVo/+NCMyDw8tFxJkwWAKl7Qa2OZxLQ0ZHjakcj1hNKfCQJ9rhyfOl4Aw==} - engines: {node: '>=6'} - - '@sentry/types@5.30.0': - resolution: {integrity: sha512-R8xOqlSTZ+htqrfteCWU5Nk0CDN5ApUTvrlvBuiH1DyP6czDZ4ktbZB0hAgBlVcK0U+qpD3ag3Tqqpa5Q67rPw==} - engines: {node: '>=6'} - - '@sentry/utils@5.30.0': - resolution: {integrity: sha512-zaYmoH0NWWtvnJjC9/CBseXMtKHm/tm40sz3YfJRxeQjyzRqNQPgivpd9R/oDJCYj999mzdW382p/qi2ypjLww==} - engines: {node: '>=6'} - - '@sinclair/typebox@0.27.8': - resolution: {integrity: sha512-+Fj43pSMwJs4KRrH/938Uf+uAELIgVBmQzg/q1YG10djyfA3TnrU8N8XzqCh/okZdszqBQTZf96idMfE5lnwTA==} - - '@sindresorhus/is@4.6.0': - resolution: {integrity: sha512-t09vSN3MdfsyCHoFcTRCH/iUtG7OJ0CsjzB8cjAmKc/va/kIgeDI/TxsigdncE/4be734m0cvIYwNaV4i2XqAw==} - engines: {node: '>=10'} - - '@sinonjs/commons@1.8.6': - resolution: {integrity: sha512-Ky+XkAkqPZSm3NLBeUng77EBQl3cmeJhITaGHdYH8kjVB+aun3S4XBRti2zt17mtt0mIUDiNxYeoJm6drVvBJQ==} - - '@sinonjs/fake-timers@6.0.1': - resolution: {integrity: sha512-MZPUxrmFubI36XS1DI3qmI0YdN1gks62JtFZvxR67ljjSNCeK6U08Zx4msEWOXuofgqUt6zPHSi1H9fbjR/NRA==} - - '@sinonjs/samsam@5.3.1': - resolution: {integrity: sha512-1Hc0b1TtyfBu8ixF/tpfSHTVWKwCBLY4QJbkgnE7HcwyvT2xArDxb4K7dMgqRm3szI+LJbzmW/s4xxEhv6hwDg==} - - '@sinonjs/text-encoding@0.7.2': - resolution: {integrity: sha512-sXXKG+uL9IrKqViTtao2Ws6dy0znu9sOaP1di/jKGW1M6VssO8vlpXCQcpZ+jisQ1tTFAC5Jo/EOzFbggBagFQ==} - - '@solidity-parser/parser@0.14.5': - resolution: {integrity: sha512-6dKnHZn7fg/iQATVEzqyUOyEidbn05q7YA2mQ9hC0MMXhhV3/JrsxmFSYZAcr7j1yUP700LLhTruvJ3MiQmjJg==} - - '@solidity-parser/parser@0.16.2': - resolution: {integrity: sha512-PI9NfoA3P8XK2VBkK5oIfRgKDsicwDZfkVq9ZTBCQYGOP1N2owgY2dyLGyU5/J/hQs8KRk55kdmvTLjy3Mu3vg==} - - '@solidity-parser/parser@0.18.0': - resolution: {integrity: sha512-yfORGUIPgLck41qyN7nbwJRAx17/jAIXCTanHOJZhB6PJ1iAk/84b/xlsVKFSyNyLXIj0dhppoE0+CRws7wlzA==} - - '@szmarczak/http-timer@4.0.6': - resolution: {integrity: sha512-4BAffykYOgO+5nzBWYwE3W90sBgLJoUPRWWcL8wlyiM8IB8ipJz3UMJ9KXQd1RKQXpKp8Tutn80HZtWsu2u76w==} - engines: {node: '>=10'} - - '@szmarczak/http-timer@5.0.1': - resolution: {integrity: sha512-+PmQX0PiAYPMeVYe237LJAYvOMYW1j2rH5YROyS3b4CTVJum34HfRvKvAzozHAQG0TnHNdUfY9nCeUyRAs//cw==} - engines: {node: '>=14.16'} - - '@truffle/abi-utils@1.0.3': - resolution: {integrity: sha512-AWhs01HCShaVKjml7Z4AbVREr/u4oiWxCcoR7Cktm0mEvtT04pvnxW5xB/cI4znRkrbPdFQlFt67kgrAjesYkw==} - engines: {node: ^16.20 || ^18.16 || >=20} - deprecated: Package no longer supported. Contact Support at https://www.npmjs.com/support for more info. - - '@truffle/blockchain-utils@0.1.9': - resolution: {integrity: sha512-RHfumgbIVo68Rv9ofDYfynjnYZIfP/f1vZy4RoqkfYAO+fqfc58PDRzB1WAGq2U6GPuOnipOJxQhnqNnffORZg==} - engines: {node: ^16.20 || ^18.16 || >=20} - deprecated: Package no longer supported. Contact Support at https://www.npmjs.com/support for more info. - - '@truffle/codec@0.17.3': - resolution: {integrity: sha512-Ko/+dsnntNyrJa57jUD9u4qx9nQby+H4GsUO6yjiCPSX0TQnEHK08XWqBSg0WdmCH2+h0y1nr2CXSx8gbZapxg==} - engines: {node: ^16.20 || ^18.16 || >=20} - deprecated: Package no longer supported. Contact Support at https://www.npmjs.com/support for more info. - - '@truffle/compile-common@0.9.8': - resolution: {integrity: sha512-DTpiyo32t/YhLI1spn84D3MHYHrnoVqO+Gp7ZHrYNwDs86mAxtNiH5lsVzSb8cPgiqlvNsRCU9nm9R0YmKMTBQ==} - engines: {node: ^16.20 || ^18.16 || >=20} - deprecated: Package no longer supported. Contact Support at https://www.npmjs.com/support for more info. - - '@truffle/contract-schema@3.4.16': - resolution: {integrity: sha512-g0WNYR/J327DqtJPI70ubS19K1Fth/1wxt2jFqLsPmz5cGZVjCwuhiie+LfBde4/Mc9QR8G+L3wtmT5cyoBxAg==} - engines: {node: ^16.20 || ^18.16 || >=20} - deprecated: Package no longer supported. Contact Support at https://www.npmjs.com/support for more info. - - '@truffle/debug-utils@6.0.57': - resolution: {integrity: sha512-Q6oI7zLaeNLB69ixjwZk2UZEWBY6b2OD1sjLMGDKBGR7GaHYiw96GLR2PFgPH1uwEeLmV4N78LYaQCrDsHbNeA==} - engines: {node: ^16.20 || ^18.16 || >=20} - deprecated: Package no longer supported. Contact Support at https://www.npmjs.com/support for more info. - - '@truffle/error@0.1.1': - resolution: {integrity: sha512-sE7c9IHIGdbK4YayH4BC8i8qMjoAOeg6nUXUDZZp8wlU21/EMpaG+CLx+KqcIPyR+GSWIW3Dm0PXkr2nlggFDA==} - deprecated: Package no longer supported. Contact Support at https://www.npmjs.com/support for more info. - - '@truffle/error@0.2.2': - resolution: {integrity: sha512-TqbzJ0O8DHh34cu8gDujnYl4dUl6o2DE4PR6iokbybvnIm/L2xl6+Gv1VC+YJS45xfH83Yo3/Zyg/9Oq8/xZWg==} - engines: {node: ^16.20 || ^18.16 || >=20} - deprecated: Package no longer supported. Contact Support at https://www.npmjs.com/support for more info. - - '@truffle/interface-adapter@0.5.37': - resolution: {integrity: sha512-lPH9MDgU+7sNDlJSClwyOwPCfuOimqsCx0HfGkznL3mcFRymc1pukAR1k17zn7ErHqBwJjiKAZ6Ri72KkS+IWw==} - engines: {node: ^16.20 || ^18.16 || >=20} - deprecated: Package no longer supported. Contact Support at https://www.npmjs.com/support for more info. - - '@trufflesuite/chromafi@3.0.0': - resolution: {integrity: sha512-oqWcOqn8nT1bwlPPfidfzS55vqcIDdpfzo3HbU9EnUmcSTX+I8z0UyUFI3tZQjByVJulbzxHxUGS3ZJPwK/GPQ==} - - '@tsconfig/node10@1.0.11': - resolution: {integrity: sha512-DcRjDCujK/kCk/cUe8Xz8ZSpm8mS3mNNpta+jGCA6USEDfktlNvm1+IuZ9eTcDbNk41BHwpHHeW+N1lKCz4zOw==} - - '@tsconfig/node12@1.0.11': - resolution: {integrity: sha512-cqefuRsh12pWyGsIoBKJA9luFu3mRxCA+ORZvA4ktLSzIuCUtWVxGIuXigEwO5/ywWFMZ2QEGKWvkZG1zDMTag==} - - '@tsconfig/node14@1.0.3': - resolution: {integrity: sha512-ysT8mhdixWK6Hw3i1V2AeRqZ5WfXg1G43mqoYlM2nc6388Fq5jcXyr5mRsqViLx/GJYdoL0bfXD8nmF+Zn/Iow==} - - '@tsconfig/node16@1.0.4': - resolution: {integrity: sha512-vxhUy4J8lyeyinH7Azl1pdd43GJhZH/tP2weN8TntQblOY+A0XbT8DJk1/oCPuOOyg/Ja757rG0CgHcWC8OfMA==} - - '@typechain/ethers-v6@0.5.1': - resolution: {integrity: sha512-F+GklO8jBWlsaVV+9oHaPh5NJdd6rAKN4tklGfInX1Q7h0xPgVLP39Jl3eCulPB5qexI71ZFHwbljx4ZXNfouA==} - peerDependencies: - ethers: 6.x - typechain: ^8.3.2 - typescript: '>=4.7.0' - - '@typechain/hardhat@9.1.0': - resolution: {integrity: sha512-mtaUlzLlkqTlfPwB3FORdejqBskSnh+Jl8AIJGjXNAQfRQ4ofHADPl1+oU7Z3pAJzmZbUXII8MhOLQltcHgKnA==} - peerDependencies: - '@typechain/ethers-v6': ^0.5.1 - ethers: ^6.1.0 - hardhat: ^2.9.9 - typechain: ^8.3.2 - - '@types/async-eventemitter@0.2.4': - resolution: {integrity: sha512-2Bq61VD01kgLf1XkK2xPtoBcu7fgn/km5JyEX9v0BlG5VQBzA+BlF9umFk+8gR8S4+eK7MgDY2oyVZCu6ar3Jw==} - - '@types/bignumber.js@5.0.0': - resolution: {integrity: sha512-0DH7aPGCClywOFaxxjE6UwpN2kQYe9LwuDQMv+zYA97j5GkOMo8e66LYT+a8JYU7jfmUFRZLa9KycxHDsKXJCA==} - deprecated: This is a stub types definition for bignumber.js (https://github.com/MikeMcl/bignumber.js/). bignumber.js provides its own type definitions, so you don't need @types/bignumber.js installed! - - '@types/bn.js@4.11.6': - resolution: {integrity: sha512-pqr857jrp2kPuO9uRjZ3PwnJTjoQy+fcdxvBTvHm6dkmEL9q+hDD/2j/0ELOBPtPnS8LjCX0gI9nbl8lVkadpg==} - - '@types/bn.js@5.1.5': - resolution: {integrity: sha512-V46N0zwKRF5Q00AZ6hWtN0T8gGmDUaUzLWQvHFo5yThtVwK/VCenFY3wXVbOvNfajEpsTfQM4IN9k/d6gUVX3A==} - - '@types/cacheable-request@6.0.3': - resolution: {integrity: sha512-IQ3EbTzGxIigb1I3qPZc1rWJnH0BmSKv5QYTalEwweFvyBDLSAe24zP0le/hyi7ecGfZVlIVAg4BZqb8WBwKqw==} - - '@types/chai-as-promised@7.1.8': - resolution: {integrity: sha512-ThlRVIJhr69FLlh6IctTXFkmhtP3NpMZ2QGq69StYLyKZFp/HOp1VdKZj7RvfNWYYcJ1xlbLGLLWj1UvP5u/Gw==} - - '@types/chai@4.3.16': - resolution: {integrity: sha512-PatH4iOdyh3MyWtmHVFXLWCCIhUbopaltqddG9BzB+gMIzee2MJrvd+jouii9Z3wzQJruGWAm7WOMjgfG8hQlQ==} - - '@types/ci-info@2.0.0': - resolution: {integrity: sha512-5R2/MHILQLDCzTuhs1j4Qqq8AaKUf7Ma4KSSkCtc12+fMs47zfa34qhto9goxpyX00tQK1zxB885VCiawZ5Qhg==} - - '@types/concat-stream@1.6.1': - resolution: {integrity: sha512-eHE4cQPoj6ngxBZMvVf6Hw7Mh4jMW4U9lpGmS5GBPB9RYxlFg+CHaVN7ErNY4W9XfLIEn20b4VDYaIrbq0q4uA==} - - '@types/debug@4.1.12': - resolution: {integrity: sha512-vIChWdVG3LG1SMxEvI/AK+FWJthlrqlTu7fbrlywTkkaONwk/UAGaULXRlf8vkzFBLVm0zkMdCquhL5aOjhXPQ==} - - '@types/events@3.0.3': - resolution: {integrity: sha512-trOc4AAUThEz9hapPtSd7wf5tiQKvTtu5b371UxXdTuqzIh0ArcRspRP0i0Viu+LXstIQ1z96t1nsPxT9ol01g==} - - '@types/find-up@2.1.1': - resolution: {integrity: sha512-60LC501bQRN9/3yfVaEEMd7IndaufffL56PBRAejPpUrY304Ps1jfnjNqPw5jmM5R8JHWiKBAe5IHzNcPV41AA==} - - '@types/form-data@0.0.33': - resolution: {integrity: sha512-8BSvG1kGm83cyJITQMZSulnl6QV8jqAGreJsc5tPu1Jq0vTSOiY/k24Wx82JRpWwZSqrala6sd5rWi6aNXvqcw==} - - '@types/fs-extra@5.1.0': - resolution: {integrity: sha512-AInn5+UBFIK9FK5xc9yP5e3TQSPNNgjHByqYcj9g5elVBnDQcQL7PlO1CIRy2gWlbwK7UPYqi7vRvFA44dCmYQ==} - - '@types/glob@7.2.0': - resolution: {integrity: sha512-ZUxbzKl0IfJILTS6t7ip5fQQM/J3TJYubDm3nMbgubNNYS62eXeUpoLUC8/7fJNiFYHTrGPQn7hspDUzIHX3UA==} - - '@types/http-cache-semantics@4.0.4': - resolution: {integrity: sha512-1m0bIFVc7eJWyve9S0RnuRgcQqF/Xd5QsUZAZeQFr1Q3/p9JWoQQEqmVy+DPTNpGXwhgIetAoYF8JSc33q29QA==} - - '@types/json-schema@7.0.15': - resolution: {integrity: sha512-5+fP8P8MFNC+AyZCDxrB2pkZFPGzqQWUzpSeuuVLvm8VMcorNYavBqoFcxK8bQz4Qsbn4oUEEem4wDLfcysGHA==} - - '@types/json5@0.0.29': - resolution: {integrity: sha512-dRLjCWHYg4oaA77cxO64oO+7JwCwnIzkZPdrrC71jQmQtlhM556pwKo5bUzqvZndkVbeFLIIi+9TC40JNF5hNQ==} - - '@types/keccak@3.0.4': - resolution: {integrity: sha512-hdnkmbie7tE0yXnQQvlIOqCyjEsoXDVEZ3ACqO+F305XgUOW4Z9ElWdogCXXRAW/khnZ7GxM0t/BGB5bORKt/g==} - - '@types/keyv@3.1.4': - resolution: {integrity: sha512-BQ5aZNSCpj7D6K2ksrRCTmKRLEpnPvWDiLPfoGyhZ++8YtiK9d/3DBKPJgry359X/P1PfruyYwvnvwFjuEiEIg==} - - '@types/lodash.clonedeep@4.5.9': - resolution: {integrity: sha512-19429mWC+FyaAhOLzsS8kZUsI+/GmBAQ0HFiCPsKGU+7pBXOQWhyrY6xNNDwUSX8SMZMJvuFVMF9O5dQOlQK9Q==} - - '@types/lodash.isequal@4.5.8': - resolution: {integrity: sha512-uput6pg4E/tj2LGxCZo9+y27JNyB2OZuuI/T5F+ylVDYuqICLG2/ktjxx0v6GvVntAf8TvEzeQLcV0ffRirXuA==} - - '@types/lodash.memoize@4.1.9': - resolution: {integrity: sha512-glY1nQuoqX4Ft8Uk+KfJudOD7DQbbEDF6k9XpGncaohW3RW4eSWBlx6AA0fZCrh40tZcQNH4jS/Oc59J6Eq+aw==} - - '@types/lodash@4.17.1': - resolution: {integrity: sha512-X+2qazGS3jxLAIz5JDXDzglAF3KpijdhFxlf/V1+hEsOUc+HnWi81L/uv/EvGuV90WY+7mPGFCUDGfQC3Gj95Q==} - - '@types/lru-cache@5.1.1': - resolution: {integrity: sha512-ssE3Vlrys7sdIzs5LOxCzTVMsU7i9oa/IaW92wF32JFb3CVczqOkru2xspuKczHEbG3nvmPY7IFqVmGGHdNbYw==} - - '@types/minimatch@5.1.2': - resolution: {integrity: sha512-K0VQKziLUWkVKiRVrx4a40iPaxTUefQmjtkQofBkYRcoaaL/8rhwDWww9qWbrgicNOgnpIsMxyNIUM4+n6dUIA==} - - '@types/minimist@1.2.5': - resolution: {integrity: sha512-hov8bUuiLiyFPGyFPE1lwWhmzYbirOXQNNo40+y3zow8aFVTeyn3VWL0VFFfdNddA8S4Vf0Tc062rzyNr7Paag==} - - '@types/mocha@10.0.6': - resolution: {integrity: sha512-dJvrYWxP/UcXm36Qn36fxhUKu8A/xMRXVT2cliFF1Z7UA9liG5Psj3ezNSZw+5puH2czDXRLcXQxf8JbJt0ejg==} - - '@types/ms@0.7.34': - resolution: {integrity: sha512-nG96G3Wp6acyAgJqGasjODb+acrI7KltPiRxzHPXnP3NgI28bpQDRv53olbqGXbfcgF5aiiHmO3xpwEpS5Ld9g==} - - '@types/node@10.17.60': - resolution: {integrity: sha512-F0KIgDJfy2nA3zMLmWGKxcH2ZVEtCZXHHdOQs2gSaQ27+lNeEfGxzkIw90aXswATX7AZ33tahPbzy6KAfUreVw==} - - '@types/node@12.20.55': - resolution: {integrity: sha512-J8xLz7q2OFulZ2cyGTLE1TbbZcjpno7FaN6zdJNrgAdrJ+DZzh/uFR6YrTb4C+nXakvud8Q4+rbhoIWlYQbUFQ==} - - '@types/node@18.15.13': - resolution: {integrity: sha512-N+0kuo9KgrUQ1Sn/ifDXsvg0TTleP7rIy4zOBGECxAljqvqfqpTfzx0Q1NUedOixRMBfe2Whhb056a42cWs26Q==} - - '@types/node@18.19.33': - resolution: {integrity: sha512-NR9+KrpSajr2qBVp/Yt5TU/rp+b5Mayi3+OlMlcg2cVCfRmcG5PWZ7S4+MG9PZ5gWBoc9Pd0BKSRViuBCRPu0A==} - - '@types/node@8.10.66': - resolution: {integrity: sha512-tktOkFUA4kXx2hhhrB8bIFb5TbwzS4uOhKEmwiD+NoiL0qtP2OQ9mFldbgD4dV1djrlBYP6eBuQZiWjuHUpqFw==} - - '@types/normalize-package-data@2.4.4': - resolution: {integrity: sha512-37i+OaWTh9qeK4LSHPsyRC7NahnGotNuZvjLSgcPzblpHB3rrCJxAOgI5gCdKm7coonsaX1Of0ILiTcnZjbfxA==} - - '@types/pbkdf2@3.1.2': - resolution: {integrity: sha512-uRwJqmiXmh9++aSu1VNEn3iIxWOhd8AHXNSdlaLfdAAdSTY9jYVeGWnzejM3dvrkbqE3/hyQkQQ29IFATEGlew==} - - '@types/prettier@2.7.3': - resolution: {integrity: sha512-+68kP9yzs4LMp7VNh8gdzMSPZFL44MLGqiHWvttYJe+6qnuVr4Ek9wSBQoveqY/r+LwjCcU29kNVkidwim+kYA==} - - '@types/qs@6.9.15': - resolution: {integrity: sha512-uXHQKES6DQKKCLh441Xv/dwxOq1TVS3JPUMlEqoEglvlhR6Mxnlew/Xq/LRVHpLyk7iK3zODe1qYHIMltO7XGg==} - - '@types/readable-stream@2.3.15': - resolution: {integrity: sha512-oM5JSKQCcICF1wvGgmecmHldZ48OZamtMxcGGVICOJA8o8cahXC1zEVAif8iwoc5j8etxFaRFnf095+CDsuoFQ==} - - '@types/resolve@1.20.6': - resolution: {integrity: sha512-A4STmOXPhMUtHH+S6ymgE2GiBSMqf4oTvcQZMcHzokuTLVYzXTB8ttjcgxOVaAp2lGwEdzZ0J+cRbbeevQj1UQ==} - - '@types/responselike@1.0.3': - resolution: {integrity: sha512-H/+L+UkTV33uf49PH5pCAUBVPNj2nDBXTN+qS1dOwyyg24l3CcicicCA7ca+HMvJBZcFgl5r8e+RR6elsb4Lyw==} - - '@types/secp256k1@4.0.6': - resolution: {integrity: sha512-hHxJU6PAEUn0TP4S/ZOzuTUvJWuZ6eIKeNKb5RBpODvSl6hp1Wrw4s7ATY50rklRCScUDpHzVA/DQdSjJ3UoYQ==} - - '@types/semver@6.2.7': - resolution: {integrity: sha512-blctEWbzUFzQx799RZjzzIdBJOXmE37YYEyDtKkx5Dg+V7o/zyyAxLPiI98A2jdTtDgxZleMdfV+7p8WbRJ1OQ==} - - '@types/semver@7.5.8': - resolution: {integrity: sha512-I8EUhyrgfLrcTkzV3TSsGyl1tSuPrEDzr0yd5m90UgNxQkyDXULk3b6MlQqTCpZpNtWe1K0hzclnZkTcLBe2UQ==} - - '@types/sinon-chai@3.2.12': - resolution: {integrity: sha512-9y0Gflk3b0+NhQZ/oxGtaAJDvRywCa5sIyaVnounqLvmf93yBF4EgIRspePtkMs3Tr844nCclYMlcCNmLCvjuQ==} - - '@types/sinon@9.0.11': - resolution: {integrity: sha512-PwP4UY33SeeVKodNE37ZlOsR9cReypbMJOhZ7BVE0lB+Hix3efCOxiJWiE5Ia+yL9Cn2Ch72EjFTRze8RZsNtg==} - - '@types/sinonjs__fake-timers@8.1.5': - resolution: {integrity: sha512-mQkU2jY8jJEF7YHjHvsQO8+3ughTL1mcnn96igfhONmR+fUPSKIkefQYpSe8bsly2Ep7oQbn/6VG5/9/0qcArQ==} - - '@types/uuid@8.3.4': - resolution: {integrity: sha512-c/I8ZRb51j+pYGAu5CrFMRxqZ2ke4y2grEBO5AUjgSkSk+qT2Ea+OdWElz/OiMf5MNpn2b17kuVBwZLQJXzihw==} - - '@types/w3c-web-usb@1.0.10': - resolution: {integrity: sha512-CHgUI5kTc/QLMP8hODUHhge0D4vx+9UiAwIGiT0sTy/B2XpdX1U5rJt6JSISgr6ikRT7vxV9EVAFeYZqUnl1gQ==} - - '@types/ws@7.4.7': - resolution: {integrity: sha512-JQbbmxZTZehdc2iszGKs5oC3NFnjeay7mtAWrdt7qNtAVK0g19muApzAy4bm9byz79xa2ZnO/BOBC2R8RC5Lww==} - - '@types/ws@8.5.3': - resolution: {integrity: sha512-6YOoWjruKj1uLf3INHH7D3qTXwFfEsg1kf3c0uDdSBJwfa/llkwIjrAGV7j7mVgGNbzTQ3HiHKKDXl6bJPD97w==} - - '@typescript-eslint/eslint-plugin@5.61.0': - resolution: {integrity: sha512-A5l/eUAug103qtkwccSCxn8ZRwT+7RXWkFECdA4Cvl1dOlDUgTpAOfSEElZn2uSUxhdDpnCdetrf0jvU4qrL+g==} - engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0} - peerDependencies: - '@typescript-eslint/parser': ^5.0.0 - eslint: ^6.0.0 || ^7.0.0 || ^8.0.0 - typescript: '*' - peerDependenciesMeta: - typescript: - optional: true - - '@typescript-eslint/parser@5.61.0': - resolution: {integrity: sha512-yGr4Sgyh8uO6fSi9hw3jAFXNBHbCtKKFMdX2IkT3ZqpKmtAq3lHS4ixB/COFuAIJpwl9/AqF7j72ZDWYKmIfvg==} - engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0} - peerDependencies: - eslint: ^6.0.0 || ^7.0.0 || ^8.0.0 - typescript: '*' - peerDependenciesMeta: - typescript: - optional: true - - '@typescript-eslint/scope-manager@5.61.0': - resolution: {integrity: sha512-W8VoMjoSg7f7nqAROEmTt6LoBpn81AegP7uKhhW5KzYlehs8VV0ZW0fIDVbcZRcaP3aPSW+JZFua+ysQN+m/Nw==} - engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0} - - '@typescript-eslint/scope-manager@5.62.0': - resolution: {integrity: sha512-VXuvVvZeQCQb5Zgf4HAxc04q5j+WrNAtNh9OwCsCgpKqESMTu3tF/jhZ3xG6T4NZwWl65Bg8KuS2uEvhSfLl0w==} - engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0} - - '@typescript-eslint/type-utils@5.61.0': - resolution: {integrity: sha512-kk8u//r+oVK2Aj3ph/26XdH0pbAkC2RiSjUYhKD+PExemG4XSjpGFeyZ/QM8lBOa7O8aGOU+/yEbMJgQv/DnCg==} - engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0} - peerDependencies: - eslint: '*' - typescript: '*' - peerDependenciesMeta: - typescript: - optional: true - - '@typescript-eslint/types@5.61.0': - resolution: {integrity: sha512-ldyueo58KjngXpzloHUog/h9REmHl59G1b3a5Sng1GfBo14BkS3ZbMEb3693gnP1k//97lh7bKsp6/V/0v1veQ==} - engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0} - - '@typescript-eslint/types@5.62.0': - resolution: {integrity: sha512-87NVngcbVXUahrRTqIK27gD2t5Cu1yuCXxbLcFtCzZGlfyVWWh8mLHkoxzjsB6DDNnvdL+fW8MiwPEJyGJQDgQ==} - engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0} - - '@typescript-eslint/typescript-estree@5.61.0': - resolution: {integrity: sha512-Fud90PxONnnLZ36oR5ClJBLTLfU4pIWBmnvGwTbEa2cXIqj70AEDEmOmpkFComjBZ/037ueKrOdHuYmSFVD7Rw==} - engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0} - peerDependencies: - typescript: '*' - peerDependenciesMeta: - typescript: - optional: true - - '@typescript-eslint/typescript-estree@5.62.0': - resolution: {integrity: sha512-CmcQ6uY7b9y694lKdRB8FEel7JbU/40iSAPomu++SjLMntB+2Leay2LO6i8VnJk58MtE9/nQSFIH6jpyRWyYzA==} - engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0} - peerDependencies: - typescript: '*' - peerDependenciesMeta: - typescript: - optional: true - - '@typescript-eslint/utils@5.61.0': - resolution: {integrity: sha512-mV6O+6VgQmVE6+xzlA91xifndPW9ElFW8vbSF0xCT/czPXVhwDewKila1jOyRwa9AE19zKnrr7Cg5S3pJVrTWQ==} - engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0} - peerDependencies: - eslint: ^6.0.0 || ^7.0.0 || ^8.0.0 - - '@typescript-eslint/utils@5.62.0': - resolution: {integrity: sha512-n8oxjeb5aIbPFEtmQxQYOLI0i9n5ySBEY/ZEHHZqKQSFnxio1rv6dthascc9dLuwrL0RC5mPCxB7vnAVGAYWAQ==} - engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0} - peerDependencies: - eslint: ^6.0.0 || ^7.0.0 || ^8.0.0 - - '@typescript-eslint/visitor-keys@5.61.0': - resolution: {integrity: sha512-50XQ5VdbWrX06mQXhy93WywSFZZGsv3EOjq+lqp6WC2t+j3mb6A9xYVdrRxafvK88vg9k9u+CT4l6D8PEatjKg==} - engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0} - - '@typescript-eslint/visitor-keys@5.62.0': - resolution: {integrity: sha512-07ny+LHRzQXepkGg6w0mFY41fVUNBrL2Roj/++7V1txKugfjm/Ci/qSND03r2RhlJhJYMcTn9AhhSSqQp0Ysyw==} - engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0} - - '@ungap/structured-clone@1.2.0': - resolution: {integrity: sha512-zuVdFrMJiuCDQUMCzQaD6KL28MjnqqN8XnAqiEq9PNm/hCPTSGfrXCOfwj1ow4LFb/tNymJPwsNbVePc1xFqrQ==} - - abbrev@1.0.9: - resolution: {integrity: sha512-LEyx4aLEC3x6T0UguF6YILf+ntvmOaWsVfENmIW0E9H09vKlLDGelMjjSm0jkDHALj8A8quZ/HapKNigzwge+Q==} - - abitype@0.7.1: - resolution: {integrity: sha512-VBkRHTDZf9Myaek/dO3yMmOzB/y2s3Zo6nVU7yaw1G+TvCHAjwaJzNGN9yo4K5D8bU/VZXKP1EJpRhFr862PlQ==} - peerDependencies: - typescript: '>=4.9.4' - zod: ^3 >=3.19.1 - peerDependenciesMeta: - zod: - optional: true - - abitype@0.9.10: - resolution: {integrity: sha512-FIS7U4n7qwAT58KibwYig5iFG4K61rbhAqaQh/UWj8v1Y8mjX3F8TC9gd8cz9yT1TYel9f8nS5NO5kZp2RW0jQ==} - peerDependencies: - typescript: '>=5.0.4' - zod: ^3 >=3.22.0 - peerDependenciesMeta: - typescript: - optional: true - zod: - optional: true - - abitype@1.0.0: - resolution: {integrity: sha512-NMeMah//6bJ56H5XRj8QCV4AwuW6hB6zqz2LnhhLdcWVQOsXki6/Pn3APeqxCma62nXIcmZWdu1DlHWS74umVQ==} - peerDependencies: - typescript: '>=5.0.4' - zod: ^3 >=3.22.0 - peerDependenciesMeta: - typescript: - optional: true - zod: - optional: true - - abortcontroller-polyfill@1.7.5: - resolution: {integrity: sha512-JMJ5soJWP18htbbxJjG7bG6yuI6pRhgJ0scHHTfkUjf6wjP912xZWvM+A4sJK3gqd9E8fcPbDnOefbA9Th/FIQ==} - - accepts@1.3.8: - resolution: {integrity: sha512-PYAthTa2m2VKxuvSD3DPC/Gy+U+sOA1LAuT8mkmRuvw+NACSaeXEQ+NHcVF7rONl6qcaxV3Uuemwawk+7+SJLw==} - engines: {node: '>= 0.6'} - - acorn-jsx@5.3.2: - resolution: {integrity: sha512-rq9s+JNhf0IChjtDXxllJ7g41oZk5SlXtp0LHwyA5cejwn7vKmKp4pPri6YEePv2PU65sAsegbXtIinmDFDXgQ==} - peerDependencies: - acorn: ^6.0.0 || ^7.0.0 || ^8.0.0 - - acorn-walk@8.3.2: - resolution: {integrity: sha512-cjkyv4OtNCIeqhHrfS81QWXoCBPExR/J62oyEqepVw8WaQeSqpW2uhuLPh1m9eWhDuOo/jUXVTlifvesOWp/4A==} - engines: {node: '>=0.4.0'} - - acorn@8.11.3: - resolution: {integrity: sha512-Y9rRfJG5jcKOE0CLisYbojUjIrIEE7AGMzA/Sm4BslANhbS+cDMpgBdcPT91oJ7OuJ9hYJBx59RjbhxVnrF8Xg==} - engines: {node: '>=0.4.0'} - hasBin: true - - address@1.2.2: - resolution: {integrity: sha512-4B/qKCfeE/ODUaAUpSwfzazo5x29WD4r3vXiWsB7I2mSDAihwEqKO+g8GELZUQSSAo5e1XTYh3ZVfLyxBc12nA==} - engines: {node: '>= 10.0.0'} - - adm-zip@0.4.16: - resolution: {integrity: sha512-TFi4HBKSGfIKsK5YCkKaaFG2m4PEDyViZmEwof3MTIgzimHLto6muaHVpbrljdIvIrFZzEq/p4nafOeLcYegrg==} - engines: {node: '>=0.3.0'} - - aes-js@3.0.0: - resolution: {integrity: sha512-H7wUZRn8WpTq9jocdxQ2c8x2sKo9ZVmzfRE13GiNJXfp7NcKYEdvl3vspKjXox6RIG2VtaRe4JFvxG4rqp2Zuw==} - - aes-js@4.0.0-beta.5: - resolution: {integrity: sha512-G965FqalsNyrPqgEGON7nIx1e/OVENSgiEIzyC63haUMuvNnwIgIjMs52hlTCKhkBny7A2ORNlfY9Zu+jmGk1Q==} - - agent-base@6.0.2: - resolution: {integrity: sha512-RZNwNclF7+MS/8bDg70amg32dyeZGZxiDuQmZxKLAlQjr3jGyLx+4Kkk58UO7D2QdgFIQCovuSuZESne6RG6XQ==} - engines: {node: '>= 6.0.0'} - - aggregate-error@3.1.0: - resolution: {integrity: sha512-4I7Td01quW/RpocfNayFdFVk1qSuoh0E7JrbRJ16nH01HhKFQ88INq9Sd+nd72zqRySlr9BmDA8xlEJ6vJMrYA==} - engines: {node: '>=8'} - - ajv@5.5.2: - resolution: {integrity: sha512-Ajr4IcMXq/2QmMkEmSvxqfLN5zGmJ92gHXAeOXq1OekoH2rfDNsgdDoL2f7QaRCy7G/E6TpxBVdRuNraMztGHw==} - - ajv@6.12.6: - resolution: {integrity: sha512-j3fVLgvTo527anyYyJOGTYJbG+vnnQYvE0m5mmkc1TK+nxAppkCLMIL0aZ4dblVCNoGShhm+kzE4ZUykBoMg4g==} - - ajv@8.13.0: - resolution: {integrity: sha512-PRA911Blj99jR5RMeTunVbNXMF6Lp4vZXnk5GQjcnUWUTsrXtekg/pnmFFI2u/I36Y/2bITGS30GZCXei6uNkA==} - - amdefine@1.0.1: - resolution: {integrity: sha512-S2Hw0TtNkMJhIabBwIojKL9YHO5T0n5eNqWJ7Lrlel/zDbftQpxpapi8tZs3X1HWa+u+QeydGmzzNU0m09+Rcg==} - engines: {node: '>=0.4.2'} - - ansi-align@3.0.1: - resolution: {integrity: sha512-IOfwwBF5iczOjp/WeY4YxyjqAFMQoZufdQWDd19SEExbVLNXqvpzSJ/M7Za4/sCPmQ0+GRquoA7bGcINcxew6w==} - - ansi-colors@4.1.1: - resolution: {integrity: sha512-JoX0apGbHaUJBNl6yF+p6JAFYZ666/hhCGKN5t9QFjbJQKUU/g8MNbFDbvfrgKXvI1QpZplPOnwIo99lX/AAmA==} - engines: {node: '>=6'} - - ansi-colors@4.1.3: - resolution: {integrity: sha512-/6w/C21Pm1A7aZitlI5Ni/2J6FFQN8i1Cvz3kHABAAbw93v/NlvKdVOqz7CCWz/3iv/JplRSEEZ83XION15ovw==} - engines: {node: '>=6'} - - ansi-escapes@4.3.2: - resolution: {integrity: sha512-gKXj5ALrKWQLsYG9jlTRmR/xKluxHV+Z9QEwNIgCfM1/uwPMCuzVVnh5mwTd+OuBZcwSIMbqssNWRm1lE51QaQ==} - engines: {node: '>=8'} - - ansi-regex@2.1.1: - resolution: {integrity: sha512-TIGnTpdo+E3+pCyAluZvtED5p5wCqLdezCyhPZzKPcxvFplEt4i+W7OONCKgeZFT3+y5NZZfOOS/Bdcanm1MYA==} - engines: {node: '>=0.10.0'} - - ansi-regex@3.0.1: - resolution: {integrity: sha512-+O9Jct8wf++lXxxFc4hc8LsjaSq0HFzzL7cVsw8pRDIPdjKD2mT4ytDZlLuSBZ4cLKZFXIrMGO7DbQCtMJJMKw==} - engines: {node: '>=4'} - - ansi-regex@5.0.1: - resolution: {integrity: sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ==} - engines: {node: '>=8'} - - ansi-styles@1.0.0: - resolution: {integrity: sha512-3iF4FIKdxaVYT3JqQuY3Wat/T2t7TRbbQ94Fu50ZUCbLy4TFbTzr90NOHQodQkNqmeEGCw8WbeP78WNi6SKYUA==} - engines: {node: '>=0.8.0'} - - ansi-styles@3.2.1: - resolution: {integrity: sha512-VT0ZI6kZRdTh8YyJw3SMbYm/u+NqfsAxEpWO0Pf9sq8/e94WxxOpPKx9FR1FlyCtOVDNOQ+8ntlqFxiRc+r5qA==} - engines: {node: '>=4'} - - ansi-styles@4.3.0: - resolution: {integrity: sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==} - engines: {node: '>=8'} - - ansi-styles@5.2.0: - resolution: {integrity: sha512-Cxwpt2SfTzTtXcfOlzGEee8O+c+MmUgGrNiBcXnuWxuFJHe6a5Hz7qwhwe5OgaSYI0IJvkLqWX1ASG+cJOkEiA==} - engines: {node: '>=10'} - - antlr4@4.13.1: - resolution: {integrity: sha512-kiXTspaRYvnIArgE97z5YVVf/cDVQABr3abFRR6mE7yesLMkgu4ujuyV/sgxafQ8wgve0DJQUJ38Z8tkgA2izA==} - engines: {node: '>=16'} - - antlr4@4.8.0: - resolution: {integrity: sha512-en/MxQ4OkPgGJQ3wD/muzj1uDnFSzdFIhc2+c6bHZokWkuBb6RRvFjpWhPxWLbgQvaEzldJZ0GSQpfSAaE3hqg==} - - antlr4ts@0.5.0-alpha.4: - resolution: {integrity: sha512-WPQDt1B74OfPv/IMS2ekXAKkTZIHl88uMetg6q3OTqgFxZ/dxDXI0EWLyZid/1Pe6hTftyg5N7gel5wNAGxXyQ==} - - any-promise@1.3.0: - resolution: {integrity: sha512-7UvmKalWRt1wgjL1RrGxoSJW/0QZFIegpeGvZG9kjp8vrRu55XTHbwnqq2GpXm9uLbcuhxm3IqX9OB4MZR1b2A==} - - anymatch@3.1.3: - resolution: {integrity: sha512-KMReFUr0B4t+D+OBkjR3KYqvocp2XaSzO55UcB6mgQMd3KbcE+mWTyvVV7D/zsdEbNnV6acZUutkiHQXvTr1Rw==} - engines: {node: '>= 8'} - - append-transform@2.0.0: - resolution: {integrity: sha512-7yeyCEurROLQJFv5Xj4lEGTy0borxepjFv1g22oAdqFu//SrAlDl1O1Nxx15SH1RoliUml6p8dwJW9jvZughhg==} - engines: {node: '>=8'} - - archy@1.0.0: - resolution: {integrity: sha512-Xg+9RwCg/0p32teKdGMPTPnVXKD0w3DfHnFTficozsAgsvq2XenPJq/MYpzzQ/v8zrOyJn6Ds39VA4JIDwFfqw==} - - arg@4.1.3: - resolution: {integrity: sha512-58S9QDqG0Xx27YwPSt9fJxivjYl432YCwfDMfZ+71RAqUrZef7LrKQZ3LHLOwCS4FLNBplP533Zx895SeOCHvA==} - - argparse@1.0.10: - resolution: {integrity: sha512-o5Roy6tNG4SL/FOkCAN6RzjiakZS25RLYFrcMttJqbdd8BWrnA+fGz57iN5Pb06pvBGvl5gQ0B48dJlslXvoTg==} - - argparse@2.0.1: - resolution: {integrity: sha512-8+9WqebbFzpX9OR+Wa6O29asIogeRMzcGtAINdpMHHyAg10f05aSFVBbcEqGf/PXw1EjAZ+q2/bEBg3DvurK3Q==} - - array-back@3.1.0: - resolution: {integrity: sha512-TkuxA4UCOvxuDK6NZYXCalszEzj+TLszyASooky+i742l9TqsOdYCMJJupxRic61hwquNtppB3hgcuq9SVSH1Q==} - engines: {node: '>=6'} - - array-back@4.0.2: - resolution: {integrity: sha512-NbdMezxqf94cnNfWLL7V/im0Ub+Anbb0IoZhvzie8+4HJ4nMQuzHuy49FkGYCJK2yAloZ3meiB6AVMClbrI1vg==} - engines: {node: '>=8'} - - array-buffer-byte-length@1.0.1: - resolution: {integrity: sha512-ahC5W1xgou+KTXix4sAO8Ki12Q+jf4i0+tmk3sC+zgcynshkHxzpXdImBehiUYKKKDwvfFiJl1tZt6ewscS1Mg==} - engines: {node: '>= 0.4'} - - array-flatten@1.1.1: - resolution: {integrity: sha512-PCVAQswWemu6UdxsDFFX/+gVeYqKAod3D3UVm91jHwynguOwAvYPhx8nNlM++NqRcK6CxxpUafjmhIdKiHibqg==} - - array-includes@3.1.8: - resolution: {integrity: sha512-itaWrbYbqpGXkGhZPGUulwnhVf5Hpy1xiCFsGqyIGglbBxmG5vSjxQen3/WGOjPpNEv1RtBLKxbmVXm8HpJStQ==} - engines: {node: '>= 0.4'} - - array-union@2.1.0: - resolution: {integrity: sha512-HGyxoOTYUyCM6stUe6EJgnd4EoewAI7zMdfqO+kGjnlZmBDz/cR5pf8r/cR4Wq60sL/p0IkcjUEEPwS3GFrIyw==} - engines: {node: '>=8'} - - array-uniq@1.0.3: - resolution: {integrity: sha512-MNha4BWQ6JbwhFhj03YK552f7cb3AzoE8SzeljgChvL1dl3IcvggXVz1DilzySZkCja+CXuZbdW7yATchWn8/Q==} - engines: {node: '>=0.10.0'} - - array.prototype.flat@1.3.2: - resolution: {integrity: sha512-djYB+Zx2vLewY8RWlNCUdHjDXs2XOgm602S9E7P/UpHgfeHL00cRiIF+IN/G/aUJ7kGPb6yO/ErDI5V2s8iycA==} - engines: {node: '>= 0.4'} - - array.prototype.flatmap@1.3.2: - resolution: {integrity: sha512-Ewyx0c9PmpcsByhSW4r+9zDU7sGjFc86qf/kKtuSCRdhfbk0SNLLkaT5qvcHnRGgc5NP/ly/y+qkXkqONX54CQ==} - engines: {node: '>= 0.4'} - - arraybuffer.prototype.slice@1.0.3: - resolution: {integrity: sha512-bMxMKAjg13EBSVscxTaYA4mRc5t1UAXa2kXiGTNfZ079HIWXEkKmkgFrh/nJqamaLSrXO5H4WFFkPEaLJWbs3A==} - engines: {node: '>= 0.4'} - - arrify@1.0.1: - resolution: {integrity: sha512-3CYzex9M9FGQjCGMGyi6/31c8GJbgb0qGyrx5HWxPd0aCwh4cB2YjMb2Xf9UuoogrMrlO9cTqnB5rI5GHZTcUA==} - engines: {node: '>=0.10.0'} - - asap@2.0.6: - resolution: {integrity: sha512-BSHWgDSAiKs50o2Re8ppvp3seVHXSRM44cdSsT9FfNEUUZLOGWVCsiWaRPWM1Znn+mqZ1OfVZ3z3DWEzSp7hRA==} - - asn1@0.2.6: - resolution: {integrity: sha512-ix/FxPn0MDjeyJ7i/yoHGFt/EX6LyNbxSEhPPXODPL+KB0VPk86UYfL0lMdy+KCnv+fmvIzySwaK5COwqVbWTQ==} - - assert-plus@1.0.0: - resolution: {integrity: sha512-NfJ4UzBCcQGLDlQq7nHxH+tv3kyZ0hHQqF5BO6J7tNJeP5do1llPr8dZ8zHonfhAu0PHAdMkSo+8o0wxg9lZWw==} - engines: {node: '>=0.8'} - - assertion-error@1.1.0: - resolution: {integrity: sha512-jgsaNduz+ndvGyFt3uSuWqvy4lCnIJiovtouQN5JZHOKCS2QuhEdbcQHFhVksz2N2U9hXJo8odG7ETyWlEeuDw==} - - ast-parents@0.0.1: - resolution: {integrity: sha512-XHusKxKz3zoYk1ic8Un640joHbFMhbqneyoZfoKnEGtf2ey9Uh/IdpcQplODdO/kENaMIWsD0nJm4+wX3UNLHA==} - - astral-regex@2.0.0: - resolution: {integrity: sha512-Z7tMw1ytTXt5jqMcOP+OQteU1VuNK9Y02uuJtKQ1Sv69jXQKKg5cibLwGJow8yzZP+eAc18EmLGPal0bp36rvQ==} - engines: {node: '>=8'} - - async-limiter@1.0.1: - resolution: {integrity: sha512-csOlWGAcRFJaI6m+F2WKdnMKr4HhdhFVBk0H/QbJFMCr+uO2kwohwXQPxw/9OCxp05r5ghVBFSyioixx3gfkNQ==} - - async@1.5.2: - resolution: {integrity: sha512-nSVgobk4rv61R9PUSDtYt7mPVB2olxNR5RWJcAsH676/ef11bUZwvu7+RGYrYauVdDPcO519v68wRhXQtxsV9w==} - - asynckit@0.4.0: - resolution: {integrity: sha512-Oei9OH4tRh0YqU3GxhX79dM/mwVgvbZJaSNaRk+bshkj0S5cfHcgYakreBjrHwatXKbz+IoIdYLxrKim2MjW0Q==} - - at-least-node@1.0.0: - resolution: {integrity: sha512-+q/t7Ekv1EDY2l6Gda6LLiX14rU9TV20Wa3ofeQmwPFZbOMo9DXrLbOjFaaclkXKWidIaopwAObQDqwWtGUjqg==} - engines: {node: '>= 4.0.0'} - - available-typed-arrays@1.0.7: - resolution: {integrity: sha512-wvUjBtSGN7+7SjNpq/9M2Tg350UZD3q62IFZLbRAR1bSMlCo1ZaeW+BJ+D090e4hIIZLBcTDWe4Mh4jvUDajzQ==} - engines: {node: '>= 0.4'} - - aws-sign2@0.7.0: - resolution: {integrity: sha512-08kcGqnYf/YmjoRhfxyu+CLxBjUtHLXLXX/vUfx9l2LYzG3c1m61nrpyFUZI6zeS+Li/wWMMidD9KgrqtGq3mA==} - - aws4@1.12.0: - resolution: {integrity: sha512-NmWvPnx0F1SfrQbYwOi7OeaNGokp9XhzNioJ/CSBs8Qa4vxug81mhJEAVZwxXuBmYB5KDRfMq/F3RR0BIU7sWg==} - - axios@0.21.4: - resolution: {integrity: sha512-ut5vewkiu8jjGBdqpM44XxjuCjq9LAKeHVmoVfHVzy8eHgxxq8SbAVQNovDA8mVi05kP0Ea/n/UzcSHcTJQfNg==} - - axios@1.6.8: - resolution: {integrity: sha512-v/ZHtJDU39mDpyBoFVkETcd/uNdxrWRrg3bKpOKzXFA6Bvqopts6ALSMU3y6ijYxbw2B+wPrIv46egTzJXCLGQ==} - - balanced-match@1.0.2: - resolution: {integrity: sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw==} - - base-x@3.0.9: - resolution: {integrity: sha512-H7JU6iBHTal1gp56aKoaa//YUxEaAOUiydvrV/pILqIHXTtqxSkATOnDA2u+jZ/61sD+L/412+7kzXRtWukhpQ==} - - base64-js@1.5.1: - resolution: {integrity: sha512-AKpaYlHn8t4SVbOHCy+b5+KKgvR4vrsD8vbvrbiQJps7fKDTkjkDry6ji0rUJjC0kzbNePLwzxq8iypo41qeWA==} - - bcrypt-pbkdf@1.0.2: - resolution: {integrity: sha512-qeFIXtP4MSoi6NLqO12WfqARWWuCKi2Rn/9hJLEmtB5yTNr9DqFWkJRCf2qShWzPeAMRnOgCrq0sg/KLv5ES9w==} - - bech32@1.1.4: - resolution: {integrity: sha512-s0IrSOzLlbvX7yp4WBfPITzpAU8sqQcpsmwXDiKwrG4r491vwCO/XpejasRNl0piBMe/DvP4Tz0mIS/X1DPJBQ==} - - better-path-resolve@1.0.0: - resolution: {integrity: sha512-pbnl5XzGBdrFU/wT4jqmJVPn2B6UHPBOhzMQkY/SPUPB6QtUXtmBHBIwCbXJol93mOpGMnQyP/+BB19q04xj7g==} - engines: {node: '>=4'} - - big-integer@1.6.36: - resolution: {integrity: sha512-t70bfa7HYEA1D9idDbmuv7YbsbVkQ+Hp+8KFSul4aE5e/i1bjCNIRYJZlA8Q8p0r9T8cF/RVvwUgRA//FydEyg==} - engines: {node: '>=0.6'} - - big.js@6.2.1: - resolution: {integrity: sha512-bCtHMwL9LeDIozFn+oNhhFoq+yQ3BNdnsLSASUxLciOb1vgvpHsIO1dsENiGMgbb4SkP5TrzWzRiLddn8ahVOQ==} - - bignumber.js@7.2.1: - resolution: {integrity: sha512-S4XzBk5sMB+Rcb/LNcpzXr57VRTxgAvaAEDAl1AwRx27j00hT84O6OkteE7u8UB3NuaaygCRrEpqox4uDOrbdQ==} - - bignumber.js@9.1.2: - resolution: {integrity: sha512-2/mKyZH9K85bzOEfhXDBFZTGd1CTs+5IHpeFQo9luiBG7hghdC851Pj2WAhb6E3R6b9tZj/XKhbg4fum+Kepug==} - - bignumber.js@https://codeload.github.com/frozeman/bignumber.js-nolookahead/tar.gz/57692b3ecfc98bbdd6b3a516cb2353652ea49934: - resolution: {tarball: https://codeload.github.com/frozeman/bignumber.js-nolookahead/tar.gz/57692b3ecfc98bbdd6b3a516cb2353652ea49934} - version: 2.0.7 - - binary-extensions@2.3.0: - resolution: {integrity: sha512-Ceh+7ox5qe7LJuLHoY0feh3pHuUDHAcRUeyL2VYghZwfpkNIy/+8Ocg0a3UuSoYzavmylwuLWQOf3hl0jjMMIw==} - engines: {node: '>=8'} - - bindings@1.5.0: - resolution: {integrity: sha512-p2q/t/mhvuOj/UeLlV6566GD/guowlr0hHxClI0W9m7MWYkL1F0hLo+0Aexs9HSPCtR1SXQ0TD3MMKrXZajbiQ==} - - bl@4.1.0: - resolution: {integrity: sha512-1W07cM9gS6DcLperZfFSj+bWLtaPGSOHWhPiGzXmvVJbRLdG82sH/Kn8EtW1VqWVA54AKf2h5k5BbnIbwF3h6w==} - - blakejs@1.2.1: - resolution: {integrity: sha512-QXUSXI3QVc/gJME0dBpXrag1kbzOqCjCX8/b54ntNyW6sjtoqxqRk3LTmXzaJoh71zMsDCjM+47jS7XiwN/+fQ==} - - bluebird@3.7.2: - resolution: {integrity: sha512-XpNj6GDQzdfW+r2Wnn7xiSAd7TM3jzkxGXBGTtWKuSXv1xUV+azxAm8jdWZN06QTQk+2N2XB9jRDkvbmQmcRtg==} - - bn-str-256@1.9.1: - resolution: {integrity: sha512-u3muv3WO5sYv9nUQsPnDGLg731yNt/MOlKPK5pmBVqClcl7tY97tyfKxw8ed44HVrpi+7dkgJgQpbXP47a3GoQ==} - - bn.js@4.11.6: - resolution: {integrity: sha512-XWwnNNFCuuSQ0m3r3C4LE3EiORltHd9M05pq6FOlVeiophzRbMo50Sbz1ehl8K3Z+jw9+vmgnXefY1hz8X+2wA==} - - bn.js@4.12.0: - resolution: {integrity: sha512-c98Bf3tPniI+scsdk237ku1Dc3ujXQTSgyiPUDEOe7tRkhrqridvh8klBv0HCEso1OLOYcHuCv/cS6DNxKH+ZA==} - - bn.js@5.2.1: - resolution: {integrity: sha512-eXRvHzWyYPBuB4NBy0cmYQjGitUrtqwbvlzP3G6VFnNRbsZQIxQ10PbKKHt8gZ/HW/D/747aDl+QkDqg3KQLMQ==} - - body-parser@1.20.2: - resolution: {integrity: sha512-ml9pReCu3M61kGlqoTm2umSXTlRTuGTx0bfYj+uIUKKYycG5NtSbeetV3faSU6R7ajOPw0g/J1PvK4qNy7s5bA==} - engines: {node: '>= 0.8', npm: 1.2.8000 || >= 1.4.16} - - boolbase@1.0.0: - resolution: {integrity: sha512-JZOSA7Mo9sNGB8+UjSgzdLtokWAky1zbztM3WRLCbZ70/3cTANmQmOdR7y2g+J0e2WXywy1yS468tY+IruqEww==} - - boolean@3.2.0: - resolution: {integrity: sha512-d0II/GO9uf9lfUHH2BQsjxzRJZBdsjgsBiW4BvhWk/3qoKwQFjIDVN19PfX8F2D/r9PCMTtLWjYVCFrpeYUzsw==} - - boxen@5.1.2: - resolution: {integrity: sha512-9gYgQKXx+1nP8mP7CzFyaUARhg7D3n1dF/FnErWmu9l6JvGpNUN278h0aSb+QjoiKSWG+iZ3uHrcqk0qrY9RQQ==} - engines: {node: '>=10'} - - brace-expansion@1.1.11: - resolution: {integrity: sha512-iCuPHDFgrHX7H2vEI/5xpz07zSHB00TpugqhmYtVmMO6518mCuRMoOYFldEBl0g187ufozdaHgWKcYFb61qGiA==} - - brace-expansion@2.0.1: - resolution: {integrity: sha512-XnAIvQ8eM+kC6aULx6wuQiwVsnzsi9d3WxzV3FpWTGA19F621kwdbsAcFKXgKUHZWsy+mY6iL1sHTxWEFCytDA==} - - braces@3.0.2: - resolution: {integrity: sha512-b8um+L1RzM3WDSzvhm6gIz1yfTbBt6YTlcEKAvsmqCZZFw46z626lVj9j1yEPW33H5H+lBQpZMP1k8l+78Ha0A==} - engines: {node: '>=8'} - - breakword@1.0.6: - resolution: {integrity: sha512-yjxDAYyK/pBvws9H4xKYpLDpYKEH6CzrBPAuXq3x18I+c/2MkVtT3qAr7Oloi6Dss9qNhPVueAAVU1CSeNDIXw==} - - brorand@1.1.0: - resolution: {integrity: sha512-cKV8tMCEpQs4hK/ik71d6LrPOnpkpGBR0wzxqr68g2m/LB2GxVYQroAjMJZRVM1Y4BCjCKc3vAamxSzOY2RP+w==} - - browser-stdout@1.3.1: - resolution: {integrity: sha512-qhAVI1+Av2X7qelOfAIYwXONood6XlZE/fXaBSmW/T5SzLAmCgzi+eiWE7fUvbHaeNBQH13UftjpXxsfLkMpgw==} - - browserify-aes@1.2.0: - resolution: {integrity: sha512-+7CHXqGuspUn/Sl5aO7Ea0xWGAtETPXNSAjHo48JfLdPWcMng33Xe4znFvQweqc/uzk5zSOI3H52CYnjCfb5hA==} - - browserslist@4.23.0: - resolution: {integrity: sha512-QW8HiM1shhT2GuzkvklfjcKDiWFXHOeFCIA/huJPwHsslwcydgk7X+z2zXpEijP98UCY7HbubZt5J2Zgvf0CaQ==} - engines: {node: ^6 || ^7 || ^8 || ^9 || ^10 || ^11 || ^12 || >=13.7} - hasBin: true - - bs58@4.0.1: - resolution: {integrity: sha512-Ok3Wdf5vOIlBrgCvTq96gBkJw+JUEzdBgyaza5HLtPm7yTHkjRy8+JzNyHF7BHa0bNWOQIp3m5YF0nnFcOIKLw==} - - bs58check@2.1.2: - resolution: {integrity: sha512-0TS1jicxdU09dwJMNZtVAfzPi6Q6QeN0pM1Fkzrjn+XYHvzMKPU3pHVpva+769iNVSfIYWf7LJ6WR+BuuMf8cA==} - - buffer-from@1.1.2: - resolution: {integrity: sha512-E+XQCRwSbaaiChtv6k6Dwgc+bx+Bs6vuKJHHl5kox/BaKbhiXzqQOwK4cO22yElGp2OCmjwVhT3HmxgyPGnJfQ==} - - buffer-to-arraybuffer@0.0.5: - resolution: {integrity: sha512-3dthu5CYiVB1DEJp61FtApNnNndTckcqe4pFcLdvHtrpG+kcyekCJKg4MRiDcFW7A6AODnXB9U4dwQiCW5kzJQ==} - - buffer-xor@1.0.3: - resolution: {integrity: sha512-571s0T7nZWK6vB67HI5dyUF7wXiNcfaPPPTl6zYCNApANjIvYJTg7hlud/+cJpdAhS7dVzqMLmfhfHR3rAcOjQ==} - - buffer@5.7.1: - resolution: {integrity: sha512-EHcyIPBQ4BSGlvjB16k5KgAJ27CIsHY/2JBmCRReo48y9rQ3MaUzWX3KVlBa4U7MyX02HdVj0K7C3WaB3ju7FQ==} - - buffer@6.0.3: - resolution: {integrity: sha512-FTiCpNxtwiZZHEZbcbTIcZjERVICn9yq/pDFkTl95/AxzD1naBctN7YO68riM/gLSDY7sdrMby8hofADYuuqOA==} - - bufferutil@4.0.8: - resolution: {integrity: sha512-4T53u4PdgsXqKaIctwF8ifXlRTTmEPJ8iEPWFdGZvcf7sbwYo6FKFEX9eNNAnzFZ7EzJAQ3CJeOtCRA4rDp7Pw==} - engines: {node: '>=6.14.2'} - - builtin-modules@3.3.0: - resolution: {integrity: sha512-zhaCDicdLuWN5UbN5IMnFqNMhNfo919sH85y2/ea+5Yg9TsTkeZxpL+JLbp6cgYFS4sRLp3YV4S6yDuqVWHYOw==} - engines: {node: '>=6'} - - builtins@5.1.0: - resolution: {integrity: sha512-SW9lzGTLvWTP1AY8xeAMZimqDrIaSdLQUcVr9DMef51niJ022Ri87SwRRKYm4A6iHfkPaiVUu/Duw2Wc4J7kKg==} - - bytes@3.1.2: - resolution: {integrity: sha512-/Nf7TyzTx6S3yRJObOAV7956r8cr2+Oj8AC5dt8wSP3BQAoeX58NoHyCU8P8zGkNXStjTSi6fzO6F0pBdcYbEg==} - engines: {node: '>= 0.8'} - - cacheable-lookup@5.0.4: - resolution: {integrity: sha512-2/kNscPhpcxrOigMZzbiWF7dz8ilhb/nIHU3EyZiXWXpeq/au8qJ8VhdftMkty3n7Gj6HIGalQG8oiBNB3AJgA==} - engines: {node: '>=10.6.0'} - - cacheable-lookup@6.1.0: - resolution: {integrity: sha512-KJ/Dmo1lDDhmW2XDPMo+9oiy/CeqosPguPCrgcVzKyZrL6pM1gU2GmPY/xo6OQPTUaA/c0kwHuywB4E6nmT9ww==} - engines: {node: '>=10.6.0'} - - cacheable-request@7.0.4: - resolution: {integrity: sha512-v+p6ongsrp0yTGbJXjgxPow2+DL93DASP4kXCDKb8/bwRtt9OEF3whggkkDkGNzgcWy2XaF4a8nZglC7uElscg==} - engines: {node: '>=8'} - - caching-transform@4.0.0: - resolution: {integrity: sha512-kpqOvwXnjjN44D89K5ccQC+RUrsy7jB/XLlRrx0D7/2HNcTPqzsb6XgYoErwko6QsV184CA2YgS1fxDiiDZMWA==} - engines: {node: '>=8'} - - call-bind@1.0.7: - resolution: {integrity: sha512-GHTSNSYICQ7scH7sZ+M2rFopRoLh8t2bLSW6BbgrtLsahOIB5iyAVJf9GjWK3cYTDaMj4XdBpM1cA6pIS0Kv2w==} - engines: {node: '>= 0.4'} - - callsites@3.1.0: - resolution: {integrity: sha512-P8BjAsXvZS+VIDUI11hHCQEv74YT67YUi5JJFNWIqL235sBmjX4+qx9Muvls5ivyNENctx46xQLQ3aTuE7ssaQ==} - engines: {node: '>=6'} - - camel-case@3.0.0: - resolution: {integrity: sha512-+MbKztAYHXPr1jNTSKQF52VpcFjwY5RkR7fxksV8Doo4KAYc5Fl4UJRgthBbTmEx8C54DqahhbLJkDwjI3PI/w==} - - camelcase-keys@6.2.2: - resolution: {integrity: sha512-YrwaA0vEKazPBkn0ipTiMpSajYDSe+KjQfrjhcBMxJt/znbvlHd8Pw/Vamaz5EB4Wfhs3SUR3Z9mwRu/P3s3Yg==} - engines: {node: '>=8'} - - camelcase@3.0.0: - resolution: {integrity: sha512-4nhGqUkc4BqbBBB4Q6zLuD7lzzrHYrjKGeYaEji/3tFR5VdJu9v+LilhGIVe8wxEJPPOeWo7eg8dwY13TZ1BNg==} - engines: {node: '>=0.10.0'} - - camelcase@4.1.0: - resolution: {integrity: sha512-FxAv7HpHrXbh3aPo4o2qxHay2lkLY3x5Mw3KeE4KQE8ysVfziWeRZDwcjauvwBSGEC/nXUPzZy8zeh4HokqOnw==} - engines: {node: '>=4'} - - camelcase@5.3.1: - resolution: {integrity: sha512-L28STB170nwWS63UjtlEOE3dldQApaJXZkOI1uMFfzf3rRuPegHaHesyee+YxQ+W6SvRDQV6UrdOdRiR153wJg==} - engines: {node: '>=6'} - - camelcase@6.3.0: - resolution: {integrity: sha512-Gmy6FhYlCY7uOElZUSbxo2UCDH8owEk996gkbrpsgGtrJLM3J7jGxl9Ic7Qwwj4ivOE5AWZWRMecDdF7hqGjFA==} - engines: {node: '>=10'} - - caniuse-lite@1.0.30001617: - resolution: {integrity: sha512-mLyjzNI9I+Pix8zwcrpxEbGlfqOkF9kM3ptzmKNw5tizSyYwMe+nGLTqMK9cO+0E+Bh6TsBxNAaHWEM8xwSsmA==} - - caseless@0.12.0: - resolution: {integrity: sha512-4tYFyifaFfGacoiObjJegolkwSU4xQNGbVgUiNYVUxbQ2x2lUsFvY4hVgVzGiIe6WLOPqycWXA40l+PWsxthUw==} - - cbor@5.2.0: - resolution: {integrity: sha512-5IMhi9e1QU76ppa5/ajP1BmMWZ2FHkhAhjeVKQ/EFCgYSEaeVaoGtL7cxJskf9oCCk+XjzaIdc3IuU/dbA/o2A==} - engines: {node: '>=6.0.0'} - - cbor@8.1.0: - resolution: {integrity: sha512-DwGjNW9omn6EwP70aXsn7FQJx5kO12tX0bZkaTjzdVFM6/7nhA4t0EENocKGx6D2Bch9PE2KzCUf5SceBdeijg==} - engines: {node: '>=12.19'} - - cbor@9.0.2: - resolution: {integrity: sha512-JPypkxsB10s9QOWwa6zwPzqE1Md3vqpPc+cai4sAecuCsRyAtAl/pMyhPlMbT/xtPnm2dznJZYRLui57qiRhaQ==} - engines: {node: '>=16'} - - chai-as-promised@7.1.1: - resolution: {integrity: sha512-azL6xMoi+uxu6z4rhWQ1jbdUhOMhis2PvscD/xjLqNMkv3BPPp2JyyuTHOrf9BOosGpNQ11v6BKv/g57RXbiaA==} - peerDependencies: - chai: '>= 2.1.2 < 5' - - chai@4.4.1: - resolution: {integrity: sha512-13sOfMv2+DWduEU+/xbun3LScLoqN17nBeTLUsmDfKdoiC1fr0n9PU4guu4AhRcOVFk/sW8LyZWHuhWtQZiF+g==} - engines: {node: '>=4'} - - chalk@0.4.0: - resolution: {integrity: sha512-sQfYDlfv2DGVtjdoQqxS0cEZDroyG8h6TamA6rvxwlrU5BaSLDx9xhatBYl2pxZ7gmpNaPFVwBtdGdu5rQ+tYQ==} - engines: {node: '>=0.8.0'} - - chalk@2.4.2: - resolution: {integrity: sha512-Mti+f9lpJNcwF4tWV8/OrTTtF1gZi+f8FqlyAdouralcFWFQWF2+NgCHShjkCb+IFBLq9buZwE1xckQU4peSuQ==} - engines: {node: '>=4'} - - chalk@4.1.2: - resolution: {integrity: sha512-oKnbhFyRIXpUuez8iBMmyEa4nbj4IOQyuhc/wy9kY7/WVPcwIO9VA668Pu8RkO7+0G76SLROeyw9CpQ061i4mA==} - engines: {node: '>=10'} - - change-case@3.0.2: - resolution: {integrity: sha512-Mww+SLF6MZ0U6kdg11algyKd5BARbyM4TbFBepwowYSR5ClfQGCGtxNXgykpN0uF/bstWeaGDT4JWaDh8zWAHA==} - - chardet@0.7.0: - resolution: {integrity: sha512-mT8iDcrh03qDGRRmoA2hmBJnxpllMR+0/0qlzjqZES6NdiWDcZkCNAk4rPFZ9Q85r27unkiNNg8ZOiwZXBHwcA==} - - charenc@0.0.2: - resolution: {integrity: sha512-yrLQ/yVUFXkzg7EDQsPieE/53+0RlaWTs+wBrvW36cyilJ2SaDWfl4Yj7MtLTXleV9uEKefbAGUPv2/iWSooRA==} - - check-error@1.0.3: - resolution: {integrity: sha512-iKEoDYaRmd1mxM90a2OEfWhjsjPpYPuQ+lMYsoxB126+t8fw7ySEO48nmDg5COTjxDI65/Y2OWpeEHk3ZOe8zg==} - - cheerio-select@2.1.0: - resolution: {integrity: sha512-9v9kG0LvzrlcungtnJtpGNxY+fzECQKhK4EGJX2vByejiMX84MFNQw4UxPJl3bFbTMw+Dfs37XaIkCwTZfLh4g==} - - cheerio@1.0.0-rc.12: - resolution: {integrity: sha512-VqR8m68vM46BNnuZ5NtnGBKIE/DfN0cRIzg9n40EIq9NOv90ayxLBXA8fXC5gquFRGJSTRqBq25Jt2ECLR431Q==} - engines: {node: '>= 6'} - - chokidar@3.5.3: - resolution: {integrity: sha512-Dr3sfKRP6oTcjf2JmUmFJfeVMvXBdegxB0iVQ5eb2V10uFJUCAS8OByZdVAyVb8xXNz3GjjTgj9kLWsZTqE6kw==} - engines: {node: '>= 8.10.0'} - - chokidar@3.6.0: - resolution: {integrity: sha512-7VT13fmjotKpGipCW9JEQAusEPE+Ei8nl6/g4FBAmIm0GOOLMua9NDDo/DWp0ZAxCr3cPq5ZpBqmPAQgDda2Pw==} - engines: {node: '>= 8.10.0'} - - chownr@1.1.4: - resolution: {integrity: sha512-jJ0bqzaylmJtVnNgzTeSOs8DPavpbYgEr/b0YL8/2GO3xJEhInFmhKMUnEJQjZumK7KXGFhUy89PrsJWlakBVg==} - - ci-info@2.0.0: - resolution: {integrity: sha512-5tK7EtrZ0N+OLFMthtqOj4fI2Jeb88C4CAZPu25LDVUgXJ0A3Js4PMGqrn0JU1W0Mh1/Z8wZzYPxqUrXeBboCQ==} - - ci-info@3.9.0: - resolution: {integrity: sha512-NIxF55hv4nSqQswkAeiOi1r83xy8JldOFDTWiug55KBu9Jnblncd2U6ViHmYgHf01TPZS77NJBhBMKdWj9HQMQ==} - engines: {node: '>=8'} - - cids@0.7.5: - resolution: {integrity: sha512-zT7mPeghoWAu+ppn8+BS1tQ5qGmbMfB4AregnQjA/qHY3GC1m1ptI9GkWNlgeu38r7CuRdXB47uY2XgAYt6QVA==} - engines: {node: '>=4.0.0', npm: '>=3.0.0'} - deprecated: This module has been superseded by the multiformats module - - cipher-base@1.0.4: - resolution: {integrity: sha512-Kkht5ye6ZGmwv40uUDZztayT2ThLQGfnj/T71N/XzeZeo3nf8foyW7zGTsPYkEya3m5f3cAypH+qe7YOrM1U2Q==} - - class-is@1.1.0: - resolution: {integrity: sha512-rhjH9AG1fvabIDoGRVH587413LPjTZgmDF9fOFCbFJQV4yuocX1mHxxvXI4g3cGwbVY9wAYIoKlg1N79frJKQw==} - - clean-stack@2.2.0: - resolution: {integrity: sha512-4diC9HaTE+KRAMWhDhrGOECgWZxoevMc5TlkObMqNSsVU62PYzXZ/SMTjzyGAFF1YusgxGcSWTEXBhp0CPwQ1A==} - engines: {node: '>=6'} - - cli-boxes@2.2.1: - resolution: {integrity: sha512-y4coMcylgSCdVinjiDBuR8PCC2bLjyGTwEmPb9NHR/QaNU6EUOXcTY/s6VjGMD6ENSEaeQYHCY0GNGS5jfMwPw==} - engines: {node: '>=6'} - - cli-cursor@3.1.0: - resolution: {integrity: sha512-I/zHAwsKf9FqGoXM4WWRACob9+SNukZTd94DWF57E4toouRulbCxcUh6RKUEOQlYTHJnzkPMySvPNaaSLNfLZw==} - engines: {node: '>=8'} - - cli-spinners@2.9.2: - resolution: {integrity: sha512-ywqV+5MmyL4E7ybXgKys4DugZbX0FC6LnwrhjuykIjnK9k8OQacQ7axGKnjDXWNhns0xot3bZI5h55H8yo9cJg==} - engines: {node: '>=6'} - - cli-table3@0.5.1: - resolution: {integrity: sha512-7Qg2Jrep1S/+Q3EceiZtQcDPWxhAvBw+ERf1162v4sikJrvojMHFqXt8QIVha8UlH9rgU0BeWPytZ9/TzYqlUw==} - engines: {node: '>=6'} - - cliui@3.2.0: - resolution: {integrity: sha512-0yayqDxWQbqk3ojkYqUKqaAQ6AfNKeKWRNA8kR0WXzAsdHpP4BIaOmMAG87JGuO6qcobyW4GjxHd9PmhEd+T9w==} - - cliui@6.0.0: - resolution: {integrity: sha512-t6wbgtoCXvAzst7QgXxJYqPt0usEfbgQdftEPbLL/cvv6HPE5VgvqCuAIDR0NgU52ds6rFwqrgakNLrHEjCbrQ==} - - cliui@7.0.4: - resolution: {integrity: sha512-OcRE68cOsVMXp1Yvonl/fzkQOyjLSu/8bhPDfQt0e0/Eb283TKP20Fs2MqoPsr9SwA595rRCA+QMzYc9nBP+JQ==} - - cliui@8.0.1: - resolution: {integrity: sha512-BSeNnyus75C4//NQ9gQt1/csTXyo/8Sb+afLAkzAptFuMsod9HFokGNudZpi/oQV73hnVK+sR+5PVRMd+Dr7YQ==} - engines: {node: '>=12'} - - clone-response@1.0.3: - resolution: {integrity: sha512-ROoL94jJH2dUVML2Y/5PEDNaSHgeOdSDicUyS7izcF63G6sTc/FTjLub4b8Il9S8S0beOfYt0TaA5qvFK+w0wA==} - - clone@1.0.4: - resolution: {integrity: sha512-JQHZ2QMW6l3aH/j6xCqQThY/9OH4D/9ls34cgkUBiEeocRTU04tHfKPBsUK1PqZCUQM7GiA0IIXJSuXHI64Kbg==} - engines: {node: '>=0.8'} - - co@4.6.0: - resolution: {integrity: sha512-QVb0dM5HvG+uaxitm8wONl7jltx8dqhfU33DcqtOZcLSVIKSDDLDi7+0LbAKiyI8hD9u42m2YxXSkMGWThaecQ==} - engines: {iojs: '>= 1.0.0', node: '>= 0.12.0'} - - code-point-at@1.1.0: - resolution: {integrity: sha512-RpAVKQA5T63xEj6/giIbUEtZwJ4UFIc3ZtvEkiaUERylqe8xb5IvqcgOurZLahv93CLKfxcw5YI+DZcUBRyLXA==} - engines: {node: '>=0.10.0'} - - color-convert@1.9.3: - resolution: {integrity: sha512-QfAUtd+vFdAtFQcC8CCyYt1fYWxSqAiK2cSD6zDB8N3cpsEBAvRxp9zOGg6G/SHHJYAT88/az/IuDGALsNVbGg==} - - color-convert@2.0.1: - resolution: {integrity: sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ==} - engines: {node: '>=7.0.0'} - - color-name@1.1.3: - resolution: {integrity: sha512-72fSenhMw2HZMTVHeCA9KCmpEIbzWiQsjN+BHcBbS9vr1mtt+vJjPdksIBNUmKAW8TFUDPJK5SUU3QhE9NEXDw==} - - color-name@1.1.4: - resolution: {integrity: sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA==} - - colors@1.4.0: - resolution: {integrity: sha512-a+UqTh4kgZg/SlGvfbzDHpgRu7AAQOmmqRHJnxhRZICKFUT91brVhNNt58CMWU9PsBbv3PDCZUHbVxuDiH2mtA==} - engines: {node: '>=0.1.90'} - - combined-stream@1.0.8: - resolution: {integrity: sha512-FQN4MRfuJeHf7cBbBMJFXhKSDq+2kAArBlmRBvcvFE5BB1HZKXtSFASDhdlz9zOYwxh8lDdnvmMOe/+5cdoEdg==} - engines: {node: '>= 0.8'} - - command-exists@1.2.9: - resolution: {integrity: sha512-LTQ/SGc+s0Xc0Fu5WaKnR0YiygZkm9eKFvyS+fRsU7/ZWFF8ykFM6Pc9aCVf1+xasOOZpO3BAVgVrKvsqKHV7w==} - - command-line-args@5.2.1: - resolution: {integrity: sha512-H4UfQhZyakIjC74I9d34fGYDwk3XpSr17QhEd0Q3I9Xq1CETHo4Hcuo87WyWHpAF1aSLjLRf5lD9ZGX2qStUvg==} - engines: {node: '>=4.0.0'} - - command-line-usage@6.1.3: - resolution: {integrity: sha512-sH5ZSPr+7UStsloltmDh7Ce5fb8XPlHyoPzTpyyMuYCtervL65+ubVZ6Q61cFtFl62UyJlc8/JwERRbAFPUqgw==} - engines: {node: '>=8.0.0'} - - commander@10.0.1: - resolution: {integrity: sha512-y4Mg2tXshplEbSGzx7amzPwKKOCGuoSRP/CjEdwwk0FOGlUbq6lKuoyDZTNZkmxHdJtp54hdfY/JUrdL7Xfdug==} - engines: {node: '>=14'} - - commander@2.20.3: - resolution: {integrity: sha512-GpVkmM8vF2vQUkj2LvZmD35JxeJOLCwJ9cUkugyk2nuhbv3+mJvpLYYt+0+USMxE+oj+ey/lJEnhZw75x/OMcQ==} - - commander@3.0.2: - resolution: {integrity: sha512-Gar0ASD4BDyKC4hl4DwHqDrmvjoxWKZigVnAbn5H1owvm4CxCPdb0HQDehwNYMJpla5+M2tPmPARzhtYuwpHow==} - - commander@6.2.1: - resolution: {integrity: sha512-U7VdrJFnJgo4xjrHpTzu0yrHPGImdsmD95ZlgYSEajAn2JKzDhDTPG9kBTefmObL2w/ngeZnilk+OV9CG3d7UA==} - engines: {node: '>= 6'} - - commondir@1.0.1: - resolution: {integrity: sha512-W9pAhw0ja1Edb5GVdIF1mjZw/ASI0AlShXM83UUGe2DVr5TdAPEA1OA8m/g8zWp9x6On7gqufY+FatDbC3MDQg==} - - concat-map@0.0.1: - resolution: {integrity: sha512-/Srv4dswyQNBfohGpz9o6Yb3Gz3SrUDqBH5rTuhGR7ahtlbYKnVxw2bCFMRljaA7EXHaXZ8wsHdodFvbkhKmqg==} - - concat-stream@1.6.2: - resolution: {integrity: sha512-27HBghJxjiZtIk3Ycvn/4kbJk/1uZuJFfuPEns6LaEvpvG1f0hTea8lilrouyo9mVc2GWdcEZ8OLoGmSADlrCw==} - engines: {'0': node >= 0.8} - - constant-case@2.0.0: - resolution: {integrity: sha512-eS0N9WwmjTqrOmR3o83F5vW8Z+9R1HnVz3xmzT2PMFug9ly+Au/fxRWlEBSb6LcZwspSsEn9Xs1uw9YgzAg1EQ==} - - content-disposition@0.5.4: - resolution: {integrity: sha512-FveZTNuGw04cxlAiWbzi6zTAL/lhehaWbTtgluJh4/E95DqMwTmha3KZN1aAWA8cFIhHzMZUvLevkw5Rqk+tSQ==} - engines: {node: '>= 0.6'} - - content-hash@2.5.2: - resolution: {integrity: sha512-FvIQKy0S1JaWV10sMsA7TRx8bpU+pqPkhbsfvOJAdjRXvYxEckAwQWGwtRjiaJfh+E0DvcWUGqcdjwMGFjsSdw==} - - content-type@1.0.5: - resolution: {integrity: sha512-nTjqfcBFEipKdXCv4YDQWCfmcLZKm81ldF0pAopTvyrFGVbcR6P/VAAd5G7N+0tTr8QqiU0tFadD6FK4NtJwOA==} - engines: {node: '>= 0.6'} - - convert-source-map@1.9.0: - resolution: {integrity: sha512-ASFBup0Mz1uyiIjANan1jzLQami9z1PoYSZCiiYW2FczPbenXc45FZdBZLzOT+r6+iciuEModtmCti+hjaAk0A==} - - convert-source-map@2.0.0: - resolution: {integrity: sha512-Kvp459HrV2FEJ1CAsi1Ku+MY3kasH19TFykTz2xWmMeq6bk2NU3XXvfJ+Q61m0xktWwt+1HSYf3JZsTms3aRJg==} - - cookie-signature@1.0.6: - resolution: {integrity: sha512-QADzlaHc8icV8I7vbaJXJwod9HWYp8uCqf1xa4OfNu1T7JVxQIrUgOWtHdNDtPiywmFbiS12VjotIXLrKM3orQ==} - - cookie@0.4.2: - resolution: {integrity: sha512-aSWTXFzaKWkvHO1Ny/s+ePFpvKsPnjc551iI41v3ny/ow6tBG5Vd+FuqGNhh1LxOmVzOlGUriIlOaokOvhaStA==} - engines: {node: '>= 0.6'} - - cookie@0.6.0: - resolution: {integrity: sha512-U71cyTamuh1CRNCfpGY6to28lxvNwPG4Guz/EVjgf3Jmzv0vlDp1atT9eS5dDjMYHucpHbWns6Lwf3BKz6svdw==} - engines: {node: '>= 0.6'} - - cookiejar@2.1.4: - resolution: {integrity: sha512-LDx6oHrK+PhzLKJU9j5S7/Y3jM/mUHvD/DeI1WQmJn652iPC5Y4TBzC9l+5OMOXlyTTA+SmVUPm0HQUwpD5Jqw==} - - core-util-is@1.0.2: - resolution: {integrity: sha512-3lqz5YjWTYnW6dlDa5TLaTCcShfar1e40rmcJVwCBJC6mWlFuj0eCHIElmG1g5kyuJ/GD+8Wn4FFCcz4gJPfaQ==} - - core-util-is@1.0.3: - resolution: {integrity: sha512-ZQBvi1DcpJ4GDqanjucZ2Hj3wEO5pZDS89BWbkcrvdxksJorwUDDZamX9ldFkp9aw2lmBDLgkObEA4DWNJ9FYQ==} - - cors@2.8.5: - resolution: {integrity: sha512-KIHbLJqu73RGr/hnbrO9uBeixNGuvSQjul/jdFvS/KFSIH1hWVd1ng7zOHx+YrEfInLG7q4n6GHQ9cDtxv/P6g==} - engines: {node: '>= 0.10'} - - cosmiconfig@8.3.6: - resolution: {integrity: sha512-kcZ6+W5QzcJ3P1Mt+83OUv/oHFqZHIx8DuxG6eZ5RGMERoLqp4BuGjhHLYGK+Kf5XVkQvqBSmAy/nGWN3qDgEA==} - engines: {node: '>=14'} - peerDependencies: - typescript: '>=4.9.5' - peerDependenciesMeta: - typescript: - optional: true - - crc-32@1.2.2: - resolution: {integrity: sha512-ROmzCKrTnOwybPcJApAA6WBWij23HVfGVNKqqrZpuyZOHqK2CwHSvpGuyt/UNNvaIjEd8X5IFGp4Mh+Ie1IHJQ==} - engines: {node: '>=0.8'} - hasBin: true - - create-hash@1.2.0: - resolution: {integrity: sha512-z00bCGNHDG8mHAkP7CtT1qVu+bFQUPjYq/4Iv3C3kWjTFV10zIjfSoeqXo9Asws8gwSHDGj/hl2u4OGIjapeCg==} - - create-hmac@1.1.7: - resolution: {integrity: sha512-MJG9liiZ+ogc4TzUwuvbER1JRdgvUFSB5+VR/g5h82fGaIRWMWddtKBHi7/sVhfjQZ6SehlyhvQYrcYkaUIpLg==} - - create-require@1.1.1: - resolution: {integrity: sha512-dcKFX3jn0MpIaXjisoRvexIJVEKzaq7z2rZKxf+MSr9TkdmHmsU4m2lcLojrj/FHl8mk5VxMmYA+ftRkP/3oKQ==} - - cross-fetch@3.1.8: - resolution: {integrity: sha512-cvA+JwZoU0Xq+h6WkMvAUqPEYy92Obet6UdKLfW60qn99ftItKjB5T+BkyWOFWe2pUyfQ+IJHmpOTznqk1M6Kg==} - - cross-fetch@4.0.0: - resolution: {integrity: sha512-e4a5N8lVvuLgAWgnCrLr2PP0YyDOTHa9H/Rj54dirp61qXnNq46m82bRhNqIA5VccJtWBvPTFRV3TtvHUKPB1g==} - - cross-spawn@5.1.0: - resolution: {integrity: sha512-pTgQJ5KC0d2hcY8eyL1IzlBPYjTkyH72XRZPnLyKus2mBfNjQs3klqbJU2VILqZryAZUt9JOb3h/mWMy23/f5A==} - - cross-spawn@7.0.3: - resolution: {integrity: sha512-iRDPJKUPVEND7dHPO8rkbOnPpyDygcDFtWjpeWNCgy8WP2rXcxXL8TskReQl6OrB2G7+UJrags1q15Fudc7G6w==} - engines: {node: '>= 8'} - - crypt@0.0.2: - resolution: {integrity: sha512-mCxBlsHFYh9C+HVpiEacem8FEBnMXgU9gy4zmNC+SXAZNB/1idgp/aulFJ4FgCi7GPEVbfyng092GqL2k2rmow==} - - crypto-addr-codec@0.1.8: - resolution: {integrity: sha512-GqAK90iLLgP3FvhNmHbpT3wR6dEdaM8hZyZtLX29SPardh3OA13RFLHDR6sntGCgRWOfiHqW6sIyohpNqOtV/g==} - - crypto-js@3.3.0: - resolution: {integrity: sha512-DIT51nX0dCfKltpRiXV+/TVZq+Qq2NgF4644+K7Ttnla7zEzqc+kjJyiB96BHNyUTBxyjzRcZYpUdZa+QAqi6Q==} - - crypto-js@4.2.0: - resolution: {integrity: sha512-KALDyEYgpY+Rlob/iriUtjV6d5Eq+Y191A5g4UqLAi8CyGP9N1+FdVbkc1SxKc2r4YAYqG8JzO2KGL+AizD70Q==} - - css-select@5.1.0: - resolution: {integrity: sha512-nwoRF1rvRRnnCqqY7updORDsuqKzqYJ28+oSMaJMMgOauh3fvwHqMS7EZpIPqK8GL+g9mKxF1vP/ZjSeNjEVHg==} - - css-what@6.1.0: - resolution: {integrity: sha512-HTUrgRJ7r4dsZKU6GjmpfRK1O76h97Z8MfS1G0FozR+oF2kG6Vfe8JE6zwrkbxigziPHinCJ+gCPjA9EaBDtRw==} - engines: {node: '>= 6'} - - csv-generate@3.4.3: - resolution: {integrity: sha512-w/T+rqR0vwvHqWs/1ZyMDWtHHSJaN06klRqJXBEpDJaM/+dZkso0OKh1VcuuYvK3XM53KysVNq8Ko/epCK8wOw==} - - csv-parse@4.16.3: - resolution: {integrity: sha512-cO1I/zmz4w2dcKHVvpCr7JVRu8/FymG5OEpmvsZYlccYolPBLoVGKUHgNoc4ZGkFeFlWGEDmMyBM+TTqRdW/wg==} - - csv-stringify@5.6.5: - resolution: {integrity: sha512-PjiQ659aQ+fUTQqSrd1XEDnOr52jh30RBurfzkscaE2tPaFsDH5wOAHJiw8XAHphRknCwMUE9KRayc4K/NbO8A==} - - csv@5.5.3: - resolution: {integrity: sha512-QTaY0XjjhTQOdguARF0lGKm5/mEq9PD9/VhZZegHDIBq2tQwgNpHc3dneD4mGo2iJs+fTKv5Bp0fZ+BRuY3Z0g==} - engines: {node: '>= 0.1.90'} - - d@1.0.2: - resolution: {integrity: sha512-MOqHvMWF9/9MX6nza0KgvFH4HpMU0EF5uUDXqX/BtxtU8NfB0QzRtJ8Oe/6SuS4kbhyzVJwjd97EA4PKrzJ8bw==} - engines: {node: '>=0.12'} - - dashdash@1.14.1: - resolution: {integrity: sha512-jRFi8UDGo6j+odZiEpjazZaWqEal3w/basFjQHQEwVtZJGDpxbH1MeYluwCS8Xq5wmLJooDlMgvVarmWfGM44g==} - engines: {node: '>=0.10'} - - data-view-buffer@1.0.1: - resolution: {integrity: sha512-0lht7OugA5x3iJLOWFhWK/5ehONdprk0ISXqVFn/NFrDu+cuc8iADFrGQz5BnRK7LLU3JmkbXSxaqX+/mXYtUA==} - engines: {node: '>= 0.4'} - - data-view-byte-length@1.0.1: - resolution: {integrity: sha512-4J7wRJD3ABAzr8wP+OcIcqq2dlUKp4DVflx++hs5h5ZKydWMI6/D/fAot+yh6g2tHh8fLFTvNOaVN357NvSrOQ==} - engines: {node: '>= 0.4'} - - data-view-byte-offset@1.0.0: - resolution: {integrity: sha512-t/Ygsytq+R995EJ5PZlD4Cu56sWa8InXySaViRzw9apusqsOO2bQP+SbYzAhR0pFKoB+43lYy8rWban9JSuXnA==} - engines: {node: '>= 0.4'} - - date-time@0.1.1: - resolution: {integrity: sha512-p4psdkgdNA6x0600SKbfWiOomNb33ADBMRHf49GMhYVgJsPefZlMSLXXVWWUpbqSxB3DL5/cxKa6a8i3XPK5Xg==} - engines: {node: '>=0.10.0'} - - death@1.1.0: - resolution: {integrity: sha512-vsV6S4KVHvTGxbEcij7hkWRv0It+sGGWVOM67dQde/o5Xjnr+KmLjxWJii2uEObIrt1CcM9w0Yaovx+iOlIL+w==} - - debug@2.6.9: - resolution: {integrity: sha512-bC7ElrdJaJnPbAP+1EotYvqZsb3ecl5wi6Bfi6BJTUcNowp6cvspg0jXznRTKDjm/E7AdgFBVeAPVMNcKGsHMA==} - peerDependencies: - supports-color: '*' - peerDependenciesMeta: - supports-color: - optional: true - - debug@3.2.7: - resolution: {integrity: sha512-CFjzYYAi4ThfiQvizrFQevTTXHtnCqWfe7x1AhgEscTz6ZbLbfoLRLPugTQyBth6f8ZERVUSyWHFD/7Wu4t1XQ==} - peerDependencies: - supports-color: '*' - peerDependenciesMeta: - supports-color: - optional: true - - debug@4.3.4: - resolution: {integrity: sha512-PRWFHuSU3eDtQJPvnNY7Jcket1j0t5OuOsFzPPzsekD52Zl8qUfFIPEiswXqIvHWGVHOgX+7G/vCNNhehwxfkQ==} - engines: {node: '>=6.0'} - peerDependencies: - supports-color: '*' - peerDependenciesMeta: - supports-color: - optional: true - - decamelize-keys@1.1.1: - resolution: {integrity: sha512-WiPxgEirIV0/eIOMcnFBA3/IJZAZqKnwAwWyvvdi4lsr1WCN22nhdf/3db3DoZcUjTV2SqfzIwNyp6y2xs3nmg==} - engines: {node: '>=0.10.0'} - - decamelize@1.2.0: - resolution: {integrity: sha512-z2S+W9X73hAUUki+N+9Za2lBlun89zigOyGrsax+KUQ6wKW4ZoWpEYBkGhQjwAjjDCkWxhY0VKEhk8wzY7F5cA==} - engines: {node: '>=0.10.0'} - - decamelize@4.0.0: - resolution: {integrity: sha512-9iE1PgSik9HeIIw2JO94IidnE3eBoQrFJ3w7sFuzSX4DpmZ3v5sZpUiV5Swcf6mQEF+Y0ru8Neo+p+nyh2J+hQ==} - engines: {node: '>=10'} - - decimal.js-light@2.5.1: - resolution: {integrity: sha512-qIMFpTMZmny+MMIitAB6D7iVPEorVw6YQRWkvarTkT4tBeSLLiHzcwj6q0MmYSFCiVpiqPJTJEYIrpcPzVEIvg==} - - decode-uri-component@0.2.2: - resolution: {integrity: sha512-FqUYQ+8o158GyGTrMFJms9qh3CqTKvAqgqsTnkLI8sKu0028orqBhxNMFkFen0zGyg6epACD32pjVk58ngIErQ==} - engines: {node: '>=0.10'} - - decompress-response@3.3.0: - resolution: {integrity: sha512-BzRPQuY1ip+qDonAOz42gRm/pg9F768C+npV/4JOsxRC2sq+Rlk+Q4ZCAsOhnIaMrgarILY+RMUIvMmmX1qAEA==} - engines: {node: '>=4'} - - decompress-response@6.0.0: - resolution: {integrity: sha512-aW35yZM6Bb/4oJlZncMH2LCoZtJXTRxES17vE3hoRiowU2kWHaJKFkSBDnDR+cm9J+9QhXmREyIfv0pji9ejCQ==} - engines: {node: '>=10'} - - deep-eql@4.1.3: - resolution: {integrity: sha512-WaEtAOpRA1MQ0eohqZjpGD8zdI0Ovsm8mmFhaDN8dvDZzyoUMcYDnf5Y6iu7HTXxf8JDS23qWa4a+hKCDyOPzw==} - engines: {node: '>=6'} - - deep-extend@0.6.0: - resolution: {integrity: sha512-LOHxIOaPYdHlJRtCQfDIVZtfw/ufM8+rVj649RIHzcm/vGwQRXFt6OPqIFWsm2XEMrNIEtWR64sY1LEKD2vAOA==} - engines: {node: '>=4.0.0'} - - deep-is@0.1.4: - resolution: {integrity: sha512-oIPzksmTg4/MriiaYGO+okXDT7ztn/w3Eptv/+gSIdMdKsJo0u4CfYNFJPy+4SKMuCqGw2wxnA+URMg3t8a/bQ==} - - deepmerge@4.3.1: - resolution: {integrity: sha512-3sUqbMEc77XqpdNO7FRyRog+eW3ph+GYCbj+rK+uYyRMuwsVy0rMiVtPn+QJlKFvWP/1PYpapqYn0Me2knFn+A==} - engines: {node: '>=0.10.0'} - - default-require-extensions@3.0.1: - resolution: {integrity: sha512-eXTJmRbm2TIt9MgWTsOH1wEuhew6XGZcMeGKCtLedIg/NCsg1iBePXkceTdK4Fii7pzmN9tGsZhKzZ4h7O/fxw==} - engines: {node: '>=8'} - - defaults@1.0.4: - resolution: {integrity: sha512-eFuaLoy/Rxalv2kr+lqMlUnrDWV+3j4pljOIJgLIhI058IQfWJ7vXhyEIHu+HtC738klGALYxOKDO0bQP3tg8A==} - - defer-to-connect@2.0.1: - resolution: {integrity: sha512-4tvttepXG1VaYGrRibk5EwJd1t4udunSOVMdLSAL6mId1ix438oPwPZMALY41FCijukO1L0twNcGsdzS7dHgDg==} - engines: {node: '>=10'} - - define-data-property@1.1.4: - resolution: {integrity: sha512-rBMvIzlpA8v6E+SJZoo++HAYqsLrkg7MSfIinMPFhmkorw7X+dOXVJQs+QT69zGkzMyfDnIMN2Wid1+NbL3T+A==} - engines: {node: '>= 0.4'} - - define-properties@1.2.1: - resolution: {integrity: sha512-8QmQKqEASLd5nx0U1B1okLElbUuuttJ/AnYmRXbbbGDWh6uS208EjD4Xqq/I9wK7u0v6O08XhTWnt5XtEbR6Dg==} - engines: {node: '>= 0.4'} - - delayed-stream@1.0.0: - resolution: {integrity: sha512-ZySD7Nf91aLB0RxL4KGrKHBXl7Eds1DAmEdcoVawXnLD7SDhpNgtuII2aAkg7a7QS41jxPSZ17p4VdGnMHk3MQ==} - engines: {node: '>=0.4.0'} - - depd@2.0.0: - resolution: {integrity: sha512-g7nH6P6dyDioJogAAGprGpCtVImJhpPk/roCzdb3fIh61/s/nPsfR6onyMwkCAR/OlC3yBC0lESvUoQEAssIrw==} - engines: {node: '>= 0.8'} - - destroy@1.2.0: - resolution: {integrity: sha512-2sJGJTaXIIaR1w4iJSNoN0hnMY7Gpc/n8D4qSCJw8QqFWXf7cuAgnEHxBpweaVcPevC2l3KpjYCx3NypQQgaJg==} - engines: {node: '>= 0.8', npm: 1.2.8000 || >= 1.4.16} - - detect-indent@5.0.0: - resolution: {integrity: sha512-rlpvsxUtM0PQvy9iZe640/IWwWYyBsTApREbA1pHOpmOUIl9MkP/U4z7vTtg4Oaojvqhxt7sdufnT0EzGaR31g==} - engines: {node: '>=4'} - - detect-indent@6.1.0: - resolution: {integrity: sha512-reYkTUJAZb9gUuZ2RvVCNhVHdg62RHnJ7WJl8ftMi4diZ6NWlciOzQN88pUhSELEwflJht4oQDv0F0BMlwaYtA==} - engines: {node: '>=8'} - - detect-libc@2.0.3: - resolution: {integrity: sha512-bwy0MGW55bG41VqxxypOsdSdGqLwXPI/focwgTYCFMbdUiBAxLg9CFzG08sz2aqzknwiX7Hkl0bQENjg8iLByw==} - engines: {node: '>=8'} - - detect-node@2.1.0: - resolution: {integrity: sha512-T0NIuQpnTvFDATNuHN5roPwSBG83rFsuO+MXXH9/3N1eFbn4wcPjttvjMLEPWJ0RGUYgQE7cGgS3tNxbqCGM7g==} - - detect-port@1.6.1: - resolution: {integrity: sha512-CmnVc+Hek2egPx1PeTFVta2W78xy2K/9Rkf6cC4T59S50tVnzKj+tnx5mmx5lwvCkujZ4uRrpRSuV+IVs3f90Q==} - engines: {node: '>= 4.0.0'} - hasBin: true - - diff-sequences@29.6.3: - resolution: {integrity: sha512-EjePK1srD3P08o2j4f0ExnylqRs5B9tJjcp9t1krH2qRi8CCdsYfwe9JgSLurFBWwq4uOlipzfk5fHNvwFKr8Q==} - engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0} - - diff@4.0.2: - resolution: {integrity: sha512-58lmxKSA4BNyLz+HHMUzlOEpg09FV+ev6ZMe3vJihgdxzgcwZ8VoEEPmALCZG9LmqfVoNMMKpttIYTVG6uDY7A==} - engines: {node: '>=0.3.1'} - - diff@5.0.0: - resolution: {integrity: sha512-/VTCrvm5Z0JGty/BWHljh+BAiw3IK+2j87NGMu8Nwc/f48WoDAC395uomO9ZD117ZOBaHmkX1oyLvkVM/aIT3w==} - engines: {node: '>=0.3.1'} - - difflib@0.2.4: - resolution: {integrity: sha512-9YVwmMb0wQHQNr5J9m6BSj6fk4pfGITGQOOs+D9Fl+INODWFOfvhIU1hNv6GgR1RBoC/9NJcwu77zShxV0kT7w==} - - dir-glob@3.0.1: - resolution: {integrity: sha512-WkrWp9GR4KXfKGYzOLmTuGVi1UWFfws377n9cc55/tb6DuqyF6pcQ5AbiHEshaDpY9v6oaSr2XCDidGmMwdzIA==} - engines: {node: '>=8'} - - doctrine@2.1.0: - resolution: {integrity: sha512-35mSku4ZXK0vfCuHEDAwt55dg2jNajHZ1odvF+8SSr82EsZY4QmXfuWso8oEd8zRhVObSN18aM0CjSdoBX7zIw==} - engines: {node: '>=0.10.0'} - - doctrine@3.0.0: - resolution: {integrity: sha512-yS+Q5i3hBf7GBkd4KG8a7eBNNWNGLTaEwwYWUijIYM7zrlYDM0BFXHjjPWlWZ1Rg7UaddZeIDmi9jF3HmqiQ2w==} - engines: {node: '>=6.0.0'} - - dom-serializer@2.0.0: - resolution: {integrity: sha512-wIkAryiqt/nV5EQKqQpo3SToSOV9J0DnbJqwK7Wv/Trc92zIAYZ4FlMu+JPFW1DfGFt81ZTCGgDEabffXeLyJg==} - - dom-walk@0.1.2: - resolution: {integrity: sha512-6QvTW9mrGeIegrFXdtQi9pk7O/nSK6lSdXW2eqUspN5LWD7UTji2Fqw5V2YLjBpHEoU9Xl/eUWNpDeZvoyOv2w==} - - domelementtype@2.3.0: - resolution: {integrity: sha512-OLETBj6w0OsagBwdXnPdN0cnMfF9opN69co+7ZrbfPGrdpPVNBUj02spi6B1N7wChLQiPn4CSH/zJvXw56gmHw==} - - domhandler@5.0.3: - resolution: {integrity: sha512-cgwlv/1iFQiFnU96XXgROh8xTeetsnJiDsTc7TYCLFd9+/WNkIqPTxiM/8pSd8VIrhXGTf1Ny1q1hquVqDJB5w==} - engines: {node: '>= 4'} - - domutils@3.1.0: - resolution: {integrity: sha512-H78uMmQtI2AhgDJjWeQmHwJJ2bLPD3GMmO7Zja/ZZh84wkm+4ut+IUnUdRa8uCGX88DiVx1j6FRe1XfxEgjEZA==} - - dot-case@2.1.1: - resolution: {integrity: sha512-HnM6ZlFqcajLsyudHq7LeeLDr2rFAVYtDv/hV5qchQEidSck8j9OPUsXY9KwJv/lHMtYlX4DjRQqwFYa+0r8Ug==} - - dot-prop@7.2.0: - resolution: {integrity: sha512-Ol/IPXUARn9CSbkrdV4VJo7uCy1I3VuSiWCaFSg+8BdUOzF9n3jefIpcgAydvUZbTdEBZs2vEiTiS9m61ssiDA==} - engines: {node: ^12.20.0 || ^14.13.1 || >=16.0.0} - - ecc-jsbn@0.1.2: - resolution: {integrity: sha512-eh9O+hwRHNbG4BLTjEl3nw044CkGm5X6LoaCf7LPp7UU8Qrt47JYNi6nPX8xjW97TKGKm1ouctg0QSpZe9qrnw==} - - ee-first@1.1.1: - resolution: {integrity: sha512-WMwm9LhRUo+WUaRN+vRuETqG89IgZphVSNkdFgeb6sS/E4OrDIN7t48CAewSHXc6C8lefD8KKfr5vY61brQlow==} - - eip55@2.1.1: - resolution: {integrity: sha512-WcagVAmNu2Ww2cDUfzuWVntYwFxbvZ5MvIyLZpMjTTkjD6sCvkGOiS86jTppzu9/gWsc8isLHAeMBWK02OnZmA==} - - electron-to-chromium@1.4.761: - resolution: {integrity: sha512-PIbxpiJGx6Bb8dQaonNc6CGTRlVntdLg/2nMa1YhnrwYOORY9a3ZgGN0UQYE6lAcj/lkyduJN7BPt/JiY+jAQQ==} - - elliptic@6.5.4: - resolution: {integrity: sha512-iLhC6ULemrljPZb+QutR5TQGB+pdW6KGD5RSegS+8sorOZT+rdQFbsQFJgvN3eRqNALqJer4oQ16YvJHlU8hzQ==} - - elliptic@6.5.5: - resolution: {integrity: sha512-7EjbcmUm17NQFu4Pmgmq2olYMj8nwMnpcddByChSUjArp8F5DQWcIcpriwO4ZToLNAJig0yiyjswfyGNje/ixw==} - - emoji-regex@8.0.0: - resolution: {integrity: sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A==} - - encodeurl@1.0.2: - resolution: {integrity: sha512-TPJXq8JqFaVYm2CWmPvnP2Iyo4ZSM7/QKcSmuMLDObfpH5fi7RUGmd/rTDf+rut/saiDiQEeVTNgAmJEdAOx0w==} - engines: {node: '>= 0.8'} - - end-of-stream@1.4.4: - resolution: {integrity: sha512-+uw1inIHVPQoaVuHzRyXd21icM+cnt4CzD5rW+NC1wjOUSTOs+Te7FOv7AhN7vS9x/oIyhLP5PR1H+phQAHu5Q==} - - enquirer@2.4.1: - resolution: {integrity: sha512-rRqJg/6gd538VHvR3PSrdRBb/1Vy2YfzHqzvbhGIQpDRKIa4FgV/54b5Q1xYSxOOwKvjXweS26E0Q+nAMwp2pQ==} - engines: {node: '>=8.6'} - - entities@4.5.0: - resolution: {integrity: sha512-V0hjH4dGPh9Ao5p0MoRY6BVqtwCjhz6vI5LT8AJ55H+4g9/4vbHx1I54fS0XuclLhDHArPQCiMjDxjaL8fPxhw==} - engines: {node: '>=0.12'} - - env-paths@2.2.1: - resolution: {integrity: sha512-+h1lkLKhZMTYjog1VEpJNG7NZJWcuc2DDk/qsqSTRRCOXiLjeQ1d1/udrUGhqMxUgAlwKNZ0cf2uqan5GLuS2A==} - engines: {node: '>=6'} - - error-ex@1.3.2: - resolution: {integrity: sha512-7dFHNmqeFSEt2ZBsCriorKnn3Z2pj+fd9kmI6QoWw4//DL+icEBfc0U7qJCisqrTsKTjw4fNFy2pW9OqStD84g==} - - es-abstract@1.23.3: - resolution: {integrity: sha512-e+HfNH61Bj1X9/jLc5v1owaLYuHdeHHSQlkhCBiTK8rBvKaULl/beGMxwrMXjpYrv4pz22BlY570vVePA2ho4A==} - engines: {node: '>= 0.4'} - - es-define-property@1.0.0: - resolution: {integrity: sha512-jxayLKShrEqqzJ0eumQbVhTYQM27CfT1T35+gCgDFoL82JLsXqTJ76zv6A0YLOgEnLUMvLzsDsGIrl8NFpT2gQ==} - engines: {node: '>= 0.4'} - - es-errors@1.3.0: - resolution: {integrity: sha512-Zf5H2Kxt2xjTvbJvP2ZWLEICxA6j+hAmMzIlypy4xcBg1vKVnx89Wy0GbS+kf5cwCVFFzdCFh2XSCFNULS6csw==} - engines: {node: '>= 0.4'} - - es-object-atoms@1.0.0: - resolution: {integrity: sha512-MZ4iQ6JwHOBQjahnjwaC1ZtIBH+2ohjamzAO3oaHcXYup7qxjF2fixyH+Q71voWHeOkI2q/TnJao/KfXYIZWbw==} - engines: {node: '>= 0.4'} - - es-set-tostringtag@2.0.3: - resolution: {integrity: sha512-3T8uNMC3OQTHkFUsFq8r/BwAXLHvU/9O9mE0fBc/MY5iq/8H7ncvO947LmYA6ldWw9Uh8Yhf25zu6n7nML5QWQ==} - engines: {node: '>= 0.4'} - - es-shim-unscopables@1.0.2: - resolution: {integrity: sha512-J3yBRXCzDu4ULnQwxyToo/OjdMx6akgVC7K6few0a7F/0wLtmKKN7I73AH5T2836UuXRqN7Qg+IIUw/+YJksRw==} - - es-to-primitive@1.2.1: - resolution: {integrity: sha512-QCOllgZJtaUo9miYBcLChTUaHNjJF3PYs1VidD7AwiEj1kYxKeQTctLAezAOH5ZKRH0g2IgPn6KwB4IT8iRpvA==} - engines: {node: '>= 0.4'} - - es5-ext@0.10.64: - resolution: {integrity: sha512-p2snDhiLaXe6dahss1LddxqEm+SkuDvV8dnIQG0MWjyHpcMNfXKPE+/Cc0y+PhxJX3A4xGNeFCj5oc0BUh6deg==} - engines: {node: '>=0.10'} - - es6-error@4.1.1: - resolution: {integrity: sha512-Um/+FxMr9CISWh0bi5Zv0iOD+4cFh5qLeks1qhAopKVAJw3drgKbKySikp7wGhDL0HPeaja0P5ULZrxLkniUVg==} - - es6-iterator@2.0.3: - resolution: {integrity: sha512-zw4SRzoUkd+cl+ZoE15A9o1oQd920Bb0iOJMQkQhl3jNc03YqVjAhG7scf9C5KWRU/R13Orf588uCC6525o02g==} - - es6-promise@4.2.8: - resolution: {integrity: sha512-HJDGx5daxeIvxdBxvG2cb9g4tEvwIk3i8+nhX0yGrYmZUzbkdg8QbDevheDB8gd0//uPj4c1EQua8Q+MViT0/w==} - - es6-symbol@3.1.4: - resolution: {integrity: sha512-U9bFFjX8tFiATgtkJ1zg25+KviIXpgRvRHS8sau3GfhVzThRQrOeksPeT0BWW2MNZs1OEWJ1DPXOQMn0KKRkvg==} - engines: {node: '>=0.12'} - - escalade@3.1.2: - resolution: {integrity: sha512-ErCHMCae19vR8vQGe50xIsVomy19rg6gFu3+r3jkEO46suLMWBksvVyoGgQV+jOfl84ZSOSlmv6Gxa89PmTGmA==} - engines: {node: '>=6'} - - escape-html@1.0.3: - resolution: {integrity: sha512-NiSupZ4OeuGwr68lGIeym/ksIZMJodUGOSCZ/FSnTxcrekbvqrgdUxlJOMpijaKZVjAJrWrGs/6Jy8OMuyj9ow==} - - escape-string-regexp@1.0.5: - resolution: {integrity: sha512-vbRorB5FUQWvla16U8R/qgaFIya2qGzwDrNmCZuYKrbdSUMG6I1ZCGQRefkRVhuOkIGVne7BQ35DSfo1qvJqFg==} - engines: {node: '>=0.8.0'} - - escape-string-regexp@4.0.0: - resolution: {integrity: sha512-TtpcNJ3XAzx3Gq8sWRzJaVajRs0uVxA2YAkdb1jm2YkPz4G6egUFAyA3n5vtEIZefPk5Wa4UXbKuS5fKkJWdgA==} - engines: {node: '>=10'} - - escodegen@1.8.1: - resolution: {integrity: sha512-yhi5S+mNTOuRvyW4gWlg5W1byMaQGWWSYHXsuFZ7GBo7tpyOwi2EdzMP/QWxh9hwkD2m+wDVHJsxhRIj+v/b/A==} - engines: {node: '>=0.12.0'} - hasBin: true - - eslint-compat-utils@0.5.0: - resolution: {integrity: sha512-dc6Y8tzEcSYZMHa+CMPLi/hyo1FzNeonbhJL7Ol0ccuKQkwopJcJBA9YL/xmMTLU1eKigXo9vj9nALElWYSowg==} - engines: {node: '>=12'} - peerDependencies: - eslint: '>=6.0.0' - - eslint-config-prettier@8.3.0: - resolution: {integrity: sha512-BgZuLUSeKzvlL/VUjx/Yb787VQ26RU3gGjA3iiFvdsp/2bMfVIWUVP7tjxtjS0e+HP409cPlPvNkQloz8C91ew==} - hasBin: true - peerDependencies: - eslint: '>=7.0.0' - - eslint-doc-generator@1.7.1: - resolution: {integrity: sha512-i1Zjl+Xcy712SZhbceCeMVaIdhbFqY27i8d7f9gyb9P/6AQNnPA0VCWynAFVGYa0hpeR5kwUI09+GBELgC2nnA==} - engines: {node: ^14.18.0 || ^16.0.0 || >=18.0.0} - hasBin: true - peerDependencies: - eslint: '>= 7' - - eslint-import-resolver-node@0.3.9: - resolution: {integrity: sha512-WFj2isz22JahUv+B788TlO3N6zL3nNJGU8CcZbPZvVEkBPaJdCV4vy5wyghty5ROFbCRnm132v8BScu5/1BQ8g==} - - eslint-module-utils@2.8.1: - resolution: {integrity: sha512-rXDXR3h7cs7dy9RNpUlQf80nX31XWJEyGq1tRMo+6GsO5VmTe4UTwtmonAD4ZkAsrfMVDA2wlGJ3790Ys+D49Q==} - engines: {node: '>=4'} - peerDependencies: - '@typescript-eslint/parser': '*' - eslint: '*' - eslint-import-resolver-node: '*' - eslint-import-resolver-typescript: '*' - eslint-import-resolver-webpack: '*' - peerDependenciesMeta: - '@typescript-eslint/parser': - optional: true - eslint: - optional: true - eslint-import-resolver-node: - optional: true - eslint-import-resolver-typescript: - optional: true - eslint-import-resolver-webpack: - optional: true - - eslint-plugin-es-x@7.6.0: - resolution: {integrity: sha512-I0AmeNgevgaTR7y2lrVCJmGYF0rjoznpDvqV/kIkZSZbZ8Rw3eu4cGlvBBULScfkSOCzqKbff5LR4CNrV7mZHA==} - engines: {node: ^14.18.0 || >=16.0.0} - peerDependencies: - eslint: '>=8' - - eslint-plugin-eslint-plugin@5.5.1: - resolution: {integrity: sha512-9AmfZzcQ7QHwpzfAQpZ7xdtwHYViylmlnruCH0aV64/tuoH3igGXg91vr0e6ShLf/mrAYGqLw5LZ/gOxJeRXnw==} - engines: {node: ^14.17.0 || ^16.0.0 || >= 18.0.0} - peerDependencies: - eslint: '>=7.0.0' - - eslint-plugin-import@2.27.5: - resolution: {integrity: sha512-LmEt3GVofgiGuiE+ORpnvP+kAm3h6MLZJ4Q5HCyHADofsb4VzXFsRiWj3c0OFiV+3DWFh0qg3v9gcPlfc3zRow==} - engines: {node: '>=4'} - peerDependencies: - '@typescript-eslint/parser': '*' - eslint: ^2 || ^3 || ^4 || ^5 || ^6 || ^7.2.0 || ^8 - peerDependenciesMeta: - '@typescript-eslint/parser': - optional: true - - eslint-plugin-mocha@10.4.1: - resolution: {integrity: sha512-G85ALUgKaLzuEuHhoW3HVRgPTmia6njQC3qCG6CEvA8/Ja9PDZnRZOuzekMki+HaViEQXINuYsmhp5WR5/4MfA==} - engines: {node: '>=14.0.0'} - peerDependencies: - eslint: '>=7.0.0' - - eslint-plugin-n@16.6.2: - resolution: {integrity: sha512-6TyDmZ1HXoFQXnhCTUjVFULReoBPOAjpuiKELMkeP40yffI/1ZRO+d9ug/VC6fqISo2WkuIBk3cvuRPALaWlOQ==} - engines: {node: '>=16.0.0'} - peerDependencies: - eslint: '>=7.0.0' - - eslint-plugin-prettier@3.4.0: - resolution: {integrity: sha512-UDK6rJT6INSfcOo545jiaOwB701uAIt2/dR7WnFQoGCVl1/EMqdANBmwUaqqQ45aXprsTGzSa39LI1PyuRBxxw==} - engines: {node: '>=6.0.0'} - peerDependencies: - eslint: '>=5.0.0' - eslint-config-prettier: '*' - prettier: '>=1.13.0' - peerDependenciesMeta: - eslint-config-prettier: - optional: true - - eslint-scope@5.1.1: - resolution: {integrity: sha512-2NxwbF/hZ0KpepYN0cNbo+FN6XoK7GaHlQhgx/hIZl6Va0bF45RQOOwhLIy8lQDbuCiadSLCBnH2CFYquit5bw==} - engines: {node: '>=8.0.0'} - - eslint-scope@7.2.2: - resolution: {integrity: sha512-dOt21O7lTMhDM+X9mB4GX+DZrZtCUJPL/wlcTqxyrx5IvO0IYtILdtrQGQp+8n5S0gwSVmOf9NQrjMOgfQZlIg==} - engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0} - - eslint-utils@3.0.0: - resolution: {integrity: sha512-uuQC43IGctw68pJA1RgbQS8/NP7rch6Cwd4j3ZBtgo4/8Flj4eGE7ZYSZRN3iq5pVUv6GPdW5Z1RFleo84uLDA==} - engines: {node: ^10.0.0 || ^12.0.0 || >= 14.0.0} - peerDependencies: - eslint: '>=5' - - eslint-visitor-keys@2.1.0: - resolution: {integrity: sha512-0rSmRBzXgDzIsD6mGdJgevzgezI534Cer5L/vyMX0kHzT/jiB43jRhd9YUlMGYLQy2zprNmoT8qasCGtY+QaKw==} - engines: {node: '>=10'} - - eslint-visitor-keys@3.4.3: - resolution: {integrity: sha512-wpc+LXeiyiisxPlEkUzU6svyS1frIO3Mgxj1fdy7Pm8Ygzguax2N3Fa/D/ag1WqbOprdI+uY6wMUl8/a2G+iag==} - engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0} - - eslint@8.57.0: - resolution: {integrity: sha512-dZ6+mexnaTIbSBZWgou51U6OmzIhYM2VcNdtiTtI7qPNZm35Akpr0f6vtw3w1Kmn5PYo+tZVfh13WrhpS6oLqQ==} - engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0} - hasBin: true - - esniff@2.0.1: - resolution: {integrity: sha512-kTUIGKQ/mDPFoJ0oVfcmyJn4iBDRptjNVIzwIFR7tqWXdVI9xfA2RMwY/gbSpJG3lkdWNEjLap/NqVHZiJsdfg==} - engines: {node: '>=0.10'} - - espree@9.6.1: - resolution: {integrity: sha512-oruZaFkjorTpF32kDSI5/75ViwGeZginGGy2NoOSg3Q9bnwlnmDm4HLnkl0RE3n+njDXR037aY1+x58Z/zFdwQ==} - engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0} - - esprima@2.7.3: - resolution: {integrity: sha512-OarPfz0lFCiW4/AV2Oy1Rp9qu0iusTKqykwTspGCZtPxmF81JR4MmIebvF1F9+UOKth2ZubLQ4XGGaU+hSn99A==} - engines: {node: '>=0.10.0'} - hasBin: true - - esprima@4.0.1: - resolution: {integrity: sha512-eGuFFw7Upda+g4p+QHvnW0RyTX/SVeJBDM/gCtMARO0cLuT2HcEKnTPvhjV6aGeqrCB/sbNop0Kszm0jsaWU4A==} - engines: {node: '>=4'} - hasBin: true - - esquery@1.5.0: - resolution: {integrity: sha512-YQLXUplAwJgCydQ78IMJywZCceoqk1oH01OERdSAJc/7U2AylwjhSCLDEtqwg811idIS/9fIU5GjG73IgjKMVg==} - engines: {node: '>=0.10'} - - esrecurse@4.3.0: - resolution: {integrity: sha512-KmfKL3b6G+RXvP8N1vr3Tq1kL/oCFgn2NYXEtqP8/L3pKapUA4G8cFVaoF3SU323CD4XypR/ffioHmkti6/Tag==} - engines: {node: '>=4.0'} - - estraverse@1.9.3: - resolution: {integrity: sha512-25w1fMXQrGdoquWnScXZGckOv+Wes+JDnuN/+7ex3SauFRS72r2lFDec0EKPt2YD1wUJ/IrfEex+9yp4hfSOJA==} - engines: {node: '>=0.10.0'} - - estraverse@4.3.0: - resolution: {integrity: sha512-39nnKffWz8xN1BU/2c79n9nB9HDzo0niYUqx6xyqUnyoAnQyyWpOTdZEeiCch8BBu515t4wp9ZmgVfVhn9EBpw==} - engines: {node: '>=4.0'} - - estraverse@5.3.0: - resolution: {integrity: sha512-MMdARuVEQziNTeJD8DgMqmhwR11BRQ/cBP+pLtYdSTnf3MIO8fFeiINEbX36ZdNlfU/7A9f3gUw49B3oQsvwBA==} - engines: {node: '>=4.0'} - - esutils@2.0.3: - resolution: {integrity: sha512-kVscqXk4OCp68SZ0dkgEKVi6/8ij300KBWTJq32P/dYeWTSwK41WyTxalN1eRmA5Z9UU/LX9D7FWSmV9SAYx6g==} - engines: {node: '>=0.10.0'} - - etag@1.8.1: - resolution: {integrity: sha512-aIL5Fx7mawVa300al2BnEE4iNvo1qETxLrPI/o05L7z6go7fCw1J6EQmbK4FmJ2AS7kgVF/KEZWufBfdClMcPg==} - engines: {node: '>= 0.6'} - - eth-ens-namehash@2.0.8: - resolution: {integrity: sha512-VWEI1+KJfz4Km//dadyvBBoBeSQ0MHTXPvr8UIXiLW6IanxvAV+DmlZAijZwAyggqGUfwQBeHf7tc9wzc1piSw==} - - eth-gas-reporter@0.2.27: - resolution: {integrity: sha512-femhvoAM7wL0GcI8ozTdxfuBtBFJ9qsyIAsmKVjlWAHUbdnnXHt+lKzz/kmldM5lA9jLuNHGwuIxorNpLbR1Zw==} - peerDependencies: - '@codechecks/client': ^0.1.0 - peerDependenciesMeta: - '@codechecks/client': - optional: true - - eth-lib@0.1.29: - resolution: {integrity: sha512-bfttrr3/7gG4E02HoWTDUcDDslN003OlOoBxk9virpAZQ1ja/jDgwkWB8QfJF7ojuEowrqy+lzp9VcJG7/k5bQ==} - - eth-lib@0.2.8: - resolution: {integrity: sha512-ArJ7x1WcWOlSpzdoTBX8vkwlkSQ85CjjifSZtV4co64vWxSV8geWfPI9x4SVYu3DSxnX4yWFVTtGL+j9DUFLNw==} - - ethereum-bloom-filters@1.1.0: - resolution: {integrity: sha512-J1gDRkLpuGNvWYzWslBQR9cDV4nd4kfvVTE/Wy4Kkm4yb3EYRSlyi0eB/inTsSTTVyA0+HyzHgbr95Fn/Z1fSw==} - - ethereum-cryptography@0.1.3: - resolution: {integrity: sha512-w8/4x1SGGzc+tO97TASLja6SLd3fRIK2tLVcV2Gx4IB21hE19atll5Cq9o3d0ZmAYC/8aw0ipieTSiekAea4SQ==} - - ethereum-cryptography@1.2.0: - resolution: {integrity: sha512-6yFQC9b5ug6/17CQpCyE3k9eKBMdhyVjzUy1WkiuY/E4vj/SXDBbCw8QEIaXqf0Mf2SnY6RmpDcwlUmBSS0EJw==} - - ethereum-cryptography@2.1.3: - resolution: {integrity: sha512-BlwbIL7/P45W8FGW2r7LGuvoEZ+7PWsniMvQ4p5s2xCyw9tmaDlpfsN9HjAucbF+t/qpVHwZUisgfK24TCW8aA==} - - ethereum-ens@0.8.0: - resolution: {integrity: sha512-a8cBTF4AWw1Q1Y37V1LSCS9pRY4Mh3f8vCg5cbXCCEJ3eno1hbI/+Ccv9SZLISYpqQhaglP3Bxb/34lS4Qf7Bg==} - - ethereumjs-abi@0.6.8: - resolution: {integrity: sha512-Tx0r/iXI6r+lRsdvkFDlut0N08jWMnKRZ6Gkq+Nmw75lZe4e6o3EkSnkaBP5NF6+m5PTGAr9JP43N3LyeoglsA==} - - ethereumjs-util@6.2.1: - resolution: {integrity: sha512-W2Ktez4L01Vexijrm5EB6w7dg4n/TgpoYU4avuT5T3Vmnw/eCRtiBrJfQYS/DCSvDIOLn2k57GcHdeBcgVxAqw==} - - ethereumjs-util@7.1.5: - resolution: {integrity: sha512-SDl5kKrQAudFBUe5OJM9Ac6WmMyYmXX/6sTmLZ3ffG2eY6ZIGBes3pEDxNN6V72WyOw4CPD5RomKdsa8DAAwLg==} - engines: {node: '>=10.0.0'} - - ethers@4.0.49: - resolution: {integrity: sha512-kPltTvWiyu+OktYy1IStSO16i2e7cS9D9OxZ81q2UUaiNPVrm/RTcbxamCXF9VUSKzJIdJV68EAIhTEVBalRWg==} - - ethers@5.7.2: - resolution: {integrity: sha512-wswUsmWo1aOK8rR7DIKiWSw9DbLWe6x98Jrn8wcTflTVvaXhAMaB5zGAXy0GYQEQp9iO1iSHWVyARQm11zUtyg==} - - ethers@6.12.1: - resolution: {integrity: sha512-j6wcVoZf06nqEcBbDWkKg8Fp895SS96dSnTCjiXT+8vt2o02raTn4Lo9ERUuIVU5bAjoPYeA+7ytQFexFmLuVw==} - engines: {node: '>=14.0.0'} - - ethjs-abi@0.1.8: - resolution: {integrity: sha512-3SIJpF+LCVJrNht9OjSJ7+3B9ABZf6dEATMj1PaslL0BW547Cz6/kGyuDvvrcEBlSsbGpCWYrJX5B8OjhcAMFQ==} - engines: {node: '>=6.5.0', npm: '>=3'} - - ethjs-unit@0.1.6: - resolution: {integrity: sha512-/Sn9Y0oKl0uqQuvgFk/zQgR7aw1g36qX/jzSQ5lSwlO0GigPymk4eGQfeNTD03w1dPOqfz8V77Cy43jH56pagw==} - engines: {node: '>=6.5.0', npm: '>=3'} - - ethjs-util@0.1.6: - resolution: {integrity: sha512-CUnVOQq7gSpDHZVVrQW8ExxUETWrnrvXYvYz55wOU8Uj4VCgw56XC2B/fVqQN+f7gmrnRHSLVnFAwsCuNwji8w==} - engines: {node: '>=6.5.0', npm: '>=3'} - - event-emitter@0.3.5: - resolution: {integrity: sha512-D9rRn9y7kLPnJ+hMq7S/nhvoKwwvVJahBi2BPmx3bvbsEdK3W9ii8cBSGjP+72/LnM4n6fo3+dkCX5FeTQruXA==} - - eventemitter3@4.0.4: - resolution: {integrity: sha512-rlaVLnVxtxvoyLsQQFBx53YmXHDxRIzzTLbdfxqi4yocpSjAxXwkU0cScM5JgSKMqEhrZpnvQ2D9gjylR0AimQ==} - - eventemitter3@5.0.1: - resolution: {integrity: sha512-GWkBvjiSZK87ELrYOSESUYeVIc9mvLLf/nXalMOS5dYrgZq9o5OVkbZAVM06CVxYsCwH9BDZFPlQTlPA1j4ahA==} - - events@3.3.0: - resolution: {integrity: sha512-mQw+2fkQbALzQ7V0MY0IqdnXNOeTtP4r0lN9z7AAawCXgqea7bDii20AYrIBrFd/Hx0M2Ocz6S111CaFkUcb0Q==} - engines: {node: '>=0.8.x'} - - evp_bytestokey@1.0.3: - resolution: {integrity: sha512-/f2Go4TognH/KvCISP7OUsHn85hT9nUkxxA9BEWxFn+Oj9o8ZNLm/40hdlgSLyuOimsrTKLUMEorQexp/aPQeA==} - - expand-template@2.0.3: - resolution: {integrity: sha512-XYfuKMvj4O35f/pOXLObndIRvyQ+/+6AhODh+OKWj9S9498pHHn/IMszH+gt0fBCRWMNfk1ZSp5x3AifmnI2vg==} - engines: {node: '>=6'} - - express@4.19.2: - resolution: {integrity: sha512-5T6nhjsT+EOMzuck8JjBHARTHfMht0POzlA60WV2pMD3gyXw2LZnZ+ueGdNxG+0calOJcWKbpFcuzLZ91YWq9Q==} - engines: {node: '>= 0.10.0'} - - ext@1.7.0: - resolution: {integrity: sha512-6hxeJYaL110a9b5TEJSj0gojyHQAmA2ch5Os+ySCiA1QGdS697XWY1pzsrSjqA9LDEEgdB/KypIlR59RcLuHYw==} - - extend@3.0.2: - resolution: {integrity: sha512-fjquC59cD7CyW6urNXK0FBufkZcoiGG80wTuPujX590cB5Ttln20E2UB4S/WARVqhXffZl2LNgS+gQdPIIim/g==} - - extendable-error@0.1.7: - resolution: {integrity: sha512-UOiS2in6/Q0FK0R0q6UY9vYpQ21mr/Qn1KOnte7vsACuNJf514WvCCUHSRCPcgjPT2bAhNIJdlE6bVap1GKmeg==} - - external-editor@3.1.0: - resolution: {integrity: sha512-hMQ4CX1p1izmuLYyZqLMO/qGNw10wSv9QDCPfzXfyFrOaCSSoRfqE1Kf1s5an66J5JZC62NewG+mK49jOCtQew==} - engines: {node: '>=4'} - - extsprintf@1.3.0: - resolution: {integrity: sha512-11Ndz7Nv+mvAC1j0ktTa7fAb0vLyGGX+rMHNBYQviQDGU0Hw7lhctJANqbPhu9nV9/izT/IntTgZ7Im/9LJs9g==} - engines: {'0': node >=0.6.0} - - fast-check@3.1.1: - resolution: {integrity: sha512-3vtXinVyuUKCKFKYcwXhGE6NtGWkqF8Yh3rvMZNzmwz8EPrgoc/v4pDdLHyLnCyCI5MZpZZkDEwFyXyEONOxpA==} - engines: {node: '>=8.0.0'} - - fast-deep-equal@1.1.0: - resolution: {integrity: sha512-fueX787WZKCV0Is4/T2cyAdM4+x1S3MXXOAhavE1ys/W42SHAPacLTQhucja22QBYrfGw50M2sRiXPtTGv9Ymw==} - - fast-deep-equal@3.1.3: - resolution: {integrity: sha512-f3qQ9oQy9j2AhBe/H9VC91wLmKBCCU/gDOnKNAYG5hswO7BLKj09Hc5HYNz9cGI++xlpDCIgDaitVs03ATR84Q==} - - fast-diff@1.3.0: - resolution: {integrity: sha512-VxPP4NqbUjj6MaAOafWeUn2cXWLcCtljklUtZf0Ind4XQ+QPtmA0b18zZy0jIQx+ExRVCR/ZQpBmik5lXshNsw==} - - fast-glob@3.3.2: - resolution: {integrity: sha512-oX2ruAFQwf/Orj8m737Y5adxDQO0LAB7/S5MnxCdTNDd4p6BsyIVsv9JQsATbTSq8KHRpLwIHbVlUNatxd+1Ow==} - engines: {node: '>=8.6.0'} - - fast-json-stable-stringify@2.1.0: - resolution: {integrity: sha512-lhd/wF+Lk98HZoTCtlVraHtfh5XYijIjalXck7saUtuanSDyLMxnHhSXEDJqHxD7msR8D0uCmqlkwjCV8xvwHw==} - - fast-levenshtein@2.0.6: - resolution: {integrity: sha512-DCXu6Ifhqcks7TZKY3Hxp3y6qphY5SJZmrWMDrKcERSOXWQdMhU9Ig/PYrzyw/ul9jOIyh0N4M0tbC5hodg8dw==} - - fast-safe-stringify@2.1.1: - resolution: {integrity: sha512-W+KJc2dmILlPplD/H4K9l9LcAHAfPtP6BY84uVLXQ6Evcz9Lcg33Y2z1IVblT6xdY54PXYVHEv+0Wpq8Io6zkA==} - - fastq@1.17.1: - resolution: {integrity: sha512-sRVD3lWVIXWg6By68ZN7vho9a1pQcN/WBFaAAsDDFzlJjvoGx0P8z7V1t72grFJfJhu3YPZBuu25f7Kaw2jN1w==} - - file-entry-cache@6.0.1: - resolution: {integrity: sha512-7Gps/XWymbLk2QLYK4NzpMOrYjMhdIxXuIvy2QBsLE6ljuodKvdkWs/cpyJJ3CVIVpH0Oi1Hvg1ovbMzLdFBBg==} - engines: {node: ^10.12.0 || >=12.0.0} - - file-uri-to-path@1.0.0: - resolution: {integrity: sha512-0Zt+s3L7Vf1biwWZ29aARiVYLx7iMGnEUl9x33fbB/j3jR81u/O2LbqK+Bm1CDSNDKVtJ/YjwY7TUd5SkeLQLw==} - - fill-range@7.0.1: - resolution: {integrity: sha512-qOo9F+dMUmC2Lcb4BbVvnKJxTPjCm+RRpe4gDuGrzkL7mEVl/djYSu2OdQ2Pa302N4oqkSg9ir6jaLWJ2USVpQ==} - engines: {node: '>=8'} - - finalhandler@1.2.0: - resolution: {integrity: sha512-5uXcUVftlQMFnWC9qu/svkWv3GTd2PfUhK/3PLkYNAe7FbqJMt3515HaxE6eRL74GdsriiwujiawdaB1BpEISg==} - engines: {node: '>= 0.8'} - - find-cache-dir@3.3.2: - resolution: {integrity: sha512-wXZV5emFEjrridIgED11OoUKLxiYjAcqot/NJdAkOhlJ+vGzwhOAfcG5OX1jP+S0PcjEn8bdMJv+g2jwQ3Onig==} - engines: {node: '>=8'} - - find-replace@3.0.0: - resolution: {integrity: sha512-6Tb2myMioCAgv5kfvP5/PkZZ/ntTpVK39fHY7WkWBgvbeE+VHd/tZuZ4mrC+bxh4cfOZeYKVPaJIZtZXV7GNCQ==} - engines: {node: '>=4.0.0'} - - find-up@1.1.2: - resolution: {integrity: sha512-jvElSjyuo4EMQGoTwo1uJU5pQMwTW5lS1x05zzfJuTIyLR3zwO27LYrxNg+dlvKpGOuGy/MzBdXh80g0ve5+HA==} - engines: {node: '>=0.10.0'} - - find-up@2.1.0: - resolution: {integrity: sha512-NWzkk0jSJtTt08+FBFMvXoeZnOJD+jTtsRmBYbAIzJdX6l7dLgR7CTubCM5/eDdPUBvLCeVasP1brfVR/9/EZQ==} - engines: {node: '>=4'} - - find-up@4.1.0: - resolution: {integrity: sha512-PpOwAdQ/YlXQ2vj8a3h8IipDuYRi3wceVQQGYWxNINccq40Anw7BlsEXCMbt1Zt+OLA6Fq9suIpIWD0OsnISlw==} - engines: {node: '>=8'} - - find-up@5.0.0: - resolution: {integrity: sha512-78/PXT1wlLLDgTzDs7sjq9hzz0vXD+zn+7wypEe4fXQxCmdmqfGsEPQxmiCSQI3ajFV91bVSsvNtrJRiW6nGng==} - engines: {node: '>=10'} - - find-yarn-workspace-root2@1.2.16: - resolution: {integrity: sha512-hr6hb1w8ePMpPVUK39S4RlwJzi+xPLuVuG8XlwXU3KD5Yn3qgBWVfy3AzNlDhWvE1EORCE65/Qm26rFQt3VLVA==} - - flat-cache@3.2.0: - resolution: {integrity: sha512-CYcENa+FtcUKLmhhqyctpclsq7QF38pKjZHsGNiSQF5r4FtoKDWabFDl3hzaEQMvT1LHEysw5twgLvpYYb4vbw==} - engines: {node: ^10.12.0 || >=12.0.0} - - flat@5.0.2: - resolution: {integrity: sha512-b6suED+5/3rTpUBdG1gupIl8MPFCAMA0QXwmljLhvCUKcUvdE4gWky9zpuGCcXHOsz4J9wPGNWq6OKpmIzz3hQ==} - hasBin: true - - flatted@3.3.1: - resolution: {integrity: sha512-X8cqMLLie7KsNUDSdzeN8FYK9rEt4Dt67OsG/DNGnYTSDBG4uFAJFBnUeiV+zCVAvwFy56IjM9sH51jVaEhNxw==} - - follow-redirects@1.15.6: - resolution: {integrity: sha512-wWN62YITEaOpSK584EZXJafH1AGpO8RVgElfkuXbTOrPX4fIfOyEpW/CsiNd8JdYrAoOvafRTOEnvsO++qCqFA==} - engines: {node: '>=4.0'} - peerDependencies: - debug: '*' - peerDependenciesMeta: - debug: - optional: true - - for-each@0.3.3: - resolution: {integrity: sha512-jqYfLp7mo9vIyQf8ykW2v7A+2N4QjeCeI5+Dz9XraiO1ign81wjiH7Fb9vSOWvQfNtmSa4H2RoQTrrXivdUZmw==} - - foreground-child@2.0.0: - resolution: {integrity: sha512-dCIq9FpEcyQyXKCkyzmlPTFNgrCzPudOe+mhvJU5zAtlBnGVy2yKxtfsxK2tQBThwq225jcvBjpw1Gr40uzZCA==} - engines: {node: '>=8.0.0'} - - forever-agent@0.6.1: - resolution: {integrity: sha512-j0KLYPhm6zeac4lz3oJ3o65qvgQCcPubiyotZrXqEaG4hNagNYO8qdlUrX5vwqv9ohqeT/Z3j6+yW067yWWdUw==} - - form-data-encoder@1.7.1: - resolution: {integrity: sha512-EFRDrsMm/kyqbTQocNvRXMLjc7Es2Vk+IQFx/YW7hkUH1eBl4J1fqiP34l74Yt0pFLCNpc06fkbVk00008mzjg==} - - form-data@2.3.3: - resolution: {integrity: sha512-1lLKB2Mu3aGP1Q/2eCOx0fNbRMe7XdwktwOruhfqqd0rIJWwN4Dh+E3hrPSlDCXnSR7UtZ1N38rVXm+6+MEhJQ==} - engines: {node: '>= 0.12'} - - form-data@2.5.1: - resolution: {integrity: sha512-m21N3WOmEEURgk6B9GLOE4RuWOFf28Lhh9qGYeNlGq4VDXUlJy2th2slBNU8Gp8EzloYZOibZJ7t5ecIrFSjVA==} - engines: {node: '>= 0.12'} - - form-data@4.0.0: - resolution: {integrity: sha512-ETEklSGi5t0QMZuiXoA/Q6vcnxcLQP5vdugSpuAyi6SVGi2clPPp+xgEhuMaHC+zGgn31Kd235W35f7Hykkaww==} - engines: {node: '>= 6'} - - forwarded@0.2.0: - resolution: {integrity: sha512-buRG0fpBtRHSTCOASe6hD258tEubFoRLb4ZNA6NxMVHNw2gOcwHo9wyablzMzOA5z9xA9L1KNjk/Nt6MT9aYow==} - engines: {node: '>= 0.6'} - - fp-ts@1.19.3: - resolution: {integrity: sha512-H5KQDspykdHuztLTg+ajGN0Z2qUjcEf3Ybxc6hLt0k7/zPkn29XnKnxlBPyW2XIddWrGaJBzBl4VLYOtk39yZg==} - - fresh@0.5.2: - resolution: {integrity: sha512-zJ2mQYM18rEFOudeV4GShTGIQ7RbzA7ozbU9I/XBpm7kqgMywgmylMwXHxZJmkVoYkna9d2pVXVXPdYTP9ej8Q==} - engines: {node: '>= 0.6'} - - fromentries@1.3.2: - resolution: {integrity: sha512-cHEpEQHUg0f8XdtZCc2ZAhrHzKzT0MrFUTcvx+hfxYu7rGMDc5SKoXFh+n4YigxsHXRzc6OrCshdR1bWH6HHyg==} - - fs-constants@1.0.0: - resolution: {integrity: sha512-y6OAwoSIf7FyjMIv94u+b5rdheZEjzR63GTyZJm5qh4Bi+2YgwLCcI/fPFZkL5PSixOt6ZNKm+w+Hfp/Bciwow==} - - fs-extra@0.30.0: - resolution: {integrity: sha512-UvSPKyhMn6LEd/WpUaV9C9t3zATuqoqfWc3QdPhPLb58prN9tqYPlPWi8Krxi44loBoUzlobqZ3+8tGpxxSzwA==} - - fs-extra@10.1.0: - resolution: {integrity: sha512-oRXApq54ETRj4eMiFzGnHWGy+zo5raudjuxN0b8H7s/RU2oW0Wvsx9O0ACRN/kRq9E8Vu/ReskGB5o3ji+FzHQ==} - engines: {node: '>=12'} - - fs-extra@4.0.3: - resolution: {integrity: sha512-q6rbdDd1o2mAnQreO7YADIxf/Whx4AHBiRf6d+/cVT8h44ss+lHgxf1FemcqDnQt9X3ct4McHr+JMGlYSsK7Cg==} - - fs-extra@7.0.1: - resolution: {integrity: sha512-YJDaCJZEnBmcbw13fvdAM9AwNOJwOzrE4pqMqBq5nFiEqXUqHwlK4B+3pUw6JNvfSPtX05xFHtYy/1ni01eGCw==} - engines: {node: '>=6 <7 || >=8'} - - fs-extra@8.1.0: - resolution: {integrity: sha512-yhlQgA6mnOJUKOsRUFsgJdQCvkKhcz8tlZG5HBQfReYZy46OwLcY+Zia0mtdHsOo9y/hP+CxMN0TU9QxoOtG4g==} - engines: {node: '>=6 <7 || >=8'} - - fs-extra@9.1.0: - resolution: {integrity: sha512-hcg3ZmepS30/7BSFqRvoo3DOMQu7IjqxO5nCDt+zM9XWjb33Wg7ziNT+Qvqbuc3+gWpzO02JubVyk2G4Zvo1OQ==} - engines: {node: '>=10'} - - fs-minipass@1.2.7: - resolution: {integrity: sha512-GWSSJGFy4e9GUeCcbIkED+bgAoFyj7XF1mV8rma3QW4NIqX9Kyx79N/PF61H5udOV3aY1IaMLs6pGbH71nlCTA==} - - fs-readdir-recursive@1.1.0: - resolution: {integrity: sha512-GNanXlVr2pf02+sPN40XN8HG+ePaNcvM0q5mZBd668Obwb0yD5GiUbZOFgwn8kGMY6I3mdyDJzieUy3PTYyTRA==} - - fs.realpath@1.0.0: - resolution: {integrity: sha512-OO0pH2lK6a0hZnAdau5ItzHPI6pUlvI7jMVnxUQRtw4owF2wk8lOSabtGDCTP4Ggrg2MbGnWO9X8K1t4+fGMDw==} - - fsevents@2.3.3: - resolution: {integrity: sha512-5xoDfX+fL7faATnagmWPpbFtwh/R77WmMMqqHGS65C3vvB0YHrgF+B1YmZ3441tMj5n63k0212XNoJwzlhffQw==} - engines: {node: ^8.16.0 || ^10.6.0 || >=11.0.0} - os: [darwin] - - function-bind@1.1.2: - resolution: {integrity: sha512-7XHNxH7qX9xG5mIwxkhumTox/MIRNcOgDrxWsMt2pAr23WHp6MrRlN7FBSFpCpr+oVO0F744iUgR82nJMfG2SA==} - - function.prototype.name@1.1.6: - resolution: {integrity: sha512-Z5kx79swU5P27WEayXM1tBi5Ze/lbIyiNgU3qyXUOf9b2rgXYyF9Dy9Cx+IQv/Lc8WCG6L82zwUPpSS9hGehIg==} - engines: {node: '>= 0.4'} - - functions-have-names@1.2.3: - resolution: {integrity: sha512-xckBUXyTIqT97tq2x2AMb+g163b5JFysYk0x4qxNFwbfQkmNZoiRHb6sPzI9/QV33WeuvVYBUIiD4NzNIyqaRQ==} - - ganache-cli@6.12.2: - resolution: {integrity: sha512-bnmwnJDBDsOWBUP8E/BExWf85TsdDEFelQSzihSJm9VChVO1SHp94YXLP5BlA4j/OTxp0wR4R1Tje9OHOuAJVw==} - deprecated: ganache-cli is now ganache; visit https://trfl.io/g7 for details - hasBin: true - bundledDependencies: - - source-map-support - - yargs - - ethereumjs-util - - gensync@1.0.0-beta.2: - resolution: {integrity: sha512-3hN7NaskYvMDLQY55gnW3NQ+mesEAepTqlg+VEbj7zzqEMBVNhzcGYYeqFo/TlYz6eQiFcp1HcsCZO+nGgS8zg==} - engines: {node: '>=6.9.0'} - - get-caller-file@1.0.3: - resolution: {integrity: sha512-3t6rVToeoZfYSGd8YoLFR2DJkiQrIiUrGcjvFX2mDw3bn6k2OtwHN0TNCLbBO+w8qTvimhDkv+LSscbJY1vE6w==} - - get-caller-file@2.0.5: - resolution: {integrity: sha512-DyFP3BM/3YHTQOCUL/w0OZHR0lpKeGrxotcHWcqNEdnltqFwXVfhEBQ94eIo34AfQpo0rGki4cyIiftY06h2Fg==} - engines: {node: 6.* || 8.* || >= 10.*} - - get-func-name@2.0.2: - resolution: {integrity: sha512-8vXOvuE167CtIc3OyItco7N/dpRtBbYOsPsXCz7X/PMnlGjYjSGuZJgM1Y7mmew7BKf9BqvLX2tnOVy1BBUsxQ==} - - get-intrinsic@1.2.4: - resolution: {integrity: sha512-5uYhsJH8VJBTv7oslg4BznJYhDoRI6waYCxMmCdnTrcCrHA/fCFKoTFz2JKKE0HdDFUF7/oQuhzumXJK7paBRQ==} - engines: {node: '>= 0.4'} - - get-package-type@0.1.0: - resolution: {integrity: sha512-pjzuKtY64GYfWizNAJ0fr9VqttZkNiK2iS430LtIHzjBEr6bX8Am2zm4sW4Ro5wjWW5cAlRL1qAMTcXbjNAO2Q==} - engines: {node: '>=8.0.0'} - - get-port@3.2.0: - resolution: {integrity: sha512-x5UJKlgeUiNT8nyo/AcnwLnZuZNcSjSw0kogRB+Whd1fjjFq4B1hySFxSFWWSn4mIBzg3sRNUDFYc4g5gjPoLg==} - engines: {node: '>=4'} - - get-port@5.1.1: - resolution: {integrity: sha512-g/Q1aTSDOxFpchXC4i8ZWvxA1lnPqx/JHqcpIw0/LX9T8x/GBbi6YnlN5nhaKIFkT8oFsscUKgDJYxfwfS6QsQ==} - engines: {node: '>=8'} - - get-stream@5.2.0: - resolution: {integrity: sha512-nBF+F1rAZVCu/p7rjzgA+Yb4lfYXrpl7a6VmJrU8wF9I1CKvP/QwPNZHnOlwbTkY6dvtFIzFMSyQXbLoTQPRpA==} - engines: {node: '>=8'} - - get-stream@6.0.1: - resolution: {integrity: sha512-ts6Wi+2j3jQjqi70w5AlN8DFnkSwC+MqmxEzdEALB2qXZYV3X/b1CTfgPLGJNMeAWxdPfU8FO1ms3NUfaHCPYg==} - engines: {node: '>=10'} - - get-symbol-description@1.0.2: - resolution: {integrity: sha512-g0QYk1dZBxGwk+Ngc+ltRH2IBp2f7zBkBMBJZCDerh6EhlhSR6+9irMCuT/09zD6qkarHUSn529sK/yL4S27mg==} - engines: {node: '>= 0.4'} - - get-tsconfig@4.7.5: - resolution: {integrity: sha512-ZCuZCnlqNzjb4QprAzXKdpp/gh6KTxSJuw3IBsPnV/7fV4NxC9ckB+vPTt8w7fJA0TaSD7c55BR47JD6MEDyDw==} - - getpass@0.1.7: - resolution: {integrity: sha512-0fzj9JxOLfJ+XGLhR8ze3unN0KZCgZwiSSDz168VERjK8Wl8kVSdcu2kspd4s4wtAa1y/qrVRiAA0WclVsu0ng==} - - ghost-testrpc@0.0.2: - resolution: {integrity: sha512-i08dAEgJ2g8z5buJIrCTduwPIhih3DP+hOCTyyryikfV8T0bNvHnGXO67i0DD1H4GBDETTclPy9njZbfluQYrQ==} - hasBin: true - - github-from-package@0.0.0: - resolution: {integrity: sha512-SyHy3T1v2NUXn29OsWdxmK6RwHD+vkj3v8en8AOBZ1wBQ/hCAQ5bAQTD02kW4W9tUp/3Qh6J8r9EvntiyCmOOw==} - - glob-parent@5.1.2: - resolution: {integrity: sha512-AOIgSQCepiJYwP3ARnGx+5VnTu2HBYdzbGP45eLw1vr3zB3vZLeyed1sC9hnbcOc9/SrMyM5RPQrkGz4aS9Zow==} - engines: {node: '>= 6'} - - glob-parent@6.0.2: - resolution: {integrity: sha512-XxwI8EOhVQgWp6iDL+3b0r86f4d6AX6zSU55HfB4ydCEuXLXc5FcYeOu+nnGftS4TEju/11rt4KJPTMgbfmv4A==} - engines: {node: '>=10.13.0'} - - glob@5.0.15: - resolution: {integrity: sha512-c9IPMazfRITpmAAKi22dK1VKxGDX9ehhqfABDriL/lzO92xcUKEJPQHrVA/2YHSNFB4iFlykVmWvwo48nr3OxA==} - - glob@7.1.7: - resolution: {integrity: sha512-OvD9ENzPLbegENnYP5UUfJIirTg4+XwMWGaQfQTY0JenxNvvIKP3U3/tAQSPIu/lHxXYSZmpXlUHeqAIdKzBLQ==} - - glob@7.2.0: - resolution: {integrity: sha512-lmLf6gtyrPq8tTjSmrO94wBeQbFR3HbLHbuyD69wuyQkImp2hWqMGB47OX65FBkPffO641IP9jWa1z4ivqG26Q==} - - glob@8.1.0: - resolution: {integrity: sha512-r8hpEjiQEYlF2QU0df3dS+nxxSIreXQS1qRhMJM0Q5NDdR386C7jb7Hwwod8Fgiuex+k0GFjgft18yvxm5XoCQ==} - engines: {node: '>=12'} - - global-modules@2.0.0: - resolution: {integrity: sha512-NGbfmJBp9x8IxyJSd1P+otYK8vonoJactOogrVfFRIAEY1ukil8RSKDz2Yo7wh1oihl51l/r6W4epkeKJHqL8A==} - engines: {node: '>=6'} - - global-prefix@3.0.0: - resolution: {integrity: sha512-awConJSVCHVGND6x3tmMaKcQvwXLhjdkmomy2W+Goaui8YPgYgXJZewhg3fWC+DlfqqQuWg8AwqjGTD2nAPVWg==} - engines: {node: '>=6'} - - global@4.4.0: - resolution: {integrity: sha512-wv/LAoHdRE3BeTGz53FAamhGlPLhlssK45usmGFThIi4XqnBmjKQ16u+RNbP7WvigRZDxUsM0J3gcQ5yicaL0w==} - - globals@11.12.0: - resolution: {integrity: sha512-WOBp/EEGUiIsJSp7wcv/y6MO+lV9UoncWqxuFfm8eBwzWNgyfBd6Gz+IeKQ9jCmyhoH99g15M3T+QaVHFjizVA==} - engines: {node: '>=4'} - - globals@13.24.0: - resolution: {integrity: sha512-AhO5QUcj8llrbG09iWhPU2B204J1xnPeL8kQmVorSsy+Sjj1sk8gIyh6cUocGmH4L0UuhAJy+hJMRA4mgA4mFQ==} - engines: {node: '>=8'} - - globalthis@1.0.4: - resolution: {integrity: sha512-DpLKbNU4WylpxJykQujfCcwYWiV/Jhm50Goo0wrVILAv5jOr9d+H+UR3PhSCD2rCCEIg0uc+G+muBTwD54JhDQ==} - engines: {node: '>= 0.4'} - - globby@10.0.2: - resolution: {integrity: sha512-7dUi7RvCoT/xast/o/dLN53oqND4yk0nsHkhRgn9w65C4PofCLOoJ39iSOg+qVDdWQPIEj+eszMHQ+aLVwwQSg==} - engines: {node: '>=8'} - - globby@11.1.0: - resolution: {integrity: sha512-jhIXaOzy1sb8IyocaruWSn1TjmnBVs8Ayhcy83rmxNJ8q2uWKCAj3CnJY+KpGSXCueAPc0i05kVvVKtP1t9S3g==} - engines: {node: '>=10'} - - gopd@1.0.1: - resolution: {integrity: sha512-d65bNlIadxvpb/A2abVdlqKqV563juRnZ1Wtk6s1sIR8uNsXR70xqIzVqxVf1eTqDunwT2MkczEeaezCKTZhwA==} - - got@11.8.6: - resolution: {integrity: sha512-6tfZ91bOr7bOXnK7PRDCGBLa1H4U080YHNaAQ2KsMGlLEzRbk44nsZF2E1IeRc3vtJHPVbKCYgdFbaGO2ljd8g==} - engines: {node: '>=10.19.0'} - - got@12.1.0: - resolution: {integrity: sha512-hBv2ty9QN2RdbJJMK3hesmSkFTjVIHyIDDbssCKnSmq62edGgImJWD10Eb1k77TiV1bxloxqcFAVK8+9pkhOig==} - engines: {node: '>=14.16'} - - graceful-fs@4.2.11: - resolution: {integrity: sha512-RbJ5/jmFcNNCcDV5o9eTnBLJ/HszWV0P73bc+Ff4nS/rJj+YaS6IGyiOL0VoBYX+l1Wrl3k63h/KrH+nhJ0XvQ==} - - grapheme-splitter@1.0.4: - resolution: {integrity: sha512-bzh50DW9kTPM00T8y4o8vQg89Di9oLJVLW/KaOGIXJWP/iqCN6WKYkbNOF04vFLJhwcpYUh9ydh/+5vpOqV4YQ==} - - graphemer@1.4.0: - resolution: {integrity: sha512-EtKwoO6kxCL9WO5xipiHTZlSzBm7WLT627TqC/uVRd0HKmq8NXyebnNYxDoBi7wt8eTWrUrKXCOVaFq9x1kgag==} - - handlebars@4.7.8: - resolution: {integrity: sha512-vafaFqs8MZkRrSX7sFVUdo3ap/eNiLnb4IakshzvP56X5Nr1iGKAIqdX6tMlm6HcNRIkr6AxO5jFEoJzzpT8aQ==} - engines: {node: '>=0.4.7'} - hasBin: true - - har-schema@2.0.0: - resolution: {integrity: sha512-Oqluz6zhGX8cyRaTQlFMPw80bSJVG2x/cFb8ZPhUILGgHka9SsokCCOQgpveePerqidZOrT14ipqfJb7ILcW5Q==} - engines: {node: '>=4'} - - har-validator@5.1.5: - resolution: {integrity: sha512-nmT2T0lljbxdQZfspsno9hgrG3Uir6Ks5afism62poxqBM6sDnMEuPmzTq8XN0OEwqKLLdh1jQI3qyE66Nzb3w==} - engines: {node: '>=6'} - deprecated: this library is no longer supported - - hard-rejection@2.1.0: - resolution: {integrity: sha512-VIZB+ibDhx7ObhAe7OVtoEbuP4h/MuOTHJ+J8h/eBXotJYl0fBgR72xDFCKgIh22OJZIOVNxBMWuhAr10r8HdA==} - engines: {node: '>=6'} - - hardhat-gas-reporter@1.0.10: - resolution: {integrity: sha512-02N4+So/fZrzJ88ci54GqwVA3Zrf0C9duuTyGt0CFRIh/CdNwbnTgkXkRfojOMLBQ+6t+lBIkgbsOtqMvNwikA==} - peerDependencies: - hardhat: ^2.0.2 - - has-bigints@1.0.2: - resolution: {integrity: sha512-tSvCKtBr9lkF0Ex0aQiP9N+OpV4zi2r/Nee5VkRDbaqv35RLYMzbwQfFSZZH0kR+Rd6302UJZ2p/bJCEoR3VoQ==} - - has-color@0.1.7: - resolution: {integrity: sha512-kaNz5OTAYYmt646Hkqw50/qyxP2vFnTVu5AQ1Zmk22Kk5+4Qx6BpO8+u7IKsML5fOsFk0ZT0AcCJNYwcvaLBvw==} - engines: {node: '>=0.10.0'} - - has-flag@1.0.0: - resolution: {integrity: sha512-DyYHfIYwAJmjAjSSPKANxI8bFY9YtFrgkAfinBojQ8YJTOuOuav64tMUJv584SES4xl74PmuaevIyaLESHdTAA==} - engines: {node: '>=0.10.0'} - - has-flag@3.0.0: - resolution: {integrity: sha512-sKJf1+ceQBr4SMkvQnBDNDtf4TXpVhVGateu0t918bl30FnbE2m4vNLX+VWe/dpjlb+HugGYzW7uQXH98HPEYw==} - engines: {node: '>=4'} - - has-flag@4.0.0: - resolution: {integrity: sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ==} - engines: {node: '>=8'} - - has-property-descriptors@1.0.2: - resolution: {integrity: sha512-55JNKuIW+vq4Ke1BjOTjM2YctQIvCT7GFzHwmfZPGo5wnrgkid0YQtnAleFSqumZm4az3n2BS+erby5ipJdgrg==} - - has-proto@1.0.3: - resolution: {integrity: sha512-SJ1amZAJUiZS+PhsVLf5tGydlaVB8EdFpaSO4gmiUKUOxk8qzn5AIy4ZeJUmh22znIdk/uMAUT2pl3FxzVUH+Q==} - engines: {node: '>= 0.4'} - - has-symbols@1.0.3: - resolution: {integrity: sha512-l3LCuF6MgDNwTDKkdYGEihYjt5pRPbEg46rtlmnSPlUbgmB8LOIrKJbYYFBSbnPaJexMKtiPO8hmeRjRz2Td+A==} - engines: {node: '>= 0.4'} - - has-tostringtag@1.0.2: - resolution: {integrity: sha512-NqADB8VjPFLM2V0VvHUewwwsw0ZWBaIdgo+ieHtK3hasLz4qeCRjYcqfB6AQrBggRKppKF8L52/VqdVsO47Dlw==} - engines: {node: '>= 0.4'} - - has@1.0.4: - resolution: {integrity: sha512-qdSAmqLF6209RFj4VVItywPMbm3vWylknmB3nvNiUIs72xAimcM8nVYxYr7ncvZq5qzk9MKIZR8ijqD/1QuYjQ==} - engines: {node: '>= 0.4.0'} - - hash-base@3.1.0: - resolution: {integrity: sha512-1nmYp/rhMDiE7AYkDw+lLwlAzz0AntGIe51F3RfFfEqyQ3feY2eI/NcwC6umIQVOASPMsWJLJScWKSSvzL9IVA==} - engines: {node: '>=4'} - - hash.js@1.1.3: - resolution: {integrity: sha512-/UETyP0W22QILqS+6HowevwhEFJ3MBJnwTf75Qob9Wz9t0DPuisL8kW8YZMK62dHAKE1c1p+gY1TtOLY+USEHA==} - - hash.js@1.1.7: - resolution: {integrity: sha512-taOaskGt4z4SOANNseOviYDvjEJinIkRgmp7LbKP2YTTmVxWBl87s/uzK9r+44BclBSp2X7K1hqeNfz9JbBeXA==} - - hasha@5.2.2: - resolution: {integrity: sha512-Hrp5vIK/xr5SkeN2onO32H0MgNZ0f17HRNH39WfL0SYUNOTZ5Lz1TJ8Pajo/87dYGEFlLMm7mIc/k/s6Bvz9HQ==} - engines: {node: '>=8'} - - hasown@2.0.2: - resolution: {integrity: sha512-0hJU9SCPvmMzIBdZFqNPXWa6dqh7WdH0cII9y+CyS8rG3nL48Bclra9HmKhVVUHyPWNH5Y7xDwAB7bfgSjkUMQ==} - engines: {node: '>= 0.4'} - - he@1.2.0: - resolution: {integrity: sha512-F/1DnUGPopORZi0ni+CvrCgHQ5FyEAHRLSApuYWMmrbSwoN2Mn/7k+Gl38gJnR7yyDZk6WLXwiGod1JOWNDKGw==} - hasBin: true - - header-case@1.0.1: - resolution: {integrity: sha512-i0q9mkOeSuhXw6bGgiQCCBgY/jlZuV/7dZXyZ9c6LcBrqwvT8eT719E9uxE5LiZftdl+z81Ugbg/VvXV4OJOeQ==} - - heap@0.2.7: - resolution: {integrity: sha512-2bsegYkkHO+h/9MGbn6KWcE45cHZgPANo5LXF7EvWdT0yT2EguSVO1nDgU5c8+ZOPwp2vMNa7YFsJhVcDR9Sdg==} - - highlight.js@10.7.3: - resolution: {integrity: sha512-tzcUFauisWKNHaRkN4Wjl/ZA07gENAjFl3J/c480dprkGTg5EQstgaNFqBfUqCq54kZRIEcreTsAgF/m2quD7A==} - - highlightjs-solidity@2.0.6: - resolution: {integrity: sha512-DySXWfQghjm2l6a/flF+cteroJqD4gI8GSdL4PtvxZSsAHie8m3yVe2JFoRg03ROKT6hp2Lc/BxXkqerNmtQYg==} - - hmac-drbg@1.0.1: - resolution: {integrity: sha512-Tti3gMqLdZfhOQY1Mzf/AanLiqh1WTiJgEj26ZuYQ9fbkLomzGchCws4FyrSd4VkpBfiNhaE1On+lOz894jvXg==} - - hosted-git-info@2.8.9: - resolution: {integrity: sha512-mxIDAb9Lsm6DoOJ7xH+5+X4y1LU/4Hi50L9C5sIswK3JzULS4bwk1FvjdBgvYR4bzT4tuUQiC15FE2f5HbLvYw==} - - html-escaper@2.0.2: - resolution: {integrity: sha512-H2iMtd0I4Mt5eYiapRdIDjp+XzelXQ0tFE4JS7YFwFevXXMmOp9myNrUvCg0D6ws8iqkRPBfKHgbwig1SmlLfg==} - - htmlparser2@8.0.2: - resolution: {integrity: sha512-GYdjWKDkbRLkZ5geuHs5NY1puJ+PXwP7+fHPRz06Eirsb9ugf6d8kkXav6ADhcODhFFPMIXyxkxSuMf3D6NCFA==} - - http-basic@8.1.3: - resolution: {integrity: sha512-/EcDMwJZh3mABI2NhGfHOGOeOZITqfkEO4p/xK+l3NpyncIHUQBoMvCSF/b5GqvKtySC2srL/GGG3+EtlqlmCw==} - engines: {node: '>=6.0.0'} - - http-cache-semantics@4.1.1: - resolution: {integrity: sha512-er295DKPVsV82j5kw1Gjt+ADA/XYHsajl82cGNQG2eyoPkvgUhX+nDIyelzhIWbbsXP39EHcI6l5tYs2FYqYXQ==} - - http-errors@2.0.0: - resolution: {integrity: sha512-FtwrG/euBzaEjYeRqOgly7G0qviiXoJWnvEH2Z1plBdXgbyjv34pHTSb9zoeHMyDy33+DWy5Wt9Wo+TURtOYSQ==} - engines: {node: '>= 0.8'} - - http-https@1.0.0: - resolution: {integrity: sha512-o0PWwVCSp3O0wS6FvNr6xfBCHgt0m1tvPLFOCc2iFDKTRAXhB7m8klDf7ErowFH8POa6dVdGatKU5I1YYwzUyg==} - - http-response-object@3.0.2: - resolution: {integrity: sha512-bqX0XTF6fnXSQcEJ2Iuyr75yVakyjIDCqroJQ/aHfSdlM743Cwqoi2nDYMzLGWUcuTWGWy8AAvOKXTfiv6q9RA==} - - http-signature@1.2.0: - resolution: {integrity: sha512-CAbnr6Rz4CYQkLYUtSNXxQPUH2gK8f3iWexVlsnMeD+GjlsQ0Xsy1cOX+mN3dtxYomRy21CiOzU8Uhw6OwncEQ==} - engines: {node: '>=0.8', npm: '>=1.3.7'} - - http2-wrapper@1.0.3: - resolution: {integrity: sha512-V+23sDMr12Wnz7iTcDeJr3O6AIxlnvT/bmaAAAP/Xda35C90p9599p0F1eHR/N1KILWSoWVAiOMFjBBXaXSMxg==} - engines: {node: '>=10.19.0'} - - http2-wrapper@2.2.1: - resolution: {integrity: sha512-V5nVw1PAOgfI3Lmeaj2Exmeg7fenjhRUgz1lPSezy1CuhPYbgQtbQj4jZfEAEMlaL+vupsvhjqCyjzob0yxsmQ==} - engines: {node: '>=10.19.0'} - - https-proxy-agent@5.0.1: - resolution: {integrity: sha512-dFcAjpTQFgoLMzC2VwU+C/CbS7uRL0lWmxDITmqm7C+7F0Odmj6s9l6alZc6AELXhrnggM2CeWSXHGOdX2YtwA==} - engines: {node: '>= 6'} - - human-id@1.0.2: - resolution: {integrity: sha512-UNopramDEhHJD+VR+ehk8rOslwSfByxPIZyJRfV739NDhN5LF1fa1MqnzKm2lGTQRjNrjK19Q5fhkgIfjlVUKw==} - - iconv-lite@0.4.24: - resolution: {integrity: sha512-v3MXnZAcvnywkTUEZomIActle7RXXeedOR31wwl7VlyoXO4Qi9arvSenNQWne1TcRwhCL1HwLI21bEqdpj8/rA==} - engines: {node: '>=0.10.0'} - - idna-uts46-hx@2.3.1: - resolution: {integrity: sha512-PWoF9Keq6laYdIRwwCdhTPl60xRqAloYNMQLiyUnG42VjT53oW07BXIRM+NK7eQjzXjAk2gUvX9caRxlnF9TAA==} - engines: {node: '>=4.0.0'} - - ieee754@1.2.1: - resolution: {integrity: sha512-dcyqhDvX1C46lXZcVqCpK+FtMRQVdIMN6/Df5js2zouUsqG7I6sFxitIC+7KYK29KdXOLHdu9zL4sFnoVQnqaA==} - - ignore@5.3.1: - resolution: {integrity: sha512-5Fytz/IraMjqpwfd34ke28PTVMjZjJG2MPn5t7OE4eUCUNf8BAa7b5WUS9/Qvr6mwOQS7Mk6vdsMno5he+T8Xw==} - engines: {node: '>= 4'} - - immer@10.0.2: - resolution: {integrity: sha512-Rx3CqeqQ19sxUtYV9CU911Vhy8/721wRFnJv3REVGWUmoAcIwzifTsdmJte/MV+0/XpM35LZdQMBGkRIoLPwQA==} - - immutable@4.3.5: - resolution: {integrity: sha512-8eabxkth9gZatlwl5TBuJnCsoTADlL6ftEr7A4qgdaTsPyreilDSnUk57SO+jfKcNtxPa22U5KK6DSeAYhpBJw==} - - import-fresh@3.3.0: - resolution: {integrity: sha512-veYYhQa+D1QBKznvhUHxb8faxlrwUnxseDAbAp457E0wLNio2bOSKnjYDhMj+YiAq61xrMGhQk9iXVk5FzgQMw==} - engines: {node: '>=6'} - - imurmurhash@0.1.4: - resolution: {integrity: sha512-JmXMZ6wuvDmLiHEml9ykzqO6lwFbof0GG4IkcGaENdCRDDmMVnny7s5HsIgHCbaq0w2MyPhDqkhTUgS2LU2PHA==} - engines: {node: '>=0.8.19'} - - indent-string@4.0.0: - resolution: {integrity: sha512-EdDDZu4A2OyIK7Lr/2zG+w5jmbuk1DVBnEwREQvBzspBJkCEbRa8GxU1lghYcaGJCnRWibjDXlq779X1/y5xwg==} - engines: {node: '>=8'} - - inflight@1.0.6: - resolution: {integrity: sha512-k92I/b08q4wvFscXCLvqfsHCrjrF7yiXsQuIVvVE7N82W3+aqpzuUdBbfhWcy/FZR3/4IgflMgKLOsvPDrGCJA==} - - inherits@2.0.4: - resolution: {integrity: sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ==} - - ini@1.3.8: - resolution: {integrity: sha512-JV/yugV2uzW5iMRSiZAyDtQd+nxtUnjeLt0acNdw98kKLrvuRVyB80tsREOE7yvGVgalhZ6RNXCmEHkUKBKxew==} - - internal-slot@1.0.7: - resolution: {integrity: sha512-NGnrKwXzSms2qUUih/ILZ5JBqNTSa1+ZmP6flaIp6KmSElgE9qdndzS3cqjrDovwFdmwsGsLdeFgB6suw+1e9g==} - engines: {node: '>= 0.4'} - - interpret@1.4.0: - resolution: {integrity: sha512-agE4QfB2Lkp9uICn7BAqoscw4SZP9kTE2hxiFI3jBPmXJfdqiahTbUuKGsMoN2GtqL9AxhYioAcVvgsb1HvRbA==} - engines: {node: '>= 0.10'} - - invariant@2.2.4: - resolution: {integrity: sha512-phJfQVBuaJM5raOpJjSfkiD6BpbCE4Ns//LaXl6wGYtUBY83nWS6Rf9tXm2e8VaK60JEjYldbPif/A2B1C2gNA==} - - invert-kv@1.0.0: - resolution: {integrity: sha512-xgs2NH9AE66ucSq4cNG1nhSFghr5l6tdL15Pk+jl46bmmBapgoaY/AacXyaDznAqmGL99TiLSQgO/XazFSKYeQ==} - engines: {node: '>=0.10.0'} - - io-ts@1.10.4: - resolution: {integrity: sha512-b23PteSnYXSONJ6JQXRAlvJhuw8KOtkqa87W4wDtvMrud/DTJd5X+NpOOI+O/zZwVq6v0VLAaJ+1EDViKEuN9g==} - - ipaddr.js@1.9.1: - resolution: {integrity: sha512-0KI/607xoxSToH7GjN1FfSbLoU0+btTicjsQSWQlh/hZykN8KpmMf7uYwPW3R+akZ6R/w18ZlXSHBYXiYUPO3g==} - engines: {node: '>= 0.10'} - - is-arguments@1.1.1: - resolution: {integrity: sha512-8Q7EARjzEnKpt/PCD7e1cgUS0a6X8u5tdSiMqXhojOdoV9TsMsiO+9VLC5vAmO8N7/GmXn7yjR8qnA6bVAEzfA==} - engines: {node: '>= 0.4'} - - is-array-buffer@3.0.4: - resolution: {integrity: sha512-wcjaerHw0ydZwfhiKbXJWLDY8A7yV7KhjQOpb83hGgGfId/aQa4TOvwyzn2PuswW2gPCYEL/nEAiSVpdOj1lXw==} - engines: {node: '>= 0.4'} - - is-arrayish@0.2.1: - resolution: {integrity: sha512-zz06S8t0ozoDXMG+ube26zeCTNXcKIPJZJi8hBrF4idCLms4CG9QtK7qBl1boi5ODzFpjswb5JPmHCbMpjaYzg==} - - is-bigint@1.0.4: - resolution: {integrity: sha512-zB9CruMamjym81i2JZ3UMn54PKGsQzsJeo6xvN3HJJ4CAsQNB6iRutp2To77OfCNuoxspsIhzaPoO1zyCEhFOg==} - - is-binary-path@2.1.0: - resolution: {integrity: sha512-ZMERYes6pDydyuGidse7OsHxtbI7WVeUEozgR/g7rd0xUimYNlvZRE/K2MgZTjWy725IfelLeVcEM97mmtRGXw==} - engines: {node: '>=8'} - - is-boolean-object@1.1.2: - resolution: {integrity: sha512-gDYaKHJmnj4aWxyj6YHyXVpdQawtVLHU5cb+eztPGczf6cjuTdwve5ZIEfgXqH4e57An1D1AKf8CZ3kYrQRqYA==} - engines: {node: '>= 0.4'} - - is-builtin-module@3.2.1: - resolution: {integrity: sha512-BSLE3HnV2syZ0FK0iMA/yUGplUeMmNz4AW5fnTunbCIqZi4vG3WjJT9FHMy5D69xmAYBHXQhJdALdpwVxV501A==} - engines: {node: '>=6'} - - is-callable@1.2.7: - resolution: {integrity: sha512-1BC0BVFhS/p0qtw6enp8e+8OD0UrK0oFLztSjNzhcKA3WDuJxxAPXzPuPtKkjEY9UUoEWlX/8fgKeu2S8i9JTA==} - engines: {node: '>= 0.4'} - - is-core-module@2.13.1: - resolution: {integrity: sha512-hHrIjvZsftOsvKSn2TRYl63zvxsgE0K+0mYMoH6gD4omR5IWB2KynivBQczo3+wF1cCkjzvptnI9Q0sPU66ilw==} - - is-data-view@1.0.1: - resolution: {integrity: sha512-AHkaJrsUVW6wq6JS8y3JnM/GJF/9cf+k20+iDzlSaJrinEo5+7vRiteOSwBhHRiAyQATN1AmY4hwzxJKPmYf+w==} - engines: {node: '>= 0.4'} - - is-date-object@1.0.5: - resolution: {integrity: sha512-9YQaSxsAiSwcvS33MBk3wTCVnWK+HhF8VZR2jRxehM16QcVOdHqPn4VPHmRK4lSr38n9JriurInLcP90xsYNfQ==} - engines: {node: '>= 0.4'} - - is-extglob@2.1.1: - resolution: {integrity: sha512-SbKbANkN603Vi4jEZv49LeVJMn4yGwsbzZworEoyEiutsN3nJYdbO36zfhGJ6QEDpOZIFkDtnq5JRxmvl3jsoQ==} - engines: {node: '>=0.10.0'} - - is-fullwidth-code-point@1.0.0: - resolution: {integrity: sha512-1pqUqRjkhPJ9miNq9SwMfdvi6lBJcd6eFxvfaivQhaH3SgisfiuudvFntdKOmxuee/77l+FPjKrQjWvmPjWrRw==} - engines: {node: '>=0.10.0'} - - is-fullwidth-code-point@2.0.0: - resolution: {integrity: sha512-VHskAKYM8RfSFXwee5t5cbN5PZeq1Wrh6qd5bkyiXIf6UQcN6w/A0eXM9r6t8d+GYOh+o6ZhiEnb88LN/Y8m2w==} - engines: {node: '>=4'} - - is-fullwidth-code-point@3.0.0: - resolution: {integrity: sha512-zymm5+u+sCsSWyD9qNaejV3DFvhCKclKdizYaJUuHA83RLjb7nSuGnddCHGv0hk+KY7BMAlsWeK4Ueg6EV6XQg==} - engines: {node: '>=8'} - - is-function@1.0.2: - resolution: {integrity: sha512-lw7DUp0aWXYg+CBCN+JKkcE0Q2RayZnSvnZBlwgxHBQhqt5pZNVy4Ri7H9GmmXkdu7LUthszM+Tor1u/2iBcpQ==} - - is-generator-function@1.0.10: - resolution: {integrity: sha512-jsEjy9l3yiXEQ+PsXdmBwEPcOxaXWLspKdplFUVI9vq1iZgIekeC0L167qeu86czQaxed3q/Uzuw0swL0irL8A==} - engines: {node: '>= 0.4'} - - is-glob@4.0.3: - resolution: {integrity: sha512-xelSayHH36ZgE7ZWhli7pW34hNbNl8Ojv5KVmkJD4hBdD3th8Tfk9vYasLM+mXWOZhFkgZfxhLSnrwRr4elSSg==} - engines: {node: '>=0.10.0'} - - is-hex-prefixed@1.0.0: - resolution: {integrity: sha512-WvtOiug1VFrE9v1Cydwm+FnXd3+w9GaeVUss5W4v/SLy3UW00vP+6iNF2SdnfiBoLy4bTqVdkftNGTUeOFVsbA==} - engines: {node: '>=6.5.0', npm: '>=3'} - - is-interactive@1.0.0: - resolution: {integrity: sha512-2HvIEKRoqS62guEC+qBjpvRubdX910WCMuJTZ+I9yvqKU2/12eSL549HMwtabb4oupdj2sMP50k+XJfB/8JE6w==} - engines: {node: '>=8'} - - is-lower-case@1.1.3: - resolution: {integrity: sha512-+5A1e/WJpLLXZEDlgz4G//WYSHyQBD32qa4Jd3Lw06qQlv3fJHnp3YIHjTQSGzHMgzmVKz2ZP3rBxTHkPw/lxA==} - - is-negative-zero@2.0.3: - resolution: {integrity: sha512-5KoIu2Ngpyek75jXodFvnafB6DJgr3u8uuK0LEZJjrU19DrMD3EVERaR8sjz8CCGgpZvxPl9SuE1GMVPFHx1mw==} - engines: {node: '>= 0.4'} - - is-number-object@1.0.7: - resolution: {integrity: sha512-k1U0IRzLMo7ZlYIfzRu23Oh6MiIFasgpb9X76eqfFZAqwH44UI4KTBvBYIZ1dSL9ZzChTB9ShHfLkR4pdW5krQ==} - engines: {node: '>= 0.4'} - - is-number@7.0.0: - resolution: {integrity: sha512-41Cifkg6e8TylSpdtTpeLVMqvSBEVzTttHvERD741+pnZ8ANv0004MRL43QKPDlK9cGvNp6NZWZUBlbGXYxxng==} - engines: {node: '>=0.12.0'} - - is-path-inside@3.0.3: - resolution: {integrity: sha512-Fd4gABb+ycGAmKou8eMftCupSir5lRxqf4aD/vd0cD2qc4HL07OjCeuHMr8Ro4CoMaeCKDB0/ECBOVWjTwUvPQ==} - engines: {node: '>=8'} - - is-plain-obj@1.1.0: - resolution: {integrity: sha512-yvkRyxmFKEOQ4pNXCmJG5AEQNlXJS5LaONXo5/cLdTZdWvsZ1ioJEonLGAosKlMWE8lwUy/bJzMjcw8az73+Fg==} - engines: {node: '>=0.10.0'} - - is-plain-obj@2.1.0: - resolution: {integrity: sha512-YWnfyRwxL/+SsrWYfOpUtz5b3YD+nyfkHvjbcanzk8zgyO4ASD67uVMRt8k5bM4lLMDnXfriRhOpemw+NfT1eA==} - engines: {node: '>=8'} - - is-regex@1.1.4: - resolution: {integrity: sha512-kvRdxDsxZjhzUX07ZnLydzS1TU/TJlTUHHY4YLL87e37oUA49DfkLqgy+VjFocowy29cKvcSiu+kIv728jTTVg==} - engines: {node: '>= 0.4'} - - is-shared-array-buffer@1.0.3: - resolution: {integrity: sha512-nA2hv5XIhLR3uVzDDfCIknerhx8XUKnstuOERPNNIinXG7v9u+ohXF67vxm4TPTEPU6lm61ZkwP3c9PCB97rhg==} - engines: {node: '>= 0.4'} - - is-stream@2.0.1: - resolution: {integrity: sha512-hFoiJiTl63nn+kstHGBtewWSKnQLpyb155KHheA1l39uvtO9nWIop1p3udqPcUd/xbF1VLMO4n7OI6p7RbngDg==} - engines: {node: '>=8'} - - is-string@1.0.7: - resolution: {integrity: sha512-tE2UXzivje6ofPW7l23cjDOMa09gb7xlAqG6jG5ej6uPV32TlWP3NKPigtaGeHNu9fohccRYvIiZMfOOnOYUtg==} - engines: {node: '>= 0.4'} - - is-subdir@1.2.0: - resolution: {integrity: sha512-2AT6j+gXe/1ueqbW6fLZJiIw3F8iXGJtt0yDrZaBhAZEG1raiTxKWU+IPqMCzQAXOUCKdA4UDMgacKH25XG2Cw==} - engines: {node: '>=4'} - - is-symbol@1.0.4: - resolution: {integrity: sha512-C/CPBqKWnvdcxqIARxyOh4v1UUEOCHpgDa0WYgpKDFMszcrPcffg5uhwSgPCLD2WWxmq6isisz87tzT01tuGhg==} - engines: {node: '>= 0.4'} - - is-typed-array@1.1.13: - resolution: {integrity: sha512-uZ25/bUAlUY5fR4OKT4rZQEBrzQWYV9ZJYGGsUmEJ6thodVJ1HX64ePQ6Z0qPWP+m+Uq6e9UugrE38jeYsDSMw==} - engines: {node: '>= 0.4'} - - is-typedarray@1.0.0: - resolution: {integrity: sha512-cyA56iCMHAh5CdzjJIa4aohJyeO1YbwLi3Jc35MmRU6poroFjIGZzUzupGiRPOjgHg9TLu43xbpwXk523fMxKA==} - - is-unicode-supported@0.1.0: - resolution: {integrity: sha512-knxG2q4UC3u8stRGyAVJCOdxFmv5DZiRcdlIaAQXAbSfJya+OhopNotLQrstBhququ4ZpuKbDc/8S6mgXgPFPw==} - engines: {node: '>=10'} - - is-upper-case@1.1.2: - resolution: {integrity: sha512-GQYSJMgfeAmVwh9ixyk888l7OIhNAGKtY6QA+IrWlu9MDTCaXmeozOZ2S9Knj7bQwBO/H6J2kb+pbyTUiMNbsw==} - - is-url@1.2.4: - resolution: {integrity: sha512-ITvGim8FhRiYe4IQ5uHSkj7pVaPDrCTkNd3yq3cV7iZAcJdHTUMPMEHcqSOy9xZ9qFenQCvi+2wjH9a1nXqHww==} - - is-utf8@0.2.1: - resolution: {integrity: sha512-rMYPYvCzsXywIsldgLaSoPlw5PfoB/ssr7hY4pLfcodrA5M/eArza1a9VmTiNIBNMjOGr1Ow9mTyU2o69U6U9Q==} - - is-weakref@1.0.2: - resolution: {integrity: sha512-qctsuLZmIQ0+vSSMfoVvyFe2+GSEvnmZ2ezTup1SBse9+twCCeial6EEi3Nc2KFcf6+qz2FBPnjXsk8xhKSaPQ==} - - is-windows@1.0.2: - resolution: {integrity: sha512-eXK1UInq2bPmjyX6e3VHIzMLobc4J94i4AWn+Hpq3OU5KkrRC96OAcR3PRJ/pGu6m8TRnBHP9dkXQVsT/COVIA==} - engines: {node: '>=0.10.0'} - - isarray@0.0.1: - resolution: {integrity: sha512-D2S+3GLxWH+uhrNEcoh/fnmYeP8E8/zHl644d/jdA0g2uyXvy3sb0qxotE+ne0LtccHknQzWwZEzhak7oJ0COQ==} - - isarray@1.0.0: - resolution: {integrity: sha512-VLghIWNM6ELQzo7zwmcg0NmTVyWKYjvIeM83yjp0wRDTmUnrM678fQbcKBo6n2CJEF0szoG//ytg+TKla89ALQ==} - - isarray@2.0.5: - resolution: {integrity: sha512-xHjhDr3cNBK0BzdUJSPXZntQUx/mwMS5Rw4A7lPJ90XGAO6ISP/ePDNuo0vhqOZU+UD5JoodwCAAoZQd3FeAKw==} - - isexe@2.0.0: - resolution: {integrity: sha512-RHxMLp9lnKHGHRng9QFhRCMbYAcVpn69smSGcq3f36xjgVVWThj4qqLbTLlq7Ssj8B+fIQ1EuCEGI2lKsyQeIw==} - - isomorphic-fetch@3.0.0: - resolution: {integrity: sha512-qvUtwJ3j6qwsF3jLxkZ72qCgjMysPzDfeV240JHiGZsANBYd+EEuu35v7dfrJ9Up0Ak07D7GGSkGhCHTqg/5wA==} - - isomorphic-ws@5.0.0: - resolution: {integrity: sha512-muId7Zzn9ywDsyXgTIafTry2sV3nySZeUDe6YedVd1Hvuuep5AsIlqK+XefWpYTyJG5e503F2xIuT2lcU6rCSw==} - peerDependencies: - ws: '*' - - isows@1.0.3: - resolution: {integrity: sha512-2cKei4vlmg2cxEjm3wVSqn8pcoRF/LX/wpifuuNquFO4SQmPwarClT+SUCA2lt+l581tTeZIPIZuIDo2jWN1fg==} - peerDependencies: - ws: '*' - - isstream@0.1.2: - resolution: {integrity: sha512-Yljz7ffyPbrLpLngrMtZ7NduUgVvi6wG9RJ9IUcyCd59YQ911PBJphODUcbOVbqYfxe1wuYf/LJ8PauMRwsM/g==} - - istanbul-lib-coverage@3.2.2: - resolution: {integrity: sha512-O8dpsF+r0WV/8MNRKfnmrtCWhuKjxrq2w+jpzBL5UZKTi2LeVWnWOmWRxFlesJONmc+wLAGvKQZEOanko0LFTg==} - engines: {node: '>=8'} - - istanbul-lib-hook@3.0.0: - resolution: {integrity: sha512-Pt/uge1Q9s+5VAZ+pCo16TYMWPBIl+oaNIjgLQxcX0itS6ueeaA+pEfThZpH8WxhFgCiEb8sAJY6MdUKgiIWaQ==} - engines: {node: '>=8'} - - istanbul-lib-instrument@4.0.3: - resolution: {integrity: sha512-BXgQl9kf4WTCPCCpmFGoJkz/+uhvm7h7PFKUYxh7qarQd3ER33vHG//qaE8eN25l07YqZPpHXU9I09l/RD5aGQ==} - engines: {node: '>=8'} - - istanbul-lib-processinfo@2.0.3: - resolution: {integrity: sha512-NkwHbo3E00oybX6NGJi6ar0B29vxyvNwoC7eJ4G4Yq28UfY758Hgn/heV8VRFhevPED4LXfFz0DQ8z/0kw9zMg==} - engines: {node: '>=8'} - - istanbul-lib-report@3.0.1: - resolution: {integrity: sha512-GCfE1mtsHGOELCU8e/Z7YWzpmybrx/+dSTfLrvY8qRmaY6zXTKWn6WQIjaAFw069icm6GVMNkgu0NzI4iPZUNw==} - engines: {node: '>=10'} - - istanbul-lib-source-maps@4.0.1: - resolution: {integrity: sha512-n3s8EwkdFIJCG3BPKBYvskgXGoy88ARzvegkitk60NxRdwltLOTaH7CUiMRXvwYorl0Q712iEjcWB+fK/MrWVw==} - engines: {node: '>=10'} - - istanbul-reports@3.1.7: - resolution: {integrity: sha512-BewmUXImeuRk2YY0PVbxgKAysvhRPUQE0h5QRM++nVWyubKGV0l8qQ5op8+B2DOmwSe63Jivj0BjkPQVf8fP5g==} - engines: {node: '>=8'} - - jest-diff@29.7.0: - resolution: {integrity: sha512-LMIgiIrhigmPrs03JHpxUh2yISK3vLFPkAodPeo0+BuF7wA2FoQbkEg1u8gBYBThncu7e1oEDUfIXVuTqLRUjw==} - engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0} - - jest-get-type@29.6.3: - resolution: {integrity: sha512-zrteXnqYxfQh7l5FHyL38jL39di8H8rHoecLH3JNxH3BwOrBsNeabdap5e0I23lD4HHI8W5VFBZqG4Eaq5LNcw==} - engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0} - - js-sha3@0.5.5: - resolution: {integrity: sha512-yLLwn44IVeunwjpDVTDZmQeVbB0h+dZpY2eO68B/Zik8hu6dH+rKeLxwua79GGIvW6xr8NBAcrtiUbYrTjEFTA==} - - js-sha3@0.5.7: - resolution: {integrity: sha512-GII20kjaPX0zJ8wzkTbNDYMY7msuZcTWk8S5UOh6806Jq/wz1J8/bnr8uGU0DAUmYDjj2Mr4X1cW8v/GLYnR+g==} - - js-sha3@0.8.0: - resolution: {integrity: sha512-gF1cRrHhIzNfToc802P800N8PpXS+evLLXfsVpowqmAFR9uwbi89WvXg2QspOmXL8QL86J4T1EpFu+yUkwJY3Q==} - - js-tokens@4.0.0: - resolution: {integrity: sha512-RdJUflcE3cUzKiMqQgsCu06FPu9UdIJO0beYbPhHN4k6apgJtifcoCtT9bcxOpYBtpD2kCM6Sbzg4CausW/PKQ==} - - js-yaml@3.14.1: - resolution: {integrity: sha512-okMH7OXXJ7YrN9Ok3/SXrnu4iX9yOk+25nqX4imS2npuvTYDmo/QEZoqwZkYaIDk3jVvBOTOIEgEhaLOynBS9g==} - hasBin: true - - js-yaml@4.1.0: - resolution: {integrity: sha512-wpxZs9NoxZaJESJGIZTyDEaYpl0FKSA+FB9aJiyemKhMwkxQg63h4T1KJgUGHpTqPDNRcmmYLugrRjJlBtWvRA==} - hasBin: true - - jsbn@0.1.1: - resolution: {integrity: sha512-UVU9dibq2JcFWxQPA6KCqj5O42VOmAY3zQUfEKxU0KpTGXwNoCjkX1e13eHNvw/xPynt6pU0rZ1htjWTNTSXsg==} - - jsesc@2.5.2: - resolution: {integrity: sha512-OYu7XEzjkCQ3C5Ps3QIZsQfNpqoJyZZA99wd9aWd05NCtC5pWOkShK2mkL6HXQR6/Cy2lbNdPlZBpuQHXE63gA==} - engines: {node: '>=4'} - hasBin: true - - json-buffer@3.0.1: - resolution: {integrity: sha512-4bV5BfR2mqfQTJm+V5tPPdf+ZpuhiIvTuAB5g8kcrXOZpTT/QwwVRWBywX1ozr6lEuPdbHxwaJlm9G6mI2sfSQ==} - - json-parse-even-better-errors@2.3.1: - resolution: {integrity: sha512-xyFwyhro/JEof6Ghe2iz2NcXoj2sloNsWr/XsERDK/oiPCfaNhl5ONfp+jQdAZRQQ0IJWNzH9zIZF7li91kh2w==} - - json-schema-traverse@0.3.1: - resolution: {integrity: sha512-4JD/Ivzg7PoW8NzdrBSr3UFwC9mHgvI7Z6z3QGBsSHgKaRTUDmyZAAKJo2UbG1kUVfS9WS8bi36N49U1xw43DA==} - - json-schema-traverse@0.4.1: - resolution: {integrity: sha512-xbbCH5dCYU5T8LcEhhuh7HJ88HXuW3qsI3Y0zOZFKfZEHcpWiHU/Jxzk629Brsab/mMiHQti9wMP+845RPe3Vg==} - - json-schema-traverse@1.0.0: - resolution: {integrity: sha512-NM8/P9n3XjXhIZn1lLhkFaACTOURQXjWhV4BA/RnOv8xvgqtqpAX9IO4mRQxSx1Rlo4tqzeqb0sOlruaOy3dug==} - - json-schema@0.4.0: - resolution: {integrity: sha512-es94M3nTIfsEPisRafak+HDLfHXnKBhV3vU5eqPcS3flIWqcxJWgXHXiey3YrpaNsanY5ei1VoYEbOzijuq9BA==} - - json-stable-stringify-without-jsonify@1.0.1: - resolution: {integrity: sha512-Bdboy+l7tA3OGW6FjyFHWkP5LuByj1Tk33Ljyq0axyzdk9//JSi2u3fP1QSmd1KNwq6VOKYGlAu87CisVir6Pw==} - - json-stringify-safe@5.0.1: - resolution: {integrity: sha512-ZClg6AaYvamvYEE82d3Iyd3vSSIjQ+odgjaTzRuO3s7toCdFKczob2i0zCh7JE8kWn17yvAWhUVxvqGwUalsRA==} - - json5@1.0.2: - resolution: {integrity: sha512-g1MWMLBiz8FKi1e4w0UyVL3w+iJceWAFBAaBnnGKOpNa5f8TLktkbre1+s6oICydWAm+HRUGTmI+//xv2hvXYA==} - hasBin: true - - json5@2.2.3: - resolution: {integrity: sha512-XmOWe7eyHYH14cLdVPoyg+GOH3rYX++KpzrylJwSW98t3Nk+U8XOl8FWKOgwtzdb8lXGf6zYwDUzeHMWfxasyg==} - engines: {node: '>=6'} - hasBin: true - - jsonfile@2.4.0: - resolution: {integrity: sha512-PKllAqbgLgxHaj8TElYymKCAgrASebJrWpTnEkOaTowt23VKXXN0sUeriJ+eh7y6ufb/CC5ap11pz71/cM0hUw==} - - jsonfile@4.0.0: - resolution: {integrity: sha512-m6F1R3z8jjlf2imQHS2Qez5sjKWQzbuuhuJ/FKYFRZvPE3PuHcSMVZzfsLhGVOkfd20obL5SWEBew5ShlquNxg==} - - jsonfile@6.1.0: - resolution: {integrity: sha512-5dgndWOriYSm5cnYaJNhalLNDKOqFwyDB/rr1E9ZsGciGvKPs8R2xYGCacuf3z6K1YKDz182fd+fY3cn3pMqXQ==} - - jsonschema@1.4.1: - resolution: {integrity: sha512-S6cATIPVv1z0IlxdN+zUk5EPjkGCdnhN4wVSBlvoUO1tOLJootbo9CquNJmbIh4yikWHiUedhRYrNPn1arpEmQ==} - - jsprim@1.4.2: - resolution: {integrity: sha512-P2bSOMAc/ciLz6DzgjVlGJP9+BrJWu5UDGK70C2iweC5QBIeFf0ZXRvGjEj2uYgrY2MkAAhsSWHDWlFtEroZWw==} - engines: {node: '>=0.6.0'} - - just-extend@4.2.1: - resolution: {integrity: sha512-g3UB796vUFIY90VIv/WX3L2c8CS2MdWUww3CNrYmqza1Fg0DURc2K/O4YrnklBdQarSJ/y8JnJYDGc+1iumQjg==} - - keccak@3.0.4: - resolution: {integrity: sha512-3vKuW0jV8J3XNTzvfyicFR5qvxrSAGl7KIhvgOu5cmWwM7tZRj3fMbj/pfIf4be7aznbc+prBWGjywox/g2Y6Q==} - engines: {node: '>=10.0.0'} - - keyv@4.5.4: - resolution: {integrity: sha512-oxVHkHR/EJf2CNXnWxRLW6mg7JyCCUcG0DtEGmL2ctUo1PNTin1PUil+r/+4r5MpVgC/fn1kjsx7mjSujKqIpw==} - - kind-of@6.0.3: - resolution: {integrity: sha512-dcS1ul+9tmeD95T+x28/ehLgd9mENa3LsvDTtzm3vyBEO7RPptvAD+t44WVXaUjTBRcrpFeFlC8WCruUR456hw==} - engines: {node: '>=0.10.0'} - - klaw@1.3.1: - resolution: {integrity: sha512-TED5xi9gGQjGpNnvRWknrwAB1eL5GciPfVFOt3Vk1OJCVDQbzuSfrF3hkUQKlsgKrG1F+0t5W0m+Fje1jIt8rw==} - - kleur@3.0.3: - resolution: {integrity: sha512-eTIzlVOSUR+JxdDFepEYcBMtZ9Qqdef+rnzWdRZuMbOywu5tO2w2N7rqjoANZ5k9vywhL6Br1VRjUIgTQx4E8w==} - engines: {node: '>=6'} - - kleur@4.1.5: - resolution: {integrity: sha512-o+NO+8WrRiQEE4/7nwRJhN1HWpVmJm511pBHUxPLtp0BUISzlBplORYSmTclCnJvQq2tKu/sgl3xVpkc7ZWuQQ==} - engines: {node: '>=6'} - - lcid@1.0.0: - resolution: {integrity: sha512-YiGkH6EnGrDGqLMITnGjXtGmNtjoXw9SVUzcaos8RBi7Ps0VBylkq+vOcY9QE5poLasPCR849ucFUkl0UzUyOw==} - engines: {node: '>=0.10.0'} - - levn@0.3.0: - resolution: {integrity: sha512-0OO4y2iOHix2W6ujICbKIaEQXvFQHue65vUG3pb5EUomzPI90z9hsA1VsO/dbIIpC53J8gxM9Q4Oho0jrCM/yA==} - engines: {node: '>= 0.8.0'} - - levn@0.4.1: - resolution: {integrity: sha512-+bT2uH4E5LGE7h/n3evcS/sQlJXCpIp6ym8OWJ5eV6+67Dsql/LaaT7qJBAt2rzfoa/5QBGBhxDix1dMt2kQKQ==} - engines: {node: '>= 0.8.0'} - - lines-and-columns@1.2.4: - resolution: {integrity: sha512-7ylylesZQ/PV29jhEDl3Ufjo6ZX7gCqJr5F7PKrqc93v7fzSymt1BpwEU8nAUXs8qzzvqhbjhK5QZg6Mt/HkBg==} - - load-json-file@1.1.0: - resolution: {integrity: sha512-cy7ZdNRXdablkXYNI049pthVeXFurRyb9+hA/dZzerZ0pGTx42z+y+ssxBaVV2l70t1muq5IdKhn4UtcoGUY9A==} - engines: {node: '>=0.10.0'} - - load-yaml-file@0.2.0: - resolution: {integrity: sha512-OfCBkGEw4nN6JLtgRidPX6QxjBQGQf72q3si2uvqyFEMbycSFFHwAZeXx6cJgFM9wmLrf9zBwCP3Ivqa+LLZPw==} - engines: {node: '>=6'} - - locate-path@2.0.0: - resolution: {integrity: sha512-NCI2kiDkyR7VeEKm27Kda/iQHyKJe1Bu0FlTbYp3CqJu+9IFe9bLyAjMxf5ZDDbEg+iMPzB5zYyUTSm8wVTKmA==} - engines: {node: '>=4'} - - locate-path@5.0.0: - resolution: {integrity: sha512-t7hw9pI+WvuwNJXwk5zVHpyhIqzg2qTlklJOf0mVxGSbe3Fp2VieZcduNYjaLDoy6p9uGpQEGWG87WpMKlNq8g==} - engines: {node: '>=8'} - - locate-path@6.0.0: - resolution: {integrity: sha512-iPZK6eYjbxRu3uB4/WZ3EsEIMJFMqAoopl3R+zuq0UjcAm/MO6KCweDgPfP3elTztoKP3KtnVHxTn2NHBSDVUw==} - engines: {node: '>=10'} - - lodash.assign@4.2.0: - resolution: {integrity: sha512-hFuH8TY+Yji7Eja3mGiuAxBqLagejScbG8GbG0j6o9vzn0YL14My+ktnqtZgFTosKymC9/44wP6s7xyuLfnClw==} - - lodash.camelcase@4.3.0: - resolution: {integrity: sha512-TwuEnCnxbc3rAvhf/LbG7tJUDzhqXyFnv3dtzLOPgCG/hODL7WFnsbwktkD7yUV0RrreP/l1PALq/YSg6VvjlA==} - - lodash.clonedeep@4.5.0: - resolution: {integrity: sha512-H5ZhCF25riFd9uB5UCkVKo61m3S/xZk1x4wA6yp/L3RFP6Z/eHH1ymQcGLo7J3GMPfm0V/7m1tryHuGVxpqEBQ==} - - lodash.deburr@4.1.0: - resolution: {integrity: sha512-m/M1U1f3ddMCs6Hq2tAsYThTBDaAKFDX3dwDo97GEYzamXi9SqUpjWi/Rrj/gf3X2n8ktwgZrlP1z6E3v/IExQ==} - - lodash.flattendeep@4.4.0: - resolution: {integrity: sha512-uHaJFihxmJcEX3kT4I23ABqKKalJ/zDrDg0lsFtc1h+3uw49SIJ5beyhx5ExVRti3AvKoOJngIj7xz3oylPdWQ==} - - lodash.get@4.4.2: - resolution: {integrity: sha512-z+Uw/vLuy6gQe8cfaFWD7p0wVv8fJl3mbzXh33RS+0oW2wvUqiRXiQ69gLWSLpgB5/6sU+r6BlQR0MBILadqTQ==} - - lodash.isequal@4.5.0: - resolution: {integrity: sha512-pDo3lu8Jhfjqls6GkMgpahsF9kCyayhgykjyLMNFTKWrpVdAQtYyB4muAMWozBB4ig/dtWAmsMxLEI8wuz+DYQ==} - - lodash.memoize@4.1.2: - resolution: {integrity: sha512-t7j+NzmgnQzTAYXcsHYLgimltOV1MXHtlOWf6GjL9Kj8GK5FInw5JotxvbOs+IvV1/Dzo04/fCGfLVs7aXb4Ag==} - - lodash.merge@4.6.2: - resolution: {integrity: sha512-0KpjqXRVvrYyCsX1swR/XTK0va6VQkQM6MNo7PqW77ByjAhoARA8EfrP1N4+KlKj8YS0ZUCtRT/YUuhyYDujIQ==} - - lodash.snakecase@4.1.1: - resolution: {integrity: sha512-QZ1d4xoBHYUeuouhEq3lk3Uq7ldgyFXGBhg04+oRLnIz8o9T65Eh+8YdroUwn846zchkA9yDsDl5CVVaV2nqYw==} - - lodash.startcase@4.4.0: - resolution: {integrity: sha512-+WKqsK294HMSc2jEbNgpHpd0JfIBhp7rEV4aqXWqFr6AlXov+SlcgB1Fv01y2kGe3Gc8nMW7VA0SrGuSkRfIEg==} - - lodash.trim@4.5.1: - resolution: {integrity: sha512-nJAlRl/K+eiOehWKDzoBVrSMhK0K3A3YQsUNXHQa5yIrKBAhsZgSu3KoAFoFT+mEgiyBHddZ0pRk1ITpIp90Wg==} - - lodash.truncate@4.4.2: - resolution: {integrity: sha512-jttmRe7bRse52OsWIMDLaXxWqRAmtIUccAQ3garviCqJjafXOfNMO0yMfNpdD6zbGaTU0P5Nz7e7gAT6cKmJRw==} - - lodash@4.17.21: - resolution: {integrity: sha512-v2kDEe57lecTulaDIuNTPy3Ry4gLGJ6Z1O3vE1krgXZNrsQ+LFTGHVxVjcXPs17LhbZVGedAJv8XZ1tvj5FvSg==} - - log-symbols@4.1.0: - resolution: {integrity: sha512-8XPvpAA8uyhfteu8pIvQxpJZ7SYYdpUivZpGy6sFsBuKRY/7rQGavedeB8aK+Zkyq6upMFVL/9AW6vOYzfRyLg==} - engines: {node: '>=10'} - - loose-envify@1.4.0: - resolution: {integrity: sha512-lyuxPGr/Wfhrlem2CL/UcnUc1zcqKAImBDzukY7Y5F/yQiNdko6+fRLevlw1HgMySw7f611UIY408EtxRSoK3Q==} - hasBin: true - - loupe@2.3.7: - resolution: {integrity: sha512-zSMINGVYkdpYSOBmLi0D1Uo7JU9nVdQKrHxC8eYlV+9YKK9WePqAlL7lSlorG/U2Fw1w0hTBmaa/jrQ3UbPHtA==} - - lower-case-first@1.0.2: - resolution: {integrity: sha512-UuxaYakO7XeONbKrZf5FEgkantPf5DUqDayzP5VXZrtRPdH86s4kN47I8B3TW10S4QKiE3ziHNf3kRN//okHjA==} - - lower-case@1.1.4: - resolution: {integrity: sha512-2Fgx1Ycm599x+WGpIYwJOvsjmXFzTSc34IwDWALRA/8AopUKAVPwfJ+h5+f85BCp0PWmmJcWzEpxOpoXycMpdA==} - - lower-case@2.0.2: - resolution: {integrity: sha512-7fm3l3NAF9WfN6W3JOmf5drwpVqX78JtoGJ3A6W0a6ZnldM41w2fV5D490psKFTpMds8TJse/eHLFFsNHHjHgg==} - - lowercase-keys@2.0.0: - resolution: {integrity: sha512-tqNXrS78oMOE73NMxK4EMLQsQowWf8jKooH9g7xPavRT706R6bkQJ6DY2Te7QukaZsulxa30wQ7bk0pm4XiHmA==} - engines: {node: '>=8'} - - lowercase-keys@3.0.0: - resolution: {integrity: sha512-ozCC6gdQ+glXOQsveKD0YsDy8DSQFjDTz4zyzEHNV5+JP5D62LmfDZ6o1cycFx9ouG940M5dE8C8CTewdj2YWQ==} - engines: {node: ^12.20.0 || ^14.13.1 || >=16.0.0} - - lru-cache@10.2.2: - resolution: {integrity: sha512-9hp3Vp2/hFQUiIwKo8XCeFVnrg8Pk3TYNPIR7tJADKi5YfcF7vEaK7avFHTlSy3kOKYaJQaalfEo6YuXdceBOQ==} - engines: {node: 14 || >=16.14} - - lru-cache@4.1.5: - resolution: {integrity: sha512-sWZlbEP2OsHNkXrMl5GYk/jKk70MBng6UU4YI/qGDYbgf6YbP4EvmqISbXCoJiRKs+1bSpFHVgQxvJ17F2li5g==} - - lru-cache@5.1.1: - resolution: {integrity: sha512-KpNARQA3Iwv+jTA0utUVVbrh+Jlrr1Fv0e56GGzAFOXN7dk/FviaDW8LHmK52DlcH4WP2n6gI8vN1aesBFgo9w==} - - lru_map@0.3.3: - resolution: {integrity: sha512-Pn9cox5CsMYngeDbmChANltQl+5pi6XmTrraMSzhPmMBbmgcxmqWry0U3PGapCU1yB4/LqCcom7qhHZiF/jGfQ==} - - make-dir@3.1.0: - resolution: {integrity: sha512-g3FeP20LNwhALb/6Cz6Dd4F2ngze0jz7tbzrD2wAV+o9FeNHe4rL+yK2md0J/fiSf1sa1ADhXqi5+oVwOM/eGw==} - engines: {node: '>=8'} - - make-dir@4.0.0: - resolution: {integrity: sha512-hXdUTZYIVOt1Ex//jAQi+wTZZpUpwBj/0QsOzqegb3rGMMeJiSEu5xLHnYfBrRV4RH2+OCSOO95Is/7x1WJ4bw==} - engines: {node: '>=10'} - - make-error@1.3.6: - resolution: {integrity: sha512-s8UhlNe7vPKomQhC1qFelMokr/Sc3AgNbso3n74mVPA5LTZwkB9NlXf4XPamLxJE8h0gh73rM94xvwRT2CVInw==} - - map-obj@1.0.1: - resolution: {integrity: sha512-7N/q3lyZ+LVCp7PzuxrJr4KMbBE2hW7BT7YNia330OFxIf4d3r5zVpicP2650l7CPN6RM9zOJRl3NGpqSiw3Eg==} - engines: {node: '>=0.10.0'} - - map-obj@4.3.0: - resolution: {integrity: sha512-hdN1wVrZbb29eBGiGjJbeP8JbKjq1urkHJ/LIP/NY48MZ1QVXUsQBV1G1zvYFHn1XE06cwjBsOI2K3Ulnj1YXQ==} - engines: {node: '>=8'} - - markdown-table@1.1.3: - resolution: {integrity: sha512-1RUZVgQlpJSPWYbFSpmudq5nHY1doEIv89gBtF0s4gW1GF2XorxcA/70M5vq7rLv0a6mhOUccRsqkwhwLCIQ2Q==} - - markdown-table@3.0.3: - resolution: {integrity: sha512-Z1NL3Tb1M9wH4XESsCDEksWoKTdlUafKc4pt0GRwjUyXaCFZ+dc3g2erqB6zm3szA2IUSi7VnPI+o/9jnxh9hw==} - - md5.js@1.3.5: - resolution: {integrity: sha512-xitP+WxNPcTTOgnTJcrhM0xvdPepipPSf3I8EIpGKeFLjt3PlJLIDG3u8EX53ZIubkb+5U2+3rELYpEhHhzdkg==} - - media-typer@0.3.0: - resolution: {integrity: sha512-dq+qelQ9akHpcOl/gUVRTxVIOkAJ1wR3QAvb4RsVjS8oVoFjDGTc679wJYmUmknUF5HwMLOgb5O+a3KxfWapPQ==} - engines: {node: '>= 0.6'} - - memorystream@0.3.1: - resolution: {integrity: sha512-S3UwM3yj5mtUSEfP41UZmt/0SCoVYUcU1rkXv+BQ5Ig8ndL4sPoJNBUJERafdPb5jjHJGuMgytgKvKIf58XNBw==} - engines: {node: '>= 0.10.0'} - - meow@6.1.1: - resolution: {integrity: sha512-3YffViIt2QWgTy6Pale5QpopX/IvU3LPL03jOTqp6pGj3VjesdO/U8CuHMKpnQr4shCNCM5fd5XFFvIIl6JBHg==} - engines: {node: '>=8'} - - merge-descriptors@1.0.1: - resolution: {integrity: sha512-cCi6g3/Zr1iqQi6ySbseM1Xvooa98N0w31jzUYrXPX2xqObmFGHJ0tQ5u74H3mVh7wLouTseZyYIq39g8cNp1w==} - - merge2@1.4.1: - resolution: {integrity: sha512-8q7VEgMJW4J8tcfVPy8g09NcQwZdbwFEqhe/WZkoIzjn/3TGDwtOCYtXGxA3O8tPzpczCCDgv+P2P5y00ZJOOg==} - engines: {node: '>= 8'} - - methods@1.1.2: - resolution: {integrity: sha512-iclAHeNqNm68zFtnZ0e+1L2yUIdvzNoauKU4WBA3VvH/vPFieF7qfRlwUZU+DA9P9bPXIS90ulxoUoCH23sV2w==} - engines: {node: '>= 0.6'} - - micro-ftch@0.3.1: - resolution: {integrity: sha512-/0LLxhzP0tfiR5hcQebtudP56gUurs2CLkGarnCiB/OqEyUFQ6U3paQi/tgLv0hBJYt2rnr9MNpxz4fiiugstg==} - - micromatch@4.0.5: - resolution: {integrity: sha512-DMy+ERcEW2q8Z2Po+WNXuw3c5YaUSFjAO5GsJqfEl7UjvtIuFKO6ZrKvcItdy98dwFI2N1tg3zNIdKaQT+aNdA==} - engines: {node: '>=8.6'} - - mime-db@1.52.0: - resolution: {integrity: sha512-sPU4uV7dYlvtWJxwwxHD0PuihVNiE7TyAbQ5SWxDCB9mUYvOgroQOwYQQOKPJ8CIbE+1ETVlOoK1UC2nU3gYvg==} - engines: {node: '>= 0.6'} - - mime-types@2.1.35: - resolution: {integrity: sha512-ZDY+bPm5zTTF+YpCrAU9nK0UgICYPT0QtT1NZWFv4s++TNkcgVaT0g6+4R2uI4MjQjzysHB1zxuWL50hzaeXiw==} - engines: {node: '>= 0.6'} - - mime@1.6.0: - resolution: {integrity: sha512-x0Vn8spI+wuJ1O6S7gnbaQg8Pxh4NNHb7KSINmEWKiPE4RKOplvijn+NkmYmmRgP68mc70j2EbeTFRsrswaQeg==} - engines: {node: '>=4'} - hasBin: true - - mimic-fn@2.1.0: - resolution: {integrity: sha512-OqbOk5oEQeAZ8WXWydlu9HJjz9WVdEIvamMCcXmuqUYjTknH/sqsWvhQ3vgwKFRR1HpjvNBKQ37nbJgYzGqGcg==} - engines: {node: '>=6'} - - mimic-response@1.0.1: - resolution: {integrity: sha512-j5EctnkH7amfV/q5Hgmoal1g2QHFJRraOtmx0JpIqkxhBhI/lJSl1nMpQ45hVarwNETOoWEimndZ4QK0RHxuxQ==} - engines: {node: '>=4'} - - mimic-response@3.1.0: - resolution: {integrity: sha512-z0yWI+4FDrrweS8Zmt4Ej5HdJmky15+L2e6Wgn3+iK5fWzb6T3fhNFq2+MeTRb064c6Wr4N/wv0DzQTjNzHNGQ==} - engines: {node: '>=10'} - - min-document@2.19.0: - resolution: {integrity: sha512-9Wy1B3m3f66bPPmU5hdA4DR4PB2OfDU/+GS3yAB7IQozE3tqXaVv2zOjgla7MEGSRv95+ILmOuvhLkOK6wJtCQ==} - - min-indent@1.0.1: - resolution: {integrity: sha512-I9jwMn07Sy/IwOj3zVkVik2JTvgpaykDZEigL6Rx6N9LbMywwUSMtxET+7lVoDLLd3O3IXwJwvuuns8UB/HeAg==} - engines: {node: '>=4'} - - minimalistic-assert@1.0.1: - resolution: {integrity: sha512-UtJcAD4yEaGtjPezWuO9wC4nwUnVH/8/Im3yEHQP4b67cXlD/Qr9hdITCU1xDbSEXg2XKNaP8jsReV7vQd00/A==} - - minimalistic-crypto-utils@1.0.1: - resolution: {integrity: sha512-JIYlbt6g8i5jKfJ3xz7rF0LXmv2TkDxBLUkiBeZ7bAx4GnnNMr8xFpGnOxn6GhTEHx3SjRrZEoU+j04prX1ktg==} - - minimatch@3.1.2: - resolution: {integrity: sha512-J7p63hRiAjw1NDEww1W7i37+ByIrOWO5XQQAzZ3VOcL0PNybwpfmV/N05zFAzwQ9USyEcX6t3UO+K5aqBQOIHw==} - - minimatch@5.0.1: - resolution: {integrity: sha512-nLDxIFRyhDblz3qMuq+SoRZED4+miJ/G+tdDrjkkkRnjAsBexeGpgjLEQ0blJy7rHhR2b93rhQY4SvyWu9v03g==} - engines: {node: '>=10'} - - minimist-options@4.1.0: - resolution: {integrity: sha512-Q4r8ghd80yhO/0j1O3B2BjweX3fiHg9cdOwjJd2J76Q135c+NDxGCqdYKQ1SKBuFfgWbAUzBfvYjPUEeNgqN1A==} - engines: {node: '>= 6'} - - minimist@1.2.8: - resolution: {integrity: sha512-2yyAR8qBkN3YuheJanUpWC5U3bb5osDywNB8RzDVlDwDHbocAJveqqj1u8+SVD7jkWT4yvsHCpWqqWqAxb0zCA==} - - minipass@2.9.0: - resolution: {integrity: sha512-wxfUjg9WebH+CUDX/CdbRlh5SmfZiy/hpkxaRI16Y9W56Pa75sWgd/rvFilSgrauD9NyFymP/+JFV3KwzIsJeg==} - - minizlib@1.3.3: - resolution: {integrity: sha512-6ZYMOEnmVsdCeTJVE0W9ZD+pVnE8h9Hma/iOwwRDsdQoePpoX56/8B6z3P9VNwppJuBKNRuFDRNRqRWexT9G9Q==} - - mixme@0.5.10: - resolution: {integrity: sha512-5H76ANWinB1H3twpJ6JY8uvAtpmFvHNArpilJAjXRKXSDDLPIMoZArw5SH0q9z+lLs8IrMw7Q2VWpWimFKFT1Q==} - engines: {node: '>= 8.0.0'} - - mkdirp-classic@0.5.3: - resolution: {integrity: sha512-gKLcREMhtuZRwRAfqP3RFW+TK4JqApVBtOIftVgjuABpAtpxhPGaDcfvbhNvD0B8iD1oUr/txX35NjcaY6Ns/A==} - - mkdirp-promise@5.0.1: - resolution: {integrity: sha512-Hepn5kb1lJPtVW84RFT40YG1OddBNTOVUZR2bzQUHc+Z03en8/3uX0+060JDhcEzyO08HmipsN9DcnFMxhIL9w==} - engines: {node: '>=4'} - deprecated: This package is broken and no longer maintained. 'mkdirp' itself supports promises now, please switch to that. - - mkdirp@0.5.6: - resolution: {integrity: sha512-FP+p8RB8OWpF3YZBCrP5gtADmtXApB5AMLn+vdyA+PyxCjrCs00mjyUozssO33cwDeT3wNGdLxJ5M//YqtHAJw==} - hasBin: true - - mkdirp@1.0.4: - resolution: {integrity: sha512-vVqVZQyf3WLx2Shd0qJ9xuvqgAyKPLAiqITEtqW0oIUjzo3PePDd6fW9iFz30ef7Ysp/oiWqbhszeGWW2T6Gzw==} - engines: {node: '>=10'} - hasBin: true - - mkdirp@3.0.1: - resolution: {integrity: sha512-+NsyUUAZDmo6YVHzL/stxSu3t9YS1iljliy3BSDrXJ/dkn1KYdmtZODGGjLcc9XLgVVpH4KshHB8XmZgMhaBXg==} - engines: {node: '>=10'} - hasBin: true - - mnemonist@0.38.5: - resolution: {integrity: sha512-bZTFT5rrPKtPJxj8KSV0WkPyNxl72vQepqqVUAW2ARUpUSF2qXMB6jZj7hW5/k7C1rtpzqbD/IIbJwLXUjCHeg==} - - mocha@10.4.0: - resolution: {integrity: sha512-eqhGB8JKapEYcC4ytX/xrzKforgEc3j1pGlAXVy3eRwrtAy5/nIfT1SvgGzfN0XZZxeLq0aQWkOUAmqIJiv+bA==} - engines: {node: '>= 14.0.0'} - hasBin: true - - mock-fs@4.14.0: - resolution: {integrity: sha512-qYvlv/exQ4+svI3UOvPUpLDF0OMX5euvUH0Ny4N5QyRyhNdgAgUrVH3iUINSzEPLvx0kbo/Bp28GJKIqvE7URw==} - - ms@2.0.0: - resolution: {integrity: sha512-Tpp60P6IUJDTuOq/5Z8cdskzJujfwqfOTkrwIwj7IRISpnkJnT6SyJ4PCPnGMoFjC9ddhal5KVIYtAt97ix05A==} - - ms@2.1.2: - resolution: {integrity: sha512-sGkPx+VjMtmA6MX27oA4FBFELFCZZ4S4XqeGOXCv68tT+jb3vk/RyaKWP0PTKyWtmLSM0b+adUTEvbs1PEaH2w==} - - ms@2.1.3: - resolution: {integrity: sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==} - - multibase@0.6.1: - resolution: {integrity: sha512-pFfAwyTjbbQgNc3G7D48JkJxWtoJoBMaR4xQUOuB8RnCgRqaYmWNFeJTTvrJ2w51bjLq2zTby6Rqj9TQ9elSUw==} - deprecated: This module has been superseded by the multiformats module - - multibase@0.7.0: - resolution: {integrity: sha512-TW8q03O0f6PNFTQDvh3xxH03c8CjGaaYrjkl9UQPG6rz53TQzzxJVCIWVjzcbN/Q5Y53Zd0IBQBMVktVgNx4Fg==} - deprecated: This module has been superseded by the multiformats module - - multicodec@0.5.7: - resolution: {integrity: sha512-PscoRxm3f+88fAtELwUnZxGDkduE2HD9Q6GHUOywQLjOGT/HAdhjLDYNZ1e7VR0s0TP0EwZ16LNUTFpoBGivOA==} - deprecated: This module has been superseded by the multiformats module - - multicodec@1.0.4: - resolution: {integrity: sha512-NDd7FeS3QamVtbgfvu5h7fd1IlbaC4EQ0/pgU4zqE2vdHCmBGsUa0TiM8/TdSeG6BMPC92OOCf8F1ocE/Wkrrg==} - deprecated: This module has been superseded by the multiformats module - - multihashes@0.4.21: - resolution: {integrity: sha512-uVSvmeCWf36pU2nB4/1kzYZjsXD9vofZKpgudqkceYY5g2aZZXJ5r9lxuzoRLl1OAp28XljXsEJ/X/85ZsKmKw==} - - mz@2.7.0: - resolution: {integrity: sha512-z81GNO7nnYMEhrGh9LeymoE4+Yr0Wn5McHIZMK5cfQCl+NDX08sCZgUc9/6MHni9IWuFLm1Z3HTCXu2z9fN62Q==} - - nano-base32@1.0.1: - resolution: {integrity: sha512-sxEtoTqAPdjWVGv71Q17koMFGsOMSiHsIFEvzOM7cNp8BXB4AnEwmDabm5dorusJf/v1z7QxaZYxUorU9RKaAw==} - - nano-json-stream-parser@0.1.2: - resolution: {integrity: sha512-9MqxMH/BSJC7dnLsEMPyfN5Dvoo49IsPFYMcHw3Bcfc2kN0lpHRBSzlMSVx4HGyJ7s9B31CyBTVehWJoQ8Ctew==} - - napi-build-utils@1.0.2: - resolution: {integrity: sha512-ONmRUqK7zj7DWX0D9ADe03wbwOBZxNAfF20PlGfCWQcD3+/MakShIHrMqx9YwPTfxDdF1zLeL+RGZiR9kGMLdg==} - - natural-compare-lite@1.4.0: - resolution: {integrity: sha512-Tj+HTDSJJKaZnfiuw+iaF9skdPpTo2GtEly5JHnWV/hfv2Qj/9RKsGISQtLh2ox3l5EAGw487hnBee0sIJ6v2g==} - - natural-compare@1.4.0: - resolution: {integrity: sha512-OWND8ei3VtNC9h7V60qff3SVobHr996CTwgxubgyQYEpg290h9J0buyECNNJexkFm5sOajh5G116RYA1c8ZMSw==} - - ndjson@2.0.0: - resolution: {integrity: sha512-nGl7LRGrzugTtaFcJMhLbpzJM6XdivmbkdlaGcrk/LXg2KL/YBC6z1g70xh0/al+oFuVFP8N8kiWRucmeEH/qQ==} - engines: {node: '>=10'} - hasBin: true - - negotiator@0.6.3: - resolution: {integrity: sha512-+EUsqGPLsM+j/zdChZjsnX51g4XrHFOIXwfnCVPGlQk/k5giakcKsuxCObBRu6DSm9opw/O6slWbJdghQM4bBg==} - engines: {node: '>= 0.6'} - - neo-async@2.6.2: - resolution: {integrity: sha512-Yd3UES5mWCSqR+qNT93S3UoYUkqAZ9lLg8a7g9rimsWmYGK8cVToA4/sF3RrshdyV3sAGMXVUmpMYOw+dLpOuw==} - - next-tick@1.1.0: - resolution: {integrity: sha512-CXdUiJembsNjuToQvxayPZF9Vqht7hewsvy2sOWafLvi2awflj9mOC6bHIg50orX8IJvWKY9wYQ/zB2kogPslQ==} - - nise@4.1.0: - resolution: {integrity: sha512-eQMEmGN/8arp0xsvGoQ+B1qvSkR73B1nWSCh7nOt5neMCtwcQVYQGdzQMhcNscktTsWB54xnlSQFzOAPJD8nXA==} - - no-case@2.3.2: - resolution: {integrity: sha512-rmTZ9kz+f3rCvK2TD1Ue/oZlns7OGoIWP4fc3llxxRXlOkHKoWPPWJOfFYpITabSow43QJbRIoHQXtt10VldyQ==} - - no-case@3.0.4: - resolution: {integrity: sha512-fgAN3jGAh+RoxUGZHTSOLJIqUc2wmoBwGR4tbpNAKmmovFoWq0OdRkb0VkldReO2a2iBT/OEulG9XSUc10r3zg==} - - node-abi@3.62.0: - resolution: {integrity: sha512-CPMcGa+y33xuL1E0TcNIu4YyaZCxnnvkVaEXrsosR3FxN+fV8xvb7Mzpb7IgKler10qeMkE6+Dp8qJhpzdq35g==} - engines: {node: '>=10'} - - node-addon-api@2.0.2: - resolution: {integrity: sha512-Ntyt4AIXyaLIuMHF6IOoTakB3K+RWxwtsHNRxllEoA6vPwP9o4866g6YWDLUdnucilZhmkxiHwHr11gAENw+QA==} - - node-addon-api@3.2.1: - resolution: {integrity: sha512-mmcei9JghVNDYydghQmeDX8KoAm0FAiYyIcUt/N4nhyAipB17pllZQDOJD2fotxABnt4Mdz+dKTO7eftLg4d0A==} - - node-addon-api@6.1.0: - resolution: {integrity: sha512-+eawOlIgy680F0kBzPUNFhMZGtJ1YmqM6l4+Crf4IkImjYrO/mqPwRMh352g23uIaQKFItcQ64I7KMaJxHgAVA==} - - node-emoji@1.11.0: - resolution: {integrity: sha512-wo2DpQkQp7Sjm2A0cq+sN7EHKO6Sl0ctXeBdFZrL9T9+UywORbufTcTZxom8YqpLQt/FqNMUkOpkZrJVYSKD3A==} - - node-fetch@2.7.0: - resolution: {integrity: sha512-c4FRfUm/dbcWZ7U+1Wq0AwCyFL+3nt2bEw05wfxSz+DWpWsitgmSgYmy2dQdWyKC1694ELPqMs/YzUSNozLt8A==} - engines: {node: 4.x || >=6.0.0} - peerDependencies: - encoding: ^0.1.0 - peerDependenciesMeta: - encoding: - optional: true - - node-gyp-build@4.8.1: - resolution: {integrity: sha512-OSs33Z9yWr148JZcbZd5WiAXhh/n9z8TxQcdMhIOlpN9AhWpLfvVFO73+m77bBABQMaY9XSvIa+qk0jlI7Gcaw==} - hasBin: true - - node-hid@2.2.0: - resolution: {integrity: sha512-vj48zh9j555DZzUhMc8tk/qw6xPFrDyPBH1ST1Z/hWaA/juBJw7IuSxPeOgpzNFNU36mGYj+THioRMt1xOdm/g==} - engines: {node: '>=10'} - hasBin: true - - node-preload@0.2.1: - resolution: {integrity: sha512-RM5oyBy45cLEoHqCeh+MNuFAxO0vTFBLskvQbOKnEE7YTTSN4tbN8QWDIPQ6L+WvKsB/qLEGpYe2ZZ9d4W9OIQ==} - engines: {node: '>=8'} - - node-releases@2.0.14: - resolution: {integrity: sha512-y10wOWt8yZpqXmOgRo77WaHEmhYQYGNA6y421PKsKYWEK8aW+cqAphborZDhqfyKrbZEN92CN1X2KbafY2s7Yw==} - - nofilter@1.0.4: - resolution: {integrity: sha512-N8lidFp+fCz+TD51+haYdbDGrcBWwuHX40F5+z0qkUjMJ5Tp+rdSuAkMJ9N9eoolDlEVTf6u5icM+cNKkKW2mA==} - engines: {node: '>=8'} - - nofilter@3.1.0: - resolution: {integrity: sha512-l2NNj07e9afPnhAhvgVrCD/oy2Ai1yfLpuo3EpiO1jFTsB4sFz6oIfAfSZyQzVpkZQ9xS8ZS5g1jCBgq4Hwo0g==} - engines: {node: '>=12.19'} - - nopt@3.0.6: - resolution: {integrity: sha512-4GUt3kSEYmk4ITxzB/b9vaIDfUVWN/Ml1Fwl11IlnIG2iaJ9O6WXZ9SrYM9NLI8OCBieN2Y8SWC2oJV0RQ7qYg==} - hasBin: true - - normalize-package-data@2.5.0: - resolution: {integrity: sha512-/5CMN3T0R4XTj4DcGaexo+roZSdSFW/0AOOTROrjxzCG1wrWXEsGbRKevjlIL+ZDE4sZlJr5ED4YW0yqmkK+eA==} - - normalize-path@3.0.0: - resolution: {integrity: sha512-6eZs5Ls3WtCisHWp9S2GUy8dqkpGi4BVSz3GaqiE6ezub0512ESztXUwUB6C6IKbQkY2Pnb/mD4WYojCRwcwLA==} - engines: {node: '>=0.10.0'} - - normalize-url@6.1.0: - resolution: {integrity: sha512-DlL+XwOy3NxAQ8xuC0okPgK46iuVNAK01YN7RueYBqqFeGsBjV9XmCAzAdgt+667bCl5kPh9EqKKDwnaPG1I7A==} - engines: {node: '>=10'} - - nth-check@2.1.1: - resolution: {integrity: sha512-lqjrjmaOoAnWfMmBPL+XNnynZh2+swxiX3WUE0s4yEHI6m+AwrK2UZOimIRl3X/4QctVqS8AiZjFqyOGrMXb/w==} - - number-is-nan@1.0.1: - resolution: {integrity: sha512-4jbtZXNAsfZbAHiiqjLPBiCl16dES1zI4Hpzzxw61Tk+loF+sBDBKx1ICKKKwIqQ7M0mFn1TmkN7euSncWgHiQ==} - engines: {node: '>=0.10.0'} - - number-to-bn@1.7.0: - resolution: {integrity: sha512-wsJ9gfSz1/s4ZsJN01lyonwuxA1tml6X1yBDnfpMglypcBRFZZkus26EdPSlqS5GJfYddVZa22p3VNb3z5m5Ig==} - engines: {node: '>=6.5.0', npm: '>=3'} - - nyc@15.1.0: - resolution: {integrity: sha512-jMW04n9SxKdKi1ZMGhvUTHBN0EICCRkHemEoE5jm6mTYcqcdas0ATzgUgejlQUHMvpnOZqGB5Xxsv9KxJW1j8A==} - engines: {node: '>=8.9'} - hasBin: true - - oauth-sign@0.9.0: - resolution: {integrity: sha512-fexhUFFPTGV8ybAtSIGbV6gOkSv8UtRbDBnAyLQw4QPKkgNlsH2ByPGtMUqdWkos6YCRmAqViwgZrJc/mRDzZQ==} - - object-assign@4.1.1: - resolution: {integrity: sha512-rJgTQnkUnH1sFw8yT6VSU3zD3sWmu6sZhIseY8VX+GRu3P6F7Fu+JNDoXfklElbLJSnc3FUQHVe4cU5hj+BcUg==} - engines: {node: '>=0.10.0'} - - object-inspect@1.13.1: - resolution: {integrity: sha512-5qoj1RUiKOMsCCNLV1CBiPYE10sziTsnmNxkAI/rZhiD63CF7IqdFGC/XzjWjpSgLf0LxXX3bDFIh0E18f6UhQ==} - - object-keys@1.1.1: - resolution: {integrity: sha512-NuAESUOUMrlIXOfHKzD6bpPu3tYt3xvjNdRIQ+FeT0lNb4K8WR70CaDxhuNguS2XG+GjkyMwOzsN5ZktImfhLA==} - engines: {node: '>= 0.4'} - - object.assign@4.1.5: - resolution: {integrity: sha512-byy+U7gp+FVwmyzKPYhW2h5l3crpmGsxl7X2s8y43IgxvG4g3QZ6CffDtsNQy1WsmZpQbO+ybo0AlW7TY6DcBQ==} - engines: {node: '>= 0.4'} - - object.values@1.2.0: - resolution: {integrity: sha512-yBYjY9QX2hnRmZHAjG/f13MzmBzxzYgQhFrke06TTyKY5zSTEqkOeukBzIdVA3j3ulu8Qa3MbVFShV7T2RmGtQ==} - engines: {node: '>= 0.4'} - - obliterator@2.0.4: - resolution: {integrity: sha512-lgHwxlxV1qIg1Eap7LgIeoBWIMFibOjbrYPIPJZcI1mmGAI2m3lNYpK12Y+GBdPQ0U1hRwSord7GIaawz962qQ==} - - oboe@2.1.5: - resolution: {integrity: sha512-zRFWiF+FoicxEs3jNI/WYUrVEgA7DeET/InK0XQuudGHRg8iIob3cNPrJTKaz4004uaA9Pbe+Dwa8iluhjLZWA==} - - on-finished@2.4.1: - resolution: {integrity: sha512-oVlzkg3ENAhCk2zdv7IJwd/QUD4z2RxRwpkcGY8psCVcCYZNq4wYnVWALHM+brtuJjePWiYF/ClmuDr8Ch5+kg==} - engines: {node: '>= 0.8'} - - once@1.4.0: - resolution: {integrity: sha512-lNaJgI+2Q5URQBkccEKHTQOPaXdUxnZZElQTZY0MFUAuaEqe1E+Nyvgdz/aIyNi6Z9MzO5dv1H8n58/GELp3+w==} - - onetime@5.1.2: - resolution: {integrity: sha512-kbpaSSGJTWdAY5KPVeMOKXSrPtr8C8C7wodJbcsd51jRnmD+GZu8Y0VoU6Dm5Z4vWr0Ig/1NKuWRKf7j5aaYSg==} - engines: {node: '>=6'} - - optionator@0.8.3: - resolution: {integrity: sha512-+IW9pACdk3XWmmTXG8m3upGUJst5XRGzxMRjXzAuJ1XnIFNvfhjjIuYkDvysnPQ7qzqVzLt78BCruntqRhWQbA==} - engines: {node: '>= 0.8.0'} - - optionator@0.9.4: - resolution: {integrity: sha512-6IpQ7mKUxRcZNLIObR0hz7lxsapSSIYNZJwXPGeF0mTVqGKFIXj1DQcMoT22S3ROcLyY/rz0PWaWZ9ayWmad9g==} - engines: {node: '>= 0.8.0'} - - ora@5.4.1: - resolution: {integrity: sha512-5b6Y85tPxZZ7QytO+BQzysW31HJku27cRIlkbAXaNx+BdcVi+LlRFmVXzeF6a7JCwJpyw5c4b+YSVImQIrBpuQ==} - engines: {node: '>=10'} - - ordinal@1.0.3: - resolution: {integrity: sha512-cMddMgb2QElm8G7vdaa02jhUNbTSrhsgAGUz1OokD83uJTwSUn+nKoNoKVVaRa08yF6sgfO7Maou1+bgLd9rdQ==} - - os-locale@1.4.0: - resolution: {integrity: sha512-PRT7ZORmwu2MEFt4/fv3Q+mEfN4zetKxufQrkShY2oGvUms9r8otu5HfdyIFHkYXjO7laNsoVGmM2MANfuTA8g==} - engines: {node: '>=0.10.0'} - - os-tmpdir@1.0.2: - resolution: {integrity: sha512-D2FR03Vir7FIu45XBY20mTb+/ZSWB00sjU9jdQXt83gDrI4Ztz5Fs7/yy74g2N5SVQY4xY1qDr4rNddwYRVX0g==} - engines: {node: '>=0.10.0'} - - outdent@0.5.0: - resolution: {integrity: sha512-/jHxFIzoMXdqPzTaCpFzAAWhpkSjZPF4Vsn6jAfNpmbH/ymsmd7Qc6VE9BGn0L6YMj6uwpQLxCECpus4ukKS9Q==} - - p-cancelable@2.1.1: - resolution: {integrity: sha512-BZOr3nRQHOntUjTrH8+Lh54smKHoHyur8We1V8DSMVrl5A2malOOwuJRnKRDjSnkoeBh4at6BwEnb5I7Jl31wg==} - engines: {node: '>=8'} - - p-cancelable@3.0.0: - resolution: {integrity: sha512-mlVgR3PGuzlo0MmTdk4cXqXWlwQDLnONTAg6sm62XkMJEiRxN3GL3SffkYvqwonbkJBcrI7Uvv5Zh9yjvn2iUw==} - engines: {node: '>=12.20'} - - p-filter@2.1.0: - resolution: {integrity: sha512-ZBxxZ5sL2HghephhpGAQdoskxplTwr7ICaehZwLIlfL6acuVgZPm8yBNuRAFBGEqtD/hmUeq9eqLg2ys9Xr/yw==} - engines: {node: '>=8'} - - p-limit@1.3.0: - resolution: {integrity: sha512-vvcXsLAJ9Dr5rQOPk7toZQZJApBl2K4J6dANSsEuh6QI41JYcsS/qhTGa9ErIUUgK3WNQoJYvylxvjqmiqEA9Q==} - engines: {node: '>=4'} - - p-limit@2.3.0: - resolution: {integrity: sha512-//88mFWSJx8lxCzwdAABTJL2MyWB12+eIY7MDL2SqLmAkeKU9qxRvWuSyTjm3FUmpBEMuFfckAIqEaVGUDxb6w==} - engines: {node: '>=6'} - - p-limit@3.1.0: - resolution: {integrity: sha512-TYOanM3wGwNGsZN2cVTYPArw454xnXj5qmWF1bEoAc4+cU/ol7GVh7odevjp1FNHduHc3KZMcFduxU5Xc6uJRQ==} - engines: {node: '>=10'} - - p-locate@2.0.0: - resolution: {integrity: sha512-nQja7m7gSKuewoVRen45CtVfODR3crN3goVQ0DDZ9N3yHxgpkuBhZqsaiotSQRrADUrne346peY7kT3TSACykg==} - engines: {node: '>=4'} - - p-locate@4.1.0: - resolution: {integrity: sha512-R79ZZ/0wAxKGu3oYMlz8jy/kbhsNrS7SKZ7PxEHBgJ5+F2mtFW2fK2cOtBh1cHYkQsbzFV7I+EoRKe6Yt0oK7A==} - engines: {node: '>=8'} - - p-locate@5.0.0: - resolution: {integrity: sha512-LaNjtRWUBY++zB5nE/NwcaoMylSPk+S+ZHNB1TzdbMJMny6dynpAGt7X/tl/QYq3TIeE6nxHppbo2LGymrG5Pw==} - engines: {node: '>=10'} - - p-map@2.1.0: - resolution: {integrity: sha512-y3b8Kpd8OAN444hxfBbFfj1FY/RjtTd8tzYwhUqNYXx0fXx2iX4maP4Qr6qhIKbQXI02wTLAda4fYUbDagTUFw==} - engines: {node: '>=6'} - - p-map@3.0.0: - resolution: {integrity: sha512-d3qXVTF/s+W+CdJ5A29wywV2n8CQQYahlgz2bFiA+4eVNJbHJodPZ+/gXwPGh0bOqA+j8S+6+ckmvLGPk1QpxQ==} - engines: {node: '>=8'} - - p-map@4.0.0: - resolution: {integrity: sha512-/bjOqmgETBYB5BoEeGVea8dmvHb2m9GLy1E9W43yeyfP6QQCZGFNa+XRceJEuDB6zqr+gKpIAmlLebMpykw/MQ==} - engines: {node: '>=10'} - - p-try@1.0.0: - resolution: {integrity: sha512-U1etNYuMJoIz3ZXSrrySFjsXQTWOx2/jdi86L+2pRvph/qMKL6sbcCYdH23fqsbm8TH2Gn0OybpT4eSFlCVHww==} - engines: {node: '>=4'} - - p-try@2.2.0: - resolution: {integrity: sha512-R4nPAVTAU0B9D35/Gk3uJf/7XYbQcyohSKdvAxIRSNghFl4e71hVoGnBNQz9cWaXxO2I10KTC+3jMdvvoKw6dQ==} - engines: {node: '>=6'} - - package-hash@4.0.0: - resolution: {integrity: sha512-whdkPIooSu/bASggZ96BWVvZTRMOFxnyUG5PnTSGKoJE2gd5mbVNmR2Nj20QFzxYYgAXpoqC+AiXzl+UMRh7zQ==} - engines: {node: '>=8'} - - pako@1.0.11: - resolution: {integrity: sha512-4hLB8Py4zZce5s4yd9XzopqwVv/yGNhV1Bl8NTmCq1763HeK2+EwVTv+leGeL13Dnh2wfbqowVPXCIO0z4taYw==} - - param-case@2.1.1: - resolution: {integrity: sha512-eQE845L6ot89sk2N8liD8HAuH4ca6Vvr7VWAWwt7+kvvG5aBcPmmphQ68JsEG2qa9n1TykS2DLeMt363AAH8/w==} - - parent-module@1.0.1: - resolution: {integrity: sha512-GQ2EWRpQV8/o+Aw8YqtfZZPfNRWZYkbidE9k5rpl/hC3vtHHBfGm2Ifi6qWV+coDGkrUKZAxE3Lot5kcsRlh+g==} - engines: {node: '>=6'} - - parse-cache-control@1.0.1: - resolution: {integrity: sha512-60zvsJReQPX5/QP0Kzfd/VrpjScIQ7SHBW6bFCYfEP+fp0Eppr1SHhIO5nd1PjZtvclzSzES9D/p5nFJurwfWg==} - - parse-headers@2.0.5: - resolution: {integrity: sha512-ft3iAoLOB/MlwbNXgzy43SWGP6sQki2jQvAyBg/zDFAgr9bfNWZIUj42Kw2eJIl8kEi4PbgE6U1Zau/HwI75HA==} - - parse-json@2.2.0: - resolution: {integrity: sha512-QR/GGaKCkhwk1ePQNYDRKYZ3mwU9ypsKhB0XyFnLQdomyEqk3e8wpW3V5Jp88zbxK4n5ST1nqo+g9juTpownhQ==} - engines: {node: '>=0.10.0'} - - parse-json@5.2.0: - resolution: {integrity: sha512-ayCKvm/phCGxOkYRSCM82iDwct8/EonSEgCSxWxD7ve6jHggsFl4fZVQBPRNgQoKiuV/odhFrGzQXZwbifC8Rg==} - engines: {node: '>=8'} - - parse-ms@0.1.2: - resolution: {integrity: sha512-VwMglE9412ifMHcRFEVJePEpreQh90wjIiOdP0UQQGKV4l+QprdKI+p5noXTkmGjznBMb40s+VymcclATAVvYA==} - engines: {node: '>=0.10.0'} - - parse5-htmlparser2-tree-adapter@7.0.0: - resolution: {integrity: sha512-B77tOZrqqfUfnVcOrUvfdLbz4pu4RopLD/4vmu3HUPswwTA8OH0EMW9BlWR2B0RCoiZRAHEUu7IxeP1Pd1UU+g==} - - parse5@7.1.2: - resolution: {integrity: sha512-Czj1WaSVpaoj0wbhMzLmWD69anp2WH7FXMB9n1Sy8/ZFF9jolSQVMu1Ij5WIyGmcBmhk7EOndpO4mIpihVqAXw==} - - parseurl@1.3.3: - resolution: {integrity: sha512-CiyeOxFT/JZyN5m0z9PfXw4SCBJ6Sygz1Dpl0wqjlhDEGGBP1GnsUVEL0p63hoG1fcj3fHynXi9NYO4nWOL+qQ==} - engines: {node: '>= 0.8'} - - pascal-case@2.0.1: - resolution: {integrity: sha512-qjS4s8rBOJa2Xm0jmxXiyh1+OFf6ekCWOvUaRgAQSktzlTbMotS0nmG9gyYAybCWBcuP4fsBeRCKNwGBnMe2OQ==} - - path-case@2.1.1: - resolution: {integrity: sha512-Ou0N05MioItesaLr9q8TtHVWmJ6fxWdqKB2RohFmNWVyJ+2zeKIeDNWAN6B/Pe7wpzWChhZX6nONYmOnMeJQ/Q==} - - path-exists@2.1.0: - resolution: {integrity: sha512-yTltuKuhtNeFJKa1PiRzfLAU5182q1y4Eb4XCJ3PBqyzEDkAZRzBrKKBct682ls9reBVHf9udYLN5Nd+K1B9BQ==} - engines: {node: '>=0.10.0'} - - path-exists@3.0.0: - resolution: {integrity: sha512-bpC7GYwiDYQ4wYLe+FA8lhRjhQCMcQGuSgGGqDkg/QerRWw9CmGRT0iSOVRSZJ29NMLZgIzqaljJ63oaL4NIJQ==} - engines: {node: '>=4'} - - path-exists@4.0.0: - resolution: {integrity: sha512-ak9Qy5Q7jYb2Wwcey5Fpvg2KoAc/ZIhLSLOSBmRmygPsGwkVVt0fZa0qrtMz+m6tJTAHfZQ8FnmB4MG4LWy7/w==} - engines: {node: '>=8'} - - path-is-absolute@1.0.1: - resolution: {integrity: sha512-AVbw3UJ2e9bq64vSaS9Am0fje1Pa8pbGqTTsmXfaIiMpnr5DlDhfJOuLj9Sf95ZPVDAUerDfEk88MPmPe7UCQg==} - engines: {node: '>=0.10.0'} - - path-key@3.1.1: - resolution: {integrity: sha512-ojmeN0qd+y0jszEtoY48r0Peq5dwMEkIlCOu6Q5f41lfkswXuKtYrhgoTpLnyIcHm24Uhqx+5Tqm2InSwLhE6Q==} - engines: {node: '>=8'} - - path-parse@1.0.7: - resolution: {integrity: sha512-LDJzPVEEEPR+y48z93A0Ed0yXb8pAByGWo/k5YYdYgpY2/2EsOsksJrq7lOHxryrVOn1ejG6oAp8ahvOIQD8sw==} - - path-to-regexp@0.1.7: - resolution: {integrity: sha512-5DFkuoqlv1uYQKxy8omFBeJPQcdoE07Kv2sferDCrAq1ohOU+MSDswDIbnx3YAM60qIOnYa53wBhXW0EbMonrQ==} - - path-to-regexp@1.8.0: - resolution: {integrity: sha512-n43JRhlUKUAlibEJhPeir1ncUID16QnEjNpwzNdO3Lm4ywrBpBZ5oLD0I6br9evr1Y9JTqwRtAh7JLoOzAQdVA==} - - path-type@1.1.0: - resolution: {integrity: sha512-S4eENJz1pkiQn9Znv33Q+deTOKmbl+jj1Fl+qiP/vYezj+S8x+J3Uo0ISrx/QoEvIlOaDWJhPaRd1flJ9HXZqg==} - engines: {node: '>=0.10.0'} - - path-type@4.0.0: - resolution: {integrity: sha512-gDKb8aZMDeD/tZWs9P6+q0J9Mwkdl6xMV8TjnGP3qJVJ06bdMgkbBlLU8IdfOsIsFz2BW1rNVT3XuNEl8zPAvw==} - engines: {node: '>=8'} - - pathval@1.1.1: - resolution: {integrity: sha512-Dp6zGqpTdETdR63lehJYPeIOqpiNBNtc7BpWSLrOje7UaIsE5aY92r/AunQA7rsXvet3lrJ3JnZX29UPTKXyKQ==} - - pbkdf2@3.1.2: - resolution: {integrity: sha512-iuh7L6jA7JEGu2WxDwtQP1ddOpaJNC4KlDEFfdQajSGgGPNi4OyDc2R7QnbY2bR9QjBVGwgvTdNJZoE7RaxUMA==} - engines: {node: '>=0.12'} - - performance-now@2.1.0: - resolution: {integrity: sha512-7EAHlyLHI56VEIdK57uwHdHKIaAGbnXPiw0yWbarQZOKaKpvUIgW0jWRVLiatnM+XXlSwsanIBH/hzGMJulMow==} - - picocolors@1.0.0: - resolution: {integrity: sha512-1fygroTLlHu66zi26VoTDv8yRgm0Fccecssto+MhsZ0D/DGW2sm8E8AjW7NU5VVTRt5GxbeZ5qBuJr+HyLYkjQ==} - - picomatch@2.3.1: - resolution: {integrity: sha512-JU3teHTNjmE2VCGFzuY8EXzCDVwEqB2a8fsIvwaStHhAWJEeVd1o1QD80CU6+ZdEXXSLbSsuLwJjkCBWqRQUVA==} - engines: {node: '>=8.6'} - - pify@2.3.0: - resolution: {integrity: sha512-udgsAY+fTnvv7kI7aaxbqwWNb0AHiB0qBO89PZKPkoTmGOgdbrHDKD+0B2X4uTfJ/FT1R09r9gTsjUjNJotuog==} - engines: {node: '>=0.10.0'} - - pify@4.0.1: - resolution: {integrity: sha512-uB80kBFb/tfd68bVleG9T5GGsGPjJrLAUpR5PZIrhBnIaRTQRjqdJSsIKkOP6OAIFbj7GOrcudc5pNjZ+geV2g==} - engines: {node: '>=6'} - - pinkie-promise@2.0.1: - resolution: {integrity: sha512-0Gni6D4UcLTbv9c57DfxDGdr41XfgUjqWZu492f0cIGr16zDU06BWP/RAEvOuo7CQ0CNjHaLlM59YJJFm3NWlw==} - engines: {node: '>=0.10.0'} - - pinkie@2.0.4: - resolution: {integrity: sha512-MnUuEycAemtSaeFSjXKW/aroV7akBbY+Sv+RkyqFjgAe73F+MR0TBWKBRDkmfWq/HiFmdavfZ1G7h4SPZXaCSg==} - engines: {node: '>=0.10.0'} - - pkg-dir@4.2.0: - resolution: {integrity: sha512-HRDzbaKjC+AOWVXxAU/x54COGeIv9eb+6CkDSQoNTt4XyWoIJvuPsXizxu/Fr23EiekbtZwmh1IcIG/l/a10GQ==} - engines: {node: '>=8'} - - pluralize@8.0.0: - resolution: {integrity: sha512-Nc3IT5yHzflTfbjgqWcCPpo7DaKy4FnpB0l/zCAW0Tc7jxAiuqSxHasntB3D7887LSrA93kDJ9IXovxJYxyLCA==} - engines: {node: '>=4'} - - possible-typed-array-names@1.0.0: - resolution: {integrity: sha512-d7Uw+eZoloe0EHDIYoe+bQ5WXnGMOpmiZFTuMWCwpjzzkL2nTjcKiAk4hh8TjnGye2TwWOk3UXucZ+3rbmBa8Q==} - engines: {node: '>= 0.4'} - - prebuild-install@7.1.2: - resolution: {integrity: sha512-UnNke3IQb6sgarcZIDU3gbMeTp/9SSU1DAIkil7PrqG1vZlBtY5msYccSKSHDqa3hNg436IXK+SNImReuA1wEQ==} - engines: {node: '>=10'} - hasBin: true - - preferred-pm@3.1.3: - resolution: {integrity: sha512-MkXsENfftWSRpzCzImcp4FRsCc3y1opwB73CfCNWyzMqArju2CrlMHlqB7VexKiPEOjGMbttv1r9fSCn5S610w==} - engines: {node: '>=10'} - - prelude-ls@1.1.2: - resolution: {integrity: sha512-ESF23V4SKG6lVSGZgYNpbsiaAkdab6ZgOxe52p7+Kid3W3u3bxR4Vfd/o21dmN7jSt0IwgZ4v5MUd26FEtXE9w==} - engines: {node: '>= 0.8.0'} - - prelude-ls@1.2.1: - resolution: {integrity: sha512-vkcDPrRZo1QZLbn5RLGPpg/WmIQ65qoWWhcGKf/b5eplkkarX0m9z8ppCat4mlOqUsWpyNuYgO3VRyrYHSzX5g==} - engines: {node: '>= 0.8.0'} - - prettier-linter-helpers@1.0.0: - resolution: {integrity: sha512-GbK2cP9nraSSUF9N2XwUwqfzlAFlMNYYl+ShE/V+H8a9uNl/oUqB1w2EL54Jh0OlyRSd8RfWYJ3coVS4TROP2w==} - engines: {node: '>=6.0.0'} - - prettier@2.4.1: - resolution: {integrity: sha512-9fbDAXSBcc6Bs1mZrDYb3XKzDLm4EXXL9sC1LqKP5rZkT6KRr/rf9amVUcODVXgguK/isJz0d0hP72WeaKWsvA==} - engines: {node: '>=10.13.0'} - hasBin: true - - prettier@2.8.8: - resolution: {integrity: sha512-tdN8qQGvNjw4CHbY+XXk0JgCXn9QiF21a55rBe5LJAU+kDyC4WQn4+awm2Xfk2lQMk5fKup9XgzTZtGkjBdP9Q==} - engines: {node: '>=10.13.0'} - hasBin: true - - pretty-format@29.7.0: - resolution: {integrity: sha512-Pdlw/oPxN+aXdmM9R00JVC9WVFoCLTKJvDVLgmJ+qAffBMxsV85l/Lu7sNx4zSzPyoL2euImuEwHhOXdEgNFZQ==} - engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0} - - pretty-ms@0.2.2: - resolution: {integrity: sha512-ah/vWDJAT0arxQwVcSGp6etaLTZr4IsrXTy/khfjimzdYgSxYWzTMByrtpJUWinAnVY8szDg+qQhsE5MUMz3lQ==} - engines: {node: '>=0.10.0'} - hasBin: true - - process-nextick-args@2.0.1: - resolution: {integrity: sha512-3ouUOpQhtgrbOa17J7+uxOTpITYWaGP7/AhoR3+A+/1e9skrzelGi/dXzEYyvbxubEF6Wn2ypscTKiKJFFn1ag==} - - process-on-spawn@1.0.0: - resolution: {integrity: sha512-1WsPDsUSMmZH5LeMLegqkPDrsGgsWwk1Exipy2hvB0o/F0ASzbpIctSCcZIK1ykJvtTJULEH+20WOFjMvGnCTg==} - engines: {node: '>=8'} - - process@0.11.10: - resolution: {integrity: sha512-cdGef/drWFoydD1JsMzuFf8100nZl+GT+yacc2bEced5f9Rjk4z+WtFUTBu9PhOi9j/jfmBPu0mMEY4wIdAF8A==} - engines: {node: '>= 0.6.0'} - - promise@8.3.0: - resolution: {integrity: sha512-rZPNPKTOYVNEEKFaq1HqTgOwZD+4/YHS5ukLzQCypkj+OkYx7iv0mA91lJlpPPZ8vMau3IIGj5Qlwrx+8iiSmg==} - - prompts@2.4.2: - resolution: {integrity: sha512-NxNv/kLguCA7p3jE8oL2aEBsrJWgAakBpgmgK6lpPWV+WuOmY6r2/zbAVnP+T8bQlA0nzHXSJSJW0Hq7ylaD2Q==} - engines: {node: '>= 6'} - - proxy-addr@2.0.7: - resolution: {integrity: sha512-llQsMLSUDUPT44jdrU/O37qlnifitDP+ZwrmmZcoSKyLKvtZxpyV0n2/bD/N4tBAAZ/gJEdZU7KMraoK1+XYAg==} - engines: {node: '>= 0.10'} - - proxy-from-env@1.1.0: - resolution: {integrity: sha512-D+zkORCbA9f1tdWRK0RaCR3GPv50cMxcrz4X8k5LTSUD1Dkw47mKJEZQNunItRTkWwgtaUSo1RVFRIG9ZXiFYg==} - - pseudomap@1.0.2: - resolution: {integrity: sha512-b/YwNhb8lk1Zz2+bXXpS/LK9OisiZZ1SNsSLxN1x2OXVEhW2Ckr/7mWE5vrC1ZTiJlD9g19jWszTmJsB+oEpFQ==} - - psl@1.9.0: - resolution: {integrity: sha512-E/ZsdU4HLs/68gYzgGTkMicWTLPdAftJLfJFlLUAAKZGkStNU72sZjT66SnMDVOfOWY/YAoiD7Jxa9iHvngcag==} - - pump@3.0.0: - resolution: {integrity: sha512-LwZy+p3SFs1Pytd/jYct4wpv49HiYCqd9Rlc5ZVdk0V+8Yzv6jR5Blk3TRmPL1ft69TxP0IMZGJ+WPFU2BFhww==} - - punycode@2.1.0: - resolution: {integrity: sha512-Yxz2kRwT90aPiWEMHVYnEf4+rhwF1tBmmZ4KepCP+Wkium9JxtWnUm1nqGwpiAHr/tnTSeHqr3wb++jgSkXjhA==} - engines: {node: '>=6'} - - punycode@2.3.1: - resolution: {integrity: sha512-vYt7UD1U9Wg6138shLtLOvdAu+8DsC/ilFtEVHcH+wydcSpNE20AfSOduf6MkRFahL5FY7X1oU7nKVZFtfq8Fg==} - engines: {node: '>=6'} - - pure-rand@5.0.5: - resolution: {integrity: sha512-BwQpbqxSCBJVpamI6ydzcKqyFmnd5msMWUGvzXLm1aXvusbbgkbOto/EUPM00hjveJEaJtdbhUjKSzWRhQVkaw==} - - qs@6.11.0: - resolution: {integrity: sha512-MvjoMCJwEarSbUYk5O+nmoSzSutSsTwF85zcHPQ9OrlFoZOYIjaqBAJIqIXjptyD5vThxGq52Xu/MaJzRkIk4Q==} - engines: {node: '>=0.6'} - - qs@6.12.1: - resolution: {integrity: sha512-zWmv4RSuB9r2mYQw3zxQuHWeU+42aKi1wWig/j4ele4ygELZ7PEO6MM7rim9oAQH2A5MWfsAVf/jPvTPgCbvUQ==} - engines: {node: '>=0.6'} - - qs@6.5.3: - resolution: {integrity: sha512-qxXIEh4pCGfHICj1mAJQ2/2XVZkjCDTcEgfoSQxc/fYivUZxTkk7L3bDBJSoNrEzXI17oUO5Dp07ktqE5KzczA==} - engines: {node: '>=0.6'} - - query-string@5.1.1: - resolution: {integrity: sha512-gjWOsm2SoGlgLEdAGt7a6slVOk9mGiXmPFMqrEhLQ68rhQuBnpfs3+EmlvqKyxnCo9/PPlF+9MtY02S1aFg+Jw==} - engines: {node: '>=0.10.0'} - - queue-microtask@1.2.3: - resolution: {integrity: sha512-NuaNSa6flKT5JaSYQzJok04JzTL1CA6aGhv5rfLW3PgqA+M2ChpZQnAC8h8i4ZFkBS8X5RqkDBHA7r4hej3K9A==} - - quick-lru@4.0.1: - resolution: {integrity: sha512-ARhCpm70fzdcvNQfPoy49IaanKkTlRWF2JMzqhcJbhSFRZv7nPTvZJdcY7301IPmvW+/p0RgIWnQDLJxifsQ7g==} - engines: {node: '>=8'} - - quick-lru@5.1.1: - resolution: {integrity: sha512-WuyALRjWPDGtt/wzJiadO5AXY+8hZ80hVpe6MyivgraREW751X3SbhRvG3eLKOYN+8VEvqLcf3wdnt44Z4S4SA==} - engines: {node: '>=10'} - - rambda@7.5.0: - resolution: {integrity: sha512-y/M9weqWAH4iopRd7EHDEQQvpFPHj1AA3oHozE9tfITHUtTR7Z9PSlIRRG2l1GuW7sefC1cXFfIcF+cgnShdBA==} - - randombytes@2.1.0: - resolution: {integrity: sha512-vYl3iOX+4CKUWuxGi9Ukhie6fsqXqS9FE2Zaic4tNFD2N2QQaXOMFbuKK4QmDHC0JO6B1Zp41J0LpT0oR68amQ==} - - range-parser@1.2.1: - resolution: {integrity: sha512-Hrgsx+orqoygnmhFbKaHE6c296J+HTAQXoxEF6gNupROmmGJRoyzfG3ccAveqCBrwr/2yxQ5BVd/GTl5agOwSg==} - engines: {node: '>= 0.6'} - - raw-body@2.5.2: - resolution: {integrity: sha512-8zGqypfENjCIqGhgXToC8aB2r7YrBX+AQAfIPs/Mlk+BtPTztOvTS01NRW/3Eh60J+a48lt8qsCzirQ6loCVfA==} - engines: {node: '>= 0.8'} - - rc@1.2.8: - resolution: {integrity: sha512-y3bGgqKj3QBdxLbLkomlohkvsA8gdAiUQlSBJnBhfn+BPxg4bc62d8TcBW15wavDfgexCgccckhcZvywyQYPOw==} - hasBin: true - - react-dom@18.3.1: - resolution: {integrity: sha512-5m4nQKp+rZRb09LNH59GM4BxTh9251/ylbKIbpe7TpGxfJ+9kv6BLkLBXIjjspbgbnIBNqlI23tRnTWT0snUIw==} - peerDependencies: - react: ^18.3.1 - - react-is@18.3.1: - resolution: {integrity: sha512-/LLMVyas0ljjAtoYiPqYiL8VWXzUUdThrmU5+n20DZv+a+ClRoevUzw5JxU+Ieh5/c87ytoTBV9G1FiKfNJdmg==} - - react@18.3.1: - resolution: {integrity: sha512-wS+hAgJShR0KhEvPJArfuPVN1+Hz1t0Y6n5jLrGQbkb4urgPE/0Rve+1kMB1v/oWgHgm4WIcV+i7F2pTVj+2iQ==} - engines: {node: '>=0.10.0'} - - read-pkg-up@1.0.1: - resolution: {integrity: sha512-WD9MTlNtI55IwYUS27iHh9tK3YoIVhxis8yKhLpTqWtml739uXc9NWTpxoHkfZf3+DkCCsXox94/VWZniuZm6A==} - engines: {node: '>=0.10.0'} - - read-pkg-up@7.0.1: - resolution: {integrity: sha512-zK0TB7Xd6JpCLmlLmufqykGE+/TlOePD6qKClNW7hHDKFh/J7/7gCWGR7joEQEW1bKq3a3yUZSObOoWLFQ4ohg==} - engines: {node: '>=8'} - - read-pkg@1.1.0: - resolution: {integrity: sha512-7BGwRHqt4s/uVbuyoeejRn4YmFnYZiFl4AuaeXHlgZf3sONF0SOGlxs2Pw8g6hCKupo08RafIO5YXFNOKTfwsQ==} - engines: {node: '>=0.10.0'} - - read-pkg@5.2.0: - resolution: {integrity: sha512-Ug69mNOpfvKDAc2Q8DRpMjjzdtrnv9HcSMX+4VsZxD1aZ6ZzrIE7rlzXBtWTyhULSMKg076AW6WR5iZpD0JiOg==} - engines: {node: '>=8'} - - read-yaml-file@1.1.0: - resolution: {integrity: sha512-VIMnQi/Z4HT2Fxuwg5KrY174U1VdUIASQVWXXyqtNRtxSr9IYkn1rsI6Tb6HsrHCmB7gVpNwX6JxPTHcH6IoTA==} - engines: {node: '>=6'} - - readable-stream@2.3.8: - resolution: {integrity: sha512-8p0AUk4XODgIewSi0l8Epjs+EVnWiK7NoDIEGU0HhE7+ZyY8D1IMY7odu5lRrFXGg71L15KG8QrPmum45RTtdA==} - - readable-stream@3.6.2: - resolution: {integrity: sha512-9u/sniCrY3D5WdsERHzHE4G2YCXqoG5FTHUiCC4SIbr6XcLZBY05ya9EKjYek9O5xOAwjGq+1JdGBAS7Q9ScoA==} - engines: {node: '>= 6'} - - readdirp@3.6.0: - resolution: {integrity: sha512-hOS089on8RduqdbhvQ5Z37A0ESjsqz6qnRcffsMU3495FuTdqSm+7bhJ29JvIOsBDEEnan5DPu9t3To9VRlMzA==} - engines: {node: '>=8.10.0'} - - rechoir@0.6.2: - resolution: {integrity: sha512-HFM8rkZ+i3zrV+4LQjwQ0W+ez98pApMGM3HUrN04j3CqzPOzl9nmP15Y8YXNm8QHGv/eacOVEjqhmWpkRV0NAw==} - engines: {node: '>= 0.10'} - - recursive-readdir@2.2.3: - resolution: {integrity: sha512-8HrF5ZsXk5FAH9dgsx3BlUer73nIhuj+9OrQwEbLTPOBzGkL1lsFCR01am+v+0m2Cmbs1nP12hLDl5FA7EszKA==} - engines: {node: '>=6.0.0'} - - redent@3.0.0: - resolution: {integrity: sha512-6tDA8g98We0zd0GvVeMT9arEOnTw9qM03L9cJXaCjrip1OO764RDBLBfrB4cwzNGDj5OA5ioymC9GkizgWJDUg==} - engines: {node: '>=8'} - - reduce-flatten@2.0.0: - resolution: {integrity: sha512-EJ4UNY/U1t2P/2k6oqotuX2Cc3T6nxJwsM0N0asT7dhrtH1ltUxDn4NalSYmPE2rCkVpcf/X6R0wDwcFpzhd4w==} - engines: {node: '>=6'} - - regenerator-runtime@0.14.1: - resolution: {integrity: sha512-dYnhHh0nJoMfnkZs6GmmhFknAGRrLznOu5nc9ML+EJxGvrx6H7teuevqVqCuPcPK//3eDrrjQhehXVx9cnkGdw==} - - regexp.prototype.flags@1.5.2: - resolution: {integrity: sha512-NcDiDkTLuPR+++OCKB0nWafEmhg/Da8aUPLPMQbK+bxKKCm1/S5he+AqYa4PlMCVBalb4/yxIRub6qkEx5yJbw==} - engines: {node: '>= 0.4'} - - release-zalgo@1.0.0: - resolution: {integrity: sha512-gUAyHVHPPC5wdqX/LG4LWtRYtgjxyX78oanFNTMMyFEfOqdC54s3eE82imuWKbOeqYht2CrNf64Qb8vgmmtZGA==} - engines: {node: '>=4'} - - req-cwd@2.0.0: - resolution: {integrity: sha512-ueoIoLo1OfB6b05COxAA9UpeoscNpYyM+BqYlA7H6LVF4hKGPXQQSSaD2YmvDVJMkk4UDpAHIeU1zG53IqjvlQ==} - engines: {node: '>=4'} - - req-from@2.0.0: - resolution: {integrity: sha512-LzTfEVDVQHBRfjOUMgNBA+V6DWsSnoeKzf42J7l0xa/B4jyPOuuF5MlNSmomLNGemWTnV2TIdjSSLnEn95fOQA==} - engines: {node: '>=4'} - - request@2.88.2: - resolution: {integrity: sha512-MsvtOrfG9ZcrOwAW+Qi+F6HbD0CWXEh9ou77uOb7FM2WPhwT7smM833PzanhJLsgXjN89Ir6V2PczXNnMpwKhw==} - engines: {node: '>= 6'} - deprecated: request has been deprecated, see https://github.com/request/request/issues/3142 - - require-directory@2.1.1: - resolution: {integrity: sha512-fGxEI7+wsG9xrvdjsrlmL22OMTTiHRwAMroiEeMgq8gzoLC/PQr7RsRDSTLUg/bZAZtF+TVIkHc6/4RIKrui+Q==} - engines: {node: '>=0.10.0'} - - require-from-string@1.2.1: - resolution: {integrity: sha512-H7AkJWMobeskkttHyhTVtS0fxpFLjxhbfMa6Bk3wimP7sdPRGL3EyCg3sAQenFfAe+xQ+oAc85Nmtvq0ROM83Q==} - engines: {node: '>=0.10.0'} - - require-from-string@2.0.2: - resolution: {integrity: sha512-Xf0nWe6RseziFMu+Ap9biiUbmplq6S9/p+7w7YXP/JBHhrUDDUhwa+vANyubuqfZWTveU//DYVGsDG7RKL/vEw==} - engines: {node: '>=0.10.0'} - - require-main-filename@1.0.1: - resolution: {integrity: sha512-IqSUtOVP4ksd1C/ej5zeEh/BIP2ajqpn8c5x+q99gvcIG/Qf0cud5raVnE/Dwd0ua9TXYDoDc0RE5hBSdz22Ug==} - - require-main-filename@2.0.0: - resolution: {integrity: sha512-NKN5kMDylKuldxYLSUfrbo5Tuzh4hd+2E8NPPX02mZtn1VuREQToYe/ZdlJy+J3uCpfaiGF05e7B8W0iXbQHmg==} - - requireindex@1.2.0: - resolution: {integrity: sha512-L9jEkOi3ASd9PYit2cwRfyppc9NoABujTP8/5gFcbERmo5jUoAKovIC3fsF17pkTnGsrByysqX+Kxd2OTNI1ww==} - engines: {node: '>=0.10.5'} - - resolve-alpn@1.2.1: - resolution: {integrity: sha512-0a1F4l73/ZFZOakJnQ3FvkJ2+gSTQWz/r2KE5OdDY0TxPm5h4GkqkWWfM47T7HsbnOtcJVEF4epCVy6u7Q3K+g==} - - resolve-from@3.0.0: - resolution: {integrity: sha512-GnlH6vxLymXJNMBo7XP1fJIzBFbdYt49CuTwmB/6N53t+kMPRMFKz783LlQ4tv28XoQfMWinAJX6WCGf2IlaIw==} - engines: {node: '>=4'} - - resolve-from@4.0.0: - resolution: {integrity: sha512-pb/MYmXstAkysRFx8piNI1tGFNQIFA3vkE3Gq4EuA1dF6gHp/+vgZqsCGJapvy8N3Q+4o7FwvquPJcnZ7RYy4g==} - engines: {node: '>=4'} - - resolve-from@5.0.0: - resolution: {integrity: sha512-qYg9KP24dD5qka9J47d0aVky0N+b4fTU89LN9iDnjB5waksiC49rvMB0PrUJQGoTmH50XPiqOvAjDfaijGxYZw==} - engines: {node: '>=8'} - - resolve-pkg-maps@1.0.0: - resolution: {integrity: sha512-seS2Tj26TBVOC2NIc2rOe2y2ZO7efxITtLZcGSOnHHNOQ7CkiUBfw0Iw2ck6xkIhPwLhKNLS8BO+hEpngQlqzw==} - - resolve@1.1.7: - resolution: {integrity: sha512-9znBF0vBcaSN3W2j7wKvdERPwqTxSpCq+if5C0WoTCyV9n24rua28jeuQ2pL/HOf+yUe/Mef+H/5p60K0Id3bg==} - - resolve@1.17.0: - resolution: {integrity: sha512-ic+7JYiV8Vi2yzQGFWOkiZD5Z9z7O2Zhm9XMaTxdJExKasieFCr+yXZ/WmXsckHiKl12ar0y6XiXDx3m4RHn1w==} - - resolve@1.22.8: - resolution: {integrity: sha512-oKWePCxqpd6FlLvGV1VU0x7bkPmmCNolxzjMf4NczoDnQcIWrAF+cPtZn5i6n+RfD2d9i0tzpKnG6Yk168yIyw==} - hasBin: true - - responselike@2.0.1: - resolution: {integrity: sha512-4gl03wn3hj1HP3yzgdI7d3lCkF95F21Pz4BPGvKHinyQzALR5CapwC8yIi0Rh58DEMQ/SguC03wFj2k0M/mHhw==} - - restore-cursor@3.1.0: - resolution: {integrity: sha512-l+sSefzHpj5qimhFSE5a8nufZYAM3sBSVMAPtYkmC+4EH2anSGaEMXSD0izRQbu9nfyQ9y5JrVmp7E8oZrUjvA==} - engines: {node: '>=8'} - - reusify@1.0.4: - resolution: {integrity: sha512-U9nH88a3fc/ekCF1l0/UP1IosiuIjyTh7hBvXVMHYgVcfGvt897Xguj2UOLDeI5BG2m7/uwyaLVT6fbtCwTyzw==} - engines: {iojs: '>=1.0.0', node: '>=0.10.0'} - - rimraf@2.7.1: - resolution: {integrity: sha512-uWjbaKIK3T1OSVptzX7Nl6PvQ3qAGtKEtVRjRuazjfL3Bx5eI409VZSqgND+4UNnmzLVdPj9FqFJNPqBZFve4w==} - hasBin: true - - rimraf@3.0.2: - resolution: {integrity: sha512-JZkJMZkAGFFPP2YqXZXPbMlMBgsxzE8ILs4lMIX/2o0L9UBw9O/Y3o6wFw/i9YLapcUJWwqbi3kdxIPdC62TIA==} - hasBin: true - - ripemd160-min@0.0.6: - resolution: {integrity: sha512-+GcJgQivhs6S9qvLogusiTcS9kQUfgR75whKuy5jIhuiOfQuJ8fjqxV6EGD5duH1Y/FawFUMtMhyeq3Fbnib8A==} - engines: {node: '>=8'} - - ripemd160@2.0.2: - resolution: {integrity: sha512-ii4iagi25WusVoiC4B4lq7pbXfAp3D9v5CwfkY33vffw2+pkDjY1D8GaN7spsxvCSx8dkPqOZCEZyfxcmJG2IA==} - - rlp@2.2.7: - resolution: {integrity: sha512-d5gdPmgQ0Z+AklL2NVXr/IoSjNZFfTVvQWzL/AM2AOcSzYP2xjlb0AC8YyCLc41MSNf6P6QVtjgPdmVtzb+4lQ==} - hasBin: true - - run-parallel@1.2.0: - resolution: {integrity: sha512-5l4VyZR86LZ/lDxZTR6jqL8AFE2S0IFLMP26AbjsLVADxHdhB/c0GUsH+y39UfCi3dzz8OlQuPmnaJOMoDHQBA==} - - rxjs@7.8.1: - resolution: {integrity: sha512-AA3TVj+0A2iuIoQkWEK/tqFjBq2j+6PO6Y0zJcvzLAFhEFIO3HL0vls9hWLncZbAAbK0mar7oZ4V079I/qPMxg==} - - safe-array-concat@1.1.2: - resolution: {integrity: sha512-vj6RsCsWBCf19jIeHEfkRMw8DPiBb+DMXklQ/1SGDHOMlHdPUkZXFQ2YdplS23zESTijAcurb1aSgJA3AgMu1Q==} - engines: {node: '>=0.4'} - - safe-buffer@5.1.2: - resolution: {integrity: sha512-Gd2UZBJDkXlY7GbJxfsE8/nvKkUEU1G38c1siN6QP6a9PT9MmHB8GnpscSmMJSoF8LOIrt8ud/wPtojys4G6+g==} - - safe-buffer@5.2.1: - resolution: {integrity: sha512-rp3So07KcdmmKbGvgaNxQSJr7bGVSVk5S9Eq1F+ppbRo70+YeaDxkw5Dd8NPN+GD6bjnYm2VuPuCXmpuYvmCXQ==} - - safe-regex-test@1.0.3: - resolution: {integrity: sha512-CdASjNJPvRa7roO6Ra/gLYBTzYzzPyyBXxIMdGW3USQLyjWEls2RgW5UBTXaQVp+OrpeCK3bLem8smtmheoRuw==} - engines: {node: '>= 0.4'} - - safer-buffer@2.1.2: - resolution: {integrity: sha512-YZo3K82SD7Riyi0E1EQPojLz7kpepnSQI9IyPbHHg1XXXevb5dJI7tpyN2ADxGcQbHG7vcyRHk0cbwqcQriUtg==} - - sc-istanbul@0.4.6: - resolution: {integrity: sha512-qJFF/8tW/zJsbyfh/iT/ZM5QNHE3CXxtLJbZsL+CzdJLBsPD7SedJZoUA4d8iAcN2IoMp/Dx80shOOd2x96X/g==} - hasBin: true - - scheduler@0.23.2: - resolution: {integrity: sha512-UOShsPwz7NrMUqhR6t0hWjFduvOzbtv7toDH1/hIrfRNIDBnnBWd0CwJTGvTpngVlmwGCdP9/Zl/tVrDqcuYzQ==} - - scrypt-js@2.0.4: - resolution: {integrity: sha512-4KsaGcPnuhtCZQCxFxN3GVYIhKFPTdLd8PLC552XwbMndtD0cjRFAhDuuydXQ0h08ZfPgzqe6EKHozpuH74iDw==} - - scrypt-js@3.0.1: - resolution: {integrity: sha512-cdwTTnqPu0Hyvf5in5asVdZocVDTNRmR7XEcJuIzMjJeSHybHl7vpB66AzwTaIg6CLSbtjcxc8fqcySfnTkccA==} - - secp256k1@4.0.3: - resolution: {integrity: sha512-NLZVf+ROMxwtEj3Xa562qgv2BK5e2WNmXPiOdVIPLgs6lyTzMvBq0aWTYMI5XCP9jZMVKOcqZLw/Wc4vDkuxhA==} - engines: {node: '>=10.0.0'} - - semver@5.7.2: - resolution: {integrity: sha512-cBznnQ9KjJqU67B52RMC65CMarK2600WFnbkcaiwWq3xy/5haFJlshgnpjovMVJ+Hff49d8GEn0b87C5pDQ10g==} - hasBin: true - - semver@6.3.1: - resolution: {integrity: sha512-BR7VvDCVHO+q2xBEWskxS6DJE1qRnb7DxzUrogb71CWoSficBxYsiAGd+Kl0mmq/MprG9yArRkyrQxTO6XjMzA==} - hasBin: true - - semver@7.6.2: - resolution: {integrity: sha512-FNAIBWCx9qcRhoHcgcJ0gvU7SN1lYU2ZXuSfl04bSC5OpvDHFyJCjdNHomPXxjQlCBU67YW64PzY7/VIEH7F2w==} - engines: {node: '>=10'} - hasBin: true - - send@0.18.0: - resolution: {integrity: sha512-qqWzuOjSFOuqPjFe4NOsMLafToQQwBSOEpS+FwEt3A2V3vKubTquT3vmLTQpFgMXp8AlFWFuP1qKaJZOtPpVXg==} - engines: {node: '>= 0.8.0'} - - sentence-case@2.1.1: - resolution: {integrity: sha512-ENl7cYHaK/Ktwk5OTD+aDbQ3uC8IByu/6Bkg+HDv8Mm+XnBnppVNalcfJTNsp1ibstKh030/JKQQWglDvtKwEQ==} - - serialize-javascript@6.0.0: - resolution: {integrity: sha512-Qr3TosvguFt8ePWqsvRfrKyQXIiW+nGbYpy8XK24NQHE83caxWt+mIymTT19DGFbNWNLfEwsrkSmN64lVWB9ag==} - - serve-static@1.15.0: - resolution: {integrity: sha512-XGuRDNjXUijsUL0vl6nSD7cwURuzEgglbOaFuZM9g3kwDXOWVTck0jLzjPzGD+TazWbboZYu52/9/XPdUgne9g==} - engines: {node: '>= 0.8.0'} - - servify@0.1.12: - resolution: {integrity: sha512-/xE6GvsKKqyo1BAY+KxOWXcLpPsUUyji7Qg3bVD7hh1eRze5bR1uYiuDA/k3Gof1s9BTzQZEJK8sNcNGFIzeWw==} - engines: {node: '>=6'} - - set-blocking@2.0.0: - resolution: {integrity: sha512-KiKBS8AnWGEyLzofFfmvKwpdPzqiy16LvQfK3yv/fVH7Bj13/wl3JSR1J+rfgRE9q7xUJK4qvgS8raSOeLUehw==} - - set-function-length@1.2.2: - resolution: {integrity: sha512-pgRc4hJ4/sNjWCSS9AmnS40x3bNMDTknHgL5UaMBTMyJnU90EgWh1Rz+MC9eFu4BuN/UwZjKQuY/1v3rM7HMfg==} - engines: {node: '>= 0.4'} - - set-function-name@2.0.2: - resolution: {integrity: sha512-7PGFlmtwsEADb0WYyvCMa1t+yke6daIG4Wirafur5kcf+MhUnPms1UeR0CKQdTZD81yESwMHbtn+TR+dMviakQ==} - engines: {node: '>= 0.4'} - - setimmediate@1.0.4: - resolution: {integrity: sha512-/TjEmXQVEzdod/FFskf3o7oOAsGhHf2j1dZqRFbDzq4F3mvvxflIIi4Hd3bLQE9y/CpwqfSQam5JakI/mi3Pog==} - - setimmediate@1.0.5: - resolution: {integrity: sha512-MATJdZp8sLqDl/68LfQmbP8zKPLQNV6BIZoIgrscFDQ+RsvK/BxeDQOgyxKKoh0y/8h3BqVFnCqQ/gd+reiIXA==} - - setprototypeof@1.2.0: - resolution: {integrity: sha512-E5LDX7Wrp85Kil5bhZv46j8jOeboKq5JMmYM3gVGdGH8xFpPWXUMsNrlODCrkoxMEeNi/XZIwuRvY4XNwYMJpw==} - - sha.js@2.4.11: - resolution: {integrity: sha512-QMEp5B7cftE7APOjk5Y6xgrbWu+WkLVQwk8JNjZ8nKRciZaByEW6MubieAiToS7+dwvrjGhH8jRXz3MVd0AYqQ==} - hasBin: true - - sha1@1.1.1: - resolution: {integrity: sha512-dZBS6OrMjtgVkopB1Gmo4RQCDKiZsqcpAQpkV/aaj+FCrCg8r4I4qMkDPQjBgLIxlmu9k4nUbWq6ohXahOneYA==} - - sha3@2.1.4: - resolution: {integrity: sha512-S8cNxbyb0UGUM2VhRD4Poe5N58gJnJsLJ5vC7FYWGUmGhcsj4++WaIOBFVDxlG0W3To6xBuiRh+i0Qp2oNCOtg==} - - shebang-command@1.2.0: - resolution: {integrity: sha512-EV3L1+UQWGor21OmnvojK36mhg+TyIKDh3iFBKBohr5xeXIhNBcx8oWdgkTEEQ+BEFFYdLRuqMfd5L84N1V5Vg==} - engines: {node: '>=0.10.0'} - - shebang-command@2.0.0: - resolution: {integrity: sha512-kHxr2zZpYtdmrN1qDjrrX/Z1rR1kG8Dx+gkpK1G4eXmvXswmcE1hTWBWYUzlraYw1/yZp6YuDY77YtvbN0dmDA==} - engines: {node: '>=8'} - - shebang-regex@1.0.0: - resolution: {integrity: sha512-wpoSFAxys6b2a2wHZ1XpDSgD7N9iVjg29Ph9uV/uaP9Ex/KXlkTZTeddxDPSYQpgvzKLGJke2UU0AzoGCjNIvQ==} - engines: {node: '>=0.10.0'} - - shebang-regex@3.0.0: - resolution: {integrity: sha512-7++dFhtcx3353uBaq8DDR4NuxBetBzC7ZQOhmTQInHEd6bSrXdiEyzCvG07Z44UYdLShWUyXt5M/yhz8ekcb1A==} - engines: {node: '>=8'} - - shelljs@0.8.5: - resolution: {integrity: sha512-TiwcRcrkhHvbrZbnRcFYMLl30Dfov3HKqzp5tO5b4pt6G/SezKcYhmDg15zXVBswHmctSAQKznqNW2LO5tTDow==} - engines: {node: '>=4'} - hasBin: true - - side-channel@1.0.6: - resolution: {integrity: sha512-fDW/EZ6Q9RiO8eFG8Hj+7u/oW+XrPTIChwCOM2+th2A6OblDtYYIpve9m+KvI9Z4C9qSEXlaGR6bTEYHReuglA==} - engines: {node: '>= 0.4'} - - signal-exit@3.0.7: - resolution: {integrity: sha512-wnD2ZE+l+SPC/uoS0vXeE9L1+0wuaMqKlfz9AMUo38JsyLSBWSFcHR1Rri62LZc12vLr1gb3jl7iwQhgwpAbGQ==} - - simple-concat@1.0.1: - resolution: {integrity: sha512-cSFtAPtRhljv69IK0hTVZQ+OfE9nePi/rtJmw5UjHeVyVroEqJXP1sFztKUy1qU+xvz3u/sfYJLa947b7nAN2Q==} - - simple-get@2.8.2: - resolution: {integrity: sha512-Ijd/rV5o+mSBBs4F/x9oDPtTx9Zb6X9brmnXvMW4J7IR15ngi9q5xxqWBKU744jTZiaXtxaPL7uHG6vtN8kUkw==} - - simple-get@4.0.1: - resolution: {integrity: sha512-brv7p5WgH0jmQJr1ZDDfKDOSeWWg+OVypG99A/5vYGPqJ6pxiaHLy8nxtFjBA7oMa01ebA9gfh1uMCFqOuXxvA==} - - sinon-chai@3.7.0: - resolution: {integrity: sha512-mf5NURdUaSdnatJx3uhoBOrY9dtL19fiOtAdT1Azxg3+lNJFiuN0uzaU3xX1LeAfL17kHQhTAJgpsfhbMJMY2g==} - peerDependencies: - chai: ^4.0.0 - sinon: '>=4.0.0' - - sinon@9.2.4: - resolution: {integrity: sha512-zljcULZQsJxVra28qIAL6ow1Z9tpattkCTEJR4RBP3TGc00FcttsP5pK284Nas5WjMZU5Yzy3kAIp3B3KRf5Yg==} - deprecated: 16.1.1 - - sisteransi@1.0.5: - resolution: {integrity: sha512-bLGGlR1QxBcynn2d5YmDX4MGjlZvy2MRBDRNHLJ8VI6l6+9FUiyTFNJ0IveOSP0bcXgVDPRcfGqA0pjaqUpfVg==} - - slash@3.0.0: - resolution: {integrity: sha512-g9Q1haeby36OSStwb4ntCGGGaKsaVSjQ68fBxoQcutl5fS1vuY18H3wSt3jFyFtrkx+Kz0V1G85A4MyAdDMi2Q==} - engines: {node: '>=8'} - - slice-ansi@4.0.0: - resolution: {integrity: sha512-qMCMfhY040cVHT43K9BFygqYbUPFZKHOg7K73mtTWJRb8pyP3fzf4Ixd5SzdEJQ6MRUg/WBnOLxghZtKKurENQ==} - engines: {node: '>=10'} - - smartwrap@2.0.2: - resolution: {integrity: sha512-vCsKNQxb7PnCNd2wY1WClWifAc2lwqsG8OaswpJkVJsvMGcnEntdTCDajZCkk93Ay1U3t/9puJmb525Rg5MZBA==} - engines: {node: '>=6'} - hasBin: true - - snake-case@2.1.0: - resolution: {integrity: sha512-FMR5YoPFwOLuh4rRz92dywJjyKYZNLpMn1R5ujVpIYkbA9p01fq8RMg0FkO4M+Yobt4MjHeLTJVm5xFFBHSV2Q==} - - solc@0.4.26: - resolution: {integrity: sha512-o+c6FpkiHd+HPjmjEVpQgH7fqZ14tJpXhho+/bQXlXbliLIS/xjXb42Vxh+qQY1WCSTMQ0+a5vR9vi0MfhU6mA==} - hasBin: true - - solc@0.7.3: - resolution: {integrity: sha512-GAsWNAjGzIDg7VxzP6mPjdurby3IkGCjQcM8GFYZT6RyaoUZKmMU6Y7YwG+tFGhv7dwZ8rmR4iwFDrrD99JwqA==} - engines: {node: '>=8.0.0'} - hasBin: true - - solhint@3.6.2: - resolution: {integrity: sha512-85EeLbmkcPwD+3JR7aEMKsVC9YrRSxd4qkXuMzrlf7+z2Eqdfm1wHWq1ffTuo5aDhoZxp2I9yF3QkxZOxOL7aQ==} - hasBin: true - - solidity-coverage@0.8.12: - resolution: {integrity: sha512-8cOB1PtjnjFRqOgwFiD8DaUsYJtVJ6+YdXQtSZDrLGf8cdhhh8xzTtGzVTGeBf15kTv0v7lYPJlV/az7zLEPJw==} - hasBin: true - peerDependencies: - hardhat: ^2.11.0 - - solpp@0.11.5: - resolution: {integrity: sha512-LjzCGMrTDXtera2C4mbQGZSpBznP+o3/82L2CneAAMNbm+t4xPsvfrgJkIaY+IZ5YLrB8IXn7cYthwHMKvAWnQ==} - engines: {node: '>=8.15.1'} - hasBin: true - - source-map-support@0.5.21: - resolution: {integrity: sha512-uBHU3L3czsIyYXKX88fdrGovxdSCoTGDRZ6SYXtSRxLZUzHg5P/66Ht6uoUlHu9EZod+inXhKo3qQgwXUT/y1w==} - - source-map@0.2.0: - resolution: {integrity: sha512-CBdZ2oa/BHhS4xj5DlhjWNHcan57/5YuvfdLf17iVmIpd9KRm+DFLmC6nBNj+6Ua7Kt3TmOjDpQT1aTYOQtoUA==} - engines: {node: '>=0.8.0'} - - source-map@0.6.1: - resolution: {integrity: sha512-UjgapumWlbMhkBgzT7Ykc5YXUT46F0iKu8SGXq0bcwP5dz/h0Plj6enJqjz1Zbq2l5WaqYnrVbwWOWMyF3F47g==} - engines: {node: '>=0.10.0'} - - spawn-wrap@2.0.0: - resolution: {integrity: sha512-EeajNjfN9zMnULLwhZZQU3GWBoFNkbngTUPfaawT4RkMiviTxcX0qfhVbGey39mfctfDHkWtuecgQ8NJcyQWHg==} - engines: {node: '>=8'} - - spawndamnit@2.0.0: - resolution: {integrity: sha512-j4JKEcncSjFlqIwU5L/rp2N5SIPsdxaRsIv678+TZxZ0SRDJTm8JrxJMjE/XuiEZNEir3S8l0Fa3Ke339WI4qA==} - - spdx-correct@3.2.0: - resolution: {integrity: sha512-kN9dJbvnySHULIluDHy32WHRUu3Og7B9sbY7tsFLctQkIqnMh3hErYgdMjTYuqmcXX+lK5T1lnUt3G7zNswmZA==} - - spdx-exceptions@2.5.0: - resolution: {integrity: sha512-PiU42r+xO4UbUS1buo3LPJkjlO7430Xn5SVAhdpzzsPHsjbYVflnnFdATgabnLude+Cqu25p6N+g2lw/PFsa4w==} - - spdx-expression-parse@3.0.1: - resolution: {integrity: sha512-cbqHunsQWnJNE6KhVSMsMeH5H/L9EpymbzqTQ3uLwNCLZ1Q481oWaofqH7nO6V07xlXwY6PhQdQ2IedWx/ZK4Q==} - - spdx-license-ids@3.0.17: - resolution: {integrity: sha512-sh8PWc/ftMqAAdFiBu6Fy6JUOYjqDJBJvIhpfDMyHrr0Rbp5liZqd4TjtQ/RgfLjKFZb+LMx5hpml5qOWy0qvg==} - - split2@3.2.2: - resolution: {integrity: sha512-9NThjpgZnifTkJpzTZ7Eue85S49QwpNhZTq6GRJwObb6jnLFNGB7Qm73V5HewTROPyxD0C29xqmaI68bQtV+hg==} - - sprintf-js@1.0.3: - resolution: {integrity: sha512-D9cPgkvLlV3t3IzL0D0YLvGA9Ahk4PcvVwUbN0dSGr1aP0Nrt4AEnTUbuGvquEC0mA64Gqt1fzirlRs5ibXx8g==} - - sshpk@1.18.0: - resolution: {integrity: sha512-2p2KJZTSqQ/I3+HX42EpYOa2l3f8Erv8MWKsy2I9uf4wA7yFIkXRffYdsx86y6z4vHtV8u7g+pPlr8/4ouAxsQ==} - engines: {node: '>=0.10.0'} - hasBin: true - - stacktrace-parser@0.1.10: - resolution: {integrity: sha512-KJP1OCML99+8fhOHxwwzyWrlUuVX5GQ0ZpJTd1DFXhdkrvg1szxfHhawXUZ3g9TkXORQd4/WG68jMlQZ2p8wlg==} - engines: {node: '>=6'} - - statuses@2.0.1: - resolution: {integrity: sha512-RwNA9Z/7PrK06rYLIzFMlaF+l73iwpzsqRIFgbMLbTcLD6cOao82TaWefPXQvB2fOC4AjuYSEndS7N/mTCbkdQ==} - engines: {node: '>= 0.8'} - - stream-transform@2.1.3: - resolution: {integrity: sha512-9GHUiM5hMiCi6Y03jD2ARC1ettBXkQBoQAe7nJsPknnI0ow10aXjTnew8QtYQmLjzn974BnmWEAJgCY6ZP1DeQ==} - - strict-uri-encode@1.1.0: - resolution: {integrity: sha512-R3f198pcvnB+5IpnBlRkphuE9n46WyVl8I39W/ZUTZLz4nqSP/oLYUrcnJrw462Ds8he4YKMov2efsTIw1BDGQ==} - engines: {node: '>=0.10.0'} - - string-format@2.0.0: - resolution: {integrity: sha512-bbEs3scLeYNXLecRRuk6uJxdXUSj6le/8rNPHChIJTn2V79aXVTR1EH2OH5zLKKoz0V02fOUKZZcw01pLUShZA==} - - string-width@1.0.2: - resolution: {integrity: sha512-0XsVpQLnVCXHJfyEs8tC0zpTVIr5PKKsQtkT29IwupnPTjtPmQ3xT/4yCREF9hYkV/3M3kzcUTSAZT6a6h81tw==} - engines: {node: '>=0.10.0'} - - string-width@2.1.1: - resolution: {integrity: sha512-nOqH59deCq9SRHlxq1Aw85Jnt4w6KvLKqWVik6oA9ZklXLNIOlqg4F2yrT1MVaTjAqvVwdfeZ7w7aCvJD7ugkw==} - engines: {node: '>=4'} - - string-width@4.2.3: - resolution: {integrity: sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g==} - engines: {node: '>=8'} - - string.prototype.trim@1.2.9: - resolution: {integrity: sha512-klHuCNxiMZ8MlsOihJhJEBJAiMVqU3Z2nEXWfWnIqjN0gEFS9J9+IxKozWWtQGcgoa1WUZzLjKPTr4ZHNFTFxw==} - engines: {node: '>= 0.4'} - - string.prototype.trimend@1.0.8: - resolution: {integrity: sha512-p73uL5VCHCO2BZZ6krwwQE3kCzM7NKmis8S//xEC6fQonchbum4eP6kR4DLEjQFO3Wnj3Fuo8NM0kOSjVdHjZQ==} - - string.prototype.trimstart@1.0.8: - resolution: {integrity: sha512-UXSH262CSZY1tfu3G3Secr6uGLCFVPMhIqHjlgCUtCCcgihYc/xKs9djMTMUOb2j1mVSeU8EU6NWc/iQKU6Gfg==} - engines: {node: '>= 0.4'} - - string_decoder@1.1.1: - resolution: {integrity: sha512-n/ShnvDi6FHbbVfviro+WojiFzv+s8MPMHBczVePfUpDJLwoLT0ht1l4YwBCbi8pJAveEEdnkHyPyTP/mzRfwg==} - - string_decoder@1.3.0: - resolution: {integrity: sha512-hkRX8U1WjJFd8LsDJ2yQ/wWWxaopEsABU1XfkM8A+j0+85JAGppt16cr1Whg6KIbb4okU6Mql6BOj+uup/wKeA==} - - strip-ansi@0.1.1: - resolution: {integrity: sha512-behete+3uqxecWlDAm5lmskaSaISA+ThQ4oNNBDTBJt0x2ppR6IPqfZNuj6BLaLJ/Sji4TPZlcRyOis8wXQTLg==} - engines: {node: '>=0.8.0'} - hasBin: true - - strip-ansi@3.0.1: - resolution: {integrity: sha512-VhumSSbBqDTP8p2ZLKj40UjBCV4+v8bUSEpUb4KjRgWk9pbqGF4REFj6KEagidb2f/M6AzC0EmFyDNGaw9OCzg==} - engines: {node: '>=0.10.0'} - - strip-ansi@4.0.0: - resolution: {integrity: sha512-4XaJ2zQdCzROZDivEVIDPkcQn8LMFSa8kj8Gxb/Lnwzv9A8VctNZ+lfivC/sV3ivW8ElJTERXZoPBRrZKkNKow==} - engines: {node: '>=4'} - - strip-ansi@6.0.1: - resolution: {integrity: sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A==} - engines: {node: '>=8'} - - strip-bom@2.0.0: - resolution: {integrity: sha512-kwrX1y7czp1E69n2ajbG65mIo9dqvJ+8aBQXOGVxqwvNbsXdFM6Lq37dLAY3mknUwru8CfcCbfOLL/gMo+fi3g==} - engines: {node: '>=0.10.0'} - - strip-bom@3.0.0: - resolution: {integrity: sha512-vavAMRXOgBVNF6nyEEmL3DBK19iRpDcoIwW+swQ+CbGiu7lju6t+JklA1MHweoWtadgt4ISVUsXLyDq34ddcwA==} - engines: {node: '>=4'} - - strip-bom@4.0.0: - resolution: {integrity: sha512-3xurFv5tEgii33Zi8Jtp55wEIILR9eh34FAW00PZf+JnSsTmV/ioewSgQl97JHvgjoRGwPShsWm+IdrxB35d0w==} - engines: {node: '>=8'} - - strip-hex-prefix@1.0.0: - resolution: {integrity: sha512-q8d4ue7JGEiVcypji1bALTos+0pWtyGlivAWyPuTkHzuTCJqrK9sWxYQZUq6Nq3cuyv3bm734IhHvHtGGURU6A==} - engines: {node: '>=6.5.0', npm: '>=3'} - - strip-indent@2.0.0: - resolution: {integrity: sha512-RsSNPLpq6YUL7QYy44RnPVTn/lcVZtb48Uof3X5JLbF4zD/Gs7ZFDv2HWol+leoQN2mT86LAzSshGfkTlSOpsA==} - engines: {node: '>=4'} - - strip-indent@3.0.0: - resolution: {integrity: sha512-laJTa3Jb+VQpaC6DseHhF7dXVqHTfJPCRDaEbid/drOhgitgYku/letMUqOXFoWV0zIIUbjpdH2t+tYj4bQMRQ==} - engines: {node: '>=8'} - - strip-json-comments@2.0.1: - resolution: {integrity: sha512-4gB8na07fecVVkOI6Rs4e7T6NOTki5EmL7TUduTs6bu3EdnSycntVJ4re8kgZA+wx9IueI2Y11bfbgwtzuE0KQ==} - engines: {node: '>=0.10.0'} - - strip-json-comments@3.1.1: - resolution: {integrity: sha512-6fPc+R4ihwqP6N/aIv2f1gMH8lOVtWQHoqC4yK6oSDVVocumAsfCqjkXnqiYMhmMwS/mEHLp7Vehlt3ql6lEig==} - engines: {node: '>=8'} - - supports-color@3.2.3: - resolution: {integrity: sha512-Jds2VIYDrlp5ui7t8abHN2bjAu4LV/q4N2KivFPpGH0lrka0BMq/33AmECUXlKPcHigkNaqfXRENFju+rlcy+A==} - engines: {node: '>=0.8.0'} - - supports-color@5.5.0: - resolution: {integrity: sha512-QjVjwdXIt408MIiAqCX4oUKsgU2EqAGzs2Ppkm4aQYbjm+ZEWEcW4SfFNTr4uMNZma0ey4f5lgLrkB0aX0QMow==} - engines: {node: '>=4'} - - supports-color@7.2.0: - resolution: {integrity: sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw==} - engines: {node: '>=8'} - - supports-color@8.1.1: - resolution: {integrity: sha512-MpUEN2OodtUzxvKQl72cUF7RQ5EiHsGvSsVG0ia9c5RbWGL2CI4C7EpPS8UTBIplnlzZiNuV56w+FuNxy3ty2Q==} - engines: {node: '>=10'} - - supports-preserve-symlinks-flag@1.0.0: - resolution: {integrity: sha512-ot0WnXS9fgdkgIcePe6RHNk1WA8+muPa6cSjeR3V8K27q9BB1rTE3R1p7Hv0z1ZyAc8s6Vvv8DIyWf681MAt0w==} - engines: {node: '>= 0.4'} - - swap-case@1.1.2: - resolution: {integrity: sha512-BAmWG6/bx8syfc6qXPprof3Mn5vQgf5dwdUNJhsNqU9WdPt5P+ES/wQ5bxfijy8zwZgZZHslC3iAsxsuQMCzJQ==} - - swarm-js@0.1.42: - resolution: {integrity: sha512-BV7c/dVlA3R6ya1lMlSSNPLYrntt0LUq4YMgy3iwpCIc6rZnS5W2wUoctarZ5pXlpKtxDDf9hNziEkcfrxdhqQ==} - - sync-request@6.1.0: - resolution: {integrity: sha512-8fjNkrNlNCrVc/av+Jn+xxqfCjYaBoHqCsDz6mt030UMxJGr+GSfCV1dQt2gRtlL63+VPidwDVLr7V2OcTSdRw==} - engines: {node: '>=8.0.0'} - - sync-rpc@1.3.6: - resolution: {integrity: sha512-J8jTXuZzRlvU7HemDgHi3pGnh/rkoqR/OZSjhTyyZrEkkYQbk7Z33AXp37mkPfPpfdOuj7Ex3H/TJM1z48uPQw==} - - table-layout@1.0.2: - resolution: {integrity: sha512-qd/R7n5rQTRFi+Zf2sk5XVVd9UQl6ZkduPFC3S7WEGJAmetDTjY3qPN50eSKzwuzEyQKy5TN2TiZdkIjos2L6A==} - engines: {node: '>=8.0.0'} - - table@6.8.2: - resolution: {integrity: sha512-w2sfv80nrAh2VCbqR5AK27wswXhqcck2AhfnNW76beQXskGZ1V12GwS//yYVa3d3fcvAip2OUnbDAjW2k3v9fA==} - engines: {node: '>=10.0.0'} - - tar-fs@2.1.1: - resolution: {integrity: sha512-V0r2Y9scmbDRLCNex/+hYzvp/zyYjvFbHPNgVTKfQvVrb6guiE/fxP+XblDNR011utopbkex2nM4dHNV6GDsng==} - - tar-stream@2.2.0: - resolution: {integrity: sha512-ujeqbceABgwMZxEJnk2HDY2DlnUZ+9oEcb1KzTVfYHio0UE6dG71n60d8D2I4qNvleWrrXpmjpt7vZeF1LnMZQ==} - engines: {node: '>=6'} - - tar@4.4.19: - resolution: {integrity: sha512-a20gEsvHnWe0ygBY8JbxoM4w3SJdhc7ZAuxkLqh+nvNQN2IOt0B5lLgM490X5Hl8FF0dl0tOf2ewFYAlIFgzVA==} - engines: {node: '>=4.5'} - - term-size@2.2.1: - resolution: {integrity: sha512-wK0Ri4fOGjv/XPy8SBHZChl8CM7uMc5VML7SqiQ0zG7+J5Vr+RMQDoHa2CNT6KHUnTGIXH34UDMkPzAUyapBZg==} - engines: {node: '>=8'} - - test-exclude@6.0.0: - resolution: {integrity: sha512-cAGWPIyOHU6zlmg88jwm7VRyXnMN7iV68OGAbYDk/Mh/xC/pzVPlQtY6ngoIH/5/tciuhGfvESU8GrHrcxD56w==} - engines: {node: '>=8'} - - testrpc@0.0.1: - resolution: {integrity: sha512-afH1hO+SQ/VPlmaLUFj2636QMeDvPCeQMc/9RBMW0IfjNe9gFD9Ra3ShqYkB7py0do1ZcCna/9acHyzTJ+GcNA==} - deprecated: testrpc has been renamed to ganache-cli, please use this package from now on. - - text-table@0.2.0: - resolution: {integrity: sha512-N+8UisAXDGk8PFXP4HAzVR9nbfmVJ3zYLAWiTIoqC5v5isinhr+r5uaO8+7r3BMfuNIufIsA7RdpVgacC2cSpw==} - - then-request@6.0.2: - resolution: {integrity: sha512-3ZBiG7JvP3wbDzA9iNY5zJQcHL4jn/0BWtXIkagfz7QgOL/LqjCEOBQuJNZfu0XYnv5JhKh+cDxCPM4ILrqruA==} - engines: {node: '>=6.0.0'} - - thenify-all@1.6.0: - resolution: {integrity: sha512-RNxQH/qI8/t3thXJDwcstUO4zeqo64+Uy/+sNVRBx4Xn2OX+OZ9oP+iJnNFqplFra2ZUVeKCSa2oVWi3T4uVmA==} - engines: {node: '>=0.8'} - - thenify@3.3.1: - resolution: {integrity: sha512-RVZSIV5IG10Hk3enotrhvz0T9em6cyHBLkH/YAZuKqd8hRkKhSfCGIcP2KUY0EPxndzANBmNllzWPwak+bheSw==} - - through2@4.0.2: - resolution: {integrity: sha512-iOqSav00cVxEEICeD7TjLB1sueEL+81Wpzp2bY17uZjZN0pWZPuo4suZ/61VujxmqSGFfgOcNuTZ85QJwNZQpw==} - - time-require@0.1.2: - resolution: {integrity: sha512-IqcSpa1sVNleRbC9eHnN7p7vwEHNmsjsXUDqjlnvo4+2VLJ7/gIY2XACTBuRhMB4weYbDYKsR3av2ySykRhDIA==} - engines: {node: '>= 0.10.0'} - - timed-out@4.0.1: - resolution: {integrity: sha512-G7r3AhovYtr5YKOWQkta8RKAPb+J9IsO4uVmzjl8AZwfhs8UcUwTiD6gcJYSgOtzyjvQKrKYn41syHbUWMkafA==} - engines: {node: '>=0.10.0'} - - title-case@2.1.1: - resolution: {integrity: sha512-EkJoZ2O3zdCz3zJsYCsxyq2OC5hrxR9mfdd5I+w8h/tmFfeOxJ+vvkxsKxdmN0WtS9zLdHEgfgVOiMVgv+Po4Q==} - - tmp@0.0.33: - resolution: {integrity: sha512-jRCJlojKnZ3addtTOjdIqoRuPEKBvNXcGYqzO6zWZX8KfKEpnGY5jfggJQ3EjKuu8D4bJRr0y+cYJFmYbImXGw==} - engines: {node: '>=0.6.0'} - - to-fast-properties@2.0.0: - resolution: {integrity: sha512-/OaKK0xYrs3DmxRYqL/yDc+FxFUVYhDlXMhRmv3z915w2HF1tnN1omB354j8VUGO/hbRzyD6Y3sA7v7GS/ceog==} - engines: {node: '>=4'} - - to-regex-range@5.0.1: - resolution: {integrity: sha512-65P7iz6X5yEr1cwcgvQxbbIw7Uk3gOy5dIdtZ4rDveLqhrdJP+Li/Hx6tyK0NEb+2GCyneCMJiGqrADCSNk8sQ==} - engines: {node: '>=8.0'} - - toidentifier@1.0.1: - resolution: {integrity: sha512-o5sSPKEkg/DIQNmH43V0/uerLrpzVedkUh8tGNvaeXpfpuwjKenlSox/2O/BTlZUtEe+JG7s5YhEz608PlAHRA==} - engines: {node: '>=0.6'} - - tough-cookie@2.5.0: - resolution: {integrity: sha512-nlLsUzgm1kfLXSXfRZMc1KLAugd4hqJHDTvc2hDIwS3mZAfMEuMbc03SujMF+GEcpaX/qboeycw6iO8JwVv2+g==} - engines: {node: '>=0.8'} - - tr46@0.0.3: - resolution: {integrity: sha512-N3WMsuqV66lT30CrXNbEjx4GEwlow3v6rr4mCcv6prnfwhS01rkgyFdjPNBYd9br7LpXV1+Emh01fHnq2Gdgrw==} - - trim-newlines@3.0.1: - resolution: {integrity: sha512-c1PTsA3tYrIsLGkJkzHF+w9F2EyxfXGo4UyJc4pFL++FMjnq0HJS69T3M7d//gKrFKwy429bouPescbjecU+Zw==} - engines: {node: '>=8'} - - truffle-blockchain-utils@0.0.5: - resolution: {integrity: sha512-eCCV8FbYOuKagRY5NiqJCZrrh9GjWX2573ahqZPvUrzxYGIvCpSsHpGCub2e00YefpMfBqwscbsDTK7WNVfwoA==} - deprecated: 'WARNING: This package has been renamed to @truffle/blockchain-utils.' - - truffle-contract-schema@2.0.3: - resolution: {integrity: sha512-eI5cFifbB3zpcO4RsXSnjN9JMSlJ4M50GQPdrfbrIXRTXHsyQ433SkgFjIATUwfq++TXWkCRfKMjN8eA7YQ3+Q==} - deprecated: 'WARNING: This package has been renamed to @truffle/contract-schema.' - - truffle-contract@3.0.8: - resolution: {integrity: sha512-uhXb/G4dORU4RjFlwZZbFT0n5BS8akify+MaRsnWWs4SA/bo6x4/bQs1xtdO3b5Cl9nXiOX88wdQzRj3xtPVUg==} - deprecated: 'WARNING: This package has been renamed to @truffle/contract.' - - truffle-error@0.0.3: - resolution: {integrity: sha512-9gxs1z6BUn7MqrE4NPm/jcYe8rLok3Z57aweGIh1+CoRJSttzYqwcXCqaPRSNrTFnsTeZMBukkYr/PUcADoihw==} - deprecated: 'WARNING: This package has been renamed to @truffle/error.' - - ts-command-line-args@2.5.1: - resolution: {integrity: sha512-H69ZwTw3rFHb5WYpQya40YAX2/w7Ut75uUECbgBIsLmM+BNuYnxsltfyyLMxy6sEeKxgijLTnQtLd0nKd6+IYw==} - hasBin: true - - ts-essentials@7.0.3: - resolution: {integrity: sha512-8+gr5+lqO3G84KdiTSMRLtuyJ+nTBVRKuCrK4lidMPdVeEp0uqC875uE5NMcaA7YYMN7XsNiFQuMvasF8HT/xQ==} - peerDependencies: - typescript: '>=3.7.0' - - ts-node@10.9.2: - resolution: {integrity: sha512-f0FFpIdcHgn8zcPSbf1dRevwt047YMnaiJM3u2w2RewrB+fob/zePZcrOyQoLMMO7aBIddLcQIEK5dYjkLnGrQ==} - hasBin: true - peerDependencies: - '@swc/core': '>=1.2.50' - '@swc/wasm': '>=1.2.50' - '@types/node': '*' - typescript: '>=2.7' - peerDependenciesMeta: - '@swc/core': - optional: true - '@swc/wasm': - optional: true - - tsconfig-paths@3.15.0: - resolution: {integrity: sha512-2Ac2RgzDe/cn48GvOe3M+o82pEFewD3UPbyoUHHdKasHwJKjds4fLXWf/Ux5kATBKN20oaFGu+jbElp1pos0mg==} - - tslib@1.14.1: - resolution: {integrity: sha512-Xni35NKzjgMrwevysHTCArtLDpPvye8zV/0E4EyYn43P7/7qvQwPh9BGkHewbMulVntbigmcT7rdX3BNo9wRJg==} - - tslib@2.4.0: - resolution: {integrity: sha512-d6xOpEDfsi2CZVlPQzGeux8XMwLT9hssAsaPYExaQMuYskwb+x1x7J371tWlbBdWHroy99KnVB6qIkUbs5X3UQ==} - - tslib@2.6.2: - resolution: {integrity: sha512-AEYxH93jGFPn/a2iVAwW87VuUIkR1FVUKB77NwMF7nBTDkDrrT/Hpt/IrCJ0QXhW27jTBDcf5ZY7w6RiqTMw2Q==} - - tsort@0.0.1: - resolution: {integrity: sha512-Tyrf5mxF8Ofs1tNoxA13lFeZ2Zrbd6cKbuH3V+MQ5sb6DtBj5FjrXVsRWT8YvNAQTqNoz66dz1WsbigI22aEnw==} - - tsutils@3.21.0: - resolution: {integrity: sha512-mHKK3iUXL+3UF6xL5k0PEhKRUBKPBCv/+RkEOpjRWxxx27KKRBmmA60A9pgOUvMi8GKhRMPEmjBRPzs2W7O1OA==} - engines: {node: '>= 6'} - peerDependencies: - typescript: '>=2.8.0 || >= 3.2.0-dev || >= 3.3.0-dev || >= 3.4.0-dev || >= 3.5.0-dev || >= 3.6.0-dev || >= 3.6.0-beta || >= 3.7.0-dev || >= 3.7.0-beta' - - tty-table@4.2.3: - resolution: {integrity: sha512-Fs15mu0vGzCrj8fmJNP7Ynxt5J7praPXqFN0leZeZBXJwkMxv9cb2D454k1ltrtUSJbZ4yH4e0CynsHLxmUfFA==} - engines: {node: '>=8.0.0'} - hasBin: true - - tunnel-agent@0.6.0: - resolution: {integrity: sha512-McnNiV1l8RYeY8tBgEpuodCC1mLUdbSN+CYBL7kJsJNInOP8UjDDEwdk6Mw60vdLLrr5NHKZhMAOSrR2NZuQ+w==} - - tweetnacl-util@0.15.1: - resolution: {integrity: sha512-RKJBIj8lySrShN4w6i/BonWp2Z/uxwC3h4y7xsRrpP59ZboCd0GpEVsOnMDYLMmKBpYhb5TgHzZXy7wTfYFBRw==} - - tweetnacl@0.14.5: - resolution: {integrity: sha512-KXXFFdAbFXY4geFIwoyNK+f5Z1b7swfXABfL7HXCmoIWMKU3dmS26672A4EeQtDzLKy7SXmfBu51JolvEKwtGA==} - - tweetnacl@1.0.3: - resolution: {integrity: sha512-6rt+RN7aOi1nGMyC4Xa5DdYiukl2UWCbcJft7YhxReBGQD7OAM8Pbxw6YMo4r2diNEA8FEmu32YOn9rhaiE5yw==} - - type-check@0.3.2: - resolution: {integrity: sha512-ZCmOJdvOWDBYJlzAoFkC+Q0+bUyEOS1ltgp1MGU03fqHG+dbi9tBFU2Rd9QKiDZFAYrhPh2JUf7rZRIuHRKtOg==} - engines: {node: '>= 0.8.0'} - - type-check@0.4.0: - resolution: {integrity: sha512-XleUoc9uwGXqjWwXaUTZAmzMcFZ5858QA2vvx1Ur5xIcixXIP+8LnFDgRplU30us6teqdlskFfu+ae4K79Ooew==} - engines: {node: '>= 0.8.0'} - - type-detect@4.0.8: - resolution: {integrity: sha512-0fr/mIH1dlO+x7TlcMy+bIDqKPsw/70tVyeHW787goQjhmqaZe10uwLujubK9q9Lg6Fiho1KUKDYz0Z7k7g5/g==} - engines: {node: '>=4'} - - type-fest@0.13.1: - resolution: {integrity: sha512-34R7HTnG0XIJcBSn5XhDd7nNFPRcXYRZrBB2O2jdKqYODldSzBAqzsWoZYYvduky73toYS/ESqxPvkDf/F0XMg==} - engines: {node: '>=10'} - - type-fest@0.20.2: - resolution: {integrity: sha512-Ne+eE4r0/iWnpAxD852z3A+N0Bt5RN//NjJwRd2VFHEmrywxf5vsZlh4R6lixl6B+wz/8d+maTSAkN1FIkI3LQ==} - engines: {node: '>=10'} - - type-fest@0.21.3: - resolution: {integrity: sha512-t0rzBq87m3fVcduHDUFhKmyyX+9eo6WQjZvf51Ea/M0Q7+T374Jp1aUiyUl0GKxp8M/OETVHSDvmkyPgvX+X2w==} - engines: {node: '>=10'} - - type-fest@0.6.0: - resolution: {integrity: sha512-q+MB8nYR1KDLrgr4G5yemftpMC7/QLqVndBmEEdqzmNj5dcFOO4Oo8qlwZE3ULT3+Zim1F8Kq4cBnikNhlCMlg==} - engines: {node: '>=8'} - - type-fest@0.7.1: - resolution: {integrity: sha512-Ne2YiiGN8bmrmJJEuTWTLJR32nh/JdL1+PSicowtNb0WFpn59GK8/lfD61bVtzguz7b3PBt74nxpv/Pw5po5Rg==} - engines: {node: '>=8'} - - type-fest@0.8.1: - resolution: {integrity: sha512-4dbzIzqvjtgiM5rw1k5rEHtBANKmdudhGyBEajN01fEyhaAIhsoKNy6y7+IN93IfpFtwY9iqi7kD+xwKhQsNJA==} - engines: {node: '>=8'} - - type-fest@2.19.0: - resolution: {integrity: sha512-RAH822pAdBgcNMAfWnCBU3CFZcfZ/i1eZjwFU/dsLKumyuuP3niueg2UAukXYF0E2AAoc82ZSSf9J0WQBinzHA==} - engines: {node: '>=12.20'} - - type-fest@3.13.1: - resolution: {integrity: sha512-tLq3bSNx+xSpwvAJnzrK0Ep5CLNWjvFTOp71URMaAEWBfRb9nnJiBoUe0tF8bI4ZFO3omgBR6NvnbzVUT3Ly4g==} - engines: {node: '>=14.16'} - - type-is@1.6.18: - resolution: {integrity: sha512-TkRKr9sUTxEH8MdfuCSP7VizJyzRNMjj2J2do2Jr3Kym598JVdEksuzPQCnlFPW4ky9Q+iA+ma9BGm06XQBy8g==} - engines: {node: '>= 0.6'} - - type@2.7.2: - resolution: {integrity: sha512-dzlvlNlt6AXU7EBSfpAscydQ7gXB+pPGsPnfJnZpiNJBDj7IaJzQlBZYGdEi4R9HmPdBv2XmWJ6YUtoTa7lmCw==} - - typechain@8.3.2: - resolution: {integrity: sha512-x/sQYr5w9K7yv3es7jo4KTX05CLxOf7TRWwoHlrjRh8H82G64g+k7VuWPJlgMo6qrjfCulOdfBjiaDtmhFYD/Q==} - hasBin: true - peerDependencies: - typescript: '>=4.3.0' - - typed-array-buffer@1.0.2: - resolution: {integrity: sha512-gEymJYKZtKXzzBzM4jqa9w6Q1Jjm7x2d+sh19AdsD4wqnMPDYyvwpsIc2Q/835kHuo3BEQ7CjelGhfTsoBb2MQ==} - engines: {node: '>= 0.4'} - - typed-array-byte-length@1.0.1: - resolution: {integrity: sha512-3iMJ9q0ao7WE9tWcaYKIptkNBuOIcZCCT0d4MRvuuH88fEoEH62IuQe0OtraD3ebQEoTRk8XCBoknUNc1Y67pw==} - engines: {node: '>= 0.4'} - - typed-array-byte-offset@1.0.2: - resolution: {integrity: sha512-Ous0vodHa56FviZucS2E63zkgtgrACj7omjwd/8lTEMEPFFyjfixMZ1ZXenpgCFBBt4EC1J2XsyVS2gkG0eTFA==} - engines: {node: '>= 0.4'} - - typed-array-length@1.0.6: - resolution: {integrity: sha512-/OxDN6OtAk5KBpGb28T+HZc2M+ADtvRxXrKKbUwtsLgdoxgX13hyy7ek6bFRl5+aBs2yZzB0c4CnQfAtVypW/g==} - engines: {node: '>= 0.4'} - - typedarray-to-buffer@3.1.5: - resolution: {integrity: sha512-zdu8XMNEDepKKR+XYOXAVPtWui0ly0NtohUscw+UmaHiAWT8hrV1rr//H6V+0DvJ3OQ19S979M0laLfX8rm82Q==} - - typedarray@0.0.6: - resolution: {integrity: sha512-/aCDEGatGvZ2BIk+HmLf4ifCJFwvKFNb9/JeZPMulfgFracn9QFcAf5GO8B/mweUjSoblS5In0cWhqpfs/5PQA==} - - typescript@5.0.4: - resolution: {integrity: sha512-cW9T5W9xY37cc+jfEnaUvX91foxtHkza3Nw3wkoF4sSlKn0MONdkdEndig/qPBWXNkmplh3NzayQzCiHM4/hqw==} - engines: {node: '>=12.20'} - hasBin: true - - typical@4.0.0: - resolution: {integrity: sha512-VAH4IvQ7BDFYglMd7BPRDfLgxZZX4O4TFcRDA6EN5X7erNJJq+McIEp8np9aVtxrCJ6qx4GTYVfOWNjcqwZgRw==} - engines: {node: '>=8'} - - typical@5.2.0: - resolution: {integrity: sha512-dvdQgNDNJo+8B2uBQoqdb11eUCE1JQXhvjC/CZtgvZseVd5TYMXnq0+vuUemXbd/Se29cTaUuPX3YIc2xgbvIg==} - engines: {node: '>=8'} - - uglify-js@3.17.4: - resolution: {integrity: sha512-T9q82TJI9e/C1TAxYvfb16xO120tMVFZrGA3f9/P4424DNu6ypK103y0GPFVa17yotwSyZW5iYXgjYHkGrJW/g==} - engines: {node: '>=0.8.0'} - hasBin: true - - ultron@1.1.1: - resolution: {integrity: sha512-UIEXBNeYmKptWH6z8ZnqTeS8fV74zG0/eRU9VGkpzz+LIJNs8W/zM/L+7ctCkRrgbNnnR0xxw4bKOr0cW0N0Og==} - - unbox-primitive@1.0.2: - resolution: {integrity: sha512-61pPlCD9h51VoreyJ0BReideM3MDKMKnh6+V9L08331ipq6Q8OFXZYiqP6n/tbHx4s5I9uRhcye6BrbkizkBDw==} - - underscore@1.13.6: - resolution: {integrity: sha512-+A5Sja4HP1M08MaXya7p5LvjuM7K6q/2EaC0+iovj/wOcMsTzMvDFbasi/oSapiwOlt252IqsKqPjCl7huKS0A==} - - undici-types@5.26.5: - resolution: {integrity: sha512-JlCMO+ehdEIKqlFxk6IfVoAUVmgz7cU7zD/h9XZ0qzeosSHmUJVOzSQvvYSYWXkFXC+IfLKSIffhv0sVZup6pA==} - - undici@5.28.4: - resolution: {integrity: sha512-72RFADWFqKmUb2hmmvNODKL3p9hcB6Gt2DOQMis1SEBaV6a4MH8soBvzg+95CYhCKPFedut2JY9bMfrDl9D23g==} - engines: {node: '>=14.0'} - - universalify@0.1.2: - resolution: {integrity: sha512-rBJeI5CXAlmy1pV+617WB9J63U6XcazHHF2f2dbJix4XzpUF0RS3Zbj0FGIOCAva5P/d/GBOYaACQ1w+0azUkg==} - engines: {node: '>= 4.0.0'} - - universalify@2.0.1: - resolution: {integrity: sha512-gptHNQghINnc/vTGIk0SOFGFNXw7JVrlRUtConJRlvaw6DuX0wO5Jeko9sWrMBhh+PsYAZ7oXAiOnf/UKogyiw==} - engines: {node: '>= 10.0.0'} - - unpipe@1.0.0: - resolution: {integrity: sha512-pjy2bYhSsufwWlKwPc+l3cN7+wuJlK6uz0YdJEOlQDbl6jo/YlPi4mb8agUkVC8BF7V8NuzeyPNqRksA3hztKQ==} - engines: {node: '>= 0.8'} - - untildify@4.0.0: - resolution: {integrity: sha512-KK8xQ1mkzZeg9inewmFVDNkg3l5LUhoq9kN6iWYB/CC9YMG8HA+c1Q8HwDe6dEX7kErrEVNVBO3fWsVq5iDgtw==} - engines: {node: '>=8'} - - update-browserslist-db@1.0.15: - resolution: {integrity: sha512-K9HWH62x3/EalU1U6sjSZiylm9C8tgq2mSvshZpqc7QE69RaA2qjhkW2HlNA0tFpEbtyFz7HTqbSdN4MSwUodA==} - hasBin: true - peerDependencies: - browserslist: '>= 4.21.0' - - upper-case-first@1.1.2: - resolution: {integrity: sha512-wINKYvI3Db8dtjikdAqoBbZoP6Q+PZUyfMR7pmwHzjC2quzSkUq5DmPrTtPEqHaz8AGtmsB4TqwapMTM1QAQOQ==} - - upper-case@1.1.3: - resolution: {integrity: sha512-WRbjgmYzgXkCV7zNVpy5YgrHgbBv126rMALQQMrmzOVC4GM2waQ9x7xtm8VU+1yF2kWyPzI9zbZ48n4vSxwfSA==} - - uri-js@4.4.1: - resolution: {integrity: sha512-7rKUyy33Q1yc98pQ1DAmLtwX109F7TIfWlW1Ydo8Wl1ii1SeHieeh0HHfPeL2fMXK6z0s8ecKs9frCuLJvndBg==} - - url-set-query@1.0.0: - resolution: {integrity: sha512-3AChu4NiXquPfeckE5R5cGdiHCMWJx1dwCWOmWIL4KHAziJNOFIYJlpGFeKDvwLPHovZRCxK3cYlwzqI9Vp+Gg==} - - usb@2.9.0: - resolution: {integrity: sha512-G0I/fPgfHUzWH8xo2KkDxTTFruUWfppgSFJ+bQxz/kVY2x15EQ/XDB7dqD1G432G4gBG4jYQuF3U7j/orSs5nw==} - engines: {node: '>=10.20.0 <11.x || >=12.17.0 <13.0 || >=14.0.0'} - - utf-8-validate@5.0.10: - resolution: {integrity: sha512-Z6czzLq4u8fPOyx7TU6X3dvUZVvoJmxSQ+IcrlmagKhilxlhZgxPK6C5Jqbkw1IDUmFTM+cz9QDnnLTwDz/2gQ==} - engines: {node: '>=6.14.2'} - - utf8@2.1.2: - resolution: {integrity: sha512-QXo+O/QkLP/x1nyi54uQiG0XrODxdysuQvE5dtVqv7F5K2Qb6FsN+qbr6KhF5wQ20tfcV3VQp0/2x1e1MRSPWg==} - - utf8@3.0.0: - resolution: {integrity: sha512-E8VjFIQ/TyQgp+TZfS6l8yp/xWppSAHzidGiRrqe4bK4XP9pTRyKFgGJpO3SN7zdX4DeomTrwaseCHovfpFcqQ==} - - util-deprecate@1.0.2: - resolution: {integrity: sha512-EPD5q1uXyFxJpCrLnCc1nHnq3gOa6DZBocAIiI2TaSCA7VCJ1UJDMagCzIkXNsUYfD1daK//LTEQ8xiIbrHtcw==} - - util@0.12.5: - resolution: {integrity: sha512-kZf/K6hEIrWHI6XqOFUiiMa+79wE/D8Q+NCNAWclkyg3b4d2k7s0QGepNjiABc+aR3N1PAyHL7p6UcLY6LmrnA==} - - utils-merge@1.0.1: - resolution: {integrity: sha512-pMZTvIkT1d+TFGvDOqodOclx0QWkkgi6Tdoa8gC8ffGAAqz9pzPTZWAybbsHHoED/ztMtkv/VoYTYyShUn81hA==} - engines: {node: '>= 0.4.0'} - - uuid@2.0.1: - resolution: {integrity: sha512-nWg9+Oa3qD2CQzHIP4qKUqwNfzKn8P0LtFhotaCTFchsV7ZfDhAybeip/HZVeMIpZi9JgY1E3nUlwaCmZT1sEg==} - deprecated: Please upgrade to version 7 or higher. Older versions may use Math.random() in certain circumstances, which is known to be problematic. See https://v8.dev/blog/math-random for details. - - uuid@3.4.0: - resolution: {integrity: sha512-HjSDRw6gZE5JMggctHBcjVak08+KEVhSIiDzFnT9S9aegmp85S/bReBVTb4QTFaRNptJ9kuYaNhnbNEOkbKb/A==} - deprecated: Please upgrade to version 7 or higher. Older versions may use Math.random() in certain circumstances, which is known to be problematic. See https://v8.dev/blog/math-random for details. - hasBin: true - - uuid@8.3.2: - resolution: {integrity: sha512-+NYs2QeMWy+GWFOEm9xnn6HCDp0l7QBD7ml8zLUmJ+93Q5NF0NocErnwkTkXVFNiX3/fpC6afS8Dhb/gz7R7eg==} - hasBin: true - - uuid@9.0.1: - resolution: {integrity: sha512-b+1eJOlsR9K8HJpow9Ok3fiWOWSIcIzXodvv0rQjVoOVNpWMpxf1wZNpt4y9h10odCNrqnYp1OBzRktckBe3sA==} - hasBin: true - - v8-compile-cache-lib@3.0.1: - resolution: {integrity: sha512-wa7YjyUGfNZngI/vtK0UHAN+lgDCxBPCylVXGp0zu59Fz5aiGtNXaq3DhIov063MorB+VfufLh3JlF2KdTK3xg==} - - validate-npm-package-license@3.0.4: - resolution: {integrity: sha512-DpKm2Ui/xN7/HQKCtpZxoRWBhZ9Z0kqtygG8XCgNQ8ZlDnxuQmWhj566j8fN4Cu3/JmbhsDo7fcAJq4s9h27Ew==} - - varint@5.0.2: - resolution: {integrity: sha512-lKxKYG6H03yCZUpAGOPOsMcGxd1RHCu1iKvEHYDPmTyq2HueGhD73ssNBqqQWfvYs04G9iUFRvmAVLW20Jw6ow==} - - vary@1.1.2: - resolution: {integrity: sha512-BNGbWLfd0eUPabhkXUVm0j8uuvREyTh5ovRa/dyow/BqAbZJyC+5fU+IzQOzmAKzYqYRAISoRhdQr3eIZ/PXqg==} - engines: {node: '>= 0.8'} - - verror@1.10.0: - resolution: {integrity: sha512-ZZKSmDAEFOijERBLkmYfJ+vmk3w+7hOLYDNkRCuRuMJGEmqYNCNLyBBFwWKVMhfwaEF3WOd0Zlw86U/WC/+nYw==} - engines: {'0': node >=0.6.0} - - viem@2.10.3: - resolution: {integrity: sha512-GmPMH+D/SDSXpVSjLM0GN1H1/h4NUPHaIqnFLwAit8nkfCiDuajKflGFiMPCIs1h7QZlBICuKvON/rc09H+w6Q==} - peerDependencies: - typescript: '>=5.0.4' - peerDependenciesMeta: - typescript: - optional: true - - wcwidth@1.0.1: - resolution: {integrity: sha512-XHPEwS0q6TaxcvG85+8EYkbiCux2XtWG2mkc47Ng2A77BQu9+DqIOJldST4HgPkuea7dvKSj5VgX3P1d4rW8Tg==} - - web3-bzz@1.10.0: - resolution: {integrity: sha512-o9IR59io3pDUsXTsps5pO5hW1D5zBmg46iNc2t4j2DkaYHNdDLwk2IP9ukoM2wg47QILfPEJYzhTfkS/CcX0KA==} - engines: {node: '>=8.0.0'} - - web3-bzz@1.10.4: - resolution: {integrity: sha512-ZZ/X4sJ0Uh2teU9lAGNS8EjveEppoHNQiKlOXAjedsrdWuaMErBPdLQjXfcrYvN6WM6Su9PMsAxf3FXXZ+HwQw==} - engines: {node: '>=8.0.0'} - - web3-core-helpers@1.10.0: - resolution: {integrity: sha512-pIxAzFDS5vnbXvfvLSpaA1tfRykAe9adw43YCKsEYQwH0gCLL0kMLkaCX3q+Q8EVmAh+e1jWL/nl9U0de1+++g==} - engines: {node: '>=8.0.0'} - - web3-core-helpers@1.10.4: - resolution: {integrity: sha512-r+L5ylA17JlD1vwS8rjhWr0qg7zVoVMDvWhajWA5r5+USdh91jRUYosp19Kd1m2vE034v7Dfqe1xYRoH2zvG0g==} - engines: {node: '>=8.0.0'} - - web3-core-method@1.10.0: - resolution: {integrity: sha512-4R700jTLAMKDMhQ+nsVfIXvH6IGJlJzGisIfMKWAIswH31h5AZz7uDUW2YctI+HrYd+5uOAlS4OJeeT9bIpvkA==} - engines: {node: '>=8.0.0'} - - web3-core-method@1.10.4: - resolution: {integrity: sha512-uZTb7flr+Xl6LaDsyTeE2L1TylokCJwTDrIVfIfnrGmnwLc6bmTWCCrm71sSrQ0hqs6vp/MKbQYIYqUN0J8WyA==} - engines: {node: '>=8.0.0'} - - web3-core-promievent@1.10.0: - resolution: {integrity: sha512-68N7k5LWL5R38xRaKFrTFT2pm2jBNFaM4GioS00YjAKXRQ3KjmhijOMG3TICz6Aa5+6GDWYelDNx21YAeZ4YTg==} - engines: {node: '>=8.0.0'} - - web3-core-promievent@1.10.4: - resolution: {integrity: sha512-2de5WnJQ72YcIhYwV/jHLc4/cWJnznuoGTJGD29ncFQHAfwW/MItHFSVKPPA5v8AhJe+r6y4Y12EKvZKjQVBvQ==} - engines: {node: '>=8.0.0'} - - web3-core-requestmanager@1.10.0: - resolution: {integrity: sha512-3z/JKE++Os62APml4dvBM+GAuId4h3L9ckUrj7ebEtS2AR0ixyQPbrBodgL91Sv7j7cQ3Y+hllaluqjguxvSaQ==} - engines: {node: '>=8.0.0'} - - web3-core-requestmanager@1.10.4: - resolution: {integrity: sha512-vqP6pKH8RrhT/2MoaU+DY/OsYK9h7HmEBNCdoMj+4ZwujQtw/Mq2JifjwsJ7gits7Q+HWJwx8q6WmQoVZAWugg==} - engines: {node: '>=8.0.0'} - - web3-core-subscriptions@1.10.0: - resolution: {integrity: sha512-HGm1PbDqsxejI075gxBc5OSkwymilRWZufIy9zEpnWKNmfbuv5FfHgW1/chtJP6aP3Uq2vHkvTDl3smQBb8l+g==} - engines: {node: '>=8.0.0'} - - web3-core-subscriptions@1.10.4: - resolution: {integrity: sha512-o0lSQo/N/f7/L76C0HV63+S54loXiE9fUPfHFcTtpJRQNDBVsSDdWRdePbWwR206XlsBqD5VHApck1//jEafTw==} - engines: {node: '>=8.0.0'} - - web3-core@1.10.0: - resolution: {integrity: sha512-fWySwqy2hn3TL89w5TM8wXF1Z2Q6frQTKHWmP0ppRQorEK8NcHJRfeMiv/mQlSKoTS1F6n/nv2uyZsixFycjYQ==} - engines: {node: '>=8.0.0'} - - web3-core@1.10.4: - resolution: {integrity: sha512-B6elffYm81MYZDTrat7aEhnhdtVE3lDBUZft16Z8awYMZYJDbnykEbJVS+l3mnA7AQTnSDr/1MjWofGDLBJPww==} - engines: {node: '>=8.0.0'} - - web3-core@4.3.2: - resolution: {integrity: sha512-uIMVd/j4BgOnwfpY8ZT+QKubOyM4xohEhFZXz9xB8wimXWMMlYVlIK/TbfHqFolS9uOerdSGhsMbcK9lETae8g==} - engines: {node: '>=14', npm: '>=6.12.0'} - - web3-errors@1.1.4: - resolution: {integrity: sha512-WahtszSqILez+83AxGecVroyZsMuuRT+KmQp4Si5P4Rnqbczno1k748PCrZTS1J4UCPmXMG2/Vt+0Bz2zwXkwQ==} - engines: {node: '>=14', npm: '>=6.12.0'} - - web3-eth-abi@1.10.0: - resolution: {integrity: sha512-cwS+qRBWpJ43aI9L3JS88QYPfFcSJJ3XapxOQ4j40v6mk7ATpA8CVK1vGTzpihNlOfMVRBkR95oAj7oL6aiDOg==} - engines: {node: '>=8.0.0'} - - web3-eth-abi@1.10.4: - resolution: {integrity: sha512-cZ0q65eJIkd/jyOlQPDjr8X4fU6CRL1eWgdLwbWEpo++MPU/2P4PFk5ZLAdye9T5Sdp+MomePPJ/gHjLMj2VfQ==} - engines: {node: '>=8.0.0'} - - web3-eth-abi@4.2.1: - resolution: {integrity: sha512-IE91WUhhiDpBtbkl/DHUoZz7z7T5FXvl3zPLkrxT+dNlOT+wni+US/67jQCLvJRbqf9ApQ26lVYry0bovFgyqA==} - engines: {node: '>=14', npm: '>=6.12.0'} - - web3-eth-accounts@1.10.0: - resolution: {integrity: sha512-wiq39Uc3mOI8rw24wE2n15hboLE0E9BsQLdlmsL4Zua9diDS6B5abXG0XhFcoNsXIGMWXVZz4TOq3u4EdpXF/Q==} - engines: {node: '>=8.0.0'} - - web3-eth-accounts@1.10.4: - resolution: {integrity: sha512-ysy5sVTg9snYS7tJjxVoQAH6DTOTkRGR8emEVCWNGLGiB9txj+qDvSeT0izjurS/g7D5xlMAgrEHLK1Vi6I3yg==} - engines: {node: '>=8.0.0'} - - web3-eth-accounts@4.1.2: - resolution: {integrity: sha512-y0JynDeTDnclyuE9mShXLeEj+BCrPHxPHOyPCgTchUBQsALF9+0OhP7WiS3IqUuu0Hle5bjG2f5ddeiPtNEuLg==} - engines: {node: '>=14', npm: '>=6.12.0'} - - web3-eth-contract@1.10.0: - resolution: {integrity: sha512-MIC5FOzP/+2evDksQQ/dpcXhSqa/2hFNytdl/x61IeWxhh6vlFeSjq0YVTAyIzdjwnL7nEmZpjfI6y6/Ufhy7w==} - engines: {node: '>=8.0.0'} - - web3-eth-contract@1.10.4: - resolution: {integrity: sha512-Q8PfolOJ4eV9TvnTj1TGdZ4RarpSLmHnUnzVxZ/6/NiTfe4maJz99R0ISgwZkntLhLRtw0C7LRJuklzGYCNN3A==} - engines: {node: '>=8.0.0'} - - web3-eth-contract@4.4.0: - resolution: {integrity: sha512-pZ/w6Lb6ZDUUs7f5GCKXiHDAGGvt2tdwiHkvgmQTRnq9b0MEsUpteDyPYspHxKzQWLgbeK37jPb8zbQe4kE/Hg==} - engines: {node: '>=14', npm: '>=6.12.0'} - - web3-eth-ens@1.10.0: - resolution: {integrity: sha512-3hpGgzX3qjgxNAmqdrC2YUQMTfnZbs4GeLEmy8aCWziVwogbuqQZ+Gzdfrym45eOZodk+lmXyLuAdqkNlvkc1g==} - engines: {node: '>=8.0.0'} - - web3-eth-ens@1.10.4: - resolution: {integrity: sha512-LLrvxuFeVooRVZ9e5T6OWKVflHPFgrVjJ/jtisRWcmI7KN/b64+D/wJzXqgmp6CNsMQcE7rpmf4CQmJCrTdsgg==} - engines: {node: '>=8.0.0'} - - web3-eth-ens@4.2.0: - resolution: {integrity: sha512-qYj34te2UctoObt8rlEIY/t2MuTMiMiiHhO2JAHRGqSLCQ7b8DM3RpvkiiSB0N0ZyEn+CetZqJCTYb8DNKBS/g==} - engines: {node: '>=14', npm: '>=6.12.0'} - - web3-eth-iban@1.10.0: - resolution: {integrity: sha512-0l+SP3IGhInw7Q20LY3IVafYEuufo4Dn75jAHT7c2aDJsIolvf2Lc6ugHkBajlwUneGfbRQs/ccYPQ9JeMUbrg==} - engines: {node: '>=8.0.0'} - - web3-eth-iban@1.10.4: - resolution: {integrity: sha512-0gE5iNmOkmtBmbKH2aTodeompnNE8jEyvwFJ6s/AF6jkw9ky9Op9cqfzS56AYAbrqEFuClsqB/AoRves7LDELw==} - engines: {node: '>=8.0.0'} - - web3-eth-iban@4.0.7: - resolution: {integrity: sha512-8weKLa9KuKRzibC87vNLdkinpUE30gn0IGY027F8doeJdcPUfsa4IlBgNC4k4HLBembBB2CTU0Kr/HAOqMeYVQ==} - engines: {node: '>=14', npm: '>=6.12.0'} - - web3-eth-personal@1.10.0: - resolution: {integrity: sha512-anseKn98w/d703eWq52uNuZi7GhQeVjTC5/svrBWEKob0WZ5kPdo+EZoFN0sp5a5ubbrk/E0xSl1/M5yORMtpg==} - engines: {node: '>=8.0.0'} - - web3-eth-personal@1.10.4: - resolution: {integrity: sha512-BRa/hs6jU1hKHz+AC/YkM71RP3f0Yci1dPk4paOic53R4ZZG4MgwKRkJhgt3/GPuPliwS46f/i5A7fEGBT4F9w==} - engines: {node: '>=8.0.0'} - - web3-eth-personal@4.0.8: - resolution: {integrity: sha512-sXeyLKJ7ddQdMxz1BZkAwImjqh7OmKxhXoBNF3isDmD4QDpMIwv/t237S3q4Z0sZQamPa/pHebJRWVuvP8jZdw==} - engines: {node: '>=14', npm: '>=6.12.0'} - - web3-eth@1.10.0: - resolution: {integrity: sha512-Z5vT6slNMLPKuwRyKGbqeGYC87OAy8bOblaqRTgg94CXcn/mmqU7iPIlG4506YdcdK3x6cfEDG7B6w+jRxypKA==} - engines: {node: '>=8.0.0'} - - web3-eth@1.10.4: - resolution: {integrity: sha512-Sql2kYKmgt+T/cgvg7b9ce24uLS7xbFrxE4kuuor1zSCGrjhTJ5rRNG8gTJUkAJGKJc7KgnWmgW+cOfMBPUDSA==} - engines: {node: '>=8.0.0'} - - web3-eth@4.6.0: - resolution: {integrity: sha512-8KtxlGsomovoFULqEpfixgmCpaJ2YIJGxbXUfezh2coXHjVgEopQhARYtKGClyV5kkdCIqwHS8Gvsm6TVNqH6Q==} - engines: {node: '>=14', npm: '>=6.12.0'} - - web3-net@1.10.0: - resolution: {integrity: sha512-NLH/N3IshYWASpxk4/18Ge6n60GEvWBVeM8inx2dmZJVmRI6SJIlUxbL8jySgiTn3MMZlhbdvrGo8fpUW7a1GA==} - engines: {node: '>=8.0.0'} - - web3-net@1.10.4: - resolution: {integrity: sha512-mKINnhOOnZ4koA+yV2OT5s5ztVjIx7IY9a03w6s+yao/BUn+Luuty0/keNemZxTr1E8Ehvtn28vbOtW7Ids+Ow==} - engines: {node: '>=8.0.0'} - - web3-net@4.0.7: - resolution: {integrity: sha512-SzEaXFrBjY25iQGk5myaOfO9ZyfTwQEa4l4Ps4HDNVMibgZji3WPzpjq8zomVHMwi8bRp6VV7YS71eEsX7zLow==} - engines: {node: '>=14', npm: '>=6.12.0'} - - web3-providers-http@1.10.0: - resolution: {integrity: sha512-eNr965YB8a9mLiNrkjAWNAPXgmQWfpBfkkn7tpEFlghfww0u3I0tktMZiaToJVcL2+Xq+81cxbkpeWJ5XQDwOA==} - engines: {node: '>=8.0.0'} - - web3-providers-http@1.10.4: - resolution: {integrity: sha512-m2P5Idc8hdiO0l60O6DSCPw0kw64Zgi0pMjbEFRmxKIck2Py57RQMu4bxvkxJwkF06SlGaEQF8rFZBmuX7aagQ==} - engines: {node: '>=8.0.0'} - - web3-providers-http@4.1.0: - resolution: {integrity: sha512-6qRUGAhJfVQM41E5t+re5IHYmb5hSaLc02BE2MaRQsz2xKA6RjmHpOA5h/+ojJxEpI9NI2CrfDKOAgtJfoUJQg==} - engines: {node: '>=14', npm: '>=6.12.0'} - - web3-providers-ipc@1.10.0: - resolution: {integrity: sha512-OfXG1aWN8L1OUqppshzq8YISkWrYHaATW9H8eh0p89TlWMc1KZOL9vttBuaBEi96D/n0eYDn2trzt22bqHWfXA==} - engines: {node: '>=8.0.0'} - - web3-providers-ipc@1.10.4: - resolution: {integrity: sha512-YRF/bpQk9z3WwjT+A6FI/GmWRCASgd+gC0si7f9zbBWLXjwzYAKG73bQBaFRAHex1hl4CVcM5WUMaQXf3Opeuw==} - engines: {node: '>=8.0.0'} - - web3-providers-ipc@4.0.7: - resolution: {integrity: sha512-YbNqY4zUvIaK2MHr1lQFE53/8t/ejHtJchrWn9zVbFMGXlTsOAbNoIoZWROrg1v+hCBvT2c9z8xt7e/+uz5p1g==} - engines: {node: '>=14', npm: '>=6.12.0'} - - web3-providers-ws@1.10.0: - resolution: {integrity: sha512-sK0fNcglW36yD5xjnjtSGBnEtf59cbw4vZzJ+CmOWIKGIR96mP5l684g0WD0Eo+f4NQc2anWWXG74lRc9OVMCQ==} - engines: {node: '>=8.0.0'} - - web3-providers-ws@1.10.4: - resolution: {integrity: sha512-j3FBMifyuFFmUIPVQR4pj+t5ILhAexAui0opgcpu9R5LxQrLRUZxHSnU+YO25UycSOa/NAX8A+qkqZNpcFAlxA==} - engines: {node: '>=8.0.0'} - - web3-providers-ws@4.0.7: - resolution: {integrity: sha512-n4Dal9/rQWjS7d6LjyEPM2R458V8blRm0eLJupDEJOOIBhGYlxw5/4FthZZ/cqB7y/sLVi7K09DdYx2MeRtU5w==} - engines: {node: '>=14', npm: '>=6.12.0'} - - web3-rpc-methods@1.2.0: - resolution: {integrity: sha512-CWJ/g4I4WyYvLkf21wCZAehdhU/VjX/OAPHnqF5/FPDJlogOsOnGXHqi1Z5AP+ocdt395PNubd8jyMMJoYGSBA==} - engines: {node: '>=14', npm: '>=6.12.0'} - - web3-shh@1.10.0: - resolution: {integrity: sha512-uNUUuNsO2AjX41GJARV9zJibs11eq6HtOe6Wr0FtRUcj8SN6nHeYIzwstAvJ4fXA53gRqFMTxdntHEt9aXVjpg==} - engines: {node: '>=8.0.0'} - - web3-shh@1.10.4: - resolution: {integrity: sha512-cOH6iFFM71lCNwSQrC3niqDXagMqrdfFW85hC9PFUrAr3PUrIem8TNstTc3xna2bwZeWG6OBy99xSIhBvyIACw==} - engines: {node: '>=8.0.0'} - - web3-types@1.6.0: - resolution: {integrity: sha512-qgOtADqlD5hw+KPKBUGaXAcdNLL0oh6qTeVgXwewCfbL/lG9R+/GrgMQB1gbTJ3cit8hMwtH8KX2Em6OwO0HRw==} - engines: {node: '>=14', npm: '>=6.12.0'} - - web3-utils@1.10.0: - resolution: {integrity: sha512-kSaCM0uMcZTNUSmn5vMEhlo02RObGNRRCkdX0V9UTAU0+lrvn0HSaudyCo6CQzuXUsnuY2ERJGCGPfeWmv19Rg==} - engines: {node: '>=8.0.0'} - - web3-utils@1.10.4: - resolution: {integrity: sha512-tsu8FiKJLk2PzhDl9fXbGUWTkkVXYhtTA+SmEFkKft+9BgwLxfCRpU96sWv7ICC8zixBNd3JURVoiR3dUXgP8A==} - engines: {node: '>=8.0.0'} - - web3-utils@4.2.3: - resolution: {integrity: sha512-m5plKTC2YtQntHITQRyIePw52UVP1IrShhmA2FACtn4zmc5ADmrXOlQWiPzxFP/18eRJsAaUAw2+CQn1u4WPxQ==} - engines: {node: '>=14', npm: '>=6.12.0'} - - web3-validator@2.0.5: - resolution: {integrity: sha512-2gLOSW8XqEN5pw5jVUm20EB7A8SbQiekpAtiI0JBmCIV0a2rp97v8FgWY5E3UEqnw5WFfEqvcDVW92EyynDTyQ==} - engines: {node: '>=14', npm: '>=6.12.0'} - - web3@0.20.6: - resolution: {integrity: sha512-diON1+Y8sPQ33htuTMZfyo+qlsmCBSYwi+MVTRneS8anqZUaTrGaBkTpPkPUvfX1X+NK+Y2spLaaei3HfXeSuw==} - - web3@0.20.7: - resolution: {integrity: sha512-VU6/DSUX93d1fCzBz7WP/SGCQizO1rKZi4Px9j/3yRyfssHyFcZamMw2/sj4E8TlfMXONvZLoforR8B4bRoyTQ==} - - web3@1.10.0: - resolution: {integrity: sha512-YfKY9wSkGcM8seO+daR89oVTcbu18NsVfvOngzqMYGUU0pPSQmE57qQDvQzUeoIOHAnXEBNzrhjQJmm8ER0rng==} - engines: {node: '>=8.0.0'} - - web3@1.10.4: - resolution: {integrity: sha512-kgJvQZjkmjOEKimx/tJQsqWfRDPTTcBfYPa9XletxuHLpHcXdx67w8EFn5AW3eVxCutE9dTVHgGa9VYe8vgsEA==} - engines: {node: '>=8.0.0'} - - web3@4.8.0: - resolution: {integrity: sha512-kQSF2NlHk8yjS3SRiJW3S+U5ibkEmVRhB4/GYsVwGvdAkFC2b+EIE1Ob7J56OmqW9VBZgkx1+SuWqo5JTIJSYQ==} - engines: {node: '>=14.0.0', npm: '>=6.12.0'} - - webidl-conversions@3.0.1: - resolution: {integrity: sha512-2JAn3z8AR6rjK8Sm8orRC0h/bcl/DqL7tRPdGZ4I1CjdF+EaMLmYxBHyXuKL849eucPFhvBoxMsflfOb8kxaeQ==} - - websocket@1.0.34: - resolution: {integrity: sha512-PRDso2sGwF6kM75QykIesBijKSVceR6jL2G8NGYyq2XrItNC2P5/qL5XeR056GhA+Ly7JMFvJb9I312mJfmqnQ==} - engines: {node: '>=4.0.0'} - - whatwg-fetch@3.6.20: - resolution: {integrity: sha512-EqhiFU6daOA8kpjOWTL0olhVOF3i7OrFzSYiGsEMB8GcXS+RrzauAERX65xMeNWVqxA6HXH2m69Z9LaKKdisfg==} - - whatwg-url@5.0.0: - resolution: {integrity: sha512-saE57nupxk6v3HY35+jzBwYa0rKSy0XR8JSxZPwgLr7ys0IBzhGviA1/TUGJLmSVqs8pb9AnvICXEuOHLprYTw==} - - which-boxed-primitive@1.0.2: - resolution: {integrity: sha512-bwZdv0AKLpplFY2KZRX6TvyuN7ojjr7lwkg6ml0roIy9YeuSr7JS372qlNW18UQYzgYK9ziGcerWqZOmEn9VNg==} - - which-module@1.0.0: - resolution: {integrity: sha512-F6+WgncZi/mJDrammbTuHe1q0R5hOXv/mBaiNA2TCNT/LTHusX0V+CJnj9XT8ki5ln2UZyyddDgHfCzyrOH7MQ==} - - which-module@2.0.1: - resolution: {integrity: sha512-iBdZ57RDvnOR9AGBhML2vFZf7h8vmBjhoaZqODJBFWHVtKkDmKuHai3cx5PgVMrX5YDNp27AofYbAwctSS+vhQ==} - - which-pm@2.0.0: - resolution: {integrity: sha512-Lhs9Pmyph0p5n5Z3mVnN0yWcbQYUAD7rbQUiMsQxOJ3T57k7RFe35SUwWMf7dsbDZks1uOmw4AecB/JMDj3v/w==} - engines: {node: '>=8.15'} - - which-typed-array@1.1.15: - resolution: {integrity: sha512-oV0jmFtUky6CXfkqehVvBP/LSWJ2sy4vWMioiENyJLePrBO/yKyV9OyJySfAKosh+RYkIl5zJCNZ8/4JncrpdA==} - engines: {node: '>= 0.4'} - - which@1.3.1: - resolution: {integrity: sha512-HxJdYWq1MTIQbJ3nw0cqssHoTNU267KlrDuGZ1WYlxDStUtKUhOaJmh112/TZmHxxUfuJqPXSOm7tDyas0OSIQ==} - hasBin: true - - which@2.0.2: - resolution: {integrity: sha512-BLI3Tl1TW3Pvl70l3yq3Y64i+awpwXqsGBYWkkqMtnbXgrMD+yj7rhW0kuEDxzJaYXGjEW5ogapKNMEKNMjibA==} - engines: {node: '>= 8'} - hasBin: true - - widest-line@3.1.0: - resolution: {integrity: sha512-NsmoXalsWVDMGupxZ5R08ka9flZjjiLvHVAWYOKtiKM8ujtZWr9cRffak+uSE48+Ob8ObalXpwyeUiyDD6QFgg==} - engines: {node: '>=8'} - - window-size@0.2.0: - resolution: {integrity: sha512-UD7d8HFA2+PZsbKyaOCEy8gMh1oDtHgJh1LfgjQ4zVXmYjAT/kvz3PueITKuqDiIXQe7yzpPnxX3lNc+AhQMyw==} - engines: {node: '>= 0.10.0'} - hasBin: true - - word-wrap@1.2.5: - resolution: {integrity: sha512-BN22B5eaMMI9UMtjrGd5g5eCYPpCPDUy0FJXbYsaT5zYxjFOckS53SQDE3pWkVoWpHXVb3BrYcEN4Twa55B5cA==} - engines: {node: '>=0.10.0'} - - wordwrap@1.0.0: - resolution: {integrity: sha512-gvVzJFlPycKc5dZN4yPkP8w7Dc37BtP1yczEneOb4uq34pXZcvrtRTmWV8W+Ume+XCxKgbjM+nevkyFPMybd4Q==} - - wordwrapjs@4.0.1: - resolution: {integrity: sha512-kKlNACbvHrkpIw6oPeYDSmdCTu2hdMHoyXLTcUKala++lx5Y+wjJ/e474Jqv5abnVmwxw08DiTuHmw69lJGksA==} - engines: {node: '>=8.0.0'} - - workerpool@6.2.1: - resolution: {integrity: sha512-ILEIE97kDZvF9Wb9f6h5aXK4swSlKGUcOEGiIYb2OOu/IrDU9iwj0fD//SsA6E5ibwJxpEvhullJY4Sl4GcpAw==} - - wrap-ansi@2.1.0: - resolution: {integrity: sha512-vAaEaDM946gbNpH5pLVNR+vX2ht6n0Bt3GXwVB1AuAqZosOvHNF3P7wDnh8KLkSqgUh0uh77le7Owgoz+Z9XBw==} - engines: {node: '>=0.10.0'} - - wrap-ansi@6.2.0: - resolution: {integrity: sha512-r6lPcBGxZXlIcymEu7InxDMhdW0KDxpLgoFLcguasxCaJ/SOIZwINatK9KY/tf+ZrlywOKU0UDj3ATXUBfxJXA==} - engines: {node: '>=8'} - - wrap-ansi@7.0.0: - resolution: {integrity: sha512-YVGIj2kamLSTxw6NsZjoBxfSwsn0ycdesmc4p+Q21c5zPuZ1pl+NfxVdxPtdHvmNVOQ6XSYG4AUtyt/Fi7D16Q==} - engines: {node: '>=10'} - - wrappy@1.0.2: - resolution: {integrity: sha512-l4Sp/DRseor9wL6EvV2+TuQn63dMkPjZ/sp9XkghTEbV9KlPS1xUsZ3u7/IQO4wxtcFB4bgpQPRcR3QCvezPcQ==} - - write-file-atomic@3.0.3: - resolution: {integrity: sha512-AvHcyZ5JnSfq3ioSyjrBkH9yW4m7Ayk8/9My/DD9onKeu/94fwrMocemO2QAJFAlnnDN+ZDS+ZjAR5ua1/PV/Q==} - - ws@3.3.3: - resolution: {integrity: sha512-nnWLa/NwZSt4KQJu51MYlCcSQ5g7INpOrOMt4XV8j4dqTXdmlUmSHQ8/oLC069ckre0fRsgfvsKwbTdtKLCDkA==} - peerDependencies: - bufferutil: ^4.0.1 - utf-8-validate: ^5.0.2 - peerDependenciesMeta: - bufferutil: - optional: true - utf-8-validate: - optional: true - - ws@7.4.6: - resolution: {integrity: sha512-YmhHDO4MzaDLB+M9ym/mDA5z0naX8j7SIlT8f8z+I0VtzsRbekxEutHSme7NPS2qE8StCYQNUnfWdXta/Yu85A==} - engines: {node: '>=8.3.0'} - peerDependencies: - bufferutil: ^4.0.1 - utf-8-validate: ^5.0.2 - peerDependenciesMeta: - bufferutil: - optional: true - utf-8-validate: - optional: true - - ws@7.5.9: - resolution: {integrity: sha512-F+P9Jil7UiSKSkppIiD94dN07AwvFixvLIj1Og1Rl9GGMuNipJnV9JzjD6XuqmAeiswGvUmNLjr5cFuXwNS77Q==} - engines: {node: '>=8.3.0'} - peerDependencies: - bufferutil: ^4.0.1 - utf-8-validate: ^5.0.2 - peerDependenciesMeta: - bufferutil: - optional: true - utf-8-validate: - optional: true - - ws@8.13.0: - resolution: {integrity: sha512-x9vcZYTrFPC7aSIbj7sRCYo7L/Xb8Iy+pW0ng0wt2vCJv7M9HOMy0UoN3rr+IFC7hb7vXoqS+P9ktyLLLhO+LA==} - engines: {node: '>=10.0.0'} - peerDependencies: - bufferutil: ^4.0.1 - utf-8-validate: '>=5.0.2' - peerDependenciesMeta: - bufferutil: - optional: true - utf-8-validate: - optional: true - - ws@8.17.0: - resolution: {integrity: sha512-uJq6108EgZMAl20KagGkzCKfMEjxmKvZHG7Tlq0Z6nOky7YF7aq4mOx6xK8TJ/i1LeK4Qus7INktacctDgY8Ow==} - engines: {node: '>=10.0.0'} - peerDependencies: - bufferutil: ^4.0.1 - utf-8-validate: '>=5.0.2' - peerDependenciesMeta: - bufferutil: - optional: true - utf-8-validate: - optional: true - - ws@8.5.0: - resolution: {integrity: sha512-BWX0SWVgLPzYwF8lTzEy1egjhS4S4OEAHfsO8o65WOVsrnSRGaSiUaa9e0ggGlkMTtBlmOpEXiie9RUcBO86qg==} - engines: {node: '>=10.0.0'} - peerDependencies: - bufferutil: ^4.0.1 - utf-8-validate: ^5.0.2 - peerDependenciesMeta: - bufferutil: - optional: true - utf-8-validate: - optional: true - - xhr-request-promise@0.1.3: - resolution: {integrity: sha512-YUBytBsuwgitWtdRzXDDkWAXzhdGB8bYm0sSzMPZT7Z2MBjMSTHFsyCT1yCRATY+XC69DUrQraRAEgcoCRaIPg==} - - xhr-request@1.1.0: - resolution: {integrity: sha512-Y7qzEaR3FDtL3fP30k9wO/e+FBnBByZeybKOhASsGP30NIkRAAkKD/sCnLvgEfAIEC1rcmK7YG8f4oEnIrrWzA==} - - xhr2-cookies@1.1.0: - resolution: {integrity: sha512-hjXUA6q+jl/bd8ADHcVfFsSPIf+tyLIjuO9TwJC9WI6JP2zKcS7C+p56I9kCLLsaCiNT035iYvEUUzdEFj/8+g==} - - xhr2@0.2.1: - resolution: {integrity: sha512-sID0rrVCqkVNUn8t6xuv9+6FViXjUVXq8H5rWOH2rz9fDNQEd4g0EA2XlcEdJXRz5BMEn4O1pJFdT+z4YHhoWw==} - engines: {node: '>= 6'} - - xhr@2.6.0: - resolution: {integrity: sha512-/eCGLb5rxjx5e3mF1A7s+pLlR6CGyqWN91fv1JgER5mVWg1MZmlhBvy9kjcsOdRk8RrIujotWyJamfyrp+WIcA==} - - xmlhttprequest@1.8.0: - resolution: {integrity: sha512-58Im/U0mlVBLM38NdZjHyhuMtCqa61469k2YP/AaPbvCoV9aQGUpbJBj1QRm2ytRiVQBD/fsw7L2bJGDVQswBA==} - engines: {node: '>=0.4.0'} - - xtend@4.0.2: - resolution: {integrity: sha512-LKYU1iAXJXUgAXn9URjiu+MWhyUXHsvfp7mcuYm9dSUKK0/CjtrUwFAxD82/mCWbtLsGjFIad0wIsod4zrTAEQ==} - engines: {node: '>=0.4'} - - y18n@3.2.2: - resolution: {integrity: sha512-uGZHXkHnhF0XeeAPgnKfPv1bgKAYyVvmNL1xlKsPYZPaIHxGti2hHqvOCQv71XMsLxu1QjergkqogUnms5D3YQ==} - - y18n@4.0.3: - resolution: {integrity: sha512-JKhqTOwSrqNA1NY5lSztJ1GrBiUodLMmIZuLiDaMRJ+itFd+ABVE8XBjOvIWL+rSqNDC74LCSFmlb/U4UZ4hJQ==} - - y18n@5.0.8: - resolution: {integrity: sha512-0pfFzegeDWJHJIAmTLRP2DwHjdF5s7jo9tuztdQxAhINCdvS+3nGINqPd00AphqJR/0LhANUS6/+7SCb98YOfA==} - engines: {node: '>=10'} - - yaeti@0.0.6: - resolution: {integrity: sha512-MvQa//+KcZCUkBTIC9blM+CU9J2GzuTytsOUwf2lidtvkx/6gnEp1QvJv34t9vdjhFmha/mUiNDbN0D0mJWdug==} - engines: {node: '>=0.10.32'} - - yallist@2.1.2: - resolution: {integrity: sha512-ncTzHV7NvsQZkYe1DW7cbDLm0YpzHmZF5r/iyP3ZnQtMiJ+pjzisCiMNI+Sj+xQF5pXhSHxSB3uDbsBTzY/c2A==} - - yallist@3.1.1: - resolution: {integrity: sha512-a4UGQaWPH59mOXUYnAG2ewncQS4i4F43Tv3JoAM+s2VDAmS9NsK8GpDMLrCHPksFT7h3K6TOoUNn2pb7RoXx4g==} - - yargs-parser@18.1.3: - resolution: {integrity: sha512-o50j0JeToy/4K6OZcaQmW6lyXXKhq7csREXcDwk2omFPJEwUNOVtJKvmDr9EI1fAJZUyZcRF7kxGBWmRXudrCQ==} - engines: {node: '>=6'} - - yargs-parser@2.4.1: - resolution: {integrity: sha512-9pIKIJhnI5tonzG6OnCFlz/yln8xHYcGl+pn3xR0Vzff0vzN1PbNRaelgfgRUwZ3s4i3jvxT9WhmUGL4whnasA==} - - yargs-parser@20.2.4: - resolution: {integrity: sha512-WOkpgNhPTlE73h4VFAFsOnomJVaovO8VqLDzy5saChRBFQFBoMYirowyW+Q9HB4HFF4Z7VZTiG3iSzJJA29yRA==} - engines: {node: '>=10'} - - yargs-parser@21.1.1: - resolution: {integrity: sha512-tVpsJW7DdjecAiFpbIB1e3qxIQsE6NoPc5/eTdrbbIC4h0LVsWhnoa3g+m2HclBIujHzsxZ4VJVA+GUuc2/LBw==} - engines: {node: '>=12'} - - yargs-unparser@2.0.0: - resolution: {integrity: sha512-7pRTIA9Qc1caZ0bZ6RYRGbHJthJWuakf+WmHK0rVeLkNrrGhfoabBNdue6kdINI6r4if7ocq9aD/n7xwKOdzOA==} - engines: {node: '>=10'} - - yargs@15.4.1: - resolution: {integrity: sha512-aePbxDmcYW++PaqBsJ+HYUFwCdv4LVvdnhBy78E57PIor8/OVvhMrADFFEDh8DHDFRv/O9i3lPhsENjO7QX0+A==} - engines: {node: '>=8'} - - yargs@16.2.0: - resolution: {integrity: sha512-D1mvvtDG0L5ft/jGWkLpG1+m0eQxOfaBvTNELraWj22wSVUMWxZUvYgJYcKh6jGGIkJFhH4IZPQhR4TKpc8mBw==} - engines: {node: '>=10'} - - yargs@17.7.2: - resolution: {integrity: sha512-7dSzzRQ++CKnNI/krKnYRV7JKKPUXMEh61soaHKg9mrWEhzFWhFnxPxGl+69cD1Ou63C13NUPCnmIcrvqCuM6w==} - engines: {node: '>=12'} - - yargs@4.8.1: - resolution: {integrity: sha512-LqodLrnIDM3IFT+Hf/5sxBnEGECrfdC1uIbgZeJmESCSo4HoCAaKEus8MylXHAkdacGc0ye+Qa+dpkuom8uVYA==} - - yn@3.1.1: - resolution: {integrity: sha512-Ux4ygGWsu2c7isFWe8Yu1YluJmqVhxqK2cLXNQA5AcC3QfbGNpM7fu0Y8b/z16pXLnFxZYvWhd3fhBY9DLmC6Q==} - engines: {node: '>=6'} - - yocto-queue@0.1.0: - resolution: {integrity: sha512-rVksvsnNCdJ/ohGc6xgPwyN8eheCxsiLM8mxuE/t/mOVqJewPuO1miLpTHQiRgTKCLexL4MeAFVagts7HmNZ2Q==} - engines: {node: '>=10'} - - zod@3.23.8: - resolution: {integrity: sha512-XBx9AXhXktjUqnepgTiE5flcKIYWi/rme0Eaj+5Y0lftuGBq+jyRu/md4WnuxqgP1ubdpNCsYEYPxrzVHD8d6g==} - -snapshots: - - '@adraffy/ens-normalize@1.10.0': {} - - '@adraffy/ens-normalize@1.10.1': {} - - '@ampproject/remapping@2.3.0': - dependencies: - '@jridgewell/gen-mapping': 0.3.5 - '@jridgewell/trace-mapping': 0.3.25 - - '@babel/code-frame@7.24.2': - dependencies: - '@babel/highlight': 7.24.5 - picocolors: 1.0.0 - - '@babel/compat-data@7.24.4': {} - - '@babel/core@7.24.5': - dependencies: - '@ampproject/remapping': 2.3.0 - '@babel/code-frame': 7.24.2 - '@babel/generator': 7.24.5 - '@babel/helper-compilation-targets': 7.23.6 - '@babel/helper-module-transforms': 7.24.5(@babel/core@7.24.5) - '@babel/helpers': 7.24.5 - '@babel/parser': 7.24.5 - '@babel/template': 7.24.0 - '@babel/traverse': 7.24.5 - '@babel/types': 7.24.5 - convert-source-map: 2.0.0 - debug: 4.3.4(supports-color@8.1.1) - gensync: 1.0.0-beta.2 - json5: 2.2.3 - semver: 6.3.1 - transitivePeerDependencies: - - supports-color - - '@babel/generator@7.24.5': - dependencies: - '@babel/types': 7.24.5 - '@jridgewell/gen-mapping': 0.3.5 - '@jridgewell/trace-mapping': 0.3.25 - jsesc: 2.5.2 - - '@babel/helper-compilation-targets@7.23.6': - dependencies: - '@babel/compat-data': 7.24.4 - '@babel/helper-validator-option': 7.23.5 - browserslist: 4.23.0 - lru-cache: 5.1.1 - semver: 6.3.1 - - '@babel/helper-environment-visitor@7.22.20': {} - - '@babel/helper-function-name@7.23.0': - dependencies: - '@babel/template': 7.24.0 - '@babel/types': 7.24.5 - - '@babel/helper-hoist-variables@7.22.5': - dependencies: - '@babel/types': 7.24.5 - - '@babel/helper-module-imports@7.24.3': - dependencies: - '@babel/types': 7.24.5 - - '@babel/helper-module-transforms@7.24.5(@babel/core@7.24.5)': - dependencies: - '@babel/core': 7.24.5 - '@babel/helper-environment-visitor': 7.22.20 - '@babel/helper-module-imports': 7.24.3 - '@babel/helper-simple-access': 7.24.5 - '@babel/helper-split-export-declaration': 7.24.5 - '@babel/helper-validator-identifier': 7.24.5 - - '@babel/helper-simple-access@7.24.5': - dependencies: - '@babel/types': 7.24.5 - - '@babel/helper-split-export-declaration@7.24.5': - dependencies: - '@babel/types': 7.24.5 - - '@babel/helper-string-parser@7.24.1': {} - - '@babel/helper-validator-identifier@7.24.5': {} - - '@babel/helper-validator-option@7.23.5': {} - - '@babel/helpers@7.24.5': - dependencies: - '@babel/template': 7.24.0 - '@babel/traverse': 7.24.5 - '@babel/types': 7.24.5 - transitivePeerDependencies: - - supports-color - - '@babel/highlight@7.24.5': - dependencies: - '@babel/helper-validator-identifier': 7.24.5 - chalk: 2.4.2 - js-tokens: 4.0.0 - picocolors: 1.0.0 - - '@babel/parser@7.24.5': - dependencies: - '@babel/types': 7.24.5 - - '@babel/runtime@7.24.5': - dependencies: - regenerator-runtime: 0.14.1 - - '@babel/template@7.24.0': - dependencies: - '@babel/code-frame': 7.24.2 - '@babel/parser': 7.24.5 - '@babel/types': 7.24.5 - - '@babel/traverse@7.24.5': - dependencies: - '@babel/code-frame': 7.24.2 - '@babel/generator': 7.24.5 - '@babel/helper-environment-visitor': 7.22.20 - '@babel/helper-function-name': 7.23.0 - '@babel/helper-hoist-variables': 7.22.5 - '@babel/helper-split-export-declaration': 7.24.5 - '@babel/parser': 7.24.5 - '@babel/types': 7.24.5 - debug: 4.3.4(supports-color@8.1.1) - globals: 11.12.0 - transitivePeerDependencies: - - supports-color - - '@babel/types@7.24.5': - dependencies: - '@babel/helper-string-parser': 7.24.1 - '@babel/helper-validator-identifier': 7.24.5 - to-fast-properties: 2.0.0 - - '@changesets/apply-release-plan@7.0.0': - dependencies: - '@babel/runtime': 7.24.5 - '@changesets/config': 3.0.0 - '@changesets/get-version-range-type': 0.4.0 - '@changesets/git': 3.0.0 - '@changesets/types': 6.0.0 - '@manypkg/get-packages': 1.1.3 - detect-indent: 6.1.0 - fs-extra: 7.0.1 - lodash.startcase: 4.4.0 - outdent: 0.5.0 - prettier: 2.8.8 - resolve-from: 5.0.0 - semver: 7.6.2 - - '@changesets/assemble-release-plan@6.0.0': - dependencies: - '@babel/runtime': 7.24.5 - '@changesets/errors': 0.2.0 - '@changesets/get-dependents-graph': 2.0.0 - '@changesets/types': 6.0.0 - '@manypkg/get-packages': 1.1.3 - semver: 7.6.2 - - '@changesets/changelog-git@0.2.0': - dependencies: - '@changesets/types': 6.0.0 - - '@changesets/cli@2.27.1': - dependencies: - '@babel/runtime': 7.24.5 - '@changesets/apply-release-plan': 7.0.0 - '@changesets/assemble-release-plan': 6.0.0 - '@changesets/changelog-git': 0.2.0 - '@changesets/config': 3.0.0 - '@changesets/errors': 0.2.0 - '@changesets/get-dependents-graph': 2.0.0 - '@changesets/get-release-plan': 4.0.0 - '@changesets/git': 3.0.0 - '@changesets/logger': 0.1.0 - '@changesets/pre': 2.0.0 - '@changesets/read': 0.6.0 - '@changesets/types': 6.0.0 - '@changesets/write': 0.3.0 - '@manypkg/get-packages': 1.1.3 - '@types/semver': 7.5.8 - ansi-colors: 4.1.3 - chalk: 2.4.2 - ci-info: 3.9.0 - enquirer: 2.4.1 - external-editor: 3.1.0 - fs-extra: 7.0.1 - human-id: 1.0.2 - meow: 6.1.1 - outdent: 0.5.0 - p-limit: 2.3.0 - preferred-pm: 3.1.3 - resolve-from: 5.0.0 - semver: 7.6.2 - spawndamnit: 2.0.0 - term-size: 2.2.1 - tty-table: 4.2.3 - - '@changesets/config@3.0.0': - dependencies: - '@changesets/errors': 0.2.0 - '@changesets/get-dependents-graph': 2.0.0 - '@changesets/logger': 0.1.0 - '@changesets/types': 6.0.0 - '@manypkg/get-packages': 1.1.3 - fs-extra: 7.0.1 - micromatch: 4.0.5 - - '@changesets/errors@0.2.0': - dependencies: - extendable-error: 0.1.7 - - '@changesets/get-dependents-graph@2.0.0': - dependencies: - '@changesets/types': 6.0.0 - '@manypkg/get-packages': 1.1.3 - chalk: 2.4.2 - fs-extra: 7.0.1 - semver: 7.6.2 - - '@changesets/get-release-plan@4.0.0': - dependencies: - '@babel/runtime': 7.24.5 - '@changesets/assemble-release-plan': 6.0.0 - '@changesets/config': 3.0.0 - '@changesets/pre': 2.0.0 - '@changesets/read': 0.6.0 - '@changesets/types': 6.0.0 - '@manypkg/get-packages': 1.1.3 - - '@changesets/get-version-range-type@0.4.0': {} - - '@changesets/git@3.0.0': - dependencies: - '@babel/runtime': 7.24.5 - '@changesets/errors': 0.2.0 - '@changesets/types': 6.0.0 - '@manypkg/get-packages': 1.1.3 - is-subdir: 1.2.0 - micromatch: 4.0.5 - spawndamnit: 2.0.0 - - '@changesets/logger@0.1.0': - dependencies: - chalk: 2.4.2 - - '@changesets/parse@0.4.0': - dependencies: - '@changesets/types': 6.0.0 - js-yaml: 3.14.1 - - '@changesets/pre@2.0.0': - dependencies: - '@babel/runtime': 7.24.5 - '@changesets/errors': 0.2.0 - '@changesets/types': 6.0.0 - '@manypkg/get-packages': 1.1.3 - fs-extra: 7.0.1 - - '@changesets/read@0.6.0': - dependencies: - '@babel/runtime': 7.24.5 - '@changesets/git': 3.0.0 - '@changesets/logger': 0.1.0 - '@changesets/parse': 0.4.0 - '@changesets/types': 6.0.0 - chalk: 2.4.2 - fs-extra: 7.0.1 - p-filter: 2.1.0 - - '@changesets/types@4.1.0': {} - - '@changesets/types@6.0.0': {} - - '@changesets/write@0.3.0': - dependencies: - '@babel/runtime': 7.24.5 - '@changesets/types': 6.0.0 - fs-extra: 7.0.1 - human-id: 1.0.2 - prettier: 2.8.8 - - '@cspotcode/source-map-support@0.8.1': - dependencies: - '@jridgewell/trace-mapping': 0.3.9 - - '@ensdomains/address-encoder@0.1.9': - dependencies: - bech32: 1.1.4 - blakejs: 1.2.1 - bn.js: 4.12.0 - bs58: 4.0.1 - crypto-addr-codec: 0.1.8 - nano-base32: 1.0.1 - ripemd160: 2.0.2 - - '@ensdomains/ens@0.4.5': - dependencies: - bluebird: 3.7.2 - eth-ens-namehash: 2.0.8 - solc: 0.4.26 - testrpc: 0.0.1 - web3-utils: 1.10.4 - - '@ensdomains/ensjs@2.1.0(bufferutil@4.0.8)(utf-8-validate@5.0.10)': - dependencies: - '@babel/runtime': 7.24.5 - '@ensdomains/address-encoder': 0.1.9 - '@ensdomains/ens': 0.4.5 - '@ensdomains/resolver': 0.2.4 - content-hash: 2.5.2 - eth-ens-namehash: 2.0.8 - ethers: 5.7.2(bufferutil@4.0.8)(utf-8-validate@5.0.10) - js-sha3: 0.8.0 - transitivePeerDependencies: - - bufferutil - - utf-8-validate - - '@ensdomains/resolver@0.2.4': {} - - '@eslint-community/eslint-utils@4.4.0(eslint@8.57.0)': - dependencies: - eslint: 8.57.0 - eslint-visitor-keys: 3.4.3 - - '@eslint-community/regexpp@4.10.0': {} - - '@eslint/eslintrc@2.1.4': - dependencies: - ajv: 6.12.6 - debug: 4.3.4(supports-color@8.1.1) - espree: 9.6.1 - globals: 13.24.0 - ignore: 5.3.1 - import-fresh: 3.3.0 - js-yaml: 4.1.0 - minimatch: 3.1.2 - strip-json-comments: 3.1.1 - transitivePeerDependencies: - - supports-color - - '@eslint/js@8.57.0': {} - - '@ethereumjs/common@2.5.0': - dependencies: - crc-32: 1.2.2 - ethereumjs-util: 7.1.5 - - '@ethereumjs/common@2.6.5': dependencies: crc-32: 1.2.2 ethereumjs-util: 7.1.5 - '@ethereumjs/rlp@4.0.1': {} + /@ethereumjs/rlp@4.0.1: + resolution: {integrity: sha512-tqsQiBQDQdmPWE1xkkBq4rlSW5QZpLOUJ5RJh2/9fug+q9tnUhuZoVLk7s0scUIKTOzEtR72DFBXI4WiZcMpvw==} + engines: {node: '>=14'} + hasBin: true - '@ethereumjs/tx@3.3.2': + /@ethereumjs/tx@3.3.2: + resolution: {integrity: sha512-6AaJhwg4ucmwTvw/1qLaZUX5miWrwZ4nLOUsKyb/HtzS3BMw/CasKhdi1ims9mBKeK9sOJCH4qGKOBGyJCeeog==} dependencies: '@ethereumjs/common': 2.5.0 ethereumjs-util: 7.1.5 + dev: false - '@ethereumjs/tx@3.5.2': + /@ethereumjs/tx@3.5.2: + resolution: {integrity: sha512-gQDNJWKrSDGu2w7w0PzVXVBNMzb7wwdDOmOqczmhNjqFxFuIbhVJDwiGEnxFNC2/b8ifcZzY7MLcluizohRzNw==} dependencies: '@ethereumjs/common': 2.6.5 ethereumjs-util: 7.1.5 - '@ethereumjs/util@8.1.0': + /@ethereumjs/util@8.1.0: + resolution: {integrity: sha512-zQ0IqbdX8FZ9aw11vP+dZkKDkS+kgIvQPHnSAXzP9pLu+Rfu3D3XEeLbicvoXJTYnhZiPmsZUxgdzXwNKxRPbA==} + engines: {node: '>=14'} dependencies: '@ethereumjs/rlp': 4.0.1 ethereum-cryptography: 2.1.3 micro-ftch: 0.3.1 - '@ethersproject/abi@5.7.0': + /@ethersproject/abi@5.7.0: + resolution: {integrity: sha512-351ktp42TiRcYB3H1OP8yajPeAQstMW/yCFokj/AthP9bLHzQFPlOrxOcwYEDkUAICmOHljvN4K39OMTMUa9RA==} dependencies: '@ethersproject/address': 5.7.0 '@ethersproject/bignumber': 5.7.0 @@ -7734,7 +2482,8 @@ snapshots: '@ethersproject/properties': 5.7.0 '@ethersproject/strings': 5.7.0 - '@ethersproject/abstract-provider@5.7.0': + /@ethersproject/abstract-provider@5.7.0: + resolution: {integrity: sha512-R41c9UkchKCpAqStMYUpdunjo3pkEvZC3FAwZn5S5MGbXoMQOHIdHItezTETxAO5bevtMApSyEhn9+CHcDsWBw==} dependencies: '@ethersproject/bignumber': 5.7.0 '@ethersproject/bytes': 5.7.0 @@ -7744,7 +2493,8 @@ snapshots: '@ethersproject/transactions': 5.7.0 '@ethersproject/web': 5.7.1 - '@ethersproject/abstract-signer@5.7.0': + /@ethersproject/abstract-signer@5.7.0: + resolution: {integrity: sha512-a16V8bq1/Cz+TGCkE2OPMTOUDLS3grCpdjoJCYNnVBbdYEMSgKrU0+B90s8b6H+ByYTBZN7a3g76jdIJi7UfKQ==} dependencies: '@ethersproject/abstract-provider': 5.7.0 '@ethersproject/bignumber': 5.7.0 @@ -7752,15 +2502,18 @@ snapshots: '@ethersproject/logger': 5.7.0 '@ethersproject/properties': 5.7.0 - '@ethersproject/address@5.6.1': + /@ethersproject/address@5.6.1: + resolution: {integrity: sha512-uOgF0kS5MJv9ZvCz7x6T2EXJSzotiybApn4XlOgoTX0xdtyVIJ7pF+6cGPxiEq/dpBiTfMiw7Yc81JcwhSYA0Q==} dependencies: '@ethersproject/bignumber': 5.7.0 '@ethersproject/bytes': 5.7.0 '@ethersproject/keccak256': 5.7.0 '@ethersproject/logger': 5.7.0 '@ethersproject/rlp': 5.7.0 + dev: true - '@ethersproject/address@5.7.0': + /@ethersproject/address@5.7.0: + resolution: {integrity: sha512-9wYhYt7aghVGo758POM5nqcOMaE168Q6aRLJZwUmiqSrAungkG74gSSeKEIR7ukixesdRZGPgVqme6vmxs1fkA==} dependencies: '@ethersproject/bignumber': 5.7.0 '@ethersproject/bytes': 5.7.0 @@ -7768,30 +2521,36 @@ snapshots: '@ethersproject/logger': 5.7.0 '@ethersproject/rlp': 5.7.0 - '@ethersproject/base64@5.7.0': + /@ethersproject/base64@5.7.0: + resolution: {integrity: sha512-Dr8tcHt2mEbsZr/mwTPIQAf3Ai0Bks/7gTw9dSqk1mQvhW3XvRlmDJr/4n+wg1JmCl16NZue17CDh8xb/vZ0sQ==} dependencies: '@ethersproject/bytes': 5.7.0 - '@ethersproject/basex@5.7.0': + /@ethersproject/basex@5.7.0: + resolution: {integrity: sha512-ywlh43GwZLv2Voc2gQVTKBoVQ1mti3d8HK5aMxsfu/nRDnMmNqaSJ3r3n85HBByT8OpoY96SXM1FogC533T4zw==} dependencies: '@ethersproject/bytes': 5.7.0 '@ethersproject/properties': 5.7.0 - '@ethersproject/bignumber@5.7.0': + /@ethersproject/bignumber@5.7.0: + resolution: {integrity: sha512-n1CAdIHRWjSucQO3MC1zPSVgV/6dy/fjL9pMrPP9peL+QxEg9wOsVqwD4+818B6LUEtaXzVHQiuivzRoxPxUGw==} dependencies: '@ethersproject/bytes': 5.7.0 '@ethersproject/logger': 5.7.0 bn.js: 5.2.1 - '@ethersproject/bytes@5.7.0': + /@ethersproject/bytes@5.7.0: + resolution: {integrity: sha512-nsbxwgFXWh9NyYWo+U8atvmMsSdKJprTcICAkvbBffT75qDocbuggBU0SJiVK2MuTrp0q+xvLkTnGMPK1+uA9A==} dependencies: '@ethersproject/logger': 5.7.0 - '@ethersproject/constants@5.7.0': + /@ethersproject/constants@5.7.0: + resolution: {integrity: sha512-DHI+y5dBNvkpYUMiRQyxRBYBefZkJfo70VUkUAsRjcPs47muV9evftfZ0PJVCXYbAiCgght0DtcF9srFQmIgWA==} dependencies: '@ethersproject/bignumber': 5.7.0 - '@ethersproject/contracts@5.7.0': + /@ethersproject/contracts@5.7.0: + resolution: {integrity: sha512-5GJbzEU3X+d33CdfPhcyS+z8MzsTrBGk/sc+G+59+tPa9yFkl6HQ9D6L0QMgNTA9q8dT0XKxxkyp883XsQvbbg==} dependencies: '@ethersproject/abi': 5.7.0 '@ethersproject/abstract-provider': 5.7.0 @@ -7804,7 +2563,8 @@ snapshots: '@ethersproject/properties': 5.7.0 '@ethersproject/transactions': 5.7.0 - '@ethersproject/hash@5.7.0': + /@ethersproject/hash@5.7.0: + resolution: {integrity: sha512-qX5WrQfnah1EFnO5zJv1v46a8HW0+E5xuBBDTwMFZLuVTx0tbU2kkx15NqdjxecrLGatQN9FGQKpb1FKdHCt+g==} dependencies: '@ethersproject/abstract-signer': 5.7.0 '@ethersproject/address': 5.7.0 @@ -7816,7 +2576,8 @@ snapshots: '@ethersproject/properties': 5.7.0 '@ethersproject/strings': 5.7.0 - '@ethersproject/hdnode@5.7.0': + /@ethersproject/hdnode@5.7.0: + resolution: {integrity: sha512-OmyYo9EENBPPf4ERhR7oj6uAtUAhYGqOnIS+jE5pTXvdKBS99ikzq1E7Iv0ZQZ5V36Lqx1qZLeak0Ra16qpeOg==} dependencies: '@ethersproject/abstract-signer': 5.7.0 '@ethersproject/basex': 5.7.0 @@ -7831,7 +2592,8 @@ snapshots: '@ethersproject/transactions': 5.7.0 '@ethersproject/wordlists': 5.7.0 - '@ethersproject/json-wallets@5.7.0': + /@ethersproject/json-wallets@5.7.0: + resolution: {integrity: sha512-8oee5Xgu6+RKgJTkvEMl2wDgSPSAQ9MB/3JYjFV9jlKvcYHUXZC+cQp0njgmxdHkYWn8s6/IqIZYm0YWCjO/0g==} dependencies: '@ethersproject/abstract-signer': 5.7.0 '@ethersproject/address': 5.7.0 @@ -7847,27 +2609,33 @@ snapshots: aes-js: 3.0.0 scrypt-js: 3.0.1 - '@ethersproject/keccak256@5.7.0': + /@ethersproject/keccak256@5.7.0: + resolution: {integrity: sha512-2UcPboeL/iW+pSg6vZ6ydF8tCnv3Iu/8tUmLLzWWGzxWKFFqOBQFLo6uLUv6BDrLgCDfN28RJ/wtByx+jZ4KBg==} dependencies: '@ethersproject/bytes': 5.7.0 js-sha3: 0.8.0 - '@ethersproject/logger@5.7.0': {} + /@ethersproject/logger@5.7.0: + resolution: {integrity: sha512-0odtFdXu/XHtjQXJYA3u9G0G8btm0ND5Cu8M7i5vhEcE8/HmF4Lbdqanwyv4uQTr2tx6b7fQRmgLrsnpQlmnig==} - '@ethersproject/networks@5.7.1': + /@ethersproject/networks@5.7.1: + resolution: {integrity: sha512-n/MufjFYv3yFcUyfhnXotyDlNdFb7onmkSy8aQERi2PjNcnWQ66xXxa3XlS8nCcA8aJKJjIIMNJTC7tu80GwpQ==} dependencies: '@ethersproject/logger': 5.7.0 - '@ethersproject/pbkdf2@5.7.0': + /@ethersproject/pbkdf2@5.7.0: + resolution: {integrity: sha512-oR/dBRZR6GTyaofd86DehG72hY6NpAjhabkhxgr3X2FpJtJuodEl2auADWBZfhDHgVCbu3/H/Ocq2uC6dpNjjw==} dependencies: '@ethersproject/bytes': 5.7.0 '@ethersproject/sha2': 5.7.0 - '@ethersproject/properties@5.7.0': + /@ethersproject/properties@5.7.0: + resolution: {integrity: sha512-J87jy8suntrAkIZtecpxEPxY//szqr1mlBaYlQ0r4RCaiD2hjheqF9s1LVE8vVuJCXisjIP+JgtK/Do54ej4Sw==} dependencies: '@ethersproject/logger': 5.7.0 - '@ethersproject/providers@5.7.2(bufferutil@4.0.8)(utf-8-validate@5.0.10)': + /@ethersproject/providers@5.7.2: + resolution: {integrity: sha512-g34EWZ1WWAVgr4aptGlVBF8mhl3VWjv+8hoAnzStu8Ah22VHBsuGzP17eb6xDVRzw895G4W7vvx60lFFur/1Rg==} dependencies: '@ethersproject/abstract-provider': 5.7.0 '@ethersproject/abstract-signer': 5.7.0 @@ -7888,28 +2656,32 @@ snapshots: '@ethersproject/transactions': 5.7.0 '@ethersproject/web': 5.7.1 bech32: 1.1.4 - ws: 7.4.6(bufferutil@4.0.8)(utf-8-validate@5.0.10) + ws: 7.4.6 transitivePeerDependencies: - bufferutil - utf-8-validate - '@ethersproject/random@5.7.0': + /@ethersproject/random@5.7.0: + resolution: {integrity: sha512-19WjScqRA8IIeWclFme75VMXSBvi4e6InrUNuaR4s5pTF2qNhcGdCUwdxUVGtDDqC00sDLCO93jPQoDUH4HVmQ==} dependencies: '@ethersproject/bytes': 5.7.0 '@ethersproject/logger': 5.7.0 - '@ethersproject/rlp@5.7.0': + /@ethersproject/rlp@5.7.0: + resolution: {integrity: sha512-rBxzX2vK8mVF7b0Tol44t5Tb8gomOHkj5guL+HhzQ1yBh/ydjGnpw6at+X6Iw0Kp3OzzzkcKp8N9r0W4kYSs9w==} dependencies: '@ethersproject/bytes': 5.7.0 '@ethersproject/logger': 5.7.0 - '@ethersproject/sha2@5.7.0': + /@ethersproject/sha2@5.7.0: + resolution: {integrity: sha512-gKlH42riwb3KYp0reLsFTokByAKoJdgFCwI+CCiX/k+Jm2mbNs6oOaCjYQSlI1+XBVejwH2KrmCbMAT/GnRDQw==} dependencies: '@ethersproject/bytes': 5.7.0 '@ethersproject/logger': 5.7.0 hash.js: 1.1.7 - '@ethersproject/signing-key@5.7.0': + /@ethersproject/signing-key@5.7.0: + resolution: {integrity: sha512-MZdy2nL3wO0u7gkB4nA/pEf8lu1TlFswPNmy8AiYkfKTdO6eXBJyUdmHO/ehm/htHw9K/qF8ujnTyUAD+Ry54Q==} dependencies: '@ethersproject/bytes': 5.7.0 '@ethersproject/logger': 5.7.0 @@ -7918,7 +2690,8 @@ snapshots: elliptic: 6.5.4 hash.js: 1.1.7 - '@ethersproject/solidity@5.7.0': + /@ethersproject/solidity@5.7.0: + resolution: {integrity: sha512-HmabMd2Dt/raavyaGukF4XxizWKhKQ24DoLtdNbBmNKUOPqwjsKQSdV9GQtj9CBEea9DlzETlVER1gYeXXBGaA==} dependencies: '@ethersproject/bignumber': 5.7.0 '@ethersproject/bytes': 5.7.0 @@ -7927,13 +2700,15 @@ snapshots: '@ethersproject/sha2': 5.7.0 '@ethersproject/strings': 5.7.0 - '@ethersproject/strings@5.7.0': + /@ethersproject/strings@5.7.0: + resolution: {integrity: sha512-/9nu+lj0YswRNSH0NXYqrh8775XNyEdUQAuf3f+SmOrnVewcJ5SBNAjF7lpgehKi4abvNNXyf+HX86czCdJ8Mg==} dependencies: '@ethersproject/bytes': 5.7.0 '@ethersproject/constants': 5.7.0 '@ethersproject/logger': 5.7.0 - '@ethersproject/transactions@5.7.0': + /@ethersproject/transactions@5.7.0: + resolution: {integrity: sha512-kmcNicCp1lp8qanMTC3RIikGgoJ80ztTyvtsFvCYpSCfkjhD0jZ2LOrnbcuxuToLIUYYf+4XwD1rP+B/erDIhQ==} dependencies: '@ethersproject/address': 5.7.0 '@ethersproject/bignumber': 5.7.0 @@ -7945,13 +2720,15 @@ snapshots: '@ethersproject/rlp': 5.7.0 '@ethersproject/signing-key': 5.7.0 - '@ethersproject/units@5.7.0': + /@ethersproject/units@5.7.0: + resolution: {integrity: sha512-pD3xLMy3SJu9kG5xDGI7+xhTEmGXlEqXU4OfNapmfnxLVY4EMSSRp7j1k7eezutBPH7RBN/7QPnwR7hzNlEFeg==} dependencies: '@ethersproject/bignumber': 5.7.0 '@ethersproject/constants': 5.7.0 '@ethersproject/logger': 5.7.0 - '@ethersproject/wallet@5.7.0': + /@ethersproject/wallet@5.7.0: + resolution: {integrity: sha512-MhmXlJXEJFBFVKrDLB4ZdDzxcBxQ3rLyCkhNqVu3CDYvR97E+8r01UgrI+TI99Le+aYm/in/0vp86guJuM7FCA==} dependencies: '@ethersproject/abstract-provider': 5.7.0 '@ethersproject/abstract-signer': 5.7.0 @@ -7969,7 +2746,8 @@ snapshots: '@ethersproject/transactions': 5.7.0 '@ethersproject/wordlists': 5.7.0 - '@ethersproject/web@5.7.1': + /@ethersproject/web@5.7.1: + resolution: {integrity: sha512-Gueu8lSvyjBWL4cYsWsjh6MtMwM0+H4HvqFPZfB6dV8ctbP9zFAO73VG1cMWae0FLPCtz0peKPpZY8/ugJJX2w==} dependencies: '@ethersproject/base64': 5.7.0 '@ethersproject/bytes': 5.7.0 @@ -7977,7 +2755,8 @@ snapshots: '@ethersproject/properties': 5.7.0 '@ethersproject/strings': 5.7.0 - '@ethersproject/wordlists@5.7.0': + /@ethersproject/wordlists@5.7.0: + resolution: {integrity: sha512-S2TFNJNfHWVHNE6cNDjbVlZ6MgE17MIxMbMg2zv3wn+3XSJGosL1m9ZVv3GXCf/2ymSsQ+hRI5IzoMJTG6aoVA==} dependencies: '@ethersproject/bytes': 5.7.0 '@ethersproject/hash': 5.7.0 @@ -7985,9 +2764,14 @@ snapshots: '@ethersproject/properties': 5.7.0 '@ethersproject/strings': 5.7.0 - '@fastify/busboy@2.1.1': {} + /@fastify/busboy@2.1.1: + resolution: {integrity: sha512-vBZP4NlzfOlerQTnba4aqZoMhE/a9HY7HRqoOPaETQcSQuWEIyZMHGfVu6w9wGtGK5fED5qRs2DteVCjOH60sA==} + engines: {node: '>=14'} + dev: false - '@fvictorio/tabtab@0.0.3': + /@fvictorio/tabtab@0.0.3: + resolution: {integrity: sha512-bT/BSy8MJThrTebqTCjXRnGSgZWthHLigZ4k2AvfNtC79vPyBS1myaxw8gRU6RxIcdDD3HBtm7pOsOoyC086Zg==} + engines: {node: '>=10'} dependencies: debug: 4.3.4(supports-color@8.1.1) enquirer: 2.4.1 @@ -7996,8 +2780,11 @@ snapshots: untildify: 4.0.0 transitivePeerDependencies: - supports-color + dev: false - '@humanwhocodes/config-array@0.11.14': + /@humanwhocodes/config-array@0.11.14: + resolution: {integrity: sha512-3T8LkOmg45BV5FICb15QQMsyUSWrQ8AygVfC7ZG32zOalnqrilm018ZVCw0eapXux8FtA33q8PSRSstjee3jSg==} + engines: {node: '>=10.10.0'} dependencies: '@humanwhocodes/object-schema': 2.0.3 debug: 4.3.4(supports-color@8.1.1) @@ -8005,78 +2792,120 @@ snapshots: transitivePeerDependencies: - supports-color - '@humanwhocodes/module-importer@1.0.1': {} + /@humanwhocodes/module-importer@1.0.1: + resolution: {integrity: sha512-bxveV4V8v5Yb4ncFTT3rPSgZBOpCkjfK0y4oVVVJwIuDVBRMDXrPyXRL988i5ap9m9bnyEEjWfm5WkBmtffLfA==} + engines: {node: '>=12.22'} - '@humanwhocodes/object-schema@2.0.3': {} + /@humanwhocodes/object-schema@2.0.3: + resolution: {integrity: sha512-93zYdMES/c1D69yZiKDBj0V24vqNzB/koF26KPaagAfd3P/4gUlh3Dys5ogAK+Exi9QyzlD8x/08Zt7wIKcDcA==} - '@istanbuljs/load-nyc-config@1.1.0': + /@istanbuljs/load-nyc-config@1.1.0: + resolution: {integrity: sha512-VjeHSlIzpv/NyD3N0YuHfXOPDIixcA1q2ZV98wsMqcYlPmv2n3Yb2lYP9XMElnaFVXg5A7YLTeLu6V84uQDjmQ==} + engines: {node: '>=8'} dependencies: camelcase: 5.3.1 find-up: 4.1.0 get-package-type: 0.1.0 js-yaml: 3.14.1 resolve-from: 5.0.0 + dev: true - '@istanbuljs/schema@0.1.3': {} + /@istanbuljs/schema@0.1.3: + resolution: {integrity: sha512-ZXRY4jNvVgSVQ8DL3LTcakaAtXwTVUxE81hslsyD2AtoXW/wVob10HkOJ1X/pAlcI7D+2YoZKg5do8G/w6RYgA==} + engines: {node: '>=8'} + dev: true - '@jest/schemas@29.6.3': + /@jest/schemas@29.6.3: + resolution: {integrity: sha512-mo5j5X+jIZmJQveBKeS/clAueipV7KgiX1vMgCxam1RNYiqE1w62n0/tJJnHtjW8ZHcQco5gY85jA3mi0L+nSA==} + engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0} dependencies: '@sinclair/typebox': 0.27.8 + dev: true - '@jridgewell/gen-mapping@0.3.5': + /@jridgewell/gen-mapping@0.3.5: + resolution: {integrity: sha512-IzL8ZoEDIBRWEzlCcRhOaCupYyN5gdIK+Q6fbFdPDg6HqX6jpkItn7DFIpW9LQzXG6Df9sA7+OKnq0qlz/GaQg==} + engines: {node: '>=6.0.0'} dependencies: '@jridgewell/set-array': 1.2.1 '@jridgewell/sourcemap-codec': 1.4.15 '@jridgewell/trace-mapping': 0.3.25 + dev: true - '@jridgewell/resolve-uri@3.1.2': {} + /@jridgewell/resolve-uri@3.1.2: + resolution: {integrity: sha512-bRISgCIjP20/tbWSPWMEi54QVPRZExkuD9lJL+UIxUKtwVJA8wW1Trb1jMs1RFXo1CBTNZ/5hpC9QvmKWdopKw==} + engines: {node: '>=6.0.0'} + dev: true - '@jridgewell/set-array@1.2.1': {} + /@jridgewell/set-array@1.2.1: + resolution: {integrity: sha512-R8gLRTZeyp03ymzP/6Lil/28tGeGEzhx1q2k703KGWRAI1VdvPIXdG70VJc2pAMw3NA6JKL5hhFu1sJX0Mnn/A==} + engines: {node: '>=6.0.0'} + dev: true - '@jridgewell/sourcemap-codec@1.4.15': {} + /@jridgewell/sourcemap-codec@1.4.15: + resolution: {integrity: sha512-eF2rxCRulEKXHTRiDrDy6erMYWqNw4LPdQ8UQA4huuxaQsVeRPFl2oM8oDGxMFhJUWZf9McpLtJasDDZb/Bpeg==} + dev: true - '@jridgewell/trace-mapping@0.3.25': + /@jridgewell/trace-mapping@0.3.25: + resolution: {integrity: sha512-vNk6aEwybGtawWmy/PzwnGDOjCkLWSD2wqvjGGAgOAwCGWySYXfYoxt00IJkTF+8Lb57DwOb3Aa0o9CApepiYQ==} dependencies: '@jridgewell/resolve-uri': 3.1.2 '@jridgewell/sourcemap-codec': 1.4.15 + dev: true - '@jridgewell/trace-mapping@0.3.9': + /@jridgewell/trace-mapping@0.3.9: + resolution: {integrity: sha512-3Belt6tdc8bPgAtbcmdtNJlirVoTmEb5e2gC94PnkwEW9jI6CAHUeoG85tjWP5WquqfavoMtMwiG4P926ZKKuQ==} dependencies: '@jridgewell/resolve-uri': 3.1.2 '@jridgewell/sourcemap-codec': 1.4.15 + dev: true - '@json-schema-spec/json-pointer@0.1.2': {} + /@json-schema-spec/json-pointer@0.1.2: + resolution: {integrity: sha512-BYY7IavBjwsWWSmVcMz2A9mKiDD9RvacnsItgmy1xV8cmgbtxFfKmKMtkVpD7pYtkx4mIW4800yZBXueVFIWPw==} + dev: true - '@json-schema-tools/dereferencer@1.5.4': + /@json-schema-tools/dereferencer@1.5.4: + resolution: {integrity: sha512-4cmEdRPIG7WrcSWGRV6HBDCLXEOXGkaOZnopqBxoG24mKYuCHWg4M6N9nioTQyNfKqlPkOPvT4lStQqkPnhLgA==} dependencies: '@json-schema-tools/reference-resolver': 1.2.4 '@json-schema-tools/traverse': 1.10.4 fast-safe-stringify: 2.1.1 transitivePeerDependencies: - encoding + dev: true - '@json-schema-tools/meta-schema@1.6.19': {} + /@json-schema-tools/meta-schema@1.6.19: + resolution: {integrity: sha512-55zuWFW7tr4tf/G5AYmybcPdGOkVAreQbt2JdnogX4I2r/zkxZiimYPJESDf5je9BI2oRveak2p296HzDppeaA==} + dev: true - '@json-schema-tools/reference-resolver@1.2.4': + /@json-schema-tools/reference-resolver@1.2.4: + resolution: {integrity: sha512-Oag20zDuapO6nBQp00k8Rd5sDTb8Gfz9uH43Tf7dHKNx7nHDK/WdeTe7OxkOmLQCL6aS+mCJx1Zv+fZBCD+tzQ==} dependencies: '@json-schema-spec/json-pointer': 0.1.2 isomorphic-fetch: 3.0.0 transitivePeerDependencies: - encoding + dev: true - '@json-schema-tools/referencer@1.1.3': + /@json-schema-tools/referencer@1.1.3: + resolution: {integrity: sha512-p2JU7GpHn1kMyP7gnB2Wnki+OnifsSi75Uj5PxqIg2pT4fqh+BM3rEEZKpaET4xv0ZszG46CCI9eEvs68v2rXg==} dependencies: '@json-schema-tools/traverse': 1.10.4 + dev: true - '@json-schema-tools/titleizer@1.0.8': + /@json-schema-tools/titleizer@1.0.8: + resolution: {integrity: sha512-xgsg7ghVhd+9ZrhpmakNJUMmp+R+1mB6n4zn4iRg6P47GTfN04L/GR7mjC8LvO+XaZxbIzE6EzvHeZ5+nmhjJA==} dependencies: '@json-schema-tools/traverse': 1.10.4 + dev: true - '@json-schema-tools/titleizer@1.0.9': + /@json-schema-tools/titleizer@1.0.9: + resolution: {integrity: sha512-Gwg3YTP5P+3Q+OnvEcthTnsup3AsEkxZCrRLXoWppdjtSzRnsWxtvmpKdGLbVcocPC7Sh3aqJ7Arp85Ii6q2GA==} dependencies: '@json-schema-tools/traverse': 1.10.4 + dev: true - '@json-schema-tools/transpiler@1.10.5': + /@json-schema-tools/transpiler@1.10.5: + resolution: {integrity: sha512-uRm43U8wKWQV8czvvkJYwcUERpQC+azKmqbd7RhV1gWx7s1t0frLtrWqGbXh9xMcgdtF7+Tkiwex48nW5EnX1w==} dependencies: '@json-schema-tools/referencer': 1.1.3 '@json-schema-tools/titleizer': 1.0.9 @@ -8085,21 +2914,29 @@ snapshots: lodash.deburr: 4.1.0 lodash.snakecase: 4.1.1 lodash.trim: 4.5.1 + dev: true - '@json-schema-tools/traverse@1.10.4': {} + /@json-schema-tools/traverse@1.10.4: + resolution: {integrity: sha512-9e42zjhLIxzBONroNC4SGsTqdB877tzwH2S6lqgTav9K24kWJR9vNieeMVSuyqnY8FlclH21D8wsm/tuD9WA9Q==} + dev: true - '@ledgerhq/cryptoassets@9.13.0': + /@ledgerhq/cryptoassets@9.13.0: + resolution: {integrity: sha512-MzGJyc48OGU/FLYGYwEJyfOgbJzlR8XJ9Oo6XpNpNUM1/E5NDqvD72V0D+0uWIJYN3e2NtyqHXShLZDu7P95YA==} dependencies: invariant: 2.2.4 + dev: false - '@ledgerhq/devices@8.3.0': + /@ledgerhq/devices@8.3.0: + resolution: {integrity: sha512-h5Scr+yIae8yjPOViCHLdMjpqn4oC2Whrsq8LinRxe48LEGMdPqSV1yY7+3Ch827wtzNpMv+/ilKnd8rY+rTlg==} dependencies: '@ledgerhq/errors': 6.16.4 '@ledgerhq/logs': 6.12.0 rxjs: 7.8.1 semver: 7.6.2 + dev: false - '@ledgerhq/domain-service@1.1.20(debug@4.3.4)': + /@ledgerhq/domain-service@1.1.20(debug@4.3.4): + resolution: {integrity: sha512-+o1cEZj9HkJeIz2eL3r52tzkOiEKMs9w5aXF+Gy4mrmBjQ3Tw0OY9b69b3jz6PjlEHwAZsDRmcvF1/hSW6ITjw==} dependencies: '@ledgerhq/errors': 6.16.4 '@ledgerhq/logs': 6.12.0 @@ -8110,10 +2947,14 @@ snapshots: react-dom: 18.3.1(react@18.3.1) transitivePeerDependencies: - debug + dev: false - '@ledgerhq/errors@6.16.4': {} + /@ledgerhq/errors@6.16.4: + resolution: {integrity: sha512-M57yFaLYSN+fZCX0E0zUqOmrV6eipK+s5RhijHoUNlHUqrsvUz7iRQgpd5gRgHB5VkIjav7KdaZjKiWGcHovaQ==} + dev: false - '@ledgerhq/hw-app-eth@6.33.6(debug@4.3.4)': + /@ledgerhq/hw-app-eth@6.33.6(debug@4.3.4): + resolution: {integrity: sha512-QzYvr5FNEWWd70Vg04A2i8CY0mtPgJrrX7/KePabjXrR8NjDyJ5Ej8qSQPBTp2dkR4TGiz5Y7+HIcWpdgYzjzg==} dependencies: '@ethersproject/abi': 5.7.0 '@ethersproject/rlp': 5.7.0 @@ -8128,22 +2969,28 @@ snapshots: crypto-js: 4.2.0 transitivePeerDependencies: - debug + dev: false - '@ledgerhq/hw-transport-mocker@6.28.6': + /@ledgerhq/hw-transport-mocker@6.28.6: + resolution: {integrity: sha512-JDO2kqMOTRCQWNZr1KVlyX1AqE6WBzHjJDS3FnSI8Z/Bj2KSc2/1H/4lW6+Ap64yLtlmOW3GchdafFmLgYAgqw==} dependencies: '@ledgerhq/hw-transport': 6.30.6 '@ledgerhq/logs': 6.12.0 rxjs: 7.8.1 + dev: false - '@ledgerhq/hw-transport-node-hid-noevents@6.29.6': + /@ledgerhq/hw-transport-node-hid-noevents@6.29.6: + resolution: {integrity: sha512-H1cGC4TLwSCxve3rbV7qfPJBZfy7VD7k9Czc9HOMDwQ9zHFtaoeiIotIMGjzHjfPtAGauMpAYvrpmEdBBX5sHg==} dependencies: '@ledgerhq/devices': 8.3.0 '@ledgerhq/errors': 6.16.4 '@ledgerhq/hw-transport': 6.30.6 '@ledgerhq/logs': 6.12.0 node-hid: 2.2.0 + dev: false - '@ledgerhq/hw-transport-node-hid@6.28.6': + /@ledgerhq/hw-transport-node-hid@6.28.6: + resolution: {integrity: sha512-USSTOO0zv9XtguWismP7/StnNS/s7Rz0JOGGaBhKe3Bzl7d5XPncUlmOvoNFzzY/QdasEoFs2QId1+ibJG71Vw==} dependencies: '@ledgerhq/devices': 8.3.0 '@ledgerhq/errors': 6.16.4 @@ -8153,29 +3000,39 @@ snapshots: lodash: 4.17.21 node-hid: 2.2.0 usb: 2.9.0 + dev: false - '@ledgerhq/hw-transport@6.30.6': + /@ledgerhq/hw-transport@6.30.6: + resolution: {integrity: sha512-fT0Z4IywiuJuZrZE/+W0blkV5UCotDPFTYKLkKCLzYzuE6javva7D/ajRaIeR+hZ4kTmKF4EqnsmDCXwElez+w==} dependencies: '@ledgerhq/devices': 8.3.0 '@ledgerhq/errors': 6.16.4 '@ledgerhq/logs': 6.12.0 events: 3.3.0 + dev: false - '@ledgerhq/logs@6.12.0': {} + /@ledgerhq/logs@6.12.0: + resolution: {integrity: sha512-ExDoj1QV5eC6TEbMdLUMMk9cfvNKhhv5gXol4SmULRVCx/3iyCPhJ74nsb3S0Vb+/f+XujBEj3vQn5+cwS0fNA==} + dev: false - '@ledgerhq/types-live@6.46.0': + /@ledgerhq/types-live@6.46.0: + resolution: {integrity: sha512-UtI4qm13wJIv9FB/0g6Hi1NijU7PuJEGetqGQxELlKEOmjubXa52EfKVA9IVOngL25m6U8i7jzluwLsHiN2uQQ==} dependencies: bignumber.js: 9.1.2 rxjs: 7.8.1 + dev: false - '@manypkg/find-root@1.1.0': + /@manypkg/find-root@1.1.0: + resolution: {integrity: sha512-mki5uBvhHzO8kYYix/WRy2WX8S3B5wdVSc9D6KcU5lQNglP2yt58/VfLuAK49glRXChosY8ap2oJ1qgma3GUVA==} dependencies: '@babel/runtime': 7.24.5 '@types/node': 12.20.55 find-up: 4.1.0 fs-extra: 8.1.0 + dev: true - '@manypkg/get-packages@1.1.3': + /@manypkg/get-packages@1.1.3: + resolution: {integrity: sha512-fo+QhuU3qE/2TQMQmbVMqaQ6EWbMhi4ABWP+O4AM1NqPBuy0OrApV5LO6BrrgnhtAHS2NH6RrVk9OL181tTi8A==} dependencies: '@babel/runtime': 7.24.5 '@changesets/types': 4.1.0 @@ -8183,60 +3040,103 @@ snapshots: fs-extra: 8.1.0 globby: 11.1.0 read-yaml-file: 1.1.0 + dev: true - '@metamask/eth-sig-util@4.0.1': + /@metamask/eth-sig-util@4.0.1: + resolution: {integrity: sha512-tghyZKLHZjcdlDqCA3gNZmLeR0XvOE9U1qoQO9ohyAZT6Pya+H9vkBPcsyXytmYLNgVoin7CKCmweo/R43V+tQ==} + engines: {node: '>=12.0.0'} dependencies: ethereumjs-abi: 0.6.8 ethereumjs-util: 6.2.1 ethjs-util: 0.1.6 tweetnacl: 1.0.3 tweetnacl-util: 0.15.1 + dev: false - '@noble/curves@1.2.0': + /@noble/curves@1.2.0: + resolution: {integrity: sha512-oYclrNgRaM9SsBUBVbb8M6DTV7ZHRTKugureoYEncY5c65HOmRzvSiTE3y5CYaPYJA/GVkrhXEoF0M3Ya9PMnw==} dependencies: '@noble/hashes': 1.3.2 - '@noble/curves@1.3.0': + /@noble/curves@1.3.0: + resolution: {integrity: sha512-t01iSXPuN+Eqzb4eBX0S5oubSqXbK/xXa1Ne18Hj8f9pStxztHCE2gfboSp/dZRLSqfuLpRK2nDXDK+W9puocA==} dependencies: '@noble/hashes': 1.3.3 - '@noble/hashes@1.2.0': {} + /@noble/hashes@1.2.0: + resolution: {integrity: sha512-FZfhjEDbT5GRswV3C6uvLPHMiVD6lQBmpoX5+eSiPaMTXte/IKqI5dykDxzZB/WBeK/CDuQRBWarPdi3FNY2zQ==} - '@noble/hashes@1.3.2': {} + /@noble/hashes@1.3.2: + resolution: {integrity: sha512-MVC8EAQp7MvEcm30KWENFjgR+Mkmf+D189XJTkFIlwohU5hcBbn1ZkKq7KVTi2Hme3PMGF390DaL52beVrIihQ==} + engines: {node: '>= 16'} - '@noble/hashes@1.3.3': {} + /@noble/hashes@1.3.3: + resolution: {integrity: sha512-V7/fPHgl+jsVPXqqeOzT8egNj2iBIVt+ECeMMG8TdcnTikP3oaBtUVqpT/gYCR68aEBJSF+XbYUxStjbFMqIIA==} + engines: {node: '>= 16'} - '@noble/hashes@1.4.0': {} + /@noble/hashes@1.4.0: + resolution: {integrity: sha512-V1JJ1WTRUqHHrOSh597hURcMqVKVGL/ea3kv0gSnEdsEZ0/+VyPghM1lMNGc00z7CIQorSvbKpuJkxvuHbvdbg==} + engines: {node: '>= 16'} - '@noble/secp256k1@1.7.1': {} + /@noble/secp256k1@1.7.1: + resolution: {integrity: sha512-hOUk6AyBFmqVrv7k5WAw/LpszxVbj9gGN4JRkIX52fdFAj1UA61KXmZDvqVEm+pOyec3+fIeZB02LYa/pWOArw==} - '@nodelib/fs.scandir@2.1.5': + /@nodelib/fs.scandir@2.1.5: + resolution: {integrity: sha512-vq24Bq3ym5HEQm2NKCr3yXDwjc7vTsEThRDnkp2DK9p1uqLR+DHurm/NOTo0KG7HYHU7eppKZj3MyqYuMBf62g==} + engines: {node: '>= 8'} dependencies: '@nodelib/fs.stat': 2.0.5 run-parallel: 1.2.0 - '@nodelib/fs.stat@2.0.5': {} + /@nodelib/fs.stat@2.0.5: + resolution: {integrity: sha512-RkhPPp2zrqDAQA/2jNhnztcPAlv64XdhIp7a7454A5ovI7Bukxgt7MX7udwAu3zg1DcpPU0rz3VV1SeaqvY4+A==} + engines: {node: '>= 8'} - '@nodelib/fs.walk@1.2.8': + /@nodelib/fs.walk@1.2.8: + resolution: {integrity: sha512-oGB+UxlgWcgQkgwo8GcEGwemoTFt3FIO9ababBmaGwXIoBKZ+GTy0pP185beGg7Llih/NSHSV2XAs1lnznocSg==} + engines: {node: '>= 8'} dependencies: '@nodelib/fs.scandir': 2.1.5 fastq: 1.17.1 - '@nomicfoundation/edr-darwin-arm64@0.3.8': {} + /@nomicfoundation/edr-darwin-arm64@0.3.8: + resolution: {integrity: sha512-eB0leCexS8sQEmfyD72cdvLj9djkBzQGP4wSQw6SNf2I4Sw4Cnzb3d45caG2FqFFjbvfqL0t+badUUIceqQuMw==} + engines: {node: '>= 18'} + dev: false - '@nomicfoundation/edr-darwin-x64@0.3.8': {} + /@nomicfoundation/edr-darwin-x64@0.3.8: + resolution: {integrity: sha512-JksVCS1N5ClwVF14EvO25HCQ+Laljh/KRfHERMVAC9ZwPbTuAd/9BtKvToCBi29uCHWqsXMI4lxCApYQv2nznw==} + engines: {node: '>= 18'} + dev: false - '@nomicfoundation/edr-linux-arm64-gnu@0.3.8': {} + /@nomicfoundation/edr-linux-arm64-gnu@0.3.8: + resolution: {integrity: sha512-raCE+fOeNXhVBLUo87cgsHSGvYYRB6arih4eG6B9KGACWK5Veebtm9xtKeiD8YCsdUlUfat6F7ibpeNm91fpsA==} + engines: {node: '>= 18'} + dev: false - '@nomicfoundation/edr-linux-arm64-musl@0.3.8': {} + /@nomicfoundation/edr-linux-arm64-musl@0.3.8: + resolution: {integrity: sha512-PwiDp4wBZWMCIy29eKkv8moTKRrpiSDlrc+GQMSZLhOAm8T33JKKXPwD/2EbplbhCygJDGXZdtEKl9x9PaH66A==} + engines: {node: '>= 18'} + dev: false - '@nomicfoundation/edr-linux-x64-gnu@0.3.8': {} + /@nomicfoundation/edr-linux-x64-gnu@0.3.8: + resolution: {integrity: sha512-6AcvA/XKoipGap5jJmQ9Y6yT7Uf39D9lu2hBcDCXnXbMcXaDGw4mn1/L4R63D+9VGZyu1PqlcJixCUZlGGIWlg==} + engines: {node: '>= 18'} + dev: false - '@nomicfoundation/edr-linux-x64-musl@0.3.8': {} + /@nomicfoundation/edr-linux-x64-musl@0.3.8: + resolution: {integrity: sha512-cxb0sEmZjlwhYWO28sPsV64VDx31ekskhC1IsDXU1p9ntjHSJRmW4KEIqJ2O3QwJap/kLKfMS6TckvY10gjc6w==} + engines: {node: '>= 18'} + dev: false - '@nomicfoundation/edr-win32-x64-msvc@0.3.8': {} + /@nomicfoundation/edr-win32-x64-msvc@0.3.8: + resolution: {integrity: sha512-yVuVPqRRNLZk7TbBMkKw7lzCvI8XO8fNTPTYxymGadjr9rEGRuNTU1yBXjfJ59I1jJU/X2TSkRk1OFX0P5tpZQ==} + engines: {node: '>= 18'} + dev: false - '@nomicfoundation/edr@0.3.8': + /@nomicfoundation/edr@0.3.8: + resolution: {integrity: sha512-u2UJ5QpznSHVkZRh6ePWoeVb6kmPrrqh08gCnZ9FHlJV9CITqlrTQHJkacd+INH31jx88pTAJnxePE4XAiH5qg==} + engines: {node: '>= 18'} dependencies: '@nomicfoundation/edr-darwin-arm64': 0.3.8 '@nomicfoundation/edr-darwin-x64': 0.3.8 @@ -8245,8 +3145,11 @@ snapshots: '@nomicfoundation/edr-linux-x64-gnu': 0.3.8 '@nomicfoundation/edr-linux-x64-musl': 0.3.8 '@nomicfoundation/edr-win32-x64-msvc': 0.3.8 + dev: false - '@nomicfoundation/ethereumjs-block@5.0.4': + /@nomicfoundation/ethereumjs-block@5.0.4: + resolution: {integrity: sha512-AcyacJ9eX/uPEvqsPiB+WO1ymE+kyH48qGGiGV+YTojdtas8itUTW5dehDSOXEEItWGbbzEJ4PRqnQZlWaPvDw==} + engines: {node: '>=18'} dependencies: '@nomicfoundation/ethereumjs-common': 4.0.4 '@nomicfoundation/ethereumjs-rlp': 5.0.4 @@ -8256,16 +3159,23 @@ snapshots: ethereum-cryptography: 0.1.3 transitivePeerDependencies: - c-kzg + dev: true - '@nomicfoundation/ethereumjs-common@4.0.4': + /@nomicfoundation/ethereumjs-common@4.0.4: + resolution: {integrity: sha512-9Rgb658lcWsjiicr5GzNCjI1llow/7r0k50dLL95OJ+6iZJcVbi15r3Y0xh2cIO+zgX0WIHcbzIu6FeQf9KPrg==} dependencies: '@nomicfoundation/ethereumjs-util': 9.0.4 transitivePeerDependencies: - c-kzg - '@nomicfoundation/ethereumjs-rlp@5.0.4': {} + /@nomicfoundation/ethereumjs-rlp@5.0.4: + resolution: {integrity: sha512-8H1S3s8F6QueOc/X92SdrA4RDenpiAEqMg5vJH99kcQaCy/a3Q6fgseo75mgWlbanGJXSlAPtnCeG9jvfTYXlw==} + engines: {node: '>=18'} + hasBin: true - '@nomicfoundation/ethereumjs-trie@6.0.4': + /@nomicfoundation/ethereumjs-trie@6.0.4: + resolution: {integrity: sha512-3nSwQiFMvr2VFe/aZUyinuohYvtytUqZCUCvIWcPJ/BwJH6oQdZRB42aNFBJ/8nAh2s3OcroWpBLskzW01mFKA==} + engines: {node: '>=18'} dependencies: '@nomicfoundation/ethereumjs-rlp': 5.0.4 '@nomicfoundation/ethereumjs-util': 9.0.4 @@ -8275,39 +3185,74 @@ snapshots: readable-stream: 3.6.2 transitivePeerDependencies: - c-kzg + dev: true - '@nomicfoundation/ethereumjs-tx@5.0.4': + /@nomicfoundation/ethereumjs-tx@5.0.4: + resolution: {integrity: sha512-Xjv8wAKJGMrP1f0n2PeyfFCCojHd7iS3s/Ab7qzF1S64kxZ8Z22LCMynArYsVqiFx6rzYy548HNVEyI+AYN/kw==} + engines: {node: '>=18'} + peerDependencies: + c-kzg: ^2.1.2 + peerDependenciesMeta: + c-kzg: + optional: true dependencies: '@nomicfoundation/ethereumjs-common': 4.0.4 '@nomicfoundation/ethereumjs-rlp': 5.0.4 '@nomicfoundation/ethereumjs-util': 9.0.4 ethereum-cryptography: 0.1.3 - '@nomicfoundation/ethereumjs-util@9.0.4': + /@nomicfoundation/ethereumjs-util@9.0.4: + resolution: {integrity: sha512-sLOzjnSrlx9Bb9EFNtHzK/FJFsfg2re6bsGqinFinH1gCqVfz9YYlXiMWwDM4C/L4ywuHFCYwfKTVr/QHQcU0Q==} + engines: {node: '>=18'} + peerDependencies: + c-kzg: ^2.1.2 + peerDependenciesMeta: + c-kzg: + optional: true dependencies: '@nomicfoundation/ethereumjs-rlp': 5.0.4 ethereum-cryptography: 0.1.3 - '@nomicfoundation/hardhat-ignition-ethers@0.15.2(@nomicfoundation/hardhat-ethers@packages+hardhat-ethers)(@nomicfoundation/hardhat-ignition@0.15.2(@nomicfoundation/hardhat-verify@packages+hardhat-verify)(bufferutil@4.0.8)(hardhat@packages+hardhat-core)(utf-8-validate@5.0.10))(@nomicfoundation/ignition-core@0.15.2(bufferutil@4.0.8)(utf-8-validate@5.0.10))(ethers@6.12.1(bufferutil@4.0.8)(utf-8-validate@5.0.10))(hardhat@packages+hardhat-core)': + /@nomicfoundation/hardhat-ignition-ethers@0.15.2(@nomicfoundation/hardhat-ethers@packages+hardhat-ethers)(@nomicfoundation/hardhat-ignition@0.15.2)(@nomicfoundation/ignition-core@0.15.2)(ethers@6.12.1)(hardhat@packages+hardhat-core): + resolution: {integrity: sha512-rXkEpzl4ZNGfrht6ZFO+37dQvL+byrJaX7pNeSFzdKKqhEe4oboRwDWaBohQO+pCn837Qh/86xwwOFoGEv2+hg==} + peerDependencies: + '@nomicfoundation/hardhat-ethers': ^3.0.4 + '@nomicfoundation/hardhat-ignition': ^0.15.2 + '@nomicfoundation/ignition-core': ^0.15.2 + ethers: ^6.7.0 + hardhat: ^2.18.0 dependencies: '@nomicfoundation/hardhat-ethers': link:packages/hardhat-ethers - '@nomicfoundation/hardhat-ignition': 0.15.2(@nomicfoundation/hardhat-verify@packages+hardhat-verify)(bufferutil@4.0.8)(hardhat@packages+hardhat-core)(utf-8-validate@5.0.10) - '@nomicfoundation/ignition-core': 0.15.2(bufferutil@4.0.8)(utf-8-validate@5.0.10) - ethers: 6.12.1(bufferutil@4.0.8)(utf-8-validate@5.0.10) + '@nomicfoundation/hardhat-ignition': 0.15.2(@nomicfoundation/hardhat-verify@packages+hardhat-verify)(hardhat@packages+hardhat-core) + '@nomicfoundation/ignition-core': 0.15.2 + ethers: 6.12.1 hardhat: link:packages/hardhat-core + dev: true - '@nomicfoundation/hardhat-ignition-viem@0.15.2(@nomicfoundation/hardhat-ignition@0.15.2(@nomicfoundation/hardhat-verify@packages+hardhat-verify)(bufferutil@4.0.8)(hardhat@packages+hardhat-core)(utf-8-validate@5.0.10))(@nomicfoundation/hardhat-viem@packages+hardhat-viem)(@nomicfoundation/ignition-core@0.15.2(bufferutil@4.0.8)(utf-8-validate@5.0.10))(hardhat@packages+hardhat-core)(viem@2.10.3(bufferutil@4.0.8)(typescript@5.0.4)(utf-8-validate@5.0.10)(zod@3.23.8))': + /@nomicfoundation/hardhat-ignition-viem@0.15.2(@nomicfoundation/hardhat-ignition@0.15.2)(@nomicfoundation/hardhat-viem@packages+hardhat-viem)(@nomicfoundation/ignition-core@0.15.2)(hardhat@packages+hardhat-core)(viem@2.10.3): + resolution: {integrity: sha512-iYmw9vJLXY1Tum0idnNsrsEmuvHsRDVJcudgzaMY6sA2nLLhJDSReK2gVZdtx3rdfJz4QRhG2+h2s3T+Rzv0TQ==} + peerDependencies: + '@nomicfoundation/hardhat-ignition': ^0.15.2 + '@nomicfoundation/hardhat-viem': ^2.0.0 + '@nomicfoundation/ignition-core': ^0.15.2 + hardhat: ^2.18.0 + viem: ^2.7.6 dependencies: - '@nomicfoundation/hardhat-ignition': 0.15.2(@nomicfoundation/hardhat-verify@packages+hardhat-verify)(bufferutil@4.0.8)(hardhat@packages+hardhat-core)(utf-8-validate@5.0.10) + '@nomicfoundation/hardhat-ignition': 0.15.2(@nomicfoundation/hardhat-verify@packages+hardhat-verify)(hardhat@packages+hardhat-core) '@nomicfoundation/hardhat-viem': link:packages/hardhat-viem - '@nomicfoundation/ignition-core': 0.15.2(bufferutil@4.0.8)(utf-8-validate@5.0.10) + '@nomicfoundation/ignition-core': 0.15.2 hardhat: link:packages/hardhat-core - viem: 2.10.3(bufferutil@4.0.8)(typescript@5.0.4)(utf-8-validate@5.0.10)(zod@3.23.8) + viem: 2.10.3(typescript@5.0.4) + dev: true - '@nomicfoundation/hardhat-ignition@0.15.2(@nomicfoundation/hardhat-verify@packages+hardhat-verify)(bufferutil@4.0.8)(hardhat@packages+hardhat-core)(utf-8-validate@5.0.10)': + /@nomicfoundation/hardhat-ignition@0.15.2(@nomicfoundation/hardhat-verify@packages+hardhat-verify)(hardhat@packages+hardhat-core): + resolution: {integrity: sha512-tdI+D+GwP8qBt3/sq0hGKk46lAfKnNj3ZtqxrNinOnQUfc3f9qXgZDFqWT2JudsmuQcuHFbn1FQ1zoDvjUVjRA==} + peerDependencies: + '@nomicfoundation/hardhat-verify': ^2.0.1 + hardhat: ^2.18.0 dependencies: '@nomicfoundation/hardhat-verify': link:packages/hardhat-verify - '@nomicfoundation/ignition-core': 0.15.2(bufferutil@4.0.8)(utf-8-validate@5.0.10) + '@nomicfoundation/ignition-core': 0.15.2 '@nomicfoundation/ignition-ui': 0.15.2 chalk: 4.1.2 debug: 4.3.4(supports-color@8.1.1) @@ -8318,14 +3263,16 @@ snapshots: - bufferutil - supports-color - utf-8-validate + dev: true - '@nomicfoundation/ignition-core@0.15.2(bufferutil@4.0.8)(utf-8-validate@5.0.10)': + /@nomicfoundation/ignition-core@0.15.2: + resolution: {integrity: sha512-6kchZOBh6zSl0BgG1bs6+ZbNYlGjeH22yi72mgeOa0oNOYFqCpka9a4FEYv0gfcphsMMmKTMlxadanf02ZoE4w==} dependencies: '@ethersproject/address': 5.6.1 '@nomicfoundation/solidity-analyzer': 0.1.1 cbor: 9.0.2 debug: 4.3.4(supports-color@8.1.1) - ethers: 6.12.1(bufferutil@4.0.8)(utf-8-validate@5.0.10) + ethers: 6.12.1 fs-extra: 10.1.0 immer: 10.0.2 lodash: 4.17.21 @@ -8334,40 +3281,95 @@ snapshots: - bufferutil - supports-color - utf-8-validate + dev: true - '@nomicfoundation/ignition-ui@0.15.2': {} + /@nomicfoundation/ignition-ui@0.15.2: + resolution: {integrity: sha512-NEX2prbfLEm45KbnBS0imvSgQgwLTgmT8zD3rAPmcIFZx+tLG4lKKw99k6EgEwmKwBiaO2zQMmt+FNoF7xGaiQ==} + dev: true - '@nomicfoundation/solidity-analyzer-darwin-arm64@0.1.1': + /@nomicfoundation/solidity-analyzer-darwin-arm64@0.1.1: + resolution: {integrity: sha512-KcTodaQw8ivDZyF+D76FokN/HdpgGpfjc/gFCImdLUyqB6eSWVaZPazMbeAjmfhx3R0zm/NYVzxwAokFKgrc0w==} + engines: {node: '>= 10'} + cpu: [arm64] + os: [darwin] + requiresBuild: true optional: true - '@nomicfoundation/solidity-analyzer-darwin-x64@0.1.1': + /@nomicfoundation/solidity-analyzer-darwin-x64@0.1.1: + resolution: {integrity: sha512-XhQG4BaJE6cIbjAVtzGOGbK3sn1BO9W29uhk9J8y8fZF1DYz0Doj8QDMfpMu+A6TjPDs61lbsmeYodIDnfveSA==} + engines: {node: '>= 10'} + cpu: [x64] + os: [darwin] + requiresBuild: true optional: true - '@nomicfoundation/solidity-analyzer-freebsd-x64@0.1.1': + /@nomicfoundation/solidity-analyzer-freebsd-x64@0.1.1: + resolution: {integrity: sha512-GHF1VKRdHW3G8CndkwdaeLkVBi5A9u2jwtlS7SLhBc8b5U/GcoL39Q+1CSO3hYqePNP+eV5YI7Zgm0ea6kMHoA==} + engines: {node: '>= 10'} + cpu: [x64] + os: [freebsd] + requiresBuild: true optional: true - '@nomicfoundation/solidity-analyzer-linux-arm64-gnu@0.1.1': + /@nomicfoundation/solidity-analyzer-linux-arm64-gnu@0.1.1: + resolution: {integrity: sha512-g4Cv2fO37ZsUENQ2vwPnZc2zRenHyAxHcyBjKcjaSmmkKrFr64yvzeNO8S3GBFCo90rfochLs99wFVGT/0owpg==} + engines: {node: '>= 10'} + cpu: [arm64] + os: [linux] + requiresBuild: true optional: true - '@nomicfoundation/solidity-analyzer-linux-arm64-musl@0.1.1': + /@nomicfoundation/solidity-analyzer-linux-arm64-musl@0.1.1: + resolution: {integrity: sha512-WJ3CE5Oek25OGE3WwzK7oaopY8xMw9Lhb0mlYuJl/maZVo+WtP36XoQTb7bW/i8aAdHW5Z+BqrHMux23pvxG3w==} + engines: {node: '>= 10'} + cpu: [arm64] + os: [linux] + requiresBuild: true optional: true - '@nomicfoundation/solidity-analyzer-linux-x64-gnu@0.1.1': + /@nomicfoundation/solidity-analyzer-linux-x64-gnu@0.1.1: + resolution: {integrity: sha512-5WN7leSr5fkUBBjE4f3wKENUy9HQStu7HmWqbtknfXkkil+eNWiBV275IOlpXku7v3uLsXTOKpnnGHJYI2qsdA==} + engines: {node: '>= 10'} + cpu: [x64] + os: [linux] + requiresBuild: true optional: true - '@nomicfoundation/solidity-analyzer-linux-x64-musl@0.1.1': + /@nomicfoundation/solidity-analyzer-linux-x64-musl@0.1.1: + resolution: {integrity: sha512-KdYMkJOq0SYPQMmErv/63CwGwMm5XHenEna9X9aB8mQmhDBrYrlAOSsIPgFCUSL0hjxE3xHP65/EPXR/InD2+w==} + engines: {node: '>= 10'} + cpu: [x64] + os: [linux] + requiresBuild: true optional: true - '@nomicfoundation/solidity-analyzer-win32-arm64-msvc@0.1.1': + /@nomicfoundation/solidity-analyzer-win32-arm64-msvc@0.1.1: + resolution: {integrity: sha512-VFZASBfl4qiBYwW5xeY20exWhmv6ww9sWu/krWSesv3q5hA0o1JuzmPHR4LPN6SUZj5vcqci0O6JOL8BPw+APg==} + engines: {node: '>= 10'} + cpu: [arm64] + os: [win32] + requiresBuild: true optional: true - '@nomicfoundation/solidity-analyzer-win32-ia32-msvc@0.1.1': + /@nomicfoundation/solidity-analyzer-win32-ia32-msvc@0.1.1: + resolution: {integrity: sha512-JnFkYuyCSA70j6Si6cS1A9Gh1aHTEb8kOTBApp/c7NRTFGNMH8eaInKlyuuiIbvYFhlXW4LicqyYuWNNq9hkpQ==} + engines: {node: '>= 10'} + cpu: [ia32] + os: [win32] + requiresBuild: true optional: true - '@nomicfoundation/solidity-analyzer-win32-x64-msvc@0.1.1': + /@nomicfoundation/solidity-analyzer-win32-x64-msvc@0.1.1: + resolution: {integrity: sha512-HrVJr6+WjIXGnw3Q9u6KQcbZCtk0caVWhCdFADySvRyUxJ8PnzlaP+MhwNE8oyT8OZ6ejHBRrrgjSqDCFXGirw==} + engines: {node: '>= 10'} + cpu: [x64] + os: [win32] + requiresBuild: true optional: true - '@nomicfoundation/solidity-analyzer@0.1.1': + /@nomicfoundation/solidity-analyzer@0.1.1: + resolution: {integrity: sha512-1LMtXj1puAxyFusBgUIy5pZk3073cNXYnXUpuNKFghHbIit/xZgbk0AokpUADbNm3gyD6bFWl3LRFh3dhVdREg==} + engines: {node: '>= 12'} optionalDependencies: '@nomicfoundation/solidity-analyzer-darwin-arm64': 0.1.1 '@nomicfoundation/solidity-analyzer-darwin-x64': 0.1.1 @@ -8380,32 +3382,43 @@ snapshots: '@nomicfoundation/solidity-analyzer-win32-ia32-msvc': 0.1.1 '@nomicfoundation/solidity-analyzer-win32-x64-msvc': 0.1.1 - '@nomiclabs/truffle-contract@4.5.10(bufferutil@4.0.8)(utf-8-validate@5.0.10)(web3-core-helpers@1.10.4)(web3-core-promievent@1.10.4)(web3-eth-abi@4.2.1(typescript@5.0.4)(zod@3.23.8))(web3-utils@4.2.3)(web3@1.10.4(bufferutil@4.0.8)(utf-8-validate@5.0.10))': + /@nomiclabs/truffle-contract@4.5.10(web3-core-helpers@1.10.3)(web3-core-promievent@1.10.3)(web3-eth-abi@1.10.4)(web3-utils@1.10.4)(web3@1.10.4): + resolution: {integrity: sha512-nF/6InFV+0hUvutyFgsdOMCoYlr//2fJbRER4itxYtQtc4/O1biTwZIKRu+5l2J5Sq6LU2WX7vZHtDgQdhWxIQ==} + peerDependencies: + web3: ^1.2.1 + web3-core-helpers: ^1.2.1 + web3-core-promievent: ^1.2.1 + web3-eth-abi: ^1.2.1 + web3-utils: ^1.2.1 dependencies: - '@ensdomains/ensjs': 2.1.0(bufferutil@4.0.8)(utf-8-validate@5.0.10) + '@ensdomains/ensjs': 2.1.0 '@truffle/blockchain-utils': 0.1.9 '@truffle/contract-schema': 3.4.16 '@truffle/debug-utils': 6.0.57 '@truffle/error': 0.1.1 - '@truffle/interface-adapter': 0.5.37(bufferutil@4.0.8)(utf-8-validate@5.0.10) + '@truffle/interface-adapter': 0.5.37 bignumber.js: 7.2.1 - ethereum-ens: 0.8.0(bufferutil@4.0.8)(utf-8-validate@5.0.10) + ethereum-ens: 0.8.0 ethers: 4.0.49 source-map-support: 0.5.21 - web3: 1.10.4(bufferutil@4.0.8)(utf-8-validate@5.0.10) - web3-core-helpers: 1.10.4 - web3-core-promievent: 1.10.4 - web3-eth-abi: 4.2.1(typescript@5.0.4)(zod@3.23.8) - web3-utils: 4.2.3 + web3: 1.10.4 + web3-core-helpers: 1.10.3 + web3-core-promievent: 1.10.3 + web3-eth-abi: 1.10.4 + web3-utils: 1.10.4 transitivePeerDependencies: - bufferutil - encoding - supports-color - utf-8-validate + dev: false - '@open-rpc/meta-schema@1.14.2': {} + /@open-rpc/meta-schema@1.14.2: + resolution: {integrity: sha512-vD4Nbkrb7wYFRcSQf+j228LwOy1C6/KKpy5NADlpMElGrAWPRxhTa2yTi6xG+x88OHzg2+cydQ0GAD6o40KUcg==} + dev: true - '@open-rpc/schema-utils-js@1.16.1': + /@open-rpc/schema-utils-js@1.16.1: + resolution: {integrity: sha512-8D4OgBnHDAv7JeaYZ5v7SL4yR0YLLO4WLTWtdR8vmqSqvX3SvPzSsGYv06zqm9z1Lhm563MAcuearrc8g9eJ4w==} dependencies: '@json-schema-tools/dereferencer': 1.5.4 '@json-schema-tools/meta-schema': 1.6.19 @@ -8419,8 +3432,11 @@ snapshots: isomorphic-fetch: 3.0.0 transitivePeerDependencies: - encoding + dev: true - '@open-rpc/typings@1.12.3': + /@open-rpc/typings@1.12.3: + resolution: {integrity: sha512-YxoC0WBMmxOAYNk9T6sFlOsy2H3YNnXJKFwkRb5GWg1ixOOEFm/3AYOciI/4Ieq08xNzjPhIz6XfC4u4fsmAWg==} + hasBin: true dependencies: '@json-schema-tools/titleizer': 1.0.8 '@json-schema-tools/transpiler': 1.10.5 @@ -8429,63 +3445,84 @@ snapshots: fs-extra: 10.1.0 transitivePeerDependencies: - encoding + dev: true - '@scure/base@1.1.6': {} + /@scure/base@1.1.6: + resolution: {integrity: sha512-ok9AWwhcgYuGG3Zfhyqg+zwl+Wn5uE+dwC0NV/2qQkx4dABbb/bx96vWu8NSj+BNjjSjno+JRYRjle1jV08k3g==} - '@scure/bip32@1.1.5': + /@scure/bip32@1.1.5: + resolution: {integrity: sha512-XyNh1rB0SkEqd3tXcXMi+Xe1fvg+kUIcoRIEujP1Jgv7DqW2r9lg3Ah0NkFaCs9sTkQAQA8kw7xiRXzENi9Rtw==} dependencies: '@noble/hashes': 1.2.0 '@noble/secp256k1': 1.7.1 '@scure/base': 1.1.6 - '@scure/bip32@1.3.2': + /@scure/bip32@1.3.2: + resolution: {integrity: sha512-N1ZhksgwD3OBlwTv3R6KFEcPojl/W4ElJOeCZdi+vuI5QmTFwLq3OFf2zd2ROpKvxFdgZ6hUpb0dx9bVNEwYCA==} dependencies: '@noble/curves': 1.2.0 '@noble/hashes': 1.3.3 '@scure/base': 1.1.6 + dev: true - '@scure/bip32@1.3.3': + /@scure/bip32@1.3.3: + resolution: {integrity: sha512-LJaN3HwRbfQK0X1xFSi0Q9amqOgzQnnDngIt+ZlsBC3Bm7/nE7K0kwshZHyaru79yIVRv/e1mQAjZyuZG6jOFQ==} dependencies: '@noble/curves': 1.3.0 '@noble/hashes': 1.3.3 '@scure/base': 1.1.6 - '@scure/bip39@1.1.1': + /@scure/bip39@1.1.1: + resolution: {integrity: sha512-t+wDck2rVkh65Hmv280fYdVdY25J9YeEUIgn2LG1WM6gxFkGzcksoDiUkWVpVp3Oex9xGC68JU2dSbUfwZ2jPg==} dependencies: '@noble/hashes': 1.2.0 '@scure/base': 1.1.6 - '@scure/bip39@1.2.1': + /@scure/bip39@1.2.1: + resolution: {integrity: sha512-Z3/Fsz1yr904dduJD0NpiyRHhRYHdcnyh73FZWiV+/qhWi83wNJ3NWolYqCEN+ZWsUz2TWwajJggcRE9r1zUYg==} dependencies: '@noble/hashes': 1.3.3 '@scure/base': 1.1.6 + dev: true - '@scure/bip39@1.2.2': + /@scure/bip39@1.2.2: + resolution: {integrity: sha512-HYf9TUXG80beW+hGAt3TRM8wU6pQoYur9iNypTROm42dorCGmLnFe3eWjz3gOq6G62H2WRh0FCzAR1PI+29zIA==} dependencies: '@noble/hashes': 1.3.3 '@scure/base': 1.1.6 - '@sentry/core@5.30.0': + /@sentry/core@5.30.0: + resolution: {integrity: sha512-TmfrII8w1PQZSZgPpUESqjB+jC6MvZJZdLtE/0hZ+SrnKhW3x5WlYLvTXZpcWePYBku7rl2wn1RZu6uT0qCTeg==} + engines: {node: '>=6'} dependencies: '@sentry/hub': 5.30.0 '@sentry/minimal': 5.30.0 '@sentry/types': 5.30.0 '@sentry/utils': 5.30.0 tslib: 1.14.1 + dev: false - '@sentry/hub@5.30.0': + /@sentry/hub@5.30.0: + resolution: {integrity: sha512-2tYrGnzb1gKz2EkMDQcfLrDTvmGcQPuWxLnJKXJvYTQDGLlEvi2tWz1VIHjunmOvJrB5aIQLhm+dcMRwFZDCqQ==} + engines: {node: '>=6'} dependencies: '@sentry/types': 5.30.0 '@sentry/utils': 5.30.0 tslib: 1.14.1 + dev: false - '@sentry/minimal@5.30.0': + /@sentry/minimal@5.30.0: + resolution: {integrity: sha512-BwWb/owZKtkDX+Sc4zCSTNcvZUq7YcH3uAVlmh/gtR9rmUvbzAA3ewLuB3myi4wWRAMEtny6+J/FN/x+2wn9Xw==} + engines: {node: '>=6'} dependencies: '@sentry/hub': 5.30.0 '@sentry/types': 5.30.0 tslib: 1.14.1 + dev: false - '@sentry/node@5.30.0': + /@sentry/node@5.30.0: + resolution: {integrity: sha512-Br5oyVBF0fZo6ZS9bxbJZG4ApAjRqAnqFFurMVJJdunNb80brh7a5Qva2kjhm+U6r9NJAB5OmDyPkA1Qnt+QVg==} + engines: {node: '>=6'} dependencies: '@sentry/core': 5.30.0 '@sentry/hub': 5.30.0 @@ -8498,69 +3535,112 @@ snapshots: tslib: 1.14.1 transitivePeerDependencies: - supports-color + dev: false - '@sentry/tracing@5.30.0': + /@sentry/tracing@5.30.0: + resolution: {integrity: sha512-dUFowCr0AIMwiLD7Fs314Mdzcug+gBVo/+NCMyDw8tFxJkwWAKl7Qa2OZxLQ0ZHjakcj1hNKfCQJ9rhyfOl4Aw==} + engines: {node: '>=6'} dependencies: '@sentry/hub': 5.30.0 '@sentry/minimal': 5.30.0 '@sentry/types': 5.30.0 '@sentry/utils': 5.30.0 tslib: 1.14.1 + dev: false - '@sentry/types@5.30.0': {} + /@sentry/types@5.30.0: + resolution: {integrity: sha512-R8xOqlSTZ+htqrfteCWU5Nk0CDN5ApUTvrlvBuiH1DyP6czDZ4ktbZB0hAgBlVcK0U+qpD3ag3Tqqpa5Q67rPw==} + engines: {node: '>=6'} + dev: false - '@sentry/utils@5.30.0': + /@sentry/utils@5.30.0: + resolution: {integrity: sha512-zaYmoH0NWWtvnJjC9/CBseXMtKHm/tm40sz3YfJRxeQjyzRqNQPgivpd9R/oDJCYj999mzdW382p/qi2ypjLww==} + engines: {node: '>=6'} dependencies: '@sentry/types': 5.30.0 tslib: 1.14.1 + dev: false - '@sinclair/typebox@0.27.8': {} + /@sinclair/typebox@0.27.8: + resolution: {integrity: sha512-+Fj43pSMwJs4KRrH/938Uf+uAELIgVBmQzg/q1YG10djyfA3TnrU8N8XzqCh/okZdszqBQTZf96idMfE5lnwTA==} + dev: true - '@sindresorhus/is@4.6.0': {} + /@sindresorhus/is@4.6.0: + resolution: {integrity: sha512-t09vSN3MdfsyCHoFcTRCH/iUtG7OJ0CsjzB8cjAmKc/va/kIgeDI/TxsigdncE/4be734m0cvIYwNaV4i2XqAw==} + engines: {node: '>=10'} - '@sinonjs/commons@1.8.6': + /@sinonjs/commons@1.8.6: + resolution: {integrity: sha512-Ky+XkAkqPZSm3NLBeUng77EBQl3cmeJhITaGHdYH8kjVB+aun3S4XBRti2zt17mtt0mIUDiNxYeoJm6drVvBJQ==} dependencies: type-detect: 4.0.8 + dev: true - '@sinonjs/fake-timers@6.0.1': + /@sinonjs/fake-timers@6.0.1: + resolution: {integrity: sha512-MZPUxrmFubI36XS1DI3qmI0YdN1gks62JtFZvxR67ljjSNCeK6U08Zx4msEWOXuofgqUt6zPHSi1H9fbjR/NRA==} dependencies: '@sinonjs/commons': 1.8.6 + dev: true - '@sinonjs/samsam@5.3.1': + /@sinonjs/samsam@5.3.1: + resolution: {integrity: sha512-1Hc0b1TtyfBu8ixF/tpfSHTVWKwCBLY4QJbkgnE7HcwyvT2xArDxb4K7dMgqRm3szI+LJbzmW/s4xxEhv6hwDg==} dependencies: '@sinonjs/commons': 1.8.6 lodash.get: 4.4.2 type-detect: 4.0.8 + dev: true - '@sinonjs/text-encoding@0.7.2': {} + /@sinonjs/text-encoding@0.7.2: + resolution: {integrity: sha512-sXXKG+uL9IrKqViTtao2Ws6dy0znu9sOaP1di/jKGW1M6VssO8vlpXCQcpZ+jisQ1tTFAC5Jo/EOzFbggBagFQ==} + dev: true - '@solidity-parser/parser@0.14.5': + /@solidity-parser/parser@0.14.5: + resolution: {integrity: sha512-6dKnHZn7fg/iQATVEzqyUOyEidbn05q7YA2mQ9hC0MMXhhV3/JrsxmFSYZAcr7j1yUP700LLhTruvJ3MiQmjJg==} dependencies: antlr4ts: 0.5.0-alpha.4 + dev: true - '@solidity-parser/parser@0.16.2': + /@solidity-parser/parser@0.16.2: + resolution: {integrity: sha512-PI9NfoA3P8XK2VBkK5oIfRgKDsicwDZfkVq9ZTBCQYGOP1N2owgY2dyLGyU5/J/hQs8KRk55kdmvTLjy3Mu3vg==} dependencies: antlr4ts: 0.5.0-alpha.4 + dev: false - '@solidity-parser/parser@0.18.0': {} + /@solidity-parser/parser@0.18.0: + resolution: {integrity: sha512-yfORGUIPgLck41qyN7nbwJRAx17/jAIXCTanHOJZhB6PJ1iAk/84b/xlsVKFSyNyLXIj0dhppoE0+CRws7wlzA==} + dev: true - '@szmarczak/http-timer@4.0.6': + /@szmarczak/http-timer@4.0.6: + resolution: {integrity: sha512-4BAffykYOgO+5nzBWYwE3W90sBgLJoUPRWWcL8wlyiM8IB8ipJz3UMJ9KXQd1RKQXpKp8Tutn80HZtWsu2u76w==} + engines: {node: '>=10'} dependencies: defer-to-connect: 2.0.1 - '@szmarczak/http-timer@5.0.1': + /@szmarczak/http-timer@5.0.1: + resolution: {integrity: sha512-+PmQX0PiAYPMeVYe237LJAYvOMYW1j2rH5YROyS3b4CTVJum34HfRvKvAzozHAQG0TnHNdUfY9nCeUyRAs//cw==} + engines: {node: '>=14.16'} dependencies: defer-to-connect: 2.0.1 - '@truffle/abi-utils@1.0.3': + /@truffle/abi-utils@1.0.3: + resolution: {integrity: sha512-AWhs01HCShaVKjml7Z4AbVREr/u4oiWxCcoR7Cktm0mEvtT04pvnxW5xB/cI4znRkrbPdFQlFt67kgrAjesYkw==} + engines: {node: ^16.20 || ^18.16 || >=20} + deprecated: Package no longer supported. Contact Support at https://www.npmjs.com/support for more info. dependencies: change-case: 3.0.2 fast-check: 3.1.1 web3-utils: 1.10.0 + dev: false - '@truffle/blockchain-utils@0.1.9': {} + /@truffle/blockchain-utils@0.1.9: + resolution: {integrity: sha512-RHfumgbIVo68Rv9ofDYfynjnYZIfP/f1vZy4RoqkfYAO+fqfc58PDRzB1WAGq2U6GPuOnipOJxQhnqNnffORZg==} + engines: {node: ^16.20 || ^18.16 || >=20} + deprecated: Package no longer supported. Contact Support at https://www.npmjs.com/support for more info. + dev: false - '@truffle/codec@0.17.3': + /@truffle/codec@0.17.3: + resolution: {integrity: sha512-Ko/+dsnntNyrJa57jUD9u4qx9nQby+H4GsUO6yjiCPSX0TQnEHK08XWqBSg0WdmCH2+h0y1nr2CXSx8gbZapxg==} + engines: {node: ^16.20 || ^18.16 || >=20} + deprecated: Package no longer supported. Contact Support at https://www.npmjs.com/support for more info. dependencies: '@truffle/abi-utils': 1.0.3 '@truffle/compile-common': 0.9.8 @@ -8574,20 +3654,32 @@ snapshots: web3-utils: 1.10.0 transitivePeerDependencies: - supports-color + dev: false - '@truffle/compile-common@0.9.8': + /@truffle/compile-common@0.9.8: + resolution: {integrity: sha512-DTpiyo32t/YhLI1spn84D3MHYHrnoVqO+Gp7ZHrYNwDs86mAxtNiH5lsVzSb8cPgiqlvNsRCU9nm9R0YmKMTBQ==} + engines: {node: ^16.20 || ^18.16 || >=20} + deprecated: Package no longer supported. Contact Support at https://www.npmjs.com/support for more info. dependencies: '@truffle/error': 0.2.2 colors: 1.4.0 + dev: false - '@truffle/contract-schema@3.4.16': + /@truffle/contract-schema@3.4.16: + resolution: {integrity: sha512-g0WNYR/J327DqtJPI70ubS19K1Fth/1wxt2jFqLsPmz5cGZVjCwuhiie+LfBde4/Mc9QR8G+L3wtmT5cyoBxAg==} + engines: {node: ^16.20 || ^18.16 || >=20} + deprecated: Package no longer supported. Contact Support at https://www.npmjs.com/support for more info. dependencies: ajv: 6.12.6 debug: 4.3.4(supports-color@8.1.1) transitivePeerDependencies: - supports-color + dev: false - '@truffle/debug-utils@6.0.57': + /@truffle/debug-utils@6.0.57: + resolution: {integrity: sha512-Q6oI7zLaeNLB69ixjwZk2UZEWBY6b2OD1sjLMGDKBGR7GaHYiw96GLR2PFgPH1uwEeLmV4N78LYaQCrDsHbNeA==} + engines: {node: ^16.20 || ^18.16 || >=20} + deprecated: Package no longer supported. Contact Support at https://www.npmjs.com/support for more info. dependencies: '@truffle/codec': 0.17.3 '@trufflesuite/chromafi': 3.0.0 @@ -8597,23 +3689,36 @@ snapshots: highlightjs-solidity: 2.0.6 transitivePeerDependencies: - supports-color + dev: false - '@truffle/error@0.1.1': {} + /@truffle/error@0.1.1: + resolution: {integrity: sha512-sE7c9IHIGdbK4YayH4BC8i8qMjoAOeg6nUXUDZZp8wlU21/EMpaG+CLx+KqcIPyR+GSWIW3Dm0PXkr2nlggFDA==} + deprecated: Package no longer supported. Contact Support at https://www.npmjs.com/support for more info. + dev: false - '@truffle/error@0.2.2': {} + /@truffle/error@0.2.2: + resolution: {integrity: sha512-TqbzJ0O8DHh34cu8gDujnYl4dUl6o2DE4PR6iokbybvnIm/L2xl6+Gv1VC+YJS45xfH83Yo3/Zyg/9Oq8/xZWg==} + engines: {node: ^16.20 || ^18.16 || >=20} + deprecated: Package no longer supported. Contact Support at https://www.npmjs.com/support for more info. + dev: false - '@truffle/interface-adapter@0.5.37(bufferutil@4.0.8)(utf-8-validate@5.0.10)': + /@truffle/interface-adapter@0.5.37: + resolution: {integrity: sha512-lPH9MDgU+7sNDlJSClwyOwPCfuOimqsCx0HfGkznL3mcFRymc1pukAR1k17zn7ErHqBwJjiKAZ6Ri72KkS+IWw==} + engines: {node: ^16.20 || ^18.16 || >=20} + deprecated: Package no longer supported. Contact Support at https://www.npmjs.com/support for more info. dependencies: bn.js: 5.2.1 ethers: 4.0.49 - web3: 1.10.0(bufferutil@4.0.8)(utf-8-validate@5.0.10) + web3: 1.10.0 transitivePeerDependencies: - bufferutil - encoding - supports-color - utf-8-validate + dev: false - '@trufflesuite/chromafi@3.0.0': + /@trufflesuite/chromafi@3.0.0: + resolution: {integrity: sha512-oqWcOqn8nT1bwlPPfidfzS55vqcIDdpfzo3HbU9EnUmcSTX+I8z0UyUFI3tZQjByVJulbzxHxUGS3ZJPwK/GPQ==} dependencies: camelcase: 4.1.0 chalk: 2.4.2 @@ -8623,190 +3728,310 @@ snapshots: lodash.merge: 4.6.2 strip-ansi: 4.0.0 strip-indent: 2.0.0 + dev: false - '@tsconfig/node10@1.0.11': {} + /@tsconfig/node10@1.0.11: + resolution: {integrity: sha512-DcRjDCujK/kCk/cUe8Xz8ZSpm8mS3mNNpta+jGCA6USEDfktlNvm1+IuZ9eTcDbNk41BHwpHHeW+N1lKCz4zOw==} + dev: true - '@tsconfig/node12@1.0.11': {} + /@tsconfig/node12@1.0.11: + resolution: {integrity: sha512-cqefuRsh12pWyGsIoBKJA9luFu3mRxCA+ORZvA4ktLSzIuCUtWVxGIuXigEwO5/ywWFMZ2QEGKWvkZG1zDMTag==} + dev: true - '@tsconfig/node14@1.0.3': {} + /@tsconfig/node14@1.0.3: + resolution: {integrity: sha512-ysT8mhdixWK6Hw3i1V2AeRqZ5WfXg1G43mqoYlM2nc6388Fq5jcXyr5mRsqViLx/GJYdoL0bfXD8nmF+Zn/Iow==} + dev: true - '@tsconfig/node16@1.0.4': {} + /@tsconfig/node16@1.0.4: + resolution: {integrity: sha512-vxhUy4J8lyeyinH7Azl1pdd43GJhZH/tP2weN8TntQblOY+A0XbT8DJk1/oCPuOOyg/Ja757rG0CgHcWC8OfMA==} + dev: true - '@typechain/ethers-v6@0.5.1(ethers@6.12.1(bufferutil@4.0.8)(utf-8-validate@5.0.10))(typechain@8.3.2(typescript@5.0.4))(typescript@5.0.4)': + /@typechain/ethers-v6@0.5.1(ethers@6.12.1)(typechain@8.3.2)(typescript@5.0.4): + resolution: {integrity: sha512-F+GklO8jBWlsaVV+9oHaPh5NJdd6rAKN4tklGfInX1Q7h0xPgVLP39Jl3eCulPB5qexI71ZFHwbljx4ZXNfouA==} + peerDependencies: + ethers: 6.x + typechain: ^8.3.2 + typescript: '>=4.7.0' dependencies: - ethers: 6.12.1(bufferutil@4.0.8)(utf-8-validate@5.0.10) + ethers: 6.12.1 lodash: 4.17.21 ts-essentials: 7.0.3(typescript@5.0.4) typechain: 8.3.2(typescript@5.0.4) typescript: 5.0.4 + dev: true - '@typechain/hardhat@9.1.0(@typechain/ethers-v6@0.5.1(ethers@6.12.1(bufferutil@4.0.8)(utf-8-validate@5.0.10))(typechain@8.3.2(typescript@5.0.4))(typescript@5.0.4))(ethers@6.12.1(bufferutil@4.0.8)(utf-8-validate@5.0.10))(hardhat@packages+hardhat-core)(typechain@8.3.2(typescript@5.0.4))': + /@typechain/hardhat@9.1.0(@typechain/ethers-v6@0.5.1)(ethers@6.12.1)(hardhat@packages+hardhat-core)(typechain@8.3.2): + resolution: {integrity: sha512-mtaUlzLlkqTlfPwB3FORdejqBskSnh+Jl8AIJGjXNAQfRQ4ofHADPl1+oU7Z3pAJzmZbUXII8MhOLQltcHgKnA==} + peerDependencies: + '@typechain/ethers-v6': ^0.5.1 + ethers: ^6.1.0 + hardhat: ^2.9.9 + typechain: ^8.3.2 dependencies: - '@typechain/ethers-v6': 0.5.1(ethers@6.12.1(bufferutil@4.0.8)(utf-8-validate@5.0.10))(typechain@8.3.2(typescript@5.0.4))(typescript@5.0.4) - ethers: 6.12.1(bufferutil@4.0.8)(utf-8-validate@5.0.10) + '@typechain/ethers-v6': 0.5.1(ethers@6.12.1)(typechain@8.3.2)(typescript@5.0.4) + ethers: 6.12.1 fs-extra: 9.1.0 hardhat: link:packages/hardhat-core typechain: 8.3.2(typescript@5.0.4) + dev: true - '@types/async-eventemitter@0.2.4': + /@types/async-eventemitter@0.2.4: + resolution: {integrity: sha512-2Bq61VD01kgLf1XkK2xPtoBcu7fgn/km5JyEX9v0BlG5VQBzA+BlF9umFk+8gR8S4+eK7MgDY2oyVZCu6ar3Jw==} dependencies: '@types/events': 3.0.3 + dev: true - '@types/bignumber.js@5.0.0': + /@types/bignumber.js@5.0.0: + resolution: {integrity: sha512-0DH7aPGCClywOFaxxjE6UwpN2kQYe9LwuDQMv+zYA97j5GkOMo8e66LYT+a8JYU7jfmUFRZLa9KycxHDsKXJCA==} + deprecated: This is a stub types definition for bignumber.js (https://github.com/MikeMcl/bignumber.js/). bignumber.js provides its own type definitions, so you don't need @types/bignumber.js installed! dependencies: bignumber.js: 9.1.2 + dev: false - '@types/bn.js@4.11.6': + /@types/bn.js@4.11.6: + resolution: {integrity: sha512-pqr857jrp2kPuO9uRjZ3PwnJTjoQy+fcdxvBTvHm6dkmEL9q+hDD/2j/0ELOBPtPnS8LjCX0gI9nbl8lVkadpg==} dependencies: '@types/node': 18.19.33 + dev: false - '@types/bn.js@5.1.5': + /@types/bn.js@5.1.5: + resolution: {integrity: sha512-V46N0zwKRF5Q00AZ6hWtN0T8gGmDUaUzLWQvHFo5yThtVwK/VCenFY3wXVbOvNfajEpsTfQM4IN9k/d6gUVX3A==} dependencies: '@types/node': 18.19.33 - '@types/cacheable-request@6.0.3': + /@types/cacheable-request@6.0.3: + resolution: {integrity: sha512-IQ3EbTzGxIigb1I3qPZc1rWJnH0BmSKv5QYTalEwweFvyBDLSAe24zP0le/hyi7ecGfZVlIVAg4BZqb8WBwKqw==} dependencies: '@types/http-cache-semantics': 4.0.4 '@types/keyv': 3.1.4 '@types/node': 18.19.33 '@types/responselike': 1.0.3 - '@types/chai-as-promised@7.1.8': + /@types/chai-as-promised@7.1.8: + resolution: {integrity: sha512-ThlRVIJhr69FLlh6IctTXFkmhtP3NpMZ2QGq69StYLyKZFp/HOp1VdKZj7RvfNWYYcJ1xlbLGLLWj1UvP5u/Gw==} dependencies: '@types/chai': 4.3.16 - '@types/chai@4.3.16': {} + /@types/chai@4.3.16: + resolution: {integrity: sha512-PatH4iOdyh3MyWtmHVFXLWCCIhUbopaltqddG9BzB+gMIzee2MJrvd+jouii9Z3wzQJruGWAm7WOMjgfG8hQlQ==} - '@types/ci-info@2.0.0': {} + /@types/ci-info@2.0.0: + resolution: {integrity: sha512-5R2/MHILQLDCzTuhs1j4Qqq8AaKUf7Ma4KSSkCtc12+fMs47zfa34qhto9goxpyX00tQK1zxB885VCiawZ5Qhg==} + dev: true - '@types/concat-stream@1.6.1': + /@types/concat-stream@1.6.1: + resolution: {integrity: sha512-eHE4cQPoj6ngxBZMvVf6Hw7Mh4jMW4U9lpGmS5GBPB9RYxlFg+CHaVN7ErNY4W9XfLIEn20b4VDYaIrbq0q4uA==} dependencies: '@types/node': 18.19.33 + dev: true - '@types/debug@4.1.12': + /@types/debug@4.1.12: + resolution: {integrity: sha512-vIChWdVG3LG1SMxEvI/AK+FWJthlrqlTu7fbrlywTkkaONwk/UAGaULXRlf8vkzFBLVm0zkMdCquhL5aOjhXPQ==} dependencies: '@types/ms': 0.7.34 + dev: true - '@types/events@3.0.3': {} + /@types/events@3.0.3: + resolution: {integrity: sha512-trOc4AAUThEz9hapPtSd7wf5tiQKvTtu5b371UxXdTuqzIh0ArcRspRP0i0Viu+LXstIQ1z96t1nsPxT9ol01g==} + dev: true - '@types/find-up@2.1.1': {} + /@types/find-up@2.1.1: + resolution: {integrity: sha512-60LC501bQRN9/3yfVaEEMd7IndaufffL56PBRAejPpUrY304Ps1jfnjNqPw5jmM5R8JHWiKBAe5IHzNcPV41AA==} + dev: true - '@types/form-data@0.0.33': + /@types/form-data@0.0.33: + resolution: {integrity: sha512-8BSvG1kGm83cyJITQMZSulnl6QV8jqAGreJsc5tPu1Jq0vTSOiY/k24Wx82JRpWwZSqrala6sd5rWi6aNXvqcw==} dependencies: '@types/node': 18.19.33 + dev: true - '@types/fs-extra@5.1.0': + /@types/fs-extra@5.1.0: + resolution: {integrity: sha512-AInn5+UBFIK9FK5xc9yP5e3TQSPNNgjHByqYcj9g5elVBnDQcQL7PlO1CIRy2gWlbwK7UPYqi7vRvFA44dCmYQ==} dependencies: '@types/node': 18.19.33 + dev: true - '@types/glob@7.2.0': + /@types/glob@7.2.0: + resolution: {integrity: sha512-ZUxbzKl0IfJILTS6t7ip5fQQM/J3TJYubDm3nMbgubNNYS62eXeUpoLUC8/7fJNiFYHTrGPQn7hspDUzIHX3UA==} dependencies: '@types/minimatch': 5.1.2 '@types/node': 18.19.33 + dev: true - '@types/http-cache-semantics@4.0.4': {} + /@types/http-cache-semantics@4.0.4: + resolution: {integrity: sha512-1m0bIFVc7eJWyve9S0RnuRgcQqF/Xd5QsUZAZeQFr1Q3/p9JWoQQEqmVy+DPTNpGXwhgIetAoYF8JSc33q29QA==} - '@types/json-schema@7.0.15': {} + /@types/json-schema@7.0.15: + resolution: {integrity: sha512-5+fP8P8MFNC+AyZCDxrB2pkZFPGzqQWUzpSeuuVLvm8VMcorNYavBqoFcxK8bQz4Qsbn4oUEEem4wDLfcysGHA==} - '@types/json5@0.0.29': {} + /@types/json5@0.0.29: + resolution: {integrity: sha512-dRLjCWHYg4oaA77cxO64oO+7JwCwnIzkZPdrrC71jQmQtlhM556pwKo5bUzqvZndkVbeFLIIi+9TC40JNF5hNQ==} + dev: true - '@types/keccak@3.0.4': + /@types/keccak@3.0.4: + resolution: {integrity: sha512-hdnkmbie7tE0yXnQQvlIOqCyjEsoXDVEZ3ACqO+F305XgUOW4Z9ElWdogCXXRAW/khnZ7GxM0t/BGB5bORKt/g==} dependencies: '@types/node': 18.19.33 + dev: true - '@types/keyv@3.1.4': + /@types/keyv@3.1.4: + resolution: {integrity: sha512-BQ5aZNSCpj7D6K2ksrRCTmKRLEpnPvWDiLPfoGyhZ++8YtiK9d/3DBKPJgry359X/P1PfruyYwvnvwFjuEiEIg==} dependencies: '@types/node': 18.19.33 - '@types/lodash.clonedeep@4.5.9': + /@types/lodash.clonedeep@4.5.9: + resolution: {integrity: sha512-19429mWC+FyaAhOLzsS8kZUsI+/GmBAQ0HFiCPsKGU+7pBXOQWhyrY6xNNDwUSX8SMZMJvuFVMF9O5dQOlQK9Q==} dependencies: '@types/lodash': 4.17.1 + dev: true - '@types/lodash.isequal@4.5.8': + /@types/lodash.isequal@4.5.8: + resolution: {integrity: sha512-uput6pg4E/tj2LGxCZo9+y27JNyB2OZuuI/T5F+ylVDYuqICLG2/ktjxx0v6GvVntAf8TvEzeQLcV0ffRirXuA==} dependencies: '@types/lodash': 4.17.1 + dev: true - '@types/lodash.memoize@4.1.9': + /@types/lodash.memoize@4.1.9: + resolution: {integrity: sha512-glY1nQuoqX4Ft8Uk+KfJudOD7DQbbEDF6k9XpGncaohW3RW4eSWBlx6AA0fZCrh40tZcQNH4jS/Oc59J6Eq+aw==} dependencies: '@types/lodash': 4.17.1 + dev: true - '@types/lodash@4.17.1': {} + /@types/lodash@4.17.1: + resolution: {integrity: sha512-X+2qazGS3jxLAIz5JDXDzglAF3KpijdhFxlf/V1+hEsOUc+HnWi81L/uv/EvGuV90WY+7mPGFCUDGfQC3Gj95Q==} + dev: true - '@types/lru-cache@5.1.1': {} + /@types/lru-cache@5.1.1: + resolution: {integrity: sha512-ssE3Vlrys7sdIzs5LOxCzTVMsU7i9oa/IaW92wF32JFb3CVczqOkru2xspuKczHEbG3nvmPY7IFqVmGGHdNbYw==} + dev: false - '@types/minimatch@5.1.2': {} + /@types/minimatch@5.1.2: + resolution: {integrity: sha512-K0VQKziLUWkVKiRVrx4a40iPaxTUefQmjtkQofBkYRcoaaL/8rhwDWww9qWbrgicNOgnpIsMxyNIUM4+n6dUIA==} + dev: true - '@types/minimist@1.2.5': {} + /@types/minimist@1.2.5: + resolution: {integrity: sha512-hov8bUuiLiyFPGyFPE1lwWhmzYbirOXQNNo40+y3zow8aFVTeyn3VWL0VFFfdNddA8S4Vf0Tc062rzyNr7Paag==} + dev: true - '@types/mocha@10.0.6': {} + /@types/mocha@10.0.6: + resolution: {integrity: sha512-dJvrYWxP/UcXm36Qn36fxhUKu8A/xMRXVT2cliFF1Z7UA9liG5Psj3ezNSZw+5puH2czDXRLcXQxf8JbJt0ejg==} + dev: true - '@types/ms@0.7.34': {} + /@types/ms@0.7.34: + resolution: {integrity: sha512-nG96G3Wp6acyAgJqGasjODb+acrI7KltPiRxzHPXnP3NgI28bpQDRv53olbqGXbfcgF5aiiHmO3xpwEpS5Ld9g==} + dev: true - '@types/node@10.17.60': {} + /@types/node@10.17.60: + resolution: {integrity: sha512-F0KIgDJfy2nA3zMLmWGKxcH2ZVEtCZXHHdOQs2gSaQ27+lNeEfGxzkIw90aXswATX7AZ33tahPbzy6KAfUreVw==} + dev: true - '@types/node@12.20.55': {} + /@types/node@12.20.55: + resolution: {integrity: sha512-J8xLz7q2OFulZ2cyGTLE1TbbZcjpno7FaN6zdJNrgAdrJ+DZzh/uFR6YrTb4C+nXakvud8Q4+rbhoIWlYQbUFQ==} - '@types/node@18.15.13': {} + /@types/node@18.15.13: + resolution: {integrity: sha512-N+0kuo9KgrUQ1Sn/ifDXsvg0TTleP7rIy4zOBGECxAljqvqfqpTfzx0Q1NUedOixRMBfe2Whhb056a42cWs26Q==} - '@types/node@18.19.33': + /@types/node@18.19.33: + resolution: {integrity: sha512-NR9+KrpSajr2qBVp/Yt5TU/rp+b5Mayi3+OlMlcg2cVCfRmcG5PWZ7S4+MG9PZ5gWBoc9Pd0BKSRViuBCRPu0A==} dependencies: undici-types: 5.26.5 - '@types/node@8.10.66': {} + /@types/node@8.10.66: + resolution: {integrity: sha512-tktOkFUA4kXx2hhhrB8bIFb5TbwzS4uOhKEmwiD+NoiL0qtP2OQ9mFldbgD4dV1djrlBYP6eBuQZiWjuHUpqFw==} + dev: true - '@types/normalize-package-data@2.4.4': {} + /@types/normalize-package-data@2.4.4: + resolution: {integrity: sha512-37i+OaWTh9qeK4LSHPsyRC7NahnGotNuZvjLSgcPzblpHB3rrCJxAOgI5gCdKm7coonsaX1Of0ILiTcnZjbfxA==} + dev: true - '@types/pbkdf2@3.1.2': + /@types/pbkdf2@3.1.2: + resolution: {integrity: sha512-uRwJqmiXmh9++aSu1VNEn3iIxWOhd8AHXNSdlaLfdAAdSTY9jYVeGWnzejM3dvrkbqE3/hyQkQQ29IFATEGlew==} dependencies: '@types/node': 18.19.33 - '@types/prettier@2.7.3': {} + /@types/prettier@2.7.3: + resolution: {integrity: sha512-+68kP9yzs4LMp7VNh8gdzMSPZFL44MLGqiHWvttYJe+6qnuVr4Ek9wSBQoveqY/r+LwjCcU29kNVkidwim+kYA==} + dev: true - '@types/qs@6.9.15': {} + /@types/qs@6.9.15: + resolution: {integrity: sha512-uXHQKES6DQKKCLh441Xv/dwxOq1TVS3JPUMlEqoEglvlhR6Mxnlew/Xq/LRVHpLyk7iK3zODe1qYHIMltO7XGg==} + dev: true - '@types/readable-stream@2.3.15': + /@types/readable-stream@2.3.15: + resolution: {integrity: sha512-oM5JSKQCcICF1wvGgmecmHldZ48OZamtMxcGGVICOJA8o8cahXC1zEVAif8iwoc5j8etxFaRFnf095+CDsuoFQ==} dependencies: '@types/node': 18.19.33 safe-buffer: 5.1.2 + dev: true - '@types/resolve@1.20.6': {} + /@types/resolve@1.20.6: + resolution: {integrity: sha512-A4STmOXPhMUtHH+S6ymgE2GiBSMqf4oTvcQZMcHzokuTLVYzXTB8ttjcgxOVaAp2lGwEdzZ0J+cRbbeevQj1UQ==} + dev: true - '@types/responselike@1.0.3': + /@types/responselike@1.0.3: + resolution: {integrity: sha512-H/+L+UkTV33uf49PH5pCAUBVPNj2nDBXTN+qS1dOwyyg24l3CcicicCA7ca+HMvJBZcFgl5r8e+RR6elsb4Lyw==} dependencies: '@types/node': 18.19.33 - '@types/secp256k1@4.0.6': + /@types/secp256k1@4.0.6: + resolution: {integrity: sha512-hHxJU6PAEUn0TP4S/ZOzuTUvJWuZ6eIKeNKb5RBpODvSl6hp1Wrw4s7ATY50rklRCScUDpHzVA/DQdSjJ3UoYQ==} dependencies: '@types/node': 18.19.33 - '@types/semver@6.2.7': {} + /@types/semver@6.2.7: + resolution: {integrity: sha512-blctEWbzUFzQx799RZjzzIdBJOXmE37YYEyDtKkx5Dg+V7o/zyyAxLPiI98A2jdTtDgxZleMdfV+7p8WbRJ1OQ==} + dev: true - '@types/semver@7.5.8': {} + /@types/semver@7.5.8: + resolution: {integrity: sha512-I8EUhyrgfLrcTkzV3TSsGyl1tSuPrEDzr0yd5m90UgNxQkyDXULk3b6MlQqTCpZpNtWe1K0hzclnZkTcLBe2UQ==} - '@types/sinon-chai@3.2.12': + /@types/sinon-chai@3.2.12: + resolution: {integrity: sha512-9y0Gflk3b0+NhQZ/oxGtaAJDvRywCa5sIyaVnounqLvmf93yBF4EgIRspePtkMs3Tr844nCclYMlcCNmLCvjuQ==} dependencies: '@types/chai': 4.3.16 '@types/sinon': 9.0.11 + dev: true - '@types/sinon@9.0.11': + /@types/sinon@9.0.11: + resolution: {integrity: sha512-PwP4UY33SeeVKodNE37ZlOsR9cReypbMJOhZ7BVE0lB+Hix3efCOxiJWiE5Ia+yL9Cn2Ch72EjFTRze8RZsNtg==} dependencies: '@types/sinonjs__fake-timers': 8.1.5 + dev: true - '@types/sinonjs__fake-timers@8.1.5': {} + /@types/sinonjs__fake-timers@8.1.5: + resolution: {integrity: sha512-mQkU2jY8jJEF7YHjHvsQO8+3ughTL1mcnn96igfhONmR+fUPSKIkefQYpSe8bsly2Ep7oQbn/6VG5/9/0qcArQ==} + dev: true - '@types/uuid@8.3.4': {} + /@types/uuid@8.3.4: + resolution: {integrity: sha512-c/I8ZRb51j+pYGAu5CrFMRxqZ2ke4y2grEBO5AUjgSkSk+qT2Ea+OdWElz/OiMf5MNpn2b17kuVBwZLQJXzihw==} + dev: true - '@types/w3c-web-usb@1.0.10': {} + /@types/w3c-web-usb@1.0.10: + resolution: {integrity: sha512-CHgUI5kTc/QLMP8hODUHhge0D4vx+9UiAwIGiT0sTy/B2XpdX1U5rJt6JSISgr6ikRT7vxV9EVAFeYZqUnl1gQ==} + dev: false - '@types/ws@7.4.7': + /@types/ws@7.4.7: + resolution: {integrity: sha512-JQbbmxZTZehdc2iszGKs5oC3NFnjeay7mtAWrdt7qNtAVK0g19muApzAy4bm9byz79xa2ZnO/BOBC2R8RC5Lww==} dependencies: '@types/node': 18.19.33 + dev: true - '@types/ws@8.5.3': + /@types/ws@8.5.3: + resolution: {integrity: sha512-6YOoWjruKj1uLf3INHH7D3qTXwFfEsg1kf3c0uDdSBJwfa/llkwIjrAGV7j7mVgGNbzTQ3HiHKKDXl6bJPD97w==} dependencies: '@types/node': 18.19.33 + dev: true - '@typescript-eslint/eslint-plugin@5.61.0(@typescript-eslint/parser@5.61.0(eslint@8.57.0)(typescript@5.0.4))(eslint@8.57.0)(typescript@5.0.4)': + /@typescript-eslint/eslint-plugin@5.61.0(@typescript-eslint/parser@5.61.0)(eslint@8.57.0)(typescript@5.0.4): + resolution: {integrity: sha512-A5l/eUAug103qtkwccSCxn8ZRwT+7RXWkFECdA4Cvl1dOlDUgTpAOfSEElZn2uSUxhdDpnCdetrf0jvU4qrL+g==} + engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0} + peerDependencies: + '@typescript-eslint/parser': ^5.0.0 + eslint: ^6.0.0 || ^7.0.0 || ^8.0.0 + typescript: '*' + peerDependenciesMeta: + typescript: + optional: true dependencies: '@eslint-community/regexpp': 4.10.0 '@typescript-eslint/parser': 5.61.0(eslint@8.57.0)(typescript@5.0.4) @@ -8820,50 +4045,80 @@ snapshots: natural-compare-lite: 1.4.0 semver: 7.6.2 tsutils: 3.21.0(typescript@5.0.4) - optionalDependencies: typescript: 5.0.4 transitivePeerDependencies: - supports-color + dev: true - '@typescript-eslint/parser@5.61.0(eslint@8.57.0)(typescript@5.0.4)': + /@typescript-eslint/parser@5.61.0(eslint@8.57.0)(typescript@5.0.4): + resolution: {integrity: sha512-yGr4Sgyh8uO6fSi9hw3jAFXNBHbCtKKFMdX2IkT3ZqpKmtAq3lHS4ixB/COFuAIJpwl9/AqF7j72ZDWYKmIfvg==} + engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0} + peerDependencies: + eslint: ^6.0.0 || ^7.0.0 || ^8.0.0 + typescript: '*' + peerDependenciesMeta: + typescript: + optional: true dependencies: '@typescript-eslint/scope-manager': 5.61.0 '@typescript-eslint/types': 5.61.0 '@typescript-eslint/typescript-estree': 5.61.0(typescript@5.0.4) debug: 4.3.4(supports-color@8.1.1) eslint: 8.57.0 - optionalDependencies: typescript: 5.0.4 transitivePeerDependencies: - supports-color - '@typescript-eslint/scope-manager@5.61.0': + /@typescript-eslint/scope-manager@5.61.0: + resolution: {integrity: sha512-W8VoMjoSg7f7nqAROEmTt6LoBpn81AegP7uKhhW5KzYlehs8VV0ZW0fIDVbcZRcaP3aPSW+JZFua+ysQN+m/Nw==} + engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0} dependencies: '@typescript-eslint/types': 5.61.0 '@typescript-eslint/visitor-keys': 5.61.0 - '@typescript-eslint/scope-manager@5.62.0': + /@typescript-eslint/scope-manager@5.62.0: + resolution: {integrity: sha512-VXuvVvZeQCQb5Zgf4HAxc04q5j+WrNAtNh9OwCsCgpKqESMTu3tF/jhZ3xG6T4NZwWl65Bg8KuS2uEvhSfLl0w==} + engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0} dependencies: '@typescript-eslint/types': 5.62.0 '@typescript-eslint/visitor-keys': 5.62.0 - '@typescript-eslint/type-utils@5.61.0(eslint@8.57.0)(typescript@5.0.4)': + /@typescript-eslint/type-utils@5.61.0(eslint@8.57.0)(typescript@5.0.4): + resolution: {integrity: sha512-kk8u//r+oVK2Aj3ph/26XdH0pbAkC2RiSjUYhKD+PExemG4XSjpGFeyZ/QM8lBOa7O8aGOU+/yEbMJgQv/DnCg==} + engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0} + peerDependencies: + eslint: '*' + typescript: '*' + peerDependenciesMeta: + typescript: + optional: true dependencies: '@typescript-eslint/typescript-estree': 5.61.0(typescript@5.0.4) '@typescript-eslint/utils': 5.61.0(eslint@8.57.0)(typescript@5.0.4) debug: 4.3.4(supports-color@8.1.1) eslint: 8.57.0 tsutils: 3.21.0(typescript@5.0.4) - optionalDependencies: typescript: 5.0.4 transitivePeerDependencies: - supports-color + dev: true - '@typescript-eslint/types@5.61.0': {} + /@typescript-eslint/types@5.61.0: + resolution: {integrity: sha512-ldyueo58KjngXpzloHUog/h9REmHl59G1b3a5Sng1GfBo14BkS3ZbMEb3693gnP1k//97lh7bKsp6/V/0v1veQ==} + engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0} - '@typescript-eslint/types@5.62.0': {} + /@typescript-eslint/types@5.62.0: + resolution: {integrity: sha512-87NVngcbVXUahrRTqIK27gD2t5Cu1yuCXxbLcFtCzZGlfyVWWh8mLHkoxzjsB6DDNnvdL+fW8MiwPEJyGJQDgQ==} + engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0} - '@typescript-eslint/typescript-estree@5.61.0(typescript@5.0.4)': + /@typescript-eslint/typescript-estree@5.61.0(typescript@5.0.4): + resolution: {integrity: sha512-Fud90PxONnnLZ36oR5ClJBLTLfU4pIWBmnvGwTbEa2cXIqj70AEDEmOmpkFComjBZ/037ueKrOdHuYmSFVD7Rw==} + engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0} + peerDependencies: + typescript: '*' + peerDependenciesMeta: + typescript: + optional: true dependencies: '@typescript-eslint/types': 5.61.0 '@typescript-eslint/visitor-keys': 5.61.0 @@ -8872,12 +4127,18 @@ snapshots: is-glob: 4.0.3 semver: 7.6.2 tsutils: 3.21.0(typescript@5.0.4) - optionalDependencies: typescript: 5.0.4 transitivePeerDependencies: - supports-color - '@typescript-eslint/typescript-estree@5.62.0(typescript@5.0.4)': + /@typescript-eslint/typescript-estree@5.62.0(typescript@5.0.4): + resolution: {integrity: sha512-CmcQ6uY7b9y694lKdRB8FEel7JbU/40iSAPomu++SjLMntB+2Leay2LO6i8VnJk58MtE9/nQSFIH6jpyRWyYzA==} + engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0} + peerDependencies: + typescript: '*' + peerDependenciesMeta: + typescript: + optional: true dependencies: '@typescript-eslint/types': 5.62.0 '@typescript-eslint/visitor-keys': 5.62.0 @@ -8886,12 +4147,15 @@ snapshots: is-glob: 4.0.3 semver: 7.6.2 tsutils: 3.21.0(typescript@5.0.4) - optionalDependencies: typescript: 5.0.4 transitivePeerDependencies: - supports-color - '@typescript-eslint/utils@5.61.0(eslint@8.57.0)(typescript@5.0.4)': + /@typescript-eslint/utils@5.61.0(eslint@8.57.0)(typescript@5.0.4): + resolution: {integrity: sha512-mV6O+6VgQmVE6+xzlA91xifndPW9ElFW8vbSF0xCT/czPXVhwDewKila1jOyRwa9AE19zKnrr7Cg5S3pJVrTWQ==} + engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0} + peerDependencies: + eslint: ^6.0.0 || ^7.0.0 || ^8.0.0 dependencies: '@eslint-community/eslint-utils': 4.4.0(eslint@8.57.0) '@types/json-schema': 7.0.15 @@ -8905,8 +4169,13 @@ snapshots: transitivePeerDependencies: - supports-color - typescript + dev: true - '@typescript-eslint/utils@5.62.0(eslint@8.57.0)(typescript@5.0.4)': + /@typescript-eslint/utils@5.62.0(eslint@8.57.0)(typescript@5.0.4): + resolution: {integrity: sha512-n8oxjeb5aIbPFEtmQxQYOLI0i9n5ySBEY/ZEHHZqKQSFnxio1rv6dthascc9dLuwrL0RC5mPCxB7vnAVGAYWAQ==} + engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0} + peerDependencies: + eslint: ^6.0.0 || ^7.0.0 || ^8.0.0 dependencies: '@eslint-community/eslint-utils': 4.4.0(eslint@8.57.0) '@types/json-schema': 7.0.15 @@ -8921,163 +4190,285 @@ snapshots: - supports-color - typescript - '@typescript-eslint/visitor-keys@5.61.0': + /@typescript-eslint/visitor-keys@5.61.0: + resolution: {integrity: sha512-50XQ5VdbWrX06mQXhy93WywSFZZGsv3EOjq+lqp6WC2t+j3mb6A9xYVdrRxafvK88vg9k9u+CT4l6D8PEatjKg==} + engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0} dependencies: '@typescript-eslint/types': 5.61.0 eslint-visitor-keys: 3.4.3 - '@typescript-eslint/visitor-keys@5.62.0': + /@typescript-eslint/visitor-keys@5.62.0: + resolution: {integrity: sha512-07ny+LHRzQXepkGg6w0mFY41fVUNBrL2Roj/++7V1txKugfjm/Ci/qSND03r2RhlJhJYMcTn9AhhSSqQp0Ysyw==} + engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0} dependencies: '@typescript-eslint/types': 5.62.0 eslint-visitor-keys: 3.4.3 - '@ungap/structured-clone@1.2.0': {} + /@ungap/structured-clone@1.2.0: + resolution: {integrity: sha512-zuVdFrMJiuCDQUMCzQaD6KL28MjnqqN8XnAqiEq9PNm/hCPTSGfrXCOfwj1ow4LFb/tNymJPwsNbVePc1xFqrQ==} - abbrev@1.0.9: {} + /abbrev@1.0.9: + resolution: {integrity: sha512-LEyx4aLEC3x6T0UguF6YILf+ntvmOaWsVfENmIW0E9H09vKlLDGelMjjSm0jkDHALj8A8quZ/HapKNigzwge+Q==} + dev: true - abitype@0.7.1(typescript@5.0.4)(zod@3.23.8): + /abitype@0.7.1(typescript@5.0.4): + resolution: {integrity: sha512-VBkRHTDZf9Myaek/dO3yMmOzB/y2s3Zo6nVU7yaw1G+TvCHAjwaJzNGN9yo4K5D8bU/VZXKP1EJpRhFr862PlQ==} + peerDependencies: + typescript: '>=4.9.4' + zod: ^3 >=3.19.1 + peerDependenciesMeta: + zod: + optional: true dependencies: typescript: 5.0.4 - optionalDependencies: - zod: 3.23.8 + dev: true - abitype@0.9.10(typescript@5.0.4)(zod@3.23.8): - optionalDependencies: + /abitype@0.9.10(typescript@5.0.4): + resolution: {integrity: sha512-FIS7U4n7qwAT58KibwYig5iFG4K61rbhAqaQh/UWj8v1Y8mjX3F8TC9gd8cz9yT1TYel9f8nS5NO5kZp2RW0jQ==} + peerDependencies: + typescript: '>=5.0.4' + zod: ^3 >=3.22.0 + peerDependenciesMeta: + typescript: + optional: true + zod: + optional: true + dependencies: typescript: 5.0.4 - zod: 3.23.8 + dev: false - abitype@1.0.0(typescript@5.0.4)(zod@3.23.8): - optionalDependencies: + /abitype@1.0.0(typescript@5.0.4): + resolution: {integrity: sha512-NMeMah//6bJ56H5XRj8QCV4AwuW6hB6zqz2LnhhLdcWVQOsXki6/Pn3APeqxCma62nXIcmZWdu1DlHWS74umVQ==} + peerDependencies: + typescript: '>=5.0.4' + zod: ^3 >=3.22.0 + peerDependenciesMeta: + typescript: + optional: true + zod: + optional: true + dependencies: typescript: 5.0.4 - zod: 3.23.8 + dev: true - abortcontroller-polyfill@1.7.5: {} + /abortcontroller-polyfill@1.7.5: + resolution: {integrity: sha512-JMJ5soJWP18htbbxJjG7bG6yuI6pRhgJ0scHHTfkUjf6wjP912xZWvM+A4sJK3gqd9E8fcPbDnOefbA9Th/FIQ==} - accepts@1.3.8: + /accepts@1.3.8: + resolution: {integrity: sha512-PYAthTa2m2VKxuvSD3DPC/Gy+U+sOA1LAuT8mkmRuvw+NACSaeXEQ+NHcVF7rONl6qcaxV3Uuemwawk+7+SJLw==} + engines: {node: '>= 0.6'} dependencies: mime-types: 2.1.35 negotiator: 0.6.3 - acorn-jsx@5.3.2(acorn@8.11.3): + /acorn-jsx@5.3.2(acorn@8.11.3): + resolution: {integrity: sha512-rq9s+JNhf0IChjtDXxllJ7g41oZk5SlXtp0LHwyA5cejwn7vKmKp4pPri6YEePv2PU65sAsegbXtIinmDFDXgQ==} + peerDependencies: + acorn: ^6.0.0 || ^7.0.0 || ^8.0.0 dependencies: acorn: 8.11.3 - acorn-walk@8.3.2: {} + /acorn-walk@8.3.2: + resolution: {integrity: sha512-cjkyv4OtNCIeqhHrfS81QWXoCBPExR/J62oyEqepVw8WaQeSqpW2uhuLPh1m9eWhDuOo/jUXVTlifvesOWp/4A==} + engines: {node: '>=0.4.0'} + dev: true - acorn@8.11.3: {} + /acorn@8.11.3: + resolution: {integrity: sha512-Y9rRfJG5jcKOE0CLisYbojUjIrIEE7AGMzA/Sm4BslANhbS+cDMpgBdcPT91oJ7OuJ9hYJBx59RjbhxVnrF8Xg==} + engines: {node: '>=0.4.0'} + hasBin: true - address@1.2.2: {} + /address@1.2.2: + resolution: {integrity: sha512-4B/qKCfeE/ODUaAUpSwfzazo5x29WD4r3vXiWsB7I2mSDAihwEqKO+g8GELZUQSSAo5e1XTYh3ZVfLyxBc12nA==} + engines: {node: '>= 10.0.0'} + dev: true - adm-zip@0.4.16: {} + /adm-zip@0.4.16: + resolution: {integrity: sha512-TFi4HBKSGfIKsK5YCkKaaFG2m4PEDyViZmEwof3MTIgzimHLto6muaHVpbrljdIvIrFZzEq/p4nafOeLcYegrg==} + engines: {node: '>=0.3.0'} + dev: false - aes-js@3.0.0: {} + /aes-js@3.0.0: + resolution: {integrity: sha512-H7wUZRn8WpTq9jocdxQ2c8x2sKo9ZVmzfRE13GiNJXfp7NcKYEdvl3vspKjXox6RIG2VtaRe4JFvxG4rqp2Zuw==} - aes-js@4.0.0-beta.5: {} + /aes-js@4.0.0-beta.5: + resolution: {integrity: sha512-G965FqalsNyrPqgEGON7nIx1e/OVENSgiEIzyC63haUMuvNnwIgIjMs52hlTCKhkBny7A2ORNlfY9Zu+jmGk1Q==} - agent-base@6.0.2: + /agent-base@6.0.2: + resolution: {integrity: sha512-RZNwNclF7+MS/8bDg70amg32dyeZGZxiDuQmZxKLAlQjr3jGyLx+4Kkk58UO7D2QdgFIQCovuSuZESne6RG6XQ==} + engines: {node: '>= 6.0.0'} dependencies: debug: 4.3.4(supports-color@8.1.1) transitivePeerDependencies: - supports-color + dev: false - aggregate-error@3.1.0: + /aggregate-error@3.1.0: + resolution: {integrity: sha512-4I7Td01quW/RpocfNayFdFVk1qSuoh0E7JrbRJ16nH01HhKFQ88INq9Sd+nd72zqRySlr9BmDA8xlEJ6vJMrYA==} + engines: {node: '>=8'} dependencies: clean-stack: 2.2.0 indent-string: 4.0.0 - ajv@5.5.2: + /ajv@5.5.2: + resolution: {integrity: sha512-Ajr4IcMXq/2QmMkEmSvxqfLN5zGmJ92gHXAeOXq1OekoH2rfDNsgdDoL2f7QaRCy7G/E6TpxBVdRuNraMztGHw==} dependencies: co: 4.6.0 fast-deep-equal: 1.1.0 fast-json-stable-stringify: 2.1.0 json-schema-traverse: 0.3.1 + dev: false - ajv@6.12.6: + /ajv@6.12.6: + resolution: {integrity: sha512-j3fVLgvTo527anyYyJOGTYJbG+vnnQYvE0m5mmkc1TK+nxAppkCLMIL0aZ4dblVCNoGShhm+kzE4ZUykBoMg4g==} dependencies: fast-deep-equal: 3.1.3 fast-json-stable-stringify: 2.1.0 json-schema-traverse: 0.4.1 uri-js: 4.4.1 - ajv@8.13.0: + /ajv@8.13.0: + resolution: {integrity: sha512-PRA911Blj99jR5RMeTunVbNXMF6Lp4vZXnk5GQjcnUWUTsrXtekg/pnmFFI2u/I36Y/2bITGS30GZCXei6uNkA==} dependencies: fast-deep-equal: 3.1.3 json-schema-traverse: 1.0.0 require-from-string: 2.0.2 uri-js: 4.4.1 - amdefine@1.0.1: + /amdefine@1.0.1: + resolution: {integrity: sha512-S2Hw0TtNkMJhIabBwIojKL9YHO5T0n5eNqWJ7Lrlel/zDbftQpxpapi8tZs3X1HWa+u+QeydGmzzNU0m09+Rcg==} + engines: {node: '>=0.4.2'} + requiresBuild: true + dev: true optional: true - ansi-align@3.0.1: + /ansi-align@3.0.1: + resolution: {integrity: sha512-IOfwwBF5iczOjp/WeY4YxyjqAFMQoZufdQWDd19SEExbVLNXqvpzSJ/M7Za4/sCPmQ0+GRquoA7bGcINcxew6w==} dependencies: string-width: 4.2.3 + dev: false - ansi-colors@4.1.1: {} + /ansi-colors@4.1.1: + resolution: {integrity: sha512-JoX0apGbHaUJBNl6yF+p6JAFYZ666/hhCGKN5t9QFjbJQKUU/g8MNbFDbvfrgKXvI1QpZplPOnwIo99lX/AAmA==} + engines: {node: '>=6'} - ansi-colors@4.1.3: {} + /ansi-colors@4.1.3: + resolution: {integrity: sha512-/6w/C21Pm1A7aZitlI5Ni/2J6FFQN8i1Cvz3kHABAAbw93v/NlvKdVOqz7CCWz/3iv/JplRSEEZ83XION15ovw==} + engines: {node: '>=6'} - ansi-escapes@4.3.2: + /ansi-escapes@4.3.2: + resolution: {integrity: sha512-gKXj5ALrKWQLsYG9jlTRmR/xKluxHV+Z9QEwNIgCfM1/uwPMCuzVVnh5mwTd+OuBZcwSIMbqssNWRm1lE51QaQ==} + engines: {node: '>=8'} dependencies: type-fest: 0.21.3 + dev: false - ansi-regex@2.1.1: {} + /ansi-regex@2.1.1: + resolution: {integrity: sha512-TIGnTpdo+E3+pCyAluZvtED5p5wCqLdezCyhPZzKPcxvFplEt4i+W7OONCKgeZFT3+y5NZZfOOS/Bdcanm1MYA==} + engines: {node: '>=0.10.0'} + dev: false - ansi-regex@3.0.1: {} + /ansi-regex@3.0.1: + resolution: {integrity: sha512-+O9Jct8wf++lXxxFc4hc8LsjaSq0HFzzL7cVsw8pRDIPdjKD2mT4ytDZlLuSBZ4cLKZFXIrMGO7DbQCtMJJMKw==} + engines: {node: '>=4'} - ansi-regex@5.0.1: {} + /ansi-regex@5.0.1: + resolution: {integrity: sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ==} + engines: {node: '>=8'} - ansi-styles@1.0.0: {} + /ansi-styles@1.0.0: + resolution: {integrity: sha512-3iF4FIKdxaVYT3JqQuY3Wat/T2t7TRbbQ94Fu50ZUCbLy4TFbTzr90NOHQodQkNqmeEGCw8WbeP78WNi6SKYUA==} + engines: {node: '>=0.8.0'} + dev: true - ansi-styles@3.2.1: + /ansi-styles@3.2.1: + resolution: {integrity: sha512-VT0ZI6kZRdTh8YyJw3SMbYm/u+NqfsAxEpWO0Pf9sq8/e94WxxOpPKx9FR1FlyCtOVDNOQ+8ntlqFxiRc+r5qA==} + engines: {node: '>=4'} dependencies: color-convert: 1.9.3 - ansi-styles@4.3.0: + /ansi-styles@4.3.0: + resolution: {integrity: sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==} + engines: {node: '>=8'} dependencies: color-convert: 2.0.1 - ansi-styles@5.2.0: {} + /ansi-styles@5.2.0: + resolution: {integrity: sha512-Cxwpt2SfTzTtXcfOlzGEee8O+c+MmUgGrNiBcXnuWxuFJHe6a5Hz7qwhwe5OgaSYI0IJvkLqWX1ASG+cJOkEiA==} + engines: {node: '>=10'} + dev: true - antlr4@4.13.1: {} + /antlr4@4.13.1: + resolution: {integrity: sha512-kiXTspaRYvnIArgE97z5YVVf/cDVQABr3abFRR6mE7yesLMkgu4ujuyV/sgxafQ8wgve0DJQUJ38Z8tkgA2izA==} + engines: {node: '>=16'} + dev: false - antlr4@4.8.0: {} + /antlr4@4.8.0: + resolution: {integrity: sha512-en/MxQ4OkPgGJQ3wD/muzj1uDnFSzdFIhc2+c6bHZokWkuBb6RRvFjpWhPxWLbgQvaEzldJZ0GSQpfSAaE3hqg==} + dev: false - antlr4ts@0.5.0-alpha.4: {} + /antlr4ts@0.5.0-alpha.4: + resolution: {integrity: sha512-WPQDt1B74OfPv/IMS2ekXAKkTZIHl88uMetg6q3OTqgFxZ/dxDXI0EWLyZid/1Pe6hTftyg5N7gel5wNAGxXyQ==} - any-promise@1.3.0: {} + /any-promise@1.3.0: + resolution: {integrity: sha512-7UvmKalWRt1wgjL1RrGxoSJW/0QZFIegpeGvZG9kjp8vrRu55XTHbwnqq2GpXm9uLbcuhxm3IqX9OB4MZR1b2A==} + dev: false - anymatch@3.1.3: + /anymatch@3.1.3: + resolution: {integrity: sha512-KMReFUr0B4t+D+OBkjR3KYqvocp2XaSzO55UcB6mgQMd3KbcE+mWTyvVV7D/zsdEbNnV6acZUutkiHQXvTr1Rw==} + engines: {node: '>= 8'} dependencies: normalize-path: 3.0.0 picomatch: 2.3.1 - append-transform@2.0.0: + /append-transform@2.0.0: + resolution: {integrity: sha512-7yeyCEurROLQJFv5Xj4lEGTy0borxepjFv1g22oAdqFu//SrAlDl1O1Nxx15SH1RoliUml6p8dwJW9jvZughhg==} + engines: {node: '>=8'} dependencies: default-require-extensions: 3.0.1 + dev: true - archy@1.0.0: {} + /archy@1.0.0: + resolution: {integrity: sha512-Xg+9RwCg/0p32teKdGMPTPnVXKD0w3DfHnFTficozsAgsvq2XenPJq/MYpzzQ/v8zrOyJn6Ds39VA4JIDwFfqw==} + dev: true - arg@4.1.3: {} + /arg@4.1.3: + resolution: {integrity: sha512-58S9QDqG0Xx27YwPSt9fJxivjYl432YCwfDMfZ+71RAqUrZef7LrKQZ3LHLOwCS4FLNBplP533Zx895SeOCHvA==} + dev: true - argparse@1.0.10: + /argparse@1.0.10: + resolution: {integrity: sha512-o5Roy6tNG4SL/FOkCAN6RzjiakZS25RLYFrcMttJqbdd8BWrnA+fGz57iN5Pb06pvBGvl5gQ0B48dJlslXvoTg==} dependencies: sprintf-js: 1.0.3 + dev: true - argparse@2.0.1: {} + /argparse@2.0.1: + resolution: {integrity: sha512-8+9WqebbFzpX9OR+Wa6O29asIogeRMzcGtAINdpMHHyAg10f05aSFVBbcEqGf/PXw1EjAZ+q2/bEBg3DvurK3Q==} - array-back@3.1.0: {} + /array-back@3.1.0: + resolution: {integrity: sha512-TkuxA4UCOvxuDK6NZYXCalszEzj+TLszyASooky+i742l9TqsOdYCMJJupxRic61hwquNtppB3hgcuq9SVSH1Q==} + engines: {node: '>=6'} + dev: true - array-back@4.0.2: {} + /array-back@4.0.2: + resolution: {integrity: sha512-NbdMezxqf94cnNfWLL7V/im0Ub+Anbb0IoZhvzie8+4HJ4nMQuzHuy49FkGYCJK2yAloZ3meiB6AVMClbrI1vg==} + engines: {node: '>=8'} + dev: true - array-buffer-byte-length@1.0.1: + /array-buffer-byte-length@1.0.1: + resolution: {integrity: sha512-ahC5W1xgou+KTXix4sAO8Ki12Q+jf4i0+tmk3sC+zgcynshkHxzpXdImBehiUYKKKDwvfFiJl1tZt6ewscS1Mg==} + engines: {node: '>= 0.4'} dependencies: call-bind: 1.0.7 is-array-buffer: 3.0.4 + dev: true - array-flatten@1.1.1: {} + /array-flatten@1.1.1: + resolution: {integrity: sha512-PCVAQswWemu6UdxsDFFX/+gVeYqKAod3D3UVm91jHwynguOwAvYPhx8nNlM++NqRcK6CxxpUafjmhIdKiHibqg==} - array-includes@3.1.8: + /array-includes@3.1.8: + resolution: {integrity: sha512-itaWrbYbqpGXkGhZPGUulwnhVf5Hpy1xiCFsGqyIGglbBxmG5vSjxQen3/WGOjPpNEv1RtBLKxbmVXm8HpJStQ==} + engines: {node: '>= 0.4'} dependencies: call-bind: 1.0.7 define-properties: 1.2.1 @@ -9085,26 +4476,40 @@ snapshots: es-object-atoms: 1.0.0 get-intrinsic: 1.2.4 is-string: 1.0.7 + dev: true - array-union@2.1.0: {} + /array-union@2.1.0: + resolution: {integrity: sha512-HGyxoOTYUyCM6stUe6EJgnd4EoewAI7zMdfqO+kGjnlZmBDz/cR5pf8r/cR4Wq60sL/p0IkcjUEEPwS3GFrIyw==} + engines: {node: '>=8'} - array-uniq@1.0.3: {} + /array-uniq@1.0.3: + resolution: {integrity: sha512-MNha4BWQ6JbwhFhj03YK552f7cb3AzoE8SzeljgChvL1dl3IcvggXVz1DilzySZkCja+CXuZbdW7yATchWn8/Q==} + engines: {node: '>=0.10.0'} + dev: true - array.prototype.flat@1.3.2: + /array.prototype.flat@1.3.2: + resolution: {integrity: sha512-djYB+Zx2vLewY8RWlNCUdHjDXs2XOgm602S9E7P/UpHgfeHL00cRiIF+IN/G/aUJ7kGPb6yO/ErDI5V2s8iycA==} + engines: {node: '>= 0.4'} dependencies: call-bind: 1.0.7 define-properties: 1.2.1 es-abstract: 1.23.3 es-shim-unscopables: 1.0.2 + dev: true - array.prototype.flatmap@1.3.2: + /array.prototype.flatmap@1.3.2: + resolution: {integrity: sha512-Ewyx0c9PmpcsByhSW4r+9zDU7sGjFc86qf/kKtuSCRdhfbk0SNLLkaT5qvcHnRGgc5NP/ly/y+qkXkqONX54CQ==} + engines: {node: '>= 0.4'} dependencies: call-bind: 1.0.7 define-properties: 1.2.1 es-abstract: 1.23.3 es-shim-unscopables: 1.0.2 + dev: true - arraybuffer.prototype.slice@1.0.3: + /arraybuffer.prototype.slice@1.0.3: + resolution: {integrity: sha512-bMxMKAjg13EBSVscxTaYA4mRc5t1UAXa2kXiGTNfZ079HIWXEkKmkgFrh/nJqamaLSrXO5H4WFFkPEaLJWbs3A==} + engines: {node: '>= 0.4'} dependencies: array-buffer-byte-length: 1.0.1 call-bind: 1.0.7 @@ -9114,46 +4519,75 @@ snapshots: get-intrinsic: 1.2.4 is-array-buffer: 3.0.4 is-shared-array-buffer: 1.0.3 + dev: true - arrify@1.0.1: {} + /arrify@1.0.1: + resolution: {integrity: sha512-3CYzex9M9FGQjCGMGyi6/31c8GJbgb0qGyrx5HWxPd0aCwh4cB2YjMb2Xf9UuoogrMrlO9cTqnB5rI5GHZTcUA==} + engines: {node: '>=0.10.0'} + dev: true - asap@2.0.6: {} + /asap@2.0.6: + resolution: {integrity: sha512-BSHWgDSAiKs50o2Re8ppvp3seVHXSRM44cdSsT9FfNEUUZLOGWVCsiWaRPWM1Znn+mqZ1OfVZ3z3DWEzSp7hRA==} + dev: true - asn1@0.2.6: + /asn1@0.2.6: + resolution: {integrity: sha512-ix/FxPn0MDjeyJ7i/yoHGFt/EX6LyNbxSEhPPXODPL+KB0VPk86UYfL0lMdy+KCnv+fmvIzySwaK5COwqVbWTQ==} dependencies: safer-buffer: 2.1.2 - assert-plus@1.0.0: {} + /assert-plus@1.0.0: + resolution: {integrity: sha512-NfJ4UzBCcQGLDlQq7nHxH+tv3kyZ0hHQqF5BO6J7tNJeP5do1llPr8dZ8zHonfhAu0PHAdMkSo+8o0wxg9lZWw==} + engines: {node: '>=0.8'} - assertion-error@1.1.0: {} + /assertion-error@1.1.0: + resolution: {integrity: sha512-jgsaNduz+ndvGyFt3uSuWqvy4lCnIJiovtouQN5JZHOKCS2QuhEdbcQHFhVksz2N2U9hXJo8odG7ETyWlEeuDw==} - ast-parents@0.0.1: {} + /ast-parents@0.0.1: + resolution: {integrity: sha512-XHusKxKz3zoYk1ic8Un640joHbFMhbqneyoZfoKnEGtf2ey9Uh/IdpcQplODdO/kENaMIWsD0nJm4+wX3UNLHA==} + dev: false - astral-regex@2.0.0: {} + /astral-regex@2.0.0: + resolution: {integrity: sha512-Z7tMw1ytTXt5jqMcOP+OQteU1VuNK9Y02uuJtKQ1Sv69jXQKKg5cibLwGJow8yzZP+eAc18EmLGPal0bp36rvQ==} + engines: {node: '>=8'} + dev: false - async-limiter@1.0.1: {} + /async-limiter@1.0.1: + resolution: {integrity: sha512-csOlWGAcRFJaI6m+F2WKdnMKr4HhdhFVBk0H/QbJFMCr+uO2kwohwXQPxw/9OCxp05r5ghVBFSyioixx3gfkNQ==} - async@1.5.2: {} + /async@1.5.2: + resolution: {integrity: sha512-nSVgobk4rv61R9PUSDtYt7mPVB2olxNR5RWJcAsH676/ef11bUZwvu7+RGYrYauVdDPcO519v68wRhXQtxsV9w==} + dev: true - asynckit@0.4.0: {} + /asynckit@0.4.0: + resolution: {integrity: sha512-Oei9OH4tRh0YqU3GxhX79dM/mwVgvbZJaSNaRk+bshkj0S5cfHcgYakreBjrHwatXKbz+IoIdYLxrKim2MjW0Q==} - at-least-node@1.0.0: {} + /at-least-node@1.0.0: + resolution: {integrity: sha512-+q/t7Ekv1EDY2l6Gda6LLiX14rU9TV20Wa3ofeQmwPFZbOMo9DXrLbOjFaaclkXKWidIaopwAObQDqwWtGUjqg==} + engines: {node: '>= 4.0.0'} + dev: true - available-typed-arrays@1.0.7: + /available-typed-arrays@1.0.7: + resolution: {integrity: sha512-wvUjBtSGN7+7SjNpq/9M2Tg350UZD3q62IFZLbRAR1bSMlCo1ZaeW+BJ+D090e4hIIZLBcTDWe4Mh4jvUDajzQ==} + engines: {node: '>= 0.4'} dependencies: possible-typed-array-names: 1.0.0 - aws-sign2@0.7.0: {} + /aws-sign2@0.7.0: + resolution: {integrity: sha512-08kcGqnYf/YmjoRhfxyu+CLxBjUtHLXLXX/vUfx9l2LYzG3c1m61nrpyFUZI6zeS+Li/wWMMidD9KgrqtGq3mA==} - aws4@1.12.0: {} + /aws4@1.12.0: + resolution: {integrity: sha512-NmWvPnx0F1SfrQbYwOi7OeaNGokp9XhzNioJ/CSBs8Qa4vxug81mhJEAVZwxXuBmYB5KDRfMq/F3RR0BIU7sWg==} - axios@0.21.4: + /axios@0.21.4: + resolution: {integrity: sha512-ut5vewkiu8jjGBdqpM44XxjuCjq9LAKeHVmoVfHVzy8eHgxxq8SbAVQNovDA8mVi05kP0Ea/n/UzcSHcTJQfNg==} dependencies: follow-redirects: 1.15.6(debug@4.3.4) transitivePeerDependencies: - debug + dev: false - axios@1.6.8(debug@4.3.4): + /axios@1.6.8(debug@4.3.4): + resolution: {integrity: sha512-v/ZHtJDU39mDpyBoFVkETcd/uNdxrWRrg3bKpOKzXFA6Bvqopts6ALSMU3y6ijYxbw2B+wPrIv46egTzJXCLGQ==} dependencies: follow-redirects: 1.15.6(debug@4.3.4) form-data: 4.0.0 @@ -9161,62 +4595,91 @@ snapshots: transitivePeerDependencies: - debug - balanced-match@1.0.2: {} + /balanced-match@1.0.2: + resolution: {integrity: sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw==} - base-x@3.0.9: + /base-x@3.0.9: + resolution: {integrity: sha512-H7JU6iBHTal1gp56aKoaa//YUxEaAOUiydvrV/pILqIHXTtqxSkATOnDA2u+jZ/61sD+L/412+7kzXRtWukhpQ==} dependencies: safe-buffer: 5.2.1 - base64-js@1.5.1: {} + /base64-js@1.5.1: + resolution: {integrity: sha512-AKpaYlHn8t4SVbOHCy+b5+KKgvR4vrsD8vbvrbiQJps7fKDTkjkDry6ji0rUJjC0kzbNePLwzxq8iypo41qeWA==} - bcrypt-pbkdf@1.0.2: + /bcrypt-pbkdf@1.0.2: + resolution: {integrity: sha512-qeFIXtP4MSoi6NLqO12WfqARWWuCKi2Rn/9hJLEmtB5yTNr9DqFWkJRCf2qShWzPeAMRnOgCrq0sg/KLv5ES9w==} dependencies: tweetnacl: 0.14.5 - bech32@1.1.4: {} + /bech32@1.1.4: + resolution: {integrity: sha512-s0IrSOzLlbvX7yp4WBfPITzpAU8sqQcpsmwXDiKwrG4r491vwCO/XpejasRNl0piBMe/DvP4Tz0mIS/X1DPJBQ==} - better-path-resolve@1.0.0: + /better-path-resolve@1.0.0: + resolution: {integrity: sha512-pbnl5XzGBdrFU/wT4jqmJVPn2B6UHPBOhzMQkY/SPUPB6QtUXtmBHBIwCbXJol93mOpGMnQyP/+BB19q04xj7g==} + engines: {node: '>=4'} dependencies: is-windows: 1.0.2 + dev: true - big-integer@1.6.36: {} - - big.js@6.2.1: {} + /big-integer@1.6.36: + resolution: {integrity: sha512-t70bfa7HYEA1D9idDbmuv7YbsbVkQ+Hp+8KFSul4aE5e/i1bjCNIRYJZlA8Q8p0r9T8cF/RVvwUgRA//FydEyg==} + engines: {node: '>=0.6'} + dev: false - bignumber.js@7.2.1: {} + /big.js@6.2.1: + resolution: {integrity: sha512-bCtHMwL9LeDIozFn+oNhhFoq+yQ3BNdnsLSASUxLciOb1vgvpHsIO1dsENiGMgbb4SkP5TrzWzRiLddn8ahVOQ==} + dev: false - bignumber.js@9.1.2: {} + /bignumber.js@7.2.1: + resolution: {integrity: sha512-S4XzBk5sMB+Rcb/LNcpzXr57VRTxgAvaAEDAl1AwRx27j00hT84O6OkteE7u8UB3NuaaygCRrEpqox4uDOrbdQ==} + dev: false - bignumber.js@https://codeload.github.com/frozeman/bignumber.js-nolookahead/tar.gz/57692b3ecfc98bbdd6b3a516cb2353652ea49934: {} + /bignumber.js@9.1.2: + resolution: {integrity: sha512-2/mKyZH9K85bzOEfhXDBFZTGd1CTs+5IHpeFQo9luiBG7hghdC851Pj2WAhb6E3R6b9tZj/XKhbg4fum+Kepug==} - binary-extensions@2.3.0: {} + /binary-extensions@2.3.0: + resolution: {integrity: sha512-Ceh+7ox5qe7LJuLHoY0feh3pHuUDHAcRUeyL2VYghZwfpkNIy/+8Ocg0a3UuSoYzavmylwuLWQOf3hl0jjMMIw==} + engines: {node: '>=8'} - bindings@1.5.0: + /bindings@1.5.0: + resolution: {integrity: sha512-p2q/t/mhvuOj/UeLlV6566GD/guowlr0hHxClI0W9m7MWYkL1F0hLo+0Aexs9HSPCtR1SXQ0TD3MMKrXZajbiQ==} dependencies: file-uri-to-path: 1.0.0 + dev: false - bl@4.1.0: + /bl@4.1.0: + resolution: {integrity: sha512-1W07cM9gS6DcLperZfFSj+bWLtaPGSOHWhPiGzXmvVJbRLdG82sH/Kn8EtW1VqWVA54AKf2h5k5BbnIbwF3h6w==} dependencies: buffer: 5.7.1 inherits: 2.0.4 readable-stream: 3.6.2 + dev: false - blakejs@1.2.1: {} + /blakejs@1.2.1: + resolution: {integrity: sha512-QXUSXI3QVc/gJME0dBpXrag1kbzOqCjCX8/b54ntNyW6sjtoqxqRk3LTmXzaJoh71zMsDCjM+47jS7XiwN/+fQ==} - bluebird@3.7.2: {} + /bluebird@3.7.2: + resolution: {integrity: sha512-XpNj6GDQzdfW+r2Wnn7xiSAd7TM3jzkxGXBGTtWKuSXv1xUV+azxAm8jdWZN06QTQk+2N2XB9jRDkvbmQmcRtg==} - bn-str-256@1.9.1: + /bn-str-256@1.9.1: + resolution: {integrity: sha512-u3muv3WO5sYv9nUQsPnDGLg731yNt/MOlKPK5pmBVqClcl7tY97tyfKxw8ed44HVrpi+7dkgJgQpbXP47a3GoQ==} dependencies: decimal.js-light: 2.5.1 lodash: 4.17.21 + dev: false - bn.js@4.11.6: {} + /bn.js@4.11.6: + resolution: {integrity: sha512-XWwnNNFCuuSQ0m3r3C4LE3EiORltHd9M05pq6FOlVeiophzRbMo50Sbz1ehl8K3Z+jw9+vmgnXefY1hz8X+2wA==} - bn.js@4.12.0: {} + /bn.js@4.12.0: + resolution: {integrity: sha512-c98Bf3tPniI+scsdk237ku1Dc3ujXQTSgyiPUDEOe7tRkhrqridvh8klBv0HCEso1OLOYcHuCv/cS6DNxKH+ZA==} - bn.js@5.2.1: {} + /bn.js@5.2.1: + resolution: {integrity: sha512-eXRvHzWyYPBuB4NBy0cmYQjGitUrtqwbvlzP3G6VFnNRbsZQIxQ10PbKKHt8gZ/HW/D/747aDl+QkDqg3KQLMQ==} - body-parser@1.20.2: + /body-parser@1.20.2: + resolution: {integrity: sha512-ml9pReCu3M61kGlqoTm2umSXTlRTuGTx0bfYj+uIUKKYycG5NtSbeetV3faSU6R7ajOPw0g/J1PvK4qNy7s5bA==} + engines: {node: '>= 0.8', npm: 1.2.8000 || >= 1.4.16} dependencies: bytes: 3.1.2 content-type: 1.0.5 @@ -9233,11 +4696,17 @@ snapshots: transitivePeerDependencies: - supports-color - boolbase@1.0.0: {} + /boolbase@1.0.0: + resolution: {integrity: sha512-JZOSA7Mo9sNGB8+UjSgzdLtokWAky1zbztM3WRLCbZ70/3cTANmQmOdR7y2g+J0e2WXywy1yS468tY+IruqEww==} + dev: false - boolean@3.2.0: {} + /boolean@3.2.0: + resolution: {integrity: sha512-d0II/GO9uf9lfUHH2BQsjxzRJZBdsjgsBiW4BvhWk/3qoKwQFjIDVN19PfX8F2D/r9PCMTtLWjYVCFrpeYUzsw==} + dev: true - boxen@5.1.2: + /boxen@5.1.2: + resolution: {integrity: sha512-9gYgQKXx+1nP8mP7CzFyaUARhg7D3n1dF/FnErWmu9l6JvGpNUN278h0aSb+QjoiKSWG+iZ3uHrcqk0qrY9RQQ==} + engines: {node: '>=10'} dependencies: ansi-align: 3.0.1 camelcase: 6.3.0 @@ -9247,29 +4716,39 @@ snapshots: type-fest: 0.20.2 widest-line: 3.1.0 wrap-ansi: 7.0.0 + dev: false - brace-expansion@1.1.11: + /brace-expansion@1.1.11: + resolution: {integrity: sha512-iCuPHDFgrHX7H2vEI/5xpz07zSHB00TpugqhmYtVmMO6518mCuRMoOYFldEBl0g187ufozdaHgWKcYFb61qGiA==} dependencies: balanced-match: 1.0.2 concat-map: 0.0.1 - brace-expansion@2.0.1: + /brace-expansion@2.0.1: + resolution: {integrity: sha512-XnAIvQ8eM+kC6aULx6wuQiwVsnzsi9d3WxzV3FpWTGA19F621kwdbsAcFKXgKUHZWsy+mY6iL1sHTxWEFCytDA==} dependencies: balanced-match: 1.0.2 - braces@3.0.2: + /braces@3.0.2: + resolution: {integrity: sha512-b8um+L1RzM3WDSzvhm6gIz1yfTbBt6YTlcEKAvsmqCZZFw46z626lVj9j1yEPW33H5H+lBQpZMP1k8l+78Ha0A==} + engines: {node: '>=8'} dependencies: fill-range: 7.0.1 - breakword@1.0.6: + /breakword@1.0.6: + resolution: {integrity: sha512-yjxDAYyK/pBvws9H4xKYpLDpYKEH6CzrBPAuXq3x18I+c/2MkVtT3qAr7Oloi6Dss9qNhPVueAAVU1CSeNDIXw==} dependencies: wcwidth: 1.0.1 + dev: true - brorand@1.1.0: {} + /brorand@1.1.0: + resolution: {integrity: sha512-cKV8tMCEpQs4hK/ik71d6LrPOnpkpGBR0wzxqr68g2m/LB2GxVYQroAjMJZRVM1Y4BCjCKc3vAamxSzOY2RP+w==} - browser-stdout@1.3.1: {} + /browser-stdout@1.3.1: + resolution: {integrity: sha512-qhAVI1+Av2X7qelOfAIYwXONood6XlZE/fXaBSmW/T5SzLAmCgzi+eiWE7fUvbHaeNBQH13UftjpXxsfLkMpgw==} - browserify-aes@1.2.0: + /browserify-aes@1.2.0: + resolution: {integrity: sha512-+7CHXqGuspUn/Sl5aO7Ea0xWGAtETPXNSAjHo48JfLdPWcMng33Xe4znFvQweqc/uzk5zSOI3H52CYnjCfb5hA==} dependencies: buffer-xor: 1.0.3 cipher-base: 1.0.4 @@ -9278,56 +4757,83 @@ snapshots: inherits: 2.0.4 safe-buffer: 5.2.1 - browserslist@4.23.0: + /browserslist@4.23.0: + resolution: {integrity: sha512-QW8HiM1shhT2GuzkvklfjcKDiWFXHOeFCIA/huJPwHsslwcydgk7X+z2zXpEijP98UCY7HbubZt5J2Zgvf0CaQ==} + engines: {node: ^6 || ^7 || ^8 || ^9 || ^10 || ^11 || ^12 || >=13.7} + hasBin: true dependencies: caniuse-lite: 1.0.30001617 electron-to-chromium: 1.4.761 node-releases: 2.0.14 update-browserslist-db: 1.0.15(browserslist@4.23.0) + dev: true - bs58@4.0.1: + /bs58@4.0.1: + resolution: {integrity: sha512-Ok3Wdf5vOIlBrgCvTq96gBkJw+JUEzdBgyaza5HLtPm7yTHkjRy8+JzNyHF7BHa0bNWOQIp3m5YF0nnFcOIKLw==} dependencies: base-x: 3.0.9 - bs58check@2.1.2: + /bs58check@2.1.2: + resolution: {integrity: sha512-0TS1jicxdU09dwJMNZtVAfzPi6Q6QeN0pM1Fkzrjn+XYHvzMKPU3pHVpva+769iNVSfIYWf7LJ6WR+BuuMf8cA==} dependencies: bs58: 4.0.1 create-hash: 1.2.0 safe-buffer: 5.2.1 - buffer-from@1.1.2: {} + /buffer-from@1.1.2: + resolution: {integrity: sha512-E+XQCRwSbaaiChtv6k6Dwgc+bx+Bs6vuKJHHl5kox/BaKbhiXzqQOwK4cO22yElGp2OCmjwVhT3HmxgyPGnJfQ==} - buffer-to-arraybuffer@0.0.5: {} + /buffer-to-arraybuffer@0.0.5: + resolution: {integrity: sha512-3dthu5CYiVB1DEJp61FtApNnNndTckcqe4pFcLdvHtrpG+kcyekCJKg4MRiDcFW7A6AODnXB9U4dwQiCW5kzJQ==} - buffer-xor@1.0.3: {} + /buffer-xor@1.0.3: + resolution: {integrity: sha512-571s0T7nZWK6vB67HI5dyUF7wXiNcfaPPPTl6zYCNApANjIvYJTg7hlud/+cJpdAhS7dVzqMLmfhfHR3rAcOjQ==} - buffer@5.7.1: + /buffer@5.7.1: + resolution: {integrity: sha512-EHcyIPBQ4BSGlvjB16k5KgAJ27CIsHY/2JBmCRReo48y9rQ3MaUzWX3KVlBa4U7MyX02HdVj0K7C3WaB3ju7FQ==} dependencies: base64-js: 1.5.1 ieee754: 1.2.1 - buffer@6.0.3: + /buffer@6.0.3: + resolution: {integrity: sha512-FTiCpNxtwiZZHEZbcbTIcZjERVICn9yq/pDFkTl95/AxzD1naBctN7YO68riM/gLSDY7sdrMby8hofADYuuqOA==} dependencies: base64-js: 1.5.1 ieee754: 1.2.1 - bufferutil@4.0.8: + /bufferutil@4.0.8: + resolution: {integrity: sha512-4T53u4PdgsXqKaIctwF8ifXlRTTmEPJ8iEPWFdGZvcf7sbwYo6FKFEX9eNNAnzFZ7EzJAQ3CJeOtCRA4rDp7Pw==} + engines: {node: '>=6.14.2'} + requiresBuild: true dependencies: node-gyp-build: 4.8.1 - builtin-modules@3.3.0: {} + /builtin-modules@3.3.0: + resolution: {integrity: sha512-zhaCDicdLuWN5UbN5IMnFqNMhNfo919sH85y2/ea+5Yg9TsTkeZxpL+JLbp6cgYFS4sRLp3YV4S6yDuqVWHYOw==} + engines: {node: '>=6'} + dev: true - builtins@5.1.0: + /builtins@5.1.0: + resolution: {integrity: sha512-SW9lzGTLvWTP1AY8xeAMZimqDrIaSdLQUcVr9DMef51niJ022Ri87SwRRKYm4A6iHfkPaiVUu/Duw2Wc4J7kKg==} dependencies: semver: 7.6.2 + dev: true - bytes@3.1.2: {} + /bytes@3.1.2: + resolution: {integrity: sha512-/Nf7TyzTx6S3yRJObOAV7956r8cr2+Oj8AC5dt8wSP3BQAoeX58NoHyCU8P8zGkNXStjTSi6fzO6F0pBdcYbEg==} + engines: {node: '>= 0.8'} - cacheable-lookup@5.0.4: {} + /cacheable-lookup@5.0.4: + resolution: {integrity: sha512-2/kNscPhpcxrOigMZzbiWF7dz8ilhb/nIHU3EyZiXWXpeq/au8qJ8VhdftMkty3n7Gj6HIGalQG8oiBNB3AJgA==} + engines: {node: '>=10.6.0'} - cacheable-lookup@6.1.0: {} + /cacheable-lookup@6.1.0: + resolution: {integrity: sha512-KJ/Dmo1lDDhmW2XDPMo+9oiy/CeqosPguPCrgcVzKyZrL6pM1gU2GmPY/xo6OQPTUaA/c0kwHuywB4E6nmT9ww==} + engines: {node: '>=10.6.0'} - cacheable-request@7.0.4: + /cacheable-request@7.0.4: + resolution: {integrity: sha512-v+p6ongsrp0yTGbJXjgxPow2+DL93DASP4kXCDKb8/bwRtt9OEF3whggkkDkGNzgcWy2XaF4a8nZglC7uElscg==} + engines: {node: '>=8'} dependencies: clone-response: 1.0.3 get-stream: 5.2.0 @@ -9337,14 +4843,19 @@ snapshots: normalize-url: 6.1.0 responselike: 2.0.1 - caching-transform@4.0.0: + /caching-transform@4.0.0: + resolution: {integrity: sha512-kpqOvwXnjjN44D89K5ccQC+RUrsy7jB/XLlRrx0D7/2HNcTPqzsb6XgYoErwko6QsV184CA2YgS1fxDiiDZMWA==} + engines: {node: '>=8'} dependencies: hasha: 5.2.2 make-dir: 3.1.0 package-hash: 4.0.0 write-file-atomic: 3.0.3 + dev: true - call-bind@1.0.7: + /call-bind@1.0.7: + resolution: {integrity: sha512-GHTSNSYICQ7scH7sZ+M2rFopRoLh8t2bLSW6BbgrtLsahOIB5iyAVJf9GjWK3cYTDaMj4XdBpM1cA6pIS0Kv2w==} + engines: {node: '>= 0.4'} dependencies: es-define-property: 1.0.0 es-errors: 1.3.0 @@ -9352,50 +4863,85 @@ snapshots: get-intrinsic: 1.2.4 set-function-length: 1.2.2 - callsites@3.1.0: {} + /callsites@3.1.0: + resolution: {integrity: sha512-P8BjAsXvZS+VIDUI11hHCQEv74YT67YUi5JJFNWIqL235sBmjX4+qx9Muvls5ivyNENctx46xQLQ3aTuE7ssaQ==} + engines: {node: '>=6'} - camel-case@3.0.0: + /camel-case@3.0.0: + resolution: {integrity: sha512-+MbKztAYHXPr1jNTSKQF52VpcFjwY5RkR7fxksV8Doo4KAYc5Fl4UJRgthBbTmEx8C54DqahhbLJkDwjI3PI/w==} dependencies: no-case: 2.3.2 upper-case: 1.1.3 + dev: false - camelcase-keys@6.2.2: + /camelcase-keys@6.2.2: + resolution: {integrity: sha512-YrwaA0vEKazPBkn0ipTiMpSajYDSe+KjQfrjhcBMxJt/znbvlHd8Pw/Vamaz5EB4Wfhs3SUR3Z9mwRu/P3s3Yg==} + engines: {node: '>=8'} dependencies: camelcase: 5.3.1 map-obj: 4.3.0 quick-lru: 4.0.1 + dev: true - camelcase@3.0.0: {} + /camelcase@3.0.0: + resolution: {integrity: sha512-4nhGqUkc4BqbBBB4Q6zLuD7lzzrHYrjKGeYaEji/3tFR5VdJu9v+LilhGIVe8wxEJPPOeWo7eg8dwY13TZ1BNg==} + engines: {node: '>=0.10.0'} + dev: false - camelcase@4.1.0: {} + /camelcase@4.1.0: + resolution: {integrity: sha512-FxAv7HpHrXbh3aPo4o2qxHay2lkLY3x5Mw3KeE4KQE8ysVfziWeRZDwcjauvwBSGEC/nXUPzZy8zeh4HokqOnw==} + engines: {node: '>=4'} + dev: false - camelcase@5.3.1: {} + /camelcase@5.3.1: + resolution: {integrity: sha512-L28STB170nwWS63UjtlEOE3dldQApaJXZkOI1uMFfzf3rRuPegHaHesyee+YxQ+W6SvRDQV6UrdOdRiR153wJg==} + engines: {node: '>=6'} + dev: true - camelcase@6.3.0: {} + /camelcase@6.3.0: + resolution: {integrity: sha512-Gmy6FhYlCY7uOElZUSbxo2UCDH8owEk996gkbrpsgGtrJLM3J7jGxl9Ic7Qwwj4ivOE5AWZWRMecDdF7hqGjFA==} + engines: {node: '>=10'} - caniuse-lite@1.0.30001617: {} + /caniuse-lite@1.0.30001617: + resolution: {integrity: sha512-mLyjzNI9I+Pix8zwcrpxEbGlfqOkF9kM3ptzmKNw5tizSyYwMe+nGLTqMK9cO+0E+Bh6TsBxNAaHWEM8xwSsmA==} + dev: true - caseless@0.12.0: {} + /caseless@0.12.0: + resolution: {integrity: sha512-4tYFyifaFfGacoiObjJegolkwSU4xQNGbVgUiNYVUxbQ2x2lUsFvY4hVgVzGiIe6WLOPqycWXA40l+PWsxthUw==} - cbor@5.2.0: + /cbor@5.2.0: + resolution: {integrity: sha512-5IMhi9e1QU76ppa5/ajP1BmMWZ2FHkhAhjeVKQ/EFCgYSEaeVaoGtL7cxJskf9oCCk+XjzaIdc3IuU/dbA/o2A==} + engines: {node: '>=6.0.0'} dependencies: bignumber.js: 9.1.2 nofilter: 1.0.4 + dev: false - cbor@8.1.0: + /cbor@8.1.0: + resolution: {integrity: sha512-DwGjNW9omn6EwP70aXsn7FQJx5kO12tX0bZkaTjzdVFM6/7nhA4t0EENocKGx6D2Bch9PE2KzCUf5SceBdeijg==} + engines: {node: '>=12.19'} dependencies: nofilter: 3.1.0 + dev: false - cbor@9.0.2: + /cbor@9.0.2: + resolution: {integrity: sha512-JPypkxsB10s9QOWwa6zwPzqE1Md3vqpPc+cai4sAecuCsRyAtAl/pMyhPlMbT/xtPnm2dznJZYRLui57qiRhaQ==} + engines: {node: '>=16'} dependencies: nofilter: 3.1.0 + dev: true - chai-as-promised@7.1.1(chai@4.4.1): + /chai-as-promised@7.1.1(chai@4.4.1): + resolution: {integrity: sha512-azL6xMoi+uxu6z4rhWQ1jbdUhOMhis2PvscD/xjLqNMkv3BPPp2JyyuTHOrf9BOosGpNQ11v6BKv/g57RXbiaA==} + peerDependencies: + chai: '>= 2.1.2 < 5' dependencies: chai: 4.4.1 check-error: 1.0.3 - chai@4.4.1: + /chai@4.4.1: + resolution: {integrity: sha512-13sOfMv2+DWduEU+/xbun3LScLoqN17nBeTLUsmDfKdoiC1fr0n9PU4guu4AhRcOVFk/sW8LyZWHuhWtQZiF+g==} + engines: {node: '>=4'} dependencies: assertion-error: 1.1.0 check-error: 1.0.3 @@ -9405,24 +4951,32 @@ snapshots: pathval: 1.1.1 type-detect: 4.0.8 - chalk@0.4.0: + /chalk@0.4.0: + resolution: {integrity: sha512-sQfYDlfv2DGVtjdoQqxS0cEZDroyG8h6TamA6rvxwlrU5BaSLDx9xhatBYl2pxZ7gmpNaPFVwBtdGdu5rQ+tYQ==} + engines: {node: '>=0.8.0'} dependencies: ansi-styles: 1.0.0 has-color: 0.1.7 strip-ansi: 0.1.1 + dev: true - chalk@2.4.2: + /chalk@2.4.2: + resolution: {integrity: sha512-Mti+f9lpJNcwF4tWV8/OrTTtF1gZi+f8FqlyAdouralcFWFQWF2+NgCHShjkCb+IFBLq9buZwE1xckQU4peSuQ==} + engines: {node: '>=4'} dependencies: ansi-styles: 3.2.1 escape-string-regexp: 1.0.5 supports-color: 5.5.0 - chalk@4.1.2: + /chalk@4.1.2: + resolution: {integrity: sha512-oKnbhFyRIXpUuez8iBMmyEa4nbj4IOQyuhc/wy9kY7/WVPcwIO9VA668Pu8RkO7+0G76SLROeyw9CpQ061i4mA==} + engines: {node: '>=10'} dependencies: ansi-styles: 4.3.0 supports-color: 7.2.0 - change-case@3.0.2: + /change-case@3.0.2: + resolution: {integrity: sha512-Mww+SLF6MZ0U6kdg11algyKd5BARbyM4TbFBepwowYSR5ClfQGCGtxNXgykpN0uF/bstWeaGDT4JWaDh8zWAHA==} dependencies: camel-case: 3.0.0 constant-case: 2.0.0 @@ -9442,16 +4996,23 @@ snapshots: title-case: 2.1.1 upper-case: 1.1.3 upper-case-first: 1.1.2 + dev: false - chardet@0.7.0: {} + /chardet@0.7.0: + resolution: {integrity: sha512-mT8iDcrh03qDGRRmoA2hmBJnxpllMR+0/0qlzjqZES6NdiWDcZkCNAk4rPFZ9Q85r27unkiNNg8ZOiwZXBHwcA==} + dev: true - charenc@0.0.2: {} + /charenc@0.0.2: + resolution: {integrity: sha512-yrLQ/yVUFXkzg7EDQsPieE/53+0RlaWTs+wBrvW36cyilJ2SaDWfl4Yj7MtLTXleV9uEKefbAGUPv2/iWSooRA==} + dev: true - check-error@1.0.3: + /check-error@1.0.3: + resolution: {integrity: sha512-iKEoDYaRmd1mxM90a2OEfWhjsjPpYPuQ+lMYsoxB126+t8fw7ySEO48nmDg5COTjxDI65/Y2OWpeEHk3ZOe8zg==} dependencies: get-func-name: 2.0.2 - cheerio-select@2.1.0: + /cheerio-select@2.1.0: + resolution: {integrity: sha512-9v9kG0LvzrlcungtnJtpGNxY+fzECQKhK4EGJX2vByejiMX84MFNQw4UxPJl3bFbTMw+Dfs37XaIkCwTZfLh4g==} dependencies: boolbase: 1.0.0 css-select: 5.1.0 @@ -9459,8 +5020,11 @@ snapshots: domelementtype: 2.3.0 domhandler: 5.0.3 domutils: 3.1.0 + dev: false - cheerio@1.0.0-rc.12: + /cheerio@1.0.0-rc.12: + resolution: {integrity: sha512-VqR8m68vM46BNnuZ5NtnGBKIE/DfN0cRIzg9n40EIq9NOv90ayxLBXA8fXC5gquFRGJSTRqBq25Jt2ECLR431Q==} + engines: {node: '>= 6'} dependencies: cheerio-select: 2.1.0 dom-serializer: 2.0.0 @@ -9469,8 +5033,11 @@ snapshots: htmlparser2: 8.0.2 parse5: 7.1.2 parse5-htmlparser2-tree-adapter: 7.0.0 + dev: false - chokidar@3.5.3: + /chokidar@3.5.3: + resolution: {integrity: sha512-Dr3sfKRP6oTcjf2JmUmFJfeVMvXBdegxB0iVQ5eb2V10uFJUCAS8OByZdVAyVb8xXNz3GjjTgj9kLWsZTqE6kw==} + engines: {node: '>= 8.10.0'} dependencies: anymatch: 3.1.3 braces: 3.0.2 @@ -9482,7 +5049,9 @@ snapshots: optionalDependencies: fsevents: 2.3.3 - chokidar@3.6.0: + /chokidar@3.6.0: + resolution: {integrity: sha512-7VT13fmjotKpGipCW9JEQAusEPE+Ei8nl6/g4FBAmIm0GOOLMua9NDDo/DWp0ZAxCr3cPq5ZpBqmPAQgDda2Pw==} + engines: {node: '>= 8.10.0'} dependencies: anymatch: 3.1.3 braces: 3.0.2 @@ -9493,14 +5062,24 @@ snapshots: readdirp: 3.6.0 optionalDependencies: fsevents: 2.3.3 + dev: false - chownr@1.1.4: {} + /chownr@1.1.4: + resolution: {integrity: sha512-jJ0bqzaylmJtVnNgzTeSOs8DPavpbYgEr/b0YL8/2GO3xJEhInFmhKMUnEJQjZumK7KXGFhUy89PrsJWlakBVg==} - ci-info@2.0.0: {} + /ci-info@2.0.0: + resolution: {integrity: sha512-5tK7EtrZ0N+OLFMthtqOj4fI2Jeb88C4CAZPu25LDVUgXJ0A3Js4PMGqrn0JU1W0Mh1/Z8wZzYPxqUrXeBboCQ==} + dev: false - ci-info@3.9.0: {} + /ci-info@3.9.0: + resolution: {integrity: sha512-NIxF55hv4nSqQswkAeiOi1r83xy8JldOFDTWiug55KBu9Jnblncd2U6ViHmYgHf01TPZS77NJBhBMKdWj9HQMQ==} + engines: {node: '>=8'} + dev: true - cids@0.7.5: + /cids@0.7.5: + resolution: {integrity: sha512-zT7mPeghoWAu+ppn8+BS1tQ5qGmbMfB4AregnQjA/qHY3GC1m1ptI9GkWNlgeu38r7CuRdXB47uY2XgAYt6QVA==} + engines: {node: '>=4.0.0', npm: '>=3.0.0'} + deprecated: This module has been superseded by the multiformats module dependencies: buffer: 5.7.1 class-is: 1.1.0 @@ -9508,167 +5087,266 @@ snapshots: multicodec: 1.0.4 multihashes: 0.4.21 - cipher-base@1.0.4: + /cipher-base@1.0.4: + resolution: {integrity: sha512-Kkht5ye6ZGmwv40uUDZztayT2ThLQGfnj/T71N/XzeZeo3nf8foyW7zGTsPYkEya3m5f3cAypH+qe7YOrM1U2Q==} dependencies: inherits: 2.0.4 safe-buffer: 5.2.1 - class-is@1.1.0: {} + /class-is@1.1.0: + resolution: {integrity: sha512-rhjH9AG1fvabIDoGRVH587413LPjTZgmDF9fOFCbFJQV4yuocX1mHxxvXI4g3cGwbVY9wAYIoKlg1N79frJKQw==} - clean-stack@2.2.0: {} + /clean-stack@2.2.0: + resolution: {integrity: sha512-4diC9HaTE+KRAMWhDhrGOECgWZxoevMc5TlkObMqNSsVU62PYzXZ/SMTjzyGAFF1YusgxGcSWTEXBhp0CPwQ1A==} + engines: {node: '>=6'} - cli-boxes@2.2.1: {} + /cli-boxes@2.2.1: + resolution: {integrity: sha512-y4coMcylgSCdVinjiDBuR8PCC2bLjyGTwEmPb9NHR/QaNU6EUOXcTY/s6VjGMD6ENSEaeQYHCY0GNGS5jfMwPw==} + engines: {node: '>=6'} + dev: false - cli-cursor@3.1.0: + /cli-cursor@3.1.0: + resolution: {integrity: sha512-I/zHAwsKf9FqGoXM4WWRACob9+SNukZTd94DWF57E4toouRulbCxcUh6RKUEOQlYTHJnzkPMySvPNaaSLNfLZw==} + engines: {node: '>=8'} dependencies: restore-cursor: 3.1.0 + dev: false - cli-spinners@2.9.2: {} + /cli-spinners@2.9.2: + resolution: {integrity: sha512-ywqV+5MmyL4E7ybXgKys4DugZbX0FC6LnwrhjuykIjnK9k8OQacQ7axGKnjDXWNhns0xot3bZI5h55H8yo9cJg==} + engines: {node: '>=6'} + dev: false - cli-table3@0.5.1: + /cli-table3@0.5.1: + resolution: {integrity: sha512-7Qg2Jrep1S/+Q3EceiZtQcDPWxhAvBw+ERf1162v4sikJrvojMHFqXt8QIVha8UlH9rgU0BeWPytZ9/TzYqlUw==} + engines: {node: '>=6'} dependencies: object-assign: 4.1.1 string-width: 2.1.1 optionalDependencies: colors: 1.4.0 + dev: true - cliui@3.2.0: + /cliui@3.2.0: + resolution: {integrity: sha512-0yayqDxWQbqk3ojkYqUKqaAQ6AfNKeKWRNA8kR0WXzAsdHpP4BIaOmMAG87JGuO6qcobyW4GjxHd9PmhEd+T9w==} dependencies: string-width: 1.0.2 strip-ansi: 3.0.1 wrap-ansi: 2.1.0 + dev: false - cliui@6.0.0: + /cliui@6.0.0: + resolution: {integrity: sha512-t6wbgtoCXvAzst7QgXxJYqPt0usEfbgQdftEPbLL/cvv6HPE5VgvqCuAIDR0NgU52ds6rFwqrgakNLrHEjCbrQ==} dependencies: string-width: 4.2.3 strip-ansi: 6.0.1 wrap-ansi: 6.2.0 + dev: true - cliui@7.0.4: + /cliui@7.0.4: + resolution: {integrity: sha512-OcRE68cOsVMXp1Yvonl/fzkQOyjLSu/8bhPDfQt0e0/Eb283TKP20Fs2MqoPsr9SwA595rRCA+QMzYc9nBP+JQ==} dependencies: string-width: 4.2.3 strip-ansi: 6.0.1 wrap-ansi: 7.0.0 - cliui@8.0.1: + /cliui@8.0.1: + resolution: {integrity: sha512-BSeNnyus75C4//NQ9gQt1/csTXyo/8Sb+afLAkzAptFuMsod9HFokGNudZpi/oQV73hnVK+sR+5PVRMd+Dr7YQ==} + engines: {node: '>=12'} dependencies: string-width: 4.2.3 strip-ansi: 6.0.1 wrap-ansi: 7.0.0 + dev: true - clone-response@1.0.3: + /clone-response@1.0.3: + resolution: {integrity: sha512-ROoL94jJH2dUVML2Y/5PEDNaSHgeOdSDicUyS7izcF63G6sTc/FTjLub4b8Il9S8S0beOfYt0TaA5qvFK+w0wA==} dependencies: mimic-response: 1.0.1 - clone@1.0.4: {} + /clone@1.0.4: + resolution: {integrity: sha512-JQHZ2QMW6l3aH/j6xCqQThY/9OH4D/9ls34cgkUBiEeocRTU04tHfKPBsUK1PqZCUQM7GiA0IIXJSuXHI64Kbg==} + engines: {node: '>=0.8'} - co@4.6.0: {} + /co@4.6.0: + resolution: {integrity: sha512-QVb0dM5HvG+uaxitm8wONl7jltx8dqhfU33DcqtOZcLSVIKSDDLDi7+0LbAKiyI8hD9u42m2YxXSkMGWThaecQ==} + engines: {iojs: '>= 1.0.0', node: '>= 0.12.0'} + dev: false - code-point-at@1.1.0: {} + /code-point-at@1.1.0: + resolution: {integrity: sha512-RpAVKQA5T63xEj6/giIbUEtZwJ4UFIc3ZtvEkiaUERylqe8xb5IvqcgOurZLahv93CLKfxcw5YI+DZcUBRyLXA==} + engines: {node: '>=0.10.0'} + dev: false - color-convert@1.9.3: + /color-convert@1.9.3: + resolution: {integrity: sha512-QfAUtd+vFdAtFQcC8CCyYt1fYWxSqAiK2cSD6zDB8N3cpsEBAvRxp9zOGg6G/SHHJYAT88/az/IuDGALsNVbGg==} dependencies: color-name: 1.1.3 - color-convert@2.0.1: + /color-convert@2.0.1: + resolution: {integrity: sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ==} + engines: {node: '>=7.0.0'} dependencies: color-name: 1.1.4 - color-name@1.1.3: {} + /color-name@1.1.3: + resolution: {integrity: sha512-72fSenhMw2HZMTVHeCA9KCmpEIbzWiQsjN+BHcBbS9vr1mtt+vJjPdksIBNUmKAW8TFUDPJK5SUU3QhE9NEXDw==} - color-name@1.1.4: {} + /color-name@1.1.4: + resolution: {integrity: sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA==} - colors@1.4.0: {} + /colors@1.4.0: + resolution: {integrity: sha512-a+UqTh4kgZg/SlGvfbzDHpgRu7AAQOmmqRHJnxhRZICKFUT91brVhNNt58CMWU9PsBbv3PDCZUHbVxuDiH2mtA==} + engines: {node: '>=0.1.90'} - combined-stream@1.0.8: + /combined-stream@1.0.8: + resolution: {integrity: sha512-FQN4MRfuJeHf7cBbBMJFXhKSDq+2kAArBlmRBvcvFE5BB1HZKXtSFASDhdlz9zOYwxh8lDdnvmMOe/+5cdoEdg==} + engines: {node: '>= 0.8'} dependencies: delayed-stream: 1.0.0 - command-exists@1.2.9: {} + /command-exists@1.2.9: + resolution: {integrity: sha512-LTQ/SGc+s0Xc0Fu5WaKnR0YiygZkm9eKFvyS+fRsU7/ZWFF8ykFM6Pc9aCVf1+xasOOZpO3BAVgVrKvsqKHV7w==} + dev: false - command-line-args@5.2.1: + /command-line-args@5.2.1: + resolution: {integrity: sha512-H4UfQhZyakIjC74I9d34fGYDwk3XpSr17QhEd0Q3I9Xq1CETHo4Hcuo87WyWHpAF1aSLjLRf5lD9ZGX2qStUvg==} + engines: {node: '>=4.0.0'} dependencies: array-back: 3.1.0 find-replace: 3.0.0 lodash.camelcase: 4.3.0 typical: 4.0.0 + dev: true - command-line-usage@6.1.3: + /command-line-usage@6.1.3: + resolution: {integrity: sha512-sH5ZSPr+7UStsloltmDh7Ce5fb8XPlHyoPzTpyyMuYCtervL65+ubVZ6Q61cFtFl62UyJlc8/JwERRbAFPUqgw==} + engines: {node: '>=8.0.0'} dependencies: array-back: 4.0.2 chalk: 2.4.2 table-layout: 1.0.2 typical: 5.2.0 + dev: true - commander@10.0.1: {} + /commander@10.0.1: + resolution: {integrity: sha512-y4Mg2tXshplEbSGzx7amzPwKKOCGuoSRP/CjEdwwk0FOGlUbq6lKuoyDZTNZkmxHdJtp54hdfY/JUrdL7Xfdug==} + engines: {node: '>=14'} - commander@2.20.3: {} + /commander@2.20.3: + resolution: {integrity: sha512-GpVkmM8vF2vQUkj2LvZmD35JxeJOLCwJ9cUkugyk2nuhbv3+mJvpLYYt+0+USMxE+oj+ey/lJEnhZw75x/OMcQ==} + dev: false - commander@3.0.2: {} + /commander@3.0.2: + resolution: {integrity: sha512-Gar0ASD4BDyKC4hl4DwHqDrmvjoxWKZigVnAbn5H1owvm4CxCPdb0HQDehwNYMJpla5+M2tPmPARzhtYuwpHow==} + dev: false - commander@6.2.1: {} + /commander@6.2.1: + resolution: {integrity: sha512-U7VdrJFnJgo4xjrHpTzu0yrHPGImdsmD95ZlgYSEajAn2JKzDhDTPG9kBTefmObL2w/ngeZnilk+OV9CG3d7UA==} + engines: {node: '>= 6'} + dev: true - commondir@1.0.1: {} + /commondir@1.0.1: + resolution: {integrity: sha512-W9pAhw0ja1Edb5GVdIF1mjZw/ASI0AlShXM83UUGe2DVr5TdAPEA1OA8m/g8zWp9x6On7gqufY+FatDbC3MDQg==} + dev: true - concat-map@0.0.1: {} + /concat-map@0.0.1: + resolution: {integrity: sha512-/Srv4dswyQNBfohGpz9o6Yb3Gz3SrUDqBH5rTuhGR7ahtlbYKnVxw2bCFMRljaA7EXHaXZ8wsHdodFvbkhKmqg==} - concat-stream@1.6.2: + /concat-stream@1.6.2: + resolution: {integrity: sha512-27HBghJxjiZtIk3Ycvn/4kbJk/1uZuJFfuPEns6LaEvpvG1f0hTea8lilrouyo9mVc2GWdcEZ8OLoGmSADlrCw==} + engines: {'0': node >= 0.8} dependencies: buffer-from: 1.1.2 inherits: 2.0.4 readable-stream: 2.3.8 typedarray: 0.0.6 + dev: true - constant-case@2.0.0: + /constant-case@2.0.0: + resolution: {integrity: sha512-eS0N9WwmjTqrOmR3o83F5vW8Z+9R1HnVz3xmzT2PMFug9ly+Au/fxRWlEBSb6LcZwspSsEn9Xs1uw9YgzAg1EQ==} dependencies: snake-case: 2.1.0 upper-case: 1.1.3 + dev: false - content-disposition@0.5.4: + /content-disposition@0.5.4: + resolution: {integrity: sha512-FveZTNuGw04cxlAiWbzi6zTAL/lhehaWbTtgluJh4/E95DqMwTmha3KZN1aAWA8cFIhHzMZUvLevkw5Rqk+tSQ==} + engines: {node: '>= 0.6'} dependencies: safe-buffer: 5.2.1 - content-hash@2.5.2: + /content-hash@2.5.2: + resolution: {integrity: sha512-FvIQKy0S1JaWV10sMsA7TRx8bpU+pqPkhbsfvOJAdjRXvYxEckAwQWGwtRjiaJfh+E0DvcWUGqcdjwMGFjsSdw==} dependencies: cids: 0.7.5 multicodec: 0.5.7 multihashes: 0.4.21 - content-type@1.0.5: {} + /content-type@1.0.5: + resolution: {integrity: sha512-nTjqfcBFEipKdXCv4YDQWCfmcLZKm81ldF0pAopTvyrFGVbcR6P/VAAd5G7N+0tTr8QqiU0tFadD6FK4NtJwOA==} + engines: {node: '>= 0.6'} - convert-source-map@1.9.0: {} + /convert-source-map@1.9.0: + resolution: {integrity: sha512-ASFBup0Mz1uyiIjANan1jzLQami9z1PoYSZCiiYW2FczPbenXc45FZdBZLzOT+r6+iciuEModtmCti+hjaAk0A==} + dev: true - convert-source-map@2.0.0: {} + /convert-source-map@2.0.0: + resolution: {integrity: sha512-Kvp459HrV2FEJ1CAsi1Ku+MY3kasH19TFykTz2xWmMeq6bk2NU3XXvfJ+Q61m0xktWwt+1HSYf3JZsTms3aRJg==} + dev: true - cookie-signature@1.0.6: {} + /cookie-signature@1.0.6: + resolution: {integrity: sha512-QADzlaHc8icV8I7vbaJXJwod9HWYp8uCqf1xa4OfNu1T7JVxQIrUgOWtHdNDtPiywmFbiS12VjotIXLrKM3orQ==} - cookie@0.4.2: {} + /cookie@0.4.2: + resolution: {integrity: sha512-aSWTXFzaKWkvHO1Ny/s+ePFpvKsPnjc551iI41v3ny/ow6tBG5Vd+FuqGNhh1LxOmVzOlGUriIlOaokOvhaStA==} + engines: {node: '>= 0.6'} + dev: false - cookie@0.6.0: {} + /cookie@0.6.0: + resolution: {integrity: sha512-U71cyTamuh1CRNCfpGY6to28lxvNwPG4Guz/EVjgf3Jmzv0vlDp1atT9eS5dDjMYHucpHbWns6Lwf3BKz6svdw==} + engines: {node: '>= 0.6'} - cookiejar@2.1.4: {} + /cookiejar@2.1.4: + resolution: {integrity: sha512-LDx6oHrK+PhzLKJU9j5S7/Y3jM/mUHvD/DeI1WQmJn652iPC5Y4TBzC9l+5OMOXlyTTA+SmVUPm0HQUwpD5Jqw==} + dev: true - core-util-is@1.0.2: {} + /core-util-is@1.0.2: + resolution: {integrity: sha512-3lqz5YjWTYnW6dlDa5TLaTCcShfar1e40rmcJVwCBJC6mWlFuj0eCHIElmG1g5kyuJ/GD+8Wn4FFCcz4gJPfaQ==} - core-util-is@1.0.3: {} + /core-util-is@1.0.3: + resolution: {integrity: sha512-ZQBvi1DcpJ4GDqanjucZ2Hj3wEO5pZDS89BWbkcrvdxksJorwUDDZamX9ldFkp9aw2lmBDLgkObEA4DWNJ9FYQ==} + dev: true - cors@2.8.5: + /cors@2.8.5: + resolution: {integrity: sha512-KIHbLJqu73RGr/hnbrO9uBeixNGuvSQjul/jdFvS/KFSIH1hWVd1ng7zOHx+YrEfInLG7q4n6GHQ9cDtxv/P6g==} + engines: {node: '>= 0.10'} dependencies: object-assign: 4.1.1 vary: 1.1.2 - cosmiconfig@8.3.6(typescript@5.0.4): + /cosmiconfig@8.3.6(typescript@5.0.4): + resolution: {integrity: sha512-kcZ6+W5QzcJ3P1Mt+83OUv/oHFqZHIx8DuxG6eZ5RGMERoLqp4BuGjhHLYGK+Kf5XVkQvqBSmAy/nGWN3qDgEA==} + engines: {node: '>=14'} + peerDependencies: + typescript: '>=4.9.5' + peerDependenciesMeta: + typescript: + optional: true dependencies: import-fresh: 3.3.0 js-yaml: 4.1.0 parse-json: 5.2.0 path-type: 4.0.0 - optionalDependencies: typescript: 5.0.4 - crc-32@1.2.2: {} + /crc-32@1.2.2: + resolution: {integrity: sha512-ROmzCKrTnOwybPcJApAA6WBWij23HVfGVNKqqrZpuyZOHqK2CwHSvpGuyt/UNNvaIjEd8X5IFGp4Mh+Ie1IHJQ==} + engines: {node: '>=0.8'} + hasBin: true - create-hash@1.2.0: + /create-hash@1.2.0: + resolution: {integrity: sha512-z00bCGNHDG8mHAkP7CtT1qVu+bFQUPjYq/4Iv3C3kWjTFV10zIjfSoeqXo9Asws8gwSHDGj/hl2u4OGIjapeCg==} dependencies: cipher-base: 1.0.4 inherits: 2.0.4 @@ -9676,7 +5354,8 @@ snapshots: ripemd160: 2.0.2 sha.js: 2.4.11 - create-hmac@1.1.7: + /create-hmac@1.1.7: + resolution: {integrity: sha512-MJG9liiZ+ogc4TzUwuvbER1JRdgvUFSB5+VR/g5h82fGaIRWMWddtKBHi7/sVhfjQZ6SehlyhvQYrcYkaUIpLg==} dependencies: cipher-base: 1.0.4 create-hash: 1.2.0 @@ -9685,35 +5364,47 @@ snapshots: safe-buffer: 5.2.1 sha.js: 2.4.11 - create-require@1.1.1: {} + /create-require@1.1.1: + resolution: {integrity: sha512-dcKFX3jn0MpIaXjisoRvexIJVEKzaq7z2rZKxf+MSr9TkdmHmsU4m2lcLojrj/FHl8mk5VxMmYA+ftRkP/3oKQ==} + dev: true - cross-fetch@3.1.8: + /cross-fetch@3.1.8: + resolution: {integrity: sha512-cvA+JwZoU0Xq+h6WkMvAUqPEYy92Obet6UdKLfW60qn99ftItKjB5T+BkyWOFWe2pUyfQ+IJHmpOTznqk1M6Kg==} dependencies: node-fetch: 2.7.0 transitivePeerDependencies: - encoding + dev: false - cross-fetch@4.0.0: + /cross-fetch@4.0.0: + resolution: {integrity: sha512-e4a5N8lVvuLgAWgnCrLr2PP0YyDOTHa9H/Rj54dirp61qXnNq46m82bRhNqIA5VccJtWBvPTFRV3TtvHUKPB1g==} dependencies: node-fetch: 2.7.0 transitivePeerDependencies: - encoding - cross-spawn@5.1.0: + /cross-spawn@5.1.0: + resolution: {integrity: sha512-pTgQJ5KC0d2hcY8eyL1IzlBPYjTkyH72XRZPnLyKus2mBfNjQs3klqbJU2VILqZryAZUt9JOb3h/mWMy23/f5A==} dependencies: lru-cache: 4.1.5 shebang-command: 1.2.0 which: 1.3.1 + dev: true - cross-spawn@7.0.3: + /cross-spawn@7.0.3: + resolution: {integrity: sha512-iRDPJKUPVEND7dHPO8rkbOnPpyDygcDFtWjpeWNCgy8WP2rXcxXL8TskReQl6OrB2G7+UJrags1q15Fudc7G6w==} + engines: {node: '>= 8'} dependencies: path-key: 3.1.1 shebang-command: 2.0.0 which: 2.0.2 - crypt@0.0.2: {} + /crypt@0.0.2: + resolution: {integrity: sha512-mCxBlsHFYh9C+HVpiEacem8FEBnMXgU9gy4zmNC+SXAZNB/1idgp/aulFJ4FgCi7GPEVbfyng092GqL2k2rmow==} + dev: true - crypto-addr-codec@0.1.8: + /crypto-addr-codec@0.1.8: + resolution: {integrity: sha512-GqAK90iLLgP3FvhNmHbpT3wR6dEdaM8hZyZtLX29SPardh3OA13RFLHDR6sntGCgRWOfiHqW6sIyohpNqOtV/g==} dependencies: base-x: 3.0.9 big-integer: 1.6.36 @@ -9722,217 +5413,365 @@ snapshots: ripemd160-min: 0.0.6 safe-buffer: 5.2.1 sha3: 2.1.4 + dev: false - crypto-js@3.3.0: {} + /crypto-js@3.3.0: + resolution: {integrity: sha512-DIT51nX0dCfKltpRiXV+/TVZq+Qq2NgF4644+K7Ttnla7zEzqc+kjJyiB96BHNyUTBxyjzRcZYpUdZa+QAqi6Q==} - crypto-js@4.2.0: {} + /crypto-js@4.2.0: + resolution: {integrity: sha512-KALDyEYgpY+Rlob/iriUtjV6d5Eq+Y191A5g4UqLAi8CyGP9N1+FdVbkc1SxKc2r4YAYqG8JzO2KGL+AizD70Q==} + dev: false - css-select@5.1.0: + /css-select@5.1.0: + resolution: {integrity: sha512-nwoRF1rvRRnnCqqY7updORDsuqKzqYJ28+oSMaJMMgOauh3fvwHqMS7EZpIPqK8GL+g9mKxF1vP/ZjSeNjEVHg==} dependencies: boolbase: 1.0.0 css-what: 6.1.0 domhandler: 5.0.3 domutils: 3.1.0 nth-check: 2.1.1 + dev: false - css-what@6.1.0: {} + /css-what@6.1.0: + resolution: {integrity: sha512-HTUrgRJ7r4dsZKU6GjmpfRK1O76h97Z8MfS1G0FozR+oF2kG6Vfe8JE6zwrkbxigziPHinCJ+gCPjA9EaBDtRw==} + engines: {node: '>= 6'} + dev: false - csv-generate@3.4.3: {} + /csv-generate@3.4.3: + resolution: {integrity: sha512-w/T+rqR0vwvHqWs/1ZyMDWtHHSJaN06klRqJXBEpDJaM/+dZkso0OKh1VcuuYvK3XM53KysVNq8Ko/epCK8wOw==} + dev: true - csv-parse@4.16.3: {} + /csv-parse@4.16.3: + resolution: {integrity: sha512-cO1I/zmz4w2dcKHVvpCr7JVRu8/FymG5OEpmvsZYlccYolPBLoVGKUHgNoc4ZGkFeFlWGEDmMyBM+TTqRdW/wg==} + dev: true - csv-stringify@5.6.5: {} + /csv-stringify@5.6.5: + resolution: {integrity: sha512-PjiQ659aQ+fUTQqSrd1XEDnOr52jh30RBurfzkscaE2tPaFsDH5wOAHJiw8XAHphRknCwMUE9KRayc4K/NbO8A==} + dev: true - csv@5.5.3: + /csv@5.5.3: + resolution: {integrity: sha512-QTaY0XjjhTQOdguARF0lGKm5/mEq9PD9/VhZZegHDIBq2tQwgNpHc3dneD4mGo2iJs+fTKv5Bp0fZ+BRuY3Z0g==} + engines: {node: '>= 0.1.90'} dependencies: csv-generate: 3.4.3 csv-parse: 4.16.3 csv-stringify: 5.6.5 stream-transform: 2.1.3 + dev: true - d@1.0.2: + /d@1.0.2: + resolution: {integrity: sha512-MOqHvMWF9/9MX6nza0KgvFH4HpMU0EF5uUDXqX/BtxtU8NfB0QzRtJ8Oe/6SuS4kbhyzVJwjd97EA4PKrzJ8bw==} + engines: {node: '>=0.12'} dependencies: es5-ext: 0.10.64 type: 2.7.2 - dashdash@1.14.1: + /dashdash@1.14.1: + resolution: {integrity: sha512-jRFi8UDGo6j+odZiEpjazZaWqEal3w/basFjQHQEwVtZJGDpxbH1MeYluwCS8Xq5wmLJooDlMgvVarmWfGM44g==} + engines: {node: '>=0.10'} dependencies: assert-plus: 1.0.0 - data-view-buffer@1.0.1: + /data-view-buffer@1.0.1: + resolution: {integrity: sha512-0lht7OugA5x3iJLOWFhWK/5ehONdprk0ISXqVFn/NFrDu+cuc8iADFrGQz5BnRK7LLU3JmkbXSxaqX+/mXYtUA==} + engines: {node: '>= 0.4'} dependencies: call-bind: 1.0.7 es-errors: 1.3.0 is-data-view: 1.0.1 + dev: true - data-view-byte-length@1.0.1: + /data-view-byte-length@1.0.1: + resolution: {integrity: sha512-4J7wRJD3ABAzr8wP+OcIcqq2dlUKp4DVflx++hs5h5ZKydWMI6/D/fAot+yh6g2tHh8fLFTvNOaVN357NvSrOQ==} + engines: {node: '>= 0.4'} dependencies: call-bind: 1.0.7 es-errors: 1.3.0 is-data-view: 1.0.1 + dev: true - data-view-byte-offset@1.0.0: + /data-view-byte-offset@1.0.0: + resolution: {integrity: sha512-t/Ygsytq+R995EJ5PZlD4Cu56sWa8InXySaViRzw9apusqsOO2bQP+SbYzAhR0pFKoB+43lYy8rWban9JSuXnA==} + engines: {node: '>= 0.4'} dependencies: call-bind: 1.0.7 es-errors: 1.3.0 is-data-view: 1.0.1 + dev: true - date-time@0.1.1: {} + /date-time@0.1.1: + resolution: {integrity: sha512-p4psdkgdNA6x0600SKbfWiOomNb33ADBMRHf49GMhYVgJsPefZlMSLXXVWWUpbqSxB3DL5/cxKa6a8i3XPK5Xg==} + engines: {node: '>=0.10.0'} + dev: true - death@1.1.0: {} + /death@1.1.0: + resolution: {integrity: sha512-vsV6S4KVHvTGxbEcij7hkWRv0It+sGGWVOM67dQde/o5Xjnr+KmLjxWJii2uEObIrt1CcM9w0Yaovx+iOlIL+w==} + dev: true - debug@2.6.9: + /debug@2.6.9: + resolution: {integrity: sha512-bC7ElrdJaJnPbAP+1EotYvqZsb3ecl5wi6Bfi6BJTUcNowp6cvspg0jXznRTKDjm/E7AdgFBVeAPVMNcKGsHMA==} + peerDependencies: + supports-color: '*' + peerDependenciesMeta: + supports-color: + optional: true dependencies: ms: 2.0.0 - debug@3.2.7: + /debug@3.2.7: + resolution: {integrity: sha512-CFjzYYAi4ThfiQvizrFQevTTXHtnCqWfe7x1AhgEscTz6ZbLbfoLRLPugTQyBth6f8ZERVUSyWHFD/7Wu4t1XQ==} + peerDependencies: + supports-color: '*' + peerDependenciesMeta: + supports-color: + optional: true dependencies: ms: 2.1.3 - debug@4.3.4(supports-color@8.1.1): + /debug@4.3.4(supports-color@8.1.1): + resolution: {integrity: sha512-PRWFHuSU3eDtQJPvnNY7Jcket1j0t5OuOsFzPPzsekD52Zl8qUfFIPEiswXqIvHWGVHOgX+7G/vCNNhehwxfkQ==} + engines: {node: '>=6.0'} + peerDependencies: + supports-color: '*' + peerDependenciesMeta: + supports-color: + optional: true dependencies: ms: 2.1.2 - optionalDependencies: supports-color: 8.1.1 - decamelize-keys@1.1.1: + /decamelize-keys@1.1.1: + resolution: {integrity: sha512-WiPxgEirIV0/eIOMcnFBA3/IJZAZqKnwAwWyvvdi4lsr1WCN22nhdf/3db3DoZcUjTV2SqfzIwNyp6y2xs3nmg==} + engines: {node: '>=0.10.0'} dependencies: decamelize: 1.2.0 map-obj: 1.0.1 + dev: true - decamelize@1.2.0: {} + /decamelize@1.2.0: + resolution: {integrity: sha512-z2S+W9X73hAUUki+N+9Za2lBlun89zigOyGrsax+KUQ6wKW4ZoWpEYBkGhQjwAjjDCkWxhY0VKEhk8wzY7F5cA==} + engines: {node: '>=0.10.0'} - decamelize@4.0.0: {} + /decamelize@4.0.0: + resolution: {integrity: sha512-9iE1PgSik9HeIIw2JO94IidnE3eBoQrFJ3w7sFuzSX4DpmZ3v5sZpUiV5Swcf6mQEF+Y0ru8Neo+p+nyh2J+hQ==} + engines: {node: '>=10'} - decimal.js-light@2.5.1: {} + /decimal.js-light@2.5.1: + resolution: {integrity: sha512-qIMFpTMZmny+MMIitAB6D7iVPEorVw6YQRWkvarTkT4tBeSLLiHzcwj6q0MmYSFCiVpiqPJTJEYIrpcPzVEIvg==} + dev: false - decode-uri-component@0.2.2: {} + /decode-uri-component@0.2.2: + resolution: {integrity: sha512-FqUYQ+8o158GyGTrMFJms9qh3CqTKvAqgqsTnkLI8sKu0028orqBhxNMFkFen0zGyg6epACD32pjVk58ngIErQ==} + engines: {node: '>=0.10'} - decompress-response@3.3.0: + /decompress-response@3.3.0: + resolution: {integrity: sha512-BzRPQuY1ip+qDonAOz42gRm/pg9F768C+npV/4JOsxRC2sq+Rlk+Q4ZCAsOhnIaMrgarILY+RMUIvMmmX1qAEA==} + engines: {node: '>=4'} dependencies: mimic-response: 1.0.1 - decompress-response@6.0.0: + /decompress-response@6.0.0: + resolution: {integrity: sha512-aW35yZM6Bb/4oJlZncMH2LCoZtJXTRxES17vE3hoRiowU2kWHaJKFkSBDnDR+cm9J+9QhXmREyIfv0pji9ejCQ==} + engines: {node: '>=10'} dependencies: mimic-response: 3.1.0 - deep-eql@4.1.3: + /deep-eql@4.1.3: + resolution: {integrity: sha512-WaEtAOpRA1MQ0eohqZjpGD8zdI0Ovsm8mmFhaDN8dvDZzyoUMcYDnf5Y6iu7HTXxf8JDS23qWa4a+hKCDyOPzw==} + engines: {node: '>=6'} dependencies: type-detect: 4.0.8 - deep-extend@0.6.0: {} + /deep-extend@0.6.0: + resolution: {integrity: sha512-LOHxIOaPYdHlJRtCQfDIVZtfw/ufM8+rVj649RIHzcm/vGwQRXFt6OPqIFWsm2XEMrNIEtWR64sY1LEKD2vAOA==} + engines: {node: '>=4.0.0'} - deep-is@0.1.4: {} + /deep-is@0.1.4: + resolution: {integrity: sha512-oIPzksmTg4/MriiaYGO+okXDT7ztn/w3Eptv/+gSIdMdKsJo0u4CfYNFJPy+4SKMuCqGw2wxnA+URMg3t8a/bQ==} - deepmerge@4.3.1: {} + /deepmerge@4.3.1: + resolution: {integrity: sha512-3sUqbMEc77XqpdNO7FRyRog+eW3ph+GYCbj+rK+uYyRMuwsVy0rMiVtPn+QJlKFvWP/1PYpapqYn0Me2knFn+A==} + engines: {node: '>=0.10.0'} + dev: true - default-require-extensions@3.0.1: + /default-require-extensions@3.0.1: + resolution: {integrity: sha512-eXTJmRbm2TIt9MgWTsOH1wEuhew6XGZcMeGKCtLedIg/NCsg1iBePXkceTdK4Fii7pzmN9tGsZhKzZ4h7O/fxw==} + engines: {node: '>=8'} dependencies: strip-bom: 4.0.0 + dev: true - defaults@1.0.4: + /defaults@1.0.4: + resolution: {integrity: sha512-eFuaLoy/Rxalv2kr+lqMlUnrDWV+3j4pljOIJgLIhI058IQfWJ7vXhyEIHu+HtC738klGALYxOKDO0bQP3tg8A==} dependencies: clone: 1.0.4 - defer-to-connect@2.0.1: {} + /defer-to-connect@2.0.1: + resolution: {integrity: sha512-4tvttepXG1VaYGrRibk5EwJd1t4udunSOVMdLSAL6mId1ix438oPwPZMALY41FCijukO1L0twNcGsdzS7dHgDg==} + engines: {node: '>=10'} - define-data-property@1.1.4: + /define-data-property@1.1.4: + resolution: {integrity: sha512-rBMvIzlpA8v6E+SJZoo++HAYqsLrkg7MSfIinMPFhmkorw7X+dOXVJQs+QT69zGkzMyfDnIMN2Wid1+NbL3T+A==} + engines: {node: '>= 0.4'} dependencies: es-define-property: 1.0.0 es-errors: 1.3.0 gopd: 1.0.1 - define-properties@1.2.1: + /define-properties@1.2.1: + resolution: {integrity: sha512-8QmQKqEASLd5nx0U1B1okLElbUuuttJ/AnYmRXbbbGDWh6uS208EjD4Xqq/I9wK7u0v6O08XhTWnt5XtEbR6Dg==} + engines: {node: '>= 0.4'} dependencies: define-data-property: 1.1.4 has-property-descriptors: 1.0.2 object-keys: 1.1.1 + dev: true - delayed-stream@1.0.0: {} + /delayed-stream@1.0.0: + resolution: {integrity: sha512-ZySD7Nf91aLB0RxL4KGrKHBXl7Eds1DAmEdcoVawXnLD7SDhpNgtuII2aAkg7a7QS41jxPSZ17p4VdGnMHk3MQ==} + engines: {node: '>=0.4.0'} - depd@2.0.0: {} + /depd@2.0.0: + resolution: {integrity: sha512-g7nH6P6dyDioJogAAGprGpCtVImJhpPk/roCzdb3fIh61/s/nPsfR6onyMwkCAR/OlC3yBC0lESvUoQEAssIrw==} + engines: {node: '>= 0.8'} - destroy@1.2.0: {} + /destroy@1.2.0: + resolution: {integrity: sha512-2sJGJTaXIIaR1w4iJSNoN0hnMY7Gpc/n8D4qSCJw8QqFWXf7cuAgnEHxBpweaVcPevC2l3KpjYCx3NypQQgaJg==} + engines: {node: '>= 0.8', npm: 1.2.8000 || >= 1.4.16} - detect-indent@5.0.0: {} + /detect-indent@5.0.0: + resolution: {integrity: sha512-rlpvsxUtM0PQvy9iZe640/IWwWYyBsTApREbA1pHOpmOUIl9MkP/U4z7vTtg4Oaojvqhxt7sdufnT0EzGaR31g==} + engines: {node: '>=4'} + dev: false - detect-indent@6.1.0: {} + /detect-indent@6.1.0: + resolution: {integrity: sha512-reYkTUJAZb9gUuZ2RvVCNhVHdg62RHnJ7WJl8ftMi4diZ6NWlciOzQN88pUhSELEwflJht4oQDv0F0BMlwaYtA==} + engines: {node: '>=8'} + dev: true - detect-libc@2.0.3: {} + /detect-libc@2.0.3: + resolution: {integrity: sha512-bwy0MGW55bG41VqxxypOsdSdGqLwXPI/focwgTYCFMbdUiBAxLg9CFzG08sz2aqzknwiX7Hkl0bQENjg8iLByw==} + engines: {node: '>=8'} + dev: false - detect-node@2.1.0: {} + /detect-node@2.1.0: + resolution: {integrity: sha512-T0NIuQpnTvFDATNuHN5roPwSBG83rFsuO+MXXH9/3N1eFbn4wcPjttvjMLEPWJ0RGUYgQE7cGgS3tNxbqCGM7g==} + dev: true - detect-port@1.6.1: + /detect-port@1.6.1: + resolution: {integrity: sha512-CmnVc+Hek2egPx1PeTFVta2W78xy2K/9Rkf6cC4T59S50tVnzKj+tnx5mmx5lwvCkujZ4uRrpRSuV+IVs3f90Q==} + engines: {node: '>= 4.0.0'} + hasBin: true dependencies: address: 1.2.2 debug: 4.3.4(supports-color@8.1.1) transitivePeerDependencies: - supports-color + dev: true - diff-sequences@29.6.3: {} + /diff-sequences@29.6.3: + resolution: {integrity: sha512-EjePK1srD3P08o2j4f0ExnylqRs5B9tJjcp9t1krH2qRi8CCdsYfwe9JgSLurFBWwq4uOlipzfk5fHNvwFKr8Q==} + engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0} + dev: true - diff@4.0.2: {} + /diff@4.0.2: + resolution: {integrity: sha512-58lmxKSA4BNyLz+HHMUzlOEpg09FV+ev6ZMe3vJihgdxzgcwZ8VoEEPmALCZG9LmqfVoNMMKpttIYTVG6uDY7A==} + engines: {node: '>=0.3.1'} + dev: true - diff@5.0.0: {} + /diff@5.0.0: + resolution: {integrity: sha512-/VTCrvm5Z0JGty/BWHljh+BAiw3IK+2j87NGMu8Nwc/f48WoDAC395uomO9ZD117ZOBaHmkX1oyLvkVM/aIT3w==} + engines: {node: '>=0.3.1'} - difflib@0.2.4: + /difflib@0.2.4: + resolution: {integrity: sha512-9YVwmMb0wQHQNr5J9m6BSj6fk4pfGITGQOOs+D9Fl+INODWFOfvhIU1hNv6GgR1RBoC/9NJcwu77zShxV0kT7w==} dependencies: heap: 0.2.7 + dev: true - dir-glob@3.0.1: + /dir-glob@3.0.1: + resolution: {integrity: sha512-WkrWp9GR4KXfKGYzOLmTuGVi1UWFfws377n9cc55/tb6DuqyF6pcQ5AbiHEshaDpY9v6oaSr2XCDidGmMwdzIA==} + engines: {node: '>=8'} dependencies: path-type: 4.0.0 - doctrine@2.1.0: + /doctrine@2.1.0: + resolution: {integrity: sha512-35mSku4ZXK0vfCuHEDAwt55dg2jNajHZ1odvF+8SSr82EsZY4QmXfuWso8oEd8zRhVObSN18aM0CjSdoBX7zIw==} + engines: {node: '>=0.10.0'} dependencies: esutils: 2.0.3 + dev: true - doctrine@3.0.0: + /doctrine@3.0.0: + resolution: {integrity: sha512-yS+Q5i3hBf7GBkd4KG8a7eBNNWNGLTaEwwYWUijIYM7zrlYDM0BFXHjjPWlWZ1Rg7UaddZeIDmi9jF3HmqiQ2w==} + engines: {node: '>=6.0.0'} dependencies: esutils: 2.0.3 - dom-serializer@2.0.0: + /dom-serializer@2.0.0: + resolution: {integrity: sha512-wIkAryiqt/nV5EQKqQpo3SToSOV9J0DnbJqwK7Wv/Trc92zIAYZ4FlMu+JPFW1DfGFt81ZTCGgDEabffXeLyJg==} dependencies: domelementtype: 2.3.0 domhandler: 5.0.3 entities: 4.5.0 + dev: false - dom-walk@0.1.2: {} + /dom-walk@0.1.2: + resolution: {integrity: sha512-6QvTW9mrGeIegrFXdtQi9pk7O/nSK6lSdXW2eqUspN5LWD7UTji2Fqw5V2YLjBpHEoU9Xl/eUWNpDeZvoyOv2w==} - domelementtype@2.3.0: {} + /domelementtype@2.3.0: + resolution: {integrity: sha512-OLETBj6w0OsagBwdXnPdN0cnMfF9opN69co+7ZrbfPGrdpPVNBUj02spi6B1N7wChLQiPn4CSH/zJvXw56gmHw==} + dev: false - domhandler@5.0.3: + /domhandler@5.0.3: + resolution: {integrity: sha512-cgwlv/1iFQiFnU96XXgROh8xTeetsnJiDsTc7TYCLFd9+/WNkIqPTxiM/8pSd8VIrhXGTf1Ny1q1hquVqDJB5w==} + engines: {node: '>= 4'} dependencies: domelementtype: 2.3.0 + dev: false - domutils@3.1.0: + /domutils@3.1.0: + resolution: {integrity: sha512-H78uMmQtI2AhgDJjWeQmHwJJ2bLPD3GMmO7Zja/ZZh84wkm+4ut+IUnUdRa8uCGX88DiVx1j6FRe1XfxEgjEZA==} dependencies: dom-serializer: 2.0.0 domelementtype: 2.3.0 domhandler: 5.0.3 + dev: false - dot-case@2.1.1: + /dot-case@2.1.1: + resolution: {integrity: sha512-HnM6ZlFqcajLsyudHq7LeeLDr2rFAVYtDv/hV5qchQEidSck8j9OPUsXY9KwJv/lHMtYlX4DjRQqwFYa+0r8Ug==} dependencies: no-case: 2.3.2 + dev: false - dot-prop@7.2.0: + /dot-prop@7.2.0: + resolution: {integrity: sha512-Ol/IPXUARn9CSbkrdV4VJo7uCy1I3VuSiWCaFSg+8BdUOzF9n3jefIpcgAydvUZbTdEBZs2vEiTiS9m61ssiDA==} + engines: {node: ^12.20.0 || ^14.13.1 || >=16.0.0} dependencies: type-fest: 2.19.0 + dev: true - ecc-jsbn@0.1.2: + /ecc-jsbn@0.1.2: + resolution: {integrity: sha512-eh9O+hwRHNbG4BLTjEl3nw044CkGm5X6LoaCf7LPp7UU8Qrt47JYNi6nPX8xjW97TKGKm1ouctg0QSpZe9qrnw==} dependencies: jsbn: 0.1.1 safer-buffer: 2.1.2 - ee-first@1.1.1: {} + /ee-first@1.1.1: + resolution: {integrity: sha512-WMwm9LhRUo+WUaRN+vRuETqG89IgZphVSNkdFgeb6sS/E4OrDIN7t48CAewSHXc6C8lefD8KKfr5vY61brQlow==} - eip55@2.1.1: + /eip55@2.1.1: + resolution: {integrity: sha512-WcagVAmNu2Ww2cDUfzuWVntYwFxbvZ5MvIyLZpMjTTkjD6sCvkGOiS86jTppzu9/gWsc8isLHAeMBWK02OnZmA==} dependencies: keccak: 3.0.4 + dev: false - electron-to-chromium@1.4.761: {} + /electron-to-chromium@1.4.761: + resolution: {integrity: sha512-PIbxpiJGx6Bb8dQaonNc6CGTRlVntdLg/2nMa1YhnrwYOORY9a3ZgGN0UQYE6lAcj/lkyduJN7BPt/JiY+jAQQ==} + dev: true - elliptic@6.5.4: + /elliptic@6.5.4: + resolution: {integrity: sha512-iLhC6ULemrljPZb+QutR5TQGB+pdW6KGD5RSegS+8sorOZT+rdQFbsQFJgvN3eRqNALqJer4oQ16YvJHlU8hzQ==} dependencies: bn.js: 4.12.0 brorand: 1.1.0 @@ -9942,7 +5781,8 @@ snapshots: minimalistic-assert: 1.0.1 minimalistic-crypto-utils: 1.0.1 - elliptic@6.5.5: + /elliptic@6.5.5: + resolution: {integrity: sha512-7EjbcmUm17NQFu4Pmgmq2olYMj8nwMnpcddByChSUjArp8F5DQWcIcpriwO4ZToLNAJig0yiyjswfyGNje/ixw==} dependencies: bn.js: 4.12.0 brorand: 1.1.0 @@ -9952,28 +5792,43 @@ snapshots: minimalistic-assert: 1.0.1 minimalistic-crypto-utils: 1.0.1 - emoji-regex@8.0.0: {} + /emoji-regex@8.0.0: + resolution: {integrity: sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A==} - encodeurl@1.0.2: {} + /encodeurl@1.0.2: + resolution: {integrity: sha512-TPJXq8JqFaVYm2CWmPvnP2Iyo4ZSM7/QKcSmuMLDObfpH5fi7RUGmd/rTDf+rut/saiDiQEeVTNgAmJEdAOx0w==} + engines: {node: '>= 0.8'} - end-of-stream@1.4.4: + /end-of-stream@1.4.4: + resolution: {integrity: sha512-+uw1inIHVPQoaVuHzRyXd21icM+cnt4CzD5rW+NC1wjOUSTOs+Te7FOv7AhN7vS9x/oIyhLP5PR1H+phQAHu5Q==} dependencies: once: 1.4.0 - enquirer@2.4.1: + /enquirer@2.4.1: + resolution: {integrity: sha512-rRqJg/6gd538VHvR3PSrdRBb/1Vy2YfzHqzvbhGIQpDRKIa4FgV/54b5Q1xYSxOOwKvjXweS26E0Q+nAMwp2pQ==} + engines: {node: '>=8.6'} dependencies: ansi-colors: 4.1.3 strip-ansi: 6.0.1 - entities@4.5.0: {} + /entities@4.5.0: + resolution: {integrity: sha512-V0hjH4dGPh9Ao5p0MoRY6BVqtwCjhz6vI5LT8AJ55H+4g9/4vbHx1I54fS0XuclLhDHArPQCiMjDxjaL8fPxhw==} + engines: {node: '>=0.12'} + dev: false - env-paths@2.2.1: {} + /env-paths@2.2.1: + resolution: {integrity: sha512-+h1lkLKhZMTYjog1VEpJNG7NZJWcuc2DDk/qsqSTRRCOXiLjeQ1d1/udrUGhqMxUgAlwKNZ0cf2uqan5GLuS2A==} + engines: {node: '>=6'} + dev: false - error-ex@1.3.2: + /error-ex@1.3.2: + resolution: {integrity: sha512-7dFHNmqeFSEt2ZBsCriorKnn3Z2pj+fd9kmI6QoWw4//DL+icEBfc0U7qJCisqrTsKTjw4fNFy2pW9OqStD84g==} dependencies: is-arrayish: 0.2.1 - es-abstract@1.23.3: + /es-abstract@1.23.3: + resolution: {integrity: sha512-e+HfNH61Bj1X9/jLc5v1owaLYuHdeHHSQlkhCBiTK8rBvKaULl/beGMxwrMXjpYrv4pz22BlY570vVePA2ho4A==} + engines: {node: '>= 0.4'} dependencies: array-buffer-byte-length: 1.0.1 arraybuffer.prototype.slice: 1.0.3 @@ -10021,64 +5876,99 @@ snapshots: typed-array-length: 1.0.6 unbox-primitive: 1.0.2 which-typed-array: 1.1.15 + dev: true - es-define-property@1.0.0: + /es-define-property@1.0.0: + resolution: {integrity: sha512-jxayLKShrEqqzJ0eumQbVhTYQM27CfT1T35+gCgDFoL82JLsXqTJ76zv6A0YLOgEnLUMvLzsDsGIrl8NFpT2gQ==} + engines: {node: '>= 0.4'} dependencies: get-intrinsic: 1.2.4 - es-errors@1.3.0: {} + /es-errors@1.3.0: + resolution: {integrity: sha512-Zf5H2Kxt2xjTvbJvP2ZWLEICxA6j+hAmMzIlypy4xcBg1vKVnx89Wy0GbS+kf5cwCVFFzdCFh2XSCFNULS6csw==} + engines: {node: '>= 0.4'} - es-object-atoms@1.0.0: + /es-object-atoms@1.0.0: + resolution: {integrity: sha512-MZ4iQ6JwHOBQjahnjwaC1ZtIBH+2ohjamzAO3oaHcXYup7qxjF2fixyH+Q71voWHeOkI2q/TnJao/KfXYIZWbw==} + engines: {node: '>= 0.4'} dependencies: es-errors: 1.3.0 + dev: true - es-set-tostringtag@2.0.3: + /es-set-tostringtag@2.0.3: + resolution: {integrity: sha512-3T8uNMC3OQTHkFUsFq8r/BwAXLHvU/9O9mE0fBc/MY5iq/8H7ncvO947LmYA6ldWw9Uh8Yhf25zu6n7nML5QWQ==} + engines: {node: '>= 0.4'} dependencies: get-intrinsic: 1.2.4 has-tostringtag: 1.0.2 hasown: 2.0.2 + dev: true - es-shim-unscopables@1.0.2: + /es-shim-unscopables@1.0.2: + resolution: {integrity: sha512-J3yBRXCzDu4ULnQwxyToo/OjdMx6akgVC7K6few0a7F/0wLtmKKN7I73AH5T2836UuXRqN7Qg+IIUw/+YJksRw==} dependencies: hasown: 2.0.2 + dev: true - es-to-primitive@1.2.1: + /es-to-primitive@1.2.1: + resolution: {integrity: sha512-QCOllgZJtaUo9miYBcLChTUaHNjJF3PYs1VidD7AwiEj1kYxKeQTctLAezAOH5ZKRH0g2IgPn6KwB4IT8iRpvA==} + engines: {node: '>= 0.4'} dependencies: is-callable: 1.2.7 is-date-object: 1.0.5 is-symbol: 1.0.4 + dev: true - es5-ext@0.10.64: + /es5-ext@0.10.64: + resolution: {integrity: sha512-p2snDhiLaXe6dahss1LddxqEm+SkuDvV8dnIQG0MWjyHpcMNfXKPE+/Cc0y+PhxJX3A4xGNeFCj5oc0BUh6deg==} + engines: {node: '>=0.10'} + requiresBuild: true dependencies: es6-iterator: 2.0.3 es6-symbol: 3.1.4 esniff: 2.0.1 next-tick: 1.1.0 - es6-error@4.1.1: {} + /es6-error@4.1.1: + resolution: {integrity: sha512-Um/+FxMr9CISWh0bi5Zv0iOD+4cFh5qLeks1qhAopKVAJw3drgKbKySikp7wGhDL0HPeaja0P5ULZrxLkniUVg==} + dev: true - es6-iterator@2.0.3: + /es6-iterator@2.0.3: + resolution: {integrity: sha512-zw4SRzoUkd+cl+ZoE15A9o1oQd920Bb0iOJMQkQhl3jNc03YqVjAhG7scf9C5KWRU/R13Orf588uCC6525o02g==} dependencies: d: 1.0.2 es5-ext: 0.10.64 es6-symbol: 3.1.4 - es6-promise@4.2.8: {} + /es6-promise@4.2.8: + resolution: {integrity: sha512-HJDGx5daxeIvxdBxvG2cb9g4tEvwIk3i8+nhX0yGrYmZUzbkdg8QbDevheDB8gd0//uPj4c1EQua8Q+MViT0/w==} - es6-symbol@3.1.4: + /es6-symbol@3.1.4: + resolution: {integrity: sha512-U9bFFjX8tFiATgtkJ1zg25+KviIXpgRvRHS8sau3GfhVzThRQrOeksPeT0BWW2MNZs1OEWJ1DPXOQMn0KKRkvg==} + engines: {node: '>=0.12'} dependencies: d: 1.0.2 ext: 1.7.0 - escalade@3.1.2: {} + /escalade@3.1.2: + resolution: {integrity: sha512-ErCHMCae19vR8vQGe50xIsVomy19rg6gFu3+r3jkEO46suLMWBksvVyoGgQV+jOfl84ZSOSlmv6Gxa89PmTGmA==} + engines: {node: '>=6'} - escape-html@1.0.3: {} + /escape-html@1.0.3: + resolution: {integrity: sha512-NiSupZ4OeuGwr68lGIeym/ksIZMJodUGOSCZ/FSnTxcrekbvqrgdUxlJOMpijaKZVjAJrWrGs/6Jy8OMuyj9ow==} - escape-string-regexp@1.0.5: {} + /escape-string-regexp@1.0.5: + resolution: {integrity: sha512-vbRorB5FUQWvla16U8R/qgaFIya2qGzwDrNmCZuYKrbdSUMG6I1ZCGQRefkRVhuOkIGVne7BQ35DSfo1qvJqFg==} + engines: {node: '>=0.8.0'} - escape-string-regexp@4.0.0: {} + /escape-string-regexp@4.0.0: + resolution: {integrity: sha512-TtpcNJ3XAzx3Gq8sWRzJaVajRs0uVxA2YAkdb1jm2YkPz4G6egUFAyA3n5vtEIZefPk5Wa4UXbKuS5fKkJWdgA==} + engines: {node: '>=10'} - escodegen@1.8.1: + /escodegen@1.8.1: + resolution: {integrity: sha512-yhi5S+mNTOuRvyW4gWlg5W1byMaQGWWSYHXsuFZ7GBo7tpyOwi2EdzMP/QWxh9hwkD2m+wDVHJsxhRIj+v/b/A==} + engines: {node: '>=0.12.0'} + hasBin: true dependencies: esprima: 2.7.3 estraverse: 1.9.3 @@ -10086,17 +5976,33 @@ snapshots: optionator: 0.8.3 optionalDependencies: source-map: 0.2.0 + dev: true - eslint-compat-utils@0.5.0(eslint@8.57.0): + /eslint-compat-utils@0.5.0(eslint@8.57.0): + resolution: {integrity: sha512-dc6Y8tzEcSYZMHa+CMPLi/hyo1FzNeonbhJL7Ol0ccuKQkwopJcJBA9YL/xmMTLU1eKigXo9vj9nALElWYSowg==} + engines: {node: '>=12'} + peerDependencies: + eslint: '>=6.0.0' dependencies: eslint: 8.57.0 semver: 7.6.2 + dev: true - eslint-config-prettier@8.3.0(eslint@8.57.0): + /eslint-config-prettier@8.3.0(eslint@8.57.0): + resolution: {integrity: sha512-BgZuLUSeKzvlL/VUjx/Yb787VQ26RU3gGjA3iiFvdsp/2bMfVIWUVP7tjxtjS0e+HP409cPlPvNkQloz8C91ew==} + hasBin: true + peerDependencies: + eslint: '>=7.0.0' dependencies: eslint: 8.57.0 + dev: true - eslint-doc-generator@1.7.1(eslint@8.57.0)(typescript@5.0.4): + /eslint-doc-generator@1.7.1(eslint@8.57.0)(typescript@5.0.4): + resolution: {integrity: sha512-i1Zjl+Xcy712SZhbceCeMVaIdhbFqY27i8d7f9gyb9P/6AQNnPA0VCWynAFVGYa0hpeR5kwUI09+GBELgC2nnA==} + engines: {node: ^14.18.0 || ^16.0.0 || >=18.0.0} + hasBin: true + peerDependencies: + eslint: '>= 7' dependencies: '@typescript-eslint/utils': 5.62.0(eslint@8.57.0)(typescript@5.0.4) ajv: 8.13.0 @@ -10114,8 +6020,10 @@ snapshots: transitivePeerDependencies: - supports-color - typescript + dev: true - eslint-import-resolver-node@0.3.9: + /eslint-import-resolver-node@0.3.9: + resolution: {integrity: sha512-WFj2isz22JahUv+B788TlO3N6zL3nNJGU8CcZbPZvVEkBPaJdCV4vy5wyghty5ROFbCRnm132v8BScu5/1BQ8g==} dependencies: debug: 3.2.7 is-core-module: 2.13.1 @@ -10123,31 +6031,68 @@ snapshots: transitivePeerDependencies: - supports-color - eslint-module-utils@2.8.1(@typescript-eslint/parser@5.61.0(eslint@8.57.0)(typescript@5.0.4))(eslint-import-resolver-node@0.3.9)(eslint@8.57.0): + /eslint-module-utils@2.8.1(@typescript-eslint/parser@5.61.0)(eslint-import-resolver-node@0.3.9)(eslint@8.57.0): + resolution: {integrity: sha512-rXDXR3h7cs7dy9RNpUlQf80nX31XWJEyGq1tRMo+6GsO5VmTe4UTwtmonAD4ZkAsrfMVDA2wlGJ3790Ys+D49Q==} + engines: {node: '>=4'} + peerDependencies: + '@typescript-eslint/parser': '*' + eslint: '*' + eslint-import-resolver-node: '*' + eslint-import-resolver-typescript: '*' + eslint-import-resolver-webpack: '*' + peerDependenciesMeta: + '@typescript-eslint/parser': + optional: true + eslint: + optional: true + eslint-import-resolver-node: + optional: true + eslint-import-resolver-typescript: + optional: true + eslint-import-resolver-webpack: + optional: true dependencies: - debug: 3.2.7 - optionalDependencies: '@typescript-eslint/parser': 5.61.0(eslint@8.57.0)(typescript@5.0.4) + debug: 3.2.7 eslint: 8.57.0 eslint-import-resolver-node: 0.3.9 transitivePeerDependencies: - supports-color - eslint-plugin-es-x@7.6.0(eslint@8.57.0): + /eslint-plugin-es-x@7.6.0(eslint@8.57.0): + resolution: {integrity: sha512-I0AmeNgevgaTR7y2lrVCJmGYF0rjoznpDvqV/kIkZSZbZ8Rw3eu4cGlvBBULScfkSOCzqKbff5LR4CNrV7mZHA==} + engines: {node: ^14.18.0 || >=16.0.0} + peerDependencies: + eslint: '>=8' dependencies: '@eslint-community/eslint-utils': 4.4.0(eslint@8.57.0) '@eslint-community/regexpp': 4.10.0 eslint: 8.57.0 eslint-compat-utils: 0.5.0(eslint@8.57.0) + dev: true - eslint-plugin-eslint-plugin@5.5.1(eslint@8.57.0): + /eslint-plugin-eslint-plugin@5.5.1(eslint@8.57.0): + resolution: {integrity: sha512-9AmfZzcQ7QHwpzfAQpZ7xdtwHYViylmlnruCH0aV64/tuoH3igGXg91vr0e6ShLf/mrAYGqLw5LZ/gOxJeRXnw==} + engines: {node: ^14.17.0 || ^16.0.0 || >= 18.0.0} + peerDependencies: + eslint: '>=7.0.0' dependencies: eslint: 8.57.0 eslint-utils: 3.0.0(eslint@8.57.0) estraverse: 5.3.0 + dev: true - eslint-plugin-import@2.27.5(@typescript-eslint/parser@5.61.0(eslint@8.57.0)(typescript@5.0.4))(eslint@8.57.0): + /eslint-plugin-import@2.27.5(@typescript-eslint/parser@5.61.0)(eslint@8.57.0): + resolution: {integrity: sha512-LmEt3GVofgiGuiE+ORpnvP+kAm3h6MLZJ4Q5HCyHADofsb4VzXFsRiWj3c0OFiV+3DWFh0qg3v9gcPlfc3zRow==} + engines: {node: '>=4'} + peerDependencies: + '@typescript-eslint/parser': '*' + eslint: ^2 || ^3 || ^4 || ^5 || ^6 || ^7.2.0 || ^8 + peerDependenciesMeta: + '@typescript-eslint/parser': + optional: true dependencies: + '@typescript-eslint/parser': 5.61.0(eslint@8.57.0)(typescript@5.0.4) array-includes: 3.1.8 array.prototype.flat: 1.3.2 array.prototype.flatmap: 1.3.2 @@ -10155,7 +6100,7 @@ snapshots: doctrine: 2.1.0 eslint: 8.57.0 eslint-import-resolver-node: 0.3.9 - eslint-module-utils: 2.8.1(@typescript-eslint/parser@5.61.0(eslint@8.57.0)(typescript@5.0.4))(eslint-import-resolver-node@0.3.9)(eslint@8.57.0) + eslint-module-utils: 2.8.1(@typescript-eslint/parser@5.61.0)(eslint-import-resolver-node@0.3.9)(eslint@8.57.0) has: 1.0.4 is-core-module: 2.13.1 is-glob: 4.0.3 @@ -10164,21 +6109,29 @@ snapshots: resolve: 1.22.8 semver: 6.3.1 tsconfig-paths: 3.15.0 - optionalDependencies: - '@typescript-eslint/parser': 5.61.0(eslint@8.57.0)(typescript@5.0.4) transitivePeerDependencies: - eslint-import-resolver-typescript - eslint-import-resolver-webpack - supports-color + dev: true - eslint-plugin-mocha@10.4.1(eslint@8.57.0): + /eslint-plugin-mocha@10.4.1(eslint@8.57.0): + resolution: {integrity: sha512-G85ALUgKaLzuEuHhoW3HVRgPTmia6njQC3qCG6CEvA8/Ja9PDZnRZOuzekMki+HaViEQXINuYsmhp5WR5/4MfA==} + engines: {node: '>=14.0.0'} + peerDependencies: + eslint: '>=7.0.0' dependencies: eslint: 8.57.0 eslint-utils: 3.0.0(eslint@8.57.0) globals: 13.24.0 rambda: 7.5.0 + dev: true - eslint-plugin-n@16.6.2(eslint@8.57.0): + /eslint-plugin-n@16.6.2(eslint@8.57.0): + resolution: {integrity: sha512-6TyDmZ1HXoFQXnhCTUjVFULReoBPOAjpuiKELMkeP40yffI/1ZRO+d9ug/VC6fqISo2WkuIBk3cvuRPALaWlOQ==} + engines: {node: '>=16.0.0'} + peerDependencies: + eslint: '>=7.0.0' dependencies: '@eslint-community/eslint-utils': 4.4.0(eslint@8.57.0) builtins: 5.1.0 @@ -10192,43 +6145,62 @@ snapshots: minimatch: 3.1.2 resolve: 1.22.8 semver: 7.6.2 + dev: true - eslint-plugin-prettier@3.4.0(eslint-config-prettier@8.3.0(eslint@8.57.0))(eslint@8.57.0)(prettier@2.4.1): + /eslint-plugin-prettier@3.4.0(eslint-config-prettier@8.3.0)(eslint@8.57.0)(prettier@2.4.1): + resolution: {integrity: sha512-UDK6rJT6INSfcOo545jiaOwB701uAIt2/dR7WnFQoGCVl1/EMqdANBmwUaqqQ45aXprsTGzSa39LI1PyuRBxxw==} + engines: {node: '>=6.0.0'} + peerDependencies: + eslint: '>=5.0.0' + eslint-config-prettier: '*' + prettier: '>=1.13.0' + peerDependenciesMeta: + eslint-config-prettier: + optional: true dependencies: eslint: 8.57.0 - prettier: 2.4.1 - prettier-linter-helpers: 1.0.0 - optionalDependencies: eslint-config-prettier: 8.3.0(eslint@8.57.0) - - eslint-plugin-prettier@3.4.0(eslint-config-prettier@8.3.0(eslint@8.57.0))(eslint@8.57.0)(prettier@2.8.8): - dependencies: - eslint: 8.57.0 - prettier: 2.8.8 + prettier: 2.4.1 prettier-linter-helpers: 1.0.0 - optionalDependencies: - eslint-config-prettier: 8.3.0(eslint@8.57.0) + dev: true - eslint-scope@5.1.1: + /eslint-scope@5.1.1: + resolution: {integrity: sha512-2NxwbF/hZ0KpepYN0cNbo+FN6XoK7GaHlQhgx/hIZl6Va0bF45RQOOwhLIy8lQDbuCiadSLCBnH2CFYquit5bw==} + engines: {node: '>=8.0.0'} dependencies: esrecurse: 4.3.0 estraverse: 4.3.0 - eslint-scope@7.2.2: + /eslint-scope@7.2.2: + resolution: {integrity: sha512-dOt21O7lTMhDM+X9mB4GX+DZrZtCUJPL/wlcTqxyrx5IvO0IYtILdtrQGQp+8n5S0gwSVmOf9NQrjMOgfQZlIg==} + engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0} dependencies: esrecurse: 4.3.0 estraverse: 5.3.0 - eslint-utils@3.0.0(eslint@8.57.0): + /eslint-utils@3.0.0(eslint@8.57.0): + resolution: {integrity: sha512-uuQC43IGctw68pJA1RgbQS8/NP7rch6Cwd4j3ZBtgo4/8Flj4eGE7ZYSZRN3iq5pVUv6GPdW5Z1RFleo84uLDA==} + engines: {node: ^10.0.0 || ^12.0.0 || >= 14.0.0} + peerDependencies: + eslint: '>=5' dependencies: eslint: 8.57.0 eslint-visitor-keys: 2.1.0 + dev: true - eslint-visitor-keys@2.1.0: {} + /eslint-visitor-keys@2.1.0: + resolution: {integrity: sha512-0rSmRBzXgDzIsD6mGdJgevzgezI534Cer5L/vyMX0kHzT/jiB43jRhd9YUlMGYLQy2zprNmoT8qasCGtY+QaKw==} + engines: {node: '>=10'} + dev: true - eslint-visitor-keys@3.4.3: {} + /eslint-visitor-keys@3.4.3: + resolution: {integrity: sha512-wpc+LXeiyiisxPlEkUzU6svyS1frIO3Mgxj1fdy7Pm8Ygzguax2N3Fa/D/ag1WqbOprdI+uY6wMUl8/a2G+iag==} + engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0} - eslint@8.57.0: + /eslint@8.57.0: + resolution: {integrity: sha512-dZ6+mexnaTIbSBZWgou51U6OmzIhYM2VcNdtiTtI7qPNZm35Akpr0f6vtw3w1Kmn5PYo+tZVfh13WrhpS6oLqQ==} + engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0} + hasBin: true dependencies: '@eslint-community/eslint-utils': 4.4.0(eslint@8.57.0) '@eslint-community/regexpp': 4.10.0 @@ -10271,54 +6243,88 @@ snapshots: transitivePeerDependencies: - supports-color - esniff@2.0.1: + /esniff@2.0.1: + resolution: {integrity: sha512-kTUIGKQ/mDPFoJ0oVfcmyJn4iBDRptjNVIzwIFR7tqWXdVI9xfA2RMwY/gbSpJG3lkdWNEjLap/NqVHZiJsdfg==} + engines: {node: '>=0.10'} dependencies: d: 1.0.2 es5-ext: 0.10.64 event-emitter: 0.3.5 type: 2.7.2 - espree@9.6.1: + /espree@9.6.1: + resolution: {integrity: sha512-oruZaFkjorTpF32kDSI5/75ViwGeZginGGy2NoOSg3Q9bnwlnmDm4HLnkl0RE3n+njDXR037aY1+x58Z/zFdwQ==} + engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0} dependencies: acorn: 8.11.3 acorn-jsx: 5.3.2(acorn@8.11.3) eslint-visitor-keys: 3.4.3 - esprima@2.7.3: {} + /esprima@2.7.3: + resolution: {integrity: sha512-OarPfz0lFCiW4/AV2Oy1Rp9qu0iusTKqykwTspGCZtPxmF81JR4MmIebvF1F9+UOKth2ZubLQ4XGGaU+hSn99A==} + engines: {node: '>=0.10.0'} + hasBin: true + dev: true - esprima@4.0.1: {} + /esprima@4.0.1: + resolution: {integrity: sha512-eGuFFw7Upda+g4p+QHvnW0RyTX/SVeJBDM/gCtMARO0cLuT2HcEKnTPvhjV6aGeqrCB/sbNop0Kszm0jsaWU4A==} + engines: {node: '>=4'} + hasBin: true + dev: true - esquery@1.5.0: + /esquery@1.5.0: + resolution: {integrity: sha512-YQLXUplAwJgCydQ78IMJywZCceoqk1oH01OERdSAJc/7U2AylwjhSCLDEtqwg811idIS/9fIU5GjG73IgjKMVg==} + engines: {node: '>=0.10'} dependencies: estraverse: 5.3.0 - esrecurse@4.3.0: + /esrecurse@4.3.0: + resolution: {integrity: sha512-KmfKL3b6G+RXvP8N1vr3Tq1kL/oCFgn2NYXEtqP8/L3pKapUA4G8cFVaoF3SU323CD4XypR/ffioHmkti6/Tag==} + engines: {node: '>=4.0'} dependencies: estraverse: 5.3.0 - estraverse@1.9.3: {} + /estraverse@1.9.3: + resolution: {integrity: sha512-25w1fMXQrGdoquWnScXZGckOv+Wes+JDnuN/+7ex3SauFRS72r2lFDec0EKPt2YD1wUJ/IrfEex+9yp4hfSOJA==} + engines: {node: '>=0.10.0'} + dev: true - estraverse@4.3.0: {} + /estraverse@4.3.0: + resolution: {integrity: sha512-39nnKffWz8xN1BU/2c79n9nB9HDzo0niYUqx6xyqUnyoAnQyyWpOTdZEeiCch8BBu515t4wp9ZmgVfVhn9EBpw==} + engines: {node: '>=4.0'} - estraverse@5.3.0: {} + /estraverse@5.3.0: + resolution: {integrity: sha512-MMdARuVEQziNTeJD8DgMqmhwR11BRQ/cBP+pLtYdSTnf3MIO8fFeiINEbX36ZdNlfU/7A9f3gUw49B3oQsvwBA==} + engines: {node: '>=4.0'} - esutils@2.0.3: {} + /esutils@2.0.3: + resolution: {integrity: sha512-kVscqXk4OCp68SZ0dkgEKVi6/8ij300KBWTJq32P/dYeWTSwK41WyTxalN1eRmA5Z9UU/LX9D7FWSmV9SAYx6g==} + engines: {node: '>=0.10.0'} - etag@1.8.1: {} + /etag@1.8.1: + resolution: {integrity: sha512-aIL5Fx7mawVa300al2BnEE4iNvo1qETxLrPI/o05L7z6go7fCw1J6EQmbK4FmJ2AS7kgVF/KEZWufBfdClMcPg==} + engines: {node: '>= 0.6'} - eth-ens-namehash@2.0.8: + /eth-ens-namehash@2.0.8: + resolution: {integrity: sha512-VWEI1+KJfz4Km//dadyvBBoBeSQ0MHTXPvr8UIXiLW6IanxvAV+DmlZAijZwAyggqGUfwQBeHf7tc9wzc1piSw==} dependencies: idna-uts46-hx: 2.3.1 js-sha3: 0.5.7 - eth-gas-reporter@0.2.27(bufferutil@4.0.8)(utf-8-validate@5.0.10): + /eth-gas-reporter@0.2.27: + resolution: {integrity: sha512-femhvoAM7wL0GcI8ozTdxfuBtBFJ9qsyIAsmKVjlWAHUbdnnXHt+lKzz/kmldM5lA9jLuNHGwuIxorNpLbR1Zw==} + peerDependencies: + '@codechecks/client': ^0.1.0 + peerDependenciesMeta: + '@codechecks/client': + optional: true dependencies: '@solidity-parser/parser': 0.14.5 axios: 1.6.8(debug@4.3.4) cli-table3: 0.5.1 colors: 1.4.0 ethereum-cryptography: 1.2.0 - ethers: 5.7.2(bufferutil@4.0.8)(utf-8-validate@5.0.10) + ethers: 5.7.2 fs-readdir-recursive: 1.1.0 lodash: 4.17.21 markdown-table: 1.1.3 @@ -10330,31 +6336,36 @@ snapshots: - bufferutil - debug - utf-8-validate + dev: true - eth-lib@0.1.29(bufferutil@4.0.8)(utf-8-validate@5.0.10): + /eth-lib@0.1.29: + resolution: {integrity: sha512-bfttrr3/7gG4E02HoWTDUcDDslN003OlOoBxk9virpAZQ1ja/jDgwkWB8QfJF7ojuEowrqy+lzp9VcJG7/k5bQ==} dependencies: bn.js: 4.12.0 elliptic: 6.5.5 nano-json-stream-parser: 0.1.2 servify: 0.1.12 - ws: 3.3.3(bufferutil@4.0.8)(utf-8-validate@5.0.10) + ws: 3.3.3 xhr-request-promise: 0.1.3 transitivePeerDependencies: - bufferutil - supports-color - utf-8-validate - eth-lib@0.2.8: + /eth-lib@0.2.8: + resolution: {integrity: sha512-ArJ7x1WcWOlSpzdoTBX8vkwlkSQ85CjjifSZtV4co64vWxSV8geWfPI9x4SVYu3DSxnX4yWFVTtGL+j9DUFLNw==} dependencies: bn.js: 4.12.0 elliptic: 6.5.5 xhr-request-promise: 0.1.3 - ethereum-bloom-filters@1.1.0: + /ethereum-bloom-filters@1.1.0: + resolution: {integrity: sha512-J1gDRkLpuGNvWYzWslBQR9cDV4nd4kfvVTE/Wy4Kkm4yb3EYRSlyi0eB/inTsSTTVyA0+HyzHgbr95Fn/Z1fSw==} dependencies: '@noble/hashes': 1.4.0 - ethereum-cryptography@0.1.3: + /ethereum-cryptography@0.1.3: + resolution: {integrity: sha512-w8/4x1SGGzc+tO97TASLja6SLd3fRIK2tLVcV2Gx4IB21hE19atll5Cq9o3d0ZmAYC/8aw0ipieTSiekAea4SQ==} dependencies: '@types/pbkdf2': 3.1.2 '@types/secp256k1': 4.0.6 @@ -10372,40 +6383,47 @@ snapshots: secp256k1: 4.0.3 setimmediate: 1.0.5 - ethereum-cryptography@1.2.0: + /ethereum-cryptography@1.2.0: + resolution: {integrity: sha512-6yFQC9b5ug6/17CQpCyE3k9eKBMdhyVjzUy1WkiuY/E4vj/SXDBbCw8QEIaXqf0Mf2SnY6RmpDcwlUmBSS0EJw==} dependencies: '@noble/hashes': 1.2.0 '@noble/secp256k1': 1.7.1 '@scure/bip32': 1.1.5 '@scure/bip39': 1.1.1 - ethereum-cryptography@2.1.3: + /ethereum-cryptography@2.1.3: + resolution: {integrity: sha512-BlwbIL7/P45W8FGW2r7LGuvoEZ+7PWsniMvQ4p5s2xCyw9tmaDlpfsN9HjAucbF+t/qpVHwZUisgfK24TCW8aA==} dependencies: '@noble/curves': 1.3.0 '@noble/hashes': 1.3.3 '@scure/bip32': 1.3.3 '@scure/bip39': 1.2.2 - ethereum-ens@0.8.0(bufferutil@4.0.8)(utf-8-validate@5.0.10): + /ethereum-ens@0.8.0: + resolution: {integrity: sha512-a8cBTF4AWw1Q1Y37V1LSCS9pRY4Mh3f8vCg5cbXCCEJ3eno1hbI/+Ccv9SZLISYpqQhaglP3Bxb/34lS4Qf7Bg==} dependencies: bluebird: 3.7.2 eth-ens-namehash: 2.0.8 js-sha3: 0.5.7 pako: 1.0.11 underscore: 1.13.6 - web3: 1.10.4(bufferutil@4.0.8)(utf-8-validate@5.0.10) + web3: 1.10.4 transitivePeerDependencies: - bufferutil - encoding - supports-color - utf-8-validate + dev: false - ethereumjs-abi@0.6.8: + /ethereumjs-abi@0.6.8: + resolution: {integrity: sha512-Tx0r/iXI6r+lRsdvkFDlut0N08jWMnKRZ6Gkq+Nmw75lZe4e6o3EkSnkaBP5NF6+m5PTGAr9JP43N3LyeoglsA==} dependencies: bn.js: 4.12.0 ethereumjs-util: 6.2.1 + dev: false - ethereumjs-util@6.2.1: + /ethereumjs-util@6.2.1: + resolution: {integrity: sha512-W2Ktez4L01Vexijrm5EB6w7dg4n/TgpoYU4avuT5T3Vmnw/eCRtiBrJfQYS/DCSvDIOLn2k57GcHdeBcgVxAqw==} dependencies: '@types/bn.js': 4.11.6 bn.js: 4.12.0 @@ -10414,8 +6432,11 @@ snapshots: ethereum-cryptography: 0.1.3 ethjs-util: 0.1.6 rlp: 2.2.7 + dev: false - ethereumjs-util@7.1.5: + /ethereumjs-util@7.1.5: + resolution: {integrity: sha512-SDl5kKrQAudFBUe5OJM9Ac6WmMyYmXX/6sTmLZ3ffG2eY6ZIGBes3pEDxNN6V72WyOw4CPD5RomKdsa8DAAwLg==} + engines: {node: '>=10.0.0'} dependencies: '@types/bn.js': 5.1.5 bn.js: 5.2.1 @@ -10423,7 +6444,8 @@ snapshots: ethereum-cryptography: 0.1.3 rlp: 2.2.7 - ethers@4.0.49: + /ethers@4.0.49: + resolution: {integrity: sha512-kPltTvWiyu+OktYy1IStSO16i2e7cS9D9OxZ81q2UUaiNPVrm/RTcbxamCXF9VUSKzJIdJV68EAIhTEVBalRWg==} dependencies: aes-js: 3.0.0 bn.js: 4.12.0 @@ -10434,8 +6456,10 @@ snapshots: setimmediate: 1.0.4 uuid: 2.0.1 xmlhttprequest: 1.8.0 + dev: false - ethers@5.7.2(bufferutil@4.0.8)(utf-8-validate@5.0.10): + /ethers@5.7.2: + resolution: {integrity: sha512-wswUsmWo1aOK8rR7DIKiWSw9DbLWe6x98Jrn8wcTflTVvaXhAMaB5zGAXy0GYQEQp9iO1iSHWVyARQm11zUtyg==} dependencies: '@ethersproject/abi': 5.7.0 '@ethersproject/abstract-provider': 5.7.0 @@ -10455,7 +6479,7 @@ snapshots: '@ethersproject/networks': 5.7.1 '@ethersproject/pbkdf2': 5.7.0 '@ethersproject/properties': 5.7.0 - '@ethersproject/providers': 5.7.2(bufferutil@4.0.8)(utf-8-validate@5.0.10) + '@ethersproject/providers': 5.7.2 '@ethersproject/random': 5.7.0 '@ethersproject/rlp': 5.7.0 '@ethersproject/sha2': 5.7.0 @@ -10471,7 +6495,9 @@ snapshots: - bufferutil - utf-8-validate - ethers@6.12.1(bufferutil@4.0.8)(utf-8-validate@5.0.10): + /ethers@6.12.1: + resolution: {integrity: sha512-j6wcVoZf06nqEcBbDWkKg8Fp895SS96dSnTCjiXT+8vt2o02raTn4Lo9ERUuIVU5bAjoPYeA+7ytQFexFmLuVw==} + engines: {node: '>=14.0.0'} dependencies: '@adraffy/ens-normalize': 1.10.1 '@noble/curves': 1.2.0 @@ -10479,46 +6505,67 @@ snapshots: '@types/node': 18.15.13 aes-js: 4.0.0-beta.5 tslib: 2.4.0 - ws: 8.5.0(bufferutil@4.0.8)(utf-8-validate@5.0.10) + ws: 8.5.0 transitivePeerDependencies: - bufferutil - utf-8-validate - ethjs-abi@0.1.8: + /ethjs-abi@0.1.8: + resolution: {integrity: sha512-3SIJpF+LCVJrNht9OjSJ7+3B9ABZf6dEATMj1PaslL0BW547Cz6/kGyuDvvrcEBlSsbGpCWYrJX5B8OjhcAMFQ==} + engines: {node: '>=6.5.0', npm: '>=3'} dependencies: bn.js: 4.11.6 js-sha3: 0.5.5 number-to-bn: 1.7.0 + dev: false - ethjs-unit@0.1.6: + /ethjs-unit@0.1.6: + resolution: {integrity: sha512-/Sn9Y0oKl0uqQuvgFk/zQgR7aw1g36qX/jzSQ5lSwlO0GigPymk4eGQfeNTD03w1dPOqfz8V77Cy43jH56pagw==} + engines: {node: '>=6.5.0', npm: '>=3'} dependencies: bn.js: 4.11.6 number-to-bn: 1.7.0 - ethjs-util@0.1.6: + /ethjs-util@0.1.6: + resolution: {integrity: sha512-CUnVOQq7gSpDHZVVrQW8ExxUETWrnrvXYvYz55wOU8Uj4VCgw56XC2B/fVqQN+f7gmrnRHSLVnFAwsCuNwji8w==} + engines: {node: '>=6.5.0', npm: '>=3'} dependencies: is-hex-prefixed: 1.0.0 strip-hex-prefix: 1.0.0 + dev: false - event-emitter@0.3.5: + /event-emitter@0.3.5: + resolution: {integrity: sha512-D9rRn9y7kLPnJ+hMq7S/nhvoKwwvVJahBi2BPmx3bvbsEdK3W9ii8cBSGjP+72/LnM4n6fo3+dkCX5FeTQruXA==} dependencies: d: 1.0.2 es5-ext: 0.10.64 - eventemitter3@4.0.4: {} + /eventemitter3@4.0.4: + resolution: {integrity: sha512-rlaVLnVxtxvoyLsQQFBx53YmXHDxRIzzTLbdfxqi4yocpSjAxXwkU0cScM5JgSKMqEhrZpnvQ2D9gjylR0AimQ==} - eventemitter3@5.0.1: {} + /eventemitter3@5.0.1: + resolution: {integrity: sha512-GWkBvjiSZK87ELrYOSESUYeVIc9mvLLf/nXalMOS5dYrgZq9o5OVkbZAVM06CVxYsCwH9BDZFPlQTlPA1j4ahA==} + dev: true - events@3.3.0: {} + /events@3.3.0: + resolution: {integrity: sha512-mQw+2fkQbALzQ7V0MY0IqdnXNOeTtP4r0lN9z7AAawCXgqea7bDii20AYrIBrFd/Hx0M2Ocz6S111CaFkUcb0Q==} + engines: {node: '>=0.8.x'} + dev: false - evp_bytestokey@1.0.3: + /evp_bytestokey@1.0.3: + resolution: {integrity: sha512-/f2Go4TognH/KvCISP7OUsHn85hT9nUkxxA9BEWxFn+Oj9o8ZNLm/40hdlgSLyuOimsrTKLUMEorQexp/aPQeA==} dependencies: md5.js: 1.3.5 safe-buffer: 5.2.1 - expand-template@2.0.3: {} + /expand-template@2.0.3: + resolution: {integrity: sha512-XYfuKMvj4O35f/pOXLObndIRvyQ+/+6AhODh+OKWj9S9498pHHn/IMszH+gt0fBCRWMNfk1ZSp5x3AifmnI2vg==} + engines: {node: '>=6'} + dev: false - express@4.19.2: + /express@4.19.2: + resolution: {integrity: sha512-5T6nhjsT+EOMzuck8JjBHARTHfMht0POzlA60WV2pMD3gyXw2LZnZ+ueGdNxG+0calOJcWKbpFcuzLZ91YWq9Q==} + engines: {node: '>= 0.10.0'} dependencies: accepts: 1.3.8 array-flatten: 1.1.1 @@ -10554,33 +6601,51 @@ snapshots: transitivePeerDependencies: - supports-color - ext@1.7.0: + /ext@1.7.0: + resolution: {integrity: sha512-6hxeJYaL110a9b5TEJSj0gojyHQAmA2ch5Os+ySCiA1QGdS697XWY1pzsrSjqA9LDEEgdB/KypIlR59RcLuHYw==} dependencies: type: 2.7.2 - extend@3.0.2: {} + /extend@3.0.2: + resolution: {integrity: sha512-fjquC59cD7CyW6urNXK0FBufkZcoiGG80wTuPujX590cB5Ttln20E2UB4S/WARVqhXffZl2LNgS+gQdPIIim/g==} - extendable-error@0.1.7: {} + /extendable-error@0.1.7: + resolution: {integrity: sha512-UOiS2in6/Q0FK0R0q6UY9vYpQ21mr/Qn1KOnte7vsACuNJf514WvCCUHSRCPcgjPT2bAhNIJdlE6bVap1GKmeg==} + dev: true - external-editor@3.1.0: + /external-editor@3.1.0: + resolution: {integrity: sha512-hMQ4CX1p1izmuLYyZqLMO/qGNw10wSv9QDCPfzXfyFrOaCSSoRfqE1Kf1s5an66J5JZC62NewG+mK49jOCtQew==} + engines: {node: '>=4'} dependencies: chardet: 0.7.0 iconv-lite: 0.4.24 tmp: 0.0.33 + dev: true - extsprintf@1.3.0: {} + /extsprintf@1.3.0: + resolution: {integrity: sha512-11Ndz7Nv+mvAC1j0ktTa7fAb0vLyGGX+rMHNBYQviQDGU0Hw7lhctJANqbPhu9nV9/izT/IntTgZ7Im/9LJs9g==} + engines: {'0': node >=0.6.0} - fast-check@3.1.1: + /fast-check@3.1.1: + resolution: {integrity: sha512-3vtXinVyuUKCKFKYcwXhGE6NtGWkqF8Yh3rvMZNzmwz8EPrgoc/v4pDdLHyLnCyCI5MZpZZkDEwFyXyEONOxpA==} + engines: {node: '>=8.0.0'} dependencies: pure-rand: 5.0.5 + dev: false - fast-deep-equal@1.1.0: {} + /fast-deep-equal@1.1.0: + resolution: {integrity: sha512-fueX787WZKCV0Is4/T2cyAdM4+x1S3MXXOAhavE1ys/W42SHAPacLTQhucja22QBYrfGw50M2sRiXPtTGv9Ymw==} + dev: false - fast-deep-equal@3.1.3: {} + /fast-deep-equal@3.1.3: + resolution: {integrity: sha512-f3qQ9oQy9j2AhBe/H9VC91wLmKBCCU/gDOnKNAYG5hswO7BLKj09Hc5HYNz9cGI++xlpDCIgDaitVs03ATR84Q==} - fast-diff@1.3.0: {} + /fast-diff@1.3.0: + resolution: {integrity: sha512-VxPP4NqbUjj6MaAOafWeUn2cXWLcCtljklUtZf0Ind4XQ+QPtmA0b18zZy0jIQx+ExRVCR/ZQpBmik5lXshNsw==} - fast-glob@3.3.2: + /fast-glob@3.3.2: + resolution: {integrity: sha512-oX2ruAFQwf/Orj8m737Y5adxDQO0LAB7/S5MnxCdTNDd4p6BsyIVsv9JQsATbTSq8KHRpLwIHbVlUNatxd+1Ow==} + engines: {node: '>=8.6.0'} dependencies: '@nodelib/fs.stat': 2.0.5 '@nodelib/fs.walk': 1.2.8 @@ -10588,27 +6653,40 @@ snapshots: merge2: 1.4.1 micromatch: 4.0.5 - fast-json-stable-stringify@2.1.0: {} + /fast-json-stable-stringify@2.1.0: + resolution: {integrity: sha512-lhd/wF+Lk98HZoTCtlVraHtfh5XYijIjalXck7saUtuanSDyLMxnHhSXEDJqHxD7msR8D0uCmqlkwjCV8xvwHw==} - fast-levenshtein@2.0.6: {} + /fast-levenshtein@2.0.6: + resolution: {integrity: sha512-DCXu6Ifhqcks7TZKY3Hxp3y6qphY5SJZmrWMDrKcERSOXWQdMhU9Ig/PYrzyw/ul9jOIyh0N4M0tbC5hodg8dw==} - fast-safe-stringify@2.1.1: {} + /fast-safe-stringify@2.1.1: + resolution: {integrity: sha512-W+KJc2dmILlPplD/H4K9l9LcAHAfPtP6BY84uVLXQ6Evcz9Lcg33Y2z1IVblT6xdY54PXYVHEv+0Wpq8Io6zkA==} + dev: true - fastq@1.17.1: + /fastq@1.17.1: + resolution: {integrity: sha512-sRVD3lWVIXWg6By68ZN7vho9a1pQcN/WBFaAAsDDFzlJjvoGx0P8z7V1t72grFJfJhu3YPZBuu25f7Kaw2jN1w==} dependencies: reusify: 1.0.4 - file-entry-cache@6.0.1: + /file-entry-cache@6.0.1: + resolution: {integrity: sha512-7Gps/XWymbLk2QLYK4NzpMOrYjMhdIxXuIvy2QBsLE6ljuodKvdkWs/cpyJJ3CVIVpH0Oi1Hvg1ovbMzLdFBBg==} + engines: {node: ^10.12.0 || >=12.0.0} dependencies: flat-cache: 3.2.0 - file-uri-to-path@1.0.0: {} + /file-uri-to-path@1.0.0: + resolution: {integrity: sha512-0Zt+s3L7Vf1biwWZ29aARiVYLx7iMGnEUl9x33fbB/j3jR81u/O2LbqK+Bm1CDSNDKVtJ/YjwY7TUd5SkeLQLw==} + dev: false - fill-range@7.0.1: + /fill-range@7.0.1: + resolution: {integrity: sha512-qOo9F+dMUmC2Lcb4BbVvnKJxTPjCm+RRpe4gDuGrzkL7mEVl/djYSu2OdQ2Pa302N4oqkSg9ir6jaLWJ2USVpQ==} + engines: {node: '>=8'} dependencies: to-regex-range: 5.0.1 - finalhandler@1.2.0: + /finalhandler@1.2.0: + resolution: {integrity: sha512-5uXcUVftlQMFnWC9qu/svkWv3GTd2PfUhK/3PLkYNAe7FbqJMt3515HaxE6eRL74GdsriiwujiawdaB1BpEISg==} + engines: {node: '>= 0.8'} dependencies: debug: 2.6.9 encodeurl: 1.0.2 @@ -10620,167 +6698,267 @@ snapshots: transitivePeerDependencies: - supports-color - find-cache-dir@3.3.2: + /find-cache-dir@3.3.2: + resolution: {integrity: sha512-wXZV5emFEjrridIgED11OoUKLxiYjAcqot/NJdAkOhlJ+vGzwhOAfcG5OX1jP+S0PcjEn8bdMJv+g2jwQ3Onig==} + engines: {node: '>=8'} dependencies: commondir: 1.0.1 make-dir: 3.1.0 pkg-dir: 4.2.0 + dev: true - find-replace@3.0.0: + /find-replace@3.0.0: + resolution: {integrity: sha512-6Tb2myMioCAgv5kfvP5/PkZZ/ntTpVK39fHY7WkWBgvbeE+VHd/tZuZ4mrC+bxh4cfOZeYKVPaJIZtZXV7GNCQ==} + engines: {node: '>=4.0.0'} dependencies: array-back: 3.1.0 + dev: true - find-up@1.1.2: + /find-up@1.1.2: + resolution: {integrity: sha512-jvElSjyuo4EMQGoTwo1uJU5pQMwTW5lS1x05zzfJuTIyLR3zwO27LYrxNg+dlvKpGOuGy/MzBdXh80g0ve5+HA==} + engines: {node: '>=0.10.0'} dependencies: path-exists: 2.1.0 pinkie-promise: 2.0.1 + dev: false - find-up@2.1.0: + /find-up@2.1.0: + resolution: {integrity: sha512-NWzkk0jSJtTt08+FBFMvXoeZnOJD+jTtsRmBYbAIzJdX6l7dLgR7CTubCM5/eDdPUBvLCeVasP1brfVR/9/EZQ==} + engines: {node: '>=4'} dependencies: locate-path: 2.0.0 + dev: false - find-up@4.1.0: + /find-up@4.1.0: + resolution: {integrity: sha512-PpOwAdQ/YlXQ2vj8a3h8IipDuYRi3wceVQQGYWxNINccq40Anw7BlsEXCMbt1Zt+OLA6Fq9suIpIWD0OsnISlw==} + engines: {node: '>=8'} dependencies: locate-path: 5.0.0 path-exists: 4.0.0 + dev: true - find-up@5.0.0: + /find-up@5.0.0: + resolution: {integrity: sha512-78/PXT1wlLLDgTzDs7sjq9hzz0vXD+zn+7wypEe4fXQxCmdmqfGsEPQxmiCSQI3ajFV91bVSsvNtrJRiW6nGng==} + engines: {node: '>=10'} dependencies: locate-path: 6.0.0 path-exists: 4.0.0 - find-yarn-workspace-root2@1.2.16: + /find-yarn-workspace-root2@1.2.16: + resolution: {integrity: sha512-hr6hb1w8ePMpPVUK39S4RlwJzi+xPLuVuG8XlwXU3KD5Yn3qgBWVfy3AzNlDhWvE1EORCE65/Qm26rFQt3VLVA==} dependencies: micromatch: 4.0.5 pkg-dir: 4.2.0 + dev: true - flat-cache@3.2.0: + /flat-cache@3.2.0: + resolution: {integrity: sha512-CYcENa+FtcUKLmhhqyctpclsq7QF38pKjZHsGNiSQF5r4FtoKDWabFDl3hzaEQMvT1LHEysw5twgLvpYYb4vbw==} + engines: {node: ^10.12.0 || >=12.0.0} dependencies: flatted: 3.3.1 keyv: 4.5.4 rimraf: 3.0.2 - flat@5.0.2: {} + /flat@5.0.2: + resolution: {integrity: sha512-b6suED+5/3rTpUBdG1gupIl8MPFCAMA0QXwmljLhvCUKcUvdE4gWky9zpuGCcXHOsz4J9wPGNWq6OKpmIzz3hQ==} + hasBin: true - flatted@3.3.1: {} + /flatted@3.3.1: + resolution: {integrity: sha512-X8cqMLLie7KsNUDSdzeN8FYK9rEt4Dt67OsG/DNGnYTSDBG4uFAJFBnUeiV+zCVAvwFy56IjM9sH51jVaEhNxw==} - follow-redirects@1.15.6(debug@4.3.4): - optionalDependencies: + /follow-redirects@1.15.6(debug@4.3.4): + resolution: {integrity: sha512-wWN62YITEaOpSK584EZXJafH1AGpO8RVgElfkuXbTOrPX4fIfOyEpW/CsiNd8JdYrAoOvafRTOEnvsO++qCqFA==} + engines: {node: '>=4.0'} + peerDependencies: + debug: '*' + peerDependenciesMeta: + debug: + optional: true + dependencies: debug: 4.3.4(supports-color@8.1.1) - for-each@0.3.3: + /for-each@0.3.3: + resolution: {integrity: sha512-jqYfLp7mo9vIyQf8ykW2v7A+2N4QjeCeI5+Dz9XraiO1ign81wjiH7Fb9vSOWvQfNtmSa4H2RoQTrrXivdUZmw==} dependencies: is-callable: 1.2.7 - foreground-child@2.0.0: + /foreground-child@2.0.0: + resolution: {integrity: sha512-dCIq9FpEcyQyXKCkyzmlPTFNgrCzPudOe+mhvJU5zAtlBnGVy2yKxtfsxK2tQBThwq225jcvBjpw1Gr40uzZCA==} + engines: {node: '>=8.0.0'} dependencies: cross-spawn: 7.0.3 signal-exit: 3.0.7 + dev: true - forever-agent@0.6.1: {} + /forever-agent@0.6.1: + resolution: {integrity: sha512-j0KLYPhm6zeac4lz3oJ3o65qvgQCcPubiyotZrXqEaG4hNagNYO8qdlUrX5vwqv9ohqeT/Z3j6+yW067yWWdUw==} - form-data-encoder@1.7.1: {} + /form-data-encoder@1.7.1: + resolution: {integrity: sha512-EFRDrsMm/kyqbTQocNvRXMLjc7Es2Vk+IQFx/YW7hkUH1eBl4J1fqiP34l74Yt0pFLCNpc06fkbVk00008mzjg==} - form-data@2.3.3: + /form-data@2.3.3: + resolution: {integrity: sha512-1lLKB2Mu3aGP1Q/2eCOx0fNbRMe7XdwktwOruhfqqd0rIJWwN4Dh+E3hrPSlDCXnSR7UtZ1N38rVXm+6+MEhJQ==} + engines: {node: '>= 0.12'} dependencies: asynckit: 0.4.0 combined-stream: 1.0.8 mime-types: 2.1.35 - form-data@2.5.1: + /form-data@2.5.1: + resolution: {integrity: sha512-m21N3WOmEEURgk6B9GLOE4RuWOFf28Lhh9qGYeNlGq4VDXUlJy2th2slBNU8Gp8EzloYZOibZJ7t5ecIrFSjVA==} + engines: {node: '>= 0.12'} dependencies: asynckit: 0.4.0 combined-stream: 1.0.8 mime-types: 2.1.35 + dev: true - form-data@4.0.0: + /form-data@4.0.0: + resolution: {integrity: sha512-ETEklSGi5t0QMZuiXoA/Q6vcnxcLQP5vdugSpuAyi6SVGi2clPPp+xgEhuMaHC+zGgn31Kd235W35f7Hykkaww==} + engines: {node: '>= 6'} dependencies: asynckit: 0.4.0 combined-stream: 1.0.8 mime-types: 2.1.35 - forwarded@0.2.0: {} + /forwarded@0.2.0: + resolution: {integrity: sha512-buRG0fpBtRHSTCOASe6hD258tEubFoRLb4ZNA6NxMVHNw2gOcwHo9wyablzMzOA5z9xA9L1KNjk/Nt6MT9aYow==} + engines: {node: '>= 0.6'} - fp-ts@1.19.3: {} + /fp-ts@1.19.3: + resolution: {integrity: sha512-H5KQDspykdHuztLTg+ajGN0Z2qUjcEf3Ybxc6hLt0k7/zPkn29XnKnxlBPyW2XIddWrGaJBzBl4VLYOtk39yZg==} + dev: false - fresh@0.5.2: {} + /fresh@0.5.2: + resolution: {integrity: sha512-zJ2mQYM18rEFOudeV4GShTGIQ7RbzA7ozbU9I/XBpm7kqgMywgmylMwXHxZJmkVoYkna9d2pVXVXPdYTP9ej8Q==} + engines: {node: '>= 0.6'} - fromentries@1.3.2: {} + /fromentries@1.3.2: + resolution: {integrity: sha512-cHEpEQHUg0f8XdtZCc2ZAhrHzKzT0MrFUTcvx+hfxYu7rGMDc5SKoXFh+n4YigxsHXRzc6OrCshdR1bWH6HHyg==} + dev: true - fs-constants@1.0.0: {} + /fs-constants@1.0.0: + resolution: {integrity: sha512-y6OAwoSIf7FyjMIv94u+b5rdheZEjzR63GTyZJm5qh4Bi+2YgwLCcI/fPFZkL5PSixOt6ZNKm+w+Hfp/Bciwow==} + dev: false - fs-extra@0.30.0: + /fs-extra@0.30.0: + resolution: {integrity: sha512-UvSPKyhMn6LEd/WpUaV9C9t3zATuqoqfWc3QdPhPLb58prN9tqYPlPWi8Krxi44loBoUzlobqZ3+8tGpxxSzwA==} dependencies: graceful-fs: 4.2.11 jsonfile: 2.4.0 klaw: 1.3.1 path-is-absolute: 1.0.1 rimraf: 2.7.1 + dev: false - fs-extra@10.1.0: + /fs-extra@10.1.0: + resolution: {integrity: sha512-oRXApq54ETRj4eMiFzGnHWGy+zo5raudjuxN0b8H7s/RU2oW0Wvsx9O0ACRN/kRq9E8Vu/ReskGB5o3ji+FzHQ==} + engines: {node: '>=12'} dependencies: graceful-fs: 4.2.11 jsonfile: 6.1.0 universalify: 2.0.1 + dev: true - fs-extra@4.0.3: + /fs-extra@4.0.3: + resolution: {integrity: sha512-q6rbdDd1o2mAnQreO7YADIxf/Whx4AHBiRf6d+/cVT8h44ss+lHgxf1FemcqDnQt9X3ct4McHr+JMGlYSsK7Cg==} dependencies: graceful-fs: 4.2.11 jsonfile: 4.0.0 universalify: 0.1.2 - fs-extra@7.0.1: + /fs-extra@7.0.1: + resolution: {integrity: sha512-YJDaCJZEnBmcbw13fvdAM9AwNOJwOzrE4pqMqBq5nFiEqXUqHwlK4B+3pUw6JNvfSPtX05xFHtYy/1ni01eGCw==} + engines: {node: '>=6 <7 || >=8'} dependencies: graceful-fs: 4.2.11 jsonfile: 4.0.0 universalify: 0.1.2 - fs-extra@8.1.0: + /fs-extra@8.1.0: + resolution: {integrity: sha512-yhlQgA6mnOJUKOsRUFsgJdQCvkKhcz8tlZG5HBQfReYZy46OwLcY+Zia0mtdHsOo9y/hP+CxMN0TU9QxoOtG4g==} + engines: {node: '>=6 <7 || >=8'} dependencies: graceful-fs: 4.2.11 jsonfile: 4.0.0 universalify: 0.1.2 + dev: true - fs-extra@9.1.0: + /fs-extra@9.1.0: + resolution: {integrity: sha512-hcg3ZmepS30/7BSFqRvoo3DOMQu7IjqxO5nCDt+zM9XWjb33Wg7ziNT+Qvqbuc3+gWpzO02JubVyk2G4Zvo1OQ==} + engines: {node: '>=10'} dependencies: at-least-node: 1.0.0 graceful-fs: 4.2.11 jsonfile: 6.1.0 universalify: 2.0.1 + dev: true - fs-minipass@1.2.7: + /fs-minipass@1.2.7: + resolution: {integrity: sha512-GWSSJGFy4e9GUeCcbIkED+bgAoFyj7XF1mV8rma3QW4NIqX9Kyx79N/PF61H5udOV3aY1IaMLs6pGbH71nlCTA==} dependencies: minipass: 2.9.0 - fs-readdir-recursive@1.1.0: {} + /fs-readdir-recursive@1.1.0: + resolution: {integrity: sha512-GNanXlVr2pf02+sPN40XN8HG+ePaNcvM0q5mZBd668Obwb0yD5GiUbZOFgwn8kGMY6I3mdyDJzieUy3PTYyTRA==} + dev: true - fs.realpath@1.0.0: {} + /fs.realpath@1.0.0: + resolution: {integrity: sha512-OO0pH2lK6a0hZnAdau5ItzHPI6pUlvI7jMVnxUQRtw4owF2wk8lOSabtGDCTP4Ggrg2MbGnWO9X8K1t4+fGMDw==} - fsevents@2.3.3: + /fsevents@2.3.3: + resolution: {integrity: sha512-5xoDfX+fL7faATnagmWPpbFtwh/R77WmMMqqHGS65C3vvB0YHrgF+B1YmZ3441tMj5n63k0212XNoJwzlhffQw==} + engines: {node: ^8.16.0 || ^10.6.0 || >=11.0.0} + os: [darwin] + requiresBuild: true optional: true - function-bind@1.1.2: {} + /function-bind@1.1.2: + resolution: {integrity: sha512-7XHNxH7qX9xG5mIwxkhumTox/MIRNcOgDrxWsMt2pAr23WHp6MrRlN7FBSFpCpr+oVO0F744iUgR82nJMfG2SA==} - function.prototype.name@1.1.6: + /function.prototype.name@1.1.6: + resolution: {integrity: sha512-Z5kx79swU5P27WEayXM1tBi5Ze/lbIyiNgU3qyXUOf9b2rgXYyF9Dy9Cx+IQv/Lc8WCG6L82zwUPpSS9hGehIg==} + engines: {node: '>= 0.4'} dependencies: call-bind: 1.0.7 define-properties: 1.2.1 es-abstract: 1.23.3 functions-have-names: 1.2.3 + dev: true - functions-have-names@1.2.3: {} + /functions-have-names@1.2.3: + resolution: {integrity: sha512-xckBUXyTIqT97tq2x2AMb+g163b5JFysYk0x4qxNFwbfQkmNZoiRHb6sPzI9/QV33WeuvVYBUIiD4NzNIyqaRQ==} + dev: true - ganache-cli@6.12.2: {} + /ganache-cli@6.12.2: + resolution: {integrity: sha512-bnmwnJDBDsOWBUP8E/BExWf85TsdDEFelQSzihSJm9VChVO1SHp94YXLP5BlA4j/OTxp0wR4R1Tje9OHOuAJVw==} + deprecated: ganache-cli is now ganache; visit https://trfl.io/g7 for details + hasBin: true + dev: true + bundledDependencies: + - source-map-support + - yargs + - ethereumjs-util - gensync@1.0.0-beta.2: {} + /gensync@1.0.0-beta.2: + resolution: {integrity: sha512-3hN7NaskYvMDLQY55gnW3NQ+mesEAepTqlg+VEbj7zzqEMBVNhzcGYYeqFo/TlYz6eQiFcp1HcsCZO+nGgS8zg==} + engines: {node: '>=6.9.0'} + dev: true - get-caller-file@1.0.3: {} + /get-caller-file@1.0.3: + resolution: {integrity: sha512-3t6rVToeoZfYSGd8YoLFR2DJkiQrIiUrGcjvFX2mDw3bn6k2OtwHN0TNCLbBO+w8qTvimhDkv+LSscbJY1vE6w==} + dev: false - get-caller-file@2.0.5: {} + /get-caller-file@2.0.5: + resolution: {integrity: sha512-DyFP3BM/3YHTQOCUL/w0OZHR0lpKeGrxotcHWcqNEdnltqFwXVfhEBQ94eIo34AfQpo0rGki4cyIiftY06h2Fg==} + engines: {node: 6.* || 8.* || >= 10.*} - get-func-name@2.0.2: {} + /get-func-name@2.0.2: + resolution: {integrity: sha512-8vXOvuE167CtIc3OyItco7N/dpRtBbYOsPsXCz7X/PMnlGjYjSGuZJgM1Y7mmew7BKf9BqvLX2tnOVy1BBUsxQ==} - get-intrinsic@1.2.4: + /get-intrinsic@1.2.4: + resolution: {integrity: sha512-5uYhsJH8VJBTv7oslg4BznJYhDoRI6waYCxMmCdnTrcCrHA/fCFKoTFz2JKKE0HdDFUF7/oQuhzumXJK7paBRQ==} + engines: {node: '>= 0.4'} dependencies: es-errors: 1.3.0 function-bind: 1.1.2 @@ -10788,56 +6966,87 @@ snapshots: has-symbols: 1.0.3 hasown: 2.0.2 - get-package-type@0.1.0: {} + /get-package-type@0.1.0: + resolution: {integrity: sha512-pjzuKtY64GYfWizNAJ0fr9VqttZkNiK2iS430LtIHzjBEr6bX8Am2zm4sW4Ro5wjWW5cAlRL1qAMTcXbjNAO2Q==} + engines: {node: '>=8.0.0'} + dev: true - get-port@3.2.0: {} + /get-port@3.2.0: + resolution: {integrity: sha512-x5UJKlgeUiNT8nyo/AcnwLnZuZNcSjSw0kogRB+Whd1fjjFq4B1hySFxSFWWSn4mIBzg3sRNUDFYc4g5gjPoLg==} + engines: {node: '>=4'} + dev: true - get-port@5.1.1: {} + /get-port@5.1.1: + resolution: {integrity: sha512-g/Q1aTSDOxFpchXC4i8ZWvxA1lnPqx/JHqcpIw0/LX9T8x/GBbi6YnlN5nhaKIFkT8oFsscUKgDJYxfwfS6QsQ==} + engines: {node: '>=8'} + dev: true - get-stream@5.2.0: + /get-stream@5.2.0: + resolution: {integrity: sha512-nBF+F1rAZVCu/p7rjzgA+Yb4lfYXrpl7a6VmJrU8wF9I1CKvP/QwPNZHnOlwbTkY6dvtFIzFMSyQXbLoTQPRpA==} + engines: {node: '>=8'} dependencies: pump: 3.0.0 - get-stream@6.0.1: {} + /get-stream@6.0.1: + resolution: {integrity: sha512-ts6Wi+2j3jQjqi70w5AlN8DFnkSwC+MqmxEzdEALB2qXZYV3X/b1CTfgPLGJNMeAWxdPfU8FO1ms3NUfaHCPYg==} + engines: {node: '>=10'} - get-symbol-description@1.0.2: + /get-symbol-description@1.0.2: + resolution: {integrity: sha512-g0QYk1dZBxGwk+Ngc+ltRH2IBp2f7zBkBMBJZCDerh6EhlhSR6+9irMCuT/09zD6qkarHUSn529sK/yL4S27mg==} + engines: {node: '>= 0.4'} dependencies: call-bind: 1.0.7 es-errors: 1.3.0 get-intrinsic: 1.2.4 + dev: true - get-tsconfig@4.7.5: + /get-tsconfig@4.7.5: + resolution: {integrity: sha512-ZCuZCnlqNzjb4QprAzXKdpp/gh6KTxSJuw3IBsPnV/7fV4NxC9ckB+vPTt8w7fJA0TaSD7c55BR47JD6MEDyDw==} dependencies: resolve-pkg-maps: 1.0.0 + dev: true - getpass@0.1.7: + /getpass@0.1.7: + resolution: {integrity: sha512-0fzj9JxOLfJ+XGLhR8ze3unN0KZCgZwiSSDz168VERjK8Wl8kVSdcu2kspd4s4wtAa1y/qrVRiAA0WclVsu0ng==} dependencies: assert-plus: 1.0.0 - ghost-testrpc@0.0.2: + /ghost-testrpc@0.0.2: + resolution: {integrity: sha512-i08dAEgJ2g8z5buJIrCTduwPIhih3DP+hOCTyyryikfV8T0bNvHnGXO67i0DD1H4GBDETTclPy9njZbfluQYrQ==} + hasBin: true dependencies: chalk: 2.4.2 node-emoji: 1.11.0 + dev: true - github-from-package@0.0.0: {} + /github-from-package@0.0.0: + resolution: {integrity: sha512-SyHy3T1v2NUXn29OsWdxmK6RwHD+vkj3v8en8AOBZ1wBQ/hCAQ5bAQTD02kW4W9tUp/3Qh6J8r9EvntiyCmOOw==} + dev: false - glob-parent@5.1.2: + /glob-parent@5.1.2: + resolution: {integrity: sha512-AOIgSQCepiJYwP3ARnGx+5VnTu2HBYdzbGP45eLw1vr3zB3vZLeyed1sC9hnbcOc9/SrMyM5RPQrkGz4aS9Zow==} + engines: {node: '>= 6'} dependencies: is-glob: 4.0.3 - glob-parent@6.0.2: + /glob-parent@6.0.2: + resolution: {integrity: sha512-XxwI8EOhVQgWp6iDL+3b0r86f4d6AX6zSU55HfB4ydCEuXLXc5FcYeOu+nnGftS4TEju/11rt4KJPTMgbfmv4A==} + engines: {node: '>=10.13.0'} dependencies: is-glob: 4.0.3 - glob@5.0.15: + /glob@5.0.15: + resolution: {integrity: sha512-c9IPMazfRITpmAAKi22dK1VKxGDX9ehhqfABDriL/lzO92xcUKEJPQHrVA/2YHSNFB4iFlykVmWvwo48nr3OxA==} dependencies: inflight: 1.0.6 inherits: 2.0.4 minimatch: 3.1.2 once: 1.4.0 path-is-absolute: 1.0.1 + dev: true - glob@7.1.7: + /glob@7.1.7: + resolution: {integrity: sha512-OvD9ENzPLbegENnYP5UUfJIirTg4+XwMWGaQfQTY0JenxNvvIKP3U3/tAQSPIu/lHxXYSZmpXlUHeqAIdKzBLQ==} dependencies: fs.realpath: 1.0.0 inflight: 1.0.6 @@ -10845,8 +7054,10 @@ snapshots: minimatch: 3.1.2 once: 1.4.0 path-is-absolute: 1.0.1 + dev: true - glob@7.2.0: + /glob@7.2.0: + resolution: {integrity: sha512-lmLf6gtyrPq8tTjSmrO94wBeQbFR3HbLHbuyD69wuyQkImp2hWqMGB47OX65FBkPffO641IP9jWa1z4ivqG26Q==} dependencies: fs.realpath: 1.0.0 inflight: 1.0.6 @@ -10855,7 +7066,9 @@ snapshots: once: 1.4.0 path-is-absolute: 1.0.1 - glob@8.1.0: + /glob@8.1.0: + resolution: {integrity: sha512-r8hpEjiQEYlF2QU0df3dS+nxxSIreXQS1qRhMJM0Q5NDdR386C7jb7Hwwod8Fgiuex+k0GFjgft18yvxm5XoCQ==} + engines: {node: '>=12'} dependencies: fs.realpath: 1.0.0 inflight: 1.0.6 @@ -10863,33 +7076,50 @@ snapshots: minimatch: 5.0.1 once: 1.4.0 - global-modules@2.0.0: + /global-modules@2.0.0: + resolution: {integrity: sha512-NGbfmJBp9x8IxyJSd1P+otYK8vonoJactOogrVfFRIAEY1ukil8RSKDz2Yo7wh1oihl51l/r6W4epkeKJHqL8A==} + engines: {node: '>=6'} dependencies: global-prefix: 3.0.0 + dev: true - global-prefix@3.0.0: + /global-prefix@3.0.0: + resolution: {integrity: sha512-awConJSVCHVGND6x3tmMaKcQvwXLhjdkmomy2W+Goaui8YPgYgXJZewhg3fWC+DlfqqQuWg8AwqjGTD2nAPVWg==} + engines: {node: '>=6'} dependencies: ini: 1.3.8 kind-of: 6.0.3 which: 1.3.1 + dev: true - global@4.4.0: + /global@4.4.0: + resolution: {integrity: sha512-wv/LAoHdRE3BeTGz53FAamhGlPLhlssK45usmGFThIi4XqnBmjKQ16u+RNbP7WvigRZDxUsM0J3gcQ5yicaL0w==} dependencies: min-document: 2.19.0 process: 0.11.10 - globals@11.12.0: {} + /globals@11.12.0: + resolution: {integrity: sha512-WOBp/EEGUiIsJSp7wcv/y6MO+lV9UoncWqxuFfm8eBwzWNgyfBd6Gz+IeKQ9jCmyhoH99g15M3T+QaVHFjizVA==} + engines: {node: '>=4'} + dev: true - globals@13.24.0: + /globals@13.24.0: + resolution: {integrity: sha512-AhO5QUcj8llrbG09iWhPU2B204J1xnPeL8kQmVorSsy+Sjj1sk8gIyh6cUocGmH4L0UuhAJy+hJMRA4mgA4mFQ==} + engines: {node: '>=8'} dependencies: type-fest: 0.20.2 - globalthis@1.0.4: + /globalthis@1.0.4: + resolution: {integrity: sha512-DpLKbNU4WylpxJykQujfCcwYWiV/Jhm50Goo0wrVILAv5jOr9d+H+UR3PhSCD2rCCEIg0uc+G+muBTwD54JhDQ==} + engines: {node: '>= 0.4'} dependencies: define-properties: 1.2.1 gopd: 1.0.1 + dev: true - globby@10.0.2: + /globby@10.0.2: + resolution: {integrity: sha512-7dUi7RvCoT/xast/o/dLN53oqND4yk0nsHkhRgn9w65C4PofCLOoJ39iSOg+qVDdWQPIEj+eszMHQ+aLVwwQSg==} + engines: {node: '>=8'} dependencies: '@types/glob': 7.2.0 array-union: 2.1.0 @@ -10899,8 +7129,11 @@ snapshots: ignore: 5.3.1 merge2: 1.4.1 slash: 3.0.0 + dev: true - globby@11.1.0: + /globby@11.1.0: + resolution: {integrity: sha512-jhIXaOzy1sb8IyocaruWSn1TjmnBVs8Ayhcy83rmxNJ8q2uWKCAj3CnJY+KpGSXCueAPc0i05kVvVKtP1t9S3g==} + engines: {node: '>=10'} dependencies: array-union: 2.1.0 dir-glob: 3.0.1 @@ -10909,11 +7142,14 @@ snapshots: merge2: 1.4.1 slash: 3.0.0 - gopd@1.0.1: + /gopd@1.0.1: + resolution: {integrity: sha512-d65bNlIadxvpb/A2abVdlqKqV563juRnZ1Wtk6s1sIR8uNsXR70xqIzVqxVf1eTqDunwT2MkczEeaezCKTZhwA==} dependencies: get-intrinsic: 1.2.4 - got@11.8.6: + /got@11.8.6: + resolution: {integrity: sha512-6tfZ91bOr7bOXnK7PRDCGBLa1H4U080YHNaAQ2KsMGlLEzRbk44nsZF2E1IeRc3vtJHPVbKCYgdFbaGO2ljd8g==} + engines: {node: '>=10.19.0'} dependencies: '@sindresorhus/is': 4.6.0 '@szmarczak/http-timer': 4.0.6 @@ -10927,7 +7163,9 @@ snapshots: p-cancelable: 2.1.1 responselike: 2.0.1 - got@12.1.0: + /got@12.1.0: + resolution: {integrity: sha512-hBv2ty9QN2RdbJJMK3hesmSkFTjVIHyIDDbssCKnSmq62edGgImJWD10Eb1k77TiV1bxloxqcFAVK8+9pkhOig==} + engines: {node: '>=14.16'} dependencies: '@sindresorhus/is': 4.6.0 '@szmarczak/http-timer': 5.0.1 @@ -10943,13 +7181,20 @@ snapshots: p-cancelable: 3.0.0 responselike: 2.0.1 - graceful-fs@4.2.11: {} + /graceful-fs@4.2.11: + resolution: {integrity: sha512-RbJ5/jmFcNNCcDV5o9eTnBLJ/HszWV0P73bc+Ff4nS/rJj+YaS6IGyiOL0VoBYX+l1Wrl3k63h/KrH+nhJ0XvQ==} - grapheme-splitter@1.0.4: {} + /grapheme-splitter@1.0.4: + resolution: {integrity: sha512-bzh50DW9kTPM00T8y4o8vQg89Di9oLJVLW/KaOGIXJWP/iqCN6WKYkbNOF04vFLJhwcpYUh9ydh/+5vpOqV4YQ==} + dev: true - graphemer@1.4.0: {} + /graphemer@1.4.0: + resolution: {integrity: sha512-EtKwoO6kxCL9WO5xipiHTZlSzBm7WLT627TqC/uVRd0HKmq8NXyebnNYxDoBi7wt8eTWrUrKXCOVaFq9x1kgag==} - handlebars@4.7.8: + /handlebars@4.7.8: + resolution: {integrity: sha512-vafaFqs8MZkRrSX7sFVUdo3ap/eNiLnb4IakshzvP56X5Nr1iGKAIqdX6tMlm6HcNRIkr6AxO5jFEoJzzpT8aQ==} + engines: {node: '>=0.4.7'} + hasBin: true dependencies: minimist: 1.2.8 neo-async: 2.6.2 @@ -10957,20 +7202,32 @@ snapshots: wordwrap: 1.0.0 optionalDependencies: uglify-js: 3.17.4 + dev: true - har-schema@2.0.0: {} + /har-schema@2.0.0: + resolution: {integrity: sha512-Oqluz6zhGX8cyRaTQlFMPw80bSJVG2x/cFb8ZPhUILGgHka9SsokCCOQgpveePerqidZOrT14ipqfJb7ILcW5Q==} + engines: {node: '>=4'} - har-validator@5.1.5: + /har-validator@5.1.5: + resolution: {integrity: sha512-nmT2T0lljbxdQZfspsno9hgrG3Uir6Ks5afism62poxqBM6sDnMEuPmzTq8XN0OEwqKLLdh1jQI3qyE66Nzb3w==} + engines: {node: '>=6'} + deprecated: this library is no longer supported dependencies: ajv: 6.12.6 har-schema: 2.0.0 - hard-rejection@2.1.0: {} + /hard-rejection@2.1.0: + resolution: {integrity: sha512-VIZB+ibDhx7ObhAe7OVtoEbuP4h/MuOTHJ+J8h/eBXotJYl0fBgR72xDFCKgIh22OJZIOVNxBMWuhAr10r8HdA==} + engines: {node: '>=6'} + dev: true - hardhat-gas-reporter@1.0.10(bufferutil@4.0.8)(hardhat@packages+hardhat-core)(utf-8-validate@5.0.10): + /hardhat-gas-reporter@1.0.10(hardhat@packages+hardhat-core): + resolution: {integrity: sha512-02N4+So/fZrzJ88ci54GqwVA3Zrf0C9duuTyGt0CFRIh/CdNwbnTgkXkRfojOMLBQ+6t+lBIkgbsOtqMvNwikA==} + peerDependencies: + hardhat: ^2.0.2 dependencies: array-uniq: 1.0.3 - eth-gas-reporter: 0.2.27(bufferutil@4.0.8)(utf-8-validate@5.0.10) + eth-gas-reporter: 0.2.27 hardhat: link:packages/hardhat-core sha1: 1.1.1 transitivePeerDependencies: @@ -10978,96 +7235,151 @@ snapshots: - bufferutil - debug - utf-8-validate + dev: true - has-bigints@1.0.2: {} + /has-bigints@1.0.2: + resolution: {integrity: sha512-tSvCKtBr9lkF0Ex0aQiP9N+OpV4zi2r/Nee5VkRDbaqv35RLYMzbwQfFSZZH0kR+Rd6302UJZ2p/bJCEoR3VoQ==} + dev: true - has-color@0.1.7: {} + /has-color@0.1.7: + resolution: {integrity: sha512-kaNz5OTAYYmt646Hkqw50/qyxP2vFnTVu5AQ1Zmk22Kk5+4Qx6BpO8+u7IKsML5fOsFk0ZT0AcCJNYwcvaLBvw==} + engines: {node: '>=0.10.0'} + dev: true - has-flag@1.0.0: {} + /has-flag@1.0.0: + resolution: {integrity: sha512-DyYHfIYwAJmjAjSSPKANxI8bFY9YtFrgkAfinBojQ8YJTOuOuav64tMUJv584SES4xl74PmuaevIyaLESHdTAA==} + engines: {node: '>=0.10.0'} + dev: true - has-flag@3.0.0: {} + /has-flag@3.0.0: + resolution: {integrity: sha512-sKJf1+ceQBr4SMkvQnBDNDtf4TXpVhVGateu0t918bl30FnbE2m4vNLX+VWe/dpjlb+HugGYzW7uQXH98HPEYw==} + engines: {node: '>=4'} - has-flag@4.0.0: {} + /has-flag@4.0.0: + resolution: {integrity: sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ==} + engines: {node: '>=8'} - has-property-descriptors@1.0.2: + /has-property-descriptors@1.0.2: + resolution: {integrity: sha512-55JNKuIW+vq4Ke1BjOTjM2YctQIvCT7GFzHwmfZPGo5wnrgkid0YQtnAleFSqumZm4az3n2BS+erby5ipJdgrg==} dependencies: es-define-property: 1.0.0 - has-proto@1.0.3: {} + /has-proto@1.0.3: + resolution: {integrity: sha512-SJ1amZAJUiZS+PhsVLf5tGydlaVB8EdFpaSO4gmiUKUOxk8qzn5AIy4ZeJUmh22znIdk/uMAUT2pl3FxzVUH+Q==} + engines: {node: '>= 0.4'} - has-symbols@1.0.3: {} + /has-symbols@1.0.3: + resolution: {integrity: sha512-l3LCuF6MgDNwTDKkdYGEihYjt5pRPbEg46rtlmnSPlUbgmB8LOIrKJbYYFBSbnPaJexMKtiPO8hmeRjRz2Td+A==} + engines: {node: '>= 0.4'} - has-tostringtag@1.0.2: + /has-tostringtag@1.0.2: + resolution: {integrity: sha512-NqADB8VjPFLM2V0VvHUewwwsw0ZWBaIdgo+ieHtK3hasLz4qeCRjYcqfB6AQrBggRKppKF8L52/VqdVsO47Dlw==} + engines: {node: '>= 0.4'} dependencies: has-symbols: 1.0.3 - has@1.0.4: {} + /has@1.0.4: + resolution: {integrity: sha512-qdSAmqLF6209RFj4VVItywPMbm3vWylknmB3nvNiUIs72xAimcM8nVYxYr7ncvZq5qzk9MKIZR8ijqD/1QuYjQ==} + engines: {node: '>= 0.4.0'} + dev: true - hash-base@3.1.0: + /hash-base@3.1.0: + resolution: {integrity: sha512-1nmYp/rhMDiE7AYkDw+lLwlAzz0AntGIe51F3RfFfEqyQ3feY2eI/NcwC6umIQVOASPMsWJLJScWKSSvzL9IVA==} + engines: {node: '>=4'} dependencies: inherits: 2.0.4 readable-stream: 3.6.2 safe-buffer: 5.2.1 - hash.js@1.1.3: + /hash.js@1.1.3: + resolution: {integrity: sha512-/UETyP0W22QILqS+6HowevwhEFJ3MBJnwTf75Qob9Wz9t0DPuisL8kW8YZMK62dHAKE1c1p+gY1TtOLY+USEHA==} dependencies: inherits: 2.0.4 minimalistic-assert: 1.0.1 + dev: false - hash.js@1.1.7: + /hash.js@1.1.7: + resolution: {integrity: sha512-taOaskGt4z4SOANNseOviYDvjEJinIkRgmp7LbKP2YTTmVxWBl87s/uzK9r+44BclBSp2X7K1hqeNfz9JbBeXA==} dependencies: inherits: 2.0.4 minimalistic-assert: 1.0.1 - hasha@5.2.2: + /hasha@5.2.2: + resolution: {integrity: sha512-Hrp5vIK/xr5SkeN2onO32H0MgNZ0f17HRNH39WfL0SYUNOTZ5Lz1TJ8Pajo/87dYGEFlLMm7mIc/k/s6Bvz9HQ==} + engines: {node: '>=8'} dependencies: is-stream: 2.0.1 type-fest: 0.8.1 + dev: true - hasown@2.0.2: + /hasown@2.0.2: + resolution: {integrity: sha512-0hJU9SCPvmMzIBdZFqNPXWa6dqh7WdH0cII9y+CyS8rG3nL48Bclra9HmKhVVUHyPWNH5Y7xDwAB7bfgSjkUMQ==} + engines: {node: '>= 0.4'} dependencies: function-bind: 1.1.2 - he@1.2.0: {} + /he@1.2.0: + resolution: {integrity: sha512-F/1DnUGPopORZi0ni+CvrCgHQ5FyEAHRLSApuYWMmrbSwoN2Mn/7k+Gl38gJnR7yyDZk6WLXwiGod1JOWNDKGw==} + hasBin: true - header-case@1.0.1: + /header-case@1.0.1: + resolution: {integrity: sha512-i0q9mkOeSuhXw6bGgiQCCBgY/jlZuV/7dZXyZ9c6LcBrqwvT8eT719E9uxE5LiZftdl+z81Ugbg/VvXV4OJOeQ==} dependencies: no-case: 2.3.2 upper-case: 1.1.3 + dev: false - heap@0.2.7: {} + /heap@0.2.7: + resolution: {integrity: sha512-2bsegYkkHO+h/9MGbn6KWcE45cHZgPANo5LXF7EvWdT0yT2EguSVO1nDgU5c8+ZOPwp2vMNa7YFsJhVcDR9Sdg==} + dev: true - highlight.js@10.7.3: {} + /highlight.js@10.7.3: + resolution: {integrity: sha512-tzcUFauisWKNHaRkN4Wjl/ZA07gENAjFl3J/c480dprkGTg5EQstgaNFqBfUqCq54kZRIEcreTsAgF/m2quD7A==} + dev: false - highlightjs-solidity@2.0.6: {} + /highlightjs-solidity@2.0.6: + resolution: {integrity: sha512-DySXWfQghjm2l6a/flF+cteroJqD4gI8GSdL4PtvxZSsAHie8m3yVe2JFoRg03ROKT6hp2Lc/BxXkqerNmtQYg==} + dev: false - hmac-drbg@1.0.1: + /hmac-drbg@1.0.1: + resolution: {integrity: sha512-Tti3gMqLdZfhOQY1Mzf/AanLiqh1WTiJgEj26ZuYQ9fbkLomzGchCws4FyrSd4VkpBfiNhaE1On+lOz894jvXg==} dependencies: hash.js: 1.1.7 minimalistic-assert: 1.0.1 minimalistic-crypto-utils: 1.0.1 - hosted-git-info@2.8.9: {} + /hosted-git-info@2.8.9: + resolution: {integrity: sha512-mxIDAb9Lsm6DoOJ7xH+5+X4y1LU/4Hi50L9C5sIswK3JzULS4bwk1FvjdBgvYR4bzT4tuUQiC15FE2f5HbLvYw==} - html-escaper@2.0.2: {} + /html-escaper@2.0.2: + resolution: {integrity: sha512-H2iMtd0I4Mt5eYiapRdIDjp+XzelXQ0tFE4JS7YFwFevXXMmOp9myNrUvCg0D6ws8iqkRPBfKHgbwig1SmlLfg==} + dev: true - htmlparser2@8.0.2: + /htmlparser2@8.0.2: + resolution: {integrity: sha512-GYdjWKDkbRLkZ5geuHs5NY1puJ+PXwP7+fHPRz06Eirsb9ugf6d8kkXav6ADhcODhFFPMIXyxkxSuMf3D6NCFA==} dependencies: domelementtype: 2.3.0 domhandler: 5.0.3 domutils: 3.1.0 entities: 4.5.0 + dev: false - http-basic@8.1.3: + /http-basic@8.1.3: + resolution: {integrity: sha512-/EcDMwJZh3mABI2NhGfHOGOeOZITqfkEO4p/xK+l3NpyncIHUQBoMvCSF/b5GqvKtySC2srL/GGG3+EtlqlmCw==} + engines: {node: '>=6.0.0'} dependencies: caseless: 0.12.0 concat-stream: 1.6.2 http-response-object: 3.0.2 parse-cache-control: 1.0.1 + dev: true - http-cache-semantics@4.1.1: {} + /http-cache-semantics@4.1.1: + resolution: {integrity: sha512-er295DKPVsV82j5kw1Gjt+ADA/XYHsajl82cGNQG2eyoPkvgUhX+nDIyelzhIWbbsXP39EHcI6l5tYs2FYqYXQ==} - http-errors@2.0.0: + /http-errors@2.0.0: + resolution: {integrity: sha512-FtwrG/euBzaEjYeRqOgly7G0qviiXoJWnvEH2Z1plBdXgbyjv34pHTSb9zoeHMyDy33+DWy5Wt9Wo+TURtOYSQ==} + engines: {node: '>= 0.8'} dependencies: depd: 2.0.0 inherits: 2.0.4 @@ -11075,253 +7387,424 @@ snapshots: statuses: 2.0.1 toidentifier: 1.0.1 - http-https@1.0.0: {} + /http-https@1.0.0: + resolution: {integrity: sha512-o0PWwVCSp3O0wS6FvNr6xfBCHgt0m1tvPLFOCc2iFDKTRAXhB7m8klDf7ErowFH8POa6dVdGatKU5I1YYwzUyg==} - http-response-object@3.0.2: + /http-response-object@3.0.2: + resolution: {integrity: sha512-bqX0XTF6fnXSQcEJ2Iuyr75yVakyjIDCqroJQ/aHfSdlM743Cwqoi2nDYMzLGWUcuTWGWy8AAvOKXTfiv6q9RA==} dependencies: '@types/node': 10.17.60 + dev: true - http-signature@1.2.0: + /http-signature@1.2.0: + resolution: {integrity: sha512-CAbnr6Rz4CYQkLYUtSNXxQPUH2gK8f3iWexVlsnMeD+GjlsQ0Xsy1cOX+mN3dtxYomRy21CiOzU8Uhw6OwncEQ==} + engines: {node: '>=0.8', npm: '>=1.3.7'} dependencies: assert-plus: 1.0.0 jsprim: 1.4.2 sshpk: 1.18.0 - http2-wrapper@1.0.3: + /http2-wrapper@1.0.3: + resolution: {integrity: sha512-V+23sDMr12Wnz7iTcDeJr3O6AIxlnvT/bmaAAAP/Xda35C90p9599p0F1eHR/N1KILWSoWVAiOMFjBBXaXSMxg==} + engines: {node: '>=10.19.0'} dependencies: quick-lru: 5.1.1 resolve-alpn: 1.2.1 - http2-wrapper@2.2.1: + /http2-wrapper@2.2.1: + resolution: {integrity: sha512-V5nVw1PAOgfI3Lmeaj2Exmeg7fenjhRUgz1lPSezy1CuhPYbgQtbQj4jZfEAEMlaL+vupsvhjqCyjzob0yxsmQ==} + engines: {node: '>=10.19.0'} dependencies: quick-lru: 5.1.1 resolve-alpn: 1.2.1 - https-proxy-agent@5.0.1: + /https-proxy-agent@5.0.1: + resolution: {integrity: sha512-dFcAjpTQFgoLMzC2VwU+C/CbS7uRL0lWmxDITmqm7C+7F0Odmj6s9l6alZc6AELXhrnggM2CeWSXHGOdX2YtwA==} + engines: {node: '>= 6'} dependencies: agent-base: 6.0.2 debug: 4.3.4(supports-color@8.1.1) transitivePeerDependencies: - supports-color + dev: false - human-id@1.0.2: {} + /human-id@1.0.2: + resolution: {integrity: sha512-UNopramDEhHJD+VR+ehk8rOslwSfByxPIZyJRfV739NDhN5LF1fa1MqnzKm2lGTQRjNrjK19Q5fhkgIfjlVUKw==} + dev: true - iconv-lite@0.4.24: + /iconv-lite@0.4.24: + resolution: {integrity: sha512-v3MXnZAcvnywkTUEZomIActle7RXXeedOR31wwl7VlyoXO4Qi9arvSenNQWne1TcRwhCL1HwLI21bEqdpj8/rA==} + engines: {node: '>=0.10.0'} dependencies: safer-buffer: 2.1.2 - idna-uts46-hx@2.3.1: + /idna-uts46-hx@2.3.1: + resolution: {integrity: sha512-PWoF9Keq6laYdIRwwCdhTPl60xRqAloYNMQLiyUnG42VjT53oW07BXIRM+NK7eQjzXjAk2gUvX9caRxlnF9TAA==} + engines: {node: '>=4.0.0'} dependencies: punycode: 2.1.0 - ieee754@1.2.1: {} + /ieee754@1.2.1: + resolution: {integrity: sha512-dcyqhDvX1C46lXZcVqCpK+FtMRQVdIMN6/Df5js2zouUsqG7I6sFxitIC+7KYK29KdXOLHdu9zL4sFnoVQnqaA==} - ignore@5.3.1: {} + /ignore@5.3.1: + resolution: {integrity: sha512-5Fytz/IraMjqpwfd34ke28PTVMjZjJG2MPn5t7OE4eUCUNf8BAa7b5WUS9/Qvr6mwOQS7Mk6vdsMno5he+T8Xw==} + engines: {node: '>= 4'} - immer@10.0.2: {} + /immer@10.0.2: + resolution: {integrity: sha512-Rx3CqeqQ19sxUtYV9CU911Vhy8/721wRFnJv3REVGWUmoAcIwzifTsdmJte/MV+0/XpM35LZdQMBGkRIoLPwQA==} + dev: true - immutable@4.3.5: {} + /immutable@4.3.5: + resolution: {integrity: sha512-8eabxkth9gZatlwl5TBuJnCsoTADlL6ftEr7A4qgdaTsPyreilDSnUk57SO+jfKcNtxPa22U5KK6DSeAYhpBJw==} + dev: false - import-fresh@3.3.0: + /import-fresh@3.3.0: + resolution: {integrity: sha512-veYYhQa+D1QBKznvhUHxb8faxlrwUnxseDAbAp457E0wLNio2bOSKnjYDhMj+YiAq61xrMGhQk9iXVk5FzgQMw==} + engines: {node: '>=6'} dependencies: parent-module: 1.0.1 resolve-from: 4.0.0 - imurmurhash@0.1.4: {} + /imurmurhash@0.1.4: + resolution: {integrity: sha512-JmXMZ6wuvDmLiHEml9ykzqO6lwFbof0GG4IkcGaENdCRDDmMVnny7s5HsIgHCbaq0w2MyPhDqkhTUgS2LU2PHA==} + engines: {node: '>=0.8.19'} - indent-string@4.0.0: {} + /indent-string@4.0.0: + resolution: {integrity: sha512-EdDDZu4A2OyIK7Lr/2zG+w5jmbuk1DVBnEwREQvBzspBJkCEbRa8GxU1lghYcaGJCnRWibjDXlq779X1/y5xwg==} + engines: {node: '>=8'} - inflight@1.0.6: + /inflight@1.0.6: + resolution: {integrity: sha512-k92I/b08q4wvFscXCLvqfsHCrjrF7yiXsQuIVvVE7N82W3+aqpzuUdBbfhWcy/FZR3/4IgflMgKLOsvPDrGCJA==} dependencies: once: 1.4.0 wrappy: 1.0.2 - inherits@2.0.4: {} + /inherits@2.0.4: + resolution: {integrity: sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ==} - ini@1.3.8: {} + /ini@1.3.8: + resolution: {integrity: sha512-JV/yugV2uzW5iMRSiZAyDtQd+nxtUnjeLt0acNdw98kKLrvuRVyB80tsREOE7yvGVgalhZ6RNXCmEHkUKBKxew==} - internal-slot@1.0.7: + /internal-slot@1.0.7: + resolution: {integrity: sha512-NGnrKwXzSms2qUUih/ILZ5JBqNTSa1+ZmP6flaIp6KmSElgE9qdndzS3cqjrDovwFdmwsGsLdeFgB6suw+1e9g==} + engines: {node: '>= 0.4'} dependencies: es-errors: 1.3.0 hasown: 2.0.2 side-channel: 1.0.6 + dev: true - interpret@1.4.0: {} + /interpret@1.4.0: + resolution: {integrity: sha512-agE4QfB2Lkp9uICn7BAqoscw4SZP9kTE2hxiFI3jBPmXJfdqiahTbUuKGsMoN2GtqL9AxhYioAcVvgsb1HvRbA==} + engines: {node: '>= 0.10'} + dev: true - invariant@2.2.4: + /invariant@2.2.4: + resolution: {integrity: sha512-phJfQVBuaJM5raOpJjSfkiD6BpbCE4Ns//LaXl6wGYtUBY83nWS6Rf9tXm2e8VaK60JEjYldbPif/A2B1C2gNA==} dependencies: loose-envify: 1.4.0 + dev: false - invert-kv@1.0.0: {} + /invert-kv@1.0.0: + resolution: {integrity: sha512-xgs2NH9AE66ucSq4cNG1nhSFghr5l6tdL15Pk+jl46bmmBapgoaY/AacXyaDznAqmGL99TiLSQgO/XazFSKYeQ==} + engines: {node: '>=0.10.0'} + dev: false - io-ts@1.10.4: + /io-ts@1.10.4: + resolution: {integrity: sha512-b23PteSnYXSONJ6JQXRAlvJhuw8KOtkqa87W4wDtvMrud/DTJd5X+NpOOI+O/zZwVq6v0VLAaJ+1EDViKEuN9g==} dependencies: fp-ts: 1.19.3 + dev: false - ipaddr.js@1.9.1: {} + /ipaddr.js@1.9.1: + resolution: {integrity: sha512-0KI/607xoxSToH7GjN1FfSbLoU0+btTicjsQSWQlh/hZykN8KpmMf7uYwPW3R+akZ6R/w18ZlXSHBYXiYUPO3g==} + engines: {node: '>= 0.10'} - is-arguments@1.1.1: + /is-arguments@1.1.1: + resolution: {integrity: sha512-8Q7EARjzEnKpt/PCD7e1cgUS0a6X8u5tdSiMqXhojOdoV9TsMsiO+9VLC5vAmO8N7/GmXn7yjR8qnA6bVAEzfA==} + engines: {node: '>= 0.4'} dependencies: call-bind: 1.0.7 has-tostringtag: 1.0.2 - is-array-buffer@3.0.4: + /is-array-buffer@3.0.4: + resolution: {integrity: sha512-wcjaerHw0ydZwfhiKbXJWLDY8A7yV7KhjQOpb83hGgGfId/aQa4TOvwyzn2PuswW2gPCYEL/nEAiSVpdOj1lXw==} + engines: {node: '>= 0.4'} dependencies: call-bind: 1.0.7 get-intrinsic: 1.2.4 + dev: true - is-arrayish@0.2.1: {} + /is-arrayish@0.2.1: + resolution: {integrity: sha512-zz06S8t0ozoDXMG+ube26zeCTNXcKIPJZJi8hBrF4idCLms4CG9QtK7qBl1boi5ODzFpjswb5JPmHCbMpjaYzg==} - is-bigint@1.0.4: + /is-bigint@1.0.4: + resolution: {integrity: sha512-zB9CruMamjym81i2JZ3UMn54PKGsQzsJeo6xvN3HJJ4CAsQNB6iRutp2To77OfCNuoxspsIhzaPoO1zyCEhFOg==} dependencies: has-bigints: 1.0.2 + dev: true - is-binary-path@2.1.0: + /is-binary-path@2.1.0: + resolution: {integrity: sha512-ZMERYes6pDydyuGidse7OsHxtbI7WVeUEozgR/g7rd0xUimYNlvZRE/K2MgZTjWy725IfelLeVcEM97mmtRGXw==} + engines: {node: '>=8'} dependencies: binary-extensions: 2.3.0 - is-boolean-object@1.1.2: + /is-boolean-object@1.1.2: + resolution: {integrity: sha512-gDYaKHJmnj4aWxyj6YHyXVpdQawtVLHU5cb+eztPGczf6cjuTdwve5ZIEfgXqH4e57An1D1AKf8CZ3kYrQRqYA==} + engines: {node: '>= 0.4'} dependencies: call-bind: 1.0.7 has-tostringtag: 1.0.2 + dev: true - is-builtin-module@3.2.1: + /is-builtin-module@3.2.1: + resolution: {integrity: sha512-BSLE3HnV2syZ0FK0iMA/yUGplUeMmNz4AW5fnTunbCIqZi4vG3WjJT9FHMy5D69xmAYBHXQhJdALdpwVxV501A==} + engines: {node: '>=6'} dependencies: builtin-modules: 3.3.0 + dev: true - is-callable@1.2.7: {} + /is-callable@1.2.7: + resolution: {integrity: sha512-1BC0BVFhS/p0qtw6enp8e+8OD0UrK0oFLztSjNzhcKA3WDuJxxAPXzPuPtKkjEY9UUoEWlX/8fgKeu2S8i9JTA==} + engines: {node: '>= 0.4'} - is-core-module@2.13.1: + /is-core-module@2.13.1: + resolution: {integrity: sha512-hHrIjvZsftOsvKSn2TRYl63zvxsgE0K+0mYMoH6gD4omR5IWB2KynivBQczo3+wF1cCkjzvptnI9Q0sPU66ilw==} dependencies: hasown: 2.0.2 - is-data-view@1.0.1: + /is-data-view@1.0.1: + resolution: {integrity: sha512-AHkaJrsUVW6wq6JS8y3JnM/GJF/9cf+k20+iDzlSaJrinEo5+7vRiteOSwBhHRiAyQATN1AmY4hwzxJKPmYf+w==} + engines: {node: '>= 0.4'} dependencies: is-typed-array: 1.1.13 + dev: true - is-date-object@1.0.5: + /is-date-object@1.0.5: + resolution: {integrity: sha512-9YQaSxsAiSwcvS33MBk3wTCVnWK+HhF8VZR2jRxehM16QcVOdHqPn4VPHmRK4lSr38n9JriurInLcP90xsYNfQ==} + engines: {node: '>= 0.4'} dependencies: has-tostringtag: 1.0.2 + dev: true - is-extglob@2.1.1: {} + /is-extglob@2.1.1: + resolution: {integrity: sha512-SbKbANkN603Vi4jEZv49LeVJMn4yGwsbzZworEoyEiutsN3nJYdbO36zfhGJ6QEDpOZIFkDtnq5JRxmvl3jsoQ==} + engines: {node: '>=0.10.0'} - is-fullwidth-code-point@1.0.0: + /is-fullwidth-code-point@1.0.0: + resolution: {integrity: sha512-1pqUqRjkhPJ9miNq9SwMfdvi6lBJcd6eFxvfaivQhaH3SgisfiuudvFntdKOmxuee/77l+FPjKrQjWvmPjWrRw==} + engines: {node: '>=0.10.0'} dependencies: number-is-nan: 1.0.1 + dev: false - is-fullwidth-code-point@2.0.0: {} + /is-fullwidth-code-point@2.0.0: + resolution: {integrity: sha512-VHskAKYM8RfSFXwee5t5cbN5PZeq1Wrh6qd5bkyiXIf6UQcN6w/A0eXM9r6t8d+GYOh+o6ZhiEnb88LN/Y8m2w==} + engines: {node: '>=4'} + dev: true - is-fullwidth-code-point@3.0.0: {} + /is-fullwidth-code-point@3.0.0: + resolution: {integrity: sha512-zymm5+u+sCsSWyD9qNaejV3DFvhCKclKdizYaJUuHA83RLjb7nSuGnddCHGv0hk+KY7BMAlsWeK4Ueg6EV6XQg==} + engines: {node: '>=8'} - is-function@1.0.2: {} + /is-function@1.0.2: + resolution: {integrity: sha512-lw7DUp0aWXYg+CBCN+JKkcE0Q2RayZnSvnZBlwgxHBQhqt5pZNVy4Ri7H9GmmXkdu7LUthszM+Tor1u/2iBcpQ==} - is-generator-function@1.0.10: + /is-generator-function@1.0.10: + resolution: {integrity: sha512-jsEjy9l3yiXEQ+PsXdmBwEPcOxaXWLspKdplFUVI9vq1iZgIekeC0L167qeu86czQaxed3q/Uzuw0swL0irL8A==} + engines: {node: '>= 0.4'} dependencies: has-tostringtag: 1.0.2 - is-glob@4.0.3: + /is-glob@4.0.3: + resolution: {integrity: sha512-xelSayHH36ZgE7ZWhli7pW34hNbNl8Ojv5KVmkJD4hBdD3th8Tfk9vYasLM+mXWOZhFkgZfxhLSnrwRr4elSSg==} + engines: {node: '>=0.10.0'} dependencies: is-extglob: 2.1.1 - is-hex-prefixed@1.0.0: {} + /is-hex-prefixed@1.0.0: + resolution: {integrity: sha512-WvtOiug1VFrE9v1Cydwm+FnXd3+w9GaeVUss5W4v/SLy3UW00vP+6iNF2SdnfiBoLy4bTqVdkftNGTUeOFVsbA==} + engines: {node: '>=6.5.0', npm: '>=3'} - is-interactive@1.0.0: {} + /is-interactive@1.0.0: + resolution: {integrity: sha512-2HvIEKRoqS62guEC+qBjpvRubdX910WCMuJTZ+I9yvqKU2/12eSL549HMwtabb4oupdj2sMP50k+XJfB/8JE6w==} + engines: {node: '>=8'} + dev: false - is-lower-case@1.1.3: + /is-lower-case@1.1.3: + resolution: {integrity: sha512-+5A1e/WJpLLXZEDlgz4G//WYSHyQBD32qa4Jd3Lw06qQlv3fJHnp3YIHjTQSGzHMgzmVKz2ZP3rBxTHkPw/lxA==} dependencies: lower-case: 1.1.4 + dev: false - is-negative-zero@2.0.3: {} + /is-negative-zero@2.0.3: + resolution: {integrity: sha512-5KoIu2Ngpyek75jXodFvnafB6DJgr3u8uuK0LEZJjrU19DrMD3EVERaR8sjz8CCGgpZvxPl9SuE1GMVPFHx1mw==} + engines: {node: '>= 0.4'} + dev: true - is-number-object@1.0.7: + /is-number-object@1.0.7: + resolution: {integrity: sha512-k1U0IRzLMo7ZlYIfzRu23Oh6MiIFasgpb9X76eqfFZAqwH44UI4KTBvBYIZ1dSL9ZzChTB9ShHfLkR4pdW5krQ==} + engines: {node: '>= 0.4'} dependencies: has-tostringtag: 1.0.2 + dev: true - is-number@7.0.0: {} + /is-number@7.0.0: + resolution: {integrity: sha512-41Cifkg6e8TylSpdtTpeLVMqvSBEVzTttHvERD741+pnZ8ANv0004MRL43QKPDlK9cGvNp6NZWZUBlbGXYxxng==} + engines: {node: '>=0.12.0'} - is-path-inside@3.0.3: {} + /is-path-inside@3.0.3: + resolution: {integrity: sha512-Fd4gABb+ycGAmKou8eMftCupSir5lRxqf4aD/vd0cD2qc4HL07OjCeuHMr8Ro4CoMaeCKDB0/ECBOVWjTwUvPQ==} + engines: {node: '>=8'} - is-plain-obj@1.1.0: {} + /is-plain-obj@1.1.0: + resolution: {integrity: sha512-yvkRyxmFKEOQ4pNXCmJG5AEQNlXJS5LaONXo5/cLdTZdWvsZ1ioJEonLGAosKlMWE8lwUy/bJzMjcw8az73+Fg==} + engines: {node: '>=0.10.0'} + dev: true - is-plain-obj@2.1.0: {} + /is-plain-obj@2.1.0: + resolution: {integrity: sha512-YWnfyRwxL/+SsrWYfOpUtz5b3YD+nyfkHvjbcanzk8zgyO4ASD67uVMRt8k5bM4lLMDnXfriRhOpemw+NfT1eA==} + engines: {node: '>=8'} - is-regex@1.1.4: + /is-regex@1.1.4: + resolution: {integrity: sha512-kvRdxDsxZjhzUX07ZnLydzS1TU/TJlTUHHY4YLL87e37oUA49DfkLqgy+VjFocowy29cKvcSiu+kIv728jTTVg==} + engines: {node: '>= 0.4'} dependencies: call-bind: 1.0.7 has-tostringtag: 1.0.2 + dev: true - is-shared-array-buffer@1.0.3: + /is-shared-array-buffer@1.0.3: + resolution: {integrity: sha512-nA2hv5XIhLR3uVzDDfCIknerhx8XUKnstuOERPNNIinXG7v9u+ohXF67vxm4TPTEPU6lm61ZkwP3c9PCB97rhg==} + engines: {node: '>= 0.4'} dependencies: call-bind: 1.0.7 + dev: true - is-stream@2.0.1: {} + /is-stream@2.0.1: + resolution: {integrity: sha512-hFoiJiTl63nn+kstHGBtewWSKnQLpyb155KHheA1l39uvtO9nWIop1p3udqPcUd/xbF1VLMO4n7OI6p7RbngDg==} + engines: {node: '>=8'} + dev: true - is-string@1.0.7: + /is-string@1.0.7: + resolution: {integrity: sha512-tE2UXzivje6ofPW7l23cjDOMa09gb7xlAqG6jG5ej6uPV32TlWP3NKPigtaGeHNu9fohccRYvIiZMfOOnOYUtg==} + engines: {node: '>= 0.4'} dependencies: has-tostringtag: 1.0.2 + dev: true - is-subdir@1.2.0: + /is-subdir@1.2.0: + resolution: {integrity: sha512-2AT6j+gXe/1ueqbW6fLZJiIw3F8iXGJtt0yDrZaBhAZEG1raiTxKWU+IPqMCzQAXOUCKdA4UDMgacKH25XG2Cw==} + engines: {node: '>=4'} dependencies: better-path-resolve: 1.0.0 + dev: true - is-symbol@1.0.4: + /is-symbol@1.0.4: + resolution: {integrity: sha512-C/CPBqKWnvdcxqIARxyOh4v1UUEOCHpgDa0WYgpKDFMszcrPcffg5uhwSgPCLD2WWxmq6isisz87tzT01tuGhg==} + engines: {node: '>= 0.4'} dependencies: has-symbols: 1.0.3 + dev: true - is-typed-array@1.1.13: + /is-typed-array@1.1.13: + resolution: {integrity: sha512-uZ25/bUAlUY5fR4OKT4rZQEBrzQWYV9ZJYGGsUmEJ6thodVJ1HX64ePQ6Z0qPWP+m+Uq6e9UugrE38jeYsDSMw==} + engines: {node: '>= 0.4'} dependencies: which-typed-array: 1.1.15 - is-typedarray@1.0.0: {} + /is-typedarray@1.0.0: + resolution: {integrity: sha512-cyA56iCMHAh5CdzjJIa4aohJyeO1YbwLi3Jc35MmRU6poroFjIGZzUzupGiRPOjgHg9TLu43xbpwXk523fMxKA==} - is-unicode-supported@0.1.0: {} + /is-unicode-supported@0.1.0: + resolution: {integrity: sha512-knxG2q4UC3u8stRGyAVJCOdxFmv5DZiRcdlIaAQXAbSfJya+OhopNotLQrstBhququ4ZpuKbDc/8S6mgXgPFPw==} + engines: {node: '>=10'} - is-upper-case@1.1.2: + /is-upper-case@1.1.2: + resolution: {integrity: sha512-GQYSJMgfeAmVwh9ixyk888l7OIhNAGKtY6QA+IrWlu9MDTCaXmeozOZ2S9Knj7bQwBO/H6J2kb+pbyTUiMNbsw==} dependencies: upper-case: 1.1.3 + dev: false - is-url@1.2.4: {} + /is-url@1.2.4: + resolution: {integrity: sha512-ITvGim8FhRiYe4IQ5uHSkj7pVaPDrCTkNd3yq3cV7iZAcJdHTUMPMEHcqSOy9xZ9qFenQCvi+2wjH9a1nXqHww==} + dev: true - is-utf8@0.2.1: {} + /is-utf8@0.2.1: + resolution: {integrity: sha512-rMYPYvCzsXywIsldgLaSoPlw5PfoB/ssr7hY4pLfcodrA5M/eArza1a9VmTiNIBNMjOGr1Ow9mTyU2o69U6U9Q==} + dev: false - is-weakref@1.0.2: + /is-weakref@1.0.2: + resolution: {integrity: sha512-qctsuLZmIQ0+vSSMfoVvyFe2+GSEvnmZ2ezTup1SBse9+twCCeial6EEi3Nc2KFcf6+qz2FBPnjXsk8xhKSaPQ==} dependencies: call-bind: 1.0.7 + dev: true - is-windows@1.0.2: {} + /is-windows@1.0.2: + resolution: {integrity: sha512-eXK1UInq2bPmjyX6e3VHIzMLobc4J94i4AWn+Hpq3OU5KkrRC96OAcR3PRJ/pGu6m8TRnBHP9dkXQVsT/COVIA==} + engines: {node: '>=0.10.0'} + dev: true - isarray@0.0.1: {} + /isarray@0.0.1: + resolution: {integrity: sha512-D2S+3GLxWH+uhrNEcoh/fnmYeP8E8/zHl644d/jdA0g2uyXvy3sb0qxotE+ne0LtccHknQzWwZEzhak7oJ0COQ==} + dev: true - isarray@1.0.0: {} + /isarray@1.0.0: + resolution: {integrity: sha512-VLghIWNM6ELQzo7zwmcg0NmTVyWKYjvIeM83yjp0wRDTmUnrM678fQbcKBo6n2CJEF0szoG//ytg+TKla89ALQ==} + dev: true - isarray@2.0.5: {} + /isarray@2.0.5: + resolution: {integrity: sha512-xHjhDr3cNBK0BzdUJSPXZntQUx/mwMS5Rw4A7lPJ90XGAO6ISP/ePDNuo0vhqOZU+UD5JoodwCAAoZQd3FeAKw==} + dev: true - isexe@2.0.0: {} + /isexe@2.0.0: + resolution: {integrity: sha512-RHxMLp9lnKHGHRng9QFhRCMbYAcVpn69smSGcq3f36xjgVVWThj4qqLbTLlq7Ssj8B+fIQ1EuCEGI2lKsyQeIw==} - isomorphic-fetch@3.0.0: + /isomorphic-fetch@3.0.0: + resolution: {integrity: sha512-qvUtwJ3j6qwsF3jLxkZ72qCgjMysPzDfeV240JHiGZsANBYd+EEuu35v7dfrJ9Up0Ak07D7GGSkGhCHTqg/5wA==} dependencies: node-fetch: 2.7.0 whatwg-fetch: 3.6.20 transitivePeerDependencies: - encoding + dev: true - isomorphic-ws@5.0.0(ws@8.17.0(bufferutil@4.0.8)(utf-8-validate@5.0.10)): + /isomorphic-ws@5.0.0(ws@8.17.0): + resolution: {integrity: sha512-muId7Zzn9ywDsyXgTIafTry2sV3nySZeUDe6YedVd1Hvuuep5AsIlqK+XefWpYTyJG5e503F2xIuT2lcU6rCSw==} + peerDependencies: + ws: '*' dependencies: - ws: 8.17.0(bufferutil@4.0.8)(utf-8-validate@5.0.10) + ws: 8.17.0 + dev: true - isows@1.0.3(ws@8.13.0(bufferutil@4.0.8)(utf-8-validate@5.0.10)): + /isows@1.0.3(ws@8.13.0): + resolution: {integrity: sha512-2cKei4vlmg2cxEjm3wVSqn8pcoRF/LX/wpifuuNquFO4SQmPwarClT+SUCA2lt+l581tTeZIPIZuIDo2jWN1fg==} + peerDependencies: + ws: '*' dependencies: - ws: 8.13.0(bufferutil@4.0.8)(utf-8-validate@5.0.10) + ws: 8.13.0 + dev: true - isstream@0.1.2: {} + /isstream@0.1.2: + resolution: {integrity: sha512-Yljz7ffyPbrLpLngrMtZ7NduUgVvi6wG9RJ9IUcyCd59YQ911PBJphODUcbOVbqYfxe1wuYf/LJ8PauMRwsM/g==} - istanbul-lib-coverage@3.2.2: {} + /istanbul-lib-coverage@3.2.2: + resolution: {integrity: sha512-O8dpsF+r0WV/8MNRKfnmrtCWhuKjxrq2w+jpzBL5UZKTi2LeVWnWOmWRxFlesJONmc+wLAGvKQZEOanko0LFTg==} + engines: {node: '>=8'} + dev: true - istanbul-lib-hook@3.0.0: + /istanbul-lib-hook@3.0.0: + resolution: {integrity: sha512-Pt/uge1Q9s+5VAZ+pCo16TYMWPBIl+oaNIjgLQxcX0itS6ueeaA+pEfThZpH8WxhFgCiEb8sAJY6MdUKgiIWaQ==} + engines: {node: '>=8'} dependencies: append-transform: 2.0.0 + dev: true - istanbul-lib-instrument@4.0.3: + /istanbul-lib-instrument@4.0.3: + resolution: {integrity: sha512-BXgQl9kf4WTCPCCpmFGoJkz/+uhvm7h7PFKUYxh7qarQd3ER33vHG//qaE8eN25l07YqZPpHXU9I09l/RD5aGQ==} + engines: {node: '>=8'} dependencies: '@babel/core': 7.24.5 '@istanbuljs/schema': 0.1.3 @@ -11329,8 +7812,11 @@ snapshots: semver: 6.3.1 transitivePeerDependencies: - supports-color + dev: true - istanbul-lib-processinfo@2.0.3: + /istanbul-lib-processinfo@2.0.3: + resolution: {integrity: sha512-NkwHbo3E00oybX6NGJi6ar0B29vxyvNwoC7eJ4G4Yq28UfY758Hgn/heV8VRFhevPED4LXfFz0DQ8z/0kw9zMg==} + engines: {node: '>=8'} dependencies: archy: 1.0.0 cross-spawn: 7.0.3 @@ -11338,264 +7824,437 @@ snapshots: p-map: 3.0.0 rimraf: 3.0.2 uuid: 8.3.2 + dev: true - istanbul-lib-report@3.0.1: + /istanbul-lib-report@3.0.1: + resolution: {integrity: sha512-GCfE1mtsHGOELCU8e/Z7YWzpmybrx/+dSTfLrvY8qRmaY6zXTKWn6WQIjaAFw069icm6GVMNkgu0NzI4iPZUNw==} + engines: {node: '>=10'} dependencies: istanbul-lib-coverage: 3.2.2 make-dir: 4.0.0 supports-color: 7.2.0 + dev: true - istanbul-lib-source-maps@4.0.1: + /istanbul-lib-source-maps@4.0.1: + resolution: {integrity: sha512-n3s8EwkdFIJCG3BPKBYvskgXGoy88ARzvegkitk60NxRdwltLOTaH7CUiMRXvwYorl0Q712iEjcWB+fK/MrWVw==} + engines: {node: '>=10'} dependencies: debug: 4.3.4(supports-color@8.1.1) istanbul-lib-coverage: 3.2.2 source-map: 0.6.1 transitivePeerDependencies: - supports-color + dev: true - istanbul-reports@3.1.7: + /istanbul-reports@3.1.7: + resolution: {integrity: sha512-BewmUXImeuRk2YY0PVbxgKAysvhRPUQE0h5QRM++nVWyubKGV0l8qQ5op8+B2DOmwSe63Jivj0BjkPQVf8fP5g==} + engines: {node: '>=8'} dependencies: html-escaper: 2.0.2 istanbul-lib-report: 3.0.1 + dev: true - jest-diff@29.7.0: + /jest-diff@29.7.0: + resolution: {integrity: sha512-LMIgiIrhigmPrs03JHpxUh2yISK3vLFPkAodPeo0+BuF7wA2FoQbkEg1u8gBYBThncu7e1oEDUfIXVuTqLRUjw==} + engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0} dependencies: chalk: 4.1.2 diff-sequences: 29.6.3 jest-get-type: 29.6.3 pretty-format: 29.7.0 + dev: true - jest-get-type@29.6.3: {} + /jest-get-type@29.6.3: + resolution: {integrity: sha512-zrteXnqYxfQh7l5FHyL38jL39di8H8rHoecLH3JNxH3BwOrBsNeabdap5e0I23lD4HHI8W5VFBZqG4Eaq5LNcw==} + engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0} + dev: true - js-sha3@0.5.5: {} + /js-sha3@0.5.5: + resolution: {integrity: sha512-yLLwn44IVeunwjpDVTDZmQeVbB0h+dZpY2eO68B/Zik8hu6dH+rKeLxwua79GGIvW6xr8NBAcrtiUbYrTjEFTA==} + dev: false - js-sha3@0.5.7: {} + /js-sha3@0.5.7: + resolution: {integrity: sha512-GII20kjaPX0zJ8wzkTbNDYMY7msuZcTWk8S5UOh6806Jq/wz1J8/bnr8uGU0DAUmYDjj2Mr4X1cW8v/GLYnR+g==} - js-sha3@0.8.0: {} + /js-sha3@0.8.0: + resolution: {integrity: sha512-gF1cRrHhIzNfToc802P800N8PpXS+evLLXfsVpowqmAFR9uwbi89WvXg2QspOmXL8QL86J4T1EpFu+yUkwJY3Q==} - js-tokens@4.0.0: {} + /js-tokens@4.0.0: + resolution: {integrity: sha512-RdJUflcE3cUzKiMqQgsCu06FPu9UdIJO0beYbPhHN4k6apgJtifcoCtT9bcxOpYBtpD2kCM6Sbzg4CausW/PKQ==} - js-yaml@3.14.1: + /js-yaml@3.14.1: + resolution: {integrity: sha512-okMH7OXXJ7YrN9Ok3/SXrnu4iX9yOk+25nqX4imS2npuvTYDmo/QEZoqwZkYaIDk3jVvBOTOIEgEhaLOynBS9g==} + hasBin: true dependencies: argparse: 1.0.10 esprima: 4.0.1 + dev: true - js-yaml@4.1.0: + /js-yaml@4.1.0: + resolution: {integrity: sha512-wpxZs9NoxZaJESJGIZTyDEaYpl0FKSA+FB9aJiyemKhMwkxQg63h4T1KJgUGHpTqPDNRcmmYLugrRjJlBtWvRA==} + hasBin: true dependencies: argparse: 2.0.1 - jsbn@0.1.1: {} + /jsbn@0.1.1: + resolution: {integrity: sha512-UVU9dibq2JcFWxQPA6KCqj5O42VOmAY3zQUfEKxU0KpTGXwNoCjkX1e13eHNvw/xPynt6pU0rZ1htjWTNTSXsg==} - jsesc@2.5.2: {} + /jsesc@2.5.2: + resolution: {integrity: sha512-OYu7XEzjkCQ3C5Ps3QIZsQfNpqoJyZZA99wd9aWd05NCtC5pWOkShK2mkL6HXQR6/Cy2lbNdPlZBpuQHXE63gA==} + engines: {node: '>=4'} + hasBin: true + dev: true - json-buffer@3.0.1: {} + /json-buffer@3.0.1: + resolution: {integrity: sha512-4bV5BfR2mqfQTJm+V5tPPdf+ZpuhiIvTuAB5g8kcrXOZpTT/QwwVRWBywX1ozr6lEuPdbHxwaJlm9G6mI2sfSQ==} - json-parse-even-better-errors@2.3.1: {} + /json-parse-even-better-errors@2.3.1: + resolution: {integrity: sha512-xyFwyhro/JEof6Ghe2iz2NcXoj2sloNsWr/XsERDK/oiPCfaNhl5ONfp+jQdAZRQQ0IJWNzH9zIZF7li91kh2w==} - json-schema-traverse@0.3.1: {} + /json-schema-traverse@0.3.1: + resolution: {integrity: sha512-4JD/Ivzg7PoW8NzdrBSr3UFwC9mHgvI7Z6z3QGBsSHgKaRTUDmyZAAKJo2UbG1kUVfS9WS8bi36N49U1xw43DA==} + dev: false - json-schema-traverse@0.4.1: {} + /json-schema-traverse@0.4.1: + resolution: {integrity: sha512-xbbCH5dCYU5T8LcEhhuh7HJ88HXuW3qsI3Y0zOZFKfZEHcpWiHU/Jxzk629Brsab/mMiHQti9wMP+845RPe3Vg==} - json-schema-traverse@1.0.0: {} + /json-schema-traverse@1.0.0: + resolution: {integrity: sha512-NM8/P9n3XjXhIZn1lLhkFaACTOURQXjWhV4BA/RnOv8xvgqtqpAX9IO4mRQxSx1Rlo4tqzeqb0sOlruaOy3dug==} - json-schema@0.4.0: {} + /json-schema@0.4.0: + resolution: {integrity: sha512-es94M3nTIfsEPisRafak+HDLfHXnKBhV3vU5eqPcS3flIWqcxJWgXHXiey3YrpaNsanY5ei1VoYEbOzijuq9BA==} - json-stable-stringify-without-jsonify@1.0.1: {} + /json-stable-stringify-without-jsonify@1.0.1: + resolution: {integrity: sha512-Bdboy+l7tA3OGW6FjyFHWkP5LuByj1Tk33Ljyq0axyzdk9//JSi2u3fP1QSmd1KNwq6VOKYGlAu87CisVir6Pw==} - json-stringify-safe@5.0.1: {} + /json-stringify-safe@5.0.1: + resolution: {integrity: sha512-ZClg6AaYvamvYEE82d3Iyd3vSSIjQ+odgjaTzRuO3s7toCdFKczob2i0zCh7JE8kWn17yvAWhUVxvqGwUalsRA==} - json5@1.0.2: + /json5@1.0.2: + resolution: {integrity: sha512-g1MWMLBiz8FKi1e4w0UyVL3w+iJceWAFBAaBnnGKOpNa5f8TLktkbre1+s6oICydWAm+HRUGTmI+//xv2hvXYA==} + hasBin: true dependencies: minimist: 1.2.8 + dev: true - json5@2.2.3: {} + /json5@2.2.3: + resolution: {integrity: sha512-XmOWe7eyHYH14cLdVPoyg+GOH3rYX++KpzrylJwSW98t3Nk+U8XOl8FWKOgwtzdb8lXGf6zYwDUzeHMWfxasyg==} + engines: {node: '>=6'} + hasBin: true + dev: true - jsonfile@2.4.0: + /jsonfile@2.4.0: + resolution: {integrity: sha512-PKllAqbgLgxHaj8TElYymKCAgrASebJrWpTnEkOaTowt23VKXXN0sUeriJ+eh7y6ufb/CC5ap11pz71/cM0hUw==} optionalDependencies: graceful-fs: 4.2.11 + dev: false - jsonfile@4.0.0: + /jsonfile@4.0.0: + resolution: {integrity: sha512-m6F1R3z8jjlf2imQHS2Qez5sjKWQzbuuhuJ/FKYFRZvPE3PuHcSMVZzfsLhGVOkfd20obL5SWEBew5ShlquNxg==} optionalDependencies: graceful-fs: 4.2.11 - jsonfile@6.1.0: + /jsonfile@6.1.0: + resolution: {integrity: sha512-5dgndWOriYSm5cnYaJNhalLNDKOqFwyDB/rr1E9ZsGciGvKPs8R2xYGCacuf3z6K1YKDz182fd+fY3cn3pMqXQ==} dependencies: universalify: 2.0.1 optionalDependencies: graceful-fs: 4.2.11 + dev: true - jsonschema@1.4.1: {} + /jsonschema@1.4.1: + resolution: {integrity: sha512-S6cATIPVv1z0IlxdN+zUk5EPjkGCdnhN4wVSBlvoUO1tOLJootbo9CquNJmbIh4yikWHiUedhRYrNPn1arpEmQ==} + dev: true - jsprim@1.4.2: + /jsprim@1.4.2: + resolution: {integrity: sha512-P2bSOMAc/ciLz6DzgjVlGJP9+BrJWu5UDGK70C2iweC5QBIeFf0ZXRvGjEj2uYgrY2MkAAhsSWHDWlFtEroZWw==} + engines: {node: '>=0.6.0'} dependencies: assert-plus: 1.0.0 extsprintf: 1.3.0 json-schema: 0.4.0 verror: 1.10.0 - just-extend@4.2.1: {} + /just-extend@4.2.1: + resolution: {integrity: sha512-g3UB796vUFIY90VIv/WX3L2c8CS2MdWUww3CNrYmqza1Fg0DURc2K/O4YrnklBdQarSJ/y8JnJYDGc+1iumQjg==} + dev: true - keccak@3.0.4: + /keccak@3.0.4: + resolution: {integrity: sha512-3vKuW0jV8J3XNTzvfyicFR5qvxrSAGl7KIhvgOu5cmWwM7tZRj3fMbj/pfIf4be7aznbc+prBWGjywox/g2Y6Q==} + engines: {node: '>=10.0.0'} + requiresBuild: true dependencies: node-addon-api: 2.0.2 node-gyp-build: 4.8.1 readable-stream: 3.6.2 - keyv@4.5.4: + /keyv@4.5.4: + resolution: {integrity: sha512-oxVHkHR/EJf2CNXnWxRLW6mg7JyCCUcG0DtEGmL2ctUo1PNTin1PUil+r/+4r5MpVgC/fn1kjsx7mjSujKqIpw==} dependencies: json-buffer: 3.0.1 - kind-of@6.0.3: {} + /kind-of@6.0.3: + resolution: {integrity: sha512-dcS1ul+9tmeD95T+x28/ehLgd9mENa3LsvDTtzm3vyBEO7RPptvAD+t44WVXaUjTBRcrpFeFlC8WCruUR456hw==} + engines: {node: '>=0.10.0'} + dev: true - klaw@1.3.1: + /klaw@1.3.1: + resolution: {integrity: sha512-TED5xi9gGQjGpNnvRWknrwAB1eL5GciPfVFOt3Vk1OJCVDQbzuSfrF3hkUQKlsgKrG1F+0t5W0m+Fje1jIt8rw==} optionalDependencies: graceful-fs: 4.2.11 + dev: false - kleur@3.0.3: {} + /kleur@3.0.3: + resolution: {integrity: sha512-eTIzlVOSUR+JxdDFepEYcBMtZ9Qqdef+rnzWdRZuMbOywu5tO2w2N7rqjoANZ5k9vywhL6Br1VRjUIgTQx4E8w==} + engines: {node: '>=6'} + dev: true - kleur@4.1.5: {} + /kleur@4.1.5: + resolution: {integrity: sha512-o+NO+8WrRiQEE4/7nwRJhN1HWpVmJm511pBHUxPLtp0BUISzlBplORYSmTclCnJvQq2tKu/sgl3xVpkc7ZWuQQ==} + engines: {node: '>=6'} + dev: true - lcid@1.0.0: + /lcid@1.0.0: + resolution: {integrity: sha512-YiGkH6EnGrDGqLMITnGjXtGmNtjoXw9SVUzcaos8RBi7Ps0VBylkq+vOcY9QE5poLasPCR849ucFUkl0UzUyOw==} + engines: {node: '>=0.10.0'} dependencies: invert-kv: 1.0.0 + dev: false - levn@0.3.0: + /levn@0.3.0: + resolution: {integrity: sha512-0OO4y2iOHix2W6ujICbKIaEQXvFQHue65vUG3pb5EUomzPI90z9hsA1VsO/dbIIpC53J8gxM9Q4Oho0jrCM/yA==} + engines: {node: '>= 0.8.0'} dependencies: prelude-ls: 1.1.2 type-check: 0.3.2 + dev: true - levn@0.4.1: + /levn@0.4.1: + resolution: {integrity: sha512-+bT2uH4E5LGE7h/n3evcS/sQlJXCpIp6ym8OWJ5eV6+67Dsql/LaaT7qJBAt2rzfoa/5QBGBhxDix1dMt2kQKQ==} + engines: {node: '>= 0.8.0'} dependencies: prelude-ls: 1.2.1 type-check: 0.4.0 - lines-and-columns@1.2.4: {} + /lines-and-columns@1.2.4: + resolution: {integrity: sha512-7ylylesZQ/PV29jhEDl3Ufjo6ZX7gCqJr5F7PKrqc93v7fzSymt1BpwEU8nAUXs8qzzvqhbjhK5QZg6Mt/HkBg==} - load-json-file@1.1.0: + /load-json-file@1.1.0: + resolution: {integrity: sha512-cy7ZdNRXdablkXYNI049pthVeXFurRyb9+hA/dZzerZ0pGTx42z+y+ssxBaVV2l70t1muq5IdKhn4UtcoGUY9A==} + engines: {node: '>=0.10.0'} dependencies: graceful-fs: 4.2.11 parse-json: 2.2.0 pify: 2.3.0 pinkie-promise: 2.0.1 strip-bom: 2.0.0 + dev: false - load-yaml-file@0.2.0: + /load-yaml-file@0.2.0: + resolution: {integrity: sha512-OfCBkGEw4nN6JLtgRidPX6QxjBQGQf72q3si2uvqyFEMbycSFFHwAZeXx6cJgFM9wmLrf9zBwCP3Ivqa+LLZPw==} + engines: {node: '>=6'} dependencies: graceful-fs: 4.2.11 js-yaml: 3.14.1 pify: 4.0.1 strip-bom: 3.0.0 + dev: true - locate-path@2.0.0: + /locate-path@2.0.0: + resolution: {integrity: sha512-NCI2kiDkyR7VeEKm27Kda/iQHyKJe1Bu0FlTbYp3CqJu+9IFe9bLyAjMxf5ZDDbEg+iMPzB5zYyUTSm8wVTKmA==} + engines: {node: '>=4'} dependencies: p-locate: 2.0.0 path-exists: 3.0.0 + dev: false - locate-path@5.0.0: + /locate-path@5.0.0: + resolution: {integrity: sha512-t7hw9pI+WvuwNJXwk5zVHpyhIqzg2qTlklJOf0mVxGSbe3Fp2VieZcduNYjaLDoy6p9uGpQEGWG87WpMKlNq8g==} + engines: {node: '>=8'} dependencies: p-locate: 4.1.0 + dev: true - locate-path@6.0.0: + /locate-path@6.0.0: + resolution: {integrity: sha512-iPZK6eYjbxRu3uB4/WZ3EsEIMJFMqAoopl3R+zuq0UjcAm/MO6KCweDgPfP3elTztoKP3KtnVHxTn2NHBSDVUw==} + engines: {node: '>=10'} dependencies: p-locate: 5.0.0 - lodash.assign@4.2.0: {} + /lodash.assign@4.2.0: + resolution: {integrity: sha512-hFuH8TY+Yji7Eja3mGiuAxBqLagejScbG8GbG0j6o9vzn0YL14My+ktnqtZgFTosKymC9/44wP6s7xyuLfnClw==} + dev: false - lodash.camelcase@4.3.0: {} + /lodash.camelcase@4.3.0: + resolution: {integrity: sha512-TwuEnCnxbc3rAvhf/LbG7tJUDzhqXyFnv3dtzLOPgCG/hODL7WFnsbwktkD7yUV0RrreP/l1PALq/YSg6VvjlA==} + dev: true - lodash.clonedeep@4.5.0: {} + /lodash.clonedeep@4.5.0: + resolution: {integrity: sha512-H5ZhCF25riFd9uB5UCkVKo61m3S/xZk1x4wA6yp/L3RFP6Z/eHH1ymQcGLo7J3GMPfm0V/7m1tryHuGVxpqEBQ==} + dev: false - lodash.deburr@4.1.0: {} + /lodash.deburr@4.1.0: + resolution: {integrity: sha512-m/M1U1f3ddMCs6Hq2tAsYThTBDaAKFDX3dwDo97GEYzamXi9SqUpjWi/Rrj/gf3X2n8ktwgZrlP1z6E3v/IExQ==} + dev: true - lodash.flattendeep@4.4.0: {} + /lodash.flattendeep@4.4.0: + resolution: {integrity: sha512-uHaJFihxmJcEX3kT4I23ABqKKalJ/zDrDg0lsFtc1h+3uw49SIJ5beyhx5ExVRti3AvKoOJngIj7xz3oylPdWQ==} + dev: true - lodash.get@4.4.2: {} + /lodash.get@4.4.2: + resolution: {integrity: sha512-z+Uw/vLuy6gQe8cfaFWD7p0wVv8fJl3mbzXh33RS+0oW2wvUqiRXiQ69gLWSLpgB5/6sU+r6BlQR0MBILadqTQ==} + dev: true - lodash.isequal@4.5.0: {} + /lodash.isequal@4.5.0: + resolution: {integrity: sha512-pDo3lu8Jhfjqls6GkMgpahsF9kCyayhgykjyLMNFTKWrpVdAQtYyB4muAMWozBB4ig/dtWAmsMxLEI8wuz+DYQ==} + dev: false - lodash.memoize@4.1.2: {} + /lodash.memoize@4.1.2: + resolution: {integrity: sha512-t7j+NzmgnQzTAYXcsHYLgimltOV1MXHtlOWf6GjL9Kj8GK5FInw5JotxvbOs+IvV1/Dzo04/fCGfLVs7aXb4Ag==} + dev: false - lodash.merge@4.6.2: {} + /lodash.merge@4.6.2: + resolution: {integrity: sha512-0KpjqXRVvrYyCsX1swR/XTK0va6VQkQM6MNo7PqW77ByjAhoARA8EfrP1N4+KlKj8YS0ZUCtRT/YUuhyYDujIQ==} - lodash.snakecase@4.1.1: {} + /lodash.snakecase@4.1.1: + resolution: {integrity: sha512-QZ1d4xoBHYUeuouhEq3lk3Uq7ldgyFXGBhg04+oRLnIz8o9T65Eh+8YdroUwn846zchkA9yDsDl5CVVaV2nqYw==} + dev: true - lodash.startcase@4.4.0: {} + /lodash.startcase@4.4.0: + resolution: {integrity: sha512-+WKqsK294HMSc2jEbNgpHpd0JfIBhp7rEV4aqXWqFr6AlXov+SlcgB1Fv01y2kGe3Gc8nMW7VA0SrGuSkRfIEg==} + dev: true - lodash.trim@4.5.1: {} + /lodash.trim@4.5.1: + resolution: {integrity: sha512-nJAlRl/K+eiOehWKDzoBVrSMhK0K3A3YQsUNXHQa5yIrKBAhsZgSu3KoAFoFT+mEgiyBHddZ0pRk1ITpIp90Wg==} + dev: true - lodash.truncate@4.4.2: {} + /lodash.truncate@4.4.2: + resolution: {integrity: sha512-jttmRe7bRse52OsWIMDLaXxWqRAmtIUccAQ3garviCqJjafXOfNMO0yMfNpdD6zbGaTU0P5Nz7e7gAT6cKmJRw==} + dev: false - lodash@4.17.21: {} + /lodash@4.17.21: + resolution: {integrity: sha512-v2kDEe57lecTulaDIuNTPy3Ry4gLGJ6Z1O3vE1krgXZNrsQ+LFTGHVxVjcXPs17LhbZVGedAJv8XZ1tvj5FvSg==} - log-symbols@4.1.0: + /log-symbols@4.1.0: + resolution: {integrity: sha512-8XPvpAA8uyhfteu8pIvQxpJZ7SYYdpUivZpGy6sFsBuKRY/7rQGavedeB8aK+Zkyq6upMFVL/9AW6vOYzfRyLg==} + engines: {node: '>=10'} dependencies: chalk: 4.1.2 is-unicode-supported: 0.1.0 - loose-envify@1.4.0: + /loose-envify@1.4.0: + resolution: {integrity: sha512-lyuxPGr/Wfhrlem2CL/UcnUc1zcqKAImBDzukY7Y5F/yQiNdko6+fRLevlw1HgMySw7f611UIY408EtxRSoK3Q==} + hasBin: true dependencies: js-tokens: 4.0.0 + dev: false - loupe@2.3.7: + /loupe@2.3.7: + resolution: {integrity: sha512-zSMINGVYkdpYSOBmLi0D1Uo7JU9nVdQKrHxC8eYlV+9YKK9WePqAlL7lSlorG/U2Fw1w0hTBmaa/jrQ3UbPHtA==} dependencies: get-func-name: 2.0.2 - lower-case-first@1.0.2: + /lower-case-first@1.0.2: + resolution: {integrity: sha512-UuxaYakO7XeONbKrZf5FEgkantPf5DUqDayzP5VXZrtRPdH86s4kN47I8B3TW10S4QKiE3ziHNf3kRN//okHjA==} dependencies: lower-case: 1.1.4 + dev: false - lower-case@1.1.4: {} + /lower-case@1.1.4: + resolution: {integrity: sha512-2Fgx1Ycm599x+WGpIYwJOvsjmXFzTSc34IwDWALRA/8AopUKAVPwfJ+h5+f85BCp0PWmmJcWzEpxOpoXycMpdA==} + dev: false - lower-case@2.0.2: + /lower-case@2.0.2: + resolution: {integrity: sha512-7fm3l3NAF9WfN6W3JOmf5drwpVqX78JtoGJ3A6W0a6ZnldM41w2fV5D490psKFTpMds8TJse/eHLFFsNHHjHgg==} dependencies: tslib: 2.6.2 + dev: true - lowercase-keys@2.0.0: {} + /lowercase-keys@2.0.0: + resolution: {integrity: sha512-tqNXrS78oMOE73NMxK4EMLQsQowWf8jKooH9g7xPavRT706R6bkQJ6DY2Te7QukaZsulxa30wQ7bk0pm4XiHmA==} + engines: {node: '>=8'} - lowercase-keys@3.0.0: {} + /lowercase-keys@3.0.0: + resolution: {integrity: sha512-ozCC6gdQ+glXOQsveKD0YsDy8DSQFjDTz4zyzEHNV5+JP5D62LmfDZ6o1cycFx9ouG940M5dE8C8CTewdj2YWQ==} + engines: {node: ^12.20.0 || ^14.13.1 || >=16.0.0} - lru-cache@10.2.2: {} + /lru-cache@10.2.2: + resolution: {integrity: sha512-9hp3Vp2/hFQUiIwKo8XCeFVnrg8Pk3TYNPIR7tJADKi5YfcF7vEaK7avFHTlSy3kOKYaJQaalfEo6YuXdceBOQ==} + engines: {node: 14 || >=16.14} + dev: true - lru-cache@4.1.5: + /lru-cache@4.1.5: + resolution: {integrity: sha512-sWZlbEP2OsHNkXrMl5GYk/jKk70MBng6UU4YI/qGDYbgf6YbP4EvmqISbXCoJiRKs+1bSpFHVgQxvJ17F2li5g==} dependencies: pseudomap: 1.0.2 yallist: 2.1.2 + dev: true - lru-cache@5.1.1: + /lru-cache@5.1.1: + resolution: {integrity: sha512-KpNARQA3Iwv+jTA0utUVVbrh+Jlrr1Fv0e56GGzAFOXN7dk/FviaDW8LHmK52DlcH4WP2n6gI8vN1aesBFgo9w==} dependencies: yallist: 3.1.1 + dev: true - lru_map@0.3.3: {} + /lru_map@0.3.3: + resolution: {integrity: sha512-Pn9cox5CsMYngeDbmChANltQl+5pi6XmTrraMSzhPmMBbmgcxmqWry0U3PGapCU1yB4/LqCcom7qhHZiF/jGfQ==} + dev: false - make-dir@3.1.0: + /make-dir@3.1.0: + resolution: {integrity: sha512-g3FeP20LNwhALb/6Cz6Dd4F2ngze0jz7tbzrD2wAV+o9FeNHe4rL+yK2md0J/fiSf1sa1ADhXqi5+oVwOM/eGw==} + engines: {node: '>=8'} dependencies: semver: 6.3.1 + dev: true - make-dir@4.0.0: + /make-dir@4.0.0: + resolution: {integrity: sha512-hXdUTZYIVOt1Ex//jAQi+wTZZpUpwBj/0QsOzqegb3rGMMeJiSEu5xLHnYfBrRV4RH2+OCSOO95Is/7x1WJ4bw==} + engines: {node: '>=10'} dependencies: semver: 7.6.2 + dev: true - make-error@1.3.6: {} + /make-error@1.3.6: + resolution: {integrity: sha512-s8UhlNe7vPKomQhC1qFelMokr/Sc3AgNbso3n74mVPA5LTZwkB9NlXf4XPamLxJE8h0gh73rM94xvwRT2CVInw==} + dev: true - map-obj@1.0.1: {} + /map-obj@1.0.1: + resolution: {integrity: sha512-7N/q3lyZ+LVCp7PzuxrJr4KMbBE2hW7BT7YNia330OFxIf4d3r5zVpicP2650l7CPN6RM9zOJRl3NGpqSiw3Eg==} + engines: {node: '>=0.10.0'} + dev: true - map-obj@4.3.0: {} + /map-obj@4.3.0: + resolution: {integrity: sha512-hdN1wVrZbb29eBGiGjJbeP8JbKjq1urkHJ/LIP/NY48MZ1QVXUsQBV1G1zvYFHn1XE06cwjBsOI2K3Ulnj1YXQ==} + engines: {node: '>=8'} + dev: true - markdown-table@1.1.3: {} + /markdown-table@1.1.3: + resolution: {integrity: sha512-1RUZVgQlpJSPWYbFSpmudq5nHY1doEIv89gBtF0s4gW1GF2XorxcA/70M5vq7rLv0a6mhOUccRsqkwhwLCIQ2Q==} + dev: true - markdown-table@3.0.3: {} + /markdown-table@3.0.3: + resolution: {integrity: sha512-Z1NL3Tb1M9wH4XESsCDEksWoKTdlUafKc4pt0GRwjUyXaCFZ+dc3g2erqB6zm3szA2IUSi7VnPI+o/9jnxh9hw==} + dev: true - md5.js@1.3.5: + /md5.js@1.3.5: + resolution: {integrity: sha512-xitP+WxNPcTTOgnTJcrhM0xvdPepipPSf3I8EIpGKeFLjt3PlJLIDG3u8EX53ZIubkb+5U2+3rELYpEhHhzdkg==} dependencies: hash-base: 3.1.0 inherits: 2.0.4 safe-buffer: 5.2.1 - media-typer@0.3.0: {} + /media-typer@0.3.0: + resolution: {integrity: sha512-dq+qelQ9akHpcOl/gUVRTxVIOkAJ1wR3QAvb4RsVjS8oVoFjDGTc679wJYmUmknUF5HwMLOgb5O+a3KxfWapPQ==} + engines: {node: '>= 0.6'} - memorystream@0.3.1: {} + /memorystream@0.3.1: + resolution: {integrity: sha512-S3UwM3yj5mtUSEfP41UZmt/0SCoVYUcU1rkXv+BQ5Ig8ndL4sPoJNBUJERafdPb5jjHJGuMgytgKvKIf58XNBw==} + engines: {node: '>= 0.10.0'} + dev: false - meow@6.1.1: + /meow@6.1.1: + resolution: {integrity: sha512-3YffViIt2QWgTy6Pale5QpopX/IvU3LPL03jOTqp6pGj3VjesdO/U8CuHMKpnQr4shCNCM5fd5XFFvIIl6JBHg==} + engines: {node: '>=8'} dependencies: '@types/minimist': 1.2.5 camelcase-keys: 6.2.2 @@ -11608,90 +8267,149 @@ snapshots: trim-newlines: 3.0.1 type-fest: 0.13.1 yargs-parser: 18.1.3 + dev: true - merge-descriptors@1.0.1: {} + /merge-descriptors@1.0.1: + resolution: {integrity: sha512-cCi6g3/Zr1iqQi6ySbseM1Xvooa98N0w31jzUYrXPX2xqObmFGHJ0tQ5u74H3mVh7wLouTseZyYIq39g8cNp1w==} - merge2@1.4.1: {} + /merge2@1.4.1: + resolution: {integrity: sha512-8q7VEgMJW4J8tcfVPy8g09NcQwZdbwFEqhe/WZkoIzjn/3TGDwtOCYtXGxA3O8tPzpczCCDgv+P2P5y00ZJOOg==} + engines: {node: '>= 8'} - methods@1.1.2: {} + /methods@1.1.2: + resolution: {integrity: sha512-iclAHeNqNm68zFtnZ0e+1L2yUIdvzNoauKU4WBA3VvH/vPFieF7qfRlwUZU+DA9P9bPXIS90ulxoUoCH23sV2w==} + engines: {node: '>= 0.6'} - micro-ftch@0.3.1: {} + /micro-ftch@0.3.1: + resolution: {integrity: sha512-/0LLxhzP0tfiR5hcQebtudP56gUurs2CLkGarnCiB/OqEyUFQ6U3paQi/tgLv0hBJYt2rnr9MNpxz4fiiugstg==} - micromatch@4.0.5: + /micromatch@4.0.5: + resolution: {integrity: sha512-DMy+ERcEW2q8Z2Po+WNXuw3c5YaUSFjAO5GsJqfEl7UjvtIuFKO6ZrKvcItdy98dwFI2N1tg3zNIdKaQT+aNdA==} + engines: {node: '>=8.6'} dependencies: braces: 3.0.2 picomatch: 2.3.1 - mime-db@1.52.0: {} + /mime-db@1.52.0: + resolution: {integrity: sha512-sPU4uV7dYlvtWJxwwxHD0PuihVNiE7TyAbQ5SWxDCB9mUYvOgroQOwYQQOKPJ8CIbE+1ETVlOoK1UC2nU3gYvg==} + engines: {node: '>= 0.6'} - mime-types@2.1.35: + /mime-types@2.1.35: + resolution: {integrity: sha512-ZDY+bPm5zTTF+YpCrAU9nK0UgICYPT0QtT1NZWFv4s++TNkcgVaT0g6+4R2uI4MjQjzysHB1zxuWL50hzaeXiw==} + engines: {node: '>= 0.6'} dependencies: mime-db: 1.52.0 - mime@1.6.0: {} + /mime@1.6.0: + resolution: {integrity: sha512-x0Vn8spI+wuJ1O6S7gnbaQg8Pxh4NNHb7KSINmEWKiPE4RKOplvijn+NkmYmmRgP68mc70j2EbeTFRsrswaQeg==} + engines: {node: '>=4'} + hasBin: true - mimic-fn@2.1.0: {} + /mimic-fn@2.1.0: + resolution: {integrity: sha512-OqbOk5oEQeAZ8WXWydlu9HJjz9WVdEIvamMCcXmuqUYjTknH/sqsWvhQ3vgwKFRR1HpjvNBKQ37nbJgYzGqGcg==} + engines: {node: '>=6'} + dev: false - mimic-response@1.0.1: {} + /mimic-response@1.0.1: + resolution: {integrity: sha512-j5EctnkH7amfV/q5Hgmoal1g2QHFJRraOtmx0JpIqkxhBhI/lJSl1nMpQ45hVarwNETOoWEimndZ4QK0RHxuxQ==} + engines: {node: '>=4'} - mimic-response@3.1.0: {} + /mimic-response@3.1.0: + resolution: {integrity: sha512-z0yWI+4FDrrweS8Zmt4Ej5HdJmky15+L2e6Wgn3+iK5fWzb6T3fhNFq2+MeTRb064c6Wr4N/wv0DzQTjNzHNGQ==} + engines: {node: '>=10'} - min-document@2.19.0: + /min-document@2.19.0: + resolution: {integrity: sha512-9Wy1B3m3f66bPPmU5hdA4DR4PB2OfDU/+GS3yAB7IQozE3tqXaVv2zOjgla7MEGSRv95+ILmOuvhLkOK6wJtCQ==} dependencies: dom-walk: 0.1.2 - min-indent@1.0.1: {} + /min-indent@1.0.1: + resolution: {integrity: sha512-I9jwMn07Sy/IwOj3zVkVik2JTvgpaykDZEigL6Rx6N9LbMywwUSMtxET+7lVoDLLd3O3IXwJwvuuns8UB/HeAg==} + engines: {node: '>=4'} + dev: true - minimalistic-assert@1.0.1: {} + /minimalistic-assert@1.0.1: + resolution: {integrity: sha512-UtJcAD4yEaGtjPezWuO9wC4nwUnVH/8/Im3yEHQP4b67cXlD/Qr9hdITCU1xDbSEXg2XKNaP8jsReV7vQd00/A==} - minimalistic-crypto-utils@1.0.1: {} + /minimalistic-crypto-utils@1.0.1: + resolution: {integrity: sha512-JIYlbt6g8i5jKfJ3xz7rF0LXmv2TkDxBLUkiBeZ7bAx4GnnNMr8xFpGnOxn6GhTEHx3SjRrZEoU+j04prX1ktg==} - minimatch@3.1.2: + /minimatch@3.1.2: + resolution: {integrity: sha512-J7p63hRiAjw1NDEww1W7i37+ByIrOWO5XQQAzZ3VOcL0PNybwpfmV/N05zFAzwQ9USyEcX6t3UO+K5aqBQOIHw==} dependencies: brace-expansion: 1.1.11 - minimatch@5.0.1: + /minimatch@5.0.1: + resolution: {integrity: sha512-nLDxIFRyhDblz3qMuq+SoRZED4+miJ/G+tdDrjkkkRnjAsBexeGpgjLEQ0blJy7rHhR2b93rhQY4SvyWu9v03g==} + engines: {node: '>=10'} dependencies: brace-expansion: 2.0.1 - minimist-options@4.1.0: + /minimist-options@4.1.0: + resolution: {integrity: sha512-Q4r8ghd80yhO/0j1O3B2BjweX3fiHg9cdOwjJd2J76Q135c+NDxGCqdYKQ1SKBuFfgWbAUzBfvYjPUEeNgqN1A==} + engines: {node: '>= 6'} dependencies: arrify: 1.0.1 is-plain-obj: 1.1.0 kind-of: 6.0.3 + dev: true - minimist@1.2.8: {} + /minimist@1.2.8: + resolution: {integrity: sha512-2yyAR8qBkN3YuheJanUpWC5U3bb5osDywNB8RzDVlDwDHbocAJveqqj1u8+SVD7jkWT4yvsHCpWqqWqAxb0zCA==} - minipass@2.9.0: + /minipass@2.9.0: + resolution: {integrity: sha512-wxfUjg9WebH+CUDX/CdbRlh5SmfZiy/hpkxaRI16Y9W56Pa75sWgd/rvFilSgrauD9NyFymP/+JFV3KwzIsJeg==} dependencies: safe-buffer: 5.2.1 yallist: 3.1.1 - minizlib@1.3.3: + /minizlib@1.3.3: + resolution: {integrity: sha512-6ZYMOEnmVsdCeTJVE0W9ZD+pVnE8h9Hma/iOwwRDsdQoePpoX56/8B6z3P9VNwppJuBKNRuFDRNRqRWexT9G9Q==} dependencies: minipass: 2.9.0 - mixme@0.5.10: {} + /mixme@0.5.10: + resolution: {integrity: sha512-5H76ANWinB1H3twpJ6JY8uvAtpmFvHNArpilJAjXRKXSDDLPIMoZArw5SH0q9z+lLs8IrMw7Q2VWpWimFKFT1Q==} + engines: {node: '>= 8.0.0'} + dev: true - mkdirp-classic@0.5.3: {} + /mkdirp-classic@0.5.3: + resolution: {integrity: sha512-gKLcREMhtuZRwRAfqP3RFW+TK4JqApVBtOIftVgjuABpAtpxhPGaDcfvbhNvD0B8iD1oUr/txX35NjcaY6Ns/A==} + dev: false - mkdirp-promise@5.0.1: + /mkdirp-promise@5.0.1: + resolution: {integrity: sha512-Hepn5kb1lJPtVW84RFT40YG1OddBNTOVUZR2bzQUHc+Z03en8/3uX0+060JDhcEzyO08HmipsN9DcnFMxhIL9w==} + engines: {node: '>=4'} + deprecated: This package is broken and no longer maintained. 'mkdirp' itself supports promises now, please switch to that. dependencies: mkdirp: 3.0.1 - mkdirp@0.5.6: + /mkdirp@0.5.6: + resolution: {integrity: sha512-FP+p8RB8OWpF3YZBCrP5gtADmtXApB5AMLn+vdyA+PyxCjrCs00mjyUozssO33cwDeT3wNGdLxJ5M//YqtHAJw==} + hasBin: true dependencies: minimist: 1.2.8 - mkdirp@1.0.4: {} + /mkdirp@1.0.4: + resolution: {integrity: sha512-vVqVZQyf3WLx2Shd0qJ9xuvqgAyKPLAiqITEtqW0oIUjzo3PePDd6fW9iFz30ef7Ysp/oiWqbhszeGWW2T6Gzw==} + engines: {node: '>=10'} + hasBin: true - mkdirp@3.0.1: {} + /mkdirp@3.0.1: + resolution: {integrity: sha512-+NsyUUAZDmo6YVHzL/stxSu3t9YS1iljliy3BSDrXJ/dkn1KYdmtZODGGjLcc9XLgVVpH4KshHB8XmZgMhaBXg==} + engines: {node: '>=10'} + hasBin: true - mnemonist@0.38.5: + /mnemonist@0.38.5: + resolution: {integrity: sha512-bZTFT5rrPKtPJxj8KSV0WkPyNxl72vQepqqVUAW2ARUpUSF2qXMB6jZj7hW5/k7C1rtpzqbD/IIbJwLXUjCHeg==} dependencies: obliterator: 2.0.4 + dev: false - mocha@10.4.0: + /mocha@10.4.0: + resolution: {integrity: sha512-eqhGB8JKapEYcC4ytX/xrzKforgEc3j1pGlAXVy3eRwrtAy5/nIfT1SvgGzfN0XZZxeLq0aQWkOUAmqIJiv+bA==} + engines: {node: '>= 14.0.0'} + hasBin: true dependencies: ansi-colors: 4.1.1 browser-stdout: 1.3.1 @@ -11714,149 +8432,239 @@ snapshots: yargs-parser: 20.2.4 yargs-unparser: 2.0.0 - mock-fs@4.14.0: {} + /mock-fs@4.14.0: + resolution: {integrity: sha512-qYvlv/exQ4+svI3UOvPUpLDF0OMX5euvUH0Ny4N5QyRyhNdgAgUrVH3iUINSzEPLvx0kbo/Bp28GJKIqvE7URw==} - ms@2.0.0: {} + /ms@2.0.0: + resolution: {integrity: sha512-Tpp60P6IUJDTuOq/5Z8cdskzJujfwqfOTkrwIwj7IRISpnkJnT6SyJ4PCPnGMoFjC9ddhal5KVIYtAt97ix05A==} - ms@2.1.2: {} + /ms@2.1.2: + resolution: {integrity: sha512-sGkPx+VjMtmA6MX27oA4FBFELFCZZ4S4XqeGOXCv68tT+jb3vk/RyaKWP0PTKyWtmLSM0b+adUTEvbs1PEaH2w==} - ms@2.1.3: {} + /ms@2.1.3: + resolution: {integrity: sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==} - multibase@0.6.1: + /multibase@0.6.1: + resolution: {integrity: sha512-pFfAwyTjbbQgNc3G7D48JkJxWtoJoBMaR4xQUOuB8RnCgRqaYmWNFeJTTvrJ2w51bjLq2zTby6Rqj9TQ9elSUw==} + deprecated: This module has been superseded by the multiformats module dependencies: base-x: 3.0.9 buffer: 5.7.1 - multibase@0.7.0: + /multibase@0.7.0: + resolution: {integrity: sha512-TW8q03O0f6PNFTQDvh3xxH03c8CjGaaYrjkl9UQPG6rz53TQzzxJVCIWVjzcbN/Q5Y53Zd0IBQBMVktVgNx4Fg==} + deprecated: This module has been superseded by the multiformats module dependencies: base-x: 3.0.9 buffer: 5.7.1 - multicodec@0.5.7: + /multicodec@0.5.7: + resolution: {integrity: sha512-PscoRxm3f+88fAtELwUnZxGDkduE2HD9Q6GHUOywQLjOGT/HAdhjLDYNZ1e7VR0s0TP0EwZ16LNUTFpoBGivOA==} + deprecated: This module has been superseded by the multiformats module dependencies: varint: 5.0.2 - multicodec@1.0.4: + /multicodec@1.0.4: + resolution: {integrity: sha512-NDd7FeS3QamVtbgfvu5h7fd1IlbaC4EQ0/pgU4zqE2vdHCmBGsUa0TiM8/TdSeG6BMPC92OOCf8F1ocE/Wkrrg==} + deprecated: This module has been superseded by the multiformats module dependencies: buffer: 5.7.1 varint: 5.0.2 - multihashes@0.4.21: + /multihashes@0.4.21: + resolution: {integrity: sha512-uVSvmeCWf36pU2nB4/1kzYZjsXD9vofZKpgudqkceYY5g2aZZXJ5r9lxuzoRLl1OAp28XljXsEJ/X/85ZsKmKw==} dependencies: buffer: 5.7.1 multibase: 0.7.0 varint: 5.0.2 - mz@2.7.0: + /mz@2.7.0: + resolution: {integrity: sha512-z81GNO7nnYMEhrGh9LeymoE4+Yr0Wn5McHIZMK5cfQCl+NDX08sCZgUc9/6MHni9IWuFLm1Z3HTCXu2z9fN62Q==} dependencies: any-promise: 1.3.0 object-assign: 4.1.1 thenify-all: 1.6.0 + dev: false - nano-base32@1.0.1: {} + /nano-base32@1.0.1: + resolution: {integrity: sha512-sxEtoTqAPdjWVGv71Q17koMFGsOMSiHsIFEvzOM7cNp8BXB4AnEwmDabm5dorusJf/v1z7QxaZYxUorU9RKaAw==} + dev: false - nano-json-stream-parser@0.1.2: {} + /nano-json-stream-parser@0.1.2: + resolution: {integrity: sha512-9MqxMH/BSJC7dnLsEMPyfN5Dvoo49IsPFYMcHw3Bcfc2kN0lpHRBSzlMSVx4HGyJ7s9B31CyBTVehWJoQ8Ctew==} - napi-build-utils@1.0.2: {} + /napi-build-utils@1.0.2: + resolution: {integrity: sha512-ONmRUqK7zj7DWX0D9ADe03wbwOBZxNAfF20PlGfCWQcD3+/MakShIHrMqx9YwPTfxDdF1zLeL+RGZiR9kGMLdg==} + dev: false - natural-compare-lite@1.4.0: {} + /natural-compare-lite@1.4.0: + resolution: {integrity: sha512-Tj+HTDSJJKaZnfiuw+iaF9skdPpTo2GtEly5JHnWV/hfv2Qj/9RKsGISQtLh2ox3l5EAGw487hnBee0sIJ6v2g==} + dev: true - natural-compare@1.4.0: {} + /natural-compare@1.4.0: + resolution: {integrity: sha512-OWND8ei3VtNC9h7V60qff3SVobHr996CTwgxubgyQYEpg290h9J0buyECNNJexkFm5sOajh5G116RYA1c8ZMSw==} - ndjson@2.0.0: + /ndjson@2.0.0: + resolution: {integrity: sha512-nGl7LRGrzugTtaFcJMhLbpzJM6XdivmbkdlaGcrk/LXg2KL/YBC6z1g70xh0/al+oFuVFP8N8kiWRucmeEH/qQ==} + engines: {node: '>=10'} + hasBin: true dependencies: json-stringify-safe: 5.0.1 minimist: 1.2.8 readable-stream: 3.6.2 split2: 3.2.2 through2: 4.0.2 + dev: true - negotiator@0.6.3: {} + /negotiator@0.6.3: + resolution: {integrity: sha512-+EUsqGPLsM+j/zdChZjsnX51g4XrHFOIXwfnCVPGlQk/k5giakcKsuxCObBRu6DSm9opw/O6slWbJdghQM4bBg==} + engines: {node: '>= 0.6'} - neo-async@2.6.2: {} + /neo-async@2.6.2: + resolution: {integrity: sha512-Yd3UES5mWCSqR+qNT93S3UoYUkqAZ9lLg8a7g9rimsWmYGK8cVToA4/sF3RrshdyV3sAGMXVUmpMYOw+dLpOuw==} + dev: true - next-tick@1.1.0: {} + /next-tick@1.1.0: + resolution: {integrity: sha512-CXdUiJembsNjuToQvxayPZF9Vqht7hewsvy2sOWafLvi2awflj9mOC6bHIg50orX8IJvWKY9wYQ/zB2kogPslQ==} - nise@4.1.0: + /nise@4.1.0: + resolution: {integrity: sha512-eQMEmGN/8arp0xsvGoQ+B1qvSkR73B1nWSCh7nOt5neMCtwcQVYQGdzQMhcNscktTsWB54xnlSQFzOAPJD8nXA==} dependencies: '@sinonjs/commons': 1.8.6 '@sinonjs/fake-timers': 6.0.1 '@sinonjs/text-encoding': 0.7.2 just-extend: 4.2.1 path-to-regexp: 1.8.0 + dev: true - no-case@2.3.2: + /no-case@2.3.2: + resolution: {integrity: sha512-rmTZ9kz+f3rCvK2TD1Ue/oZlns7OGoIWP4fc3llxxRXlOkHKoWPPWJOfFYpITabSow43QJbRIoHQXtt10VldyQ==} dependencies: lower-case: 1.1.4 + dev: false - no-case@3.0.4: + /no-case@3.0.4: + resolution: {integrity: sha512-fgAN3jGAh+RoxUGZHTSOLJIqUc2wmoBwGR4tbpNAKmmovFoWq0OdRkb0VkldReO2a2iBT/OEulG9XSUc10r3zg==} dependencies: lower-case: 2.0.2 tslib: 2.6.2 + dev: true - node-abi@3.62.0: + /node-abi@3.62.0: + resolution: {integrity: sha512-CPMcGa+y33xuL1E0TcNIu4YyaZCxnnvkVaEXrsosR3FxN+fV8xvb7Mzpb7IgKler10qeMkE6+Dp8qJhpzdq35g==} + engines: {node: '>=10'} dependencies: semver: 7.6.2 + dev: false - node-addon-api@2.0.2: {} + /node-addon-api@2.0.2: + resolution: {integrity: sha512-Ntyt4AIXyaLIuMHF6IOoTakB3K+RWxwtsHNRxllEoA6vPwP9o4866g6YWDLUdnucilZhmkxiHwHr11gAENw+QA==} - node-addon-api@3.2.1: {} + /node-addon-api@3.2.1: + resolution: {integrity: sha512-mmcei9JghVNDYydghQmeDX8KoAm0FAiYyIcUt/N4nhyAipB17pllZQDOJD2fotxABnt4Mdz+dKTO7eftLg4d0A==} + dev: false - node-addon-api@6.1.0: {} + /node-addon-api@6.1.0: + resolution: {integrity: sha512-+eawOlIgy680F0kBzPUNFhMZGtJ1YmqM6l4+Crf4IkImjYrO/mqPwRMh352g23uIaQKFItcQ64I7KMaJxHgAVA==} + dev: false - node-emoji@1.11.0: + /node-emoji@1.11.0: + resolution: {integrity: sha512-wo2DpQkQp7Sjm2A0cq+sN7EHKO6Sl0ctXeBdFZrL9T9+UywORbufTcTZxom8YqpLQt/FqNMUkOpkZrJVYSKD3A==} dependencies: lodash: 4.17.21 + dev: true - node-fetch@2.7.0: + /node-fetch@2.7.0: + resolution: {integrity: sha512-c4FRfUm/dbcWZ7U+1Wq0AwCyFL+3nt2bEw05wfxSz+DWpWsitgmSgYmy2dQdWyKC1694ELPqMs/YzUSNozLt8A==} + engines: {node: 4.x || >=6.0.0} + peerDependencies: + encoding: ^0.1.0 + peerDependenciesMeta: + encoding: + optional: true dependencies: whatwg-url: 5.0.0 - node-gyp-build@4.8.1: {} + /node-gyp-build@4.8.1: + resolution: {integrity: sha512-OSs33Z9yWr148JZcbZd5WiAXhh/n9z8TxQcdMhIOlpN9AhWpLfvVFO73+m77bBABQMaY9XSvIa+qk0jlI7Gcaw==} + hasBin: true - node-hid@2.2.0: + /node-hid@2.2.0: + resolution: {integrity: sha512-vj48zh9j555DZzUhMc8tk/qw6xPFrDyPBH1ST1Z/hWaA/juBJw7IuSxPeOgpzNFNU36mGYj+THioRMt1xOdm/g==} + engines: {node: '>=10'} + hasBin: true + requiresBuild: true dependencies: bindings: 1.5.0 node-addon-api: 3.2.1 prebuild-install: 7.1.2 + dev: false - node-preload@0.2.1: + /node-preload@0.2.1: + resolution: {integrity: sha512-RM5oyBy45cLEoHqCeh+MNuFAxO0vTFBLskvQbOKnEE7YTTSN4tbN8QWDIPQ6L+WvKsB/qLEGpYe2ZZ9d4W9OIQ==} + engines: {node: '>=8'} dependencies: process-on-spawn: 1.0.0 + dev: true - node-releases@2.0.14: {} + /node-releases@2.0.14: + resolution: {integrity: sha512-y10wOWt8yZpqXmOgRo77WaHEmhYQYGNA6y421PKsKYWEK8aW+cqAphborZDhqfyKrbZEN92CN1X2KbafY2s7Yw==} + dev: true - nofilter@1.0.4: {} + /nofilter@1.0.4: + resolution: {integrity: sha512-N8lidFp+fCz+TD51+haYdbDGrcBWwuHX40F5+z0qkUjMJ5Tp+rdSuAkMJ9N9eoolDlEVTf6u5icM+cNKkKW2mA==} + engines: {node: '>=8'} + dev: false - nofilter@3.1.0: {} + /nofilter@3.1.0: + resolution: {integrity: sha512-l2NNj07e9afPnhAhvgVrCD/oy2Ai1yfLpuo3EpiO1jFTsB4sFz6oIfAfSZyQzVpkZQ9xS8ZS5g1jCBgq4Hwo0g==} + engines: {node: '>=12.19'} - nopt@3.0.6: + /nopt@3.0.6: + resolution: {integrity: sha512-4GUt3kSEYmk4ITxzB/b9vaIDfUVWN/Ml1Fwl11IlnIG2iaJ9O6WXZ9SrYM9NLI8OCBieN2Y8SWC2oJV0RQ7qYg==} + hasBin: true dependencies: abbrev: 1.0.9 + dev: true - normalize-package-data@2.5.0: + /normalize-package-data@2.5.0: + resolution: {integrity: sha512-/5CMN3T0R4XTj4DcGaexo+roZSdSFW/0AOOTROrjxzCG1wrWXEsGbRKevjlIL+ZDE4sZlJr5ED4YW0yqmkK+eA==} dependencies: hosted-git-info: 2.8.9 resolve: 1.17.0 semver: 5.7.2 validate-npm-package-license: 3.0.4 - normalize-path@3.0.0: {} + /normalize-path@3.0.0: + resolution: {integrity: sha512-6eZs5Ls3WtCisHWp9S2GUy8dqkpGi4BVSz3GaqiE6ezub0512ESztXUwUB6C6IKbQkY2Pnb/mD4WYojCRwcwLA==} + engines: {node: '>=0.10.0'} - normalize-url@6.1.0: {} + /normalize-url@6.1.0: + resolution: {integrity: sha512-DlL+XwOy3NxAQ8xuC0okPgK46iuVNAK01YN7RueYBqqFeGsBjV9XmCAzAdgt+667bCl5kPh9EqKKDwnaPG1I7A==} + engines: {node: '>=10'} - nth-check@2.1.1: + /nth-check@2.1.1: + resolution: {integrity: sha512-lqjrjmaOoAnWfMmBPL+XNnynZh2+swxiX3WUE0s4yEHI6m+AwrK2UZOimIRl3X/4QctVqS8AiZjFqyOGrMXb/w==} dependencies: boolbase: 1.0.0 + dev: false - number-is-nan@1.0.1: {} + /number-is-nan@1.0.1: + resolution: {integrity: sha512-4jbtZXNAsfZbAHiiqjLPBiCl16dES1zI4Hpzzxw61Tk+loF+sBDBKx1ICKKKwIqQ7M0mFn1TmkN7euSncWgHiQ==} + engines: {node: '>=0.10.0'} + dev: false - number-to-bn@1.7.0: + /number-to-bn@1.7.0: + resolution: {integrity: sha512-wsJ9gfSz1/s4ZsJN01lyonwuxA1tml6X1yBDnfpMglypcBRFZZkus26EdPSlqS5GJfYddVZa22p3VNb3z5m5Ig==} + engines: {node: '>=6.5.0', npm: '>=3'} dependencies: bn.js: 4.11.6 strip-hex-prefix: 1.0.0 - nyc@15.1.0: + /nyc@15.1.0: + resolution: {integrity: sha512-jMW04n9SxKdKi1ZMGhvUTHBN0EICCRkHemEoE5jm6mTYcqcdas0ATzgUgejlQUHMvpnOZqGB5Xxsv9KxJW1j8A==} + engines: {node: '>=8.9'} + hasBin: true dependencies: '@istanbuljs/load-nyc-config': 1.1.0 '@istanbuljs/schema': 0.1.3 @@ -11887,47 +8695,72 @@ snapshots: yargs: 15.4.1 transitivePeerDependencies: - supports-color + dev: true - oauth-sign@0.9.0: {} + /oauth-sign@0.9.0: + resolution: {integrity: sha512-fexhUFFPTGV8ybAtSIGbV6gOkSv8UtRbDBnAyLQw4QPKkgNlsH2ByPGtMUqdWkos6YCRmAqViwgZrJc/mRDzZQ==} - object-assign@4.1.1: {} + /object-assign@4.1.1: + resolution: {integrity: sha512-rJgTQnkUnH1sFw8yT6VSU3zD3sWmu6sZhIseY8VX+GRu3P6F7Fu+JNDoXfklElbLJSnc3FUQHVe4cU5hj+BcUg==} + engines: {node: '>=0.10.0'} - object-inspect@1.13.1: {} + /object-inspect@1.13.1: + resolution: {integrity: sha512-5qoj1RUiKOMsCCNLV1CBiPYE10sziTsnmNxkAI/rZhiD63CF7IqdFGC/XzjWjpSgLf0LxXX3bDFIh0E18f6UhQ==} - object-keys@1.1.1: {} + /object-keys@1.1.1: + resolution: {integrity: sha512-NuAESUOUMrlIXOfHKzD6bpPu3tYt3xvjNdRIQ+FeT0lNb4K8WR70CaDxhuNguS2XG+GjkyMwOzsN5ZktImfhLA==} + engines: {node: '>= 0.4'} + dev: true - object.assign@4.1.5: + /object.assign@4.1.5: + resolution: {integrity: sha512-byy+U7gp+FVwmyzKPYhW2h5l3crpmGsxl7X2s8y43IgxvG4g3QZ6CffDtsNQy1WsmZpQbO+ybo0AlW7TY6DcBQ==} + engines: {node: '>= 0.4'} dependencies: call-bind: 1.0.7 define-properties: 1.2.1 has-symbols: 1.0.3 object-keys: 1.1.1 + dev: true - object.values@1.2.0: + /object.values@1.2.0: + resolution: {integrity: sha512-yBYjY9QX2hnRmZHAjG/f13MzmBzxzYgQhFrke06TTyKY5zSTEqkOeukBzIdVA3j3ulu8Qa3MbVFShV7T2RmGtQ==} + engines: {node: '>= 0.4'} dependencies: call-bind: 1.0.7 define-properties: 1.2.1 es-object-atoms: 1.0.0 + dev: true - obliterator@2.0.4: {} + /obliterator@2.0.4: + resolution: {integrity: sha512-lgHwxlxV1qIg1Eap7LgIeoBWIMFibOjbrYPIPJZcI1mmGAI2m3lNYpK12Y+GBdPQ0U1hRwSord7GIaawz962qQ==} + dev: false - oboe@2.1.5: + /oboe@2.1.5: + resolution: {integrity: sha512-zRFWiF+FoicxEs3jNI/WYUrVEgA7DeET/InK0XQuudGHRg8iIob3cNPrJTKaz4004uaA9Pbe+Dwa8iluhjLZWA==} dependencies: http-https: 1.0.0 - on-finished@2.4.1: + /on-finished@2.4.1: + resolution: {integrity: sha512-oVlzkg3ENAhCk2zdv7IJwd/QUD4z2RxRwpkcGY8psCVcCYZNq4wYnVWALHM+brtuJjePWiYF/ClmuDr8Ch5+kg==} + engines: {node: '>= 0.8'} dependencies: ee-first: 1.1.1 - once@1.4.0: + /once@1.4.0: + resolution: {integrity: sha512-lNaJgI+2Q5URQBkccEKHTQOPaXdUxnZZElQTZY0MFUAuaEqe1E+Nyvgdz/aIyNi6Z9MzO5dv1H8n58/GELp3+w==} dependencies: wrappy: 1.0.2 - onetime@5.1.2: + /onetime@5.1.2: + resolution: {integrity: sha512-kbpaSSGJTWdAY5KPVeMOKXSrPtr8C8C7wodJbcsd51jRnmD+GZu8Y0VoU6Dm5Z4vWr0Ig/1NKuWRKf7j5aaYSg==} + engines: {node: '>=6'} dependencies: mimic-fn: 2.1.0 + dev: false - optionator@0.8.3: + /optionator@0.8.3: + resolution: {integrity: sha512-+IW9pACdk3XWmmTXG8m3upGUJst5XRGzxMRjXzAuJ1XnIFNvfhjjIuYkDvysnPQ7qzqVzLt78BCruntqRhWQbA==} + engines: {node: '>= 0.8.0'} dependencies: deep-is: 0.1.4 fast-levenshtein: 2.0.6 @@ -11935,8 +8768,11 @@ snapshots: prelude-ls: 1.1.2 type-check: 0.3.2 word-wrap: 1.2.5 + dev: true - optionator@0.9.4: + /optionator@0.9.4: + resolution: {integrity: sha512-6IpQ7mKUxRcZNLIObR0hz7lxsapSSIYNZJwXPGeF0mTVqGKFIXj1DQcMoT22S3ROcLyY/rz0PWaWZ9ayWmad9g==} + engines: {node: '>= 0.8.0'} dependencies: deep-is: 0.1.4 fast-levenshtein: 2.0.6 @@ -11945,7 +8781,9 @@ snapshots: type-check: 0.4.0 word-wrap: 1.2.5 - ora@5.4.1: + /ora@5.4.1: + resolution: {integrity: sha512-5b6Y85tPxZZ7QytO+BQzysW31HJku27cRIlkbAXaNx+BdcVi+LlRFmVXzeF6a7JCwJpyw5c4b+YSVImQIrBpuQ==} + engines: {node: '>=10'} dependencies: bl: 4.1.0 chalk: 4.1.2 @@ -11956,148 +8794,250 @@ snapshots: log-symbols: 4.1.0 strip-ansi: 6.0.1 wcwidth: 1.0.1 + dev: false - ordinal@1.0.3: {} + /ordinal@1.0.3: + resolution: {integrity: sha512-cMddMgb2QElm8G7vdaa02jhUNbTSrhsgAGUz1OokD83uJTwSUn+nKoNoKVVaRa08yF6sgfO7Maou1+bgLd9rdQ==} + dev: false - os-locale@1.4.0: + /os-locale@1.4.0: + resolution: {integrity: sha512-PRT7ZORmwu2MEFt4/fv3Q+mEfN4zetKxufQrkShY2oGvUms9r8otu5HfdyIFHkYXjO7laNsoVGmM2MANfuTA8g==} + engines: {node: '>=0.10.0'} dependencies: lcid: 1.0.0 + dev: false - os-tmpdir@1.0.2: {} + /os-tmpdir@1.0.2: + resolution: {integrity: sha512-D2FR03Vir7FIu45XBY20mTb+/ZSWB00sjU9jdQXt83gDrI4Ztz5Fs7/yy74g2N5SVQY4xY1qDr4rNddwYRVX0g==} + engines: {node: '>=0.10.0'} - outdent@0.5.0: {} + /outdent@0.5.0: + resolution: {integrity: sha512-/jHxFIzoMXdqPzTaCpFzAAWhpkSjZPF4Vsn6jAfNpmbH/ymsmd7Qc6VE9BGn0L6YMj6uwpQLxCECpus4ukKS9Q==} + dev: true - p-cancelable@2.1.1: {} + /p-cancelable@2.1.1: + resolution: {integrity: sha512-BZOr3nRQHOntUjTrH8+Lh54smKHoHyur8We1V8DSMVrl5A2malOOwuJRnKRDjSnkoeBh4at6BwEnb5I7Jl31wg==} + engines: {node: '>=8'} - p-cancelable@3.0.0: {} + /p-cancelable@3.0.0: + resolution: {integrity: sha512-mlVgR3PGuzlo0MmTdk4cXqXWlwQDLnONTAg6sm62XkMJEiRxN3GL3SffkYvqwonbkJBcrI7Uvv5Zh9yjvn2iUw==} + engines: {node: '>=12.20'} - p-filter@2.1.0: + /p-filter@2.1.0: + resolution: {integrity: sha512-ZBxxZ5sL2HghephhpGAQdoskxplTwr7ICaehZwLIlfL6acuVgZPm8yBNuRAFBGEqtD/hmUeq9eqLg2ys9Xr/yw==} + engines: {node: '>=8'} dependencies: p-map: 2.1.0 + dev: true - p-limit@1.3.0: + /p-limit@1.3.0: + resolution: {integrity: sha512-vvcXsLAJ9Dr5rQOPk7toZQZJApBl2K4J6dANSsEuh6QI41JYcsS/qhTGa9ErIUUgK3WNQoJYvylxvjqmiqEA9Q==} + engines: {node: '>=4'} dependencies: p-try: 1.0.0 + dev: false - p-limit@2.3.0: + /p-limit@2.3.0: + resolution: {integrity: sha512-//88mFWSJx8lxCzwdAABTJL2MyWB12+eIY7MDL2SqLmAkeKU9qxRvWuSyTjm3FUmpBEMuFfckAIqEaVGUDxb6w==} + engines: {node: '>=6'} dependencies: p-try: 2.2.0 + dev: true - p-limit@3.1.0: + /p-limit@3.1.0: + resolution: {integrity: sha512-TYOanM3wGwNGsZN2cVTYPArw454xnXj5qmWF1bEoAc4+cU/ol7GVh7odevjp1FNHduHc3KZMcFduxU5Xc6uJRQ==} + engines: {node: '>=10'} dependencies: yocto-queue: 0.1.0 - p-locate@2.0.0: + /p-locate@2.0.0: + resolution: {integrity: sha512-nQja7m7gSKuewoVRen45CtVfODR3crN3goVQ0DDZ9N3yHxgpkuBhZqsaiotSQRrADUrne346peY7kT3TSACykg==} + engines: {node: '>=4'} dependencies: p-limit: 1.3.0 + dev: false - p-locate@4.1.0: + /p-locate@4.1.0: + resolution: {integrity: sha512-R79ZZ/0wAxKGu3oYMlz8jy/kbhsNrS7SKZ7PxEHBgJ5+F2mtFW2fK2cOtBh1cHYkQsbzFV7I+EoRKe6Yt0oK7A==} + engines: {node: '>=8'} dependencies: p-limit: 2.3.0 + dev: true - p-locate@5.0.0: + /p-locate@5.0.0: + resolution: {integrity: sha512-LaNjtRWUBY++zB5nE/NwcaoMylSPk+S+ZHNB1TzdbMJMny6dynpAGt7X/tl/QYq3TIeE6nxHppbo2LGymrG5Pw==} + engines: {node: '>=10'} dependencies: p-limit: 3.1.0 - p-map@2.1.0: {} + /p-map@2.1.0: + resolution: {integrity: sha512-y3b8Kpd8OAN444hxfBbFfj1FY/RjtTd8tzYwhUqNYXx0fXx2iX4maP4Qr6qhIKbQXI02wTLAda4fYUbDagTUFw==} + engines: {node: '>=6'} + dev: true - p-map@3.0.0: + /p-map@3.0.0: + resolution: {integrity: sha512-d3qXVTF/s+W+CdJ5A29wywV2n8CQQYahlgz2bFiA+4eVNJbHJodPZ+/gXwPGh0bOqA+j8S+6+ckmvLGPk1QpxQ==} + engines: {node: '>=8'} dependencies: aggregate-error: 3.1.0 + dev: true - p-map@4.0.0: + /p-map@4.0.0: + resolution: {integrity: sha512-/bjOqmgETBYB5BoEeGVea8dmvHb2m9GLy1E9W43yeyfP6QQCZGFNa+XRceJEuDB6zqr+gKpIAmlLebMpykw/MQ==} + engines: {node: '>=10'} dependencies: aggregate-error: 3.1.0 + dev: false - p-try@1.0.0: {} + /p-try@1.0.0: + resolution: {integrity: sha512-U1etNYuMJoIz3ZXSrrySFjsXQTWOx2/jdi86L+2pRvph/qMKL6sbcCYdH23fqsbm8TH2Gn0OybpT4eSFlCVHww==} + engines: {node: '>=4'} + dev: false - p-try@2.2.0: {} + /p-try@2.2.0: + resolution: {integrity: sha512-R4nPAVTAU0B9D35/Gk3uJf/7XYbQcyohSKdvAxIRSNghFl4e71hVoGnBNQz9cWaXxO2I10KTC+3jMdvvoKw6dQ==} + engines: {node: '>=6'} + dev: true - package-hash@4.0.0: + /package-hash@4.0.0: + resolution: {integrity: sha512-whdkPIooSu/bASggZ96BWVvZTRMOFxnyUG5PnTSGKoJE2gd5mbVNmR2Nj20QFzxYYgAXpoqC+AiXzl+UMRh7zQ==} + engines: {node: '>=8'} dependencies: graceful-fs: 4.2.11 hasha: 5.2.2 lodash.flattendeep: 4.4.0 release-zalgo: 1.0.0 + dev: true - pako@1.0.11: {} + /pako@1.0.11: + resolution: {integrity: sha512-4hLB8Py4zZce5s4yd9XzopqwVv/yGNhV1Bl8NTmCq1763HeK2+EwVTv+leGeL13Dnh2wfbqowVPXCIO0z4taYw==} + dev: false - param-case@2.1.1: + /param-case@2.1.1: + resolution: {integrity: sha512-eQE845L6ot89sk2N8liD8HAuH4ca6Vvr7VWAWwt7+kvvG5aBcPmmphQ68JsEG2qa9n1TykS2DLeMt363AAH8/w==} dependencies: no-case: 2.3.2 + dev: false - parent-module@1.0.1: + /parent-module@1.0.1: + resolution: {integrity: sha512-GQ2EWRpQV8/o+Aw8YqtfZZPfNRWZYkbidE9k5rpl/hC3vtHHBfGm2Ifi6qWV+coDGkrUKZAxE3Lot5kcsRlh+g==} + engines: {node: '>=6'} dependencies: callsites: 3.1.0 - parse-cache-control@1.0.1: {} + /parse-cache-control@1.0.1: + resolution: {integrity: sha512-60zvsJReQPX5/QP0Kzfd/VrpjScIQ7SHBW6bFCYfEP+fp0Eppr1SHhIO5nd1PjZtvclzSzES9D/p5nFJurwfWg==} + dev: true - parse-headers@2.0.5: {} + /parse-headers@2.0.5: + resolution: {integrity: sha512-ft3iAoLOB/MlwbNXgzy43SWGP6sQki2jQvAyBg/zDFAgr9bfNWZIUj42Kw2eJIl8kEi4PbgE6U1Zau/HwI75HA==} - parse-json@2.2.0: + /parse-json@2.2.0: + resolution: {integrity: sha512-QR/GGaKCkhwk1ePQNYDRKYZ3mwU9ypsKhB0XyFnLQdomyEqk3e8wpW3V5Jp88zbxK4n5ST1nqo+g9juTpownhQ==} + engines: {node: '>=0.10.0'} dependencies: error-ex: 1.3.2 + dev: false - parse-json@5.2.0: + /parse-json@5.2.0: + resolution: {integrity: sha512-ayCKvm/phCGxOkYRSCM82iDwct8/EonSEgCSxWxD7ve6jHggsFl4fZVQBPRNgQoKiuV/odhFrGzQXZwbifC8Rg==} + engines: {node: '>=8'} dependencies: '@babel/code-frame': 7.24.2 error-ex: 1.3.2 json-parse-even-better-errors: 2.3.1 lines-and-columns: 1.2.4 - parse-ms@0.1.2: {} + /parse-ms@0.1.2: + resolution: {integrity: sha512-VwMglE9412ifMHcRFEVJePEpreQh90wjIiOdP0UQQGKV4l+QprdKI+p5noXTkmGjznBMb40s+VymcclATAVvYA==} + engines: {node: '>=0.10.0'} + dev: true - parse5-htmlparser2-tree-adapter@7.0.0: + /parse5-htmlparser2-tree-adapter@7.0.0: + resolution: {integrity: sha512-B77tOZrqqfUfnVcOrUvfdLbz4pu4RopLD/4vmu3HUPswwTA8OH0EMW9BlWR2B0RCoiZRAHEUu7IxeP1Pd1UU+g==} dependencies: domhandler: 5.0.3 parse5: 7.1.2 + dev: false - parse5@7.1.2: + /parse5@7.1.2: + resolution: {integrity: sha512-Czj1WaSVpaoj0wbhMzLmWD69anp2WH7FXMB9n1Sy8/ZFF9jolSQVMu1Ij5WIyGmcBmhk7EOndpO4mIpihVqAXw==} dependencies: entities: 4.5.0 + dev: false - parseurl@1.3.3: {} + /parseurl@1.3.3: + resolution: {integrity: sha512-CiyeOxFT/JZyN5m0z9PfXw4SCBJ6Sygz1Dpl0wqjlhDEGGBP1GnsUVEL0p63hoG1fcj3fHynXi9NYO4nWOL+qQ==} + engines: {node: '>= 0.8'} - pascal-case@2.0.1: + /pascal-case@2.0.1: + resolution: {integrity: sha512-qjS4s8rBOJa2Xm0jmxXiyh1+OFf6ekCWOvUaRgAQSktzlTbMotS0nmG9gyYAybCWBcuP4fsBeRCKNwGBnMe2OQ==} dependencies: camel-case: 3.0.0 upper-case-first: 1.1.2 + dev: false - path-case@2.1.1: + /path-case@2.1.1: + resolution: {integrity: sha512-Ou0N05MioItesaLr9q8TtHVWmJ6fxWdqKB2RohFmNWVyJ+2zeKIeDNWAN6B/Pe7wpzWChhZX6nONYmOnMeJQ/Q==} dependencies: no-case: 2.3.2 + dev: false - path-exists@2.1.0: + /path-exists@2.1.0: + resolution: {integrity: sha512-yTltuKuhtNeFJKa1PiRzfLAU5182q1y4Eb4XCJ3PBqyzEDkAZRzBrKKBct682ls9reBVHf9udYLN5Nd+K1B9BQ==} + engines: {node: '>=0.10.0'} dependencies: pinkie-promise: 2.0.1 + dev: false - path-exists@3.0.0: {} + /path-exists@3.0.0: + resolution: {integrity: sha512-bpC7GYwiDYQ4wYLe+FA8lhRjhQCMcQGuSgGGqDkg/QerRWw9CmGRT0iSOVRSZJ29NMLZgIzqaljJ63oaL4NIJQ==} + engines: {node: '>=4'} + dev: false - path-exists@4.0.0: {} + /path-exists@4.0.0: + resolution: {integrity: sha512-ak9Qy5Q7jYb2Wwcey5Fpvg2KoAc/ZIhLSLOSBmRmygPsGwkVVt0fZa0qrtMz+m6tJTAHfZQ8FnmB4MG4LWy7/w==} + engines: {node: '>=8'} - path-is-absolute@1.0.1: {} + /path-is-absolute@1.0.1: + resolution: {integrity: sha512-AVbw3UJ2e9bq64vSaS9Am0fje1Pa8pbGqTTsmXfaIiMpnr5DlDhfJOuLj9Sf95ZPVDAUerDfEk88MPmPe7UCQg==} + engines: {node: '>=0.10.0'} - path-key@3.1.1: {} + /path-key@3.1.1: + resolution: {integrity: sha512-ojmeN0qd+y0jszEtoY48r0Peq5dwMEkIlCOu6Q5f41lfkswXuKtYrhgoTpLnyIcHm24Uhqx+5Tqm2InSwLhE6Q==} + engines: {node: '>=8'} - path-parse@1.0.7: {} + /path-parse@1.0.7: + resolution: {integrity: sha512-LDJzPVEEEPR+y48z93A0Ed0yXb8pAByGWo/k5YYdYgpY2/2EsOsksJrq7lOHxryrVOn1ejG6oAp8ahvOIQD8sw==} - path-to-regexp@0.1.7: {} + /path-to-regexp@0.1.7: + resolution: {integrity: sha512-5DFkuoqlv1uYQKxy8omFBeJPQcdoE07Kv2sferDCrAq1ohOU+MSDswDIbnx3YAM60qIOnYa53wBhXW0EbMonrQ==} - path-to-regexp@1.8.0: + /path-to-regexp@1.8.0: + resolution: {integrity: sha512-n43JRhlUKUAlibEJhPeir1ncUID16QnEjNpwzNdO3Lm4ywrBpBZ5oLD0I6br9evr1Y9JTqwRtAh7JLoOzAQdVA==} dependencies: isarray: 0.0.1 + dev: true - path-type@1.1.0: + /path-type@1.1.0: + resolution: {integrity: sha512-S4eENJz1pkiQn9Znv33Q+deTOKmbl+jj1Fl+qiP/vYezj+S8x+J3Uo0ISrx/QoEvIlOaDWJhPaRd1flJ9HXZqg==} + engines: {node: '>=0.10.0'} dependencies: graceful-fs: 4.2.11 pify: 2.3.0 pinkie-promise: 2.0.1 + dev: false - path-type@4.0.0: {} + /path-type@4.0.0: + resolution: {integrity: sha512-gDKb8aZMDeD/tZWs9P6+q0J9Mwkdl6xMV8TjnGP3qJVJ06bdMgkbBlLU8IdfOsIsFz2BW1rNVT3XuNEl8zPAvw==} + engines: {node: '>=8'} - pathval@1.1.1: {} + /pathval@1.1.1: + resolution: {integrity: sha512-Dp6zGqpTdETdR63lehJYPeIOqpiNBNtc7BpWSLrOje7UaIsE5aY92r/AunQA7rsXvet3lrJ3JnZX29UPTKXyKQ==} - pbkdf2@3.1.2: + /pbkdf2@3.1.2: + resolution: {integrity: sha512-iuh7L6jA7JEGu2WxDwtQP1ddOpaJNC4KlDEFfdQajSGgGPNi4OyDc2R7QnbY2bR9QjBVGwgvTdNJZoE7RaxUMA==} + engines: {node: '>=0.12'} dependencies: create-hash: 1.2.0 create-hmac: 1.1.7 @@ -12105,31 +9045,58 @@ snapshots: safe-buffer: 5.2.1 sha.js: 2.4.11 - performance-now@2.1.0: {} + /performance-now@2.1.0: + resolution: {integrity: sha512-7EAHlyLHI56VEIdK57uwHdHKIaAGbnXPiw0yWbarQZOKaKpvUIgW0jWRVLiatnM+XXlSwsanIBH/hzGMJulMow==} - picocolors@1.0.0: {} + /picocolors@1.0.0: + resolution: {integrity: sha512-1fygroTLlHu66zi26VoTDv8yRgm0Fccecssto+MhsZ0D/DGW2sm8E8AjW7NU5VVTRt5GxbeZ5qBuJr+HyLYkjQ==} - picomatch@2.3.1: {} + /picomatch@2.3.1: + resolution: {integrity: sha512-JU3teHTNjmE2VCGFzuY8EXzCDVwEqB2a8fsIvwaStHhAWJEeVd1o1QD80CU6+ZdEXXSLbSsuLwJjkCBWqRQUVA==} + engines: {node: '>=8.6'} - pify@2.3.0: {} + /pify@2.3.0: + resolution: {integrity: sha512-udgsAY+fTnvv7kI7aaxbqwWNb0AHiB0qBO89PZKPkoTmGOgdbrHDKD+0B2X4uTfJ/FT1R09r9gTsjUjNJotuog==} + engines: {node: '>=0.10.0'} + dev: false - pify@4.0.1: {} + /pify@4.0.1: + resolution: {integrity: sha512-uB80kBFb/tfd68bVleG9T5GGsGPjJrLAUpR5PZIrhBnIaRTQRjqdJSsIKkOP6OAIFbj7GOrcudc5pNjZ+geV2g==} + engines: {node: '>=6'} + dev: true - pinkie-promise@2.0.1: + /pinkie-promise@2.0.1: + resolution: {integrity: sha512-0Gni6D4UcLTbv9c57DfxDGdr41XfgUjqWZu492f0cIGr16zDU06BWP/RAEvOuo7CQ0CNjHaLlM59YJJFm3NWlw==} + engines: {node: '>=0.10.0'} dependencies: pinkie: 2.0.4 + dev: false - pinkie@2.0.4: {} + /pinkie@2.0.4: + resolution: {integrity: sha512-MnUuEycAemtSaeFSjXKW/aroV7akBbY+Sv+RkyqFjgAe73F+MR0TBWKBRDkmfWq/HiFmdavfZ1G7h4SPZXaCSg==} + engines: {node: '>=0.10.0'} + dev: false - pkg-dir@4.2.0: + /pkg-dir@4.2.0: + resolution: {integrity: sha512-HRDzbaKjC+AOWVXxAU/x54COGeIv9eb+6CkDSQoNTt4XyWoIJvuPsXizxu/Fr23EiekbtZwmh1IcIG/l/a10GQ==} + engines: {node: '>=8'} dependencies: find-up: 4.1.0 + dev: true - pluralize@8.0.0: {} + /pluralize@8.0.0: + resolution: {integrity: sha512-Nc3IT5yHzflTfbjgqWcCPpo7DaKy4FnpB0l/zCAW0Tc7jxAiuqSxHasntB3D7887LSrA93kDJ9IXovxJYxyLCA==} + engines: {node: '>=4'} + dev: false - possible-typed-array-names@1.0.0: {} + /possible-typed-array-names@1.0.0: + resolution: {integrity: sha512-d7Uw+eZoloe0EHDIYoe+bQ5WXnGMOpmiZFTuMWCwpjzzkL2nTjcKiAk4hh8TjnGye2TwWOk3UXucZ+3rbmBa8Q==} + engines: {node: '>= 0.4'} - prebuild-install@7.1.2: + /prebuild-install@7.1.2: + resolution: {integrity: sha512-UnNke3IQb6sgarcZIDU3gbMeTp/9SSU1DAIkil7PrqG1vZlBtY5msYccSKSHDqa3hNg436IXK+SNImReuA1wEQ==} + engines: {node: '>=10'} + hasBin: true dependencies: detect-libc: 2.0.3 expand-template: 2.0.3 @@ -12143,163 +9110,264 @@ snapshots: simple-get: 4.0.1 tar-fs: 2.1.1 tunnel-agent: 0.6.0 + dev: false - preferred-pm@3.1.3: + /preferred-pm@3.1.3: + resolution: {integrity: sha512-MkXsENfftWSRpzCzImcp4FRsCc3y1opwB73CfCNWyzMqArju2CrlMHlqB7VexKiPEOjGMbttv1r9fSCn5S610w==} + engines: {node: '>=10'} dependencies: find-up: 5.0.0 find-yarn-workspace-root2: 1.2.16 path-exists: 4.0.0 which-pm: 2.0.0 + dev: true - prelude-ls@1.1.2: {} + /prelude-ls@1.1.2: + resolution: {integrity: sha512-ESF23V4SKG6lVSGZgYNpbsiaAkdab6ZgOxe52p7+Kid3W3u3bxR4Vfd/o21dmN7jSt0IwgZ4v5MUd26FEtXE9w==} + engines: {node: '>= 0.8.0'} + dev: true - prelude-ls@1.2.1: {} + /prelude-ls@1.2.1: + resolution: {integrity: sha512-vkcDPrRZo1QZLbn5RLGPpg/WmIQ65qoWWhcGKf/b5eplkkarX0m9z8ppCat4mlOqUsWpyNuYgO3VRyrYHSzX5g==} + engines: {node: '>= 0.8.0'} - prettier-linter-helpers@1.0.0: + /prettier-linter-helpers@1.0.0: + resolution: {integrity: sha512-GbK2cP9nraSSUF9N2XwUwqfzlAFlMNYYl+ShE/V+H8a9uNl/oUqB1w2EL54Jh0OlyRSd8RfWYJ3coVS4TROP2w==} + engines: {node: '>=6.0.0'} dependencies: fast-diff: 1.3.0 + dev: true - prettier@2.4.1: {} + /prettier@2.4.1: + resolution: {integrity: sha512-9fbDAXSBcc6Bs1mZrDYb3XKzDLm4EXXL9sC1LqKP5rZkT6KRr/rf9amVUcODVXgguK/isJz0d0hP72WeaKWsvA==} + engines: {node: '>=10.13.0'} + hasBin: true + dev: true - prettier@2.8.8: {} + /prettier@2.8.8: + resolution: {integrity: sha512-tdN8qQGvNjw4CHbY+XXk0JgCXn9QiF21a55rBe5LJAU+kDyC4WQn4+awm2Xfk2lQMk5fKup9XgzTZtGkjBdP9Q==} + engines: {node: '>=10.13.0'} + hasBin: true - pretty-format@29.7.0: + /pretty-format@29.7.0: + resolution: {integrity: sha512-Pdlw/oPxN+aXdmM9R00JVC9WVFoCLTKJvDVLgmJ+qAffBMxsV85l/Lu7sNx4zSzPyoL2euImuEwHhOXdEgNFZQ==} + engines: {node: ^14.15.0 || ^16.10.0 || >=18.0.0} dependencies: '@jest/schemas': 29.6.3 ansi-styles: 5.2.0 react-is: 18.3.1 + dev: true - pretty-ms@0.2.2: + /pretty-ms@0.2.2: + resolution: {integrity: sha512-ah/vWDJAT0arxQwVcSGp6etaLTZr4IsrXTy/khfjimzdYgSxYWzTMByrtpJUWinAnVY8szDg+qQhsE5MUMz3lQ==} + engines: {node: '>=0.10.0'} + hasBin: true dependencies: parse-ms: 0.1.2 + dev: true - process-nextick-args@2.0.1: {} + /process-nextick-args@2.0.1: + resolution: {integrity: sha512-3ouUOpQhtgrbOa17J7+uxOTpITYWaGP7/AhoR3+A+/1e9skrzelGi/dXzEYyvbxubEF6Wn2ypscTKiKJFFn1ag==} + dev: true - process-on-spawn@1.0.0: + /process-on-spawn@1.0.0: + resolution: {integrity: sha512-1WsPDsUSMmZH5LeMLegqkPDrsGgsWwk1Exipy2hvB0o/F0ASzbpIctSCcZIK1ykJvtTJULEH+20WOFjMvGnCTg==} + engines: {node: '>=8'} dependencies: fromentries: 1.3.2 + dev: true - process@0.11.10: {} + /process@0.11.10: + resolution: {integrity: sha512-cdGef/drWFoydD1JsMzuFf8100nZl+GT+yacc2bEced5f9Rjk4z+WtFUTBu9PhOi9j/jfmBPu0mMEY4wIdAF8A==} + engines: {node: '>= 0.6.0'} - promise@8.3.0: + /promise@8.3.0: + resolution: {integrity: sha512-rZPNPKTOYVNEEKFaq1HqTgOwZD+4/YHS5ukLzQCypkj+OkYx7iv0mA91lJlpPPZ8vMau3IIGj5Qlwrx+8iiSmg==} dependencies: asap: 2.0.6 + dev: true - prompts@2.4.2: + /prompts@2.4.2: + resolution: {integrity: sha512-NxNv/kLguCA7p3jE8oL2aEBsrJWgAakBpgmgK6lpPWV+WuOmY6r2/zbAVnP+T8bQlA0nzHXSJSJW0Hq7ylaD2Q==} + engines: {node: '>= 6'} dependencies: kleur: 3.0.3 sisteransi: 1.0.5 + dev: true - proxy-addr@2.0.7: + /proxy-addr@2.0.7: + resolution: {integrity: sha512-llQsMLSUDUPT44jdrU/O37qlnifitDP+ZwrmmZcoSKyLKvtZxpyV0n2/bD/N4tBAAZ/gJEdZU7KMraoK1+XYAg==} + engines: {node: '>= 0.10'} dependencies: forwarded: 0.2.0 ipaddr.js: 1.9.1 - proxy-from-env@1.1.0: {} + /proxy-from-env@1.1.0: + resolution: {integrity: sha512-D+zkORCbA9f1tdWRK0RaCR3GPv50cMxcrz4X8k5LTSUD1Dkw47mKJEZQNunItRTkWwgtaUSo1RVFRIG9ZXiFYg==} - pseudomap@1.0.2: {} + /pseudomap@1.0.2: + resolution: {integrity: sha512-b/YwNhb8lk1Zz2+bXXpS/LK9OisiZZ1SNsSLxN1x2OXVEhW2Ckr/7mWE5vrC1ZTiJlD9g19jWszTmJsB+oEpFQ==} + dev: true - psl@1.9.0: {} + /psl@1.9.0: + resolution: {integrity: sha512-E/ZsdU4HLs/68gYzgGTkMicWTLPdAftJLfJFlLUAAKZGkStNU72sZjT66SnMDVOfOWY/YAoiD7Jxa9iHvngcag==} - pump@3.0.0: + /pump@3.0.0: + resolution: {integrity: sha512-LwZy+p3SFs1Pytd/jYct4wpv49HiYCqd9Rlc5ZVdk0V+8Yzv6jR5Blk3TRmPL1ft69TxP0IMZGJ+WPFU2BFhww==} dependencies: end-of-stream: 1.4.4 once: 1.4.0 - punycode@2.1.0: {} + /punycode@2.1.0: + resolution: {integrity: sha512-Yxz2kRwT90aPiWEMHVYnEf4+rhwF1tBmmZ4KepCP+Wkium9JxtWnUm1nqGwpiAHr/tnTSeHqr3wb++jgSkXjhA==} + engines: {node: '>=6'} - punycode@2.3.1: {} + /punycode@2.3.1: + resolution: {integrity: sha512-vYt7UD1U9Wg6138shLtLOvdAu+8DsC/ilFtEVHcH+wydcSpNE20AfSOduf6MkRFahL5FY7X1oU7nKVZFtfq8Fg==} + engines: {node: '>=6'} - pure-rand@5.0.5: {} + /pure-rand@5.0.5: + resolution: {integrity: sha512-BwQpbqxSCBJVpamI6ydzcKqyFmnd5msMWUGvzXLm1aXvusbbgkbOto/EUPM00hjveJEaJtdbhUjKSzWRhQVkaw==} + dev: false - qs@6.11.0: + /qs@6.11.0: + resolution: {integrity: sha512-MvjoMCJwEarSbUYk5O+nmoSzSutSsTwF85zcHPQ9OrlFoZOYIjaqBAJIqIXjptyD5vThxGq52Xu/MaJzRkIk4Q==} + engines: {node: '>=0.6'} dependencies: side-channel: 1.0.6 - qs@6.12.1: + /qs@6.12.1: + resolution: {integrity: sha512-zWmv4RSuB9r2mYQw3zxQuHWeU+42aKi1wWig/j4ele4ygELZ7PEO6MM7rim9oAQH2A5MWfsAVf/jPvTPgCbvUQ==} + engines: {node: '>=0.6'} dependencies: side-channel: 1.0.6 + dev: true - qs@6.5.3: {} + /qs@6.5.3: + resolution: {integrity: sha512-qxXIEh4pCGfHICj1mAJQ2/2XVZkjCDTcEgfoSQxc/fYivUZxTkk7L3bDBJSoNrEzXI17oUO5Dp07ktqE5KzczA==} + engines: {node: '>=0.6'} - query-string@5.1.1: + /query-string@5.1.1: + resolution: {integrity: sha512-gjWOsm2SoGlgLEdAGt7a6slVOk9mGiXmPFMqrEhLQ68rhQuBnpfs3+EmlvqKyxnCo9/PPlF+9MtY02S1aFg+Jw==} + engines: {node: '>=0.10.0'} dependencies: decode-uri-component: 0.2.2 object-assign: 4.1.1 strict-uri-encode: 1.1.0 - queue-microtask@1.2.3: {} + /queue-microtask@1.2.3: + resolution: {integrity: sha512-NuaNSa6flKT5JaSYQzJok04JzTL1CA6aGhv5rfLW3PgqA+M2ChpZQnAC8h8i4ZFkBS8X5RqkDBHA7r4hej3K9A==} - quick-lru@4.0.1: {} + /quick-lru@4.0.1: + resolution: {integrity: sha512-ARhCpm70fzdcvNQfPoy49IaanKkTlRWF2JMzqhcJbhSFRZv7nPTvZJdcY7301IPmvW+/p0RgIWnQDLJxifsQ7g==} + engines: {node: '>=8'} + dev: true - quick-lru@5.1.1: {} + /quick-lru@5.1.1: + resolution: {integrity: sha512-WuyALRjWPDGtt/wzJiadO5AXY+8hZ80hVpe6MyivgraREW751X3SbhRvG3eLKOYN+8VEvqLcf3wdnt44Z4S4SA==} + engines: {node: '>=10'} - rambda@7.5.0: {} + /rambda@7.5.0: + resolution: {integrity: sha512-y/M9weqWAH4iopRd7EHDEQQvpFPHj1AA3oHozE9tfITHUtTR7Z9PSlIRRG2l1GuW7sefC1cXFfIcF+cgnShdBA==} + dev: true - randombytes@2.1.0: + /randombytes@2.1.0: + resolution: {integrity: sha512-vYl3iOX+4CKUWuxGi9Ukhie6fsqXqS9FE2Zaic4tNFD2N2QQaXOMFbuKK4QmDHC0JO6B1Zp41J0LpT0oR68amQ==} dependencies: safe-buffer: 5.2.1 - range-parser@1.2.1: {} + /range-parser@1.2.1: + resolution: {integrity: sha512-Hrgsx+orqoygnmhFbKaHE6c296J+HTAQXoxEF6gNupROmmGJRoyzfG3ccAveqCBrwr/2yxQ5BVd/GTl5agOwSg==} + engines: {node: '>= 0.6'} - raw-body@2.5.2: + /raw-body@2.5.2: + resolution: {integrity: sha512-8zGqypfENjCIqGhgXToC8aB2r7YrBX+AQAfIPs/Mlk+BtPTztOvTS01NRW/3Eh60J+a48lt8qsCzirQ6loCVfA==} + engines: {node: '>= 0.8'} dependencies: bytes: 3.1.2 http-errors: 2.0.0 iconv-lite: 0.4.24 unpipe: 1.0.0 - rc@1.2.8: + /rc@1.2.8: + resolution: {integrity: sha512-y3bGgqKj3QBdxLbLkomlohkvsA8gdAiUQlSBJnBhfn+BPxg4bc62d8TcBW15wavDfgexCgccckhcZvywyQYPOw==} + hasBin: true dependencies: deep-extend: 0.6.0 ini: 1.3.8 minimist: 1.2.8 strip-json-comments: 2.0.1 + dev: false - react-dom@18.3.1(react@18.3.1): + /react-dom@18.3.1(react@18.3.1): + resolution: {integrity: sha512-5m4nQKp+rZRb09LNH59GM4BxTh9251/ylbKIbpe7TpGxfJ+9kv6BLkLBXIjjspbgbnIBNqlI23tRnTWT0snUIw==} + peerDependencies: + react: ^18.3.1 dependencies: loose-envify: 1.4.0 react: 18.3.1 scheduler: 0.23.2 + dev: false - react-is@18.3.1: {} + /react-is@18.3.1: + resolution: {integrity: sha512-/LLMVyas0ljjAtoYiPqYiL8VWXzUUdThrmU5+n20DZv+a+ClRoevUzw5JxU+Ieh5/c87ytoTBV9G1FiKfNJdmg==} + dev: true - react@18.3.1: + /react@18.3.1: + resolution: {integrity: sha512-wS+hAgJShR0KhEvPJArfuPVN1+Hz1t0Y6n5jLrGQbkb4urgPE/0Rve+1kMB1v/oWgHgm4WIcV+i7F2pTVj+2iQ==} + engines: {node: '>=0.10.0'} dependencies: loose-envify: 1.4.0 + dev: false - read-pkg-up@1.0.1: + /read-pkg-up@1.0.1: + resolution: {integrity: sha512-WD9MTlNtI55IwYUS27iHh9tK3YoIVhxis8yKhLpTqWtml739uXc9NWTpxoHkfZf3+DkCCsXox94/VWZniuZm6A==} + engines: {node: '>=0.10.0'} dependencies: find-up: 1.1.2 read-pkg: 1.1.0 + dev: false - read-pkg-up@7.0.1: + /read-pkg-up@7.0.1: + resolution: {integrity: sha512-zK0TB7Xd6JpCLmlLmufqykGE+/TlOePD6qKClNW7hHDKFh/J7/7gCWGR7joEQEW1bKq3a3yUZSObOoWLFQ4ohg==} + engines: {node: '>=8'} dependencies: find-up: 4.1.0 read-pkg: 5.2.0 type-fest: 0.8.1 + dev: true - read-pkg@1.1.0: + /read-pkg@1.1.0: + resolution: {integrity: sha512-7BGwRHqt4s/uVbuyoeejRn4YmFnYZiFl4AuaeXHlgZf3sONF0SOGlxs2Pw8g6hCKupo08RafIO5YXFNOKTfwsQ==} + engines: {node: '>=0.10.0'} dependencies: load-json-file: 1.1.0 normalize-package-data: 2.5.0 path-type: 1.1.0 + dev: false - read-pkg@5.2.0: + /read-pkg@5.2.0: + resolution: {integrity: sha512-Ug69mNOpfvKDAc2Q8DRpMjjzdtrnv9HcSMX+4VsZxD1aZ6ZzrIE7rlzXBtWTyhULSMKg076AW6WR5iZpD0JiOg==} + engines: {node: '>=8'} dependencies: '@types/normalize-package-data': 2.4.4 normalize-package-data: 2.5.0 parse-json: 5.2.0 type-fest: 0.6.0 + dev: true - read-yaml-file@1.1.0: + /read-yaml-file@1.1.0: + resolution: {integrity: sha512-VIMnQi/Z4HT2Fxuwg5KrY174U1VdUIASQVWXXyqtNRtxSr9IYkn1rsI6Tb6HsrHCmB7gVpNwX6JxPTHcH6IoTA==} + engines: {node: '>=6'} dependencies: graceful-fs: 4.2.11 js-yaml: 3.14.1 pify: 4.0.1 strip-bom: 3.0.0 + dev: true - readable-stream@2.3.8: + /readable-stream@2.3.8: + resolution: {integrity: sha512-8p0AUk4XODgIewSi0l8Epjs+EVnWiK7NoDIEGU0HhE7+ZyY8D1IMY7odu5lRrFXGg71L15KG8QrPmum45RTtdA==} dependencies: core-util-is: 1.0.3 inherits: 2.0.4 @@ -12308,54 +9376,87 @@ snapshots: safe-buffer: 5.1.2 string_decoder: 1.1.1 util-deprecate: 1.0.2 + dev: true - readable-stream@3.6.2: + /readable-stream@3.6.2: + resolution: {integrity: sha512-9u/sniCrY3D5WdsERHzHE4G2YCXqoG5FTHUiCC4SIbr6XcLZBY05ya9EKjYek9O5xOAwjGq+1JdGBAS7Q9ScoA==} + engines: {node: '>= 6'} dependencies: inherits: 2.0.4 string_decoder: 1.3.0 util-deprecate: 1.0.2 - readdirp@3.6.0: + /readdirp@3.6.0: + resolution: {integrity: sha512-hOS089on8RduqdbhvQ5Z37A0ESjsqz6qnRcffsMU3495FuTdqSm+7bhJ29JvIOsBDEEnan5DPu9t3To9VRlMzA==} + engines: {node: '>=8.10.0'} dependencies: picomatch: 2.3.1 - rechoir@0.6.2: + /rechoir@0.6.2: + resolution: {integrity: sha512-HFM8rkZ+i3zrV+4LQjwQ0W+ez98pApMGM3HUrN04j3CqzPOzl9nmP15Y8YXNm8QHGv/eacOVEjqhmWpkRV0NAw==} + engines: {node: '>= 0.10'} dependencies: resolve: 1.17.0 + dev: true - recursive-readdir@2.2.3: + /recursive-readdir@2.2.3: + resolution: {integrity: sha512-8HrF5ZsXk5FAH9dgsx3BlUer73nIhuj+9OrQwEbLTPOBzGkL1lsFCR01am+v+0m2Cmbs1nP12hLDl5FA7EszKA==} + engines: {node: '>=6.0.0'} dependencies: minimatch: 3.1.2 + dev: true - redent@3.0.0: + /redent@3.0.0: + resolution: {integrity: sha512-6tDA8g98We0zd0GvVeMT9arEOnTw9qM03L9cJXaCjrip1OO764RDBLBfrB4cwzNGDj5OA5ioymC9GkizgWJDUg==} + engines: {node: '>=8'} dependencies: indent-string: 4.0.0 strip-indent: 3.0.0 + dev: true - reduce-flatten@2.0.0: {} + /reduce-flatten@2.0.0: + resolution: {integrity: sha512-EJ4UNY/U1t2P/2k6oqotuX2Cc3T6nxJwsM0N0asT7dhrtH1ltUxDn4NalSYmPE2rCkVpcf/X6R0wDwcFpzhd4w==} + engines: {node: '>=6'} + dev: true - regenerator-runtime@0.14.1: {} + /regenerator-runtime@0.14.1: + resolution: {integrity: sha512-dYnhHh0nJoMfnkZs6GmmhFknAGRrLznOu5nc9ML+EJxGvrx6H7teuevqVqCuPcPK//3eDrrjQhehXVx9cnkGdw==} - regexp.prototype.flags@1.5.2: + /regexp.prototype.flags@1.5.2: + resolution: {integrity: sha512-NcDiDkTLuPR+++OCKB0nWafEmhg/Da8aUPLPMQbK+bxKKCm1/S5he+AqYa4PlMCVBalb4/yxIRub6qkEx5yJbw==} + engines: {node: '>= 0.4'} dependencies: call-bind: 1.0.7 define-properties: 1.2.1 es-errors: 1.3.0 set-function-name: 2.0.2 + dev: true - release-zalgo@1.0.0: + /release-zalgo@1.0.0: + resolution: {integrity: sha512-gUAyHVHPPC5wdqX/LG4LWtRYtgjxyX78oanFNTMMyFEfOqdC54s3eE82imuWKbOeqYht2CrNf64Qb8vgmmtZGA==} + engines: {node: '>=4'} dependencies: es6-error: 4.1.1 + dev: true - req-cwd@2.0.0: + /req-cwd@2.0.0: + resolution: {integrity: sha512-ueoIoLo1OfB6b05COxAA9UpeoscNpYyM+BqYlA7H6LVF4hKGPXQQSSaD2YmvDVJMkk4UDpAHIeU1zG53IqjvlQ==} + engines: {node: '>=4'} dependencies: req-from: 2.0.0 + dev: true - req-from@2.0.0: + /req-from@2.0.0: + resolution: {integrity: sha512-LzTfEVDVQHBRfjOUMgNBA+V6DWsSnoeKzf42J7l0xa/B4jyPOuuF5MlNSmomLNGemWTnV2TIdjSSLnEn95fOQA==} + engines: {node: '>=4'} dependencies: resolve-from: 3.0.0 + dev: true - request@2.88.2: + /request@2.88.2: + resolution: {integrity: sha512-MsvtOrfG9ZcrOwAW+Qi+F6HbD0CWXEh9ou77uOb7FM2WPhwT7smM833PzanhJLsgXjN89Ir6V2PczXNnMpwKhw==} + engines: {node: '>= 6'} + deprecated: request has been deprecated, see https://github.com/request/request/issues/3142 dependencies: aws-sign2: 0.7.0 aws4: 1.12.0 @@ -12378,98 +9479,159 @@ snapshots: tunnel-agent: 0.6.0 uuid: 3.4.0 - require-directory@2.1.1: {} + /require-directory@2.1.1: + resolution: {integrity: sha512-fGxEI7+wsG9xrvdjsrlmL22OMTTiHRwAMroiEeMgq8gzoLC/PQr7RsRDSTLUg/bZAZtF+TVIkHc6/4RIKrui+Q==} + engines: {node: '>=0.10.0'} - require-from-string@1.2.1: {} + /require-from-string@1.2.1: + resolution: {integrity: sha512-H7AkJWMobeskkttHyhTVtS0fxpFLjxhbfMa6Bk3wimP7sdPRGL3EyCg3sAQenFfAe+xQ+oAc85Nmtvq0ROM83Q==} + engines: {node: '>=0.10.0'} + dev: false - require-from-string@2.0.2: {} + /require-from-string@2.0.2: + resolution: {integrity: sha512-Xf0nWe6RseziFMu+Ap9biiUbmplq6S9/p+7w7YXP/JBHhrUDDUhwa+vANyubuqfZWTveU//DYVGsDG7RKL/vEw==} + engines: {node: '>=0.10.0'} - require-main-filename@1.0.1: {} + /require-main-filename@1.0.1: + resolution: {integrity: sha512-IqSUtOVP4ksd1C/ej5zeEh/BIP2ajqpn8c5x+q99gvcIG/Qf0cud5raVnE/Dwd0ua9TXYDoDc0RE5hBSdz22Ug==} + dev: false - require-main-filename@2.0.0: {} + /require-main-filename@2.0.0: + resolution: {integrity: sha512-NKN5kMDylKuldxYLSUfrbo5Tuzh4hd+2E8NPPX02mZtn1VuREQToYe/ZdlJy+J3uCpfaiGF05e7B8W0iXbQHmg==} + dev: true - requireindex@1.2.0: {} + /requireindex@1.2.0: + resolution: {integrity: sha512-L9jEkOi3ASd9PYit2cwRfyppc9NoABujTP8/5gFcbERmo5jUoAKovIC3fsF17pkTnGsrByysqX+Kxd2OTNI1ww==} + engines: {node: '>=0.10.5'} + dev: false - resolve-alpn@1.2.1: {} + /resolve-alpn@1.2.1: + resolution: {integrity: sha512-0a1F4l73/ZFZOakJnQ3FvkJ2+gSTQWz/r2KE5OdDY0TxPm5h4GkqkWWfM47T7HsbnOtcJVEF4epCVy6u7Q3K+g==} - resolve-from@3.0.0: {} + /resolve-from@3.0.0: + resolution: {integrity: sha512-GnlH6vxLymXJNMBo7XP1fJIzBFbdYt49CuTwmB/6N53t+kMPRMFKz783LlQ4tv28XoQfMWinAJX6WCGf2IlaIw==} + engines: {node: '>=4'} + dev: true - resolve-from@4.0.0: {} + /resolve-from@4.0.0: + resolution: {integrity: sha512-pb/MYmXstAkysRFx8piNI1tGFNQIFA3vkE3Gq4EuA1dF6gHp/+vgZqsCGJapvy8N3Q+4o7FwvquPJcnZ7RYy4g==} + engines: {node: '>=4'} - resolve-from@5.0.0: {} + /resolve-from@5.0.0: + resolution: {integrity: sha512-qYg9KP24dD5qka9J47d0aVky0N+b4fTU89LN9iDnjB5waksiC49rvMB0PrUJQGoTmH50XPiqOvAjDfaijGxYZw==} + engines: {node: '>=8'} + dev: true - resolve-pkg-maps@1.0.0: {} + /resolve-pkg-maps@1.0.0: + resolution: {integrity: sha512-seS2Tj26TBVOC2NIc2rOe2y2ZO7efxITtLZcGSOnHHNOQ7CkiUBfw0Iw2ck6xkIhPwLhKNLS8BO+hEpngQlqzw==} + dev: true - resolve@1.1.7: {} + /resolve@1.1.7: + resolution: {integrity: sha512-9znBF0vBcaSN3W2j7wKvdERPwqTxSpCq+if5C0WoTCyV9n24rua28jeuQ2pL/HOf+yUe/Mef+H/5p60K0Id3bg==} + dev: true - resolve@1.17.0: + /resolve@1.17.0: + resolution: {integrity: sha512-ic+7JYiV8Vi2yzQGFWOkiZD5Z9z7O2Zhm9XMaTxdJExKasieFCr+yXZ/WmXsckHiKl12ar0y6XiXDx3m4RHn1w==} dependencies: path-parse: 1.0.7 - resolve@1.22.8: + /resolve@1.22.8: + resolution: {integrity: sha512-oKWePCxqpd6FlLvGV1VU0x7bkPmmCNolxzjMf4NczoDnQcIWrAF+cPtZn5i6n+RfD2d9i0tzpKnG6Yk168yIyw==} + hasBin: true dependencies: is-core-module: 2.13.1 path-parse: 1.0.7 supports-preserve-symlinks-flag: 1.0.0 - responselike@2.0.1: + /responselike@2.0.1: + resolution: {integrity: sha512-4gl03wn3hj1HP3yzgdI7d3lCkF95F21Pz4BPGvKHinyQzALR5CapwC8yIi0Rh58DEMQ/SguC03wFj2k0M/mHhw==} dependencies: lowercase-keys: 2.0.0 - restore-cursor@3.1.0: + /restore-cursor@3.1.0: + resolution: {integrity: sha512-l+sSefzHpj5qimhFSE5a8nufZYAM3sBSVMAPtYkmC+4EH2anSGaEMXSD0izRQbu9nfyQ9y5JrVmp7E8oZrUjvA==} + engines: {node: '>=8'} dependencies: onetime: 5.1.2 signal-exit: 3.0.7 + dev: false - reusify@1.0.4: {} + /reusify@1.0.4: + resolution: {integrity: sha512-U9nH88a3fc/ekCF1l0/UP1IosiuIjyTh7hBvXVMHYgVcfGvt897Xguj2UOLDeI5BG2m7/uwyaLVT6fbtCwTyzw==} + engines: {iojs: '>=1.0.0', node: '>=0.10.0'} - rimraf@2.7.1: + /rimraf@2.7.1: + resolution: {integrity: sha512-uWjbaKIK3T1OSVptzX7Nl6PvQ3qAGtKEtVRjRuazjfL3Bx5eI409VZSqgND+4UNnmzLVdPj9FqFJNPqBZFve4w==} + hasBin: true dependencies: glob: 7.2.0 + dev: false - rimraf@3.0.2: + /rimraf@3.0.2: + resolution: {integrity: sha512-JZkJMZkAGFFPP2YqXZXPbMlMBgsxzE8ILs4lMIX/2o0L9UBw9O/Y3o6wFw/i9YLapcUJWwqbi3kdxIPdC62TIA==} + hasBin: true dependencies: glob: 7.2.0 - ripemd160-min@0.0.6: {} + /ripemd160-min@0.0.6: + resolution: {integrity: sha512-+GcJgQivhs6S9qvLogusiTcS9kQUfgR75whKuy5jIhuiOfQuJ8fjqxV6EGD5duH1Y/FawFUMtMhyeq3Fbnib8A==} + engines: {node: '>=8'} + dev: false - ripemd160@2.0.2: + /ripemd160@2.0.2: + resolution: {integrity: sha512-ii4iagi25WusVoiC4B4lq7pbXfAp3D9v5CwfkY33vffw2+pkDjY1D8GaN7spsxvCSx8dkPqOZCEZyfxcmJG2IA==} dependencies: hash-base: 3.1.0 inherits: 2.0.4 - rlp@2.2.7: + /rlp@2.2.7: + resolution: {integrity: sha512-d5gdPmgQ0Z+AklL2NVXr/IoSjNZFfTVvQWzL/AM2AOcSzYP2xjlb0AC8YyCLc41MSNf6P6QVtjgPdmVtzb+4lQ==} + hasBin: true dependencies: bn.js: 5.2.1 - run-parallel@1.2.0: + /run-parallel@1.2.0: + resolution: {integrity: sha512-5l4VyZR86LZ/lDxZTR6jqL8AFE2S0IFLMP26AbjsLVADxHdhB/c0GUsH+y39UfCi3dzz8OlQuPmnaJOMoDHQBA==} dependencies: queue-microtask: 1.2.3 - rxjs@7.8.1: + /rxjs@7.8.1: + resolution: {integrity: sha512-AA3TVj+0A2iuIoQkWEK/tqFjBq2j+6PO6Y0zJcvzLAFhEFIO3HL0vls9hWLncZbAAbK0mar7oZ4V079I/qPMxg==} dependencies: tslib: 2.6.2 + dev: false - safe-array-concat@1.1.2: + /safe-array-concat@1.1.2: + resolution: {integrity: sha512-vj6RsCsWBCf19jIeHEfkRMw8DPiBb+DMXklQ/1SGDHOMlHdPUkZXFQ2YdplS23zESTijAcurb1aSgJA3AgMu1Q==} + engines: {node: '>=0.4'} dependencies: call-bind: 1.0.7 get-intrinsic: 1.2.4 has-symbols: 1.0.3 isarray: 2.0.5 + dev: true - safe-buffer@5.1.2: {} + /safe-buffer@5.1.2: + resolution: {integrity: sha512-Gd2UZBJDkXlY7GbJxfsE8/nvKkUEU1G38c1siN6QP6a9PT9MmHB8GnpscSmMJSoF8LOIrt8ud/wPtojys4G6+g==} - safe-buffer@5.2.1: {} + /safe-buffer@5.2.1: + resolution: {integrity: sha512-rp3So07KcdmmKbGvgaNxQSJr7bGVSVk5S9Eq1F+ppbRo70+YeaDxkw5Dd8NPN+GD6bjnYm2VuPuCXmpuYvmCXQ==} - safe-regex-test@1.0.3: + /safe-regex-test@1.0.3: + resolution: {integrity: sha512-CdASjNJPvRa7roO6Ra/gLYBTzYzzPyyBXxIMdGW3USQLyjWEls2RgW5UBTXaQVp+OrpeCK3bLem8smtmheoRuw==} + engines: {node: '>= 0.4'} dependencies: call-bind: 1.0.7 es-errors: 1.3.0 is-regex: 1.1.4 + dev: true - safer-buffer@2.1.2: {} + /safer-buffer@2.1.2: + resolution: {integrity: sha512-YZo3K82SD7Riyi0E1EQPojLz7kpepnSQI9IyPbHHg1XXXevb5dJI7tpyN2ADxGcQbHG7vcyRHk0cbwqcQriUtg==} - sc-istanbul@0.4.6: + /sc-istanbul@0.4.6: + resolution: {integrity: sha512-qJFF/8tW/zJsbyfh/iT/ZM5QNHE3CXxtLJbZsL+CzdJLBsPD7SedJZoUA4d8iAcN2IoMp/Dx80shOOd2x96X/g==} + hasBin: true dependencies: abbrev: 1.0.9 async: 1.5.2 @@ -12485,28 +9647,46 @@ snapshots: supports-color: 3.2.3 which: 1.3.1 wordwrap: 1.0.0 + dev: true - scheduler@0.23.2: + /scheduler@0.23.2: + resolution: {integrity: sha512-UOShsPwz7NrMUqhR6t0hWjFduvOzbtv7toDH1/hIrfRNIDBnnBWd0CwJTGvTpngVlmwGCdP9/Zl/tVrDqcuYzQ==} dependencies: loose-envify: 1.4.0 + dev: false - scrypt-js@2.0.4: {} + /scrypt-js@2.0.4: + resolution: {integrity: sha512-4KsaGcPnuhtCZQCxFxN3GVYIhKFPTdLd8PLC552XwbMndtD0cjRFAhDuuydXQ0h08ZfPgzqe6EKHozpuH74iDw==} + dev: false - scrypt-js@3.0.1: {} + /scrypt-js@3.0.1: + resolution: {integrity: sha512-cdwTTnqPu0Hyvf5in5asVdZocVDTNRmR7XEcJuIzMjJeSHybHl7vpB66AzwTaIg6CLSbtjcxc8fqcySfnTkccA==} - secp256k1@4.0.3: + /secp256k1@4.0.3: + resolution: {integrity: sha512-NLZVf+ROMxwtEj3Xa562qgv2BK5e2WNmXPiOdVIPLgs6lyTzMvBq0aWTYMI5XCP9jZMVKOcqZLw/Wc4vDkuxhA==} + engines: {node: '>=10.0.0'} + requiresBuild: true dependencies: elliptic: 6.5.5 node-addon-api: 2.0.2 node-gyp-build: 4.8.1 - semver@5.7.2: {} + /semver@5.7.2: + resolution: {integrity: sha512-cBznnQ9KjJqU67B52RMC65CMarK2600WFnbkcaiwWq3xy/5haFJlshgnpjovMVJ+Hff49d8GEn0b87C5pDQ10g==} + hasBin: true - semver@6.3.1: {} + /semver@6.3.1: + resolution: {integrity: sha512-BR7VvDCVHO+q2xBEWskxS6DJE1qRnb7DxzUrogb71CWoSficBxYsiAGd+Kl0mmq/MprG9yArRkyrQxTO6XjMzA==} + hasBin: true - semver@7.6.2: {} + /semver@7.6.2: + resolution: {integrity: sha512-FNAIBWCx9qcRhoHcgcJ0gvU7SN1lYU2ZXuSfl04bSC5OpvDHFyJCjdNHomPXxjQlCBU67YW64PzY7/VIEH7F2w==} + engines: {node: '>=10'} + hasBin: true - send@0.18.0: + /send@0.18.0: + resolution: {integrity: sha512-qqWzuOjSFOuqPjFe4NOsMLafToQQwBSOEpS+FwEt3A2V3vKubTquT3vmLTQpFgMXp8AlFWFuP1qKaJZOtPpVXg==} + engines: {node: '>= 0.8.0'} dependencies: debug: 2.6.9 depd: 2.0.0 @@ -12524,16 +9704,21 @@ snapshots: transitivePeerDependencies: - supports-color - sentence-case@2.1.1: + /sentence-case@2.1.1: + resolution: {integrity: sha512-ENl7cYHaK/Ktwk5OTD+aDbQ3uC8IByu/6Bkg+HDv8Mm+XnBnppVNalcfJTNsp1ibstKh030/JKQQWglDvtKwEQ==} dependencies: no-case: 2.3.2 upper-case-first: 1.1.2 + dev: false - serialize-javascript@6.0.0: + /serialize-javascript@6.0.0: + resolution: {integrity: sha512-Qr3TosvguFt8ePWqsvRfrKyQXIiW+nGbYpy8XK24NQHE83caxWt+mIymTT19DGFbNWNLfEwsrkSmN64lVWB9ag==} dependencies: randombytes: 2.1.0 - serve-static@1.15.0: + /serve-static@1.15.0: + resolution: {integrity: sha512-XGuRDNjXUijsUL0vl6nSD7cwURuzEgglbOaFuZM9g3kwDXOWVTck0jLzjPzGD+TazWbboZYu52/9/XPdUgne9g==} + engines: {node: '>= 0.8.0'} dependencies: encodeurl: 1.0.2 escape-html: 1.0.3 @@ -12542,7 +9727,9 @@ snapshots: transitivePeerDependencies: - supports-color - servify@0.1.12: + /servify@0.1.12: + resolution: {integrity: sha512-/xE6GvsKKqyo1BAY+KxOWXcLpPsUUyji7Qg3bVD7hh1eRze5bR1uYiuDA/k3Gof1s9BTzQZEJK8sNcNGFIzeWw==} + engines: {node: '>=6'} dependencies: body-parser: 1.20.2 cors: 2.8.5 @@ -12552,9 +9739,12 @@ snapshots: transitivePeerDependencies: - supports-color - set-blocking@2.0.0: {} + /set-blocking@2.0.0: + resolution: {integrity: sha512-KiKBS8AnWGEyLzofFfmvKwpdPzqiy16LvQfK3yv/fVH7Bj13/wl3JSR1J+rfgRE9q7xUJK4qvgS8raSOeLUehw==} - set-function-length@1.2.2: + /set-function-length@1.2.2: + resolution: {integrity: sha512-pgRc4hJ4/sNjWCSS9AmnS40x3bNMDTknHgL5UaMBTMyJnU90EgWh1Rz+MC9eFu4BuN/UwZjKQuY/1v3rM7HMfg==} + engines: {node: '>= 0.4'} dependencies: define-data-property: 1.1.4 es-errors: 1.3.0 @@ -12563,80 +9753,120 @@ snapshots: gopd: 1.0.1 has-property-descriptors: 1.0.2 - set-function-name@2.0.2: + /set-function-name@2.0.2: + resolution: {integrity: sha512-7PGFlmtwsEADb0WYyvCMa1t+yke6daIG4Wirafur5kcf+MhUnPms1UeR0CKQdTZD81yESwMHbtn+TR+dMviakQ==} + engines: {node: '>= 0.4'} dependencies: define-data-property: 1.1.4 es-errors: 1.3.0 functions-have-names: 1.2.3 has-property-descriptors: 1.0.2 + dev: true - setimmediate@1.0.4: {} + /setimmediate@1.0.4: + resolution: {integrity: sha512-/TjEmXQVEzdod/FFskf3o7oOAsGhHf2j1dZqRFbDzq4F3mvvxflIIi4Hd3bLQE9y/CpwqfSQam5JakI/mi3Pog==} + dev: false - setimmediate@1.0.5: {} + /setimmediate@1.0.5: + resolution: {integrity: sha512-MATJdZp8sLqDl/68LfQmbP8zKPLQNV6BIZoIgrscFDQ+RsvK/BxeDQOgyxKKoh0y/8h3BqVFnCqQ/gd+reiIXA==} - setprototypeof@1.2.0: {} + /setprototypeof@1.2.0: + resolution: {integrity: sha512-E5LDX7Wrp85Kil5bhZv46j8jOeboKq5JMmYM3gVGdGH8xFpPWXUMsNrlODCrkoxMEeNi/XZIwuRvY4XNwYMJpw==} - sha.js@2.4.11: + /sha.js@2.4.11: + resolution: {integrity: sha512-QMEp5B7cftE7APOjk5Y6xgrbWu+WkLVQwk8JNjZ8nKRciZaByEW6MubieAiToS7+dwvrjGhH8jRXz3MVd0AYqQ==} + hasBin: true dependencies: inherits: 2.0.4 safe-buffer: 5.2.1 - sha1@1.1.1: + /sha1@1.1.1: + resolution: {integrity: sha512-dZBS6OrMjtgVkopB1Gmo4RQCDKiZsqcpAQpkV/aaj+FCrCg8r4I4qMkDPQjBgLIxlmu9k4nUbWq6ohXahOneYA==} dependencies: charenc: 0.0.2 crypt: 0.0.2 + dev: true - sha3@2.1.4: + /sha3@2.1.4: + resolution: {integrity: sha512-S8cNxbyb0UGUM2VhRD4Poe5N58gJnJsLJ5vC7FYWGUmGhcsj4++WaIOBFVDxlG0W3To6xBuiRh+i0Qp2oNCOtg==} dependencies: buffer: 6.0.3 - shebang-command@1.2.0: + /shebang-command@1.2.0: + resolution: {integrity: sha512-EV3L1+UQWGor21OmnvojK36mhg+TyIKDh3iFBKBohr5xeXIhNBcx8oWdgkTEEQ+BEFFYdLRuqMfd5L84N1V5Vg==} + engines: {node: '>=0.10.0'} dependencies: shebang-regex: 1.0.0 + dev: true - shebang-command@2.0.0: + /shebang-command@2.0.0: + resolution: {integrity: sha512-kHxr2zZpYtdmrN1qDjrrX/Z1rR1kG8Dx+gkpK1G4eXmvXswmcE1hTWBWYUzlraYw1/yZp6YuDY77YtvbN0dmDA==} + engines: {node: '>=8'} dependencies: shebang-regex: 3.0.0 - shebang-regex@1.0.0: {} + /shebang-regex@1.0.0: + resolution: {integrity: sha512-wpoSFAxys6b2a2wHZ1XpDSgD7N9iVjg29Ph9uV/uaP9Ex/KXlkTZTeddxDPSYQpgvzKLGJke2UU0AzoGCjNIvQ==} + engines: {node: '>=0.10.0'} + dev: true - shebang-regex@3.0.0: {} + /shebang-regex@3.0.0: + resolution: {integrity: sha512-7++dFhtcx3353uBaq8DDR4NuxBetBzC7ZQOhmTQInHEd6bSrXdiEyzCvG07Z44UYdLShWUyXt5M/yhz8ekcb1A==} + engines: {node: '>=8'} - shelljs@0.8.5: + /shelljs@0.8.5: + resolution: {integrity: sha512-TiwcRcrkhHvbrZbnRcFYMLl30Dfov3HKqzp5tO5b4pt6G/SezKcYhmDg15zXVBswHmctSAQKznqNW2LO5tTDow==} + engines: {node: '>=4'} + hasBin: true dependencies: glob: 7.2.0 interpret: 1.4.0 rechoir: 0.6.2 + dev: true - side-channel@1.0.6: + /side-channel@1.0.6: + resolution: {integrity: sha512-fDW/EZ6Q9RiO8eFG8Hj+7u/oW+XrPTIChwCOM2+th2A6OblDtYYIpve9m+KvI9Z4C9qSEXlaGR6bTEYHReuglA==} + engines: {node: '>= 0.4'} dependencies: call-bind: 1.0.7 es-errors: 1.3.0 get-intrinsic: 1.2.4 object-inspect: 1.13.1 - signal-exit@3.0.7: {} + /signal-exit@3.0.7: + resolution: {integrity: sha512-wnD2ZE+l+SPC/uoS0vXeE9L1+0wuaMqKlfz9AMUo38JsyLSBWSFcHR1Rri62LZc12vLr1gb3jl7iwQhgwpAbGQ==} - simple-concat@1.0.1: {} + /simple-concat@1.0.1: + resolution: {integrity: sha512-cSFtAPtRhljv69IK0hTVZQ+OfE9nePi/rtJmw5UjHeVyVroEqJXP1sFztKUy1qU+xvz3u/sfYJLa947b7nAN2Q==} - simple-get@2.8.2: + /simple-get@2.8.2: + resolution: {integrity: sha512-Ijd/rV5o+mSBBs4F/x9oDPtTx9Zb6X9brmnXvMW4J7IR15ngi9q5xxqWBKU744jTZiaXtxaPL7uHG6vtN8kUkw==} dependencies: decompress-response: 3.3.0 once: 1.4.0 simple-concat: 1.0.1 - simple-get@4.0.1: + /simple-get@4.0.1: + resolution: {integrity: sha512-brv7p5WgH0jmQJr1ZDDfKDOSeWWg+OVypG99A/5vYGPqJ6pxiaHLy8nxtFjBA7oMa01ebA9gfh1uMCFqOuXxvA==} dependencies: decompress-response: 6.0.0 once: 1.4.0 simple-concat: 1.0.1 + dev: false - sinon-chai@3.7.0(chai@4.4.1)(sinon@9.2.4): + /sinon-chai@3.7.0(chai@4.4.1)(sinon@9.2.4): + resolution: {integrity: sha512-mf5NURdUaSdnatJx3uhoBOrY9dtL19fiOtAdT1Azxg3+lNJFiuN0uzaU3xX1LeAfL17kHQhTAJgpsfhbMJMY2g==} + peerDependencies: + chai: ^4.0.0 + sinon: '>=4.0.0' dependencies: chai: 4.4.1 sinon: 9.2.4 + dev: true - sinon@9.2.4: + /sinon@9.2.4: + resolution: {integrity: sha512-zljcULZQsJxVra28qIAL6ow1Z9tpattkCTEJR4RBP3TGc00FcttsP5pK284Nas5WjMZU5Yzy3kAIp3B3KRf5Yg==} + deprecated: 16.1.1 dependencies: '@sinonjs/commons': 1.8.6 '@sinonjs/fake-timers': 6.0.1 @@ -12644,18 +9874,29 @@ snapshots: diff: 4.0.2 nise: 4.1.0 supports-color: 7.2.0 + dev: true - sisteransi@1.0.5: {} + /sisteransi@1.0.5: + resolution: {integrity: sha512-bLGGlR1QxBcynn2d5YmDX4MGjlZvy2MRBDRNHLJ8VI6l6+9FUiyTFNJ0IveOSP0bcXgVDPRcfGqA0pjaqUpfVg==} + dev: true - slash@3.0.0: {} + /slash@3.0.0: + resolution: {integrity: sha512-g9Q1haeby36OSStwb4ntCGGGaKsaVSjQ68fBxoQcutl5fS1vuY18H3wSt3jFyFtrkx+Kz0V1G85A4MyAdDMi2Q==} + engines: {node: '>=8'} - slice-ansi@4.0.0: + /slice-ansi@4.0.0: + resolution: {integrity: sha512-qMCMfhY040cVHT43K9BFygqYbUPFZKHOg7K73mtTWJRb8pyP3fzf4Ixd5SzdEJQ6MRUg/WBnOLxghZtKKurENQ==} + engines: {node: '>=10'} dependencies: ansi-styles: 4.3.0 astral-regex: 2.0.0 is-fullwidth-code-point: 3.0.0 + dev: false - smartwrap@2.0.2: + /smartwrap@2.0.2: + resolution: {integrity: sha512-vCsKNQxb7PnCNd2wY1WClWifAc2lwqsG8OaswpJkVJsvMGcnEntdTCDajZCkk93Ay1U3t/9puJmb525Rg5MZBA==} + engines: {node: '>=6'} + hasBin: true dependencies: array.prototype.flat: 1.3.2 breakword: 1.0.6 @@ -12663,20 +9904,29 @@ snapshots: strip-ansi: 6.0.1 wcwidth: 1.0.1 yargs: 15.4.1 + dev: true - snake-case@2.1.0: + /snake-case@2.1.0: + resolution: {integrity: sha512-FMR5YoPFwOLuh4rRz92dywJjyKYZNLpMn1R5ujVpIYkbA9p01fq8RMg0FkO4M+Yobt4MjHeLTJVm5xFFBHSV2Q==} dependencies: no-case: 2.3.2 + dev: false - solc@0.4.26: + /solc@0.4.26: + resolution: {integrity: sha512-o+c6FpkiHd+HPjmjEVpQgH7fqZ14tJpXhho+/bQXlXbliLIS/xjXb42Vxh+qQY1WCSTMQ0+a5vR9vi0MfhU6mA==} + hasBin: true dependencies: fs-extra: 0.30.0 memorystream: 0.3.1 require-from-string: 1.2.1 semver: 5.7.2 yargs: 4.8.1 + dev: false - solc@0.7.3(debug@4.3.4): + /solc@0.7.3(debug@4.3.4): + resolution: {integrity: sha512-GAsWNAjGzIDg7VxzP6mPjdurby3IkGCjQcM8GFYZT6RyaoUZKmMU6Y7YwG+tFGhv7dwZ8rmR4iwFDrrD99JwqA==} + engines: {node: '>=8.0.0'} + hasBin: true dependencies: command-exists: 1.2.9 commander: 3.0.2 @@ -12689,8 +9939,11 @@ snapshots: tmp: 0.0.33 transitivePeerDependencies: - debug + dev: false - solhint@3.6.2(typescript@5.0.4): + /solhint@3.6.2(typescript@5.0.4): + resolution: {integrity: sha512-85EeLbmkcPwD+3JR7aEMKsVC9YrRSxd4qkXuMzrlf7+z2Eqdfm1wHWq1ffTuo5aDhoZxp2I9yF3QkxZOxOL7aQ==} + hasBin: true dependencies: '@solidity-parser/parser': 0.16.2 ajv: 6.12.6 @@ -12713,8 +9966,13 @@ snapshots: prettier: 2.8.8 transitivePeerDependencies: - typescript + dev: false - solidity-coverage@0.8.12(hardhat@packages+hardhat-core): + /solidity-coverage@0.8.12(hardhat@packages+hardhat-core): + resolution: {integrity: sha512-8cOB1PtjnjFRqOgwFiD8DaUsYJtVJ6+YdXQtSZDrLGf8cdhhh8xzTtGzVTGeBf15kTv0v7lYPJlV/az7zLEPJw==} + hasBin: true + peerDependencies: + hardhat: ^2.11.0 dependencies: '@ethersproject/abi': 5.7.0 '@solidity-parser/parser': 0.18.0 @@ -12736,8 +9994,12 @@ snapshots: semver: 7.6.2 shelljs: 0.8.5 web3-utils: 1.10.4 + dev: true - solpp@0.11.5: + /solpp@0.11.5: + resolution: {integrity: sha512-LjzCGMrTDXtera2C4mbQGZSpBznP+o3/82L2CneAAMNbm+t4xPsvfrgJkIaY+IZ5YLrB8IXn7cYthwHMKvAWnQ==} + engines: {node: '>=8.15.1'} + hasBin: true dependencies: antlr4: 4.8.0 axios: 0.21.4 @@ -12750,20 +10012,31 @@ snapshots: semver: 5.7.2 transitivePeerDependencies: - debug + dev: false - source-map-support@0.5.21: + /source-map-support@0.5.21: + resolution: {integrity: sha512-uBHU3L3czsIyYXKX88fdrGovxdSCoTGDRZ6SYXtSRxLZUzHg5P/66Ht6uoUlHu9EZod+inXhKo3qQgwXUT/y1w==} dependencies: buffer-from: 1.1.2 source-map: 0.6.1 + dev: false - source-map@0.2.0: + /source-map@0.2.0: + resolution: {integrity: sha512-CBdZ2oa/BHhS4xj5DlhjWNHcan57/5YuvfdLf17iVmIpd9KRm+DFLmC6nBNj+6Ua7Kt3TmOjDpQT1aTYOQtoUA==} + engines: {node: '>=0.8.0'} + requiresBuild: true dependencies: amdefine: 1.0.1 + dev: true optional: true - source-map@0.6.1: {} + /source-map@0.6.1: + resolution: {integrity: sha512-UjgapumWlbMhkBgzT7Ykc5YXUT46F0iKu8SGXq0bcwP5dz/h0Plj6enJqjz1Zbq2l5WaqYnrVbwWOWMyF3F47g==} + engines: {node: '>=0.10.0'} - spawn-wrap@2.0.0: + /spawn-wrap@2.0.0: + resolution: {integrity: sha512-EeajNjfN9zMnULLwhZZQU3GWBoFNkbngTUPfaawT4RkMiviTxcX0qfhVbGey39mfctfDHkWtuecgQ8NJcyQWHg==} + engines: {node: '>=8'} dependencies: foreground-child: 2.0.0 is-windows: 1.0.2 @@ -12771,33 +10044,47 @@ snapshots: rimraf: 3.0.2 signal-exit: 3.0.7 which: 2.0.2 + dev: true - spawndamnit@2.0.0: + /spawndamnit@2.0.0: + resolution: {integrity: sha512-j4JKEcncSjFlqIwU5L/rp2N5SIPsdxaRsIv678+TZxZ0SRDJTm8JrxJMjE/XuiEZNEir3S8l0Fa3Ke339WI4qA==} dependencies: cross-spawn: 5.1.0 signal-exit: 3.0.7 + dev: true - spdx-correct@3.2.0: + /spdx-correct@3.2.0: + resolution: {integrity: sha512-kN9dJbvnySHULIluDHy32WHRUu3Og7B9sbY7tsFLctQkIqnMh3hErYgdMjTYuqmcXX+lK5T1lnUt3G7zNswmZA==} dependencies: spdx-expression-parse: 3.0.1 spdx-license-ids: 3.0.17 - spdx-exceptions@2.5.0: {} + /spdx-exceptions@2.5.0: + resolution: {integrity: sha512-PiU42r+xO4UbUS1buo3LPJkjlO7430Xn5SVAhdpzzsPHsjbYVflnnFdATgabnLude+Cqu25p6N+g2lw/PFsa4w==} - spdx-expression-parse@3.0.1: + /spdx-expression-parse@3.0.1: + resolution: {integrity: sha512-cbqHunsQWnJNE6KhVSMsMeH5H/L9EpymbzqTQ3uLwNCLZ1Q481oWaofqH7nO6V07xlXwY6PhQdQ2IedWx/ZK4Q==} dependencies: spdx-exceptions: 2.5.0 spdx-license-ids: 3.0.17 - spdx-license-ids@3.0.17: {} + /spdx-license-ids@3.0.17: + resolution: {integrity: sha512-sh8PWc/ftMqAAdFiBu6Fy6JUOYjqDJBJvIhpfDMyHrr0Rbp5liZqd4TjtQ/RgfLjKFZb+LMx5hpml5qOWy0qvg==} - split2@3.2.2: + /split2@3.2.2: + resolution: {integrity: sha512-9NThjpgZnifTkJpzTZ7Eue85S49QwpNhZTq6GRJwObb6jnLFNGB7Qm73V5HewTROPyxD0C29xqmaI68bQtV+hg==} dependencies: readable-stream: 3.6.2 + dev: true - sprintf-js@1.0.3: {} + /sprintf-js@1.0.3: + resolution: {integrity: sha512-D9cPgkvLlV3t3IzL0D0YLvGA9Ahk4PcvVwUbN0dSGr1aP0Nrt4AEnTUbuGvquEC0mA64Gqt1fzirlRs5ibXx8g==} + dev: true - sshpk@1.18.0: + /sshpk@1.18.0: + resolution: {integrity: sha512-2p2KJZTSqQ/I3+HX42EpYOa2l3f8Erv8MWKsy2I9uf4wA7yFIkXRffYdsx86y6z4vHtV8u7g+pPlr8/4ouAxsQ==} + engines: {node: '>=0.10.0'} + hasBin: true dependencies: asn1: 0.2.6 assert-plus: 1.0.0 @@ -12809,128 +10096,205 @@ snapshots: safer-buffer: 2.1.2 tweetnacl: 0.14.5 - stacktrace-parser@0.1.10: + /stacktrace-parser@0.1.10: + resolution: {integrity: sha512-KJP1OCML99+8fhOHxwwzyWrlUuVX5GQ0ZpJTd1DFXhdkrvg1szxfHhawXUZ3g9TkXORQd4/WG68jMlQZ2p8wlg==} + engines: {node: '>=6'} dependencies: type-fest: 0.7.1 + dev: false - statuses@2.0.1: {} + /statuses@2.0.1: + resolution: {integrity: sha512-RwNA9Z/7PrK06rYLIzFMlaF+l73iwpzsqRIFgbMLbTcLD6cOao82TaWefPXQvB2fOC4AjuYSEndS7N/mTCbkdQ==} + engines: {node: '>= 0.8'} - stream-transform@2.1.3: + /stream-transform@2.1.3: + resolution: {integrity: sha512-9GHUiM5hMiCi6Y03jD2ARC1ettBXkQBoQAe7nJsPknnI0ow10aXjTnew8QtYQmLjzn974BnmWEAJgCY6ZP1DeQ==} dependencies: mixme: 0.5.10 + dev: true - strict-uri-encode@1.1.0: {} + /strict-uri-encode@1.1.0: + resolution: {integrity: sha512-R3f198pcvnB+5IpnBlRkphuE9n46WyVl8I39W/ZUTZLz4nqSP/oLYUrcnJrw462Ds8he4YKMov2efsTIw1BDGQ==} + engines: {node: '>=0.10.0'} - string-format@2.0.0: {} + /string-format@2.0.0: + resolution: {integrity: sha512-bbEs3scLeYNXLecRRuk6uJxdXUSj6le/8rNPHChIJTn2V79aXVTR1EH2OH5zLKKoz0V02fOUKZZcw01pLUShZA==} + dev: true - string-width@1.0.2: + /string-width@1.0.2: + resolution: {integrity: sha512-0XsVpQLnVCXHJfyEs8tC0zpTVIr5PKKsQtkT29IwupnPTjtPmQ3xT/4yCREF9hYkV/3M3kzcUTSAZT6a6h81tw==} + engines: {node: '>=0.10.0'} dependencies: code-point-at: 1.1.0 is-fullwidth-code-point: 1.0.0 strip-ansi: 3.0.1 + dev: false - string-width@2.1.1: + /string-width@2.1.1: + resolution: {integrity: sha512-nOqH59deCq9SRHlxq1Aw85Jnt4w6KvLKqWVik6oA9ZklXLNIOlqg4F2yrT1MVaTjAqvVwdfeZ7w7aCvJD7ugkw==} + engines: {node: '>=4'} dependencies: is-fullwidth-code-point: 2.0.0 strip-ansi: 4.0.0 + dev: true - string-width@4.2.3: + /string-width@4.2.3: + resolution: {integrity: sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g==} + engines: {node: '>=8'} dependencies: emoji-regex: 8.0.0 is-fullwidth-code-point: 3.0.0 strip-ansi: 6.0.1 - string.prototype.trim@1.2.9: + /string.prototype.trim@1.2.9: + resolution: {integrity: sha512-klHuCNxiMZ8MlsOihJhJEBJAiMVqU3Z2nEXWfWnIqjN0gEFS9J9+IxKozWWtQGcgoa1WUZzLjKPTr4ZHNFTFxw==} + engines: {node: '>= 0.4'} dependencies: call-bind: 1.0.7 define-properties: 1.2.1 es-abstract: 1.23.3 es-object-atoms: 1.0.0 + dev: true - string.prototype.trimend@1.0.8: + /string.prototype.trimend@1.0.8: + resolution: {integrity: sha512-p73uL5VCHCO2BZZ6krwwQE3kCzM7NKmis8S//xEC6fQonchbum4eP6kR4DLEjQFO3Wnj3Fuo8NM0kOSjVdHjZQ==} dependencies: call-bind: 1.0.7 define-properties: 1.2.1 es-object-atoms: 1.0.0 + dev: true - string.prototype.trimstart@1.0.8: + /string.prototype.trimstart@1.0.8: + resolution: {integrity: sha512-UXSH262CSZY1tfu3G3Secr6uGLCFVPMhIqHjlgCUtCCcgihYc/xKs9djMTMUOb2j1mVSeU8EU6NWc/iQKU6Gfg==} + engines: {node: '>= 0.4'} dependencies: call-bind: 1.0.7 define-properties: 1.2.1 es-object-atoms: 1.0.0 + dev: true - string_decoder@1.1.1: + /string_decoder@1.1.1: + resolution: {integrity: sha512-n/ShnvDi6FHbbVfviro+WojiFzv+s8MPMHBczVePfUpDJLwoLT0ht1l4YwBCbi8pJAveEEdnkHyPyTP/mzRfwg==} dependencies: safe-buffer: 5.1.2 + dev: true - string_decoder@1.3.0: + /string_decoder@1.3.0: + resolution: {integrity: sha512-hkRX8U1WjJFd8LsDJ2yQ/wWWxaopEsABU1XfkM8A+j0+85JAGppt16cr1Whg6KIbb4okU6Mql6BOj+uup/wKeA==} dependencies: safe-buffer: 5.2.1 - strip-ansi@0.1.1: {} + /strip-ansi@0.1.1: + resolution: {integrity: sha512-behete+3uqxecWlDAm5lmskaSaISA+ThQ4oNNBDTBJt0x2ppR6IPqfZNuj6BLaLJ/Sji4TPZlcRyOis8wXQTLg==} + engines: {node: '>=0.8.0'} + hasBin: true + dev: true - strip-ansi@3.0.1: + /strip-ansi@3.0.1: + resolution: {integrity: sha512-VhumSSbBqDTP8p2ZLKj40UjBCV4+v8bUSEpUb4KjRgWk9pbqGF4REFj6KEagidb2f/M6AzC0EmFyDNGaw9OCzg==} + engines: {node: '>=0.10.0'} dependencies: ansi-regex: 2.1.1 + dev: false - strip-ansi@4.0.0: + /strip-ansi@4.0.0: + resolution: {integrity: sha512-4XaJ2zQdCzROZDivEVIDPkcQn8LMFSa8kj8Gxb/Lnwzv9A8VctNZ+lfivC/sV3ivW8ElJTERXZoPBRrZKkNKow==} + engines: {node: '>=4'} dependencies: ansi-regex: 3.0.1 - strip-ansi@6.0.1: + /strip-ansi@6.0.1: + resolution: {integrity: sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A==} + engines: {node: '>=8'} dependencies: ansi-regex: 5.0.1 - strip-bom@2.0.0: + /strip-bom@2.0.0: + resolution: {integrity: sha512-kwrX1y7czp1E69n2ajbG65mIo9dqvJ+8aBQXOGVxqwvNbsXdFM6Lq37dLAY3mknUwru8CfcCbfOLL/gMo+fi3g==} + engines: {node: '>=0.10.0'} dependencies: is-utf8: 0.2.1 + dev: false - strip-bom@3.0.0: {} + /strip-bom@3.0.0: + resolution: {integrity: sha512-vavAMRXOgBVNF6nyEEmL3DBK19iRpDcoIwW+swQ+CbGiu7lju6t+JklA1MHweoWtadgt4ISVUsXLyDq34ddcwA==} + engines: {node: '>=4'} + dev: true - strip-bom@4.0.0: {} + /strip-bom@4.0.0: + resolution: {integrity: sha512-3xurFv5tEgii33Zi8Jtp55wEIILR9eh34FAW00PZf+JnSsTmV/ioewSgQl97JHvgjoRGwPShsWm+IdrxB35d0w==} + engines: {node: '>=8'} + dev: true - strip-hex-prefix@1.0.0: + /strip-hex-prefix@1.0.0: + resolution: {integrity: sha512-q8d4ue7JGEiVcypji1bALTos+0pWtyGlivAWyPuTkHzuTCJqrK9sWxYQZUq6Nq3cuyv3bm734IhHvHtGGURU6A==} + engines: {node: '>=6.5.0', npm: '>=3'} dependencies: is-hex-prefixed: 1.0.0 - strip-indent@2.0.0: {} + /strip-indent@2.0.0: + resolution: {integrity: sha512-RsSNPLpq6YUL7QYy44RnPVTn/lcVZtb48Uof3X5JLbF4zD/Gs7ZFDv2HWol+leoQN2mT86LAzSshGfkTlSOpsA==} + engines: {node: '>=4'} + dev: false - strip-indent@3.0.0: + /strip-indent@3.0.0: + resolution: {integrity: sha512-laJTa3Jb+VQpaC6DseHhF7dXVqHTfJPCRDaEbid/drOhgitgYku/letMUqOXFoWV0zIIUbjpdH2t+tYj4bQMRQ==} + engines: {node: '>=8'} dependencies: min-indent: 1.0.1 + dev: true - strip-json-comments@2.0.1: {} + /strip-json-comments@2.0.1: + resolution: {integrity: sha512-4gB8na07fecVVkOI6Rs4e7T6NOTki5EmL7TUduTs6bu3EdnSycntVJ4re8kgZA+wx9IueI2Y11bfbgwtzuE0KQ==} + engines: {node: '>=0.10.0'} + dev: false - strip-json-comments@3.1.1: {} + /strip-json-comments@3.1.1: + resolution: {integrity: sha512-6fPc+R4ihwqP6N/aIv2f1gMH8lOVtWQHoqC4yK6oSDVVocumAsfCqjkXnqiYMhmMwS/mEHLp7Vehlt3ql6lEig==} + engines: {node: '>=8'} - supports-color@3.2.3: + /supports-color@3.2.3: + resolution: {integrity: sha512-Jds2VIYDrlp5ui7t8abHN2bjAu4LV/q4N2KivFPpGH0lrka0BMq/33AmECUXlKPcHigkNaqfXRENFju+rlcy+A==} + engines: {node: '>=0.8.0'} dependencies: has-flag: 1.0.0 + dev: true - supports-color@5.5.0: + /supports-color@5.5.0: + resolution: {integrity: sha512-QjVjwdXIt408MIiAqCX4oUKsgU2EqAGzs2Ppkm4aQYbjm+ZEWEcW4SfFNTr4uMNZma0ey4f5lgLrkB0aX0QMow==} + engines: {node: '>=4'} dependencies: has-flag: 3.0.0 - supports-color@7.2.0: + /supports-color@7.2.0: + resolution: {integrity: sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw==} + engines: {node: '>=8'} dependencies: has-flag: 4.0.0 - supports-color@8.1.1: + /supports-color@8.1.1: + resolution: {integrity: sha512-MpUEN2OodtUzxvKQl72cUF7RQ5EiHsGvSsVG0ia9c5RbWGL2CI4C7EpPS8UTBIplnlzZiNuV56w+FuNxy3ty2Q==} + engines: {node: '>=10'} dependencies: has-flag: 4.0.0 - supports-preserve-symlinks-flag@1.0.0: {} + /supports-preserve-symlinks-flag@1.0.0: + resolution: {integrity: sha512-ot0WnXS9fgdkgIcePe6RHNk1WA8+muPa6cSjeR3V8K27q9BB1rTE3R1p7Hv0z1ZyAc8s6Vvv8DIyWf681MAt0w==} + engines: {node: '>= 0.4'} - swap-case@1.1.2: + /swap-case@1.1.2: + resolution: {integrity: sha512-BAmWG6/bx8syfc6qXPprof3Mn5vQgf5dwdUNJhsNqU9WdPt5P+ES/wQ5bxfijy8zwZgZZHslC3iAsxsuQMCzJQ==} dependencies: lower-case: 1.1.4 upper-case: 1.1.3 + dev: false - swarm-js@0.1.42(bufferutil@4.0.8)(utf-8-validate@5.0.10): + /swarm-js@0.1.42: + resolution: {integrity: sha512-BV7c/dVlA3R6ya1lMlSSNPLYrntt0LUq4YMgy3iwpCIc6rZnS5W2wUoctarZ5pXlpKtxDDf9hNziEkcfrxdhqQ==} dependencies: bluebird: 3.7.2 buffer: 5.7.1 - eth-lib: 0.1.29(bufferutil@4.0.8)(utf-8-validate@5.0.10) + eth-lib: 0.1.29 fs-extra: 4.0.3 got: 11.8.6 mime-types: 2.1.35 @@ -12944,47 +10308,65 @@ snapshots: - supports-color - utf-8-validate - sync-request@6.1.0: + /sync-request@6.1.0: + resolution: {integrity: sha512-8fjNkrNlNCrVc/av+Jn+xxqfCjYaBoHqCsDz6mt030UMxJGr+GSfCV1dQt2gRtlL63+VPidwDVLr7V2OcTSdRw==} + engines: {node: '>=8.0.0'} dependencies: http-response-object: 3.0.2 sync-rpc: 1.3.6 then-request: 6.0.2 + dev: true - sync-rpc@1.3.6: + /sync-rpc@1.3.6: + resolution: {integrity: sha512-J8jTXuZzRlvU7HemDgHi3pGnh/rkoqR/OZSjhTyyZrEkkYQbk7Z33AXp37mkPfPpfdOuj7Ex3H/TJM1z48uPQw==} dependencies: get-port: 3.2.0 + dev: true - table-layout@1.0.2: + /table-layout@1.0.2: + resolution: {integrity: sha512-qd/R7n5rQTRFi+Zf2sk5XVVd9UQl6ZkduPFC3S7WEGJAmetDTjY3qPN50eSKzwuzEyQKy5TN2TiZdkIjos2L6A==} + engines: {node: '>=8.0.0'} dependencies: array-back: 4.0.2 deep-extend: 0.6.0 typical: 5.2.0 wordwrapjs: 4.0.1 + dev: true - table@6.8.2: + /table@6.8.2: + resolution: {integrity: sha512-w2sfv80nrAh2VCbqR5AK27wswXhqcck2AhfnNW76beQXskGZ1V12GwS//yYVa3d3fcvAip2OUnbDAjW2k3v9fA==} + engines: {node: '>=10.0.0'} dependencies: ajv: 8.13.0 lodash.truncate: 4.4.2 slice-ansi: 4.0.0 string-width: 4.2.3 strip-ansi: 6.0.1 + dev: false - tar-fs@2.1.1: + /tar-fs@2.1.1: + resolution: {integrity: sha512-V0r2Y9scmbDRLCNex/+hYzvp/zyYjvFbHPNgVTKfQvVrb6guiE/fxP+XblDNR011utopbkex2nM4dHNV6GDsng==} dependencies: chownr: 1.1.4 mkdirp-classic: 0.5.3 pump: 3.0.0 tar-stream: 2.2.0 + dev: false - tar-stream@2.2.0: + /tar-stream@2.2.0: + resolution: {integrity: sha512-ujeqbceABgwMZxEJnk2HDY2DlnUZ+9oEcb1KzTVfYHio0UE6dG71n60d8D2I4qNvleWrrXpmjpt7vZeF1LnMZQ==} + engines: {node: '>=6'} dependencies: bl: 4.1.0 end-of-stream: 1.4.4 fs-constants: 1.0.0 inherits: 2.0.4 readable-stream: 3.6.2 + dev: false - tar@4.4.19: + /tar@4.4.19: + resolution: {integrity: sha512-a20gEsvHnWe0ygBY8JbxoM4w3SJdhc7ZAuxkLqh+nvNQN2IOt0B5lLgM490X5Hl8FF0dl0tOf2ewFYAlIFgzVA==} + engines: {node: '>=4.5'} dependencies: chownr: 1.1.4 fs-minipass: 1.2.7 @@ -12994,19 +10376,31 @@ snapshots: safe-buffer: 5.2.1 yallist: 3.1.1 - term-size@2.2.1: {} + /term-size@2.2.1: + resolution: {integrity: sha512-wK0Ri4fOGjv/XPy8SBHZChl8CM7uMc5VML7SqiQ0zG7+J5Vr+RMQDoHa2CNT6KHUnTGIXH34UDMkPzAUyapBZg==} + engines: {node: '>=8'} + dev: true - test-exclude@6.0.0: + /test-exclude@6.0.0: + resolution: {integrity: sha512-cAGWPIyOHU6zlmg88jwm7VRyXnMN7iV68OGAbYDk/Mh/xC/pzVPlQtY6ngoIH/5/tciuhGfvESU8GrHrcxD56w==} + engines: {node: '>=8'} dependencies: '@istanbuljs/schema': 0.1.3 glob: 7.2.0 minimatch: 3.1.2 + dev: true - testrpc@0.0.1: {} + /testrpc@0.0.1: + resolution: {integrity: sha512-afH1hO+SQ/VPlmaLUFj2636QMeDvPCeQMc/9RBMW0IfjNe9gFD9Ra3ShqYkB7py0do1ZcCna/9acHyzTJ+GcNA==} + deprecated: testrpc has been renamed to ganache-cli, please use this package from now on. + dev: false - text-table@0.2.0: {} + /text-table@0.2.0: + resolution: {integrity: sha512-N+8UisAXDGk8PFXP4HAzVR9nbfmVJ3zYLAWiTIoqC5v5isinhr+r5uaO8+7r3BMfuNIufIsA7RdpVgacC2cSpw==} - then-request@6.0.2: + /then-request@6.0.2: + resolution: {integrity: sha512-3ZBiG7JvP3wbDzA9iNY5zJQcHL4jn/0BWtXIkagfz7QgOL/LqjCEOBQuJNZfu0XYnv5JhKh+cDxCPM4ILrqruA==} + engines: {node: '>=6.0.0'} dependencies: '@types/concat-stream': 1.6.1 '@types/form-data': 0.0.33 @@ -13019,65 +10413,103 @@ snapshots: http-response-object: 3.0.2 promise: 8.3.0 qs: 6.12.1 + dev: true - thenify-all@1.6.0: + /thenify-all@1.6.0: + resolution: {integrity: sha512-RNxQH/qI8/t3thXJDwcstUO4zeqo64+Uy/+sNVRBx4Xn2OX+OZ9oP+iJnNFqplFra2ZUVeKCSa2oVWi3T4uVmA==} + engines: {node: '>=0.8'} dependencies: thenify: 3.3.1 + dev: false - thenify@3.3.1: + /thenify@3.3.1: + resolution: {integrity: sha512-RVZSIV5IG10Hk3enotrhvz0T9em6cyHBLkH/YAZuKqd8hRkKhSfCGIcP2KUY0EPxndzANBmNllzWPwak+bheSw==} dependencies: any-promise: 1.3.0 + dev: false - through2@4.0.2: + /through2@4.0.2: + resolution: {integrity: sha512-iOqSav00cVxEEICeD7TjLB1sueEL+81Wpzp2bY17uZjZN0pWZPuo4suZ/61VujxmqSGFfgOcNuTZ85QJwNZQpw==} dependencies: readable-stream: 3.6.2 + dev: true - time-require@0.1.2: + /time-require@0.1.2: + resolution: {integrity: sha512-IqcSpa1sVNleRbC9eHnN7p7vwEHNmsjsXUDqjlnvo4+2VLJ7/gIY2XACTBuRhMB4weYbDYKsR3av2ySykRhDIA==} + engines: {node: '>= 0.10.0'} dependencies: chalk: 0.4.0 date-time: 0.1.1 pretty-ms: 0.2.2 text-table: 0.2.0 + dev: true - timed-out@4.0.1: {} + /timed-out@4.0.1: + resolution: {integrity: sha512-G7r3AhovYtr5YKOWQkta8RKAPb+J9IsO4uVmzjl8AZwfhs8UcUwTiD6gcJYSgOtzyjvQKrKYn41syHbUWMkafA==} + engines: {node: '>=0.10.0'} - title-case@2.1.1: + /title-case@2.1.1: + resolution: {integrity: sha512-EkJoZ2O3zdCz3zJsYCsxyq2OC5hrxR9mfdd5I+w8h/tmFfeOxJ+vvkxsKxdmN0WtS9zLdHEgfgVOiMVgv+Po4Q==} dependencies: no-case: 2.3.2 upper-case: 1.1.3 + dev: false - tmp@0.0.33: + /tmp@0.0.33: + resolution: {integrity: sha512-jRCJlojKnZ3addtTOjdIqoRuPEKBvNXcGYqzO6zWZX8KfKEpnGY5jfggJQ3EjKuu8D4bJRr0y+cYJFmYbImXGw==} + engines: {node: '>=0.6.0'} dependencies: os-tmpdir: 1.0.2 - to-fast-properties@2.0.0: {} + /to-fast-properties@2.0.0: + resolution: {integrity: sha512-/OaKK0xYrs3DmxRYqL/yDc+FxFUVYhDlXMhRmv3z915w2HF1tnN1omB354j8VUGO/hbRzyD6Y3sA7v7GS/ceog==} + engines: {node: '>=4'} + dev: true - to-regex-range@5.0.1: + /to-regex-range@5.0.1: + resolution: {integrity: sha512-65P7iz6X5yEr1cwcgvQxbbIw7Uk3gOy5dIdtZ4rDveLqhrdJP+Li/Hx6tyK0NEb+2GCyneCMJiGqrADCSNk8sQ==} + engines: {node: '>=8.0'} dependencies: is-number: 7.0.0 - toidentifier@1.0.1: {} + /toidentifier@1.0.1: + resolution: {integrity: sha512-o5sSPKEkg/DIQNmH43V0/uerLrpzVedkUh8tGNvaeXpfpuwjKenlSox/2O/BTlZUtEe+JG7s5YhEz608PlAHRA==} + engines: {node: '>=0.6'} - tough-cookie@2.5.0: + /tough-cookie@2.5.0: + resolution: {integrity: sha512-nlLsUzgm1kfLXSXfRZMc1KLAugd4hqJHDTvc2hDIwS3mZAfMEuMbc03SujMF+GEcpaX/qboeycw6iO8JwVv2+g==} + engines: {node: '>=0.8'} dependencies: psl: 1.9.0 punycode: 2.3.1 - tr46@0.0.3: {} + /tr46@0.0.3: + resolution: {integrity: sha512-N3WMsuqV66lT30CrXNbEjx4GEwlow3v6rr4mCcv6prnfwhS01rkgyFdjPNBYd9br7LpXV1+Emh01fHnq2Gdgrw==} - trim-newlines@3.0.1: {} + /trim-newlines@3.0.1: + resolution: {integrity: sha512-c1PTsA3tYrIsLGkJkzHF+w9F2EyxfXGo4UyJc4pFL++FMjnq0HJS69T3M7d//gKrFKwy429bouPescbjecU+Zw==} + engines: {node: '>=8'} + dev: true - truffle-blockchain-utils@0.0.5: {} + /truffle-blockchain-utils@0.0.5: + resolution: {integrity: sha512-eCCV8FbYOuKagRY5NiqJCZrrh9GjWX2573ahqZPvUrzxYGIvCpSsHpGCub2e00YefpMfBqwscbsDTK7WNVfwoA==} + deprecated: 'WARNING: This package has been renamed to @truffle/blockchain-utils.' + dev: false - truffle-contract-schema@2.0.3: + /truffle-contract-schema@2.0.3: + resolution: {integrity: sha512-eI5cFifbB3zpcO4RsXSnjN9JMSlJ4M50GQPdrfbrIXRTXHsyQ433SkgFjIATUwfq++TXWkCRfKMjN8eA7YQ3+Q==} + deprecated: 'WARNING: This package has been renamed to @truffle/contract-schema.' dependencies: ajv: 5.5.2 crypto-js: 3.3.0 debug: 3.2.7 transitivePeerDependencies: - supports-color + dev: false - truffle-contract@3.0.8: + /truffle-contract@3.0.8: + resolution: {integrity: sha512-uhXb/G4dORU4RjFlwZZbFT0n5BS8akify+MaRsnWWs4SA/bo6x4/bQs1xtdO3b5Cl9nXiOX88wdQzRj3xtPVUg==} + deprecated: 'WARNING: This package has been renamed to @truffle/contract.' dependencies: ethjs-abi: 0.1.8 truffle-blockchain-utils: 0.0.5 @@ -13086,21 +10518,44 @@ snapshots: web3: 0.20.6 transitivePeerDependencies: - supports-color + dev: false - truffle-error@0.0.3: {} + /truffle-error@0.0.3: + resolution: {integrity: sha512-9gxs1z6BUn7MqrE4NPm/jcYe8rLok3Z57aweGIh1+CoRJSttzYqwcXCqaPRSNrTFnsTeZMBukkYr/PUcADoihw==} + deprecated: 'WARNING: This package has been renamed to @truffle/error.' + dev: false - ts-command-line-args@2.5.1: + /ts-command-line-args@2.5.1: + resolution: {integrity: sha512-H69ZwTw3rFHb5WYpQya40YAX2/w7Ut75uUECbgBIsLmM+BNuYnxsltfyyLMxy6sEeKxgijLTnQtLd0nKd6+IYw==} + hasBin: true dependencies: chalk: 4.1.2 command-line-args: 5.2.1 command-line-usage: 6.1.3 string-format: 2.0.0 + dev: true - ts-essentials@7.0.3(typescript@5.0.4): + /ts-essentials@7.0.3(typescript@5.0.4): + resolution: {integrity: sha512-8+gr5+lqO3G84KdiTSMRLtuyJ+nTBVRKuCrK4lidMPdVeEp0uqC875uE5NMcaA7YYMN7XsNiFQuMvasF8HT/xQ==} + peerDependencies: + typescript: '>=3.7.0' dependencies: typescript: 5.0.4 + dev: true - ts-node@10.9.2(@types/node@18.19.33)(typescript@5.0.4): + /ts-node@10.9.2(@types/node@18.19.33)(typescript@5.0.4): + resolution: {integrity: sha512-f0FFpIdcHgn8zcPSbf1dRevwt047YMnaiJM3u2w2RewrB+fob/zePZcrOyQoLMMO7aBIddLcQIEK5dYjkLnGrQ==} + hasBin: true + peerDependencies: + '@swc/core': '>=1.2.50' + '@swc/wasm': '>=1.2.50' + '@types/node': '*' + typescript: '>=2.7' + peerDependenciesMeta: + '@swc/core': + optional: true + '@swc/wasm': + optional: true dependencies: '@cspotcode/source-map-support': 0.8.1 '@tsconfig/node10': 1.0.11 @@ -13117,28 +10572,43 @@ snapshots: typescript: 5.0.4 v8-compile-cache-lib: 3.0.1 yn: 3.1.1 + dev: true - tsconfig-paths@3.15.0: + /tsconfig-paths@3.15.0: + resolution: {integrity: sha512-2Ac2RgzDe/cn48GvOe3M+o82pEFewD3UPbyoUHHdKasHwJKjds4fLXWf/Ux5kATBKN20oaFGu+jbElp1pos0mg==} dependencies: '@types/json5': 0.0.29 json5: 1.0.2 minimist: 1.2.8 strip-bom: 3.0.0 + dev: true - tslib@1.14.1: {} + /tslib@1.14.1: + resolution: {integrity: sha512-Xni35NKzjgMrwevysHTCArtLDpPvye8zV/0E4EyYn43P7/7qvQwPh9BGkHewbMulVntbigmcT7rdX3BNo9wRJg==} - tslib@2.4.0: {} + /tslib@2.4.0: + resolution: {integrity: sha512-d6xOpEDfsi2CZVlPQzGeux8XMwLT9hssAsaPYExaQMuYskwb+x1x7J371tWlbBdWHroy99KnVB6qIkUbs5X3UQ==} - tslib@2.6.2: {} + /tslib@2.6.2: + resolution: {integrity: sha512-AEYxH93jGFPn/a2iVAwW87VuUIkR1FVUKB77NwMF7nBTDkDrrT/Hpt/IrCJ0QXhW27jTBDcf5ZY7w6RiqTMw2Q==} - tsort@0.0.1: {} + /tsort@0.0.1: + resolution: {integrity: sha512-Tyrf5mxF8Ofs1tNoxA13lFeZ2Zrbd6cKbuH3V+MQ5sb6DtBj5FjrXVsRWT8YvNAQTqNoz66dz1WsbigI22aEnw==} + dev: false - tsutils@3.21.0(typescript@5.0.4): + /tsutils@3.21.0(typescript@5.0.4): + resolution: {integrity: sha512-mHKK3iUXL+3UF6xL5k0PEhKRUBKPBCv/+RkEOpjRWxxx27KKRBmmA60A9pgOUvMi8GKhRMPEmjBRPzs2W7O1OA==} + engines: {node: '>= 6'} + peerDependencies: + typescript: '>=2.8.0 || >= 3.2.0-dev || >= 3.3.0-dev || >= 3.4.0-dev || >= 3.5.0-dev || >= 3.6.0-dev || >= 3.6.0-beta || >= 3.7.0-dev || >= 3.7.0-beta' dependencies: tslib: 1.14.1 typescript: 5.0.4 - tty-table@4.2.3: + /tty-table@4.2.3: + resolution: {integrity: sha512-Fs15mu0vGzCrj8fmJNP7Ynxt5J7praPXqFN0leZeZBXJwkMxv9cb2D454k1ltrtUSJbZ4yH4e0CynsHLxmUfFA==} + engines: {node: '>=8.0.0'} + hasBin: true dependencies: chalk: 4.1.2 csv: 5.5.3 @@ -13147,51 +10617,95 @@ snapshots: strip-ansi: 6.0.1 wcwidth: 1.0.1 yargs: 17.7.2 + dev: true - tunnel-agent@0.6.0: + /tunnel-agent@0.6.0: + resolution: {integrity: sha512-McnNiV1l8RYeY8tBgEpuodCC1mLUdbSN+CYBL7kJsJNInOP8UjDDEwdk6Mw60vdLLrr5NHKZhMAOSrR2NZuQ+w==} dependencies: safe-buffer: 5.2.1 - tweetnacl-util@0.15.1: {} + /tweetnacl-util@0.15.1: + resolution: {integrity: sha512-RKJBIj8lySrShN4w6i/BonWp2Z/uxwC3h4y7xsRrpP59ZboCd0GpEVsOnMDYLMmKBpYhb5TgHzZXy7wTfYFBRw==} + dev: false - tweetnacl@0.14.5: {} + /tweetnacl@0.14.5: + resolution: {integrity: sha512-KXXFFdAbFXY4geFIwoyNK+f5Z1b7swfXABfL7HXCmoIWMKU3dmS26672A4EeQtDzLKy7SXmfBu51JolvEKwtGA==} - tweetnacl@1.0.3: {} + /tweetnacl@1.0.3: + resolution: {integrity: sha512-6rt+RN7aOi1nGMyC4Xa5DdYiukl2UWCbcJft7YhxReBGQD7OAM8Pbxw6YMo4r2diNEA8FEmu32YOn9rhaiE5yw==} + dev: false - type-check@0.3.2: + /type-check@0.3.2: + resolution: {integrity: sha512-ZCmOJdvOWDBYJlzAoFkC+Q0+bUyEOS1ltgp1MGU03fqHG+dbi9tBFU2Rd9QKiDZFAYrhPh2JUf7rZRIuHRKtOg==} + engines: {node: '>= 0.8.0'} dependencies: prelude-ls: 1.1.2 + dev: true - type-check@0.4.0: + /type-check@0.4.0: + resolution: {integrity: sha512-XleUoc9uwGXqjWwXaUTZAmzMcFZ5858QA2vvx1Ur5xIcixXIP+8LnFDgRplU30us6teqdlskFfu+ae4K79Ooew==} + engines: {node: '>= 0.8.0'} dependencies: prelude-ls: 1.2.1 - type-detect@4.0.8: {} + /type-detect@4.0.8: + resolution: {integrity: sha512-0fr/mIH1dlO+x7TlcMy+bIDqKPsw/70tVyeHW787goQjhmqaZe10uwLujubK9q9Lg6Fiho1KUKDYz0Z7k7g5/g==} + engines: {node: '>=4'} - type-fest@0.13.1: {} + /type-fest@0.13.1: + resolution: {integrity: sha512-34R7HTnG0XIJcBSn5XhDd7nNFPRcXYRZrBB2O2jdKqYODldSzBAqzsWoZYYvduky73toYS/ESqxPvkDf/F0XMg==} + engines: {node: '>=10'} + dev: true - type-fest@0.20.2: {} + /type-fest@0.20.2: + resolution: {integrity: sha512-Ne+eE4r0/iWnpAxD852z3A+N0Bt5RN//NjJwRd2VFHEmrywxf5vsZlh4R6lixl6B+wz/8d+maTSAkN1FIkI3LQ==} + engines: {node: '>=10'} - type-fest@0.21.3: {} + /type-fest@0.21.3: + resolution: {integrity: sha512-t0rzBq87m3fVcduHDUFhKmyyX+9eo6WQjZvf51Ea/M0Q7+T374Jp1aUiyUl0GKxp8M/OETVHSDvmkyPgvX+X2w==} + engines: {node: '>=10'} + dev: false - type-fest@0.6.0: {} + /type-fest@0.6.0: + resolution: {integrity: sha512-q+MB8nYR1KDLrgr4G5yemftpMC7/QLqVndBmEEdqzmNj5dcFOO4Oo8qlwZE3ULT3+Zim1F8Kq4cBnikNhlCMlg==} + engines: {node: '>=8'} + dev: true - type-fest@0.7.1: {} + /type-fest@0.7.1: + resolution: {integrity: sha512-Ne2YiiGN8bmrmJJEuTWTLJR32nh/JdL1+PSicowtNb0WFpn59GK8/lfD61bVtzguz7b3PBt74nxpv/Pw5po5Rg==} + engines: {node: '>=8'} + dev: false - type-fest@0.8.1: {} + /type-fest@0.8.1: + resolution: {integrity: sha512-4dbzIzqvjtgiM5rw1k5rEHtBANKmdudhGyBEajN01fEyhaAIhsoKNy6y7+IN93IfpFtwY9iqi7kD+xwKhQsNJA==} + engines: {node: '>=8'} + dev: true - type-fest@2.19.0: {} + /type-fest@2.19.0: + resolution: {integrity: sha512-RAH822pAdBgcNMAfWnCBU3CFZcfZ/i1eZjwFU/dsLKumyuuP3niueg2UAukXYF0E2AAoc82ZSSf9J0WQBinzHA==} + engines: {node: '>=12.20'} + dev: true - type-fest@3.13.1: {} + /type-fest@3.13.1: + resolution: {integrity: sha512-tLq3bSNx+xSpwvAJnzrK0Ep5CLNWjvFTOp71URMaAEWBfRb9nnJiBoUe0tF8bI4ZFO3omgBR6NvnbzVUT3Ly4g==} + engines: {node: '>=14.16'} + dev: true - type-is@1.6.18: + /type-is@1.6.18: + resolution: {integrity: sha512-TkRKr9sUTxEH8MdfuCSP7VizJyzRNMjj2J2do2Jr3Kym598JVdEksuzPQCnlFPW4ky9Q+iA+ma9BGm06XQBy8g==} + engines: {node: '>= 0.6'} dependencies: media-typer: 0.3.0 mime-types: 2.1.35 - type@2.7.2: {} + /type@2.7.2: + resolution: {integrity: sha512-dzlvlNlt6AXU7EBSfpAscydQ7gXB+pPGsPnfJnZpiNJBDj7IaJzQlBZYGdEi4R9HmPdBv2XmWJ6YUtoTa7lmCw==} - typechain@8.3.2(typescript@5.0.4): + /typechain@8.3.2(typescript@5.0.4): + resolution: {integrity: sha512-x/sQYr5w9K7yv3es7jo4KTX05CLxOf7TRWwoHlrjRh8H82G64g+k7VuWPJlgMo6qrjfCulOdfBjiaDtmhFYD/Q==} + hasBin: true + peerDependencies: + typescript: '>=4.3.0' dependencies: '@types/prettier': 2.7.3 debug: 4.3.4(supports-color@8.1.1) @@ -13206,22 +10720,31 @@ snapshots: typescript: 5.0.4 transitivePeerDependencies: - supports-color + dev: true - typed-array-buffer@1.0.2: + /typed-array-buffer@1.0.2: + resolution: {integrity: sha512-gEymJYKZtKXzzBzM4jqa9w6Q1Jjm7x2d+sh19AdsD4wqnMPDYyvwpsIc2Q/835kHuo3BEQ7CjelGhfTsoBb2MQ==} + engines: {node: '>= 0.4'} dependencies: call-bind: 1.0.7 es-errors: 1.3.0 is-typed-array: 1.1.13 + dev: true - typed-array-byte-length@1.0.1: + /typed-array-byte-length@1.0.1: + resolution: {integrity: sha512-3iMJ9q0ao7WE9tWcaYKIptkNBuOIcZCCT0d4MRvuuH88fEoEH62IuQe0OtraD3ebQEoTRk8XCBoknUNc1Y67pw==} + engines: {node: '>= 0.4'} dependencies: call-bind: 1.0.7 for-each: 0.3.3 gopd: 1.0.1 has-proto: 1.0.3 is-typed-array: 1.1.13 + dev: true - typed-array-byte-offset@1.0.2: + /typed-array-byte-offset@1.0.2: + resolution: {integrity: sha512-Ous0vodHa56FviZucS2E63zkgtgrACj7omjwd/8lTEMEPFFyjfixMZ1ZXenpgCFBBt4EC1J2XsyVS2gkG0eTFA==} + engines: {node: '>= 0.4'} dependencies: available-typed-arrays: 1.0.7 call-bind: 1.0.7 @@ -13229,8 +10752,11 @@ snapshots: gopd: 1.0.1 has-proto: 1.0.3 is-typed-array: 1.1.13 + dev: true - typed-array-length@1.0.6: + /typed-array-length@1.0.6: + resolution: {integrity: sha512-/OxDN6OtAk5KBpGb28T+HZc2M+ADtvRxXrKKbUwtsLgdoxgX13hyy7ek6bFRl5+aBs2yZzB0c4CnQfAtVypW/g==} + engines: {node: '>= 0.4'} dependencies: call-bind: 1.0.7 for-each: 0.3.3 @@ -13238,82 +10764,141 @@ snapshots: has-proto: 1.0.3 is-typed-array: 1.1.13 possible-typed-array-names: 1.0.0 + dev: true - typedarray-to-buffer@3.1.5: + /typedarray-to-buffer@3.1.5: + resolution: {integrity: sha512-zdu8XMNEDepKKR+XYOXAVPtWui0ly0NtohUscw+UmaHiAWT8hrV1rr//H6V+0DvJ3OQ19S979M0laLfX8rm82Q==} dependencies: is-typedarray: 1.0.0 - typedarray@0.0.6: {} + /typedarray@0.0.6: + resolution: {integrity: sha512-/aCDEGatGvZ2BIk+HmLf4ifCJFwvKFNb9/JeZPMulfgFracn9QFcAf5GO8B/mweUjSoblS5In0cWhqpfs/5PQA==} + dev: true - typescript@5.0.4: {} + /typescript@5.0.4: + resolution: {integrity: sha512-cW9T5W9xY37cc+jfEnaUvX91foxtHkza3Nw3wkoF4sSlKn0MONdkdEndig/qPBWXNkmplh3NzayQzCiHM4/hqw==} + engines: {node: '>=12.20'} + hasBin: true - typical@4.0.0: {} + /typical@4.0.0: + resolution: {integrity: sha512-VAH4IvQ7BDFYglMd7BPRDfLgxZZX4O4TFcRDA6EN5X7erNJJq+McIEp8np9aVtxrCJ6qx4GTYVfOWNjcqwZgRw==} + engines: {node: '>=8'} + dev: true - typical@5.2.0: {} + /typical@5.2.0: + resolution: {integrity: sha512-dvdQgNDNJo+8B2uBQoqdb11eUCE1JQXhvjC/CZtgvZseVd5TYMXnq0+vuUemXbd/Se29cTaUuPX3YIc2xgbvIg==} + engines: {node: '>=8'} + dev: true - uglify-js@3.17.4: + /uglify-js@3.17.4: + resolution: {integrity: sha512-T9q82TJI9e/C1TAxYvfb16xO120tMVFZrGA3f9/P4424DNu6ypK103y0GPFVa17yotwSyZW5iYXgjYHkGrJW/g==} + engines: {node: '>=0.8.0'} + hasBin: true + requiresBuild: true + dev: true optional: true - ultron@1.1.1: {} + /ultron@1.1.1: + resolution: {integrity: sha512-UIEXBNeYmKptWH6z8ZnqTeS8fV74zG0/eRU9VGkpzz+LIJNs8W/zM/L+7ctCkRrgbNnnR0xxw4bKOr0cW0N0Og==} - unbox-primitive@1.0.2: + /unbox-primitive@1.0.2: + resolution: {integrity: sha512-61pPlCD9h51VoreyJ0BReideM3MDKMKnh6+V9L08331ipq6Q8OFXZYiqP6n/tbHx4s5I9uRhcye6BrbkizkBDw==} dependencies: call-bind: 1.0.7 has-bigints: 1.0.2 has-symbols: 1.0.3 which-boxed-primitive: 1.0.2 + dev: true - underscore@1.13.6: {} + /underscore@1.13.6: + resolution: {integrity: sha512-+A5Sja4HP1M08MaXya7p5LvjuM7K6q/2EaC0+iovj/wOcMsTzMvDFbasi/oSapiwOlt252IqsKqPjCl7huKS0A==} + dev: false - undici-types@5.26.5: {} + /undici-types@5.26.5: + resolution: {integrity: sha512-JlCMO+ehdEIKqlFxk6IfVoAUVmgz7cU7zD/h9XZ0qzeosSHmUJVOzSQvvYSYWXkFXC+IfLKSIffhv0sVZup6pA==} - undici@5.28.4: + /undici@5.28.4: + resolution: {integrity: sha512-72RFADWFqKmUb2hmmvNODKL3p9hcB6Gt2DOQMis1SEBaV6a4MH8soBvzg+95CYhCKPFedut2JY9bMfrDl9D23g==} + engines: {node: '>=14.0'} dependencies: '@fastify/busboy': 2.1.1 + dev: false - universalify@0.1.2: {} + /universalify@0.1.2: + resolution: {integrity: sha512-rBJeI5CXAlmy1pV+617WB9J63U6XcazHHF2f2dbJix4XzpUF0RS3Zbj0FGIOCAva5P/d/GBOYaACQ1w+0azUkg==} + engines: {node: '>= 4.0.0'} - universalify@2.0.1: {} + /universalify@2.0.1: + resolution: {integrity: sha512-gptHNQghINnc/vTGIk0SOFGFNXw7JVrlRUtConJRlvaw6DuX0wO5Jeko9sWrMBhh+PsYAZ7oXAiOnf/UKogyiw==} + engines: {node: '>= 10.0.0'} + dev: true - unpipe@1.0.0: {} + /unpipe@1.0.0: + resolution: {integrity: sha512-pjy2bYhSsufwWlKwPc+l3cN7+wuJlK6uz0YdJEOlQDbl6jo/YlPi4mb8agUkVC8BF7V8NuzeyPNqRksA3hztKQ==} + engines: {node: '>= 0.8'} - untildify@4.0.0: {} + /untildify@4.0.0: + resolution: {integrity: sha512-KK8xQ1mkzZeg9inewmFVDNkg3l5LUhoq9kN6iWYB/CC9YMG8HA+c1Q8HwDe6dEX7kErrEVNVBO3fWsVq5iDgtw==} + engines: {node: '>=8'} + dev: false - update-browserslist-db@1.0.15(browserslist@4.23.0): + /update-browserslist-db@1.0.15(browserslist@4.23.0): + resolution: {integrity: sha512-K9HWH62x3/EalU1U6sjSZiylm9C8tgq2mSvshZpqc7QE69RaA2qjhkW2HlNA0tFpEbtyFz7HTqbSdN4MSwUodA==} + hasBin: true + peerDependencies: + browserslist: '>= 4.21.0' dependencies: browserslist: 4.23.0 escalade: 3.1.2 picocolors: 1.0.0 + dev: true - upper-case-first@1.1.2: + /upper-case-first@1.1.2: + resolution: {integrity: sha512-wINKYvI3Db8dtjikdAqoBbZoP6Q+PZUyfMR7pmwHzjC2quzSkUq5DmPrTtPEqHaz8AGtmsB4TqwapMTM1QAQOQ==} dependencies: upper-case: 1.1.3 + dev: false - upper-case@1.1.3: {} + /upper-case@1.1.3: + resolution: {integrity: sha512-WRbjgmYzgXkCV7zNVpy5YgrHgbBv126rMALQQMrmzOVC4GM2waQ9x7xtm8VU+1yF2kWyPzI9zbZ48n4vSxwfSA==} + dev: false - uri-js@4.4.1: + /uri-js@4.4.1: + resolution: {integrity: sha512-7rKUyy33Q1yc98pQ1DAmLtwX109F7TIfWlW1Ydo8Wl1ii1SeHieeh0HHfPeL2fMXK6z0s8ecKs9frCuLJvndBg==} dependencies: punycode: 2.3.1 - url-set-query@1.0.0: {} + /url-set-query@1.0.0: + resolution: {integrity: sha512-3AChu4NiXquPfeckE5R5cGdiHCMWJx1dwCWOmWIL4KHAziJNOFIYJlpGFeKDvwLPHovZRCxK3cYlwzqI9Vp+Gg==} - usb@2.9.0: + /usb@2.9.0: + resolution: {integrity: sha512-G0I/fPgfHUzWH8xo2KkDxTTFruUWfppgSFJ+bQxz/kVY2x15EQ/XDB7dqD1G432G4gBG4jYQuF3U7j/orSs5nw==} + engines: {node: '>=10.20.0 <11.x || >=12.17.0 <13.0 || >=14.0.0'} + requiresBuild: true dependencies: '@types/w3c-web-usb': 1.0.10 node-addon-api: 6.1.0 node-gyp-build: 4.8.1 + dev: false - utf-8-validate@5.0.10: + /utf-8-validate@5.0.10: + resolution: {integrity: sha512-Z6czzLq4u8fPOyx7TU6X3dvUZVvoJmxSQ+IcrlmagKhilxlhZgxPK6C5Jqbkw1IDUmFTM+cz9QDnnLTwDz/2gQ==} + engines: {node: '>=6.14.2'} + requiresBuild: true dependencies: node-gyp-build: 4.8.1 - utf8@2.1.2: {} + /utf8@2.1.2: + resolution: {integrity: sha512-QXo+O/QkLP/x1nyi54uQiG0XrODxdysuQvE5dtVqv7F5K2Qb6FsN+qbr6KhF5wQ20tfcV3VQp0/2x1e1MRSPWg==} - utf8@3.0.0: {} + /utf8@3.0.0: + resolution: {integrity: sha512-E8VjFIQ/TyQgp+TZfS6l8yp/xWppSAHzidGiRrqe4bK4XP9pTRyKFgGJpO3SN7zdX4DeomTrwaseCHovfpFcqQ==} - util-deprecate@1.0.2: {} + /util-deprecate@1.0.2: + resolution: {integrity: sha512-EPD5q1uXyFxJpCrLnCc1nHnq3gOa6DZBocAIiI2TaSCA7VCJ1UJDMagCzIkXNsUYfD1daK//LTEQ8xiIbrHtcw==} - util@0.12.5: + /util@0.12.5: + resolution: {integrity: sha512-kZf/K6hEIrWHI6XqOFUiiMa+79wE/D8Q+NCNAWclkyg3b4d2k7s0QGepNjiABc+aR3N1PAyHL7p6UcLY6LmrnA==} dependencies: inherits: 2.0.4 is-arguments: 1.1.1 @@ -13321,93 +10906,145 @@ snapshots: is-typed-array: 1.1.13 which-typed-array: 1.1.15 - utils-merge@1.0.1: {} + /utils-merge@1.0.1: + resolution: {integrity: sha512-pMZTvIkT1d+TFGvDOqodOclx0QWkkgi6Tdoa8gC8ffGAAqz9pzPTZWAybbsHHoED/ztMtkv/VoYTYyShUn81hA==} + engines: {node: '>= 0.4.0'} - uuid@2.0.1: {} + /uuid@2.0.1: + resolution: {integrity: sha512-nWg9+Oa3qD2CQzHIP4qKUqwNfzKn8P0LtFhotaCTFchsV7ZfDhAybeip/HZVeMIpZi9JgY1E3nUlwaCmZT1sEg==} + deprecated: Please upgrade to version 7 or higher. Older versions may use Math.random() in certain circumstances, which is known to be problematic. See https://v8.dev/blog/math-random for details. + dev: false - uuid@3.4.0: {} + /uuid@3.4.0: + resolution: {integrity: sha512-HjSDRw6gZE5JMggctHBcjVak08+KEVhSIiDzFnT9S9aegmp85S/bReBVTb4QTFaRNptJ9kuYaNhnbNEOkbKb/A==} + deprecated: Please upgrade to version 7 or higher. Older versions may use Math.random() in certain circumstances, which is known to be problematic. See https://v8.dev/blog/math-random for details. + hasBin: true - uuid@8.3.2: {} + /uuid@8.3.2: + resolution: {integrity: sha512-+NYs2QeMWy+GWFOEm9xnn6HCDp0l7QBD7ml8zLUmJ+93Q5NF0NocErnwkTkXVFNiX3/fpC6afS8Dhb/gz7R7eg==} + hasBin: true - uuid@9.0.1: {} + /uuid@9.0.1: + resolution: {integrity: sha512-b+1eJOlsR9K8HJpow9Ok3fiWOWSIcIzXodvv0rQjVoOVNpWMpxf1wZNpt4y9h10odCNrqnYp1OBzRktckBe3sA==} + hasBin: true - v8-compile-cache-lib@3.0.1: {} + /v8-compile-cache-lib@3.0.1: + resolution: {integrity: sha512-wa7YjyUGfNZngI/vtK0UHAN+lgDCxBPCylVXGp0zu59Fz5aiGtNXaq3DhIov063MorB+VfufLh3JlF2KdTK3xg==} + dev: true - validate-npm-package-license@3.0.4: + /validate-npm-package-license@3.0.4: + resolution: {integrity: sha512-DpKm2Ui/xN7/HQKCtpZxoRWBhZ9Z0kqtygG8XCgNQ8ZlDnxuQmWhj566j8fN4Cu3/JmbhsDo7fcAJq4s9h27Ew==} dependencies: spdx-correct: 3.2.0 spdx-expression-parse: 3.0.1 - varint@5.0.2: {} + /varint@5.0.2: + resolution: {integrity: sha512-lKxKYG6H03yCZUpAGOPOsMcGxd1RHCu1iKvEHYDPmTyq2HueGhD73ssNBqqQWfvYs04G9iUFRvmAVLW20Jw6ow==} - vary@1.1.2: {} + /vary@1.1.2: + resolution: {integrity: sha512-BNGbWLfd0eUPabhkXUVm0j8uuvREyTh5ovRa/dyow/BqAbZJyC+5fU+IzQOzmAKzYqYRAISoRhdQr3eIZ/PXqg==} + engines: {node: '>= 0.8'} - verror@1.10.0: + /verror@1.10.0: + resolution: {integrity: sha512-ZZKSmDAEFOijERBLkmYfJ+vmk3w+7hOLYDNkRCuRuMJGEmqYNCNLyBBFwWKVMhfwaEF3WOd0Zlw86U/WC/+nYw==} + engines: {'0': node >=0.6.0} dependencies: assert-plus: 1.0.0 core-util-is: 1.0.2 extsprintf: 1.3.0 - viem@2.10.3(bufferutil@4.0.8)(typescript@5.0.4)(utf-8-validate@5.0.10)(zod@3.23.8): + /viem@2.10.3(typescript@5.0.4): + resolution: {integrity: sha512-GmPMH+D/SDSXpVSjLM0GN1H1/h4NUPHaIqnFLwAit8nkfCiDuajKflGFiMPCIs1h7QZlBICuKvON/rc09H+w6Q==} + peerDependencies: + typescript: '>=5.0.4' + peerDependenciesMeta: + typescript: + optional: true dependencies: '@adraffy/ens-normalize': 1.10.0 '@noble/curves': 1.2.0 '@noble/hashes': 1.3.2 '@scure/bip32': 1.3.2 '@scure/bip39': 1.2.1 - abitype: 1.0.0(typescript@5.0.4)(zod@3.23.8) - isows: 1.0.3(ws@8.13.0(bufferutil@4.0.8)(utf-8-validate@5.0.10)) - ws: 8.13.0(bufferutil@4.0.8)(utf-8-validate@5.0.10) - optionalDependencies: + abitype: 1.0.0(typescript@5.0.4) + isows: 1.0.3(ws@8.13.0) typescript: 5.0.4 + ws: 8.13.0 transitivePeerDependencies: - bufferutil - utf-8-validate - zod + dev: true - wcwidth@1.0.1: + /wcwidth@1.0.1: + resolution: {integrity: sha512-XHPEwS0q6TaxcvG85+8EYkbiCux2XtWG2mkc47Ng2A77BQu9+DqIOJldST4HgPkuea7dvKSj5VgX3P1d4rW8Tg==} dependencies: defaults: 1.0.4 - web3-bzz@1.10.0(bufferutil@4.0.8)(utf-8-validate@5.0.10): + /web3-bzz@1.10.0: + resolution: {integrity: sha512-o9IR59io3pDUsXTsps5pO5hW1D5zBmg46iNc2t4j2DkaYHNdDLwk2IP9ukoM2wg47QILfPEJYzhTfkS/CcX0KA==} + engines: {node: '>=8.0.0'} + requiresBuild: true dependencies: '@types/node': 12.20.55 got: 12.1.0 - swarm-js: 0.1.42(bufferutil@4.0.8)(utf-8-validate@5.0.10) + swarm-js: 0.1.42 transitivePeerDependencies: - bufferutil - supports-color - utf-8-validate + dev: false - web3-bzz@1.10.4(bufferutil@4.0.8)(utf-8-validate@5.0.10): + /web3-bzz@1.10.4: + resolution: {integrity: sha512-ZZ/X4sJ0Uh2teU9lAGNS8EjveEppoHNQiKlOXAjedsrdWuaMErBPdLQjXfcrYvN6WM6Su9PMsAxf3FXXZ+HwQw==} + engines: {node: '>=8.0.0'} + requiresBuild: true dependencies: '@types/node': 12.20.55 got: 12.1.0 - swarm-js: 0.1.42(bufferutil@4.0.8)(utf-8-validate@5.0.10) + swarm-js: 0.1.42 transitivePeerDependencies: - bufferutil - supports-color - utf-8-validate - web3-core-helpers@1.10.0: + /web3-core-helpers@1.10.0: + resolution: {integrity: sha512-pIxAzFDS5vnbXvfvLSpaA1tfRykAe9adw43YCKsEYQwH0gCLL0kMLkaCX3q+Q8EVmAh+e1jWL/nl9U0de1+++g==} + engines: {node: '>=8.0.0'} dependencies: web3-eth-iban: 1.10.0 web3-utils: 1.10.0 + dev: false + + /web3-core-helpers@1.10.3: + resolution: {integrity: sha512-Yv7dQC3B9ipOc5sWm3VAz1ys70Izfzb8n9rSiQYIPjpqtJM+3V4EeK6ghzNR6CO2es0+Yu9CtCkw0h8gQhrTxA==} + engines: {node: '>=8.0.0'} + dependencies: + web3-eth-iban: 1.10.3 + web3-utils: 1.10.3 + dev: false - web3-core-helpers@1.10.4: + /web3-core-helpers@1.10.4: + resolution: {integrity: sha512-r+L5ylA17JlD1vwS8rjhWr0qg7zVoVMDvWhajWA5r5+USdh91jRUYosp19Kd1m2vE034v7Dfqe1xYRoH2zvG0g==} + engines: {node: '>=8.0.0'} dependencies: web3-eth-iban: 1.10.4 web3-utils: 1.10.4 - web3-core-method@1.10.0: + /web3-core-method@1.10.0: + resolution: {integrity: sha512-4R700jTLAMKDMhQ+nsVfIXvH6IGJlJzGisIfMKWAIswH31h5AZz7uDUW2YctI+HrYd+5uOAlS4OJeeT9bIpvkA==} + engines: {node: '>=8.0.0'} dependencies: '@ethersproject/transactions': 5.7.0 web3-core-helpers: 1.10.0 web3-core-promievent: 1.10.0 web3-core-subscriptions: 1.10.0 web3-utils: 1.10.0 + dev: false - web3-core-method@1.10.4: + /web3-core-method@1.10.4: + resolution: {integrity: sha512-uZTb7flr+Xl6LaDsyTeE2L1TylokCJwTDrIVfIfnrGmnwLc6bmTWCCrm71sSrQ0hqs6vp/MKbQYIYqUN0J8WyA==} + engines: {node: '>=8.0.0'} dependencies: '@ethersproject/transactions': 5.7.0 web3-core-helpers: 1.10.4 @@ -13415,15 +11052,29 @@ snapshots: web3-core-subscriptions: 1.10.4 web3-utils: 1.10.4 - web3-core-promievent@1.10.0: + /web3-core-promievent@1.10.0: + resolution: {integrity: sha512-68N7k5LWL5R38xRaKFrTFT2pm2jBNFaM4GioS00YjAKXRQ3KjmhijOMG3TICz6Aa5+6GDWYelDNx21YAeZ4YTg==} + engines: {node: '>=8.0.0'} + dependencies: + eventemitter3: 4.0.4 + dev: false + + /web3-core-promievent@1.10.3: + resolution: {integrity: sha512-HgjY+TkuLm5uTwUtaAfkTgRx/NzMxvVradCi02gy17NxDVdg/p6svBHcp037vcNpkuGeFznFJgULP+s2hdVgUQ==} + engines: {node: '>=8.0.0'} dependencies: eventemitter3: 4.0.4 + dev: false - web3-core-promievent@1.10.4: + /web3-core-promievent@1.10.4: + resolution: {integrity: sha512-2de5WnJQ72YcIhYwV/jHLc4/cWJnznuoGTJGD29ncFQHAfwW/MItHFSVKPPA5v8AhJe+r6y4Y12EKvZKjQVBvQ==} + engines: {node: '>=8.0.0'} dependencies: eventemitter3: 4.0.4 - web3-core-requestmanager@1.10.0: + /web3-core-requestmanager@1.10.0: + resolution: {integrity: sha512-3z/JKE++Os62APml4dvBM+GAuId4h3L9ckUrj7ebEtS2AR0ixyQPbrBodgL91Sv7j7cQ3Y+hllaluqjguxvSaQ==} + engines: {node: '>=8.0.0'} dependencies: util: 0.12.5 web3-core-helpers: 1.10.0 @@ -13433,8 +11084,11 @@ snapshots: transitivePeerDependencies: - encoding - supports-color + dev: false - web3-core-requestmanager@1.10.4: + /web3-core-requestmanager@1.10.4: + resolution: {integrity: sha512-vqP6pKH8RrhT/2MoaU+DY/OsYK9h7HmEBNCdoMj+4ZwujQtw/Mq2JifjwsJ7gits7Q+HWJwx8q6WmQoVZAWugg==} + engines: {node: '>=8.0.0'} dependencies: util: 0.12.5 web3-core-helpers: 1.10.4 @@ -13445,17 +11099,24 @@ snapshots: - encoding - supports-color - web3-core-subscriptions@1.10.0: + /web3-core-subscriptions@1.10.0: + resolution: {integrity: sha512-HGm1PbDqsxejI075gxBc5OSkwymilRWZufIy9zEpnWKNmfbuv5FfHgW1/chtJP6aP3Uq2vHkvTDl3smQBb8l+g==} + engines: {node: '>=8.0.0'} dependencies: eventemitter3: 4.0.4 web3-core-helpers: 1.10.0 + dev: false - web3-core-subscriptions@1.10.4: + /web3-core-subscriptions@1.10.4: + resolution: {integrity: sha512-o0lSQo/N/f7/L76C0HV63+S54loXiE9fUPfHFcTtpJRQNDBVsSDdWRdePbWwR206XlsBqD5VHApck1//jEafTw==} + engines: {node: '>=8.0.0'} dependencies: eventemitter3: 4.0.4 web3-core-helpers: 1.10.4 - web3-core@1.10.0: + /web3-core@1.10.0: + resolution: {integrity: sha512-fWySwqy2hn3TL89w5TM8wXF1Z2Q6frQTKHWmP0ppRQorEK8NcHJRfeMiv/mQlSKoTS1F6n/nv2uyZsixFycjYQ==} + engines: {node: '>=8.0.0'} dependencies: '@types/bn.js': 5.1.5 '@types/node': 12.20.55 @@ -13467,8 +11128,11 @@ snapshots: transitivePeerDependencies: - encoding - supports-color + dev: false - web3-core@1.10.4: + /web3-core@1.10.4: + resolution: {integrity: sha512-B6elffYm81MYZDTrat7aEhnhdtVE3lDBUZft16Z8awYMZYJDbnykEbJVS+l3mnA7AQTnSDr/1MjWofGDLBJPww==} + engines: {node: '>=8.0.0'} dependencies: '@types/bn.js': 5.1.5 '@types/node': 12.20.55 @@ -13481,13 +11145,15 @@ snapshots: - encoding - supports-color - web3-core@4.3.2(bufferutil@4.0.8)(utf-8-validate@5.0.10): + /web3-core@4.3.2: + resolution: {integrity: sha512-uIMVd/j4BgOnwfpY8ZT+QKubOyM4xohEhFZXz9xB8wimXWMMlYVlIK/TbfHqFolS9uOerdSGhsMbcK9lETae8g==} + engines: {node: '>=14', npm: '>=6.12.0'} dependencies: web3-errors: 1.1.4 web3-eth-accounts: 4.1.2 web3-eth-iban: 4.0.7 web3-providers-http: 4.1.0 - web3-providers-ws: 4.0.7(bufferutil@4.0.8)(utf-8-validate@5.0.10) + web3-providers-ws: 4.0.7 web3-types: 1.6.0 web3-utils: 4.2.3 web3-validator: 2.0.5 @@ -13497,24 +11163,35 @@ snapshots: - bufferutil - encoding - utf-8-validate + dev: true - web3-errors@1.1.4: + /web3-errors@1.1.4: + resolution: {integrity: sha512-WahtszSqILez+83AxGecVroyZsMuuRT+KmQp4Si5P4Rnqbczno1k748PCrZTS1J4UCPmXMG2/Vt+0Bz2zwXkwQ==} + engines: {node: '>=14', npm: '>=6.12.0'} dependencies: web3-types: 1.6.0 + dev: true - web3-eth-abi@1.10.0: + /web3-eth-abi@1.10.0: + resolution: {integrity: sha512-cwS+qRBWpJ43aI9L3JS88QYPfFcSJJ3XapxOQ4j40v6mk7ATpA8CVK1vGTzpihNlOfMVRBkR95oAj7oL6aiDOg==} + engines: {node: '>=8.0.0'} dependencies: '@ethersproject/abi': 5.7.0 web3-utils: 1.10.0 + dev: false - web3-eth-abi@1.10.4: + /web3-eth-abi@1.10.4: + resolution: {integrity: sha512-cZ0q65eJIkd/jyOlQPDjr8X4fU6CRL1eWgdLwbWEpo++MPU/2P4PFk5ZLAdye9T5Sdp+MomePPJ/gHjLMj2VfQ==} + engines: {node: '>=8.0.0'} dependencies: '@ethersproject/abi': 5.7.0 web3-utils: 1.10.4 - web3-eth-abi@4.2.1(typescript@5.0.4)(zod@3.23.8): + /web3-eth-abi@4.2.1(typescript@5.0.4): + resolution: {integrity: sha512-IE91WUhhiDpBtbkl/DHUoZz7z7T5FXvl3zPLkrxT+dNlOT+wni+US/67jQCLvJRbqf9ApQ26lVYry0bovFgyqA==} + engines: {node: '>=14', npm: '>=6.12.0'} dependencies: - abitype: 0.7.1(typescript@5.0.4)(zod@3.23.8) + abitype: 0.7.1(typescript@5.0.4) web3-errors: 1.1.4 web3-types: 1.6.0 web3-utils: 4.2.3 @@ -13522,8 +11199,11 @@ snapshots: transitivePeerDependencies: - typescript - zod + dev: true - web3-eth-accounts@1.10.0: + /web3-eth-accounts@1.10.0: + resolution: {integrity: sha512-wiq39Uc3mOI8rw24wE2n15hboLE0E9BsQLdlmsL4Zua9diDS6B5abXG0XhFcoNsXIGMWXVZz4TOq3u4EdpXF/Q==} + engines: {node: '>=8.0.0'} dependencies: '@ethereumjs/common': 2.5.0 '@ethereumjs/tx': 3.3.2 @@ -13538,8 +11218,11 @@ snapshots: transitivePeerDependencies: - encoding - supports-color + dev: false - web3-eth-accounts@1.10.4: + /web3-eth-accounts@1.10.4: + resolution: {integrity: sha512-ysy5sVTg9snYS7tJjxVoQAH6DTOTkRGR8emEVCWNGLGiB9txj+qDvSeT0izjurS/g7D5xlMAgrEHLK1Vi6I3yg==} + engines: {node: '>=8.0.0'} dependencies: '@ethereumjs/common': 2.6.5 '@ethereumjs/tx': 3.5.2 @@ -13555,7 +11238,9 @@ snapshots: - encoding - supports-color - web3-eth-accounts@4.1.2: + /web3-eth-accounts@4.1.2: + resolution: {integrity: sha512-y0JynDeTDnclyuE9mShXLeEj+BCrPHxPHOyPCgTchUBQsALF9+0OhP7WiS3IqUuu0Hle5bjG2f5ddeiPtNEuLg==} + engines: {node: '>=14', npm: '>=6.12.0'} dependencies: '@ethereumjs/rlp': 4.0.1 crc-32: 1.2.2 @@ -13564,8 +11249,11 @@ snapshots: web3-types: 1.6.0 web3-utils: 4.2.3 web3-validator: 2.0.5 + dev: true - web3-eth-contract@1.10.0: + /web3-eth-contract@1.10.0: + resolution: {integrity: sha512-MIC5FOzP/+2evDksQQ/dpcXhSqa/2hFNytdl/x61IeWxhh6vlFeSjq0YVTAyIzdjwnL7nEmZpjfI6y6/Ufhy7w==} + engines: {node: '>=8.0.0'} dependencies: '@types/bn.js': 5.1.5 web3-core: 1.10.0 @@ -13578,8 +11266,11 @@ snapshots: transitivePeerDependencies: - encoding - supports-color + dev: false - web3-eth-contract@1.10.4: + /web3-eth-contract@1.10.4: + resolution: {integrity: sha512-Q8PfolOJ4eV9TvnTj1TGdZ4RarpSLmHnUnzVxZ/6/NiTfe4maJz99R0ISgwZkntLhLRtw0C7LRJuklzGYCNN3A==} + engines: {node: '>=8.0.0'} dependencies: '@types/bn.js': 5.1.5 web3-core: 1.10.4 @@ -13593,12 +11284,14 @@ snapshots: - encoding - supports-color - web3-eth-contract@4.4.0(bufferutil@4.0.8)(typescript@5.0.4)(utf-8-validate@5.0.10)(zod@3.23.8): + /web3-eth-contract@4.4.0(typescript@5.0.4): + resolution: {integrity: sha512-pZ/w6Lb6ZDUUs7f5GCKXiHDAGGvt2tdwiHkvgmQTRnq9b0MEsUpteDyPYspHxKzQWLgbeK37jPb8zbQe4kE/Hg==} + engines: {node: '>=14', npm: '>=6.12.0'} dependencies: - web3-core: 4.3.2(bufferutil@4.0.8)(utf-8-validate@5.0.10) + web3-core: 4.3.2 web3-errors: 1.1.4 - web3-eth: 4.6.0(bufferutil@4.0.8)(typescript@5.0.4)(utf-8-validate@5.0.10)(zod@3.23.8) - web3-eth-abi: 4.2.1(typescript@5.0.4)(zod@3.23.8) + web3-eth: 4.6.0(typescript@5.0.4) + web3-eth-abi: 4.2.1(typescript@5.0.4) web3-types: 1.6.0 web3-utils: 4.2.3 web3-validator: 2.0.5 @@ -13608,8 +11301,11 @@ snapshots: - typescript - utf-8-validate - zod + dev: true - web3-eth-ens@1.10.0: + /web3-eth-ens@1.10.0: + resolution: {integrity: sha512-3hpGgzX3qjgxNAmqdrC2YUQMTfnZbs4GeLEmy8aCWziVwogbuqQZ+Gzdfrym45eOZodk+lmXyLuAdqkNlvkc1g==} + engines: {node: '>=8.0.0'} dependencies: content-hash: 2.5.2 eth-ens-namehash: 2.0.8 @@ -13622,8 +11318,11 @@ snapshots: transitivePeerDependencies: - encoding - supports-color + dev: false - web3-eth-ens@1.10.4: + /web3-eth-ens@1.10.4: + resolution: {integrity: sha512-LLrvxuFeVooRVZ9e5T6OWKVflHPFgrVjJ/jtisRWcmI7KN/b64+D/wJzXqgmp6CNsMQcE7rpmf4CQmJCrTdsgg==} + engines: {node: '>=8.0.0'} dependencies: content-hash: 2.5.2 eth-ens-namehash: 2.0.8 @@ -13637,14 +11336,16 @@ snapshots: - encoding - supports-color - web3-eth-ens@4.2.0(bufferutil@4.0.8)(typescript@5.0.4)(utf-8-validate@5.0.10)(zod@3.23.8): + /web3-eth-ens@4.2.0(typescript@5.0.4): + resolution: {integrity: sha512-qYj34te2UctoObt8rlEIY/t2MuTMiMiiHhO2JAHRGqSLCQ7b8DM3RpvkiiSB0N0ZyEn+CetZqJCTYb8DNKBS/g==} + engines: {node: '>=14', npm: '>=6.12.0'} dependencies: '@adraffy/ens-normalize': 1.10.1 - web3-core: 4.3.2(bufferutil@4.0.8)(utf-8-validate@5.0.10) + web3-core: 4.3.2 web3-errors: 1.1.4 - web3-eth: 4.6.0(bufferutil@4.0.8)(typescript@5.0.4)(utf-8-validate@5.0.10)(zod@3.23.8) - web3-eth-contract: 4.4.0(bufferutil@4.0.8)(typescript@5.0.4)(utf-8-validate@5.0.10)(zod@3.23.8) - web3-net: 4.0.7(bufferutil@4.0.8)(utf-8-validate@5.0.10) + web3-eth: 4.6.0(typescript@5.0.4) + web3-eth-contract: 4.4.0(typescript@5.0.4) + web3-net: 4.0.7 web3-types: 1.6.0 web3-utils: 4.2.3 web3-validator: 2.0.5 @@ -13654,25 +11355,44 @@ snapshots: - typescript - utf-8-validate - zod + dev: true - web3-eth-iban@1.10.0: + /web3-eth-iban@1.10.0: + resolution: {integrity: sha512-0l+SP3IGhInw7Q20LY3IVafYEuufo4Dn75jAHT7c2aDJsIolvf2Lc6ugHkBajlwUneGfbRQs/ccYPQ9JeMUbrg==} + engines: {node: '>=8.0.0'} dependencies: bn.js: 5.2.1 web3-utils: 1.10.0 + dev: false + + /web3-eth-iban@1.10.3: + resolution: {integrity: sha512-ZCfOjYKAjaX2TGI8uif5ah+J3BYFuo+47JOIV1RIz2l7kD9VfnxvRH5UiQDRyMALQC7KFd2hUqIEtHklapNyKA==} + engines: {node: '>=8.0.0'} + dependencies: + bn.js: 5.2.1 + web3-utils: 1.10.3 + dev: false - web3-eth-iban@1.10.4: + /web3-eth-iban@1.10.4: + resolution: {integrity: sha512-0gE5iNmOkmtBmbKH2aTodeompnNE8jEyvwFJ6s/AF6jkw9ky9Op9cqfzS56AYAbrqEFuClsqB/AoRves7LDELw==} + engines: {node: '>=8.0.0'} dependencies: bn.js: 5.2.1 web3-utils: 1.10.4 - web3-eth-iban@4.0.7: + /web3-eth-iban@4.0.7: + resolution: {integrity: sha512-8weKLa9KuKRzibC87vNLdkinpUE30gn0IGY027F8doeJdcPUfsa4IlBgNC4k4HLBembBB2CTU0Kr/HAOqMeYVQ==} + engines: {node: '>=14', npm: '>=6.12.0'} dependencies: web3-errors: 1.1.4 web3-types: 1.6.0 web3-utils: 4.2.3 web3-validator: 2.0.5 + dev: true - web3-eth-personal@1.10.0: + /web3-eth-personal@1.10.0: + resolution: {integrity: sha512-anseKn98w/d703eWq52uNuZi7GhQeVjTC5/svrBWEKob0WZ5kPdo+EZoFN0sp5a5ubbrk/E0xSl1/M5yORMtpg==} + engines: {node: '>=8.0.0'} dependencies: '@types/node': 12.20.55 web3-core: 1.10.0 @@ -13683,8 +11403,11 @@ snapshots: transitivePeerDependencies: - encoding - supports-color + dev: false - web3-eth-personal@1.10.4: + /web3-eth-personal@1.10.4: + resolution: {integrity: sha512-BRa/hs6jU1hKHz+AC/YkM71RP3f0Yci1dPk4paOic53R4ZZG4MgwKRkJhgt3/GPuPliwS46f/i5A7fEGBT4F9w==} + engines: {node: '>=8.0.0'} dependencies: '@types/node': 12.20.55 web3-core: 1.10.4 @@ -13696,11 +11419,13 @@ snapshots: - encoding - supports-color - web3-eth-personal@4.0.8(bufferutil@4.0.8)(typescript@5.0.4)(utf-8-validate@5.0.10)(zod@3.23.8): + /web3-eth-personal@4.0.8(typescript@5.0.4): + resolution: {integrity: sha512-sXeyLKJ7ddQdMxz1BZkAwImjqh7OmKxhXoBNF3isDmD4QDpMIwv/t237S3q4Z0sZQamPa/pHebJRWVuvP8jZdw==} + engines: {node: '>=14', npm: '>=6.12.0'} dependencies: - web3-core: 4.3.2(bufferutil@4.0.8)(utf-8-validate@5.0.10) - web3-eth: 4.6.0(bufferutil@4.0.8)(typescript@5.0.4)(utf-8-validate@5.0.10)(zod@3.23.8) - web3-rpc-methods: 1.2.0(bufferutil@4.0.8)(utf-8-validate@5.0.10) + web3-core: 4.3.2 + web3-eth: 4.6.0(typescript@5.0.4) + web3-rpc-methods: 1.2.0 web3-types: 1.6.0 web3-utils: 4.2.3 web3-validator: 2.0.5 @@ -13710,8 +11435,11 @@ snapshots: - typescript - utf-8-validate - zod + dev: true - web3-eth@1.10.0: + /web3-eth@1.10.0: + resolution: {integrity: sha512-Z5vT6slNMLPKuwRyKGbqeGYC87OAy8bOblaqRTgg94CXcn/mmqU7iPIlG4506YdcdK3x6cfEDG7B6w+jRxypKA==} + engines: {node: '>=8.0.0'} dependencies: web3-core: 1.10.0 web3-core-helpers: 1.10.0 @@ -13728,8 +11456,11 @@ snapshots: transitivePeerDependencies: - encoding - supports-color + dev: false - web3-eth@1.10.4: + /web3-eth@1.10.4: + resolution: {integrity: sha512-Sql2kYKmgt+T/cgvg7b9ce24uLS7xbFrxE4kuuor1zSCGrjhTJ5rRNG8gTJUkAJGKJc7KgnWmgW+cOfMBPUDSA==} + engines: {node: '>=8.0.0'} dependencies: web3-core: 1.10.4 web3-core-helpers: 1.10.4 @@ -13747,16 +11478,18 @@ snapshots: - encoding - supports-color - web3-eth@4.6.0(bufferutil@4.0.8)(typescript@5.0.4)(utf-8-validate@5.0.10)(zod@3.23.8): + /web3-eth@4.6.0(typescript@5.0.4): + resolution: {integrity: sha512-8KtxlGsomovoFULqEpfixgmCpaJ2YIJGxbXUfezh2coXHjVgEopQhARYtKGClyV5kkdCIqwHS8Gvsm6TVNqH6Q==} + engines: {node: '>=14', npm: '>=6.12.0'} dependencies: setimmediate: 1.0.5 - web3-core: 4.3.2(bufferutil@4.0.8)(utf-8-validate@5.0.10) + web3-core: 4.3.2 web3-errors: 1.1.4 - web3-eth-abi: 4.2.1(typescript@5.0.4)(zod@3.23.8) + web3-eth-abi: 4.2.1(typescript@5.0.4) web3-eth-accounts: 4.1.2 - web3-net: 4.0.7(bufferutil@4.0.8)(utf-8-validate@5.0.10) - web3-providers-ws: 4.0.7(bufferutil@4.0.8)(utf-8-validate@5.0.10) - web3-rpc-methods: 1.2.0(bufferutil@4.0.8)(utf-8-validate@5.0.10) + web3-net: 4.0.7 + web3-providers-ws: 4.0.7 + web3-rpc-methods: 1.2.0 web3-types: 1.6.0 web3-utils: 4.2.3 web3-validator: 2.0.5 @@ -13766,8 +11499,11 @@ snapshots: - typescript - utf-8-validate - zod + dev: true - web3-net@1.10.0: + /web3-net@1.10.0: + resolution: {integrity: sha512-NLH/N3IshYWASpxk4/18Ge6n60GEvWBVeM8inx2dmZJVmRI6SJIlUxbL8jySgiTn3MMZlhbdvrGo8fpUW7a1GA==} + engines: {node: '>=8.0.0'} dependencies: web3-core: 1.10.0 web3-core-method: 1.10.0 @@ -13775,8 +11511,11 @@ snapshots: transitivePeerDependencies: - encoding - supports-color + dev: false - web3-net@1.10.4: + /web3-net@1.10.4: + resolution: {integrity: sha512-mKINnhOOnZ4koA+yV2OT5s5ztVjIx7IY9a03w6s+yao/BUn+Luuty0/keNemZxTr1E8Ehvtn28vbOtW7Ids+Ow==} + engines: {node: '>=8.0.0'} dependencies: web3-core: 1.10.4 web3-core-method: 1.10.4 @@ -13785,18 +11524,23 @@ snapshots: - encoding - supports-color - web3-net@4.0.7(bufferutil@4.0.8)(utf-8-validate@5.0.10): + /web3-net@4.0.7: + resolution: {integrity: sha512-SzEaXFrBjY25iQGk5myaOfO9ZyfTwQEa4l4Ps4HDNVMibgZji3WPzpjq8zomVHMwi8bRp6VV7YS71eEsX7zLow==} + engines: {node: '>=14', npm: '>=6.12.0'} dependencies: - web3-core: 4.3.2(bufferutil@4.0.8)(utf-8-validate@5.0.10) - web3-rpc-methods: 1.2.0(bufferutil@4.0.8)(utf-8-validate@5.0.10) + web3-core: 4.3.2 + web3-rpc-methods: 1.2.0 web3-types: 1.6.0 web3-utils: 4.2.3 transitivePeerDependencies: - bufferutil - encoding - utf-8-validate + dev: true - web3-providers-http@1.10.0: + /web3-providers-http@1.10.0: + resolution: {integrity: sha512-eNr965YB8a9mLiNrkjAWNAPXgmQWfpBfkkn7tpEFlghfww0u3I0tktMZiaToJVcL2+Xq+81cxbkpeWJ5XQDwOA==} + engines: {node: '>=8.0.0'} dependencies: abortcontroller-polyfill: 1.7.5 cross-fetch: 3.1.8 @@ -13804,8 +11548,11 @@ snapshots: web3-core-helpers: 1.10.0 transitivePeerDependencies: - encoding + dev: false - web3-providers-http@1.10.4: + /web3-providers-http@1.10.4: + resolution: {integrity: sha512-m2P5Idc8hdiO0l60O6DSCPw0kw64Zgi0pMjbEFRmxKIck2Py57RQMu4bxvkxJwkF06SlGaEQF8rFZBmuX7aagQ==} + engines: {node: '>=8.0.0'} dependencies: abortcontroller-polyfill: 1.7.5 cross-fetch: 4.0.0 @@ -13814,7 +11561,9 @@ snapshots: transitivePeerDependencies: - encoding - web3-providers-http@4.1.0: + /web3-providers-http@4.1.0: + resolution: {integrity: sha512-6qRUGAhJfVQM41E5t+re5IHYmb5hSaLc02BE2MaRQsz2xKA6RjmHpOA5h/+ojJxEpI9NI2CrfDKOAgtJfoUJQg==} + engines: {node: '>=14', npm: '>=6.12.0'} dependencies: cross-fetch: 4.0.0 web3-errors: 1.1.4 @@ -13822,33 +11571,48 @@ snapshots: web3-utils: 4.2.3 transitivePeerDependencies: - encoding + dev: true - web3-providers-ipc@1.10.0: + /web3-providers-ipc@1.10.0: + resolution: {integrity: sha512-OfXG1aWN8L1OUqppshzq8YISkWrYHaATW9H8eh0p89TlWMc1KZOL9vttBuaBEi96D/n0eYDn2trzt22bqHWfXA==} + engines: {node: '>=8.0.0'} dependencies: oboe: 2.1.5 web3-core-helpers: 1.10.0 + dev: false - web3-providers-ipc@1.10.4: + /web3-providers-ipc@1.10.4: + resolution: {integrity: sha512-YRF/bpQk9z3WwjT+A6FI/GmWRCASgd+gC0si7f9zbBWLXjwzYAKG73bQBaFRAHex1hl4CVcM5WUMaQXf3Opeuw==} + engines: {node: '>=8.0.0'} dependencies: oboe: 2.1.5 web3-core-helpers: 1.10.4 - web3-providers-ipc@4.0.7: + /web3-providers-ipc@4.0.7: + resolution: {integrity: sha512-YbNqY4zUvIaK2MHr1lQFE53/8t/ejHtJchrWn9zVbFMGXlTsOAbNoIoZWROrg1v+hCBvT2c9z8xt7e/+uz5p1g==} + engines: {node: '>=14', npm: '>=6.12.0'} + requiresBuild: true dependencies: web3-errors: 1.1.4 web3-types: 1.6.0 web3-utils: 4.2.3 + dev: true optional: true - web3-providers-ws@1.10.0: + /web3-providers-ws@1.10.0: + resolution: {integrity: sha512-sK0fNcglW36yD5xjnjtSGBnEtf59cbw4vZzJ+CmOWIKGIR96mP5l684g0WD0Eo+f4NQc2anWWXG74lRc9OVMCQ==} + engines: {node: '>=8.0.0'} dependencies: eventemitter3: 4.0.4 web3-core-helpers: 1.10.0 websocket: 1.0.34 transitivePeerDependencies: - supports-color + dev: false - web3-providers-ws@1.10.4: + /web3-providers-ws@1.10.4: + resolution: {integrity: sha512-j3FBMifyuFFmUIPVQR4pj+t5ILhAexAui0opgcpu9R5LxQrLRUZxHSnU+YO25UycSOa/NAX8A+qkqZNpcFAlxA==} + engines: {node: '>=8.0.0'} dependencies: eventemitter3: 4.0.4 web3-core-helpers: 1.10.4 @@ -13856,29 +11620,38 @@ snapshots: transitivePeerDependencies: - supports-color - web3-providers-ws@4.0.7(bufferutil@4.0.8)(utf-8-validate@5.0.10): + /web3-providers-ws@4.0.7: + resolution: {integrity: sha512-n4Dal9/rQWjS7d6LjyEPM2R458V8blRm0eLJupDEJOOIBhGYlxw5/4FthZZ/cqB7y/sLVi7K09DdYx2MeRtU5w==} + engines: {node: '>=14', npm: '>=6.12.0'} dependencies: '@types/ws': 8.5.3 - isomorphic-ws: 5.0.0(ws@8.17.0(bufferutil@4.0.8)(utf-8-validate@5.0.10)) + isomorphic-ws: 5.0.0(ws@8.17.0) web3-errors: 1.1.4 web3-types: 1.6.0 web3-utils: 4.2.3 - ws: 8.17.0(bufferutil@4.0.8)(utf-8-validate@5.0.10) + ws: 8.17.0 transitivePeerDependencies: - bufferutil - utf-8-validate + dev: true - web3-rpc-methods@1.2.0(bufferutil@4.0.8)(utf-8-validate@5.0.10): + /web3-rpc-methods@1.2.0: + resolution: {integrity: sha512-CWJ/g4I4WyYvLkf21wCZAehdhU/VjX/OAPHnqF5/FPDJlogOsOnGXHqi1Z5AP+ocdt395PNubd8jyMMJoYGSBA==} + engines: {node: '>=14', npm: '>=6.12.0'} dependencies: - web3-core: 4.3.2(bufferutil@4.0.8)(utf-8-validate@5.0.10) + web3-core: 4.3.2 web3-types: 1.6.0 web3-validator: 2.0.5 transitivePeerDependencies: - bufferutil - encoding - utf-8-validate + dev: true - web3-shh@1.10.0: + /web3-shh@1.10.0: + resolution: {integrity: sha512-uNUUuNsO2AjX41GJARV9zJibs11eq6HtOe6Wr0FtRUcj8SN6nHeYIzwstAvJ4fXA53gRqFMTxdntHEt9aXVjpg==} + engines: {node: '>=8.0.0'} + requiresBuild: true dependencies: web3-core: 1.10.0 web3-core-method: 1.10.0 @@ -13887,8 +11660,12 @@ snapshots: transitivePeerDependencies: - encoding - supports-color + dev: false - web3-shh@1.10.4: + /web3-shh@1.10.4: + resolution: {integrity: sha512-cOH6iFFM71lCNwSQrC3niqDXagMqrdfFW85hC9PFUrAr3PUrIem8TNstTc3xna2bwZeWG6OBy99xSIhBvyIACw==} + engines: {node: '>=8.0.0'} + requiresBuild: true dependencies: web3-core: 1.10.4 web3-core-method: 1.10.4 @@ -13898,9 +11675,14 @@ snapshots: - encoding - supports-color - web3-types@1.6.0: {} + /web3-types@1.6.0: + resolution: {integrity: sha512-qgOtADqlD5hw+KPKBUGaXAcdNLL0oh6qTeVgXwewCfbL/lG9R+/GrgMQB1gbTJ3cit8hMwtH8KX2Em6OwO0HRw==} + engines: {node: '>=14', npm: '>=6.12.0'} + dev: true - web3-utils@1.10.0: + /web3-utils@1.10.0: + resolution: {integrity: sha512-kSaCM0uMcZTNUSmn5vMEhlo02RObGNRRCkdX0V9UTAU0+lrvn0HSaudyCo6CQzuXUsnuY2ERJGCGPfeWmv19Rg==} + engines: {node: '>=8.0.0'} dependencies: bn.js: 5.2.1 ethereum-bloom-filters: 1.1.0 @@ -13909,8 +11691,25 @@ snapshots: number-to-bn: 1.7.0 randombytes: 2.1.0 utf8: 3.0.0 + dev: false + + /web3-utils@1.10.3: + resolution: {integrity: sha512-OqcUrEE16fDBbGoQtZXWdavsPzbGIDc5v3VrRTZ0XrIpefC/viZ1ZU9bGEemazyS0catk/3rkOOxpzTfY+XsyQ==} + engines: {node: '>=8.0.0'} + dependencies: + '@ethereumjs/util': 8.1.0 + bn.js: 5.2.1 + ethereum-bloom-filters: 1.1.0 + ethereum-cryptography: 2.1.3 + ethjs-unit: 0.1.6 + number-to-bn: 1.7.0 + randombytes: 2.1.0 + utf8: 3.0.0 + dev: false - web3-utils@1.10.4: + /web3-utils@1.10.4: + resolution: {integrity: sha512-tsu8FiKJLk2PzhDl9fXbGUWTkkVXYhtTA+SmEFkKft+9BgwLxfCRpU96sWv7ICC8zixBNd3JURVoiR3dUXgP8A==} + engines: {node: '>=8.0.0'} dependencies: '@ethereumjs/util': 8.1.0 bn.js: 5.2.1 @@ -13921,41 +11720,54 @@ snapshots: randombytes: 2.1.0 utf8: 3.0.0 - web3-utils@4.2.3: + /web3-utils@4.2.3: + resolution: {integrity: sha512-m5plKTC2YtQntHITQRyIePw52UVP1IrShhmA2FACtn4zmc5ADmrXOlQWiPzxFP/18eRJsAaUAw2+CQn1u4WPxQ==} + engines: {node: '>=14', npm: '>=6.12.0'} dependencies: ethereum-cryptography: 2.1.3 eventemitter3: 5.0.1 web3-errors: 1.1.4 web3-types: 1.6.0 web3-validator: 2.0.5 + dev: true - web3-validator@2.0.5: + /web3-validator@2.0.5: + resolution: {integrity: sha512-2gLOSW8XqEN5pw5jVUm20EB7A8SbQiekpAtiI0JBmCIV0a2rp97v8FgWY5E3UEqnw5WFfEqvcDVW92EyynDTyQ==} + engines: {node: '>=14', npm: '>=6.12.0'} dependencies: ethereum-cryptography: 2.1.3 util: 0.12.5 web3-errors: 1.1.4 web3-types: 1.6.0 zod: 3.23.8 + dev: true - web3@0.20.6: + /web3@0.20.6: + resolution: {integrity: sha512-diON1+Y8sPQ33htuTMZfyo+qlsmCBSYwi+MVTRneS8anqZUaTrGaBkTpPkPUvfX1X+NK+Y2spLaaei3HfXeSuw==} dependencies: - bignumber.js: https://codeload.github.com/frozeman/bignumber.js-nolookahead/tar.gz/57692b3ecfc98bbdd6b3a516cb2353652ea49934 + bignumber.js: github.com/frozeman/bignumber.js-nolookahead/57692b3ecfc98bbdd6b3a516cb2353652ea49934 crypto-js: 3.3.0 utf8: 2.1.2 xhr2: 0.2.1 xmlhttprequest: 1.8.0 + dev: false - web3@0.20.7: + /web3@0.20.7: + resolution: {integrity: sha512-VU6/DSUX93d1fCzBz7WP/SGCQizO1rKZi4Px9j/3yRyfssHyFcZamMw2/sj4E8TlfMXONvZLoforR8B4bRoyTQ==} dependencies: - bignumber.js: https://codeload.github.com/frozeman/bignumber.js-nolookahead/tar.gz/57692b3ecfc98bbdd6b3a516cb2353652ea49934 + bignumber.js: github.com/frozeman/bignumber.js-nolookahead/57692b3ecfc98bbdd6b3a516cb2353652ea49934 crypto-js: 3.3.0 utf8: 2.1.2 xhr2-cookies: 1.1.0 xmlhttprequest: 1.8.0 + dev: true - web3@1.10.0(bufferutil@4.0.8)(utf-8-validate@5.0.10): + /web3@1.10.0: + resolution: {integrity: sha512-YfKY9wSkGcM8seO+daR89oVTcbu18NsVfvOngzqMYGUU0pPSQmE57qQDvQzUeoIOHAnXEBNzrhjQJmm8ER0rng==} + engines: {node: '>=8.0.0'} + requiresBuild: true dependencies: - web3-bzz: 1.10.0(bufferutil@4.0.8)(utf-8-validate@5.0.10) + web3-bzz: 1.10.0 web3-core: 1.10.0 web3-eth: 1.10.0 web3-eth-personal: 1.10.0 @@ -13967,10 +11779,14 @@ snapshots: - encoding - supports-color - utf-8-validate + dev: false - web3@1.10.4(bufferutil@4.0.8)(utf-8-validate@5.0.10): + /web3@1.10.4: + resolution: {integrity: sha512-kgJvQZjkmjOEKimx/tJQsqWfRDPTTcBfYPa9XletxuHLpHcXdx67w8EFn5AW3eVxCutE9dTVHgGa9VYe8vgsEA==} + engines: {node: '>=8.0.0'} + requiresBuild: true dependencies: - web3-bzz: 1.10.4(bufferutil@4.0.8)(utf-8-validate@5.0.10) + web3-bzz: 1.10.4 web3-core: 1.10.4 web3-eth: 1.10.4 web3-eth-personal: 1.10.4 @@ -13983,21 +11799,23 @@ snapshots: - supports-color - utf-8-validate - web3@4.8.0(bufferutil@4.0.8)(typescript@5.0.4)(utf-8-validate@5.0.10)(zod@3.23.8): + /web3@4.8.0(typescript@5.0.4): + resolution: {integrity: sha512-kQSF2NlHk8yjS3SRiJW3S+U5ibkEmVRhB4/GYsVwGvdAkFC2b+EIE1Ob7J56OmqW9VBZgkx1+SuWqo5JTIJSYQ==} + engines: {node: '>=14.0.0', npm: '>=6.12.0'} dependencies: - web3-core: 4.3.2(bufferutil@4.0.8)(utf-8-validate@5.0.10) + web3-core: 4.3.2 web3-errors: 1.1.4 - web3-eth: 4.6.0(bufferutil@4.0.8)(typescript@5.0.4)(utf-8-validate@5.0.10)(zod@3.23.8) - web3-eth-abi: 4.2.1(typescript@5.0.4)(zod@3.23.8) + web3-eth: 4.6.0(typescript@5.0.4) + web3-eth-abi: 4.2.1(typescript@5.0.4) web3-eth-accounts: 4.1.2 - web3-eth-contract: 4.4.0(bufferutil@4.0.8)(typescript@5.0.4)(utf-8-validate@5.0.10)(zod@3.23.8) - web3-eth-ens: 4.2.0(bufferutil@4.0.8)(typescript@5.0.4)(utf-8-validate@5.0.10)(zod@3.23.8) + web3-eth-contract: 4.4.0(typescript@5.0.4) + web3-eth-ens: 4.2.0(typescript@5.0.4) web3-eth-iban: 4.0.7 - web3-eth-personal: 4.0.8(bufferutil@4.0.8)(typescript@5.0.4)(utf-8-validate@5.0.10)(zod@3.23.8) - web3-net: 4.0.7(bufferutil@4.0.8)(utf-8-validate@5.0.10) + web3-eth-personal: 4.0.8(typescript@5.0.4) + web3-net: 4.0.7 web3-providers-http: 4.1.0 - web3-providers-ws: 4.0.7(bufferutil@4.0.8)(utf-8-validate@5.0.10) - web3-rpc-methods: 1.2.0(bufferutil@4.0.8)(utf-8-validate@5.0.10) + web3-providers-ws: 4.0.7 + web3-rpc-methods: 1.2.0 web3-types: 1.6.0 web3-utils: 4.2.3 web3-validator: 2.0.5 @@ -14007,10 +11825,14 @@ snapshots: - typescript - utf-8-validate - zod + dev: true - webidl-conversions@3.0.1: {} + /webidl-conversions@3.0.1: + resolution: {integrity: sha512-2JAn3z8AR6rjK8Sm8orRC0h/bcl/DqL7tRPdGZ4I1CjdF+EaMLmYxBHyXuKL849eucPFhvBoxMsflfOb8kxaeQ==} - websocket@1.0.34: + /websocket@1.0.34: + resolution: {integrity: sha512-PRDso2sGwF6kM75QykIesBijKSVceR6jL2G8NGYyq2XrItNC2P5/qL5XeR056GhA+Ly7JMFvJb9I312mJfmqnQ==} + engines: {node: '>=4.0.0'} dependencies: bufferutil: 4.0.8 debug: 2.6.9 @@ -14021,31 +11843,45 @@ snapshots: transitivePeerDependencies: - supports-color - whatwg-fetch@3.6.20: {} + /whatwg-fetch@3.6.20: + resolution: {integrity: sha512-EqhiFU6daOA8kpjOWTL0olhVOF3i7OrFzSYiGsEMB8GcXS+RrzauAERX65xMeNWVqxA6HXH2m69Z9LaKKdisfg==} + dev: true - whatwg-url@5.0.0: + /whatwg-url@5.0.0: + resolution: {integrity: sha512-saE57nupxk6v3HY35+jzBwYa0rKSy0XR8JSxZPwgLr7ys0IBzhGviA1/TUGJLmSVqs8pb9AnvICXEuOHLprYTw==} dependencies: tr46: 0.0.3 webidl-conversions: 3.0.1 - which-boxed-primitive@1.0.2: + /which-boxed-primitive@1.0.2: + resolution: {integrity: sha512-bwZdv0AKLpplFY2KZRX6TvyuN7ojjr7lwkg6ml0roIy9YeuSr7JS372qlNW18UQYzgYK9ziGcerWqZOmEn9VNg==} dependencies: is-bigint: 1.0.4 is-boolean-object: 1.1.2 is-number-object: 1.0.7 is-string: 1.0.7 is-symbol: 1.0.4 + dev: true - which-module@1.0.0: {} + /which-module@1.0.0: + resolution: {integrity: sha512-F6+WgncZi/mJDrammbTuHe1q0R5hOXv/mBaiNA2TCNT/LTHusX0V+CJnj9XT8ki5ln2UZyyddDgHfCzyrOH7MQ==} + dev: false - which-module@2.0.1: {} + /which-module@2.0.1: + resolution: {integrity: sha512-iBdZ57RDvnOR9AGBhML2vFZf7h8vmBjhoaZqODJBFWHVtKkDmKuHai3cx5PgVMrX5YDNp27AofYbAwctSS+vhQ==} + dev: true - which-pm@2.0.0: + /which-pm@2.0.0: + resolution: {integrity: sha512-Lhs9Pmyph0p5n5Z3mVnN0yWcbQYUAD7rbQUiMsQxOJ3T57k7RFe35SUwWMf7dsbDZks1uOmw4AecB/JMDj3v/w==} + engines: {node: '>=8.15'} dependencies: load-yaml-file: 0.2.0 path-exists: 4.0.0 + dev: true - which-typed-array@1.1.15: + /which-typed-array@1.1.15: + resolution: {integrity: sha512-oV0jmFtUky6CXfkqehVvBP/LSWJ2sy4vWMioiENyJLePrBO/yKyV9OyJySfAKosh+RYkIl5zJCNZ8/4JncrpdA==} + engines: {node: '>= 0.4'} dependencies: available-typed-arrays: 1.0.7 call-bind: 1.0.7 @@ -14053,96 +11889,174 @@ snapshots: gopd: 1.0.1 has-tostringtag: 1.0.2 - which@1.3.1: + /which@1.3.1: + resolution: {integrity: sha512-HxJdYWq1MTIQbJ3nw0cqssHoTNU267KlrDuGZ1WYlxDStUtKUhOaJmh112/TZmHxxUfuJqPXSOm7tDyas0OSIQ==} + hasBin: true dependencies: isexe: 2.0.0 + dev: true - which@2.0.2: + /which@2.0.2: + resolution: {integrity: sha512-BLI3Tl1TW3Pvl70l3yq3Y64i+awpwXqsGBYWkkqMtnbXgrMD+yj7rhW0kuEDxzJaYXGjEW5ogapKNMEKNMjibA==} + engines: {node: '>= 8'} + hasBin: true dependencies: isexe: 2.0.0 - widest-line@3.1.0: + /widest-line@3.1.0: + resolution: {integrity: sha512-NsmoXalsWVDMGupxZ5R08ka9flZjjiLvHVAWYOKtiKM8ujtZWr9cRffak+uSE48+Ob8ObalXpwyeUiyDD6QFgg==} + engines: {node: '>=8'} dependencies: string-width: 4.2.3 + dev: false - window-size@0.2.0: {} + /window-size@0.2.0: + resolution: {integrity: sha512-UD7d8HFA2+PZsbKyaOCEy8gMh1oDtHgJh1LfgjQ4zVXmYjAT/kvz3PueITKuqDiIXQe7yzpPnxX3lNc+AhQMyw==} + engines: {node: '>= 0.10.0'} + hasBin: true + dev: false - word-wrap@1.2.5: {} + /word-wrap@1.2.5: + resolution: {integrity: sha512-BN22B5eaMMI9UMtjrGd5g5eCYPpCPDUy0FJXbYsaT5zYxjFOckS53SQDE3pWkVoWpHXVb3BrYcEN4Twa55B5cA==} + engines: {node: '>=0.10.0'} - wordwrap@1.0.0: {} + /wordwrap@1.0.0: + resolution: {integrity: sha512-gvVzJFlPycKc5dZN4yPkP8w7Dc37BtP1yczEneOb4uq34pXZcvrtRTmWV8W+Ume+XCxKgbjM+nevkyFPMybd4Q==} + dev: true - wordwrapjs@4.0.1: + /wordwrapjs@4.0.1: + resolution: {integrity: sha512-kKlNACbvHrkpIw6oPeYDSmdCTu2hdMHoyXLTcUKala++lx5Y+wjJ/e474Jqv5abnVmwxw08DiTuHmw69lJGksA==} + engines: {node: '>=8.0.0'} dependencies: reduce-flatten: 2.0.0 typical: 5.2.0 + dev: true - workerpool@6.2.1: {} + /workerpool@6.2.1: + resolution: {integrity: sha512-ILEIE97kDZvF9Wb9f6h5aXK4swSlKGUcOEGiIYb2OOu/IrDU9iwj0fD//SsA6E5ibwJxpEvhullJY4Sl4GcpAw==} - wrap-ansi@2.1.0: + /wrap-ansi@2.1.0: + resolution: {integrity: sha512-vAaEaDM946gbNpH5pLVNR+vX2ht6n0Bt3GXwVB1AuAqZosOvHNF3P7wDnh8KLkSqgUh0uh77le7Owgoz+Z9XBw==} + engines: {node: '>=0.10.0'} dependencies: string-width: 1.0.2 strip-ansi: 3.0.1 + dev: false - wrap-ansi@6.2.0: + /wrap-ansi@6.2.0: + resolution: {integrity: sha512-r6lPcBGxZXlIcymEu7InxDMhdW0KDxpLgoFLcguasxCaJ/SOIZwINatK9KY/tf+ZrlywOKU0UDj3ATXUBfxJXA==} + engines: {node: '>=8'} dependencies: ansi-styles: 4.3.0 string-width: 4.2.3 strip-ansi: 6.0.1 + dev: true - wrap-ansi@7.0.0: + /wrap-ansi@7.0.0: + resolution: {integrity: sha512-YVGIj2kamLSTxw6NsZjoBxfSwsn0ycdesmc4p+Q21c5zPuZ1pl+NfxVdxPtdHvmNVOQ6XSYG4AUtyt/Fi7D16Q==} + engines: {node: '>=10'} dependencies: ansi-styles: 4.3.0 string-width: 4.2.3 strip-ansi: 6.0.1 - wrappy@1.0.2: {} + /wrappy@1.0.2: + resolution: {integrity: sha512-l4Sp/DRseor9wL6EvV2+TuQn63dMkPjZ/sp9XkghTEbV9KlPS1xUsZ3u7/IQO4wxtcFB4bgpQPRcR3QCvezPcQ==} - write-file-atomic@3.0.3: + /write-file-atomic@3.0.3: + resolution: {integrity: sha512-AvHcyZ5JnSfq3ioSyjrBkH9yW4m7Ayk8/9My/DD9onKeu/94fwrMocemO2QAJFAlnnDN+ZDS+ZjAR5ua1/PV/Q==} dependencies: imurmurhash: 0.1.4 is-typedarray: 1.0.0 signal-exit: 3.0.7 typedarray-to-buffer: 3.1.5 + dev: true - ws@3.3.3(bufferutil@4.0.8)(utf-8-validate@5.0.10): + /ws@3.3.3: + resolution: {integrity: sha512-nnWLa/NwZSt4KQJu51MYlCcSQ5g7INpOrOMt4XV8j4dqTXdmlUmSHQ8/oLC069ckre0fRsgfvsKwbTdtKLCDkA==} + peerDependencies: + bufferutil: ^4.0.1 + utf-8-validate: ^5.0.2 + peerDependenciesMeta: + bufferutil: + optional: true + utf-8-validate: + optional: true dependencies: async-limiter: 1.0.1 safe-buffer: 5.1.2 ultron: 1.1.1 - optionalDependencies: - bufferutil: 4.0.8 - utf-8-validate: 5.0.10 - ws@7.4.6(bufferutil@4.0.8)(utf-8-validate@5.0.10): - optionalDependencies: - bufferutil: 4.0.8 - utf-8-validate: 5.0.10 + /ws@7.4.6: + resolution: {integrity: sha512-YmhHDO4MzaDLB+M9ym/mDA5z0naX8j7SIlT8f8z+I0VtzsRbekxEutHSme7NPS2qE8StCYQNUnfWdXta/Yu85A==} + engines: {node: '>=8.3.0'} + peerDependencies: + bufferutil: ^4.0.1 + utf-8-validate: ^5.0.2 + peerDependenciesMeta: + bufferutil: + optional: true + utf-8-validate: + optional: true - ws@7.5.9(bufferutil@4.0.8)(utf-8-validate@5.0.10): - optionalDependencies: - bufferutil: 4.0.8 - utf-8-validate: 5.0.10 + /ws@7.5.9: + resolution: {integrity: sha512-F+P9Jil7UiSKSkppIiD94dN07AwvFixvLIj1Og1Rl9GGMuNipJnV9JzjD6XuqmAeiswGvUmNLjr5cFuXwNS77Q==} + engines: {node: '>=8.3.0'} + peerDependencies: + bufferutil: ^4.0.1 + utf-8-validate: ^5.0.2 + peerDependenciesMeta: + bufferutil: + optional: true + utf-8-validate: + optional: true + dev: false - ws@8.13.0(bufferutil@4.0.8)(utf-8-validate@5.0.10): - optionalDependencies: - bufferutil: 4.0.8 - utf-8-validate: 5.0.10 + /ws@8.13.0: + resolution: {integrity: sha512-x9vcZYTrFPC7aSIbj7sRCYo7L/Xb8Iy+pW0ng0wt2vCJv7M9HOMy0UoN3rr+IFC7hb7vXoqS+P9ktyLLLhO+LA==} + engines: {node: '>=10.0.0'} + peerDependencies: + bufferutil: ^4.0.1 + utf-8-validate: '>=5.0.2' + peerDependenciesMeta: + bufferutil: + optional: true + utf-8-validate: + optional: true + dev: true - ws@8.17.0(bufferutil@4.0.8)(utf-8-validate@5.0.10): - optionalDependencies: - bufferutil: 4.0.8 - utf-8-validate: 5.0.10 + /ws@8.17.0: + resolution: {integrity: sha512-uJq6108EgZMAl20KagGkzCKfMEjxmKvZHG7Tlq0Z6nOky7YF7aq4mOx6xK8TJ/i1LeK4Qus7INktacctDgY8Ow==} + engines: {node: '>=10.0.0'} + peerDependencies: + bufferutil: ^4.0.1 + utf-8-validate: '>=5.0.2' + peerDependenciesMeta: + bufferutil: + optional: true + utf-8-validate: + optional: true + dev: true - ws@8.5.0(bufferutil@4.0.8)(utf-8-validate@5.0.10): - optionalDependencies: - bufferutil: 4.0.8 - utf-8-validate: 5.0.10 + /ws@8.5.0: + resolution: {integrity: sha512-BWX0SWVgLPzYwF8lTzEy1egjhS4S4OEAHfsO8o65WOVsrnSRGaSiUaa9e0ggGlkMTtBlmOpEXiie9RUcBO86qg==} + engines: {node: '>=10.0.0'} + peerDependencies: + bufferutil: ^4.0.1 + utf-8-validate: ^5.0.2 + peerDependenciesMeta: + bufferutil: + optional: true + utf-8-validate: + optional: true - xhr-request-promise@0.1.3: + /xhr-request-promise@0.1.3: + resolution: {integrity: sha512-YUBytBsuwgitWtdRzXDDkWAXzhdGB8bYm0sSzMPZT7Z2MBjMSTHFsyCT1yCRATY+XC69DUrQraRAEgcoCRaIPg==} dependencies: xhr-request: 1.1.0 - xhr-request@1.1.0: + /xhr-request@1.1.0: + resolution: {integrity: sha512-Y7qzEaR3FDtL3fP30k9wO/e+FBnBByZeybKOhASsGP30NIkRAAkKD/sCnLvgEfAIEC1rcmK7YG8f4oEnIrrWzA==} dependencies: buffer-to-arraybuffer: 0.0.5 object-assign: 4.1.1 @@ -14152,57 +12066,92 @@ snapshots: url-set-query: 1.0.0 xhr: 2.6.0 - xhr2-cookies@1.1.0: + /xhr2-cookies@1.1.0: + resolution: {integrity: sha512-hjXUA6q+jl/bd8ADHcVfFsSPIf+tyLIjuO9TwJC9WI6JP2zKcS7C+p56I9kCLLsaCiNT035iYvEUUzdEFj/8+g==} dependencies: cookiejar: 2.1.4 + dev: true - xhr2@0.2.1: {} + /xhr2@0.2.1: + resolution: {integrity: sha512-sID0rrVCqkVNUn8t6xuv9+6FViXjUVXq8H5rWOH2rz9fDNQEd4g0EA2XlcEdJXRz5BMEn4O1pJFdT+z4YHhoWw==} + engines: {node: '>= 6'} + dev: false - xhr@2.6.0: + /xhr@2.6.0: + resolution: {integrity: sha512-/eCGLb5rxjx5e3mF1A7s+pLlR6CGyqWN91fv1JgER5mVWg1MZmlhBvy9kjcsOdRk8RrIujotWyJamfyrp+WIcA==} dependencies: global: 4.4.0 is-function: 1.0.2 parse-headers: 2.0.5 xtend: 4.0.2 - xmlhttprequest@1.8.0: {} + /xmlhttprequest@1.8.0: + resolution: {integrity: sha512-58Im/U0mlVBLM38NdZjHyhuMtCqa61469k2YP/AaPbvCoV9aQGUpbJBj1QRm2ytRiVQBD/fsw7L2bJGDVQswBA==} + engines: {node: '>=0.4.0'} - xtend@4.0.2: {} + /xtend@4.0.2: + resolution: {integrity: sha512-LKYU1iAXJXUgAXn9URjiu+MWhyUXHsvfp7mcuYm9dSUKK0/CjtrUwFAxD82/mCWbtLsGjFIad0wIsod4zrTAEQ==} + engines: {node: '>=0.4'} - y18n@3.2.2: {} + /y18n@3.2.2: + resolution: {integrity: sha512-uGZHXkHnhF0XeeAPgnKfPv1bgKAYyVvmNL1xlKsPYZPaIHxGti2hHqvOCQv71XMsLxu1QjergkqogUnms5D3YQ==} + dev: false - y18n@4.0.3: {} + /y18n@4.0.3: + resolution: {integrity: sha512-JKhqTOwSrqNA1NY5lSztJ1GrBiUodLMmIZuLiDaMRJ+itFd+ABVE8XBjOvIWL+rSqNDC74LCSFmlb/U4UZ4hJQ==} + dev: true - y18n@5.0.8: {} + /y18n@5.0.8: + resolution: {integrity: sha512-0pfFzegeDWJHJIAmTLRP2DwHjdF5s7jo9tuztdQxAhINCdvS+3nGINqPd00AphqJR/0LhANUS6/+7SCb98YOfA==} + engines: {node: '>=10'} - yaeti@0.0.6: {} + /yaeti@0.0.6: + resolution: {integrity: sha512-MvQa//+KcZCUkBTIC9blM+CU9J2GzuTytsOUwf2lidtvkx/6gnEp1QvJv34t9vdjhFmha/mUiNDbN0D0mJWdug==} + engines: {node: '>=0.10.32'} - yallist@2.1.2: {} + /yallist@2.1.2: + resolution: {integrity: sha512-ncTzHV7NvsQZkYe1DW7cbDLm0YpzHmZF5r/iyP3ZnQtMiJ+pjzisCiMNI+Sj+xQF5pXhSHxSB3uDbsBTzY/c2A==} + dev: true - yallist@3.1.1: {} + /yallist@3.1.1: + resolution: {integrity: sha512-a4UGQaWPH59mOXUYnAG2ewncQS4i4F43Tv3JoAM+s2VDAmS9NsK8GpDMLrCHPksFT7h3K6TOoUNn2pb7RoXx4g==} - yargs-parser@18.1.3: + /yargs-parser@18.1.3: + resolution: {integrity: sha512-o50j0JeToy/4K6OZcaQmW6lyXXKhq7csREXcDwk2omFPJEwUNOVtJKvmDr9EI1fAJZUyZcRF7kxGBWmRXudrCQ==} + engines: {node: '>=6'} dependencies: camelcase: 5.3.1 decamelize: 1.2.0 + dev: true - yargs-parser@2.4.1: + /yargs-parser@2.4.1: + resolution: {integrity: sha512-9pIKIJhnI5tonzG6OnCFlz/yln8xHYcGl+pn3xR0Vzff0vzN1PbNRaelgfgRUwZ3s4i3jvxT9WhmUGL4whnasA==} dependencies: camelcase: 3.0.0 lodash.assign: 4.2.0 + dev: false - yargs-parser@20.2.4: {} + /yargs-parser@20.2.4: + resolution: {integrity: sha512-WOkpgNhPTlE73h4VFAFsOnomJVaovO8VqLDzy5saChRBFQFBoMYirowyW+Q9HB4HFF4Z7VZTiG3iSzJJA29yRA==} + engines: {node: '>=10'} - yargs-parser@21.1.1: {} + /yargs-parser@21.1.1: + resolution: {integrity: sha512-tVpsJW7DdjecAiFpbIB1e3qxIQsE6NoPc5/eTdrbbIC4h0LVsWhnoa3g+m2HclBIujHzsxZ4VJVA+GUuc2/LBw==} + engines: {node: '>=12'} + dev: true - yargs-unparser@2.0.0: + /yargs-unparser@2.0.0: + resolution: {integrity: sha512-7pRTIA9Qc1caZ0bZ6RYRGbHJthJWuakf+WmHK0rVeLkNrrGhfoabBNdue6kdINI6r4if7ocq9aD/n7xwKOdzOA==} + engines: {node: '>=10'} dependencies: camelcase: 6.3.0 decamelize: 4.0.0 flat: 5.0.2 is-plain-obj: 2.1.0 - yargs@15.4.1: + /yargs@15.4.1: + resolution: {integrity: sha512-aePbxDmcYW++PaqBsJ+HYUFwCdv4LVvdnhBy78E57PIor8/OVvhMrADFFEDh8DHDFRv/O9i3lPhsENjO7QX0+A==} + engines: {node: '>=8'} dependencies: cliui: 6.0.0 decamelize: 1.2.0 @@ -14215,8 +12164,11 @@ snapshots: which-module: 2.0.1 y18n: 4.0.3 yargs-parser: 18.1.3 + dev: true - yargs@16.2.0: + /yargs@16.2.0: + resolution: {integrity: sha512-D1mvvtDG0L5ft/jGWkLpG1+m0eQxOfaBvTNELraWj22wSVUMWxZUvYgJYcKh6jGGIkJFhH4IZPQhR4TKpc8mBw==} + engines: {node: '>=10'} dependencies: cliui: 7.0.4 escalade: 3.1.2 @@ -14226,7 +12178,9 @@ snapshots: y18n: 5.0.8 yargs-parser: 20.2.4 - yargs@17.7.2: + /yargs@17.7.2: + resolution: {integrity: sha512-7dSzzRQ++CKnNI/krKnYRV7JKKPUXMEh61soaHKg9mrWEhzFWhFnxPxGl+69cD1Ou63C13NUPCnmIcrvqCuM6w==} + engines: {node: '>=12'} dependencies: cliui: 8.0.1 escalade: 3.1.2 @@ -14235,8 +12189,10 @@ snapshots: string-width: 4.2.3 y18n: 5.0.8 yargs-parser: 21.1.1 + dev: true - yargs@4.8.1: + /yargs@4.8.1: + resolution: {integrity: sha512-LqodLrnIDM3IFT+Hf/5sxBnEGECrfdC1uIbgZeJmESCSo4HoCAaKEus8MylXHAkdacGc0ye+Qa+dpkuom8uVYA==} dependencies: cliui: 3.2.0 decamelize: 1.2.0 @@ -14252,9 +12208,22 @@ snapshots: window-size: 0.2.0 y18n: 3.2.2 yargs-parser: 2.4.1 + dev: false - yn@3.1.1: {} + /yn@3.1.1: + resolution: {integrity: sha512-Ux4ygGWsu2c7isFWe8Yu1YluJmqVhxqK2cLXNQA5AcC3QfbGNpM7fu0Y8b/z16pXLnFxZYvWhd3fhBY9DLmC6Q==} + engines: {node: '>=6'} + dev: true + + /yocto-queue@0.1.0: + resolution: {integrity: sha512-rVksvsnNCdJ/ohGc6xgPwyN8eheCxsiLM8mxuE/t/mOVqJewPuO1miLpTHQiRgTKCLexL4MeAFVagts7HmNZ2Q==} + engines: {node: '>=10'} - yocto-queue@0.1.0: {} + /zod@3.23.8: + resolution: {integrity: sha512-XBx9AXhXktjUqnepgTiE5flcKIYWi/rme0Eaj+5Y0lftuGBq+jyRu/md4WnuxqgP1ubdpNCsYEYPxrzVHD8d6g==} + dev: true - zod@3.23.8: {} + github.com/frozeman/bignumber.js-nolookahead/57692b3ecfc98bbdd6b3a516cb2353652ea49934: + resolution: {tarball: https://codeload.github.com/frozeman/bignumber.js-nolookahead/tar.gz/57692b3ecfc98bbdd6b3a516cb2353652ea49934} + name: bignumber.js + version: 2.0.7