diff --git a/packages/hardhat/contracts/claim/GeneratePeriodicTranches.sol b/packages/hardhat/contracts/claim/GeneratePeriodicTranches.sol new file mode 100644 index 00000000..419d5cdc --- /dev/null +++ b/packages/hardhat/contracts/claim/GeneratePeriodicTranches.sol @@ -0,0 +1,50 @@ +// SPDX-License-Identifier: MIT +pragma solidity 0.8.21; + +contract TrancheVesting { + struct Tranche { + uint256 time; + uint256 vestedFraction; + uint256 date; + } + + function generatePeriodicTranches(uint256 startTime, uint256 cliffTime, uint256 endTime, string memory units) external pure returns (Tranche[] memory) { + uint256 totalTranches = getDifference(startTime, endTime, units); + + Tranche[] memory tranches = new Tranche[](totalTranches); + + uint256 currentIndex = 0; + + for (uint256 i = 0; i < totalTranches; i++) { + uint256 trancheStartTime = addToDateTime(startTime, i, units); + + if (trancheStartTime < cliffTime) { + continue; + } + + uint256 vestedFraction = ((i + 1) * (100 / totalTranches)) * 100; + + tranches[currentIndex] = Tranche({ + time: trancheStartTime, + vestedFraction: vestedFraction, + date: trancheStartTime + }); + + currentIndex++; + } + + return tranches; + } + + // Function to calculate the difference between two timestamps + function getDifference(uint256 startTime, uint256 endTime, string memory units) internal pure returns (uint256) { + // Implementation of getDifference based on units + // You need to implement this function according to your requirements + } + + // Function to add time to a given timestamp + function addToDateTime(uint256 timestamp, uint256 amount, string memory units) internal pure returns (uint256) { + // Implementation of addToDateTime based on units + // You need to implement this function according to your requirements + } +} diff --git a/packages/hardhat/contracts/claim/PerAddressTrancheVestingMerkle.sol b/packages/hardhat/contracts/claim/PerAddressTrancheVestingMerkle.sol new file mode 100644 index 00000000..1050e6d2 --- /dev/null +++ b/packages/hardhat/contracts/claim/PerAddressTrancheVestingMerkle.sol @@ -0,0 +1,74 @@ +// SPDX-License-Identifier: MIT +pragma solidity 0.8.21; + +import { IERC20 } from '@openzeppelin/contracts/token/ERC20/IERC20.sol'; + +import { PerAddressTrancheVesting, Tranche } from './abstract/PerAddressTrancheVesting.sol'; +import { MerkleSet } from './abstract/MerkleSet.sol'; + +contract PerAddressTrancheVestingMerkle is PerAddressTrancheVesting, MerkleSet { + constructor( + IERC20 _token, + uint256 _total, + string memory _uri, // information on the sale (e.g. merkle proofs) + uint256 _voteFactor, + uint256 _start, + uint256 _end, + uint256 _cliff, + bytes32 _merkleRoot, + uint160 _maxDelayTime // the maximum delay time for the fair queue + ) + PerAddressTrancheVesting( + _token, + _total, + _uri, + _voteFactor, + _start, + _end, + _cliff, + _maxDelayTime, + uint160(uint256(_merkleRoot)) + ) + MerkleSet(_merkleRoot) + {} + + function NAME() external pure override returns (string memory) { + return 'PerAddressTrancheVestingMerkle'; + } + + function VERSION() external pure override returns (uint256) { + return 3; + } + + function initializeDistributionRecord( + uint256 index, // the beneficiary's index in the merkle root + address beneficiary, // the address that will receive tokens + uint256 amount, // the total claimable by this beneficiary + bytes32[] calldata merkleProof + ) + external + validMerkleProof(keccak256(abi.encodePacked(index, beneficiary, amount)), merkleProof) + { + _initializeDistributionRecord(beneficiary, amount); + } + + function claim( + uint256 index, // the beneficiary's index in the merkle root + address beneficiary, // the address that will receive tokens + uint256 totalAmount, // the total claimable by this beneficiary + bytes32[] calldata merkleProof + ) + external + validMerkleProof(keccak256(abi.encodePacked(index, beneficiary, totalAmount)), merkleProof) + nonReentrant + { + // effects + uint256 claimedAmount = _executeClaim(beneficiary, totalAmount); + // interactions + _settleClaim(beneficiary, claimedAmount); + } + + function setMerkleRoot(bytes32 _merkleRoot) external onlyOwner { + _setMerkleRoot(_merkleRoot); + } +} diff --git a/packages/hardhat/contracts/claim/abstract/PerAddressContinuousVesting.sol b/packages/hardhat/contracts/claim/abstract/PerAddressContinuousVesting.sol new file mode 100644 index 00000000..27765b63 --- /dev/null +++ b/packages/hardhat/contracts/claim/abstract/PerAddressContinuousVesting.sol @@ -0,0 +1,86 @@ +// SPDX-License-Identifier: MIT +pragma solidity 0.8.21; + +import { Distributor, AdvancedDistributor } from "./AdvancedDistributor.sol"; +import { IContinuousVesting } from "../../interfaces/IContinuousVesting.sol"; +import "@openzeppelin/contracts/token/ERC20/IERC20.sol"; + +abstract contract ContinuousVesting is AdvancedDistributor, IContinuousVesting { + uint256 private start; // time vesting clock begins + uint256 private cliff; // time vesting begins (all tokens vested prior to the cliff are immediately claimable) + uint256 private end; // time vesting clock ends + + constructor( + IERC20 _token, + uint256 _total, + string memory _uri, + uint256 _voteFactor, + uint256 _start, + uint256 _cliff, + uint256 _end, + uint160 _maxDelayTime, + uint160 _salt + ) + // use a large fraction denominator to provide the highest resolution on continuous vesting. + AdvancedDistributor(_token, _total, _uri, _voteFactor, 10**18, _maxDelayTime, _salt) + { + // require(_start <= _cliff, "vesting cliff before start"); + // require(_cliff <= _end, "vesting end before cliff"); + // require(_end <= 4102444800, "vesting ends after 4102444800 (Jan 1 2100)"); + + // start = _start; + // cliff = _cliff; + // end = _end; + + emit SetContinuousVesting(start, cliff, end); + } + + function getVestedFraction( + address beneficiary, + uint256 time, // time is in seconds past the epoch (e.g. block.timestamp) + uint256 _start, + uint256 _cliff, + uint256 _end + + ) public view returns (uint256) { + uint256 delayedTime = time- getFairDelayTime(beneficiary); + // no tokens are vested + if (delayedTime <= cliff) { + return 0; + } + + // all tokens are vested + if (delayedTime >= end) { + return fractionDenominator; + } + + // some tokens are vested + return (fractionDenominator * (delayedTime - start)) / (end - start); + } + + function getVestingConfig() + external + view + returns ( + uint256, + uint256, + uint256 + ) + { + // We probably need to update this so that it takes in an address + return (start, cliff, end); + } + + // Adjustable admin functions + function setVestingConfig( + uint256 _start, + uint256 _cliff, + uint256 _end + ) external onlyOwner { + start = _start; + cliff = _cliff; + end = _end; + // We probably don't need this function anymore, as it'll be per address + emit SetContinuousVesting(start, cliff, end); + } +} diff --git a/packages/hardhat/contracts/claim/abstract/PerAddressTrancheVesting.sol b/packages/hardhat/contracts/claim/abstract/PerAddressTrancheVesting.sol new file mode 100644 index 00000000..65439a9c --- /dev/null +++ b/packages/hardhat/contracts/claim/abstract/PerAddressTrancheVesting.sol @@ -0,0 +1,121 @@ +// SPDX-License-Identifier: MIT +pragma solidity 0.8.21; + +import { AdvancedDistributor } from './AdvancedDistributor.sol'; +import { IPerAddressTrancheVesting, Tranche } from '../../interfaces/IPerAddressTrancheVesting.sol'; +import { IERC20 } from '@openzeppelin/contracts/token/ERC20/IERC20.sol'; +import "hardhat/console.sol"; + +/** + * @title TrancheVesting + * @notice Distributes funds to beneficiaries over time in tranches. + */ +abstract contract PerAddressTrancheVesting is AdvancedDistributor, IPerAddressTrancheVesting { + // time and vested fraction must monotonically increase in the tranche array + Tranche[] private tranches; + + constructor( + IERC20 _token, + uint256 _total, + string memory _uri, + uint256 _voteFactor, + uint256 _start, + uint256 _end, + uint256 _cliff, + uint160 _maxDelayTime, + uint160 _salt + ) AdvancedDistributor(_token, _total, _uri, _voteFactor, 10000, _maxDelayTime, _salt) { + // tranches can be set in the constructor or in setTranches() + _setTranches(_start, _end, _cliff); + } + + /** + * @notice Get the vested fraction for a beneficiary at a given time. + * @dev Before the first tranche time, the vested fraction will be 0. At times between + * tranche_i and tranche_i+1, the vested fraction will be tranche_i+1's vested fraction. + * After the last tranche time, the vested fraction will be the fraction denominator. + */ + function getVestedFraction( + address beneficiary, + uint256 time, + uint256 _start, + uint256 _end, + uint256 _cliff + ) public view returns (uint256) { + // tranches = calculate the the tranche from start, end, cliff from record, record.start, record.end, record.cliff, + // calculateTranche(beneficiary, record); + + uint256 delay = getFairDelayTime(beneficiary); + for (uint256 i = tranches.length; i != 0; ) { + unchecked { + --i; + } + + if (time - delay > tranches[i].time) { + return tranches[i].vestedFraction; + } + } + + return 0; + } + + // Get a single tranche + function getTranche(uint256 i) public view returns (Tranche memory) { + return tranches[i]; + } + + // Get all tranches + function getTranches() public view returns (Tranche[] memory) { + return tranches; + } + + /** + * @dev Tranches can be updated at any time. The quantity of tokens a user can claim is based on the + * claimable quantity at the time of the claim and the quantity of tokens already claimed by the user. + */ + function _setTranches( + uint256 _start, + uint256 _end, + uint256 _cliff + ) private { + + // TODO: create tranches based off start, end, and cliff + Tranche[] memory _tranches = new Tranche[](3); + + require(_tranches.length != 0, 'tranches required'); + + delete tranches; + + uint128 lastTime = 0; + uint128 lastVestedFraction = 0; + + for (uint256 i = 0; i < _tranches.length; ) { + require(_tranches[i].vestedFraction != 0, 'tranche vested fraction == 0'); + require(_tranches[i].time > lastTime, 'tranche time must increase'); + require( + _tranches[i].vestedFraction > lastVestedFraction, + 'tranche vested fraction must increase' + ); + lastTime = _tranches[i].time; + lastVestedFraction = _tranches[i].vestedFraction; + tranches.push(_tranches[i]); + + emit SetTranche(i, lastTime, lastVestedFraction); + + unchecked { + ++i; + } + } + + require(lastTime <= 4102444800, 'vesting ends after 4102444800 (Jan 1 2100)'); + require(lastVestedFraction == fractionDenominator, 'last tranche must vest all tokens'); + } + + /** + * @notice Set the vesting tranches. Tranches must be sorted by time and vested fraction must monotonically increase. + * The last tranche must vest all tokens (vestedFraction == fractionDenominator) + */ + function setTranches(uint256 _start, uint256 _end, uint256 _cliff) external onlyOwner { + _setTranches(_start, _end, _cliff); + } +} diff --git a/packages/hardhat/contracts/claim/factory/PerAddressDistributorInitializable.sol b/packages/hardhat/contracts/claim/factory/PerAddressDistributorInitializable.sol new file mode 100644 index 00000000..21bf5cef --- /dev/null +++ b/packages/hardhat/contracts/claim/factory/PerAddressDistributorInitializable.sol @@ -0,0 +1,120 @@ +// SPDX-License-Identifier: MIT +pragma solidity 0.8.21; + +import "@openzeppelin/contracts/proxy/utils/Initializable.sol"; +import {SafeERC20} from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol"; +import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol"; +import {ReentrancyGuard} from "@openzeppelin/contracts/security/ReentrancyGuard.sol"; + +import {IDistributor, DistributionRecord} from "../../interfaces/IDistributor.sol"; + +/** + * @title Distributor + * @notice Distributes funds to beneficiaries and tracks distribution status + */ +abstract contract DistributorInitializable is Initializable, IDistributor, ReentrancyGuard { + using SafeERC20 for IERC20; + + mapping(address => DistributionRecord) internal records; // track distribution records per user + IERC20 public token; // the token being claimed + uint256 public total; // total tokens allocated for claims + uint256 public claimed; // tokens already claimed + string public uri; // ipfs link on distributor info + uint256 internal fractionDenominator; // denominator for vesting fraction (e.g. if vested fraction is 100 and fractionDenominator is 10000, 1% of tokens have vested) + + // provide context on the contract name and version + function NAME() external view virtual returns (string memory); + + function VERSION() external view virtual returns (uint256); + + function __Distributor_init(IERC20 _token, uint256 _total, string memory _uri, uint256 _fractionDenominator) + internal + onlyInitializing + { + require(address(_token) != address(0), "Distributor: token is address(0)"); + require(_total > 0, "Distributor: total is 0"); + + token = _token; + total = _total; + uri = _uri; + fractionDenominator = _fractionDenominator; + emit InitializeDistributor(token, total, uri, fractionDenominator); + } + + /** + * @dev Set up the distribution record for a user. Permissions are not checked in this function. + * Amount is limited to type(uint120).max to allow each DistributionRecord to be packed into a single storage slot. + * + * @param beneficiary The address of the beneficiary + * @param _totalAmount The total amount of tokens to be distributed to the beneficiary + */ + function _initializeDistributionRecord(address beneficiary, uint256 _totalAmount) internal virtual { + // Checks + require(_totalAmount <= type(uint120).max, "Distributor: totalAmount > type(uint120).max"); + uint120 totalAmount = uint120(_totalAmount); + + // Effects - note that the existing claimed quantity is re-used during re-initialization + records[beneficiary] = DistributionRecord(true, totalAmount, records[beneficiary].claimed); + emit InitializeDistributionRecord(beneficiary, totalAmount); + } + + /** + * @notice Record the claim internally: + * @dev This function does not check permissions: caller must verify the claim is valid! + * this function should not call any untrusted external contracts to avoid reentrancy + */ + function _executeClaim(address beneficiary, uint256 _totalAmount) internal virtual returns (uint256) { + uint120 totalAmount = uint120(_totalAmount); + + // effects + if (records[beneficiary].total != totalAmount) { + // re-initialize if the total has been updated + _initializeDistributionRecord(beneficiary, totalAmount); + } + + uint120 claimableAmount = uint120(getClaimableAmount(beneficiary)); + require(claimableAmount > 0, "Distributor: no more tokens claimable right now"); + + records[beneficiary].claimed += claimableAmount; + claimed += claimableAmount; + + return claimableAmount; + } + + /** + * @dev Move tokens associated with the claim to the recipient. This function should be called + * after the claim has been executed internally to avoid reentrancy issues. + * @param _recipient The address of the recipient + * @param _amount The amount of tokens to be transferred during this claim + */ + function _settleClaim(address _recipient, uint256 _amount) internal virtual { + token.safeTransfer(_recipient, _amount); + emit Claim(_recipient, _amount); + } + + /// @notice return a distribution record + function getDistributionRecord(address beneficiary) external view virtual returns (DistributionRecord memory) { + return records[beneficiary]; + } + + // Get tokens vested as fraction of fractionDenominator + function getVestedFraction(address beneficiary, uint256 time) public view virtual returns (uint256); + + function getFractionDenominator() public view returns (uint256) { + return fractionDenominator; + } + + // get the number of tokens currently claimable by a specific use + function getClaimableAmount(address beneficiary) public view virtual returns (uint256) { + require(records[beneficiary].initialized, "Distributor: claim not initialized"); + + DistributionRecord memory record = records[beneficiary]; + + // Pass in start, end, cliff from record + // uint256 claimable = (record.total * getVestedFraction(beneficiary, block.timestamp, record.start, record.end, record.cliff)) / fractionDenominator; + uint256 claimable = (record.total * getVestedFraction(beneficiary, block.timestamp)) / fractionDenominator; + return record.claimed >= claimable + ? 0 // no more tokens to claim + : claimable - record.claimed; // claim all available tokens + } +} diff --git a/packages/hardhat/contracts/interfaces/IPerAddressTrancheVesting.sol b/packages/hardhat/contracts/interfaces/IPerAddressTrancheVesting.sol new file mode 100644 index 00000000..302f2525 --- /dev/null +++ b/packages/hardhat/contracts/interfaces/IPerAddressTrancheVesting.sol @@ -0,0 +1,19 @@ +// SPDX-License-Identifier: MIT +pragma solidity 0.8.21; + +import "@openzeppelin/contracts/token/ERC20/IERC20.sol"; + +struct Tranche { + uint128 time; // block.timestamp upon which the tranche vests + uint128 vestedFraction; // fraction of tokens unlockable as basis points (e.g. 100% of vested tokens is the fraction denominator, defaulting to 10000) +} + +interface IPerAddressTrancheVesting { + event SetTranche(uint256 indexed index, uint128 time, uint128 VestedFraction); + + function getTranche(uint256 i) external view returns (Tranche memory); + + function getTranches() external view returns (Tranche[] memory); + + function setTranches(uint256 _start, uint256 _end, uint256 _cliff) external; +} diff --git a/packages/hardhat/docs/index.md b/packages/hardhat/docs/index.md new file mode 100644 index 00000000..51387dbe --- /dev/null +++ b/packages/hardhat/docs/index.md @@ -0,0 +1,5866 @@ +# Solidity API + +## BasicDistributor + +### constructor + +```solidity +constructor(contract IERC20 _token, uint256 _total, string _uri, uint256 _voteFactor, address[] _recipients, uint256[] _amounts) public +``` + +### getVestedFraction + +```solidity +function getVestedFraction(address, uint256) public view returns (uint256) +``` + +### NAME + +```solidity +function NAME() external pure virtual returns (string) +``` + +_get a human-readable name for the distributor that describes basic functionality +On-chain consumers should rely on registered ERC165 interface IDs or similar for more specificity_ + +### VERSION + +```solidity +function VERSION() external pure virtual returns (uint256) +``` + +_get a human-readable version for the distributor that describes basic functionality +The version should update whenever functionality significantly changes +On-chain consumers should rely on registered ERC165 interface IDs or similar for more specificity_ + +### claim + +```solidity +function claim(address beneficiary) external +``` + +## ContinuousVestingMerkle + +### constructor + +```solidity +constructor(contract IERC20 _token, uint256 _total, string _uri, uint256 _voteFactor, uint256 _start, uint256 _cliff, uint256 _end, bytes32 _merkleRoot, uint160 _maxDelayTime) public +``` + +### NAME + +```solidity +function NAME() external pure returns (string) +``` + +_get a human-readable name for the distributor that describes basic functionality +On-chain consumers should rely on registered ERC165 interface IDs or similar for more specificity_ + +### VERSION + +```solidity +function VERSION() external pure returns (uint256) +``` + +_get a human-readable version for the distributor that describes basic functionality +The version should update whenever functionality significantly changes +On-chain consumers should rely on registered ERC165 interface IDs or similar for more specificity_ + +### initializeDistributionRecord + +```solidity +function initializeDistributionRecord(uint256 index, address beneficiary, uint256 amount, bytes32[] merkleProof) external +``` + +### claim + +```solidity +function claim(uint256 index, address beneficiary, uint256 totalAmount, bytes32[] merkleProof) external +``` + +### setMerkleRoot + +```solidity +function setMerkleRoot(bytes32 _merkleRoot) external +``` + +## CrosschainContinuousVestingMerkle + +Distributes funds to beneficiaries across Connext domains and vesting continuously between a start and end date. + +### constructor + +```solidity +constructor(contract IERC20 _token, contract IConnext _connext, uint256 _total, string _uri, uint256 _voteFactor, uint256 _start, uint256 _cliff, uint256 _end, bytes32 _merkleRoot, uint160 _maxDelayTime) public +``` + +### NAME + +```solidity +function NAME() external pure returns (string) +``` + +### VERSION + +```solidity +function VERSION() external pure returns (uint256) +``` + +### _setToken + +```solidity +function _setToken(contract IERC20 _token) internal +``` + +### _setTotal + +```solidity +function _setTotal(uint256 _total) internal +``` + +## CrosschainTrancheVestingMerkle + +Distributes funds to beneficiaries across Connext domains and vesting in tranches over time. + +### constructor + +```solidity +constructor(contract IERC20 _token, contract IConnext _connext, uint256 _total, string _uri, uint256 _voteFactor, struct Tranche[] _tranches, bytes32 _merkleRoot, uint160 _maxDelayTime) public +``` + +### NAME + +```solidity +function NAME() external pure returns (string) +``` + +### VERSION + +```solidity +function VERSION() external pure returns (uint256) +``` + +### _setToken + +```solidity +function _setToken(contract IERC20 _token) internal +``` + +### _setTotal + +```solidity +function _setTotal(uint256 _total) internal +``` + +## PriceTierVestingMerkle + +### constructor + +```solidity +constructor(contract IERC20 _token, uint256 _total, string _uri, uint256 _voteFactor, uint256 _start, uint256 _end, contract IOracleOrL2OracleWithSequencerCheck _oracle, struct PriceTier[] _priceTiers, bytes32 _merkleRoot, uint160 _maxDelayTime) public +``` + +### NAME + +```solidity +function NAME() external pure returns (string) +``` + +_get a human-readable name for the distributor that describes basic functionality +On-chain consumers should rely on registered ERC165 interface IDs or similar for more specificity_ + +### VERSION + +```solidity +function VERSION() external pure returns (uint256) +``` + +_get a human-readable version for the distributor that describes basic functionality +The version should update whenever functionality significantly changes +On-chain consumers should rely on registered ERC165 interface IDs or similar for more specificity_ + +### initializeDistributionRecord + +```solidity +function initializeDistributionRecord(uint256 index, address beneficiary, uint256 amount, bytes32[] merkleProof) external +``` + +### claim + +```solidity +function claim(uint256 index, address beneficiary, uint256 totalAmount, bytes32[] merkleProof) external +``` + +### setMerkleRoot + +```solidity +function setMerkleRoot(bytes32 _merkleRoot) external +``` + +## PriceTierVestingSale_2_0 + +### sale + +```solidity +contract FlatPriceSale sale +``` + +### price + +```solidity +uint256 price +``` + +### soldTokenDecimals + +```solidity +uint8 soldTokenDecimals +``` + +### validSaleParticipant + +```solidity +modifier validSaleParticipant(address beneficiary) +``` + +### constructor + +```solidity +constructor(contract FlatPriceSale _sale, contract IERC20 _token, uint8 _soldTokenDecimals, uint256 _price, uint256 _start, uint256 _end, contract IOracleOrL2OracleWithSequencerCheck _oracle, struct PriceTier[] priceTiers, uint256 _voteFactor, string _uri) public +``` + +### NAME + +```solidity +function NAME() external pure virtual returns (string) +``` + +_get a human-readable name for the distributor that describes basic functionality +On-chain consumers should rely on registered ERC165 interface IDs or similar for more specificity_ + +### VERSION + +```solidity +function VERSION() external pure virtual returns (uint256) +``` + +_get a human-readable version for the distributor that describes basic functionality +The version should update whenever functionality significantly changes +On-chain consumers should rely on registered ERC165 interface IDs or similar for more specificity_ + +### getPurchasedAmount + +```solidity +function getPurchasedAmount(address buyer) public view returns (uint256) +``` + +### initializeDistributionRecord + +```solidity +function initializeDistributionRecord(address beneficiary) external +``` + +### claim + +```solidity +function claim(address beneficiary) external +``` + +### getDistributionRecord + +```solidity +function getDistributionRecord(address beneficiary) external view virtual returns (struct DistributionRecord) +``` + +return a distribution record + +### getClaimableAmount + +```solidity +function getClaimableAmount(address beneficiary) public view returns (uint256) +``` + +_get the amount of tokens currently claimable by a beneficiary_ + +#### Parameters + +| Name | Type | Description | +| ---- | ---- | ----------- | +| beneficiary | address | the address of the beneficiary | + +### getTotalClaimableAmount + +```solidity +function getTotalClaimableAmount(address beneficiary) internal view returns (uint256) +``` + +## Satellite + +This contract allows a beneficiary to claim tokens to this chain from a Distributor on another chain. +This contract validates inclusion in the merkle root, but only as a sanity check. The distributor contract +is the source of truth for claim eligibility. + +_The beneficiary domain in the merkle leaf must be this contract's domain. The beneficiary address may be +an EOA or a smart contract and must match msg.sender. The Satellite contract(s) and CrosschainDistributor contracts must only +be deployed on chains supported by the Connext protocol. + +Note that anyone could deploy a fake Satellite contract that does not require msg.sender to match the beneficiary or the Satellite +domain to match the beneficiary domain. This would allow the attacker to claim tokens from the distributor on behalf of a beneficiary onto +the chain / domain specified by that beneficiary's merkle leaf. This is not a security risk to the CrosschainMerkleDistributor, +as this is the intended behavior for a properly constructed merkle root._ + +### ClaimInitiated + +```solidity +event ClaimInitiated(bytes32 id, address beneficiary, uint256 total) +``` + +Emitted when a claim is initiated + +#### Parameters + +| Name | Type | Description | +| ---- | ---- | ----------- | +| id | bytes32 | The transfer id for sending claim to distributor | +| beneficiary | address | The user claiming tokens | +| total | uint256 | The beneficiary's total claimable token quantity (which may not be immediately claimable due to vesting conditions) | + +### distributor + +```solidity +contract ICrosschain distributor +``` + +The distributor hosted on on distributorDomain + +### distributorDomain + +```solidity +uint32 distributorDomain +``` + +The domain of the distributor + +### domain + +```solidity +uint32 domain +``` + +The domain of this satellite + +### connext + +```solidity +contract IConnext connext +``` + +Address of Connext on the satellite domain + +### constructor + +```solidity +constructor(contract IConnext _connext, contract ICrosschain _distributor, uint32 _distributorDomain, bytes32 _merkleRoot) public +``` + +### initiateClaim + +```solidity +function initiateClaim(uint256 total, bytes32[] proof) public payable +``` + +Initiates crosschain claim by msg.sender, relayer fees paid by native asset only. + +_Verifies membership in distribution merkle proof and xcalls to Distributor to initiate claim_ + +#### Parameters + +| Name | Type | Description | +| ---- | ---- | ----------- | +| total | uint256 | The amount of the claim (in leaf) | +| proof | bytes32[] | The merkle proof of the leaf in the root | + +### setMerkleRoot + +```solidity +function setMerkleRoot(bytes32 _merkleRoot) external +``` + +## TrancheVestingMerkle + +### constructor + +```solidity +constructor(contract IERC20 _token, uint256 _total, string _uri, uint256 _voteFactor, struct Tranche[] _tranches, bytes32 _merkleRoot, uint160 _maxDelayTime) public +``` + +### NAME + +```solidity +function NAME() external pure returns (string) +``` + +_get a human-readable name for the distributor that describes basic functionality +On-chain consumers should rely on registered ERC165 interface IDs or similar for more specificity_ + +### VERSION + +```solidity +function VERSION() external pure returns (uint256) +``` + +_get a human-readable version for the distributor that describes basic functionality +The version should update whenever functionality significantly changes +On-chain consumers should rely on registered ERC165 interface IDs or similar for more specificity_ + +### initializeDistributionRecord + +```solidity +function initializeDistributionRecord(uint256 index, address beneficiary, uint256 amount, bytes32[] merkleProof) external +``` + +### claim + +```solidity +function claim(uint256 index, address beneficiary, uint256 totalAmount, bytes32[] merkleProof) external +``` + +### setMerkleRoot + +```solidity +function setMerkleRoot(bytes32 _merkleRoot) external +``` + +## TrancheVestingSale_1_3 + +### saleManager + +```solidity +contract ISaleManager_v_1_3 saleManager +``` + +### saleId + +```solidity +bytes32 saleId +``` + +### validSaleParticipant + +```solidity +modifier validSaleParticipant(address beneficiary) +``` + +### constructor + +```solidity +constructor(contract ISaleManager_v_1_3 _saleManager, bytes32 _saleId, contract IERC20 _token, struct Tranche[] _tranches, uint256 _voteFactor, string _uri) public +``` + +### NAME + +```solidity +function NAME() external pure virtual returns (string) +``` + +_get a human-readable name for the distributor that describes basic functionality +On-chain consumers should rely on registered ERC165 interface IDs or similar for more specificity_ + +### VERSION + +```solidity +function VERSION() external pure virtual returns (uint256) +``` + +_get a human-readable version for the distributor that describes basic functionality +The version should update whenever functionality significantly changes +On-chain consumers should rely on registered ERC165 interface IDs or similar for more specificity_ + +### tryDecimals + +```solidity +function tryDecimals(contract IERC20 _token) internal view returns (int256) +``` + +### getPurchasedAmount + +```solidity +function getPurchasedAmount(address buyer) public view returns (uint256) +``` + +### initializeDistributionRecord + +```solidity +function initializeDistributionRecord(address beneficiary) external +``` + +### claim + +```solidity +function claim(address beneficiary) external +``` + +### getDistributionRecord + +```solidity +function getDistributionRecord(address beneficiary) external view returns (struct DistributionRecord) +``` + +return a distribution record + +### getClaimableAmount + +```solidity +function getClaimableAmount(address beneficiary) public view returns (uint256) +``` + +_get the amount of tokens currently claimable by a beneficiary_ + +#### Parameters + +| Name | Type | Description | +| ---- | ---- | ----------- | +| beneficiary | address | the address of the beneficiary | + +### getTotalClaimableAmount + +```solidity +function getTotalClaimableAmount(address beneficiary) internal view returns (uint256) +``` + +## TrancheVestingSale_2_0 + +### sale + +```solidity +contract FlatPriceSale sale +``` + +### price + +```solidity +uint256 price +``` + +### soldTokenDecimals + +```solidity +uint8 soldTokenDecimals +``` + +### validSaleParticipant + +```solidity +modifier validSaleParticipant(address beneficiary) +``` + +### constructor + +```solidity +constructor(contract FlatPriceSale _sale, contract IERC20 _token, uint8 _soldTokenDecimals, uint256 _price, struct Tranche[] tranches, uint256 voteWeightBips, string _uri) public +``` + +### NAME + +```solidity +function NAME() external pure virtual returns (string) +``` + +_get a human-readable name for the distributor that describes basic functionality +On-chain consumers should rely on registered ERC165 interface IDs or similar for more specificity_ + +### VERSION + +```solidity +function VERSION() external pure virtual returns (uint256) +``` + +_get a human-readable version for the distributor that describes basic functionality +The version should update whenever functionality significantly changes +On-chain consumers should rely on registered ERC165 interface IDs or similar for more specificity_ + +### getPurchasedAmount + +```solidity +function getPurchasedAmount(address buyer) public view returns (uint256) +``` + +### initializeDistributionRecord + +```solidity +function initializeDistributionRecord(address beneficiary) external +``` + +### claim + +```solidity +function claim(address beneficiary) external +``` + +### getDistributionRecord + +```solidity +function getDistributionRecord(address beneficiary) external view virtual returns (struct DistributionRecord) +``` + +return a distribution record + +### getClaimableAmount + +```solidity +function getClaimableAmount(address beneficiary) public view returns (uint256) +``` + +_get the amount of tokens currently claimable by a beneficiary_ + +#### Parameters + +| Name | Type | Description | +| ---- | ---- | ----------- | +| beneficiary | address | the address of the beneficiary | + +### getTotalClaimableAmount + +```solidity +function getTotalClaimableAmount(address beneficiary) internal view returns (uint256) +``` + +## AdvancedDistributor + +Distributes tokens to beneficiaries with voting-while-vesting and administrative controls. +The contract owner can control these distribution parameters: +- the merkle root determining all distribution details +- adjustments to specific distributions +- the token being distributed +- the total amount to distribute +- the metadata URI +- the voting power of undistributed tokens +- the recipient of swept funds + +This contract also allows owners to perform several other admin functions +- updating the contract owner +- sweeping tokens and native currency to a recipient + +This contract tracks beneficiary voting power through an internal ERC20Votes token that cannot be transferred. The +beneficiary must delegate to an address to use this voting power. Their voting power decreases when the token is claimed. + +_Updates to the contract must follow these constraints: +- If a merkle root update alters the total token quantity to distribute across all users, also adjust the total value. + The DistributionRecord for each beneficiary updated in the merkle root will be incorrect until a claim is executed. +- If the total changes, make sure to add or withdraw tokens being distributed to match the new total._ + +### constructor + +```solidity +constructor(contract IERC20 _token, uint256 _total, string _uri, uint256 _voteFactor, uint256 _fractionDenominator, uint160 _maxDelayTime, uint160 _salt) internal +``` + +### _initializeDistributionRecord + +```solidity +function _initializeDistributionRecord(address beneficiary, uint256 totalAmount) internal virtual +``` + +### _executeClaim + +```solidity +function _executeClaim(address beneficiary, uint256 totalAmount) internal virtual returns (uint256 _claimed) +``` + +### adjust + +```solidity +function adjust(address beneficiary, int256 amount) external +``` + +_Adjust the quantity claimable by a user, overriding the value in the distribution record. + +Note: If used in combination with merkle proofs, adjustments to a beneficiary's total could be +reset by anyone to the value in the merkle leaf at any time. Update the merkle root instead. + +Amount is limited to type(uint120).max to allow each DistributionRecord to be packed into a single storage slot._ + +### _setToken + +```solidity +function _setToken(contract IERC20 _token) internal virtual +``` + +### setToken + +```solidity +function setToken(contract IERC20 _token) external virtual +``` + +### _setTotal + +```solidity +function _setTotal(uint256 _total) internal virtual +``` + +### setTotal + +```solidity +function setTotal(uint256 _total) external virtual +``` + +### setUri + +```solidity +function setUri(string _uri) external +``` + +### setSweepRecipient + +```solidity +function setSweepRecipient(address payable _recipient) external +``` + +### getTotalVotes + +```solidity +function getTotalVotes() external view returns (uint256) +``` + +### getVoteFactor + +```solidity +function getVoteFactor(address) external view returns (uint256) +``` + +### setVoteFactor + +```solidity +function setVoteFactor(uint256 _voteFactor) external +``` + +Set the voting power of undistributed tokens + +_The vote factor can be any integer. If voteFactor / fractionDenominator == 1, +one unclaimed token provides one vote. If voteFactor / fractionDenominator == 2, one +unclaimed token counts as two votes._ + +#### Parameters + +| Name | Type | Description | +| ---- | ---- | ----------- | +| _voteFactor | uint256 | The voting power multiplier as a fraction of fractionDenominator | + +### _approve + +```solidity +function _approve(address, address, uint256) internal pure +``` + +_the internal token used only for tracking voting power cannot be transferred_ + +### _transfer + +```solidity +function _transfer(address, address, uint256) internal pure +``` + +_the internal token used only f or tracking voting power cannot be transferred_ + +## ContinuousVesting + +### constructor + +```solidity +constructor(contract IERC20 _token, uint256 _total, string _uri, uint256 _voteFactor, uint256 _start, uint256 _cliff, uint256 _end, uint160 _maxDelayTime, uint160 _salt) internal +``` + +### getVestedFraction + +```solidity +function getVestedFraction(address beneficiary, uint256 time) public view returns (uint256) +``` + +### getVestingConfig + +```solidity +function getVestingConfig() external view returns (uint256, uint256, uint256) +``` + +### setVestingConfig + +```solidity +function setVestingConfig(uint256 _start, uint256 _cliff, uint256 _end) external +``` + +## CrosschainDistributor + +### connext + +```solidity +contract IConnext connext +``` + +### domain + +```solidity +uint32 domain +``` + +### onlyConnext + +```solidity +modifier onlyConnext() +``` + +Throws if the msg.sender is not connext + +### constructor + +```solidity +constructor(contract IConnext _connext, uint256 _total) internal +``` + +### _allowConnext + +```solidity +function _allowConnext(uint256 amount) internal +``` + +_allows Connext to withdraw tokens for cross-chain settlement. Connext may withdraw up to + the remaining quantity of tokens that can be claimed - the allowance must be set for cross-chain claims._ + +### _setTotal + +```solidity +function _setTotal(uint256 _total) internal virtual +``` + +Reset Connext allowance when total is updated + +### _setToken + +```solidity +function _setToken(contract IERC20 _token) internal virtual +``` + +Reset Connext allowance when token is updated + +### _settleClaim + +```solidity +function _settleClaim(address _beneficiary, address _recipient, uint32 _recipientDomain, uint256 _amount) internal virtual +``` + +Settles claimed tokens to any valid Connext domain. + +_permissions are not checked: call only after a valid claim is executed +assumes connext fees are paid in native assets, not from the claim total_ + +#### Parameters + +| Name | Type | Description | +| ---- | ---- | ----------- | +| _beneficiary | address | | +| _recipient | address | | +| _recipientDomain | uint32 | | +| _amount | uint256 | | + +## CrosschainMerkleDistributor + +Distributes funds to beneficiaries listed in a merkle proof on Connext-compatible chains. If a beneficiary is listed in multiple leaves, +they can claim at most the max(amounts) rather than sum(amounts) -- each beneficiary gets a single distribution record across all chains or merkle leaves. + +_There are three ways to claim funds from this contract: + +1. `claimBySignature` allows any address to claim funds on behalf of an EOA beneficiary to any Connext domain and recipient address (including recipients and domains not in the merkle leaf) by providing a merkle proof and beneficiary signature +2. `claimByMerkleProof` allows any address to claim funds on behalf of a beneficiary to the Connext domain and address specified in the merkle leaf by providing a merkle proof +3. `xReceive` allows any address on another Connext domain to claim funds on behalf of a beneficiary to the connext domain and address specified in the merkle leaf by providing a merkle proof + +A note on the merkle tree structure: + +The leaf structure used is: `hash(beneficiary, total, beneficiaryDomain)`. + +The contract is designed to support claims by both EOAs and contracts. If the beneficiary +is a contract, the merkle leaf domain must match the contract domain. In this case, you can only guarantee the beneficiary +controls their address on the domain the claim was initiated from (contracts do not share +addresses across chains). Including the domain context in the leaf allows the contract to +enforce this assertion via merkle proofs instead of using an authorized call (see: +https://docs.connext.network/developers/guides/authentication)._ + +### Foo + +```solidity +event Foo(address bar) +``` + +### constructor + +```solidity +constructor(contract IConnext _connext, bytes32 _merkleRoot, uint256 _total) internal +``` + +### initializeDistributionRecord + +```solidity +function initializeDistributionRecord(uint32 _domain, address _beneficiary, uint256 _amount, bytes32[] merkleProof) external +``` + +_public method to initialize a distribution record: requires a valid merkle proof_ + +### xReceive + +```solidity +function xReceive(bytes32, uint256, address, address, uint32, bytes _callData) external returns (bytes) +``` + +Used for cross-chain claims via Satellite, which triggers claims through Connext. + +_This method is only callable by Connext, but anyone on any other Connext domain can +trigger this method call on behalf of a beneficiary. Claimed funds will always be sent to +the beneficiary address and beneficiary domain set in the merkle proof._ + +#### Parameters + +| Name | Type | Description | +| ---- | ---- | ----------- | +| | bytes32 | | +| | uint256 | | +| | address | | +| | address | | +| | uint32 | | +| _callData | bytes | Calldata from origin initiator (Satellite). Should include proof, leaf information, and recipient information | + +### claimByMerkleProof + +```solidity +function claimByMerkleProof(address _beneficiary, uint256 _total, bytes32[] _proof) external payable +``` + +Claim tokens for a beneficiary using a merkle proof + +_This method can be called by anyone, but claimed funds will always be sent to the +beneficiary address and domain set in the merkle proof._ + +#### Parameters + +| Name | Type | Description | +| ---- | ---- | ----------- | +| _beneficiary | address | The address of the beneficiary | +| _total | uint256 | The total claimable amount for this beneficiary | +| _proof | bytes32[] | The merkle proof | + +### claimBySignature + +```solidity +function claimBySignature(address _recipient, uint32 _recipientDomain, address _beneficiary, uint32 _beneficiaryDomain, uint256 _total, bytes _signature, bytes32[] _proof) external payable +``` + +Claim tokens for a beneficiary using a merkle proof and beneficiary signature. The beneficiary +may specify any Connext domain and recipient address to receive the tokens. Will validate +the proof and beneficiary signature, track the claim, and forward the funds to the designated +recipient on the designated chain. + +#### Parameters + +| Name | Type | Description | +| ---- | ---- | ----------- | +| _recipient | address | The address to receive the claimed tokens | +| _recipientDomain | uint32 | The domain of the recipient | +| _beneficiary | address | The address eligible to claim tokens based on a merkle leaf | +| _beneficiaryDomain | uint32 | The domain of the beneficiary set in a merkle leaf | +| _total | uint256 | The total quantity of tokens the beneficiary is eligible to claim | +| _signature | bytes | The signature of the beneficiary on the leaf | +| _proof | bytes32[] | The merkle proof of the beneficiary leaf | + +### setMerkleRoot + +```solidity +function setMerkleRoot(bytes32 _merkleRoot) external +``` + +Allows the owner update the merkle root + +#### Parameters + +| Name | Type | Description | +| ---- | ---- | ----------- | +| _merkleRoot | bytes32 | The new merkle root | + +### _recoverSignature + +```solidity +function _recoverSignature(bytes32 _signed, bytes _sig) internal pure returns (address) +``` + +Recover the signing address from an encoded payload. + +_Will hash and convert to an eth signed message._ + +#### Parameters + +| Name | Type | Description | +| ---- | ---- | ----------- | +| _signed | bytes32 | The hash that was signed. | +| _sig | bytes | The signature from which we will recover the signer. | + +### _getLeaf + +```solidity +function _getLeaf(address _beneficiary, uint256 _total, uint32 _domain) internal pure returns (bytes32 _leaf) +``` + +Generates the leaf from plaintext + +#### Parameters + +| Name | Type | Description | +| ---- | ---- | ----------- | +| _beneficiary | address | Beneficiary address on domain | +| _total | uint256 | Total claim amount for the beneficiary | +| _domain | uint32 | Beneficiary domain | + +## Distributor + +Distributes funds to beneficiaries and tracks distribution status + +### records + +```solidity +mapping(address => struct DistributionRecord) records +``` + +### token + +```solidity +contract IERC20 token +``` + +_get the ERC20 token being distributed_ + +### total + +```solidity +uint256 total +``` + +_get the total distribution quantity across all beneficiaries_ + +### claimed + +```solidity +uint256 claimed +``` + +### uri + +```solidity +string uri +``` + +_get a URI for additional information about the distribution_ + +### fractionDenominator + +```solidity +uint256 fractionDenominator +``` + +### NAME + +```solidity +function NAME() external view virtual returns (string) +``` + +_get a human-readable name for the distributor that describes basic functionality +On-chain consumers should rely on registered ERC165 interface IDs or similar for more specificity_ + +### VERSION + +```solidity +function VERSION() external view virtual returns (uint256) +``` + +_get a human-readable version for the distributor that describes basic functionality +The version should update whenever functionality significantly changes +On-chain consumers should rely on registered ERC165 interface IDs or similar for more specificity_ + +### constructor + +```solidity +constructor(contract IERC20 _token, uint256 _total, string _uri, uint256 _fractionDenominator) internal +``` + +### _initializeDistributionRecord + +```solidity +function _initializeDistributionRecord(address beneficiary, uint256 _totalAmount) internal virtual +``` + +_Set up the distribution record for a user. Permissions are not checked in this function. +Amount is limited to type(uint120).max to allow each DistributionRecord to be packed into a single storage slot._ + +#### Parameters + +| Name | Type | Description | +| ---- | ---- | ----------- | +| beneficiary | address | The address of the beneficiary | +| _totalAmount | uint256 | The total amount of tokens to be distributed to the beneficiary | + +### _executeClaim + +```solidity +function _executeClaim(address beneficiary, uint256 _totalAmount) internal virtual returns (uint256) +``` + +Record the claim internally: + +_This function does not check permissions: caller must verify the claim is valid! +this function should not call any untrusted external contracts to avoid reentrancy_ + +### _settleClaim + +```solidity +function _settleClaim(address _recipient, uint256 _amount) internal virtual +``` + +_Move tokens associated with the claim to the recipient. This function should be called +after the claim has been executed internally to avoid reentrancy issues._ + +#### Parameters + +| Name | Type | Description | +| ---- | ---- | ----------- | +| _recipient | address | The address of the recipient | +| _amount | uint256 | The amount of tokens to be transferred during this claim | + +### getDistributionRecord + +```solidity +function getDistributionRecord(address beneficiary) external view virtual returns (struct DistributionRecord) +``` + +return a distribution record + +### getVestedFraction + +```solidity +function getVestedFraction(address beneficiary, uint256 time) public view virtual returns (uint256) +``` + +### getFractionDenominator + +```solidity +function getFractionDenominator() public view returns (uint256) +``` + +_get the denominator for vesting fractions represented as integers_ + +### getClaimableAmount + +```solidity +function getClaimableAmount(address beneficiary) public view virtual returns (uint256) +``` + +_get the amount of tokens currently claimable by a beneficiary_ + +#### Parameters + +| Name | Type | Description | +| ---- | ---- | ----------- | +| beneficiary | address | the address of the beneficiary | + +## MerkleSet + +Checks merkle proofs + +_Contracts inheriting from MerkleSet may update the merkle root whenever desired._ + +### constructor + +```solidity +constructor(bytes32 _merkleRoot) public +``` + +### validMerkleProof + +```solidity +modifier validMerkleProof(bytes32 leaf, bytes32[] merkleProof) +``` + +### _testMembership + +```solidity +function _testMembership(bytes32 leaf, bytes32[] merkleProof) internal view returns (bool) +``` + +Tests membership in the merkle set + +### getMerkleRoot + +```solidity +function getMerkleRoot() public view returns (bytes32) +``` + +### _verifyMembership + +```solidity +function _verifyMembership(bytes32 leaf, bytes32[] merkleProof) internal view +``` + +_Verifies membership in the merkle set_ + +### _setMerkleRoot + +```solidity +function _setMerkleRoot(bytes32 _merkleRoot) internal +``` + +_Updates the merkle root_ + +## PriceTierVesting + +### constructor + +```solidity +constructor(contract IERC20 _token, uint256 _total, string _uri, uint256 _voteFactor, uint256 _start, uint256 _end, contract IOracleOrL2OracleWithSequencerCheck _oracle, struct PriceTier[] _tiers, uint160 _maxDelayTime, uint160 _salt) internal +``` + +### getStart + +```solidity +function getStart() external view returns (uint256) +``` + +### getEnd + +```solidity +function getEnd() external view returns (uint256) +``` + +### getOracle + +```solidity +function getOracle() external view returns (contract IOracleOrL2OracleWithSequencerCheck) +``` + +### getPriceTier + +```solidity +function getPriceTier(uint256 i) public view returns (struct PriceTier) +``` + +### getPriceTiers + +```solidity +function getPriceTiers() public view returns (struct PriceTier[]) +``` + +### getVestedFraction + +```solidity +function getVestedFraction(address beneficiary, uint256 time) public view returns (uint256) +``` + +### setPriceTiers + +```solidity +function setPriceTiers(uint256 _start, uint256 _end, contract IOracleOrL2OracleWithSequencerCheck _oracle, struct PriceTier[] _tiers) external +``` + +## TrancheVesting + +Distributes funds to beneficiaries over time in tranches. + +### constructor + +```solidity +constructor(contract IERC20 _token, uint256 _total, string _uri, uint256 _voteFactor, struct Tranche[] _tranches, uint160 _maxDelayTime, uint160 _salt) internal +``` + +### getVestedFraction + +```solidity +function getVestedFraction(address beneficiary, uint256 time) public view returns (uint256) +``` + +Get the vested fraction for a beneficiary at a given time. + +_Before the first tranche time, the vested fraction will be 0. At times between +tranche_i and tranche_i+1, the vested fraction will be tranche_i+1's vested fraction. +After the last tranche time, the vested fraction will be the fraction denominator._ + +### getTranche + +```solidity +function getTranche(uint256 i) public view returns (struct Tranche) +``` + +### getTranches + +```solidity +function getTranches() public view returns (struct Tranche[]) +``` + +### setTranches + +```solidity +function setTranches(struct Tranche[] _tranches) external +``` + +Set the vesting tranches. Tranches must be sorted by time and vested fraction must monotonically increase. +The last tranche must vest all tokens (vestedFraction == fractionDenominator) + +## AdvancedDistributorInitializable + +Distributes tokens to beneficiaries with voting-while-vesting and administrative controls. +The contract owner can control these distribution parameters: +- the merkle root determining all distribution details +- adjustments to specific distributions +- the token being distributed +- the total amount to distribute +- the metadata URI +- the voting power of undistributed tokens +- the recipient of swept funds + +This contract also allows owners to perform several other admin functions +- updating the contract owner +- sweeping tokens and native currency to a recipient + +This contract tracks beneficiary voting power through an internal ERC20Votes token that cannot be transferred. The +beneficiary must delegate to an address to use this voting power. Their voting power decreases when the token is claimed. + +_Updates to the contract must follow these constraints: +- If a merkle root update alters the total token quantity to distribute across all users, also adjust the total value. + The DistributionRecord for each beneficiary updated in the merkle root will be incorrect until a claim is executed. +- If the total changes, make sure to add or withdraw tokens being distributed to match the new total._ + +### constructor + +```solidity +constructor() internal +``` + +### __AdvancedDistributor_init + +```solidity +function __AdvancedDistributor_init(contract IERC20 _token, uint256 _total, string _uri, uint256 _voteFactor, uint256 _fractionDenominator, uint160 _maxDelayTime, uint160 _salt, address _owner) internal +``` + +### _initializeDistributionRecord + +```solidity +function _initializeDistributionRecord(address beneficiary, uint256 totalAmount) internal virtual +``` + +### _executeClaim + +```solidity +function _executeClaim(address beneficiary, uint256 totalAmount) internal virtual returns (uint256 _claimed) +``` + +### adjust + +```solidity +function adjust(address beneficiary, int256 amount) external +``` + +_Adjust the quantity claimable by a user, overriding the value in the distribution record. + +Note: If used in combination with merkle proofs, adjustments to a beneficiary's total could be +reset by anyone to the value in the merkle leaf at any time. Update the merkle root instead. + +Amount is limited to type(uint120).max to allow each DistributionRecord to be packed into a single storage slot._ + +### _setToken + +```solidity +function _setToken(contract IERC20 _token) internal virtual +``` + +### setToken + +```solidity +function setToken(contract IERC20 _token) external virtual +``` + +### _setTotal + +```solidity +function _setTotal(uint256 _total) internal virtual +``` + +### setTotal + +```solidity +function setTotal(uint256 _total) external virtual +``` + +### setUri + +```solidity +function setUri(string _uri) external +``` + +### setSweepRecipient + +```solidity +function setSweepRecipient(address payable _recipient) external +``` + +### getTotalVotes + +```solidity +function getTotalVotes() external view returns (uint256) +``` + +### getVoteFactor + +```solidity +function getVoteFactor(address) external view returns (uint256) +``` + +### setVoteFactor + +```solidity +function setVoteFactor(uint256 _voteFactor) external +``` + +Set the voting power of undistributed tokens + +_The vote factor can be any integer. If voteFactor / fractionDenominator == 1, +one unclaimed token provides one vote. If voteFactor / fractionDenominator == 2, one +unclaimed token counts as two votes._ + +#### Parameters + +| Name | Type | Description | +| ---- | ---- | ----------- | +| _voteFactor | uint256 | The voting power multiplier as a fraction of fractionDenominator | + +### _approve + +```solidity +function _approve(address, address, uint256) internal pure +``` + +_the internal token used only for tracking voting power cannot be transferred_ + +### _transfer + +```solidity +function _transfer(address, address, uint256) internal pure +``` + +_the internal token used only for tracking voting power cannot be transferred_ + +## ContinuousVestingInitializable + +### __ContinuousVesting_init + +```solidity +function __ContinuousVesting_init(contract IERC20 _token, uint256 _total, string _uri, uint256 _start, uint256 _cliff, uint256 _end, uint160 _maxDelayTime, uint160 _salt, address _owner) internal +``` + +### getVestedFraction + +```solidity +function getVestedFraction(address beneficiary, uint256 time) public view returns (uint256) +``` + +### getVestingConfig + +```solidity +function getVestingConfig() external view returns (uint256, uint256, uint256) +``` + +### setVestingConfig + +```solidity +function setVestingConfig(uint256 _start, uint256 _cliff, uint256 _end) external +``` + +## ContinuousVestingMerkleDistributor + +### constructor + +```solidity +constructor() public +``` + +### initialize + +```solidity +function initialize(contract IERC20 _token, uint256 _total, string _uri, uint256 _start, uint256 _cliff, uint256 _end, bytes32 _merkleRoot, uint160 _maxDelayTime, address _owner) public +``` + +### NAME + +```solidity +function NAME() external pure returns (string) +``` + +_get a human-readable name for the distributor that describes basic functionality +On-chain consumers should rely on registered ERC165 interface IDs or similar for more specificity_ + +### VERSION + +```solidity +function VERSION() external pure returns (uint256) +``` + +_get a human-readable version for the distributor that describes basic functionality +The version should update whenever functionality significantly changes +On-chain consumers should rely on registered ERC165 interface IDs or similar for more specificity_ + +### initializeDistributionRecord + +```solidity +function initializeDistributionRecord(uint256 index, address beneficiary, uint256 amount, bytes32[] merkleProof) external +``` + +### claim + +```solidity +function claim(uint256 index, address beneficiary, uint256 totalAmount, bytes32[] merkleProof) external +``` + +### setMerkleRoot + +```solidity +function setMerkleRoot(bytes32 _merkleRoot) external +``` + +## ContinuousVestingMerkleDistributorFactory + +### distributors + +```solidity +address[] distributors +``` + +### DistributorDeployed + +```solidity +event DistributorDeployed(address distributor) +``` + +### constructor + +```solidity +constructor(address implementation) public +``` + +### deployDistributor + +```solidity +function deployDistributor(contract IERC20 _token, uint256 _total, string _uri, uint256 _start, uint256 _cliff, uint256 _end, bytes32 _merkleRoot, uint160 _maxDelayTime, address _owner, uint256 _nonce) public returns (contract ContinuousVestingMerkleDistributor distributor) +``` + +### getImplementation + +```solidity +function getImplementation() public view returns (address) +``` + +### predictDistributorAddress + +```solidity +function predictDistributorAddress(contract IERC20 _token, uint256 _total, string _uri, uint256 _start, uint256 _cliff, uint256 _end, bytes32 _merkleRoot, uint160 _maxDelayTime, address _owner, uint256 _nonce) public view returns (address) +``` + +## DistributorInitializable + +Distributes funds to beneficiaries and tracks distribution status + +### records + +```solidity +mapping(address => struct DistributionRecord) records +``` + +### token + +```solidity +contract IERC20 token +``` + +_get the ERC20 token being distributed_ + +### total + +```solidity +uint256 total +``` + +_get the total distribution quantity across all beneficiaries_ + +### claimed + +```solidity +uint256 claimed +``` + +### uri + +```solidity +string uri +``` + +_get a URI for additional information about the distribution_ + +### fractionDenominator + +```solidity +uint256 fractionDenominator +``` + +### NAME + +```solidity +function NAME() external view virtual returns (string) +``` + +_get a human-readable name for the distributor that describes basic functionality +On-chain consumers should rely on registered ERC165 interface IDs or similar for more specificity_ + +### VERSION + +```solidity +function VERSION() external view virtual returns (uint256) +``` + +_get a human-readable version for the distributor that describes basic functionality +The version should update whenever functionality significantly changes +On-chain consumers should rely on registered ERC165 interface IDs or similar for more specificity_ + +### __Distributor_init + +```solidity +function __Distributor_init(contract IERC20 _token, uint256 _total, string _uri, uint256 _fractionDenominator) internal +``` + +### _initializeDistributionRecord + +```solidity +function _initializeDistributionRecord(address beneficiary, uint256 _totalAmount) internal virtual +``` + +_Set up the distribution record for a user. Permissions are not checked in this function. +Amount is limited to type(uint120).max to allow each DistributionRecord to be packed into a single storage slot._ + +#### Parameters + +| Name | Type | Description | +| ---- | ---- | ----------- | +| beneficiary | address | The address of the beneficiary | +| _totalAmount | uint256 | The total amount of tokens to be distributed to the beneficiary | + +### _executeClaim + +```solidity +function _executeClaim(address beneficiary, uint256 _totalAmount) internal virtual returns (uint256) +``` + +Record the claim internally: + +_This function does not check permissions: caller must verify the claim is valid! +this function should not call any untrusted external contracts to avoid reentrancy_ + +### _settleClaim + +```solidity +function _settleClaim(address _recipient, uint256 _amount) internal virtual +``` + +_Move tokens associated with the claim to the recipient. This function should be called +after the claim has been executed internally to avoid reentrancy issues._ + +#### Parameters + +| Name | Type | Description | +| ---- | ---- | ----------- | +| _recipient | address | The address of the recipient | +| _amount | uint256 | The amount of tokens to be transferred during this claim | + +### getDistributionRecord + +```solidity +function getDistributionRecord(address beneficiary) external view virtual returns (struct DistributionRecord) +``` + +return a distribution record + +### getVestedFraction + +```solidity +function getVestedFraction(address beneficiary, uint256 time) public view virtual returns (uint256) +``` + +### getFractionDenominator + +```solidity +function getFractionDenominator() public view returns (uint256) +``` + +_get the denominator for vesting fractions represented as integers_ + +### getClaimableAmount + +```solidity +function getClaimableAmount(address beneficiary) public view virtual returns (uint256) +``` + +_get the amount of tokens currently claimable by a beneficiary_ + +#### Parameters + +| Name | Type | Description | +| ---- | ---- | ----------- | +| beneficiary | address | the address of the beneficiary | + +## FairQueueInitializable + +Fairly assigns a delay time to each address from a uniform distribution over [0, maxDelayTime] + +_The delay is determined by calculating a distance between the user's address and a pseudorandom value based on a provided salt and a blockhash +using the XOR distance metric. Do not use this contract if the event is public because users could grind addresses until they find one with a low delay._ + +### SetDelay + +```solidity +event SetDelay(uint160 maxDelayTime) +``` + +### distancePerSecond + +```solidity +uint160 distancePerSecond +``` + +calculate a speed at which the queue is exhausted such that all users complete the queue by maxDelayTime + +### maxDelayTime + +```solidity +uint160 maxDelayTime +``` + +### randomValue + +```solidity +uint160 randomValue +``` + +_the random value from which a distance will be calculated for each address. Reset the random value +to shuffle the delays for all addresses._ + +### __FairQueue_init + +```solidity +function __FairQueue_init(uint160 _maxDelayTime, uint160 salt) internal +``` + +### _setPseudorandomValue + +```solidity +function _setPseudorandomValue(uint160 salt) internal +``` + +_internal function to set the random value. A salt (e.g. from a merkle root) is required to prevent +naive manipulation of the random value by validators_ + +### _setDelay + +```solidity +function _setDelay(uint160 _maxDelayTime) internal +``` + +_Internal function to configure delay + @param _maxDelayTime the maximum delay for any address in seconds. Set this value to 0 to disable delays entirely._ + +### getFairDelayTime + +```solidity +function getFairDelayTime(address user) public view returns (uint256) +``` + +get a fixed delay for any address by drawing from a unform distribution over the interval [0, maxDelay] + @param user The address for which a delay should be calculated. The delay is deterministic for any given address and pseudorandom value. + @dev The delay is determined by calculating a distance between the user's address and a pseudorandom value using the XOR distance metric (c.f. Kademlia) + + Users cannot exploit the fair delay if: + - The event is private, i.e. an access list of some form is required + - Each eligible user gets exactly one address in the access list + - There is no collusion between event participants, block validators, and event owners + + The threat of collusion is likely minimal: + - the economic opportunity to validators is zero or relatively small (only specific addresses can participate in private events, and a lower delay time does not imply higher returns) + - event owners are usually trying to achieve a fair distribution of access to their event + +## MerkleSetInitializable + +Checks merkle proofs + +_Contracts inheriting from MerkleSet may update the merkle root whenever desired._ + +### __MerkleSet_init + +```solidity +function __MerkleSet_init(bytes32 _merkleRoot) internal +``` + +### validMerkleProof + +```solidity +modifier validMerkleProof(bytes32 leaf, bytes32[] merkleProof) +``` + +### _testMembership + +```solidity +function _testMembership(bytes32 leaf, bytes32[] merkleProof) internal view returns (bool) +``` + +Tests membership in the merkle set + +### getMerkleRoot + +```solidity +function getMerkleRoot() public view returns (bytes32) +``` + +### _verifyMembership + +```solidity +function _verifyMembership(bytes32 leaf, bytes32[] merkleProof) internal view +``` + +_Verifies membership in the merkle set_ + +### _setMerkleRoot + +```solidity +function _setMerkleRoot(bytes32 _merkleRoot) internal +``` + +_Updates the merkle root_ + +## TrancheVestingInitializable + +### __TrancheVesting_init + +```solidity +function __TrancheVesting_init(contract IERC20 _token, uint256 _total, string _uri, struct Tranche[] _tranches, uint160 _maxDelayTime, uint160 _salt, address _owner) internal +``` + +### getVestedFraction + +```solidity +function getVestedFraction(address beneficiary, uint256 time) public view returns (uint256) +``` + +Get the vested fraction for a beneficiary at a given time. + +_Before the first tranche time, the vested fraction will be 0. At times between +tranche_i and tranche_i+1, the vested fraction will be tranche_i+1's vested fraction. +After the last tranche time, the vested fraction will be the fraction denominator._ + +### getTranche + +```solidity +function getTranche(uint256 i) public view returns (struct Tranche) +``` + +### getTranches + +```solidity +function getTranches() public view returns (struct Tranche[]) +``` + +### setTranches + +```solidity +function setTranches(struct Tranche[] _tranches) external +``` + +Set the vesting tranches. Tranches must be sorted by time and vested fraction must monotonically increase. +The last tranche must vest all tokens (vestedFraction == fractionDenominator) + +## TrancheVestingMerkleDistributor + +### constructor + +```solidity +constructor() public +``` + +### initialize + +```solidity +function initialize(contract IERC20 _token, uint256 _total, string _uri, struct Tranche[] _tranches, bytes32 _merkleRoot, uint160 _maxDelayTime, address _owner) public +``` + +### NAME + +```solidity +function NAME() external pure returns (string) +``` + +_get a human-readable name for the distributor that describes basic functionality +On-chain consumers should rely on registered ERC165 interface IDs or similar for more specificity_ + +### VERSION + +```solidity +function VERSION() external pure returns (uint256) +``` + +_get a human-readable version for the distributor that describes basic functionality +The version should update whenever functionality significantly changes +On-chain consumers should rely on registered ERC165 interface IDs or similar for more specificity_ + +### initializeDistributionRecord + +```solidity +function initializeDistributionRecord(uint256 index, address beneficiary, uint256 amount, bytes32[] merkleProof) external +``` + +### claim + +```solidity +function claim(uint256 index, address beneficiary, uint256 totalAmount, bytes32[] merkleProof) external +``` + +### setMerkleRoot + +```solidity +function setMerkleRoot(bytes32 _merkleRoot) external +``` + +## TrancheVestingMerkleDistributorFactory + +### distributors + +```solidity +address[] distributors +``` + +### DistributorDeployed + +```solidity +event DistributorDeployed(address distributor) +``` + +### constructor + +```solidity +constructor(address implementation) public +``` + +### deployDistributor + +```solidity +function deployDistributor(contract IERC20 _token, uint256 _total, string _uri, struct Tranche[] _tranches, bytes32 _merkleRoot, uint160 _maxDelayTime, address _owner, uint256 _nonce) public returns (contract TrancheVestingMerkleDistributor distributor) +``` + +### getImplementation + +```solidity +function getImplementation() public view returns (address) +``` + +### predictDistributorAddress + +```solidity +function predictDistributorAddress(contract IERC20 _token, uint256 _total, string _uri, struct Tranche[] _tranches, bytes32 _merkleRoot, uint160 _maxDelayTime, address _owner, uint256 _nonce) public view returns (address) +``` + +## GovernorMultiSourceUpgradeable + +### constructor + +```solidity +constructor() public +``` + +### initialize + +```solidity +function initialize(contract IVotesUpgradeable _token, contract TimelockControllerUpgradeable _timelock, contract IVotesUpgradeable[] _voteSources) public virtual +``` + +### NAME + +```solidity +function NAME() external pure returns (string) +``` + +### VERSION + +```solidity +function VERSION() external pure returns (uint256) +``` + +### votingDelay + +```solidity +function votingDelay() public pure virtual returns (uint256) +``` + +module:user-config + +_Delay, in number of block, between the proposal is created and the vote starts. This can be increassed to +leave time for users to buy voting power, or delegate it, before the voting of a proposal starts._ + +### votingPeriod + +```solidity +function votingPeriod() public pure virtual returns (uint256) +``` + +module:user-config + +_Delay, in number of blocks, between the vote start and vote ends. + +NOTE: The {votingDelay} can delay the start of the vote. This must be considered when setting the voting +duration compared to the voting delay._ + +### proposalThreshold + +```solidity +function proposalThreshold() public pure returns (uint256) +``` + +_Part of the Governor Bravo's interface: _"The number of votes required in order for a voter to become a proposer"_._ + +### _authorizeUpgrade + +```solidity +function _authorizeUpgrade(address newImplementation) internal +``` + +_Function that should revert when `msg.sender` is not authorized to upgrade the contract. Called by +{upgradeTo} and {upgradeToAndCall}. + +Normally, this function will use an xref:access.adoc[access control] modifier such as {Ownable-onlyOwner}. + +```solidity +function _authorizeUpgrade(address) internal override onlyOwner {} +```_ + +### _getVotes + +```solidity +function _getVotes(address account, uint256 blockNumber, bytes _data) internal view returns (uint256 votes) +``` + +### quorum + +```solidity +function quorum(uint256 blockNumber) public view returns (uint256) +``` + +### state + +```solidity +function state(uint256 proposalId) public view returns (enum IGovernorUpgradeable.ProposalState) +``` + +### propose + +```solidity +function propose(address[] targets, uint256[] values, bytes[] calldatas, string description) public returns (uint256) +``` + +### _execute + +```solidity +function _execute(uint256 proposalId, address[] targets, uint256[] values, bytes[] calldatas, bytes32 descriptionHash) internal +``` + +### _cancel + +```solidity +function _cancel(address[] targets, uint256[] values, bytes[] calldatas, bytes32 descriptionHash) internal returns (uint256) +``` + +### _executor + +```solidity +function _executor() internal view returns (address) +``` + +### supportsInterface + +```solidity +function supportsInterface(bytes4 interfaceId) public view returns (bool) +``` + +## GovernorVotesMultiSourceUpgradeable + +### validVoteSources + +```solidity +modifier validVoteSources(contract IVotesUpgradeable[] _voteSources) +``` + +### __GovernorVotesMultiSource_init + +```solidity +function __GovernorVotesMultiSource_init(contract IVotesUpgradeable tokenAddress, contract IVotesUpgradeable[] _voteSources) internal +``` + +### __GovernorVotesMultiSource_init__unchained + +```solidity +function __GovernorVotesMultiSource_init__unchained(contract IVotesUpgradeable tokenAddress, contract IVotesUpgradeable[] _voteSources) internal +``` + +### _getVotes + +```solidity +function _getVotes(address account, uint256 blockNumber, bytes _data) internal view virtual returns (uint256 votes) +``` + +Modified from open zeppelin defaults + +### setVoteSources + +```solidity +function setVoteSources(contract IVotesUpgradeable[] _voteSources) public +``` + +New function allowing the DAO to update its vote sources + +### getVoteSources + +```solidity +function getVoteSources() public view returns (contract IVotesUpgradeable[]) +``` + +## MyTimelockControllerUpgradeable + +### constructor + +```solidity +constructor() public +``` + +### initialize + +```solidity +function initialize(uint256 minDelay, address[] proposers, address[] executors) public +``` + +## IAdjustable + +_Interface for the Adjustable contract. Defines methods to update +the contract and events emitted upon update._ + +### Adjust + +```solidity +event Adjust(address beneficiary, int256 amount) +``` + +### SetToken + +```solidity +event SetToken(contract IERC20 token) +``` + +### SetTotal + +```solidity +event SetTotal(uint256 total) +``` + +### SetUri + +```solidity +event SetUri(string uri) +``` + +### adjust + +```solidity +function adjust(address beneficiary, int256 amount) external +``` + +### setToken + +```solidity +function setToken(contract IERC20 token) external +``` + +### setTotal + +```solidity +function setTotal(uint256 total) external +``` + +### setUri + +```solidity +function setUri(string uri) external +``` + +### setVoteFactor + +```solidity +function setVoteFactor(uint256 setVoteFactor) external +``` + +## IConnext + +### xcall + +```solidity +function xcall(uint32 _destination, address _to, address _asset, address _delegate, uint256 _amount, uint256 _slippage, bytes _callData) external payable returns (bytes32) +``` + +### xcall + +```solidity +function xcall(uint32 _destination, address _to, address _asset, address _delegate, uint256 _amount, uint256 _slippage, bytes _callData, uint256 _relayerFee) external returns (bytes32) +``` + +### xcallIntoLocal + +```solidity +function xcallIntoLocal(uint32 _destination, address _to, address _asset, address _delegate, uint256 _amount, uint256 _slippage, bytes _callData) external payable returns (bytes32) +``` + +### domain + +```solidity +function domain() external view returns (uint256) +``` + +## IContinuousVesting + +### SetContinuousVesting + +```solidity +event SetContinuousVesting(uint256 start, uint256 cliff, uint256 end) +``` + +### getVestingConfig + +```solidity +function getVestingConfig() external view returns (uint256, uint256, uint256) +``` + +### setVestingConfig + +```solidity +function setVestingConfig(uint256 _start, uint256 _cliff, uint256 _end) external +``` + +## ICrosschain + +Defines functions and events for receiving and tracking crosschain claims + +### CrosschainClaim + +```solidity +event CrosschainClaim(bytes32 id, address beneficiary, address recipient, uint32 recipientDomain, uint256 amount) +``` + +_The beneficiary and recipient may be different addresses. The beneficiary is the address +eligible to receive the claim, and the recipient is where the funds are actually sent._ + +## DistributionRecord + +_This struct tracks claim progress for a given beneficiary. +Because many claims are stored in a merkle root, this struct is only valid once initialized. +Users can no longer claim once their claimed quantity meets or exceeds their total quantity. +Note that admins may update the merkle root or adjust the total quantity for a specific +beneficiary after initialization!_ + +```solidity +struct DistributionRecord { + bool initialized; + uint120 total; + uint120 claimed; +} +``` + +## IDistributor + +### InitializeDistributor + +```solidity +event InitializeDistributor(contract IERC20 token, uint256 total, string uri, uint256 fractionDenominator) +``` + +### InitializeDistributionRecord + +```solidity +event InitializeDistributionRecord(address beneficiary, uint256 total) +``` + +### Claim + +```solidity +event Claim(address beneficiary, uint256 amount) +``` + +### getDistributionRecord + +```solidity +function getDistributionRecord(address beneficiary) external view returns (struct DistributionRecord) +``` + +_get the current distribution status for a particular user_ + +#### Parameters + +| Name | Type | Description | +| ---- | ---- | ----------- | +| beneficiary | address | the address of the beneficiary | + +### getClaimableAmount + +```solidity +function getClaimableAmount(address beneficiary) external view returns (uint256) +``` + +_get the amount of tokens currently claimable by a beneficiary_ + +#### Parameters + +| Name | Type | Description | +| ---- | ---- | ----------- | +| beneficiary | address | the address of the beneficiary | + +### getFractionDenominator + +```solidity +function getFractionDenominator() external view returns (uint256) +``` + +_get the denominator for vesting fractions represented as integers_ + +### token + +```solidity +function token() external view returns (contract IERC20) +``` + +_get the ERC20 token being distributed_ + +### total + +```solidity +function total() external view returns (uint256) +``` + +_get the total distribution quantity across all beneficiaries_ + +### uri + +```solidity +function uri() external view returns (string) +``` + +_get a URI for additional information about the distribution_ + +### NAME + +```solidity +function NAME() external view returns (string) +``` + +_get a human-readable name for the distributor that describes basic functionality +On-chain consumers should rely on registered ERC165 interface IDs or similar for more specificity_ + +### VERSION + +```solidity +function VERSION() external view returns (uint256) +``` + +_get a human-readable version for the distributor that describes basic functionality +The version should update whenever functionality significantly changes +On-chain consumers should rely on registered ERC165 interface IDs or similar for more specificity_ + +## IERC20Extended + +### decimals + +```solidity +function decimals() external view returns (uint8) +``` + +## IHashflowQuote + +### RFQTQuote + +```solidity +struct RFQTQuote { + address pool; + address externalAccount; + address trader; + address effectiveTrader; + address baseToken; + address quoteToken; + uint256 effectiveBaseTokenAmount; + uint256 maxBaseTokenAmount; + uint256 maxQuoteTokenAmount; + uint256 quoteExpiry; + uint256 nonce; + bytes32 txid; + bytes signature; +} +``` + +### XChainRFQTQuote + +```solidity +struct XChainRFQTQuote { + uint16 srcChainId; + uint16 dstChainId; + address srcPool; + bytes32 dstPool; + address srcExternalAccount; + bytes32 dstExternalAccount; + address trader; + address baseToken; + address quoteToken; + uint256 baseTokenAmount; + uint256 quoteTokenAmount; + uint256 quoteExpiry; + uint256 nonce; + bytes32 txid; + bytes signature; +} +``` + +### XChainMessageProtocol + +```solidity +enum XChainMessageProtocol { + layerZero, + wormhole +} +``` + +### tradeSingleHop + +```solidity +function tradeSingleHop(struct IHashflowQuote.RFQTQuote quote) external payable +``` + +### tradeXChain + +```solidity +function tradeXChain(struct IHashflowQuote.XChainRFQTQuote quote, enum IHashflowQuote.XChainMessageProtocol protocol) external payable +``` + +## IMerkleSet + +### SetMerkleRoot + +```solidity +event SetMerkleRoot(bytes32 merkleRoot) +``` + +### getMerkleRoot + +```solidity +function getMerkleRoot() external view returns (bytes32 root) +``` + +## IOracleOrL2OracleWithSequencerCheck + +### decimals + +```solidity +function decimals() external view returns (uint8) +``` + +### latestRoundData + +```solidity +function latestRoundData() external view returns (uint80 roundId, int256 answer, uint256 startedAt, uint256 updatedAt, uint80 answeredInRound) +``` + +## PriceTier + +```solidity +struct PriceTier { + uint128 price; + uint128 vestedFraction; +} +``` + +## IPriceTierVesting + +### SetPriceTierConfig + +```solidity +event SetPriceTierConfig(uint256 start, uint256 end, contract IOracleOrL2OracleWithSequencerCheck oracle, struct PriceTier[] tiers) +``` + +### getStart + +```solidity +function getStart() external view returns (uint256) +``` + +### getEnd + +```solidity +function getEnd() external view returns (uint256) +``` + +### getOracle + +```solidity +function getOracle() external view returns (contract IOracleOrL2OracleWithSequencerCheck) +``` + +### getPriceTier + +```solidity +function getPriceTier(uint256 i) external view returns (struct PriceTier) +``` + +### getPriceTiers + +```solidity +function getPriceTiers() external view returns (struct PriceTier[]) +``` + +### setPriceTiers + +```solidity +function setPriceTiers(uint256 _start, uint256 _end, contract IOracleOrL2OracleWithSequencerCheck _oracle, struct PriceTier[] _tiers) external +``` + +## Tranche + +```solidity +struct Tranche { + uint128 time; + uint128 vestedFraction; +} +``` + +## ITrancheVesting + +### SetTranche + +```solidity +event SetTranche(uint256 index, uint128 time, uint128 VestedFraction) +``` + +### getTranche + +```solidity +function getTranche(uint256 i) external view returns (struct Tranche) +``` + +### getTranches + +```solidity +function getTranches() external view returns (struct Tranche[]) +``` + +### setTranches + +```solidity +function setTranches(struct Tranche[] _tranches) external +``` + +## IVesting + +### getVestedFraction + +```solidity +function getVestedFraction(address, uint256 time) external returns (uint256) +``` + +## IVoting + +### SetVoteFactor + +```solidity +event SetVoteFactor(uint256 voteFactor) +``` + +### getTotalVotes + +```solidity +function getTotalVotes() external view returns (uint256) +``` + +### getVoteFactor + +```solidity +function getVoteFactor(address account) external view returns (uint256) +``` + +## IXReceiver + +### xReceive + +```solidity +function xReceive(bytes32 _transferId, uint256 _amount, address _asset, address _originSender, uint32 _origin, bytes _callData) external returns (bytes) +``` + +## ConnextMock + +### XCalled + +```solidity +event XCalled(uint32 destination, address to, address asset, address delegate, uint256 amount, uint256 slippage, bytes callData) +``` + +### NativeRelayerFeeIncluded + +```solidity +event NativeRelayerFeeIncluded(address caller, uint256 amount) +``` + +### constructor + +```solidity +constructor(uint32 domain_) public +``` + +### domain + +```solidity +function domain() public view returns (uint32) +``` + +### setDomain + +```solidity +function setDomain(uint32 domain_) public +``` + +### xcall + +```solidity +function xcall(uint32 _destination, address _to, address _asset, address _delegate, uint256 _amount, uint256 _slippage, bytes _callData) public payable returns (bytes32) +``` + +### callXreceive + +```solidity +function callXreceive(bytes32 _transferId, uint256 _amount, address _asset, address _originSender, uint32 _origin, bytes32[] _proof, address _distributor) public returns (bytes) +``` + +## FakeChainlinkOracle + +### constructor + +```solidity +constructor(int256 _answer, string _oracleDescription) public +``` + +### decimals + +```solidity +function decimals() external pure returns (uint8) +``` + +### description + +```solidity +function description() external view returns (string) +``` + +### version + +```solidity +function version() external pure returns (uint256) +``` + +### setAnswer + +```solidity +function setAnswer(int256 _answer) public +``` + +### latestRoundData + +```solidity +function latestRoundData() external view returns (uint80 roundId, int256, uint256 startedAt, uint256 updatedAt, uint80 answeredInRound) +``` + +### getRoundData + +```solidity +function getRoundData(uint80) external view returns (uint80 roundId, int256, uint256 startedAt, uint256 updatedAt, uint80 answeredInRound) +``` + +## FakeEthOracle + +### constructor + +```solidity +constructor(int256 _answer, string _oracleDescription) public +``` + +### decimals + +```solidity +function decimals() external pure returns (uint8) +``` + +### description + +```solidity +function description() external view returns (string) +``` + +### version + +```solidity +function version() external pure returns (uint256) +``` + +### setAnswer + +```solidity +function setAnswer(int256 _answer) public +``` + +### latestRoundData + +```solidity +function latestRoundData() external view returns (uint80 roundId, int256, uint256 startedAt, uint256 updatedAt, uint80 answeredInRound) +``` + +### getRoundData + +```solidity +function getRoundData(uint80) external view returns (uint80 roundId, int256, uint256 startedAt, uint256 updatedAt, uint80 answeredInRound) +``` + +## FakeUsdcOracle + +### constructor + +```solidity +constructor(int256 _answer, string _oracleDescription) public +``` + +### decimals + +```solidity +function decimals() external pure returns (uint8) +``` + +### description + +```solidity +function description() external view returns (string) +``` + +### version + +```solidity +function version() external pure returns (uint256) +``` + +### setAnswer + +```solidity +function setAnswer(int256 _answer) public +``` + +### latestRoundData + +```solidity +function latestRoundData() external view returns (uint80 roundId, int256, uint256 startedAt, uint256 updatedAt, uint80 answeredInRound) +``` + +### getRoundData + +```solidity +function getRoundData(uint80) external view returns (uint80 roundId, int256, uint256 startedAt, uint256 updatedAt, uint80 answeredInRound) +``` + +## FakeUsdtOracle + +### constructor + +```solidity +constructor(int256 _answer, string _oracleDescription) public +``` + +### decimals + +```solidity +function decimals() external pure returns (uint8) +``` + +### description + +```solidity +function description() external view returns (string) +``` + +### version + +```solidity +function version() external pure returns (uint256) +``` + +### setAnswer + +```solidity +function setAnswer(int256 _answer) public +``` + +### latestRoundData + +```solidity +function latestRoundData() external view returns (uint80 roundId, int256, uint256 startedAt, uint256 updatedAt, uint80 answeredInRound) +``` + +### getRoundData + +```solidity +function getRoundData(uint80) external view returns (uint80 roundId, int256, uint256 startedAt, uint256 updatedAt, uint80 answeredInRound) +``` + +## FakeSequencerUptimeFeed + +### constructor + +```solidity +constructor(int256 _answer, string _oracleDescription) public +``` + +### decimals + +```solidity +function decimals() external pure returns (uint8) +``` + +### description + +```solidity +function description() external view returns (string) +``` + +### version + +```solidity +function version() external pure returns (uint256) +``` + +### setAnswer + +```solidity +function setAnswer(int256 _answer) public +``` + +### getAnswer + +```solidity +function getAnswer(uint256) external view returns (int256) +``` + +### getTimestamp + +```solidity +function getTimestamp(uint256) external view returns (uint256) +``` + +### latestAnswer + +```solidity +function latestAnswer() external view returns (int256) +``` + +### latestRound + +```solidity +function latestRound() external pure returns (uint256) +``` + +### latestTimestamp + +```solidity +function latestTimestamp() external view returns (uint256) +``` + +### latestRoundData + +```solidity +function latestRoundData() external view returns (uint80 roundId, int256, uint256, uint256, uint80 answeredInRound) +``` + +### getRoundData + +```solidity +function getRoundData(uint80) external view returns (uint80 roundId, int256, uint256, uint256, uint80 answeredInRound) +``` + +## GovernorMultiSourceUpgradeableMock + +### constructor + +```solidity +constructor() public +``` + +### initialize + +```solidity +function initialize(contract IVotesUpgradeable _token, contract TimelockControllerUpgradeable _timelock, contract IVotesUpgradeable[] _voteSources) public +``` + +### votingDelay + +```solidity +function votingDelay() public pure returns (uint256) +``` + +module:user-config + +_Delay, in number of block, between the proposal is created and the vote starts. This can be increassed to +leave time for users to buy voting power, or delegate it, before the voting of a proposal starts._ + +### votingPeriod + +```solidity +function votingPeriod() public pure returns (uint256) +``` + +module:user-config + +_Delay, in number of blocks, between the vote start and vote ends. + +NOTE: The {votingDelay} can delay the start of the vote. This must be considered when setting the voting +duration compared to the voting delay._ + +## HashflowRouterMock + +### constructor + +```solidity +constructor() public +``` + +### estimateCrossChainFee + +```solidity +function estimateCrossChainFee() public pure returns (uint256) +``` + +### tradeSingleHop + +```solidity +function tradeSingleHop(struct IHashflowQuote.RFQTQuote quote) public payable +``` + +### tradeXChain + +```solidity +function tradeXChain(struct IHashflowQuote.XChainRFQTQuote quote, enum IHashflowQuote.XChainMessageProtocol) public payable +``` + +### depositEth + +```solidity +function depositEth() external payable +``` + +## Metrics + +```solidity +struct Metrics { + uint256 purchaseCount; + uint256 buyerCount; + uint256 purchaseTotal; + mapping(address => uint256) buyerTotal; +} +``` + +## PaymentTokenInfo + +```solidity +struct PaymentTokenInfo { + contract IOracleOrL2OracleWithSequencerCheck oracle; + uint8 decimals; +} +``` + +## SaleManager_v_1_0 + +### priceOracle + +```solidity +contract IOracleOrL2OracleWithSequencerCheck priceOracle +``` + +### paymentToken + +```solidity +contract IERC20 paymentToken +``` + +### paymentTokenDecimals + +```solidity +uint8 paymentTokenDecimals +``` + +### Sale + +```solidity +struct Sale { + address payable seller; + bytes32 merkleRoot; + address claimManager; + uint256 saleBuyLimit; + uint256 userBuyLimit; + uint256 startTime; + uint256 endTime; + string name; + string symbol; + uint256 price; + uint8 decimals; + uint256 totalSpent; + uint256 maxQueueTime; + uint160 randomValue; + mapping(address => uint256) spent; +} +``` + +### sales + +```solidity +mapping(bytes32 => struct SaleManager_v_1_0.Sale) sales +``` + +### saleCount + +```solidity +uint256 saleCount +``` + +### totalSpent + +```solidity +uint256 totalSpent +``` + +### NewSale + +```solidity +event NewSale(bytes32 saleId, bytes32 merkleRoot, address seller, uint256 saleBuyLimit, uint256 userBuyLimit, uint256 maxQueueTime, uint256 startTime, uint256 endTime, string name, string symbol, uint256 price, uint8 decimals) +``` + +### UpdateStart + +```solidity +event UpdateStart(bytes32 saleId, uint256 startTime) +``` + +### UpdateEnd + +```solidity +event UpdateEnd(bytes32 saleId, uint256 endTime) +``` + +### UpdateMerkleRoot + +```solidity +event UpdateMerkleRoot(bytes32 saleId, bytes32 merkleRoot) +``` + +### UpdateMaxQueueTime + +```solidity +event UpdateMaxQueueTime(bytes32 saleId, uint256 maxQueueTime) +``` + +### Buy + +```solidity +event Buy(bytes32 saleId, address buyer, uint256 value, bool native, bytes32[] proof) +``` + +### RegisterClaimManager + +```solidity +event RegisterClaimManager(bytes32 saleId, address claimManager) +``` + +### constructor + +```solidity +constructor(address _paymentToken, uint8 _paymentTokenDecimals, address _priceOracle) public +``` + +### validSale + +```solidity +modifier validSale(bytes32 saleId) +``` + +### isSeller + +```solidity +modifier isSeller(bytes32 saleId) +``` + +### canAccessSale + +```solidity +modifier canAccessSale(bytes32 saleId, bytes32[] proof) +``` + +### requireOpen + +```solidity +modifier requireOpen(bytes32 saleId) +``` + +### getLatestPrice + +```solidity +function getLatestPrice() public view returns (uint256) +``` + +### getSeller + +```solidity +function getSeller(bytes32 saleId) public view returns (address) +``` + +### getMerkleRoot + +```solidity +function getMerkleRoot(bytes32 saleId) public view returns (bytes32) +``` + +### getPriceOracle + +```solidity +function getPriceOracle() public view returns (address) +``` + +### getClaimManager + +```solidity +function getClaimManager(bytes32 saleId) public view returns (address) +``` + +### getSaleBuyLimit + +```solidity +function getSaleBuyLimit(bytes32 saleId) public view returns (uint256) +``` + +### getUserBuyLimit + +```solidity +function getUserBuyLimit(bytes32 saleId) public view returns (uint256) +``` + +### getStartTime + +```solidity +function getStartTime(bytes32 saleId) public view returns (uint256) +``` + +### getEndTime + +```solidity +function getEndTime(bytes32 saleId) public view returns (uint256) +``` + +### getName + +```solidity +function getName(bytes32 saleId) public view returns (string) +``` + +### getSymbol + +```solidity +function getSymbol(bytes32 saleId) public view returns (string) +``` + +### getPrice + +```solidity +function getPrice(bytes32 saleId) public view returns (uint256) +``` + +### getDecimals + +```solidity +function getDecimals(bytes32 saleId) public view returns (uint256) +``` + +### getTotalSpent + +```solidity +function getTotalSpent(bytes32 saleId) public view returns (uint256) +``` + +### getRandomValue + +```solidity +function getRandomValue(bytes32 saleId) public view returns (uint160) +``` + +### getMaxQueueTime + +```solidity +function getMaxQueueTime(bytes32 saleId) public view returns (uint256) +``` + +### generateRandomishValue + +```solidity +function generateRandomishValue(bytes32 merkleRoot) public view returns (uint160) +``` + +### getFairQueueTime + +```solidity +function getFairQueueTime(bytes32 saleId, address buyer) public view returns (uint256) +``` + +### spentToBought + +```solidity +function spentToBought(bytes32 saleId, uint256 spent) public view returns (uint256) +``` + +### nativeToPaymentToken + +```solidity +function nativeToPaymentToken(uint256 nativeValue) public view returns (uint256) +``` + +### getSpent + +```solidity +function getSpent(bytes32 saleId, address userAddress) public view returns (uint256) +``` + +### getBought + +```solidity +function getBought(bytes32 saleId, address userAddress) public view returns (uint256) +``` + +### isOpen + +```solidity +function isOpen(bytes32 saleId) public view returns (bool) +``` + +### isOver + +```solidity +function isOver(bytes32 saleId) public view returns (bool) +``` + +### newSale + +```solidity +function newSale(bytes32 merkleRoot, uint256 saleBuyLimit, uint256 userBuyLimit, uint256 startTime, uint256 endTime, uint160 maxQueueTime, string name, string symbol, uint256 price, uint8 decimals) public returns (bytes32) +``` + +sale setup and config + - the address calling this method is the seller: all payments are sent to this address + - only the seller can change sale configuration + +### setStart + +```solidity +function setStart(bytes32 saleId, uint256 startTime) public +``` + +### setEnd + +```solidity +function setEnd(bytes32 saleId, uint256 endTime) public +``` + +### setMerkleRoot + +```solidity +function setMerkleRoot(bytes32 saleId, bytes32 merkleRoot) public +``` + +### setMaxQueueTime + +```solidity +function setMaxQueueTime(bytes32 saleId, uint160 maxQueueTime) public +``` + +### _isAllowed + +```solidity +function _isAllowed(bytes32 root, address account, bytes32[] proof) external pure returns (bool) +``` + +### buy + +```solidity +function buy(bytes32 saleId, uint256 tokenQuantity, bytes32[] proof) public +``` + +### buy + +```solidity +function buy(bytes32 saleId, bytes32[] proof) public payable +``` + +### registerClaimManager + +```solidity +function registerClaimManager(bytes32 saleId, address claimManager) public +``` + +### recoverERC20 + +```solidity +function recoverERC20(bytes32 saleId, address tokenAddress, uint256 tokenAmount) public +``` + +## ClaimManager + +### Open + +```solidity +event Open(uint256 totalClaims) +``` + +### Void + +```solidity +event Void(address claimant, uint256 voidedClaim, bytes32 saleId) +``` + +### Claim + +```solidity +event Claim(address claimant, uint256 amount, bytes32 saleId) +``` + +### Close + +```solidity +event Close() +``` + +### saleManager + +```solidity +contract SaleManager_v_1_2 saleManager +``` + +### saleId + +```solidity +bytes32 saleId +``` + +### claimToken + +```solidity +contract IERC20 claimToken +``` + +### opened + +```solidity +bool opened +``` + +### voidClaims + +```solidity +uint256 voidClaims +``` + +### remainingClaims + +```solidity +uint256 remainingClaims +``` + +### claimed + +```solidity +mapping(address => bool) claimed +``` + +### constructor + +```solidity +constructor(address _saleManager, bytes32 _saleId, address _claimToken) public +``` + +### isAdmin + +```solidity +modifier isAdmin() +``` + +### saleOver + +```solidity +modifier saleOver() +``` + +### claimsOpened + +```solidity +modifier claimsOpened() +``` + +### getRemainingClaim + +```solidity +function getRemainingClaim(address claimant) public view returns (uint256) +``` + +### getTotalClaimable + +```solidity +function getTotalClaimable() public view returns (uint256) +``` + +### getTokenBalance + +```solidity +function getTokenBalance() public view returns (uint256) +``` + +### void + +```solidity +function void(address claimant) public returns (uint256) +``` + +### open + +```solidity +function open() public +``` + +### claim + +```solidity +function claim() public returns (uint256) +``` + +### recoverERC20 + +```solidity +function recoverERC20(address tokenAddress, uint256 tokenAmount) public +``` + +## SaleManager_v_1_2 + +### priceOracle + +```solidity +contract IOracleOrL2OracleWithSequencerCheck priceOracle +``` + +### paymentToken + +```solidity +contract IERC20 paymentToken +``` + +### paymentTokenDecimals + +```solidity +uint8 paymentTokenDecimals +``` + +### Sale + +```solidity +struct Sale { + address payable recipient; + address admin; + bytes32 merkleRoot; + address claimManager; + uint256 saleBuyLimit; + uint256 userBuyLimit; + uint256 startTime; + uint256 endTime; + string uri; + uint256 price; + uint8 decimals; + uint256 totalSpent; + uint256 maxQueueTime; + uint160 randomValue; + mapping(address => uint256) spent; +} +``` + +### saleCount + +```solidity +uint256 saleCount +``` + +### totalSpent + +```solidity +uint256 totalSpent +``` + +### VERSION + +```solidity +string VERSION +``` + +### NewSale + +```solidity +event NewSale(bytes32 saleId, bytes32 merkleRoot, address recipient, address admin, uint256 saleBuyLimit, uint256 userBuyLimit, uint256 maxQueueTime, uint256 startTime, uint256 endTime, string uri, uint256 price, uint8 decimals) +``` + +### Deploy + +```solidity +event Deploy(address paymentToken, uint8 paymentTokenDecimals, address priceOracle) +``` + +### UpdateStart + +```solidity +event UpdateStart(bytes32 saleId, uint256 startTime) +``` + +### UpdateEnd + +```solidity +event UpdateEnd(bytes32 saleId, uint256 endTime) +``` + +### UpdateMerkleRoot + +```solidity +event UpdateMerkleRoot(bytes32 saleId, bytes32 merkleRoot) +``` + +### UpdateMaxQueueTime + +```solidity +event UpdateMaxQueueTime(bytes32 saleId, uint256 maxQueueTime) +``` + +### Buy + +```solidity +event Buy(bytes32 saleId, address buyer, uint256 value, bool native, bytes32[] proof) +``` + +### RegisterClaimManager + +```solidity +event RegisterClaimManager(bytes32 saleId, address claimManager) +``` + +### UpdateUri + +```solidity +event UpdateUri(bytes32 saleId, string uri) +``` + +### constructor + +```solidity +constructor(address _paymentToken, uint8 _paymentTokenDecimals, address _priceOracle) public +``` + +### validSale + +```solidity +modifier validSale(bytes32 saleId) +``` + +### isAdmin + +```solidity +modifier isAdmin(bytes32 saleId) +``` + +### canAccessSale + +```solidity +modifier canAccessSale(bytes32 saleId, bytes32[] proof) +``` + +### requireOpen + +```solidity +modifier requireOpen(bytes32 saleId) +``` + +### getLatestPrice + +```solidity +function getLatestPrice() public view returns (uint256) +``` + +### getAdmin + +```solidity +function getAdmin(bytes32 saleId) public view returns (address) +``` + +### getRecipient + +```solidity +function getRecipient(bytes32 saleId) public view returns (address) +``` + +### getMerkleRoot + +```solidity +function getMerkleRoot(bytes32 saleId) public view returns (bytes32) +``` + +### getPriceOracle + +```solidity +function getPriceOracle() public view returns (address) +``` + +### getClaimManager + +```solidity +function getClaimManager(bytes32 saleId) public view returns (address) +``` + +### getSaleBuyLimit + +```solidity +function getSaleBuyLimit(bytes32 saleId) public view returns (uint256) +``` + +### getUserBuyLimit + +```solidity +function getUserBuyLimit(bytes32 saleId) public view returns (uint256) +``` + +### getStartTime + +```solidity +function getStartTime(bytes32 saleId) public view returns (uint256) +``` + +### getEndTime + +```solidity +function getEndTime(bytes32 saleId) public view returns (uint256) +``` + +### getUri + +```solidity +function getUri(bytes32 saleId) public view returns (string) +``` + +### getPrice + +```solidity +function getPrice(bytes32 saleId) public view returns (uint256) +``` + +### getDecimals + +```solidity +function getDecimals(bytes32 saleId) public view returns (uint256) +``` + +### getTotalSpent + +```solidity +function getTotalSpent(bytes32 saleId) public view returns (uint256) +``` + +### getRandomValue + +```solidity +function getRandomValue(bytes32 saleId) public view returns (uint160) +``` + +### getMaxQueueTime + +```solidity +function getMaxQueueTime(bytes32 saleId) public view returns (uint256) +``` + +### generateRandomishValue + +```solidity +function generateRandomishValue(bytes32 merkleRoot) public view returns (uint160) +``` + +### getFairQueueTime + +```solidity +function getFairQueueTime(bytes32 saleId, address buyer) public view returns (uint256) +``` + +### spentToBought + +```solidity +function spentToBought(bytes32 saleId, uint256 spent) public view returns (uint256) +``` + +### nativeToPaymentToken + +```solidity +function nativeToPaymentToken(uint256 nativeValue) public view returns (uint256) +``` + +### getSpent + +```solidity +function getSpent(bytes32 saleId, address userAddress) public view returns (uint256) +``` + +### getBought + +```solidity +function getBought(bytes32 saleId, address userAddress) public view returns (uint256) +``` + +### isOpen + +```solidity +function isOpen(bytes32 saleId) public view returns (bool) +``` + +### isOver + +```solidity +function isOver(bytes32 saleId) public view returns (bool) +``` + +### newSale + +```solidity +function newSale(address payable recipient, bytes32 merkleRoot, uint256 saleBuyLimit, uint256 userBuyLimit, uint256 startTime, uint256 endTime, uint160 maxQueueTime, string uri, uint256 price, uint8 decimals) public returns (bytes32) +``` + +sale setup and config + - the address calling this method is the admin: only the admin can change sale configuration + - all payments are sent to the the recipient + +### setStart + +```solidity +function setStart(bytes32 saleId, uint256 startTime) public +``` + +### setEnd + +```solidity +function setEnd(bytes32 saleId, uint256 endTime) public +``` + +### setMerkleRoot + +```solidity +function setMerkleRoot(bytes32 saleId, bytes32 merkleRoot) public +``` + +### setMaxQueueTime + +```solidity +function setMaxQueueTime(bytes32 saleId, uint160 maxQueueTime) public +``` + +### setUriAndMerkleRoot + +```solidity +function setUriAndMerkleRoot(bytes32 saleId, bytes32 merkleRoot, string uri) public +``` + +### _isAllowed + +```solidity +function _isAllowed(bytes32 root, address account, bytes32[] proof) external pure returns (bool) +``` + +### buy + +```solidity +function buy(bytes32 saleId, uint256 tokenQuantity, bytes32[] proof) public +``` + +### buy + +```solidity +function buy(bytes32 saleId, bytes32[] proof) public payable +``` + +### registerClaimManager + +```solidity +function registerClaimManager(bytes32 saleId, address claimManager) public +``` + +### recoverERC20 + +```solidity +function recoverERC20(bytes32 saleId, address tokenAddress, uint256 tokenAmount) public +``` + +## ISaleManager_v_1_3 + +### getAdmin + +```solidity +function getAdmin(bytes32 saleId) external view returns (address) +``` + +### getRecipient + +```solidity +function getRecipient(bytes32 saleId) external view returns (address) +``` + +### getMerkleRoot + +```solidity +function getMerkleRoot(bytes32 saleId) external view returns (bytes32) +``` + +### getPriceOracle + +```solidity +function getPriceOracle() external view returns (address) +``` + +### getClaimManager + +```solidity +function getClaimManager(bytes32 saleId) external view returns (address) +``` + +### getSaleBuyLimit + +```solidity +function getSaleBuyLimit(bytes32 saleId) external view returns (uint256) +``` + +### getUserBuyLimit + +```solidity +function getUserBuyLimit(bytes32 saleId) external view returns (uint256) +``` + +### getPurchaseMinimum + +```solidity +function getPurchaseMinimum(bytes32 saleId) external view returns (uint256) +``` + +### getStartTime + +```solidity +function getStartTime(bytes32 saleId) external view returns (uint256) +``` + +### getEndTime + +```solidity +function getEndTime(bytes32 saleId) external view returns (uint256) +``` + +### getUri + +```solidity +function getUri(bytes32 saleId) external view returns (string) +``` + +### getPrice + +```solidity +function getPrice(bytes32 saleId) external view returns (uint256) +``` + +### getDecimals + +```solidity +function getDecimals(bytes32 saleId) external view returns (uint256) +``` + +### getTotalSpent + +```solidity +function getTotalSpent(bytes32 saleId) external view returns (uint256) +``` + +### getRandomValue + +```solidity +function getRandomValue(bytes32 saleId) external view returns (uint160) +``` + +### getMaxQueueTime + +```solidity +function getMaxQueueTime(bytes32 saleId) external view returns (uint256) +``` + +### generateRandomishValue + +```solidity +function generateRandomishValue(bytes32 merkleRoot) external view returns (uint160) +``` + +### getFairQueueTime + +```solidity +function getFairQueueTime(bytes32 saleId, address buyer) external view returns (uint256) +``` + +### spentToBought + +```solidity +function spentToBought(bytes32 saleId, uint256 spent) external view returns (uint256) +``` + +### nativeToPaymentToken + +```solidity +function nativeToPaymentToken(uint256 nativeValue) external view returns (uint256) +``` + +### getSpent + +```solidity +function getSpent(bytes32 saleId, address userAddress) external view returns (uint256) +``` + +### getBought + +```solidity +function getBought(bytes32 saleId, address userAddress) external view returns (uint256) +``` + +### isOpen + +```solidity +function isOpen(bytes32 saleId) external view returns (bool) +``` + +### isOver + +```solidity +function isOver(bytes32 saleId) external view returns (bool) +``` + +### newSale + +```solidity +function newSale(address payable recipient, bytes32 merkleRoot, uint256 saleBuyLimit, uint256 userBuyLimit, uint256 purchaseMinimum, uint256 startTime, uint256 endTime, uint160 maxQueueTime, string uri, uint256 price, uint8 decimals) external returns (bytes32) +``` + +### setStart + +```solidity +function setStart(bytes32 saleId, uint256 startTime) external +``` + +### setEnd + +```solidity +function setEnd(bytes32 saleId, uint256 endTime) external +``` + +### setMerkleRoot + +```solidity +function setMerkleRoot(bytes32 saleId, bytes32 merkleRoot) external +``` + +### setMaxQueueTime + +```solidity +function setMaxQueueTime(bytes32 saleId, uint160 maxQueueTime) external +``` + +### setUriAndMerkleRoot + +```solidity +function setUriAndMerkleRoot(bytes32 saleId, bytes32 merkleRoot, string uri) external +``` + +### buy + +```solidity +function buy(bytes32 saleId, uint256 tokenQuantity, bytes32[] proof) external +``` + +### buy + +```solidity +function buy(bytes32 saleId, bytes32[] proof) external payable +``` + +### registerClaimManager + +```solidity +function registerClaimManager(bytes32 saleId, address claimManager) external +``` + +### recoverERC20 + +```solidity +function recoverERC20(bytes32 saleId, address tokenAddress, uint256 tokenAmount) external +``` + +## SaleManager_v_1_3 + +### priceOracle + +```solidity +contract IOracleOrL2OracleWithSequencerCheck priceOracle +``` + +### paymentToken + +```solidity +contract IERC20 paymentToken +``` + +### paymentTokenDecimals + +```solidity +uint8 paymentTokenDecimals +``` + +### Sale + +```solidity +struct Sale { + address payable recipient; + address admin; + bytes32 merkleRoot; + address claimManager; + uint256 saleBuyLimit; + uint256 userBuyLimit; + uint256 purchaseMinimum; + uint256 startTime; + uint256 endTime; + string uri; + uint256 price; + uint8 decimals; + uint256 totalSpent; + uint256 maxQueueTime; + uint160 randomValue; + mapping(address => uint256) spent; +} +``` + +### saleCount + +```solidity +uint256 saleCount +``` + +### totalSpent + +```solidity +uint256 totalSpent +``` + +### VERSION + +```solidity +string VERSION +``` + +### NewSale + +```solidity +event NewSale(bytes32 saleId, bytes32 merkleRoot, address recipient, address admin, uint256 saleBuyLimit, uint256 userBuyLimit, uint256 purchaseMinimum, uint256 maxQueueTime, uint256 startTime, uint256 endTime, string uri, uint256 price, uint8 decimals) +``` + +### Deploy + +```solidity +event Deploy(address paymentToken, uint8 paymentTokenDecimals, address priceOracle) +``` + +### UpdateStart + +```solidity +event UpdateStart(bytes32 saleId, uint256 startTime) +``` + +### UpdateEnd + +```solidity +event UpdateEnd(bytes32 saleId, uint256 endTime) +``` + +### UpdateMerkleRoot + +```solidity +event UpdateMerkleRoot(bytes32 saleId, bytes32 merkleRoot) +``` + +### UpdateMaxQueueTime + +```solidity +event UpdateMaxQueueTime(bytes32 saleId, uint256 maxQueueTime) +``` + +### Buy + +```solidity +event Buy(bytes32 saleId, address buyer, uint256 value, bool native, bytes32[] proof) +``` + +### RegisterClaimManager + +```solidity +event RegisterClaimManager(bytes32 saleId, address claimManager) +``` + +### UpdateUri + +```solidity +event UpdateUri(bytes32 saleId, string uri) +``` + +### constructor + +```solidity +constructor(address _paymentToken, uint8 _paymentTokenDecimals, address _priceOracle) public payable +``` + +### validSale + +```solidity +modifier validSale(bytes32 saleId) +``` + +### isAdmin + +```solidity +modifier isAdmin(bytes32 saleId) +``` + +### canAccessSale + +```solidity +modifier canAccessSale(bytes32 saleId, bytes32[] proof) +``` + +### requireOpen + +```solidity +modifier requireOpen(bytes32 saleId) +``` + +### getLatestPrice + +```solidity +function getLatestPrice() public view returns (uint256) +``` + +### getAdmin + +```solidity +function getAdmin(bytes32 saleId) public view returns (address) +``` + +### getRecipient + +```solidity +function getRecipient(bytes32 saleId) public view returns (address) +``` + +### getMerkleRoot + +```solidity +function getMerkleRoot(bytes32 saleId) public view returns (bytes32) +``` + +### getPriceOracle + +```solidity +function getPriceOracle() public view returns (address) +``` + +### getClaimManager + +```solidity +function getClaimManager(bytes32 saleId) public view returns (address) +``` + +### getSaleBuyLimit + +```solidity +function getSaleBuyLimit(bytes32 saleId) public view returns (uint256) +``` + +### getUserBuyLimit + +```solidity +function getUserBuyLimit(bytes32 saleId) public view returns (uint256) +``` + +### getPurchaseMinimum + +```solidity +function getPurchaseMinimum(bytes32 saleId) public view returns (uint256) +``` + +### getStartTime + +```solidity +function getStartTime(bytes32 saleId) public view returns (uint256) +``` + +### getEndTime + +```solidity +function getEndTime(bytes32 saleId) public view returns (uint256) +``` + +### getUri + +```solidity +function getUri(bytes32 saleId) public view returns (string) +``` + +### getPrice + +```solidity +function getPrice(bytes32 saleId) public view returns (uint256) +``` + +### getDecimals + +```solidity +function getDecimals(bytes32 saleId) public view returns (uint256) +``` + +### getTotalSpent + +```solidity +function getTotalSpent(bytes32 saleId) public view returns (uint256) +``` + +### getRandomValue + +```solidity +function getRandomValue(bytes32 saleId) public view returns (uint160) +``` + +### getMaxQueueTime + +```solidity +function getMaxQueueTime(bytes32 saleId) public view returns (uint256) +``` + +### generateRandomishValue + +```solidity +function generateRandomishValue(bytes32 merkleRoot) public view returns (uint160) +``` + +### getFairQueueTime + +```solidity +function getFairQueueTime(bytes32 saleId, address buyer) public view returns (uint256) +``` + +### spentToBought + +```solidity +function spentToBought(bytes32 saleId, uint256 spent) public view returns (uint256) +``` + +### nativeToPaymentToken + +```solidity +function nativeToPaymentToken(uint256 nativeValue) public view returns (uint256) +``` + +### getSpent + +```solidity +function getSpent(bytes32 saleId, address userAddress) public view returns (uint256) +``` + +### getBought + +```solidity +function getBought(bytes32 saleId, address userAddress) public view returns (uint256) +``` + +### isOpen + +```solidity +function isOpen(bytes32 saleId) public view returns (bool) +``` + +### isOver + +```solidity +function isOver(bytes32 saleId) public view returns (bool) +``` + +### newSale + +```solidity +function newSale(address payable recipient, bytes32 merkleRoot, uint256 saleBuyLimit, uint256 userBuyLimit, uint256 purchaseMinimum, uint256 startTime, uint256 endTime, uint160 maxQueueTime, string uri, uint256 price, uint8 decimals) public returns (bytes32) +``` + +sale setup and config + - the address calling this method is the admin: only the admin can change sale configuration + - all payments are sent to the the recipient + +### setStart + +```solidity +function setStart(bytes32 saleId, uint256 startTime) public +``` + +### setEnd + +```solidity +function setEnd(bytes32 saleId, uint256 endTime) public +``` + +### setMerkleRoot + +```solidity +function setMerkleRoot(bytes32 saleId, bytes32 merkleRoot) public +``` + +### setMaxQueueTime + +```solidity +function setMaxQueueTime(bytes32 saleId, uint160 maxQueueTime) public +``` + +### setUriAndMerkleRoot + +```solidity +function setUriAndMerkleRoot(bytes32 saleId, bytes32 merkleRoot, string uri) public +``` + +### _isAllowed + +```solidity +function _isAllowed(bytes32 root, address account, bytes32[] proof) external pure returns (bool) +``` + +### buy + +```solidity +function buy(bytes32 saleId, uint256 tokenQuantity, bytes32[] proof) public +``` + +### buy + +```solidity +function buy(bytes32 saleId, bytes32[] proof) public payable +``` + +### registerClaimManager + +```solidity +function registerClaimManager(bytes32 saleId, address claimManager) public +``` + +### recoverERC20 + +```solidity +function recoverERC20(bytes32 saleId, address tokenAddress, uint256 tokenAmount) public +``` + +## Config + +Allow qualified users to participate in a sale according to sale rules. + +Management +- the address that deploys the sale is the sale owner +- owners may change some sale parameters (e.g. start and end times) +- sale proceeds are sent to the sale recipient + +Qualification +- public sale: anyone can participate +- private sale: only users who can prove membership in a merkle tree can participate + +Sale Rules +- timing: purchases can only be made + - after the sale opens + - after the per-account random queue time has elapsed + - before the sale ends +- purchase quantity: quantity is limited by + - per-address limit + - total sale limit +- payment method: participants can pay using either + - the native token on the network (e.g. ETH) + - a single ERC-20 token (e.g. USDC) +- number of purchases: there is no limit to the number of compliant purchases a user may make + +Token Distribution +- this contract does not distribute any purchased tokens + +Metrics +- purchase count: number of purchases made in this sale +- user count: number of unique addresses that participated in this sale +- total bought: value of purchases denominated in a base currency (e.g. USD) as an integer (to get the float value, divide by oracle decimals) +- bought per user: value of a user's purchases denominated in a base currency (e.g. USD) + +total bought and bought per user metrics are inclusive of any fee charged (if a fee is charged, the sale recipient will receive less than the total spend) + +```solidity +struct Config { + address payable recipient; + bytes32 merkleRoot; + uint256 saleMaximum; + uint256 userMaximum; + uint256 purchaseMinimum; + uint256 startTime; + uint256 endTime; + uint256 maxQueueTime; + string URI; +} +``` + +## Metrics + +```solidity +struct Metrics { + uint256 purchaseCount; + uint256 buyerCount; + uint256 purchaseTotal; + mapping(address => uint256) buyerTotal; +} +``` + +## PaymentTokenInfo + +```solidity +struct PaymentTokenInfo { + contract IOracleOrL2OracleWithSequencerCheck oracle; + uint8 decimals; +} +``` + +## FlatPriceSale_v_2_1 + +### ImplementationConstructor + +```solidity +event ImplementationConstructor(address payable feeRecipient, uint256 feeBips) +``` + +### Update + +```solidity +event Update(struct Config config) +``` + +### Initialize + +```solidity +event Initialize(struct Config config, string baseCurrency, contract IOracleOrL2OracleWithSequencerCheck nativeOracle, bool nativePaymentsEnabled) +``` + +### SetPaymentTokenInfo + +```solidity +event SetPaymentTokenInfo(contract IERC20Upgradeable token, struct PaymentTokenInfo paymentTokenInfo) +``` + +### SweepToken + +```solidity +event SweepToken(address token, uint256 amount) +``` + +### SweepNative + +```solidity +event SweepNative(uint256 amount) +``` + +### RegisterDistributor + +```solidity +event RegisterDistributor(address distributor) +``` + +### NATIVE_TOKEN_DECIMALS + +```solidity +uint256 NATIVE_TOKEN_DECIMALS +``` + +### PER_USER_PURCHASE_LIMIT + +```solidity +uint8 PER_USER_PURCHASE_LIMIT +``` + +### PER_USER_END_TIME + +```solidity +uint8 PER_USER_END_TIME +``` + +### feeBips + +```solidity +uint256 feeBips +``` + +Variables set by implementation contract constructor (immutable) + +### fractionDenominator + +```solidity +uint256 fractionDenominator +``` + +### feeRecipient + +```solidity +address payable feeRecipient +``` + +### distributor + +```solidity +address distributor +``` + +### baseCurrency + +```solidity +string baseCurrency +``` + +Variables set during initialization of clone contracts ("immutable" on each instance) + +### VERSION + +```solidity +string VERSION +``` + +### nativeTokenPriceOracle + +```solidity +contract IOracleOrL2OracleWithSequencerCheck nativeTokenPriceOracle +``` + +### nativePaymentsEnabled + +```solidity +bool nativePaymentsEnabled +``` + +### paymentTokens + +```solidity +mapping(contract IERC20Upgradeable => struct PaymentTokenInfo) paymentTokens +``` + +### config + +```solidity +struct Config config +``` + +### metrics + +```solidity +struct Metrics metrics +``` + +### randomValue + +```solidity +uint160 randomValue +``` + +### constructor + +```solidity +constructor(uint256 _feeBips, address payable _feeRecipient) public +``` + +### initialize + +```solidity +function initialize(address _owner, struct Config _config, string _baseCurrency, bool _nativePaymentsEnabled, contract IOracleOrL2OracleWithSequencerCheck _nativeTokenPriceOracle, contract IERC20Upgradeable[] tokens, contract IOracleOrL2OracleWithSequencerCheck[] oracles, uint8[] decimals) public +``` + +Replacement for constructor for clones of the implementation contract + Important: anyone can call the initialize function! + +### canAccessSale + +```solidity +modifier canAccessSale(bytes data, bytes32[] proof) +``` + +Check that the user can currently participate in the sale based on the merkle root + + Merkle root options: + - bytes32(0): this is a public sale, any address can participate + - otherwise: this is a private sale, users must submit a merkle proof that their address is included in the merkle root + +### validUpdate + +```solidity +modifier validUpdate(struct Config newConfig) +``` + +Check that the new sale is a valid update + - If the config already exists, it must not be over (cannot edit sale after it concludes) + - Sale start, end, and max queue times must be consistent and not too far in the future + +### validPaymentToken + +```solidity +modifier validPaymentToken(contract IERC20Upgradeable token) +``` + +### areNativePaymentsEnabled + +```solidity +modifier areNativePaymentsEnabled() +``` + +### getPaymentToken + +```solidity +function getPaymentToken(contract IERC20Upgradeable token) external view returns (struct PaymentTokenInfo) +``` + +### getOraclePrice + +```solidity +function getOraclePrice(contract IOracleOrL2OracleWithSequencerCheck oracle) public view returns (uint256) +``` + +### generatePseudorandomValue + +```solidity +function generatePseudorandomValue(bytes32 merkleRoot) public view returns (uint160) +``` + +Generate a pseudorandom value + This is not a truly random value: + - miners can alter the block hash + - owners can repeatedly call setMerkleRoot() + - owners can choose when to submit the transaction + +### getFairQueueTime + +```solidity +function getFairQueueTime(address buyer) public view returns (uint256) +``` + +Get the delay in seconds that a specific buyer must wait after the sale begins in order to buy tokens in the sale + + Buyers cannot exploit the fair queue when: + - The sale is private (merkle root != bytes32(0)) + - Each eligible buyer gets exactly one address in the merkle root + + Although miners and sellers can minimize the delay for an arbitrary address, these are not significant threats: + - the economic opportunity to miners is zero or relatively small (only specific addresses can participate in private sales, and a better queue postion does not imply high returns) + - sellers can repeatedly set merkle roots to achieve a favorable queue time for any address, but sellers already control the tokens being sold! + +### tokensToBaseCurrency + +```solidity +function tokensToBaseCurrency(uint256 tokenQuantity, uint256 tokenDecimals, contract IOracleOrL2OracleWithSequencerCheck oracle) public view returns (uint256 value) +``` + +Convert a token quantity (e.g. USDC or ETH) to a base currency (e.g. USD) with the same number of decimals as the price oracle (e.g. 8) + + Example: given 2 NCT tokens, each worth $1.23, tokensToBaseCurrency should return 246000000 ($2.46) + + Function arguments + - tokenQuantity: 2000000000000000000 + - tokenDecimals: 18 + + NCT/USD chainlink oracle (important! the oracle must be / not /, e.g. ETH/USD, ~$2000 not USD/ETH, ~0.0005) + - baseCurrencyPerToken: 123000000 + - baseCurrencyDecimals: 8 + + Calculation: 2000000000000000000 * 123000000 / 1000000000000000000 + + Returns: 246000000 + +### total + +```solidity +function total() external view returns (uint256) +``` + +### isOver + +```solidity +function isOver() public view returns (bool) +``` + +### isOpen + +```solidity +function isOpen() public view returns (bool) +``` + +### buyerTotal + +```solidity +function buyerTotal(address user) external view returns (uint256) +``` + +### _execute + +```solidity +function _execute(uint256 baseCurrencyQuantity, bytes data) internal +``` + +Records a purchase + Follow the Checks -> Effects -> Interactions pattern +Checks: CALLER MUST ENSURE BUYER IS PERMITTED TO PARTICIPATE IN THIS SALE: THIS METHOD DOES NOT CHECK WHETHER THE BUYER SHOULD BE ABLE TO ACCESS THE SALE! +Effects: record the payment +Interactions: none! + +### _settlePaymentToken + +```solidity +function _settlePaymentToken(uint256 baseCurrencyValue, contract IERC20Upgradeable token, uint256 quantity) internal +``` + +Settle payment made with payment token + Important: this function has no checks! Only call if the purchase is valid! + +### _settleNativeToken + +```solidity +function _settleNativeToken(uint256 baseCurrencyValue, uint256 nativeTokenQuantity) internal +``` + +Settle payment made with native token + Important: this function has no checks! Only call if the purchase is valid! + +### buyWithToken + +```solidity +function buyWithToken(contract IERC20Upgradeable token, uint256 quantity, bytes data, bytes32[] proof) external +``` + +Pay with the payment token (e.g. USDC) + +### buyWithNative + +```solidity +function buyWithNative(bytes data, bytes32[] proof) external payable +``` + +Pay with the native token (e.g. ETH) + +### update + +```solidity +function update(struct Config _config) external +``` + +External management functions (only the owner may update the sale) + +### registerDistributor + +```solidity +function registerDistributor(address _distributor) external +``` + +### sweepToken + +```solidity +function sweepToken(contract IERC20Upgradeable token) external +``` + +Public management functions + +### sweepNative + +```solidity +function sweepNative() external +``` + +## FlatPriceSaleFactory_v_2_1 + +### implementation + +```solidity +address implementation +``` + +### VERSION + +```solidity +string VERSION +``` + +### NewSale + +```solidity +event NewSale(address implementation, contract FlatPriceSale_v_2_1 clone, struct Config config, string baseCurrency, contract IOracleOrL2OracleWithSequencerCheck nativeOracle, bool nativePaymentsEnabled) +``` + +### constructor + +```solidity +constructor(address _implementation) public +``` + +### newSale + +```solidity +function newSale(address _owner, struct Config _config, string _baseCurrency, bool _nativePaymentsEnabled, contract IOracleOrL2OracleWithSequencerCheck _nativeTokenPriceOracle, contract IERC20Upgradeable[] tokens, contract IOracleOrL2OracleWithSequencerCheck[] oracles, uint8[] decimals) external returns (contract FlatPriceSale_v_2_1 sale) +``` + +## Sale + +### Buy + +```solidity +event Buy(address buyer, address token, uint256 baseCurrencyValue, uint256 tokenValue, uint256 tokenFee) +``` + +### constructor + +```solidity +constructor() internal +``` + +### isValidMerkleProof + +```solidity +function isValidMerkleProof(bytes32 root, address account, bytes data, bytes32[] proof) public pure returns (bool) +``` + +### buyWithToken + +```solidity +function buyWithToken(contract IERC20Upgradeable token, uint256 quantity, bytes data, bytes32[] proof) external virtual +``` + +### buyWithNative + +```solidity +function buyWithNative(bytes data, bytes32[] proof) external payable virtual +``` + +### isOpen + +```solidity +function isOpen() public view virtual returns (bool) +``` + +### isOver + +```solidity +function isOver() public view virtual returns (bool) +``` + +### buyerTotal + +```solidity +function buyerTotal(address user) external view virtual returns (uint256) +``` + +### total + +```solidity +function total() external view virtual returns (uint256) +``` + +## Config + +Allow qualified users to participate in a sale according to sale rules. + +Management +- the address that deploys the sale is the sale owner +- owners may change some sale parameters (e.g. start and end times) +- sale proceeds are sent to the sale recipient + +Qualification +- public sale: anyone can participate +- private sale: only users who can prove membership in a merkle tree can participate + +Sale Rules +- timing: purchases can only be made + - after the sale opens + - after the per-account random queue time has elapsed + - before the sale ends +- purchase quantity: quantity is limited by + - per-address limit + - total sale limit +- payment method: participants can pay using either + - the native token on the network (e.g. ETH) + - a single ERC-20 token (e.g. USDC) +- number of purchases: there is no limit to the number of compliant purchases a user may make + +Token Distribution +- this contract does not distribute any purchased tokens + +Metrics +- purchase count: number of purchases made in this sale +- user count: number of unique addresses that participated in this sale +- total bought: value of purchases denominated in a base currency (e.g. USD) as an integer (to get the float value, divide by oracle decimals) +- bought per user: value of a user's purchases denominated in a base currency (e.g. USD) + +total bought and bought per user metrics are inclusive of any fee charged (if a fee is charged, the sale recipient will receive less than the total spend) + +```solidity +struct Config { + address payable recipient; + bytes32 merkleRoot; + uint256 saleMaximum; + uint256 userMaximum; + uint256 purchaseMinimum; + uint256 startTime; + uint256 endTime; + uint256 maxQueueTime; + string URI; +} +``` + +## Metrics + +```solidity +struct Metrics { + uint256 purchaseCount; + uint256 buyerCount; + uint256 purchaseTotal; + mapping(address => uint256) buyerTotal; +} +``` + +## PaymentTokenInfo + +```solidity +struct PaymentTokenInfo { + contract IOracleOrL2OracleWithSequencerCheck oracle; + uint8 decimals; +} +``` + +## FlatPriceSale + +### ImplementationConstructor + +```solidity +event ImplementationConstructor(address payable feeRecipient, uint256 feeBips) +``` + +### Update + +```solidity +event Update(struct Config config) +``` + +### Initialize + +```solidity +event Initialize(struct Config config, string baseCurrency, contract IOracleOrL2OracleWithSequencerCheck nativeOracle, bool nativePaymentsEnabled) +``` + +### SetPaymentTokenInfo + +```solidity +event SetPaymentTokenInfo(contract IERC20Upgradeable token, struct PaymentTokenInfo paymentTokenInfo) +``` + +### SweepToken + +```solidity +event SweepToken(address token, uint256 amount) +``` + +### SweepNative + +```solidity +event SweepNative(uint256 amount) +``` + +### RegisterDistributor + +```solidity +event RegisterDistributor(address distributor) +``` + +### BASE_CURRENCY_DECIMALS + +```solidity +uint256 BASE_CURRENCY_DECIMALS +``` + +### NATIVE_TOKEN_DECIMALS + +```solidity +uint256 NATIVE_TOKEN_DECIMALS +``` + +### PER_USER_PURCHASE_LIMIT + +```solidity +uint8 PER_USER_PURCHASE_LIMIT +``` + +### PER_USER_END_TIME + +```solidity +uint8 PER_USER_END_TIME +``` + +### feeBips + +```solidity +uint256 feeBips +``` + +Variables set by implementation contract constructor (immutable) + +### fractionDenominator + +```solidity +uint256 fractionDenominator +``` + +### feeRecipient + +```solidity +address payable feeRecipient +``` + +### distributor + +```solidity +address distributor +``` + +### baseCurrency + +```solidity +string baseCurrency +``` + +Variables set during initialization of clone contracts ("immutable" on each instance) + +### VERSION + +```solidity +string VERSION +``` + +### nativeTokenPriceOracle + +```solidity +contract IOracleOrL2OracleWithSequencerCheck nativeTokenPriceOracle +``` + +### nativePaymentsEnabled + +```solidity +bool nativePaymentsEnabled +``` + +### paymentTokens + +```solidity +mapping(contract IERC20Upgradeable => struct PaymentTokenInfo) paymentTokens +``` + +### config + +```solidity +struct Config config +``` + +### metrics + +```solidity +struct Metrics metrics +``` + +### randomValue + +```solidity +uint160 randomValue +``` + +### constructor + +```solidity +constructor(uint256 _feeBips, address payable _feeRecipient) public +``` + +### initialize + +```solidity +function initialize(address _owner, struct Config _config, string _baseCurrency, bool _nativePaymentsEnabled, contract IOracleOrL2OracleWithSequencerCheck _nativeTokenPriceOracle, contract IERC20Upgradeable[] tokens, contract IOracleOrL2OracleWithSequencerCheck[] oracles, uint8[] decimals) public +``` + +Replacement for constructor for clones of the implementation contract + Important: anyone can call the initialize function! + +### canAccessSale + +```solidity +modifier canAccessSale(bytes data, bytes32[] proof) +``` + +Check that the user can currently participate in the sale based on the merkle root + + Merkle root options: + - bytes32(0): this is a public sale, any address can participate + - otherwise: this is a private sale, users must submit a merkle proof that their address is included in the merkle root + +### validUpdate + +```solidity +modifier validUpdate(struct Config newConfig) +``` + +Check that the new sale is a valid update + - If the config already exists, it must not be over (cannot edit sale after it concludes) + - Sale start, end, and max queue times must be consistent and not too far in the future + +### validPaymentToken + +```solidity +modifier validPaymentToken(contract IERC20Upgradeable token) +``` + +### areNativePaymentsEnabled + +```solidity +modifier areNativePaymentsEnabled() +``` + +### getPaymentToken + +```solidity +function getPaymentToken(contract IERC20Upgradeable token) external view returns (struct PaymentTokenInfo) +``` + +### getOraclePrice + +```solidity +function getOraclePrice(contract IOracleOrL2OracleWithSequencerCheck oracle) public view returns (uint256) +``` + +### generatePseudorandomValue + +```solidity +function generatePseudorandomValue(bytes32 merkleRoot) public view returns (uint160) +``` + +Generate a pseudorandom value + This is not a truly random value: + - miners can alter the block hash + - owners can repeatedly call setMerkleRoot() + - owners can choose when to submit the transaction + +### getFairQueueTime + +```solidity +function getFairQueueTime(address buyer) public view returns (uint256) +``` + +Get the delay in seconds that a specific buyer must wait after the sale begins in order to buy tokens in the sale + + Buyers cannot exploit the fair queue when: + - The sale is private (merkle root != bytes32(0)) + - Each eligible buyer gets exactly one address in the merkle root + + Although miners and sellers can minimize the delay for an arbitrary address, these are not significant threats: + - the economic opportunity to miners is zero or relatively small (only specific addresses can participate in private sales, and a better queue postion does not imply high returns) + - sellers can repeatedly set merkle roots to achieve a favorable queue time for any address, but sellers already control the tokens being sold! + +### tokensToBaseCurrency + +```solidity +function tokensToBaseCurrency(uint256 tokenQuantity, uint256 tokenDecimals, contract IOracleOrL2OracleWithSequencerCheck oracle) public view returns (uint256 value) +``` + +Convert a token quantity (e.g. USDC or ETH) to a base currency (e.g. USD) with the same number of decimals as the price oracle (e.g. 8) + + Example: given 2 NCT tokens, each worth $1.23, tokensToBaseCurrency should return 246000000 ($2.46) + + Function arguments + - tokenQuantity: 2000000000000000000 + - tokenDecimals: 18 + + NCT/USD chainlink oracle (important! the oracle must be / not /, e.g. ETH/USD, ~$2000 not USD/ETH, ~0.0005) + - baseCurrencyPerToken: 123000000 + - baseCurrencyDecimals: 8 + + Calculation: 2000000000000000000 * 123000000 / 1000000000000000000 + + Returns: 246000000 + +### total + +```solidity +function total() external view returns (uint256) +``` + +### isOver + +```solidity +function isOver() public view returns (bool) +``` + +### isOpen + +```solidity +function isOpen() public view returns (bool) +``` + +### buyerTotal + +```solidity +function buyerTotal(address user) external view returns (uint256) +``` + +### _execute + +```solidity +function _execute(uint256 baseCurrencyQuantity, bytes data) internal +``` + +Records a purchase + Follow the Checks -> Effects -> Interactions pattern +Checks: CALLER MUST ENSURE BUYER IS PERMITTED TO PARTICIPATE IN THIS SALE: THIS METHOD DOES NOT CHECK WHETHER THE BUYER SHOULD BE ABLE TO ACCESS THE SALE! +Effects: record the payment +Interactions: none! + +### _settlePaymentToken + +```solidity +function _settlePaymentToken(uint256 baseCurrencyValue, contract IERC20Upgradeable token, uint256 quantity) internal +``` + +Settle payment made with payment token + Important: this function has no checks! Only call if the purchase is valid! + +### _settleNativeToken + +```solidity +function _settleNativeToken(uint256 baseCurrencyValue, uint256 nativeTokenQuantity) internal +``` + +Settle payment made with native token + Important: this function has no checks! Only call if the purchase is valid! + +### buyWithToken + +```solidity +function buyWithToken(contract IERC20Upgradeable token, uint256 quantity, bytes data, bytes32[] proof) external +``` + +Pay with the payment token (e.g. USDC) + +### buyWithNative + +```solidity +function buyWithNative(bytes data, bytes32[] proof) external payable +``` + +Pay with the native token (e.g. ETH) + +### update + +```solidity +function update(struct Config _config) external +``` + +External management functions (only the owner may update the sale) + +### registerDistributor + +```solidity +function registerDistributor(address _distributor) external +``` + +### sweepToken + +```solidity +function sweepToken(contract IERC20Upgradeable token) external +``` + +Public management functions + +### sweepNative + +```solidity +function sweepNative() external +``` + +## FlatPriceSaleFactory + +### implementation + +```solidity +address implementation +``` + +### VERSION + +```solidity +string VERSION +``` + +### NewSale + +```solidity +event NewSale(address implementation, contract FlatPriceSale clone, struct Config config, string baseCurrency, contract IOracleOrL2OracleWithSequencerCheck nativeOracle, bool nativePaymentsEnabled) +``` + +### constructor + +```solidity +constructor(address _implementation) public +``` + +### newSale + +```solidity +function newSale(address _owner, struct Config _config, string _baseCurrency, bool _nativePaymentsEnabled, contract IOracleOrL2OracleWithSequencerCheck _nativeTokenPriceOracle, contract IERC20Upgradeable[] tokens, contract IOracleOrL2OracleWithSequencerCheck[] oracles, uint8[] decimals) external returns (contract FlatPriceSale sale) +``` + +## Sale + +### Buy + +```solidity +event Buy(address buyer, address token, uint256 baseCurrencyValue, uint256 tokenValue, uint256 tokenFee) +``` + +### constructor + +```solidity +constructor() internal +``` + +### isValidMerkleProof + +```solidity +function isValidMerkleProof(bytes32 root, address account, bytes data, bytes32[] proof) public pure returns (bool) +``` + +### buyWithToken + +```solidity +function buyWithToken(contract IERC20Upgradeable token, uint256 quantity, bytes data, bytes32[] proof) external virtual +``` + +### buyWithNative + +```solidity +function buyWithNative(bytes data, bytes32[] proof) external payable virtual +``` + +### isOpen + +```solidity +function isOpen() public view virtual returns (bool) +``` + +### isOver + +```solidity +function isOver() public view virtual returns (bool) +``` + +### buyerTotal + +```solidity +function buyerTotal(address user) external view virtual returns (uint256) +``` + +### total + +```solidity +function total() external view virtual returns (uint256) +``` + +## GenericERC20 + +### d + +```solidity +uint8 d +``` + +### constructor + +```solidity +constructor(string _name, string _symbol, uint8 _decimals, uint256 supply) public +``` + +### decimals + +```solidity +function decimals() public view virtual returns (uint8) +``` + +_Returns the number of decimals used to get its user representation. +For example, if `decimals` equals `2`, a balance of `505` tokens should +be displayed to a user as `5.05` (`505 / 10 ** 2`). + +Tokens usually opt for a value of 18, imitating the relationship between +Ether and Wei. This is the value {ERC20} uses, unless this function is +overridden; + +NOTE: This information is only used for _display_ purposes: it in +no way affects any of the arithmetic of the contract, including +{IERC20-balanceOf} and {IERC20-transfer}._ + +## FakeUSDC + +### d + +```solidity +uint8 d +``` + +### constructor + +```solidity +constructor(string _name, string _symbol, uint8 _decimals, uint256 supply) public +``` + +### decimals + +```solidity +function decimals() public view virtual returns (uint8) +``` + +_Returns the number of decimals used to get its user representation. +For example, if `decimals` equals `2`, a balance of `505` tokens should +be displayed to a user as `5.05` (`505 / 10 ** 2`). + +Tokens usually opt for a value of 18, imitating the relationship between +Ether and Wei. This is the value {ERC20} uses, unless this function is +overridden; + +NOTE: This information is only used for _display_ purposes: it in +no way affects any of the arithmetic of the contract, including +{IERC20-balanceOf} and {IERC20-transfer}._ + +## FakeUSDT + +### d + +```solidity +uint8 d +``` + +### constructor + +```solidity +constructor(string _name, string _symbol, uint8 _decimals, uint256 supply) public +``` + +### decimals + +```solidity +function decimals() public view virtual returns (uint8) +``` + +_Returns the number of decimals used to get its user representation. +For example, if `decimals` equals `2`, a balance of `505` tokens should +be displayed to a user as `5.05` (`505 / 10 ** 2`). + +Tokens usually opt for a value of 18, imitating the relationship between +Ether and Wei. This is the value {ERC20} uses, unless this function is +overridden; + +NOTE: This information is only used for _display_ purposes: it in +no way affects any of the arithmetic of the contract, including +{IERC20-balanceOf} and {IERC20-transfer}._ + +## MyERC20Votes + +### constructor + +```solidity +constructor(string _name, string _symbol, uint256 supply) public +``` + +### _afterTokenTransfer + +```solidity +function _afterTokenTransfer(address from, address to, uint256 amount) internal +``` + +### _mint + +```solidity +function _mint(address to, uint256 amount) internal +``` + +### _burn + +```solidity +function _burn(address account, uint256 amount) internal +``` + +## Trader + +### SetConfig + +```solidity +event SetConfig(contract IHashflowQuote router, uint256 feeBips) +``` + +### HashflowTradeSingleHop + +```solidity +event HashflowTradeSingleHop(struct IHashflowQuote.RFQTQuote quote) +``` + +### HashflowTradeXChain + +```solidity +event HashflowTradeXChain(struct IHashflowQuote.XChainRFQTQuote quote, enum IHashflowQuote.XChainMessageProtocol protocol) +``` + +### constructor + +```solidity +constructor(contract IHashflowQuote _router, uint256 _feeBips, address payable _feeRecipient) public +``` + +### getSplit + +```solidity +function getSplit(uint256 initialTotal) public view returns (uint256 baseTokenTotal, uint256 baseTokenAmount, uint256 baseTokenFee) +``` + +### getFee + +```solidity +function getFee(uint256 baseTokenAmount) public view returns (uint256 baseTokenFee) +``` + +### tradeSingleHop + +```solidity +function tradeSingleHop(struct IHashflowQuote.RFQTQuote quote) public payable +``` + +### tradeXChain + +```solidity +function tradeXChain(struct IHashflowQuote.XChainRFQTQuote quote, enum IHashflowQuote.XChainMessageProtocol protocol) public payable +``` + +### setConfig + +```solidity +function setConfig(contract IHashflowQuote _router, uint256 _feeBips, address payable _feeRecipient) external +``` + +### getConfig + +```solidity +function getConfig() external view returns (contract IHashflowQuote, uint256, address payable) +``` + +## BatchSendEth + +### constructor + +```solidity +constructor() public +``` + +### send + +```solidity +function send(address[] addresses, uint256 amount) public payable +``` + +## FairQueue + +Fairly assigns a delay time to each address from a uniform distribution over [0, maxDelayTime] + +_The delay is determined by calculating a distance between the user's address and a pseudorandom value based on a provided salt and a blockhash +using the XOR distance metric. Do not use this contract if the event is public because users could grind addresses until they find one with a low delay._ + +### SetDelay + +```solidity +event SetDelay(uint160 maxDelayTime) +``` + +### distancePerSecond + +```solidity +uint160 distancePerSecond +``` + +calculate a speed at which the queue is exhausted such that all users complete the queue by maxDelayTime + +### maxDelayTime + +```solidity +uint160 maxDelayTime +``` + +### randomValue + +```solidity +uint160 randomValue +``` + +_the random value from which a distance will be calculated for each address. Reset the random value +to shuffle the delays for all addresses._ + +### constructor + +```solidity +constructor(uint160 _maxDelayTime, uint160 salt) public +``` + +### _setPseudorandomValue + +```solidity +function _setPseudorandomValue(uint160 salt) internal +``` + +_internal function to set the random value. A salt (e.g. from a merkle root) is required to prevent +naive manipulation of the random value by validators_ + +### _setDelay + +```solidity +function _setDelay(uint160 _maxDelayTime) internal +``` + +_Internal function to configure delay + @param _maxDelayTime the maximum delay for any address in seconds. Set this value to 0 to disable delays entirely._ + +### getFairDelayTime + +```solidity +function getFairDelayTime(address user) public view returns (uint256) +``` + +get a fixed delay for any address by drawing from a unform distribution over the interval [0, maxDelay] + @param user The address for which a delay should be calculated. The delay is deterministic for any given address and pseudorandom value. + @dev The delay is determined by calculating a distance between the user's address and a pseudorandom value using the XOR distance metric (c.f. Kademlia) + + Users cannot exploit the fair delay if: + - The event is private, i.e. an access list of some form is required + - Each eligible user gets exactly one address in the access list + - There is no collusion between event participants, block validators, and event owners + + The threat of collusion is likely minimal: + - the economic opportunity to validators is zero or relatively small (only specific addresses can participate in private events, and a lower delay time does not imply higher returns) + - event owners are usually trying to achieve a fair distribution of access to their event + +## L2OracleWithSequencerCheck + +Data feed oracle for use on optimistic L2s (Arbiturm, Optimism, Base, +Metis) that uses a data feed that tracks the last known status of the +L2 sequencer at a given point in time, and reverts if the sequencer is +down, or is up but a specified grace period has not passed. + +_For a list of available Sequencer Uptime Feed proxy addresses, see: +https://docs.chain.link/docs/data-feeds/l2-sequencer-feeds_ + +### dataFeed + +```solidity +contract AggregatorV3Interface dataFeed +``` + +### sequencerUptimeFeed + +```solidity +contract AggregatorV3Interface sequencerUptimeFeed +``` + +### SequencerDown + +```solidity +error SequencerDown() +``` + +### GracePeriodNotOver + +```solidity +error GracePeriodNotOver() +``` + +### constructor + +```solidity +constructor(address _dataFeed, address _sequencerUptimeFeed) public +``` + +### latestRoundData + +```solidity +function latestRoundData() public view returns (uint80 roundId, int256 answer, uint256 startedAt, uint256 updatedAt, uint80 answeredInRound) +``` + +### decimals + +```solidity +function decimals() public view returns (uint8) +``` + +## Registry + +### DeployRegistry + +```solidity +event DeployRegistry() +``` + +### Register + +```solidity +event Register(address addressRegistered, bytes4[] interfaceIds, address registeredBy) +``` + +### Unregister + +```solidity +event Unregister(address addressUnregistered, bytes4[] interfaceIds, address unregisteredBy) +``` + +### ADMIN_ROLE + +```solidity +bytes32 ADMIN_ROLE +``` + +### constructor + +```solidity +constructor() public +``` + +### addAdmin + +```solidity +function addAdmin(address admin) public +``` + +### removeAdmin + +```solidity +function removeAdmin(address admin) public +``` + +### register + +```solidity +function register(address addressRegistered, bytes4[] interfaceIds) public +``` + +### unregister + +```solidity +function unregister(address addressUnregistered, bytes4[] interfaceIds) public +``` + +### targetSupportsInterface + +```solidity +function targetSupportsInterface(address target, bytes4 interfaceId) public view returns (bool) +``` + +## Sweepable + +### SetSweepRecipient + +```solidity +event SetSweepRecipient(address recipient) +``` + +### SweepToken + +```solidity +event SweepToken(address token, uint256 amount) +``` + +### SweepNative + +```solidity +event SweepNative(uint256 amount) +``` + +### constructor + +```solidity +constructor(address payable _recipient) internal +``` + +### sweepToken + +```solidity +function sweepToken(contract IERC20 token) external +``` + +### sweepToken + +```solidity +function sweepToken(contract IERC20 token, uint256 amount) external +``` + +### sweepNative + +```solidity +function sweepNative() external +``` + +### sweepNative + +```solidity +function sweepNative(uint256 amount) external +``` + +### getSweepRecipient + +```solidity +function getSweepRecipient() public view returns (address payable) +``` + +### _setSweepRecipient + +```solidity +function _setSweepRecipient(address payable _recipient) internal +``` + diff --git a/packages/hardhat/hardhat.config.js b/packages/hardhat/hardhat.config.js index 5379a22f..1089c328 100644 --- a/packages/hardhat/hardhat.config.js +++ b/packages/hardhat/hardhat.config.js @@ -19,6 +19,8 @@ require("@nomiclabs/hardhat-etherscan"); // this allows hardhat to use jest for tests require("hardhat-jest"); +require("solidity-docgen"); + const selectedNetwork = process.env.HARDHAT_NETWORK || process.env.NETWORK || "localhost"; function getApiKey(network) { diff --git a/packages/hardhat/package.json b/packages/hardhat/package.json index bc0c08d8..af41b955 100644 --- a/packages/hardhat/package.json +++ b/packages/hardhat/package.json @@ -63,6 +63,7 @@ "envfile": "^6.18.0", "jest": "^29.6.1", "qrcode": "^1.5.1", + "solidity-docgen": "^0.6.0-beta.36", "ts-jest": "^29.1.1" }, "workspaces": { diff --git a/packages/subgraph/package.json b/packages/subgraph/package.json index 4a610a7d..cf3f7ae3 100644 --- a/packages/subgraph/package.json +++ b/packages/subgraph/package.json @@ -117,6 +117,6 @@ }, "devDependencies": { "handlebars-cmd": "^0.1.4", - "node-jq": "^2.3.4" + "node-jq": "2.3.5" } } diff --git a/yarn.lock b/yarn.lock index 6be5147f..22b903f5 100644 --- a/yarn.lock +++ b/yarn.lock @@ -22,68 +22,68 @@ __metadata: languageName: node linkType: hard -"@babel/code-frame@npm:^7.0.0, @babel/code-frame@npm:^7.12.13, @babel/code-frame@npm:^7.22.13": - version: 7.22.13 - resolution: "@babel/code-frame@npm:7.22.13" +"@babel/code-frame@npm:^7.0.0, @babel/code-frame@npm:^7.12.13, @babel/code-frame@npm:^7.23.5": + version: 7.23.5 + resolution: "@babel/code-frame@npm:7.23.5" dependencies: - "@babel/highlight": ^7.22.13 + "@babel/highlight": ^7.23.4 chalk: ^2.4.2 - checksum: 22e342c8077c8b77eeb11f554ecca2ba14153f707b85294fcf6070b6f6150aae88a7b7436dd88d8c9289970585f3fe5b9b941c5aa3aa26a6d5a8ef3f292da058 + checksum: d90981fdf56a2824a9b14d19a4c0e8db93633fd488c772624b4e83e0ceac6039a27cd298a247c3214faa952bf803ba23696172ae7e7235f3b97f43ba278c569a languageName: node linkType: hard -"@babel/compat-data@npm:^7.22.9": - version: 7.23.2 - resolution: "@babel/compat-data@npm:7.23.2" - checksum: d8dc27437d40907b271161d4c88ffe72ccecb034c730deb1960a417b59a14d7c5ebca8cd80dd458a01cd396a7a329eb48cddcc3791b5a84da33d7f278f7bec6a +"@babel/compat-data@npm:^7.23.5": + version: 7.23.5 + resolution: "@babel/compat-data@npm:7.23.5" + checksum: 06ce244cda5763295a0ea924728c09bae57d35713b675175227278896946f922a63edf803c322f855a3878323d48d0255a2a3023409d2a123483c8a69ebb4744 languageName: node linkType: hard -"@babel/core@npm:^7.11.6, @babel/core@npm:^7.12.3": - version: 7.23.2 - resolution: "@babel/core@npm:7.23.2" +"@babel/core@npm:^7.11.6, @babel/core@npm:^7.12.3, @babel/core@npm:^7.23.9": + version: 7.23.9 + resolution: "@babel/core@npm:7.23.9" dependencies: "@ampproject/remapping": ^2.2.0 - "@babel/code-frame": ^7.22.13 - "@babel/generator": ^7.23.0 - "@babel/helper-compilation-targets": ^7.22.15 - "@babel/helper-module-transforms": ^7.23.0 - "@babel/helpers": ^7.23.2 - "@babel/parser": ^7.23.0 - "@babel/template": ^7.22.15 - "@babel/traverse": ^7.23.2 - "@babel/types": ^7.23.0 + "@babel/code-frame": ^7.23.5 + "@babel/generator": ^7.23.6 + "@babel/helper-compilation-targets": ^7.23.6 + "@babel/helper-module-transforms": ^7.23.3 + "@babel/helpers": ^7.23.9 + "@babel/parser": ^7.23.9 + "@babel/template": ^7.23.9 + "@babel/traverse": ^7.23.9 + "@babel/types": ^7.23.9 convert-source-map: ^2.0.0 debug: ^4.1.0 gensync: ^1.0.0-beta.2 json5: ^2.2.3 semver: ^6.3.1 - checksum: 003897718ded16f3b75632d63cd49486bf67ff206cc7ebd1a10d49e2456f8d45740910d5ec7e42e3faf0deec7a2e96b1a02e766d19a67a8309053f0d4e57c0fe + checksum: 634a511f74db52a5f5a283c1121f25e2227b006c095b84a02a40a9213842489cd82dc7d61cdc74e10b5bcd9bb0a4e28bab47635b54c7e2256d47ab57356e2a76 languageName: node linkType: hard -"@babel/generator@npm:^7.23.0, @babel/generator@npm:^7.7.2": - version: 7.23.0 - resolution: "@babel/generator@npm:7.23.0" +"@babel/generator@npm:^7.23.6, @babel/generator@npm:^7.7.2": + version: 7.23.6 + resolution: "@babel/generator@npm:7.23.6" dependencies: - "@babel/types": ^7.23.0 + "@babel/types": ^7.23.6 "@jridgewell/gen-mapping": ^0.3.2 "@jridgewell/trace-mapping": ^0.3.17 jsesc: ^2.5.1 - checksum: 8efe24adad34300f1f8ea2add420b28171a646edc70f2a1b3e1683842f23b8b7ffa7e35ef0119294e1901f45bfea5b3dc70abe1f10a1917ccdfb41bed69be5f1 + checksum: 1a1a1c4eac210f174cd108d479464d053930a812798e09fee069377de39a893422df5b5b146199ead7239ae6d3a04697b45fc9ac6e38e0f6b76374390f91fc6c languageName: node linkType: hard -"@babel/helper-compilation-targets@npm:^7.22.15": - version: 7.22.15 - resolution: "@babel/helper-compilation-targets@npm:7.22.15" +"@babel/helper-compilation-targets@npm:^7.23.6": + version: 7.23.6 + resolution: "@babel/helper-compilation-targets@npm:7.23.6" dependencies: - "@babel/compat-data": ^7.22.9 - "@babel/helper-validator-option": ^7.22.15 - browserslist: ^4.21.9 + "@babel/compat-data": ^7.23.5 + "@babel/helper-validator-option": ^7.23.5 + browserslist: ^4.22.2 lru-cache: ^5.1.1 semver: ^6.3.1 - checksum: ce85196769e091ae54dd39e4a80c2a9df1793da8588e335c383d536d54f06baf648d0a08fc873044f226398c4ded15c4ae9120ee18e7dfd7c639a68e3cdc9980 + checksum: c630b98d4527ac8fe2c58d9a06e785dfb2b73ec71b7c4f2ddf90f814b5f75b547f3c015f110a010fd31f76e3864daaf09f3adcd2f6acdbfb18a8de3a48717590 languageName: node linkType: hard @@ -122,9 +122,9 @@ __metadata: languageName: node linkType: hard -"@babel/helper-module-transforms@npm:^7.23.0": - version: 7.23.0 - resolution: "@babel/helper-module-transforms@npm:7.23.0" +"@babel/helper-module-transforms@npm:^7.23.3": + version: 7.23.3 + resolution: "@babel/helper-module-transforms@npm:7.23.3" dependencies: "@babel/helper-environment-visitor": ^7.22.20 "@babel/helper-module-imports": ^7.22.15 @@ -133,7 +133,7 @@ __metadata: "@babel/helper-validator-identifier": ^7.22.20 peerDependencies: "@babel/core": ^7.0.0 - checksum: 6e2afffb058cf3f8ce92f5116f710dda4341c81cfcd872f9a0197ea594f7ce0ab3cb940b0590af2fe99e60d2e5448bfba6bca8156ed70a2ed4be2adc8586c891 + checksum: 5d0895cfba0e16ae16f3aa92fee108517023ad89a855289c4eb1d46f7aef4519adf8e6f971e1d55ac20c5461610e17213f1144097a8f932e768a9132e2278d71 languageName: node linkType: hard @@ -162,10 +162,10 @@ __metadata: languageName: node linkType: hard -"@babel/helper-string-parser@npm:^7.22.5": - version: 7.22.5 - resolution: "@babel/helper-string-parser@npm:7.22.5" - checksum: 836851ca5ec813077bbb303acc992d75a360267aa3b5de7134d220411c852a6f17de7c0d0b8c8dcc0f567f67874c00f4528672b2a4f1bc978a3ada64c8c78467 +"@babel/helper-string-parser@npm:^7.23.4": + version: 7.23.4 + resolution: "@babel/helper-string-parser@npm:7.23.4" + checksum: c0641144cf1a7e7dc93f3d5f16d5327465b6cf5d036b48be61ecba41e1eece161b48f46b7f960951b67f8c3533ce506b16dece576baef4d8b3b49f8c65410f90 languageName: node linkType: hard @@ -176,41 +176,41 @@ __metadata: languageName: node linkType: hard -"@babel/helper-validator-option@npm:^7.22.15": - version: 7.22.15 - resolution: "@babel/helper-validator-option@npm:7.22.15" - checksum: 68da52b1e10002a543161494c4bc0f4d0398c8fdf361d5f7f4272e95c45d5b32d974896d44f6a0ea7378c9204988879d73613ca683e13bd1304e46d25ff67a8d +"@babel/helper-validator-option@npm:^7.23.5": + version: 7.23.5 + resolution: "@babel/helper-validator-option@npm:7.23.5" + checksum: 537cde2330a8aede223552510e8a13e9c1c8798afee3757995a7d4acae564124fe2bf7e7c3d90d62d3657434a74340a274b3b3b1c6f17e9a2be1f48af29cb09e languageName: node linkType: hard -"@babel/helpers@npm:^7.23.2": - version: 7.23.2 - resolution: "@babel/helpers@npm:7.23.2" +"@babel/helpers@npm:^7.23.9": + version: 7.23.9 + resolution: "@babel/helpers@npm:7.23.9" dependencies: - "@babel/template": ^7.22.15 - "@babel/traverse": ^7.23.2 - "@babel/types": ^7.23.0 - checksum: aaf4828df75ec460eaa70e5c9f66e6dadc28dae3728ddb7f6c13187dbf38030e142194b83d81aa8a31bbc35a5529a5d7d3f3cf59d5d0b595f5dd7f9d8f1ced8e + "@babel/template": ^7.23.9 + "@babel/traverse": ^7.23.9 + "@babel/types": ^7.23.9 + checksum: 2678231192c0471dbc2fc403fb19456cc46b1afefcfebf6bc0f48b2e938fdb0fef2e0fe90c8c8ae1f021dae5012b700372e4b5d15867f1d7764616532e4a6324 languageName: node linkType: hard -"@babel/highlight@npm:^7.22.13": - version: 7.22.20 - resolution: "@babel/highlight@npm:7.22.20" +"@babel/highlight@npm:^7.23.4": + version: 7.23.4 + resolution: "@babel/highlight@npm:7.23.4" dependencies: "@babel/helper-validator-identifier": ^7.22.20 chalk: ^2.4.2 js-tokens: ^4.0.0 - checksum: 84bd034dca309a5e680083cd827a766780ca63cef37308404f17653d32366ea76262bd2364b2d38776232f2d01b649f26721417d507e8b4b6da3e4e739f6d134 + checksum: 643acecdc235f87d925979a979b539a5d7d1f31ae7db8d89047269082694122d11aa85351304c9c978ceeb6d250591ccadb06c366f358ccee08bb9c122476b89 languageName: node linkType: hard -"@babel/parser@npm:^7.1.0, @babel/parser@npm:^7.14.7, @babel/parser@npm:^7.20.7, @babel/parser@npm:^7.22.15, @babel/parser@npm:^7.23.0": - version: 7.23.0 - resolution: "@babel/parser@npm:7.23.0" +"@babel/parser@npm:^7.1.0, @babel/parser@npm:^7.14.7, @babel/parser@npm:^7.20.7, @babel/parser@npm:^7.23.9": + version: 7.23.9 + resolution: "@babel/parser@npm:7.23.9" bin: parser: ./bin/babel-parser.js - checksum: 453fdf8b9e2c2b7d7b02139e0ce003d1af21947bbc03eb350fb248ee335c9b85e4ab41697ddbdd97079698de825a265e45a0846bb2ed47a2c7c1df833f42a354 + checksum: e7cd4960ac8671774e13803349da88d512f9292d7baa952173260d3e8f15620a28a3701f14f709d769209022f9e7b79965256b8be204fc550cfe783cdcabe7c7 languageName: node linkType: hard @@ -270,13 +270,13 @@ __metadata: linkType: hard "@babel/plugin-syntax-jsx@npm:^7.7.2": - version: 7.22.5 - resolution: "@babel/plugin-syntax-jsx@npm:7.22.5" + version: 7.23.3 + resolution: "@babel/plugin-syntax-jsx@npm:7.23.3" dependencies: "@babel/helper-plugin-utils": ^7.22.5 peerDependencies: "@babel/core": ^7.0.0-0 - checksum: 8829d30c2617ab31393d99cec2978e41f014f4ac6f01a1cecf4c4dd8320c3ec12fdc3ce121126b2d8d32f6887e99ca1a0bad53dedb1e6ad165640b92b24980ce + checksum: 89037694314a74e7f0e7a9c8d3793af5bf6b23d80950c29b360db1c66859d67f60711ea437e70ad6b5b4b29affe17eababda841b6c01107c2b638e0493bafb4e languageName: node linkType: hard @@ -358,53 +358,53 @@ __metadata: linkType: hard "@babel/plugin-syntax-typescript@npm:^7.7.2": - version: 7.22.5 - resolution: "@babel/plugin-syntax-typescript@npm:7.22.5" + version: 7.23.3 + resolution: "@babel/plugin-syntax-typescript@npm:7.23.3" dependencies: "@babel/helper-plugin-utils": ^7.22.5 peerDependencies: "@babel/core": ^7.0.0-0 - checksum: 8ab7718fbb026d64da93681a57797d60326097fd7cb930380c8bffd9eb101689e90142c760a14b51e8e69c88a73ba3da956cb4520a3b0c65743aee5c71ef360a + checksum: abfad3a19290d258b028e285a1f34c9b8a0cbe46ef79eafed4ed7ffce11b5d0720b5e536c82f91cbd8442cde35a3dd8e861fa70366d87ff06fdc0d4756e30876 languageName: node linkType: hard -"@babel/template@npm:^7.22.15, @babel/template@npm:^7.3.3": - version: 7.22.15 - resolution: "@babel/template@npm:7.22.15" +"@babel/template@npm:^7.22.15, @babel/template@npm:^7.23.9, @babel/template@npm:^7.3.3": + version: 7.23.9 + resolution: "@babel/template@npm:7.23.9" dependencies: - "@babel/code-frame": ^7.22.13 - "@babel/parser": ^7.22.15 - "@babel/types": ^7.22.15 - checksum: 1f3e7dcd6c44f5904c184b3f7fe280394b191f2fed819919ffa1e529c259d5b197da8981b6ca491c235aee8dbad4a50b7e31304aa531271cb823a4a24a0dd8fd + "@babel/code-frame": ^7.23.5 + "@babel/parser": ^7.23.9 + "@babel/types": ^7.23.9 + checksum: 6e67414c0f7125d7ecaf20c11fab88085fa98a96c3ef10da0a61e962e04fdf3a18a496a66047005ddd1bb682a7cc7842d556d1db2f3f3f6ccfca97d5e445d342 languageName: node linkType: hard -"@babel/traverse@npm:^7.23.2": - version: 7.23.2 - resolution: "@babel/traverse@npm:7.23.2" +"@babel/traverse@npm:^7.23.9": + version: 7.23.9 + resolution: "@babel/traverse@npm:7.23.9" dependencies: - "@babel/code-frame": ^7.22.13 - "@babel/generator": ^7.23.0 + "@babel/code-frame": ^7.23.5 + "@babel/generator": ^7.23.6 "@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.22.6 - "@babel/parser": ^7.23.0 - "@babel/types": ^7.23.0 - debug: ^4.1.0 + "@babel/parser": ^7.23.9 + "@babel/types": ^7.23.9 + debug: ^4.3.1 globals: ^11.1.0 - checksum: 26a1eea0dde41ab99dde8b9773a013a0dc50324e5110a049f5d634e721ff08afffd54940b3974a20308d7952085ac769689369e9127dea655f868c0f6e1ab35d + checksum: a932f7aa850e158c00c97aad22f639d48c72805c687290f6a73e30c5c4957c07f5d28310c9bf59648e2980fe6c9d16adeb2ff92a9ca0f97fa75739c1328fc6c3 languageName: node linkType: hard -"@babel/types@npm:^7.0.0, @babel/types@npm:^7.20.7, @babel/types@npm:^7.22.15, @babel/types@npm:^7.22.5, @babel/types@npm:^7.23.0, @babel/types@npm:^7.3.3, @babel/types@npm:^7.8.3": - version: 7.23.0 - resolution: "@babel/types@npm:7.23.0" +"@babel/types@npm:^7.0.0, @babel/types@npm:^7.20.7, @babel/types@npm:^7.22.15, @babel/types@npm:^7.22.5, @babel/types@npm:^7.23.0, @babel/types@npm:^7.23.6, @babel/types@npm:^7.23.9, @babel/types@npm:^7.3.3, @babel/types@npm:^7.8.3": + version: 7.23.9 + resolution: "@babel/types@npm:7.23.9" dependencies: - "@babel/helper-string-parser": ^7.22.5 + "@babel/helper-string-parser": ^7.23.4 "@babel/helper-validator-identifier": ^7.22.20 to-fast-properties: ^2.0.0 - checksum: 215fe04bd7feef79eeb4d33374b39909ce9cad1611c4135a4f7fdf41fe3280594105af6d7094354751514625ea92d0875aba355f53e86a92600f290e77b0e604 + checksum: 0a9b008e9bfc89beb8c185e620fa0f8ed6c771f1e1b2e01e1596870969096fec7793898a1d64a035176abf1dd13e2668ee30bf699f2d92c210a8128f4b151e65 languageName: node linkType: hard @@ -427,52 +427,6 @@ __metadata: languageName: node linkType: hard -"@chainsafe/as-sha256@npm:^0.3.1": - version: 0.3.1 - resolution: "@chainsafe/as-sha256@npm:0.3.1" - checksum: 58ea733be1657b0e31dbf48b0dba862da0833df34a81c1460c7352f04ce90874f70003cbf34d0afb9e5e53a33ee2d63a261a8b12462be85b2ba0a6f7f13d6150 - languageName: node - linkType: hard - -"@chainsafe/persistent-merkle-tree@npm:^0.4.2": - version: 0.4.2 - resolution: "@chainsafe/persistent-merkle-tree@npm:0.4.2" - dependencies: - "@chainsafe/as-sha256": ^0.3.1 - checksum: f9cfcb2132a243992709715dbd28186ab48c7c0c696f29d30857693cca5526bf753974a505ef68ffd5623bbdbcaa10f9083f4dd40bf99eb6408e451cc26a1a9e - languageName: node - linkType: hard - -"@chainsafe/persistent-merkle-tree@npm:^0.5.0": - version: 0.5.0 - resolution: "@chainsafe/persistent-merkle-tree@npm:0.5.0" - dependencies: - "@chainsafe/as-sha256": ^0.3.1 - checksum: 2c67203da776c79cd3a6132e2d672fe132393b2e63dc71604e3134acc8c0ec25cc5e431051545939ea0f7c5ff2066fb806b9e5cab974ca085d046226a1671f7d - languageName: node - linkType: hard - -"@chainsafe/ssz@npm:^0.10.0": - version: 0.10.2 - resolution: "@chainsafe/ssz@npm:0.10.2" - dependencies: - "@chainsafe/as-sha256": ^0.3.1 - "@chainsafe/persistent-merkle-tree": ^0.5.0 - checksum: 6bb70cf741d0a19dd0b28b3f6f067b96fa39f556e2eefa6ac745b21db9c3b3a8393dc3cca8ff4a6ce065ed71ddc3fb1b2b390a92004b9d01067c26e2558e5503 - languageName: node - linkType: hard - -"@chainsafe/ssz@npm:^0.9.2": - version: 0.9.4 - resolution: "@chainsafe/ssz@npm:0.9.4" - dependencies: - "@chainsafe/as-sha256": ^0.3.1 - "@chainsafe/persistent-merkle-tree": ^0.4.2 - case: ^1.6.3 - checksum: c6eaedeae9e5618b3c666ff4507a27647f665a8dcf17d5ca86da4ed4788c5a93868f256d0005467d184fdf35ec03f323517ec2e55ec42492d769540a2ec396bc - languageName: node - linkType: hard - "@cspotcode/source-map-support@npm:^0.8.0": version: 0.8.1 resolution: "@cspotcode/source-map-support@npm:0.8.1" @@ -494,15 +448,15 @@ __metadata: linkType: hard "@eslint-community/regexpp@npm:^4.5.1, @eslint-community/regexpp@npm:^4.6.1": - version: 4.9.1 - resolution: "@eslint-community/regexpp@npm:4.9.1" - checksum: 06fb839e9c756f6375cc545c2f2e05a0a64576bd6370e8e3c07983fd29a3d6e164ef4aa48a361f7d27e6713ab79c83053ff6a2ccb78748bc955e344279c4a3b6 + version: 4.10.0 + resolution: "@eslint-community/regexpp@npm:4.10.0" + checksum: 2a6e345429ea8382aaaf3a61f865cae16ed44d31ca917910033c02dc00d505d939f10b81e079fa14d43b51499c640138e153b7e40743c4c094d9df97d4e56f7b languageName: node linkType: hard -"@eslint/eslintrc@npm:^2.1.2": - version: 2.1.2 - resolution: "@eslint/eslintrc@npm:2.1.2" +"@eslint/eslintrc@npm:^2.1.4": + version: 2.1.4 + resolution: "@eslint/eslintrc@npm:2.1.4" dependencies: ajv: ^6.12.4 debug: ^4.3.2 @@ -513,14 +467,14 @@ __metadata: js-yaml: ^4.1.0 minimatch: ^3.1.2 strip-json-comments: ^3.1.1 - checksum: bc742a1e3b361f06fedb4afb6bf32cbd27171292ef7924f61c62f2aed73048367bcc7ac68f98c06d4245cd3fabc43270f844e3c1699936d4734b3ac5398814a7 + checksum: 10957c7592b20ca0089262d8c2a8accbad14b4f6507e35416c32ee6b4dbf9cad67dfb77096bbd405405e9ada2b107f3797fe94362e1c55e0b09d6e90dd149127 languageName: node linkType: hard -"@eslint/js@npm:8.51.0": - version: 8.51.0 - resolution: "@eslint/js@npm:8.51.0" - checksum: 0228bf1e1e0414843e56d9ff362a2a72d579c078f93174666f29315690e9e30a8633ad72c923297f7fd7182381b5a476805ff04dac8debe638953eb1ded3ac73 +"@eslint/js@npm:8.56.0": + version: 8.56.0 + resolution: "@eslint/js@npm:8.56.0" + checksum: 5804130574ef810207bdf321c265437814e7a26f4e6fac9b496de3206afd52f533e09ec002a3be06cd9adcc9da63e727f1883938e663c4e4751c007d5b58e539 languageName: node linkType: hard @@ -1001,9 +955,9 @@ __metadata: linkType: hard "@fastify/busboy@npm:^2.0.0": - version: 2.0.0 - resolution: "@fastify/busboy@npm:2.0.0" - checksum: 41879937ce1dee6421ef9cd4da53239830617e1f0bb7a0e843940772cd72827205d05e518af6adabe6e1ea19301285fff432b9d11bad01a531e698bea95c781b + version: 2.1.0 + resolution: "@fastify/busboy@npm:2.1.0" + checksum: 3233abd10f73e50668cb4bb278a79b7b3fadd30215ac6458299b0e5a09a29c3586ec07597aae6bd93f5cbedfcef43a8aeea51829cd28fc13850cdbcd324c28d5 languageName: node linkType: hard @@ -1066,14 +1020,14 @@ __metadata: languageName: node linkType: hard -"@hapi/hoek@npm:^9.0.0": +"@hapi/hoek@npm:^9.0.0, @hapi/hoek@npm:^9.3.0": version: 9.3.0 resolution: "@hapi/hoek@npm:9.3.0" checksum: 4771c7a776242c3c022b168046af4e324d116a9d2e1d60631ee64f474c6e38d1bb07092d898bf95c7bc5d334c5582798a1456321b2e53ca817d4e7c88bc25b43 languageName: node linkType: hard -"@hapi/topo@npm:^5.0.0": +"@hapi/topo@npm:^5.1.0": version: 5.1.0 resolution: "@hapi/topo@npm:5.1.0" dependencies: @@ -1082,14 +1036,14 @@ __metadata: languageName: node linkType: hard -"@humanwhocodes/config-array@npm:^0.11.11": - version: 0.11.11 - resolution: "@humanwhocodes/config-array@npm:0.11.11" +"@humanwhocodes/config-array@npm:^0.11.13": + version: 0.11.14 + resolution: "@humanwhocodes/config-array@npm:0.11.14" dependencies: - "@humanwhocodes/object-schema": ^1.2.1 - debug: ^4.1.1 + "@humanwhocodes/object-schema": ^2.0.2 + debug: ^4.3.1 minimatch: ^3.0.5 - checksum: db84507375ab77b8ffdd24f498a5b49ad6b64391d30dd2ac56885501d03964d29637e05b1ed5aefa09d57ac667e28028bc22d2da872bfcd619652fbdb5f4ca19 + checksum: 861ccce9eaea5de19546653bccf75bf09fe878bc39c3aab00aeee2d2a0e654516adad38dd1098aab5e3af0145bbcbf3f309bdf4d964f8dab9dcd5834ae4c02f2 languageName: node linkType: hard @@ -1100,10 +1054,10 @@ __metadata: languageName: node linkType: hard -"@humanwhocodes/object-schema@npm:^1.2.1": - version: 1.2.1 - resolution: "@humanwhocodes/object-schema@npm:1.2.1" - checksum: a824a1ec31591231e4bad5787641f59e9633827d0a2eaae131a288d33c9ef0290bd16fda8da6f7c0fcb014147865d12118df10db57f27f41e20da92369fcb3f1 +"@humanwhocodes/object-schema@npm:^2.0.2": + version: 2.0.2 + resolution: "@humanwhocodes/object-schema@npm:2.0.2" + checksum: 2fc11503361b5fb4f14714c700c02a3f4c7c93e9acd6b87a29f62c522d90470f364d6161b03d1cc618b979f2ae02aed1106fd29d302695d8927e2fc8165ba8ee languageName: node linkType: hard @@ -1163,7 +1117,7 @@ __metadata: languageName: node linkType: hard -"@istanbuljs/schema@npm:^0.1.2": +"@istanbuljs/schema@npm:^0.1.2, @istanbuljs/schema@npm:^0.1.3": version: 0.1.3 resolution: "@istanbuljs/schema@npm:0.1.3" checksum: 5282759d961d61350f33d9118d16bcaed914ebf8061a52f4fa474b2cb08720c9c81d165e13b82f2e5a8a212cc5af482f0c6fc1ac27b9e067e5394c9a6ed186c9 @@ -1412,9 +1366,9 @@ __metadata: linkType: hard "@jridgewell/resolve-uri@npm:^3.0.3, @jridgewell/resolve-uri@npm:^3.1.0": - version: 3.1.1 - resolution: "@jridgewell/resolve-uri@npm:3.1.1" - checksum: f5b441fe7900eab4f9155b3b93f9800a916257f4e8563afbcd3b5a5337b55e52bd8ae6735453b1b745457d9f6cdb16d74cd6220bbdd98cf153239e13f6cbb653 + version: 3.1.2 + resolution: "@jridgewell/resolve-uri@npm:3.1.2" + checksum: 83b85f72c59d1c080b4cbec0fef84528963a1b5db34e4370fa4bd1e3ff64a0d80e0cee7369d11d73c704e0286fb2865b530acac7a871088fbe92b5edf1000870 languageName: node linkType: hard @@ -1443,12 +1397,12 @@ __metadata: linkType: hard "@jridgewell/trace-mapping@npm:^0.3.12, @jridgewell/trace-mapping@npm:^0.3.17, @jridgewell/trace-mapping@npm:^0.3.18, @jridgewell/trace-mapping@npm:^0.3.9": - version: 0.3.19 - resolution: "@jridgewell/trace-mapping@npm:0.3.19" + version: 0.3.22 + resolution: "@jridgewell/trace-mapping@npm:0.3.22" dependencies: "@jridgewell/resolve-uri": ^3.1.0 "@jridgewell/sourcemap-codec": ^1.4.14 - checksum: 956a6f0f6fec060fb48c6bf1f5ec2064e13cd38c8be3873877d4b92b4a27ba58289a34071752671262a3e3c202abcc3fa2aac64d8447b4b0fa1ba3c9047f1c20 + checksum: ac7dd2cfe0b479aa1b81776d40d789243131cc792dc8b6b6a028c70fcd6171958ae1a71bf67b618ffe3c0c3feead9870c095ee46a5e30319410d92976b28f498 languageName: node linkType: hard @@ -1465,12 +1419,12 @@ __metadata: languageName: node linkType: hard -"@noble/curves@npm:1.1.0, @noble/curves@npm:~1.1.0": - version: 1.1.0 - resolution: "@noble/curves@npm:1.1.0" +"@noble/curves@npm:1.3.0, @noble/curves@npm:~1.3.0": + version: 1.3.0 + resolution: "@noble/curves@npm:1.3.0" dependencies: - "@noble/hashes": 1.3.1 - checksum: 2658cdd3f84f71079b4e3516c47559d22cf4b55c23ac8ee9d2b1f8e5b72916d9689e59820e0f9d9cb4a46a8423af5b56dc6bb7782405c88be06a015180508db5 + "@noble/hashes": 1.3.3 + checksum: b65342ee66c4a440eee2978524412eabba9a9efdd16d6370e15218c6a7d80bddf35e66bb57ed52c0dfd32cb9a717b439ab3a72db618f1a0066dfebe3fd12a421 languageName: node linkType: hard @@ -1481,17 +1435,10 @@ __metadata: languageName: node linkType: hard -"@noble/hashes@npm:1.3.1": - version: 1.3.1 - resolution: "@noble/hashes@npm:1.3.1" - checksum: 7fdefc0f7a0c1ec27acc6ff88841793e3f93ec4ce6b8a6a12bfc0dd70ae6b7c4c82fe305fdfeda1735d5ad4a9eebe761e6693b3d355689c559e91242f4bc95b1 - languageName: node - linkType: hard - -"@noble/hashes@npm:~1.3.0, @noble/hashes@npm:~1.3.1": - version: 1.3.2 - resolution: "@noble/hashes@npm:1.3.2" - checksum: fe23536b436539d13f90e4b9be843cc63b1b17666a07634a2b1259dded6f490be3d050249e6af98076ea8f2ea0d56f578773c2197f2aa0eeaa5fba5bc18ba474 +"@noble/hashes@npm:1.3.3, @noble/hashes@npm:~1.3.2": + version: 1.3.3 + resolution: "@noble/hashes@npm:1.3.3" + checksum: 8a6496d1c0c64797339bc694ad06cdfaa0f9e56cd0c3f68ae3666cfb153a791a55deb0af9c653c7ed2db64d537aa3e3054629740d2f2338bb1dcb7ab60cd205b languageName: node linkType: hard @@ -1529,161 +1476,180 @@ __metadata: languageName: node linkType: hard -"@nomicfoundation/ethereumjs-block@npm:5.0.2": - version: 5.0.2 - resolution: "@nomicfoundation/ethereumjs-block@npm:5.0.2" +"@nomicfoundation/ethereumjs-block@npm:5.0.4": + version: 5.0.4 + resolution: "@nomicfoundation/ethereumjs-block@npm:5.0.4" dependencies: - "@nomicfoundation/ethereumjs-common": 4.0.2 - "@nomicfoundation/ethereumjs-rlp": 5.0.2 - "@nomicfoundation/ethereumjs-trie": 6.0.2 - "@nomicfoundation/ethereumjs-tx": 5.0.2 - "@nomicfoundation/ethereumjs-util": 9.0.2 + "@nomicfoundation/ethereumjs-common": 4.0.4 + "@nomicfoundation/ethereumjs-rlp": 5.0.4 + "@nomicfoundation/ethereumjs-trie": 6.0.4 + "@nomicfoundation/ethereumjs-tx": 5.0.4 + "@nomicfoundation/ethereumjs-util": 9.0.4 ethereum-cryptography: 0.1.3 - ethers: ^5.7.1 - checksum: 7ff744f44a01f1c059ca7812a1cfc8089f87aa506af6cb39c78331dca71b32993cbd6fa05ad03f8c4f4fab73bb998a927af69e0d8ff01ae192ee5931606e09f5 + checksum: fe60b3dc31e0991eb6659f838485384e52992b72dd97a42c7bec320ea9902d1200352b5690a222442f77c5447cee4dd834fc25c53247aed5aa3130b0ab7e3c53 languageName: node linkType: hard -"@nomicfoundation/ethereumjs-blockchain@npm:7.0.2": - version: 7.0.2 - resolution: "@nomicfoundation/ethereumjs-blockchain@npm:7.0.2" - dependencies: - "@nomicfoundation/ethereumjs-block": 5.0.2 - "@nomicfoundation/ethereumjs-common": 4.0.2 - "@nomicfoundation/ethereumjs-ethash": 3.0.2 - "@nomicfoundation/ethereumjs-rlp": 5.0.2 - "@nomicfoundation/ethereumjs-trie": 6.0.2 - "@nomicfoundation/ethereumjs-tx": 5.0.2 - "@nomicfoundation/ethereumjs-util": 9.0.2 - abstract-level: ^1.0.3 +"@nomicfoundation/ethereumjs-blockchain@npm:7.0.4": + version: 7.0.4 + resolution: "@nomicfoundation/ethereumjs-blockchain@npm:7.0.4" + dependencies: + "@nomicfoundation/ethereumjs-block": 5.0.4 + "@nomicfoundation/ethereumjs-common": 4.0.4 + "@nomicfoundation/ethereumjs-ethash": 3.0.4 + "@nomicfoundation/ethereumjs-rlp": 5.0.4 + "@nomicfoundation/ethereumjs-trie": 6.0.4 + "@nomicfoundation/ethereumjs-tx": 5.0.4 + "@nomicfoundation/ethereumjs-util": 9.0.4 debug: ^4.3.3 ethereum-cryptography: 0.1.3 - level: ^8.0.0 - lru-cache: ^5.1.1 - memory-level: ^1.0.0 - checksum: b7e440dcd73e32aa72d13bfd28cb472773c9c60ea808a884131bf7eb3f42286ad594a0864215f599332d800f3fe1f772fff4b138d2dcaa8f41e4d8389bff33e7 + lru-cache: ^10.0.0 + checksum: 0d35f28ed5ef356557b974b91898b6f61292a3e0fd3d1b1c8924250a59c7f583939453184f5b54f7cd2a2d8c055cdc6f3b8588c7b22f839beaa4ba69638ba2c8 languageName: node linkType: hard -"@nomicfoundation/ethereumjs-common@npm:4.0.2": - version: 4.0.2 - resolution: "@nomicfoundation/ethereumjs-common@npm:4.0.2" +"@nomicfoundation/ethereumjs-common@npm:4.0.4": + version: 4.0.4 + resolution: "@nomicfoundation/ethereumjs-common@npm:4.0.4" dependencies: - "@nomicfoundation/ethereumjs-util": 9.0.2 - crc-32: ^1.2.0 - checksum: f0d84704d6254d374299c19884312bd5666974b4b6f342d3f10bc76e549de78d20e45a53d25fbdc146268a52335497127e4f069126da7c60ac933a158e704887 + "@nomicfoundation/ethereumjs-util": 9.0.4 + checksum: ce3f6e4ae15b976efdb7ccda27e19aadb62b5ffee209f9503e68b4fd8633715d4d697c0cc10ccd35f5e4e977edd05100d0f214e28880ec64fff77341dc34fcdf languageName: node linkType: hard -"@nomicfoundation/ethereumjs-ethash@npm:3.0.2": - version: 3.0.2 - resolution: "@nomicfoundation/ethereumjs-ethash@npm:3.0.2" +"@nomicfoundation/ethereumjs-ethash@npm:3.0.4": + version: 3.0.4 + resolution: "@nomicfoundation/ethereumjs-ethash@npm:3.0.4" dependencies: - "@nomicfoundation/ethereumjs-block": 5.0.2 - "@nomicfoundation/ethereumjs-rlp": 5.0.2 - "@nomicfoundation/ethereumjs-util": 9.0.2 - abstract-level: ^1.0.3 - bigint-crypto-utils: ^3.0.23 + "@nomicfoundation/ethereumjs-block": 5.0.4 + "@nomicfoundation/ethereumjs-rlp": 5.0.4 + "@nomicfoundation/ethereumjs-util": 9.0.4 + bigint-crypto-utils: ^3.2.2 ethereum-cryptography: 0.1.3 - checksum: e4011e4019dd9b92f7eeebfc1e6c9a9685c52d8fd0ee4f28f03e50048a23b600c714490827f59fdce497b3afb503b3fd2ebf6815ff307e9949c3efeff1403278 + checksum: 52c2b003078be233929ae8355e8d2e0949ac66f75312a47725790b87111293de4303750a446f10eec22f5ffd9a2accb3f17fff8e6a85c36b47786e25242dad66 languageName: node linkType: hard -"@nomicfoundation/ethereumjs-evm@npm:2.0.2": - version: 2.0.2 - resolution: "@nomicfoundation/ethereumjs-evm@npm:2.0.2" +"@nomicfoundation/ethereumjs-evm@npm:2.0.4": + version: 2.0.4 + resolution: "@nomicfoundation/ethereumjs-evm@npm:2.0.4" dependencies: - "@ethersproject/providers": ^5.7.1 - "@nomicfoundation/ethereumjs-common": 4.0.2 - "@nomicfoundation/ethereumjs-tx": 5.0.2 - "@nomicfoundation/ethereumjs-util": 9.0.2 + "@nomicfoundation/ethereumjs-common": 4.0.4 + "@nomicfoundation/ethereumjs-statemanager": 2.0.4 + "@nomicfoundation/ethereumjs-tx": 5.0.4 + "@nomicfoundation/ethereumjs-util": 9.0.4 + "@types/debug": ^4.1.9 debug: ^4.3.3 ethereum-cryptography: 0.1.3 - mcl-wasm: ^0.7.1 - rustbn.js: ~0.2.0 - checksum: a23cf570836ddc147606b02df568069de946108e640f902358fef67e589f6b371d856056ee44299d9b4e3497f8ae25faa45e6b18fefd90e9b222dc6a761d85f0 + rustbn-wasm: ^0.2.0 + checksum: db25327f7bda067cd0726a1bc7937c1c0405602fbe692abaa804f44e4fe9d2dcce103d50a767c0f3dc3067b38c35f468e997789234d2a4aef0ad31a36ad6d916 languageName: node linkType: hard -"@nomicfoundation/ethereumjs-rlp@npm:5.0.2": - version: 5.0.2 - resolution: "@nomicfoundation/ethereumjs-rlp@npm:5.0.2" +"@nomicfoundation/ethereumjs-rlp@npm:5.0.4": + version: 5.0.4 + resolution: "@nomicfoundation/ethereumjs-rlp@npm:5.0.4" bin: - rlp: bin/rlp - checksum: a74434cadefca9aa8754607cc1ad7bb4bbea4ee61c6214918e60a5bbee83206850346eb64e39fd1fe97f854c7ec0163e01148c0c881dda23881938f0645a0ef2 + rlp: bin/rlp.cjs + checksum: ee2c2e5776c73801dc5ed636f4988b599b4563c2d0037da542ea57eb237c69dd1ac555f6bcb5e06f70515b6459779ba0d68252a6e105132b4659ab4bf62919b0 languageName: node linkType: hard -"@nomicfoundation/ethereumjs-statemanager@npm:2.0.2": - version: 2.0.2 - resolution: "@nomicfoundation/ethereumjs-statemanager@npm:2.0.2" +"@nomicfoundation/ethereumjs-statemanager@npm:2.0.4": + version: 2.0.4 + resolution: "@nomicfoundation/ethereumjs-statemanager@npm:2.0.4" dependencies: - "@nomicfoundation/ethereumjs-common": 4.0.2 - "@nomicfoundation/ethereumjs-rlp": 5.0.2 + "@nomicfoundation/ethereumjs-common": 4.0.4 + "@nomicfoundation/ethereumjs-rlp": 5.0.4 + "@nomicfoundation/ethereumjs-trie": 6.0.4 + "@nomicfoundation/ethereumjs-util": 9.0.4 debug: ^4.3.3 ethereum-cryptography: 0.1.3 - ethers: ^5.7.1 js-sdsl: ^4.1.4 - checksum: 3ab6578e252e53609afd98d8ba42a99f182dcf80252f23ed9a5e0471023ffb2502130f85fc47fa7c94cd149f9be799ed9a0942ca52a143405be9267f4ad94e64 + lru-cache: ^10.0.0 + peerDependencies: + "@nomicfoundation/ethereumjs-verkle": 0.0.2 + peerDependenciesMeta: + "@nomicfoundation/ethereumjs-verkle": + optional: true + checksum: 585dc67872d37f39310d85fc5c1b3179691412b9450411422ad6468017d8723e5192d22447c927d8403f7b6e95c1ecf7b48467edc440e50f15b5ac81e1fecd1d languageName: node linkType: hard -"@nomicfoundation/ethereumjs-trie@npm:6.0.2": - version: 6.0.2 - resolution: "@nomicfoundation/ethereumjs-trie@npm:6.0.2" +"@nomicfoundation/ethereumjs-trie@npm:6.0.4": + version: 6.0.4 + resolution: "@nomicfoundation/ethereumjs-trie@npm:6.0.4" dependencies: - "@nomicfoundation/ethereumjs-rlp": 5.0.2 - "@nomicfoundation/ethereumjs-util": 9.0.2 + "@nomicfoundation/ethereumjs-rlp": 5.0.4 + "@nomicfoundation/ethereumjs-util": 9.0.4 "@types/readable-stream": ^2.3.13 ethereum-cryptography: 0.1.3 + lru-cache: ^10.0.0 readable-stream: ^3.6.0 - checksum: d4da918d333851b9f2cce7dbd25ab5753e0accd43d562d98fd991b168b6a08d1794528f0ade40fe5617c84900378376fe6256cdbe52c8d66bf4c53293bbc7c40 + checksum: 93a6be32657e67e74714fe557dbaf606d92c5cd1571c60f249295c27b0ab24b64e2e59cf211c214f8ba403d6475d23ed8c557be9077b92b2317e44384de8a6bf languageName: node linkType: hard -"@nomicfoundation/ethereumjs-tx@npm:5.0.2": - version: 5.0.2 - resolution: "@nomicfoundation/ethereumjs-tx@npm:5.0.2" +"@nomicfoundation/ethereumjs-tx@npm:5.0.4": + version: 5.0.4 + resolution: "@nomicfoundation/ethereumjs-tx@npm:5.0.4" dependencies: - "@chainsafe/ssz": ^0.9.2 - "@ethersproject/providers": ^5.7.2 - "@nomicfoundation/ethereumjs-common": 4.0.2 - "@nomicfoundation/ethereumjs-rlp": 5.0.2 - "@nomicfoundation/ethereumjs-util": 9.0.2 + "@nomicfoundation/ethereumjs-common": 4.0.4 + "@nomicfoundation/ethereumjs-rlp": 5.0.4 + "@nomicfoundation/ethereumjs-util": 9.0.4 ethereum-cryptography: 0.1.3 - checksum: 0bbcea75786b2ccb559afe2ecc9866fb4566a9f157b6ffba4f50960d14f4b3da2e86e273f6fadda9b860e67cfcabf589970fb951b328cb5f900a585cd21842a2 + peerDependencies: + c-kzg: ^2.1.2 + peerDependenciesMeta: + c-kzg: + optional: true + checksum: 0f1c87716682ccbcf4d92ffc6cf8ab557e658b90319d82be3219a091a736859f8803c73c98e4863682e3e86d264751c472d33ff6d3c3daf4e75b5f01d0af8fa3 languageName: node linkType: hard -"@nomicfoundation/ethereumjs-util@npm:9.0.2": - version: 9.0.2 - resolution: "@nomicfoundation/ethereumjs-util@npm:9.0.2" +"@nomicfoundation/ethereumjs-util@npm:9.0.4": + version: 9.0.4 + resolution: "@nomicfoundation/ethereumjs-util@npm:9.0.4" dependencies: - "@chainsafe/ssz": ^0.10.0 - "@nomicfoundation/ethereumjs-rlp": 5.0.2 + "@nomicfoundation/ethereumjs-rlp": 5.0.4 ethereum-cryptography: 0.1.3 - checksum: 3a08f7b88079ef9f53b43da9bdcb8195498fd3d3911c2feee2571f4d1204656053f058b2f650471c86f7d2d0ba2f814768c7cfb0f266eede41c848356afc4900 + peerDependencies: + c-kzg: ^2.1.2 + peerDependenciesMeta: + c-kzg: + optional: true + checksum: 754439f72b11cad2d8986707ad020077dcc763c4055f73e2668a0b4cadb22aa4407faa9b3c587d9eb5b97ac337afbe037eb642bc1d5a16197284f83db3462cbe languageName: node linkType: hard -"@nomicfoundation/ethereumjs-vm@npm:7.0.2": - version: 7.0.2 - resolution: "@nomicfoundation/ethereumjs-vm@npm:7.0.2" - dependencies: - "@nomicfoundation/ethereumjs-block": 5.0.2 - "@nomicfoundation/ethereumjs-blockchain": 7.0.2 - "@nomicfoundation/ethereumjs-common": 4.0.2 - "@nomicfoundation/ethereumjs-evm": 2.0.2 - "@nomicfoundation/ethereumjs-rlp": 5.0.2 - "@nomicfoundation/ethereumjs-statemanager": 2.0.2 - "@nomicfoundation/ethereumjs-trie": 6.0.2 - "@nomicfoundation/ethereumjs-tx": 5.0.2 - "@nomicfoundation/ethereumjs-util": 9.0.2 +"@nomicfoundation/ethereumjs-verkle@npm:0.0.2": + version: 0.0.2 + resolution: "@nomicfoundation/ethereumjs-verkle@npm:0.0.2" + dependencies: + "@nomicfoundation/ethereumjs-rlp": 5.0.4 + "@nomicfoundation/ethereumjs-util": 9.0.4 + lru-cache: ^10.0.0 + rust-verkle-wasm: ^0.0.1 + checksum: e075d7a2475670bb7039e715f0edce849ef3947aae2c7d0b658f058686ac9df3863499a5324717beff5d8f20a751f85ba1449942af818ec6772d775dcbb011d6 + languageName: node + linkType: hard + +"@nomicfoundation/ethereumjs-vm@npm:7.0.4": + version: 7.0.4 + resolution: "@nomicfoundation/ethereumjs-vm@npm:7.0.4" + dependencies: + "@nomicfoundation/ethereumjs-block": 5.0.4 + "@nomicfoundation/ethereumjs-blockchain": 7.0.4 + "@nomicfoundation/ethereumjs-common": 4.0.4 + "@nomicfoundation/ethereumjs-evm": 2.0.4 + "@nomicfoundation/ethereumjs-rlp": 5.0.4 + "@nomicfoundation/ethereumjs-statemanager": 2.0.4 + "@nomicfoundation/ethereumjs-trie": 6.0.4 + "@nomicfoundation/ethereumjs-tx": 5.0.4 + "@nomicfoundation/ethereumjs-util": 9.0.4 debug: ^4.3.3 ethereum-cryptography: 0.1.3 - mcl-wasm: ^0.7.1 - rustbn.js: ~0.2.0 - checksum: 1c25ba4d0644cadb8a2b0241a4bb02e578bfd7f70e3492b855c2ab5c120cb159cb8f7486f84dc1597884bd1697feedbfb5feb66e91352afb51f3694fd8e4a043 + checksum: 6f3b2507189b236e65dd3eaf3f072385a0252b826a348fe6ea5532a810bc2b6aab11d8ccec2cdfed629995e61e4c82c6e8765ac5794154772064ba3f18397407 languageName: node linkType: hard @@ -1717,13 +1683,13 @@ __metadata: linkType: hard "@nomicfoundation/hardhat-network-helpers@npm:^1.0.6": - version: 1.0.9 - resolution: "@nomicfoundation/hardhat-network-helpers@npm:1.0.9" + version: 1.0.10 + resolution: "@nomicfoundation/hardhat-network-helpers@npm:1.0.10" dependencies: ethereumjs-util: ^7.1.4 peerDependencies: hardhat: ^2.9.5 - checksum: ff378795075af853aeaacb7bc0783928d947d7f9fb043c046fcaffdf1e1219c4af47b18ea7fa2c10fe0b25daef48f13ae8b103bc11ea494ecdfbe34a3dcdf936 + checksum: 675da8d3229946a2bac0df9d1b5cc278bba9cd1a8214b5ff6099dcba874d913df07b9772a2ead0cb7ea2ced6b3fa430a73f94a3e257ae105493931c38fc7bf61 languageName: node linkType: hard @@ -1874,8 +1840,8 @@ __metadata: linkType: hard "@nomiclabs/hardhat-etherscan@npm:^3.1.0": - version: 3.1.7 - resolution: "@nomiclabs/hardhat-etherscan@npm:3.1.7" + version: 3.1.8 + resolution: "@nomiclabs/hardhat-etherscan@npm:3.1.8" dependencies: "@ethersproject/abi": ^5.1.2 "@ethersproject/address": ^5.0.2 @@ -1889,7 +1855,20 @@ __metadata: undici: ^5.14.0 peerDependencies: hardhat: ^2.0.4 - checksum: 32d74e567e78a940a79cbe49c5dee0eb5cda0a4c0c34a9badfaf13d45e6054d9e717c28b8d2b0b20f29721a484af15a52d391fb60768222c4b13de92ef0f72b3 + checksum: 13864380d104705a54668adf2fb37a87d1147a064c1d29dbc356390e7254d5c7501b9b3af9c4ec2f9d9ff642a01417d5d35970d626fe706f5f4830820ae89ecb + languageName: node + linkType: hard + +"@npmcli/agent@npm:^2.0.0": + version: 2.2.1 + resolution: "@npmcli/agent@npm:2.2.1" + dependencies: + agent-base: ^7.1.0 + http-proxy-agent: ^7.0.0 + https-proxy-agent: ^7.0.1 + lru-cache: ^10.0.1 + socks-proxy-agent: ^8.0.1 + checksum: c69aca42dbba393f517bc5777ee872d38dc98ea0e5e93c1f6d62b82b8fecdc177a57ea045f07dda1a770c592384b2dd92a5e79e21e2a7cf51c9159466a8f9c9b languageName: node linkType: hard @@ -1947,9 +1926,9 @@ __metadata: linkType: hard "@openzeppelin/contracts-upgradeable@npm:^4.7.3": - version: 4.9.3 - resolution: "@openzeppelin/contracts-upgradeable@npm:4.9.3" - checksum: bda0240b1d44c913ec5a4e109c622f216c2bbd7b468d210822f75782a5f7fe0609d08bf03b78b253333625e99e507cf2f75212f1de3b274bd9fc64ae967aeec3 + version: 4.9.5 + resolution: "@openzeppelin/contracts-upgradeable@npm:4.9.5" + checksum: d5d9bad93fe2a88a8336060901d45f185ebfe1fed9844b1fe50e8641d946588c6e69a5a8f1694f0bd073c913b4b9a5c34316acfc17d8f75228adecbcb635ea62 languageName: node linkType: hard @@ -1974,14 +1953,14 @@ __metadata: languageName: node linkType: hard -"@peculiar/asn1-schema@npm:^2.3.6": - version: 2.3.6 - resolution: "@peculiar/asn1-schema@npm:2.3.6" +"@peculiar/asn1-schema@npm:^2.3.8": + version: 2.3.8 + resolution: "@peculiar/asn1-schema@npm:2.3.8" dependencies: asn1js: ^3.0.5 - pvtsutils: ^1.3.2 - tslib: ^2.4.0 - checksum: fc09387c6e3dea07fca21b54ea8c71ce3ec0f8c92377237e51aef729f0c2df92781aa7a18a546a6fe809519faeaa222df576ec21a35c6095037a78677204a55b + pvtsutils: ^1.3.5 + tslib: ^2.6.2 + checksum: 1f4dd421f1411df8bc52bca12b1cef710434c13ff0a8b5746ede42b10d62b5ad06a3925c4a6db53102aaf1e589947539a6955fa8554a9b8ebb1ffa38b0155a24 languageName: node linkType: hard @@ -1995,15 +1974,15 @@ __metadata: linkType: hard "@peculiar/webcrypto@npm:^1.4.0": - version: 1.4.3 - resolution: "@peculiar/webcrypto@npm:1.4.3" + version: 1.4.5 + resolution: "@peculiar/webcrypto@npm:1.4.5" dependencies: - "@peculiar/asn1-schema": ^2.3.6 + "@peculiar/asn1-schema": ^2.3.8 "@peculiar/json-schema": ^1.1.12 - pvtsutils: ^1.3.2 - tslib: ^2.5.0 - webcrypto-core: ^1.7.7 - checksum: 5604c02b7e9a8cef61bb4430e733e939c7737533ba65ba5fac4beb3a6d613add478ab45455cb57506789b6d00704d83e4965a0f712de3e8f40706e0961670e5c + pvtsutils: ^1.3.5 + tslib: ^2.6.2 + webcrypto-core: ^1.7.8 + checksum: a07b49b44d9bfa75647e5633ad1c0232dab43d3a592e5579f5288dabd319138f2714cf5451d7b8f728d7ed16c9cb159aab6313bcd79f8ce9ed4b2933f9f3a72b languageName: node linkType: hard @@ -2106,10 +2085,10 @@ __metadata: languageName: node linkType: hard -"@scure/base@npm:~1.1.0": - version: 1.1.3 - resolution: "@scure/base@npm:1.1.3" - checksum: 1606ab8a4db898cb3a1ada16c15437c3bce4e25854fadc8eb03ae93cbbbac1ed90655af4b0be3da37e12056fef11c0374499f69b9e658c9e5b7b3e06353c630c +"@scure/base@npm:^1.1.1, @scure/base@npm:~1.1.0, @scure/base@npm:~1.1.4": + version: 1.1.5 + resolution: "@scure/base@npm:1.1.5" + checksum: 9e9ee6088cb3aa0fb91f5a48497d26682c7829df3019b1251d088d166d7a8c0f941c68aaa8e7b96bbad20c71eb210397cb1099062cde3e29d4bad6b975c18519 languageName: node linkType: hard @@ -2124,14 +2103,14 @@ __metadata: languageName: node linkType: hard -"@scure/bip32@npm:1.3.1": - version: 1.3.1 - resolution: "@scure/bip32@npm:1.3.1" +"@scure/bip32@npm:1.3.3": + version: 1.3.3 + resolution: "@scure/bip32@npm:1.3.3" dependencies: - "@noble/curves": ~1.1.0 - "@noble/hashes": ~1.3.1 - "@scure/base": ~1.1.0 - checksum: 394d65f77a40651eba21a5096da0f4233c3b50d422864751d373fcf142eeedb94a1149f9ab1dbb078086dab2d0bc27e2b1afec8321bf22d4403c7df2fea5bfe2 + "@noble/curves": ~1.3.0 + "@noble/hashes": ~1.3.2 + "@scure/base": ~1.1.4 + checksum: f939ca733972622fcc1e61d4fdf170a0ad294b24ddb7ed7cdd4c467e1ef283b970154cb101cf5f1a7b64cf5337e917ad31135911dfc36b1d76625320167df2fa languageName: node linkType: hard @@ -2145,13 +2124,13 @@ __metadata: languageName: node linkType: hard -"@scure/bip39@npm:1.2.1": - version: 1.2.1 - resolution: "@scure/bip39@npm:1.2.1" +"@scure/bip39@npm:1.2.2": + version: 1.2.2 + resolution: "@scure/bip39@npm:1.2.2" dependencies: - "@noble/hashes": ~1.3.0 - "@scure/base": ~1.1.0 - checksum: c5bd6f1328fdbeae2dcdd891825b1610225310e5e62a4942714db51066866e4f7bef242c7b06a1b9dcc8043a4a13412cf5c5df76d3b10aa9e36b82e9b6e3eeaa + "@noble/hashes": ~1.3.2 + "@scure/base": ~1.1.4 + checksum: cb99505e6d2deef8e55e81df8c563ce8dbfdf1595596dc912bceadcf366c91b05a98130e928ecb090df74efdb20150b64acc4be55bc42768cab4d39a2833d234 languageName: node linkType: hard @@ -2199,6 +2178,7 @@ __metadata: prettier: ^2.8.4 qrcode: ^1.5.1 solidity-coverage: ^0.8.2 + solidity-docgen: ^0.6.0-beta.36 ts-jest: ^29.1.1 ts-node: ^10.9.1 typechain: ^8.1.0 @@ -2213,7 +2193,7 @@ __metadata: "@graphprotocol/graph-cli": ^0.46.1 "@graphprotocol/graph-ts": ^0.29.3 handlebars-cmd: ^0.1.4 - node-jq: ^2.3.4 + node-jq: 2.3.5 ts-node: ^10.9.1 typescript: ^5.0.4 languageName: unknown @@ -2301,12 +2281,12 @@ __metadata: languageName: node linkType: hard -"@sideway/address@npm:^4.1.3": - version: 4.1.4 - resolution: "@sideway/address@npm:4.1.4" +"@sideway/address@npm:^4.1.5": + version: 4.1.5 + resolution: "@sideway/address@npm:4.1.5" dependencies: "@hapi/hoek": ^9.0.0 - checksum: b9fca2a93ac2c975ba12e0a6d97853832fb1f4fb02393015e012b47fa916a75ca95102d77214b2a29a2784740df2407951af8c5dde054824c65577fd293c4cdb + checksum: 3e3ea0f00b4765d86509282290368a4a5fd39a7995fdc6de42116ca19a96120858e56c2c995081def06e1c53e1f8bccc7d013f6326602bec9d56b72ee2772b9d languageName: node linkType: hard @@ -2332,11 +2312,11 @@ __metadata: linkType: hard "@sinonjs/commons@npm:^3.0.0": - version: 3.0.0 - resolution: "@sinonjs/commons@npm:3.0.0" + version: 3.0.1 + resolution: "@sinonjs/commons@npm:3.0.1" dependencies: type-detect: 4.0.8 - checksum: b4b5b73d4df4560fb8c0c7b38c7ad4aeabedd362f3373859d804c988c725889cde33550e4bcc7cd316a30f5152a2d1d43db71b6d0c38f5feef71fd8d016763f8 + checksum: a7c3e7cc612352f4004873747d9d8b2d4d90b13a6d483f685598c945a70e734e255f1ca5dc49702515533c403b32725defff148177453b3f3915bcb60e9d4601 languageName: node linkType: hard @@ -2358,19 +2338,10 @@ __metadata: languageName: node linkType: hard -"@solidity-parser/parser@npm:^0.16.0": - version: 0.16.1 - resolution: "@solidity-parser/parser@npm:0.16.1" - dependencies: - antlr4ts: ^0.5.0-alpha.4 - checksum: d9e2f7042434fb850a97a2c3679f5fbf4997c7845278d0a436b3de30169e6758fe3818191694ece36dc39a40f55ae0384c4ae0ae912790b5b0806728a50466c2 - languageName: node - linkType: hard - -"@tootallnate/once@npm:2": - version: 2.0.0 - resolution: "@tootallnate/once@npm:2.0.0" - checksum: ad87447820dd3f24825d2d947ebc03072b20a42bfc96cbafec16bff8bbda6c1a81fcb0be56d5b21968560c5359a0af4038a68ba150c3e1694fe4c109a063bed8 +"@solidity-parser/parser@npm:^0.18.0": + version: 0.18.0 + resolution: "@solidity-parser/parser@npm:0.18.0" + checksum: 970d991529d632862fa88e107531339d84df35bf0374e31e8215ce301b19a01ede33fccf4d374402649814263f8bc278a8e6d62a0129bb877539fbdd16a604cc languageName: node linkType: hard @@ -2449,43 +2420,43 @@ __metadata: linkType: hard "@types/babel__core@npm:^7.1.14": - version: 7.20.2 - resolution: "@types/babel__core@npm:7.20.2" + version: 7.20.5 + resolution: "@types/babel__core@npm:7.20.5" dependencies: "@babel/parser": ^7.20.7 "@babel/types": ^7.20.7 "@types/babel__generator": "*" "@types/babel__template": "*" "@types/babel__traverse": "*" - checksum: 564fbaa8ff1305d50807ada0ec227c3e7528bebb2f8fe6b2ed88db0735a31511a74ad18729679c43eeed8025ed29d408f53059289719e95ab1352ed559a100bd + checksum: a3226f7930b635ee7a5e72c8d51a357e799d19cbf9d445710fa39ab13804f79ab1a54b72ea7d8e504659c7dfc50675db974b526142c754398d7413aa4bc30845 languageName: node linkType: hard "@types/babel__generator@npm:*": - version: 7.6.5 - resolution: "@types/babel__generator@npm:7.6.5" + version: 7.6.8 + resolution: "@types/babel__generator@npm:7.6.8" dependencies: "@babel/types": ^7.0.0 - checksum: c7459f5025c4c800eaf58f4db3b24e9d736331fe7df40961d9bc49f31b46e2a3be83dc9276e8688f10a5ed752ae153ad5f1bdd45e2245bac95273730b9115ec2 + checksum: 5b332ea336a2efffbdeedb92b6781949b73498606ddd4205462f7d96dafd45ff3618770b41de04c4881e333dd84388bfb8afbdf6f2764cbd98be550d85c6bb48 languageName: node linkType: hard "@types/babel__template@npm:*": - version: 7.4.2 - resolution: "@types/babel__template@npm:7.4.2" + version: 7.4.4 + resolution: "@types/babel__template@npm:7.4.4" dependencies: "@babel/parser": ^7.1.0 "@babel/types": ^7.0.0 - checksum: 0fe977b45a3269336c77f3ae4641a6c48abf0fa35ab1a23fb571690786af02d6cec08255a43499b0b25c5633800f7ae882ace450cce905e3060fa9e6995047ae + checksum: d7a02d2a9b67e822694d8e6a7ddb8f2b71a1d6962dfd266554d2513eefbb205b33ca71a0d163b1caea3981ccf849211f9964d8bd0727124d18ace45aa6c9ae29 languageName: node linkType: hard "@types/babel__traverse@npm:*, @types/babel__traverse@npm:^7.0.6": - version: 7.20.2 - resolution: "@types/babel__traverse@npm:7.20.2" + version: 7.20.5 + resolution: "@types/babel__traverse@npm:7.20.5" dependencies: "@babel/types": ^7.20.7 - checksum: 981340286479524436348d32373eaa3bf993c635cbf70307b4b69463eee83406a959ac4844f683911e0db8ab8d9f0025ab630dc7a8c170fee9ee74144c2a528f + checksum: 608e0ab4fc31cd47011d98942e6241b34d461608c0c0e153377c5fd822c436c475f1ded76a56bfa76a1adf8d9266b727bbf9bfac90c4cb152c97f30dadc5b7e8 languageName: node linkType: hard @@ -2499,36 +2470,36 @@ __metadata: linkType: hard "@types/bn.js@npm:^5.1.0": - version: 5.1.2 - resolution: "@types/bn.js@npm:5.1.2" + version: 5.1.5 + resolution: "@types/bn.js@npm:5.1.5" dependencies: "@types/node": "*" - checksum: 8d9fdb43836646c2ecd445041de03e057f9b459885be57faee64104160487a63730b9f371e8ad7d33f360b3cc6dc0e323543962fc5fa296b92b322b946732be0 + checksum: c87b28c4af74545624f8a3dae5294b16aa190c222626e8d4b2e327b33b1a3f1eeb43e7a24d914a9774bca43d8cd6e1cb0325c1f4b3a244af6693a024e1d918e6 languageName: node linkType: hard "@types/chai-as-promised@npm:^7.1.3": - version: 7.1.6 - resolution: "@types/chai-as-promised@npm:7.1.6" + version: 7.1.8 + resolution: "@types/chai-as-promised@npm:7.1.8" dependencies: "@types/chai": "*" - checksum: f765dd249ae9384540f8e6402bd3a9f5e87b97f9078ef58f4b5ec15f7c3673e1f10f0089f819eceb20e00b3df40b7aae1bd44d2b8f4edbbedfcb33ce296f6791 + checksum: f0e5eab451b91bc1e289ed89519faf6591932e8a28d2ec9bbe95826eb73d28fe43713633e0c18706f3baa560a7d97e7c7c20dc53ce639e5d75bac46b2a50bf21 languageName: node linkType: hard "@types/chai@npm:*": - version: 4.3.8 - resolution: "@types/chai@npm:4.3.8" - checksum: 21431e46fa4a5602641726a24c7631bbf7ba8a41b1a290d0c73dcef6b3521c1d973ee605236b83a978cc918e55470fd04a3109d51aa30dcdf93a8b122e6c3e2c + version: 4.3.11 + resolution: "@types/chai@npm:4.3.11" + checksum: d0c05fe5d02b2e6bbca2bd4866a2ab20a59cf729bc04af0060e7a3277eaf2fb65651b90d4c74b0ebf1d152b4b1d49fa8e44143acef276a2bbaa7785fbe5642d3 languageName: node linkType: hard "@types/cli-progress@npm:^3.11.0": - version: 3.11.3 - resolution: "@types/cli-progress@npm:3.11.3" + version: 3.11.5 + resolution: "@types/cli-progress@npm:3.11.5" dependencies: "@types/node": "*" - checksum: bc05d46091686f0d569301ad942dd25ebd7766b5ec2d7aaa5e1fc2c3b55b9a0148e8433d71e45b761e748dc4b64b6afad1ba3361e83cd3a329757d48ed430275 + checksum: 571fb3b11646415ac49c90e8003b82f3ac58d75fde5952caf40b4a079517b6e25e79ab0a7455d0ab0398d0b2de062646dba075d3d1f8d147eed2ab4d41abbf64 languageName: node linkType: hard @@ -2542,11 +2513,11 @@ __metadata: linkType: hard "@types/connect@npm:^3.4.33": - version: 3.4.36 - resolution: "@types/connect@npm:3.4.36" + version: 3.4.38 + resolution: "@types/connect@npm:3.4.38" dependencies: "@types/node": "*" - checksum: 4dee3d966fb527b98f0cbbdcf6977c9193fc3204ed539b7522fe5e64dfa45f9017bdda4ffb1f760062262fce7701a0ee1c2f6ce2e50af36c74d4e37052303172 + checksum: 7eb1bc5342a9604facd57598a6c62621e244822442976c443efb84ff745246b10d06e8b309b6e80130026a396f19bf6793b7cecd7380169f369dac3bfc46fb99 languageName: node linkType: hard @@ -2559,20 +2530,29 @@ __metadata: languageName: node linkType: hard +"@types/debug@npm:^4.1.9": + version: 4.1.12 + resolution: "@types/debug@npm:4.1.12" + dependencies: + "@types/ms": "*" + checksum: 47876a852de8240bfdaf7481357af2b88cb660d30c72e73789abf00c499d6bc7cd5e52f41c915d1b9cd8ec9fef5b05688d7b7aef17f7f272c2d04679508d1053 + languageName: node + linkType: hard + "@types/eslint@npm:^8": - version: 8.44.4 - resolution: "@types/eslint@npm:8.44.4" + version: 8.56.2 + resolution: "@types/eslint@npm:8.56.2" dependencies: "@types/estree": "*" "@types/json-schema": "*" - checksum: 15bafdaba800e2995f38d3a2a929d8e9303035315e8d3535523a21cd719b6769a45884afa955f0b845ffa545a4150429b0178e2c44feeedf59ebb285eeae9825 + checksum: 38e054971596f5c0413f66a62dc26b10e0a21ac46ceacb06fbf8cfb838d20820787209b17218b3916e4c23d990ff77cfdb482d655cac0e0d2b837d430fcc5db8 languageName: node linkType: hard "@types/estree@npm:*": - version: 1.0.2 - resolution: "@types/estree@npm:1.0.2" - checksum: aeedb1b2fe20cbe06f44b99b562bf9703e360bfcdf5bb3d61d248182ee1dd63500f2474e12f098ffe1f5ac3202b43b3e18ec99902d9328d5374f5512fa077e45 + version: 1.0.5 + resolution: "@types/estree@npm:1.0.5" + checksum: dd8b5bed28e6213b7acd0fb665a84e693554d850b0df423ac8076cc3ad5823a6bc26b0251d080bdc545af83179ede51dd3f6fa78cad2c46ed1f29624ddf3e41a languageName: node linkType: hard @@ -2596,53 +2576,53 @@ __metadata: linkType: hard "@types/graceful-fs@npm:^4.1.3": - version: 4.1.7 - resolution: "@types/graceful-fs@npm:4.1.7" + version: 4.1.9 + resolution: "@types/graceful-fs@npm:4.1.9" dependencies: "@types/node": "*" - checksum: 8b97e208f85c9efd02a6003a582c77646dd87be0af13aec9419a720771560a8a87a979eaca73ae193d7c73127f34d0a958403a9b5d6246e450289fd8c79adf09 + checksum: 79d746a8f053954bba36bd3d94a90c78de995d126289d656fb3271dd9f1229d33f678da04d10bce6be440494a5a73438e2e363e92802d16b8315b051036c5256 languageName: node linkType: hard "@types/istanbul-lib-coverage@npm:*, @types/istanbul-lib-coverage@npm:^2.0.0, @types/istanbul-lib-coverage@npm:^2.0.1": - version: 2.0.4 - resolution: "@types/istanbul-lib-coverage@npm:2.0.4" - checksum: a25d7589ee65c94d31464c16b72a9dc81dfa0bea9d3e105ae03882d616e2a0712a9c101a599ec482d297c3591e16336962878cb3eb1a0a62d5b76d277a890ce7 + version: 2.0.6 + resolution: "@types/istanbul-lib-coverage@npm:2.0.6" + checksum: 3feac423fd3e5449485afac999dcfcb3d44a37c830af898b689fadc65d26526460bedb889db278e0d4d815a670331796494d073a10ee6e3a6526301fe7415778 languageName: node linkType: hard "@types/istanbul-lib-report@npm:*": - version: 3.0.1 - resolution: "@types/istanbul-lib-report@npm:3.0.1" + version: 3.0.3 + resolution: "@types/istanbul-lib-report@npm:3.0.3" dependencies: "@types/istanbul-lib-coverage": "*" - checksum: cfc66de48577bb7b2636a6afded7056483693c3ea70916276518cdfaa0d4b51bf564ded88fb13e75716665c3af3d4d54e9c2de042c0219dcabad7e81c398688b + checksum: b91e9b60f865ff08cb35667a427b70f6c2c63e88105eadd29a112582942af47ed99c60610180aa8dcc22382fa405033f141c119c69b95db78c4c709fbadfeeb4 languageName: node linkType: hard "@types/istanbul-reports@npm:^3.0.0": - version: 3.0.2 - resolution: "@types/istanbul-reports@npm:3.0.2" + version: 3.0.4 + resolution: "@types/istanbul-reports@npm:3.0.4" dependencies: "@types/istanbul-lib-report": "*" - checksum: f52028d6fe4d28f0085dd7ed66ccfa6af632579e9a4091b90928ffef93d4dbec0bacd49e9caf1b939d05df9eafc5ac1f5939413cdf8ac59fbe4b29602d4d0939 + checksum: 93eb18835770b3431f68ae9ac1ca91741ab85f7606f310a34b3586b5a34450ec038c3eed7ab19266635499594de52ff73723a54a72a75b9f7d6a956f01edee95 languageName: node linkType: hard "@types/jest@npm:^29.5.2": - version: 29.5.5 - resolution: "@types/jest@npm:29.5.5" + version: 29.5.12 + resolution: "@types/jest@npm:29.5.12" dependencies: expect: ^29.0.0 pretty-format: ^29.0.0 - checksum: 56e55cde9949bcc0ee2fa34ce5b7c32c2bfb20e53424aa4ff3a210859eeaaa3fdf6f42f81a3f655238039cdaaaf108b054b7a8602f394e6c52b903659338d8c6 + checksum: 19b1efdeed9d9a60a81edc8226cdeae5af7479e493eaed273e01243891c9651f7b8b4c08fc633a7d0d1d379b091c4179bbaa0807af62542325fd72f2dd17ce1c languageName: node linkType: hard "@types/json-schema@npm:*, @types/json-schema@npm:^7.0.12": - version: 7.0.13 - resolution: "@types/json-schema@npm:7.0.13" - checksum: 345df21a678fa72fb389f35f33de77833d09d4a142bb2bcb27c18690efa4cf70fc2876e43843cefb3fbdb9fcb12cd3e970a90936df30f53bbee899865ff605ab + version: 7.0.15 + resolution: "@types/json-schema@npm:7.0.15" + checksum: 97ed0cb44d4070aecea772b7b2e2ed971e10c81ec87dd4ecc160322ffa55ff330dace1793489540e3e318d90942064bb697cc0f8989391797792d919737b3b98 languageName: node linkType: hard @@ -2690,12 +2670,19 @@ __metadata: languageName: node linkType: hard +"@types/ms@npm:*": + version: 0.7.34 + resolution: "@types/ms@npm:0.7.34" + checksum: f38d36e7b6edecd9badc9cf50474159e9da5fa6965a75186cceaf883278611b9df6669dc3a3cc122b7938d317b68a9e3d573d316fcb35d1be47ec9e468c6bd8a + languageName: node + linkType: hard + "@types/node@npm:*, @types/node@npm:>=13.7.0": - version: 20.8.6 - resolution: "@types/node@npm:20.8.6" + version: 20.11.19 + resolution: "@types/node@npm:20.11.19" dependencies: - undici-types: ~5.25.1 - checksum: ccfb7ac482c5a96edeb239893c5c099f5257fcc2ed9ae62fefdfbc782b79e16dbc2af9a85b379665237bf759904b44ca2be68e75d239e0297882aad42f61905c + undici-types: ~5.26.4 + checksum: 259d16643ba611ade617a8212e594a3ac014727457507389bbf7213971346ab052d870f1e6e2df0afd0876ecd7874f578bccb130be01e069263cfc7136ddc0c1 languageName: node linkType: hard @@ -2721,18 +2708,18 @@ __metadata: linkType: hard "@types/parse-json@npm:^4.0.0": - version: 4.0.0 - resolution: "@types/parse-json@npm:4.0.0" - checksum: fd6bce2b674b6efc3db4c7c3d336bd70c90838e8439de639b909ce22f3720d21344f52427f1d9e57b265fcb7f6c018699b99e5e0c208a1a4823014269a6bf35b + version: 4.0.2 + resolution: "@types/parse-json@npm:4.0.2" + checksum: 5bf62eec37c332ad10059252fc0dab7e7da730764869c980b0714777ad3d065e490627be9f40fc52f238ffa3ac4199b19de4127196910576c2fe34dd47c7a470 languageName: node linkType: hard "@types/pbkdf2@npm:^3.0.0": - version: 3.1.0 - resolution: "@types/pbkdf2@npm:3.1.0" + version: 3.1.2 + resolution: "@types/pbkdf2@npm:3.1.2" dependencies: "@types/node": "*" - checksum: d15024b1957c21cf3b8887329d9bd8dfde754cf13a09d76ae25f1391cfc62bb8b8d7b760773c5dbaa748172fba8b3e0c3dbe962af6ccbd69b76df12a48dfba40 + checksum: bebe1e596cbbe5f7d2726a58859e61986c5a42459048e29cb7f2d4d764be6bbb0844572fd5d70ca8955a8a17e8b4ed80984fc4903e165d9efb8807a3fbb051aa languageName: node linkType: hard @@ -2744,18 +2731,18 @@ __metadata: linkType: hard "@types/qrcode@npm:^1": - version: 1.5.2 - resolution: "@types/qrcode@npm:1.5.2" + version: 1.5.5 + resolution: "@types/qrcode@npm:1.5.5" dependencies: "@types/node": "*" - checksum: 2f696916e66002ecf0616451a44308b33948ce68f7ee1eae0ff8a4acc133024a3d9a7314e9dcb6455ab7f7e126963c204a687a665e3688ba39ec4ae80eb30670 + checksum: d92c1d3e77406bf13a03ec521b2ffb1ac99b2e6ea3a17cad670f2610f62e1293554c57e4074bb2fd4e9369f475f863b69e0ae8c543cb049c4a3c1b0c2d92522a languageName: node linkType: hard "@types/qs@npm:^6.2.31, @types/qs@npm:^6.9.7": - version: 6.9.8 - resolution: "@types/qs@npm:6.9.8" - checksum: c28e07d00d07970e5134c6eed184a0189b8a4649e28fdf36d9117fe671c067a44820890de6bdecef18217647a95e9c6aebdaaae69f5fe4b0bec9345db885f77e + version: 6.9.11 + resolution: "@types/qs@npm:6.9.11" + checksum: 620ca1628bf3da65662c54ed6ebb120b18a3da477d0bfcc872b696685a9bb1893c3c92b53a1190a8f54d52eaddb6af8b2157755699ac83164604329935e8a7f2 languageName: node linkType: hard @@ -2770,34 +2757,34 @@ __metadata: linkType: hard "@types/responselike@npm:^1.0.0": - version: 1.0.1 - resolution: "@types/responselike@npm:1.0.1" + version: 1.0.3 + resolution: "@types/responselike@npm:1.0.3" dependencies: "@types/node": "*" - checksum: ae8c36c9354aaedfa462dab655aa17613529d545a418acc54ba0214145fc1d0454be2ae107031a1b2c24768f19f2af7e4096a85d1e604010becd0bec2355cb0e + checksum: 6ac4b35723429b11b117e813c7acc42c3af8b5554caaf1fc750404c1ae59f9b7376bc69b9e9e194a5a97357a597c2228b7173d317320f0360d617b6425212f58 languageName: node linkType: hard "@types/secp256k1@npm:^4.0.1": - version: 4.0.4 - resolution: "@types/secp256k1@npm:4.0.4" + version: 4.0.6 + resolution: "@types/secp256k1@npm:4.0.6" dependencies: "@types/node": "*" - checksum: 6f521a08486a98e71c8529f5c3119f99e610196a47243cc6052c6160b216dff2c85dc50a8f3208ed47028dbb470bbb6fdee47a3fdc064687e46021d5a712767c + checksum: 984494caf49a4ce99fda2b9ea1840eb47af946b8c2737314108949bcc0c06b4880e871296bd49ed6ea4c8423e3a302ad79fec43abfc987330e7eb98f0c4e8ba4 languageName: node linkType: hard "@types/semver@npm:^7.5.0": - version: 7.5.3 - resolution: "@types/semver@npm:7.5.3" - checksum: 349fdd1ab6c213bac5c991bac766bd07b8b12e63762462bb058740dcd2eb09c8193d068bb226f134661275f2022976214c0e727a4e5eb83ec1b131127c980d3e + version: 7.5.7 + resolution: "@types/semver@npm:7.5.7" + checksum: 5af9b13e3d74d86d4b618f6506ccbded801fb35dbc28608cd5a7bfb8bcac0021dd35ef305a72a0c2a8def0cff60acd706bfee16a9ed1c39a893d2a175e778ea7 languageName: node linkType: hard "@types/stack-utils@npm:^2.0.0": - version: 2.0.1 - resolution: "@types/stack-utils@npm:2.0.1" - checksum: 205fdbe3326b7046d7eaf5e494d8084f2659086a266f3f9cf00bccc549c8e36e407f88168ad4383c8b07099957ad669f75f2532ed4bc70be2b037330f7bae019 + version: 2.0.3 + resolution: "@types/stack-utils@npm:2.0.3" + checksum: 72576cc1522090fe497337c2b99d9838e320659ac57fa5560fcbdcbafcf5d0216c6b3a0a8a4ee4fdb3b1f5e3420aa4f6223ab57b82fef3578bec3206425c6cf5 languageName: node linkType: hard @@ -2811,30 +2798,30 @@ __metadata: linkType: hard "@types/yargs-parser@npm:*": - version: 21.0.1 - resolution: "@types/yargs-parser@npm:21.0.1" - checksum: 64e6316c2045e2d460c4fb79572f872f9d2f98fddc6d9d3949c71f0b6ad0ef8a2706cf49db26dfb02a9cb81433abb8f340f015e1d20a9692279abe9477b72c8e + version: 21.0.3 + resolution: "@types/yargs-parser@npm:21.0.3" + checksum: ef236c27f9432983e91432d974243e6c4cdae227cb673740320eff32d04d853eed59c92ca6f1142a335cfdc0e17cccafa62e95886a8154ca8891cc2dec4ee6fc languageName: node linkType: hard "@types/yargs@npm:^17.0.8": - version: 17.0.28 - resolution: "@types/yargs@npm:17.0.28" + version: 17.0.32 + resolution: "@types/yargs@npm:17.0.32" dependencies: "@types/yargs-parser": "*" - checksum: f78c5e5c29903933c0557b4ffcd1d0b8564d66859c8ca4aa51da3714e49109ed7c2644334a1918d033df19028f4cecc91fd2e502651bb8e8451f246c371da847 + checksum: 4505bdebe8716ff383640c6e928f855b5d337cb3c68c81f7249fc6b983d0aa48de3eee26062b84f37e0d75a5797bc745e0c6e76f42f81771252a758c638f36ba languageName: node linkType: hard "@typescript-eslint/eslint-plugin@npm:latest": - version: 6.8.0 - resolution: "@typescript-eslint/eslint-plugin@npm:6.8.0" + version: 7.0.2 + resolution: "@typescript-eslint/eslint-plugin@npm:7.0.2" dependencies: "@eslint-community/regexpp": ^4.5.1 - "@typescript-eslint/scope-manager": 6.8.0 - "@typescript-eslint/type-utils": 6.8.0 - "@typescript-eslint/utils": 6.8.0 - "@typescript-eslint/visitor-keys": 6.8.0 + "@typescript-eslint/scope-manager": 7.0.2 + "@typescript-eslint/type-utils": 7.0.2 + "@typescript-eslint/utils": 7.0.2 + "@typescript-eslint/visitor-keys": 7.0.2 debug: ^4.3.4 graphemer: ^1.4.0 ignore: ^5.2.4 @@ -2842,109 +2829,117 @@ __metadata: semver: ^7.5.4 ts-api-utils: ^1.0.1 peerDependencies: - "@typescript-eslint/parser": ^6.0.0 || ^6.0.0-alpha - eslint: ^7.0.0 || ^8.0.0 + "@typescript-eslint/parser": ^7.0.0 + eslint: ^8.56.0 peerDependenciesMeta: typescript: optional: true - checksum: c36ccf606ebcaff8263c4ffa3b4cda58c6f93474b9eea9906e51be2fef8596977a245cc13770b21c6bfd38ccf45a3cf3613d5f4499429f62ec80afe15ae345bd + checksum: ec65524af6948d3ca8ee709c8eb12b086235467fa9de10e4e692d62e42ca9d8da255cec641f59e6912d7658dc9ecfc29f121e00704107d345310b71914916589 languageName: node linkType: hard "@typescript-eslint/parser@npm:latest": - version: 6.8.0 - resolution: "@typescript-eslint/parser@npm:6.8.0" + version: 7.0.2 + resolution: "@typescript-eslint/parser@npm:7.0.2" dependencies: - "@typescript-eslint/scope-manager": 6.8.0 - "@typescript-eslint/types": 6.8.0 - "@typescript-eslint/typescript-estree": 6.8.0 - "@typescript-eslint/visitor-keys": 6.8.0 + "@typescript-eslint/scope-manager": 7.0.2 + "@typescript-eslint/types": 7.0.2 + "@typescript-eslint/typescript-estree": 7.0.2 + "@typescript-eslint/visitor-keys": 7.0.2 debug: ^4.3.4 peerDependencies: - eslint: ^7.0.0 || ^8.0.0 + eslint: ^8.56.0 peerDependenciesMeta: typescript: optional: true - checksum: 10d7a3ae383fee5a5cba9541c72e23d6ab01cca6b414a62b44dacb5ebc15c80b80aa6c105b6469d3795f2f8514ae2499c069cd2d9dcac61f3db9ef6c7a75e080 + checksum: ac47105ee238f6085c281f2634579ffe2e54f3f62c8540c569536f3229b9a7ba4eeeda947461255266e8d5c4162ab4c43974d174c93591d1a16c3bb0c8123eec languageName: node linkType: hard -"@typescript-eslint/scope-manager@npm:6.8.0": - version: 6.8.0 - resolution: "@typescript-eslint/scope-manager@npm:6.8.0" +"@typescript-eslint/scope-manager@npm:7.0.2": + version: 7.0.2 + resolution: "@typescript-eslint/scope-manager@npm:7.0.2" dependencies: - "@typescript-eslint/types": 6.8.0 - "@typescript-eslint/visitor-keys": 6.8.0 - checksum: b6cf2803531d1c14b56c30fd3cd807b80e17fe48d0da8e5aa9ae50915407ed732c7e2a7ac8030b7cf8ed07b8e481a1138d76bf05b727837a0e016280c2f6873b + "@typescript-eslint/types": 7.0.2 + "@typescript-eslint/visitor-keys": 7.0.2 + checksum: e8db4d7cab296bb234c720f16b35aef6e44d94f3f0fc1565209e69aa17d2ae63fa4ad8650d77135cd45d658551072179d82d379725751a6b23d9a97f54928484 languageName: node linkType: hard -"@typescript-eslint/type-utils@npm:6.8.0": - version: 6.8.0 - resolution: "@typescript-eslint/type-utils@npm:6.8.0" +"@typescript-eslint/type-utils@npm:7.0.2": + version: 7.0.2 + resolution: "@typescript-eslint/type-utils@npm:7.0.2" dependencies: - "@typescript-eslint/typescript-estree": 6.8.0 - "@typescript-eslint/utils": 6.8.0 + "@typescript-eslint/typescript-estree": 7.0.2 + "@typescript-eslint/utils": 7.0.2 debug: ^4.3.4 ts-api-utils: ^1.0.1 peerDependencies: - eslint: ^7.0.0 || ^8.0.0 + eslint: ^8.56.0 peerDependenciesMeta: typescript: optional: true - checksum: 9b7d56904dc1a5719ef79eb1b7989d6fad10c71fb07ec3e66cf69b8c8dc5383d644ab122d4701bc4960fb7c99cc08aee4e645db3e4675d488d5779197e15dfda + checksum: 288c556dc33fea3ed3089c7075a18b7ca8b1c34dcb7530c4c31c7c0282522266fbfd2f202aae47b4b2e600a9c5fb6bd15a080aad33b2f810f647af25b0d28dea languageName: node linkType: hard -"@typescript-eslint/types@npm:6.8.0": - version: 6.8.0 - resolution: "@typescript-eslint/types@npm:6.8.0" - checksum: 1fcd85f6d575116d51c6ee757ed37610ae5e7e4296a29f93c9c6949f6cd16d24550eb7fc5bae7a43119cc08e13836f69a7ae7c54ebba6c95aef96b34d3bfb7f7 +"@typescript-eslint/types@npm:7.0.2": + version: 7.0.2 + resolution: "@typescript-eslint/types@npm:7.0.2" + checksum: 4224afa1cc2e056f3a83d9a69fd894d2b3b15eaa8319ef075066ffd8d20379983124c7663bee873b541e8a95c5dd61a5bad864eeecc7ec68968b6cb4ca70c6bd languageName: node linkType: hard -"@typescript-eslint/typescript-estree@npm:6.8.0": - version: 6.8.0 - resolution: "@typescript-eslint/typescript-estree@npm:6.8.0" +"@typescript-eslint/typescript-estree@npm:7.0.2": + version: 7.0.2 + resolution: "@typescript-eslint/typescript-estree@npm:7.0.2" dependencies: - "@typescript-eslint/types": 6.8.0 - "@typescript-eslint/visitor-keys": 6.8.0 + "@typescript-eslint/types": 7.0.2 + "@typescript-eslint/visitor-keys": 7.0.2 debug: ^4.3.4 globby: ^11.1.0 is-glob: ^4.0.3 + minimatch: 9.0.3 semver: ^7.5.4 ts-api-utils: ^1.0.1 peerDependenciesMeta: typescript: optional: true - checksum: 388db7f33ef1bc0e7b960c0bce9c744c2e32c66c7ab8dfae73d8533958202ad6f31663b0010f79c45b5ff93159c67f45b00693d73b9da2472b17156dfd26b4a8 + checksum: 3fc491081746fa0bb7ba552cdfecd7490de16867541fa6748462856a2a49a60158f65f48ce45f4ae451655ecbce840d065fc5b06d6f0f61d60d0997a2d08cdf2 languageName: node linkType: hard -"@typescript-eslint/utils@npm:6.8.0": - version: 6.8.0 - resolution: "@typescript-eslint/utils@npm:6.8.0" +"@typescript-eslint/utils@npm:7.0.2": + version: 7.0.2 + resolution: "@typescript-eslint/utils@npm:7.0.2" dependencies: "@eslint-community/eslint-utils": ^4.4.0 "@types/json-schema": ^7.0.12 "@types/semver": ^7.5.0 - "@typescript-eslint/scope-manager": 6.8.0 - "@typescript-eslint/types": 6.8.0 - "@typescript-eslint/typescript-estree": 6.8.0 + "@typescript-eslint/scope-manager": 7.0.2 + "@typescript-eslint/types": 7.0.2 + "@typescript-eslint/typescript-estree": 7.0.2 semver: ^7.5.4 peerDependencies: - eslint: ^7.0.0 || ^8.0.0 - checksum: 6d9f90db504502a9aa10e834830c3ffa25483757414670acc6141a3ebef9171a57688a3a179febf35a0e1e0b322f37228d9537bf1b279f1af7fc97888b873bc3 + eslint: ^8.56.0 + checksum: 76b067290f926cf5f955e5e4217958fec5b83f9071f92ec11c2fb1395c61c0b5481706de7ad0260669c02fa8762e18ff397a1fbba822634880f8c6f1690b957c languageName: node linkType: hard -"@typescript-eslint/visitor-keys@npm:6.8.0": - version: 6.8.0 - resolution: "@typescript-eslint/visitor-keys@npm:6.8.0" +"@typescript-eslint/visitor-keys@npm:7.0.2": + version: 7.0.2 + resolution: "@typescript-eslint/visitor-keys@npm:7.0.2" dependencies: - "@typescript-eslint/types": 6.8.0 + "@typescript-eslint/types": 7.0.2 eslint-visitor-keys: ^3.4.1 - checksum: 710d9067b85d7715a400ae625c083c41733abb891d7b35108de083913980f9642e79d27689599fa39915f0fecae16dbfc30367007fccc838ccd917943660de22 + checksum: f1f97961baa6dda9235576c0ec0c359fd157aa2336b82f46578697f6b1c0ad3a76b28bc0ac586305595aaa1b84fdaaba668e53dd24819ad184d2e1f7031353dc + languageName: node + linkType: hard + +"@ungap/structured-clone@npm:^1.2.0": + version: 1.2.0 + resolution: "@ungap/structured-clone@npm:1.2.0" + checksum: 4f656b7b4672f2ce6e272f2427d8b0824ed11546a601d8d5412b9d7704e83db38a8d9f402ecdf2b9063fc164af842ad0ec4a55819f621ed7e7ea4d1efcc74524 languageName: node linkType: hard @@ -3005,7 +3000,7 @@ __metadata: languageName: node linkType: hard -"abbrev@npm:1, abbrev@npm:^1.0.0": +"abbrev@npm:1": version: 1.1.1 resolution: "abbrev@npm:1.1.1" checksum: a4a97ec07d7ea112c517036882b2ac22f3109b7b19077dc656316d07d308438aac28e4d9746dc4d84bf6b1e75b4a7b0a5f3cb30592419f128ca9a8cee3bcfa17 @@ -3019,6 +3014,13 @@ __metadata: languageName: node linkType: hard +"abbrev@npm:^2.0.0": + version: 2.0.0 + resolution: "abbrev@npm:2.0.0" + checksum: 0e994ad2aa6575f94670d8a2149afe94465de9cedaaaac364e7fb43a40c3691c980ff74899f682f4ca58fa96b4cbd7421a015d3a6defe43a442117d7821a2f36 + languageName: node + linkType: hard + "abort-controller@npm:^3.0.0": version: 3.0.0 resolution: "abort-controller@npm:3.0.0" @@ -3028,21 +3030,6 @@ __metadata: languageName: node linkType: hard -"abstract-level@npm:^1.0.0, abstract-level@npm:^1.0.2, abstract-level@npm:^1.0.3": - version: 1.0.3 - resolution: "abstract-level@npm:1.0.3" - dependencies: - buffer: ^6.0.3 - catering: ^2.1.0 - is-buffer: ^2.0.5 - level-supports: ^4.0.0 - level-transcoder: ^1.0.1 - module-error: ^1.0.1 - queue-microtask: ^1.2.3 - checksum: 70d61a3924526ebc257b138992052f9ff571a6cee5a7660836e37a1cc7081273c3acf465dd2f5e1897b38dc743a6fd9dba14a5d8a2a9d39e5787cd3da99f301d - languageName: node - linkType: hard - "acorn-jsx@npm:^5.3.2": version: 5.3.2 resolution: "acorn-jsx@npm:5.3.2" @@ -3053,25 +3040,18 @@ __metadata: linkType: hard "acorn-walk@npm:^8.1.1": - version: 8.2.0 - resolution: "acorn-walk@npm:8.2.0" - checksum: 1715e76c01dd7b2d4ca472f9c58968516a4899378a63ad5b6c2d668bba8da21a71976c14ec5f5b75f887b6317c4ae0b897ab141c831d741dc76024d8745f1ad1 + version: 8.3.2 + resolution: "acorn-walk@npm:8.3.2" + checksum: 3626b9d26a37b1b427796feaa5261faf712307a8920392c8dce9a5739fb31077667f4ad2ec71c7ac6aaf9f61f04a9d3d67ff56f459587206fc04aa31c27ef392 languageName: node linkType: hard "acorn@npm:^8.4.1, acorn@npm:^8.9.0": - version: 8.10.0 - resolution: "acorn@npm:8.10.0" + version: 8.11.3 + resolution: "acorn@npm:8.11.3" bin: acorn: bin/acorn - checksum: 538ba38af0cc9e5ef983aee196c4b8b4d87c0c94532334fa7e065b2c8a1f85863467bb774231aae91613fcda5e68740c15d97b1967ae3394d20faddddd8af61d - languageName: node - linkType: hard - -"address@npm:^1.0.1": - version: 1.2.2 - resolution: "address@npm:1.2.2" - checksum: ace439960c1e3564d8f523aff23a841904bf33a2a7c2e064f7f60a064194075758b9690e65bd9785692a4ef698a998c57eb74d145881a1cecab8ba658ddb1607 + checksum: 76d8e7d559512566b43ab4aadc374f11f563f0a9e21626dd59cb2888444e9445923ae9f3699972767f18af61df89cd89f5eaaf772d1327b055b45cb829b4a88c languageName: node linkType: hard @@ -3089,7 +3069,7 @@ __metadata: languageName: node linkType: hard -"agent-base@npm:6, agent-base@npm:^6.0.2": +"agent-base@npm:6": version: 6.0.2 resolution: "agent-base@npm:6.0.2" dependencies: @@ -3098,12 +3078,12 @@ __metadata: languageName: node linkType: hard -"agentkeepalive@npm:^4.2.1": - version: 4.5.0 - resolution: "agentkeepalive@npm:4.5.0" +"agent-base@npm:^7.0.2, agent-base@npm:^7.1.0": + version: 7.1.0 + resolution: "agent-base@npm:7.1.0" dependencies: - humanize-ms: ^1.2.1 - checksum: 13278cd5b125e51eddd5079f04d6fe0914ac1b8b91c1f3db2c1822f99ac1a7457869068997784342fe455d59daaff22e14fb7b8c3da4e741896e7e31faf92481 + debug: ^4.3.4 + checksum: f7828f991470a0cc22cb579c86a18cbae83d8a3cbed39992ab34fc7217c4d126017f1c74d0ab66be87f71455318a8ea3e757d6a37881b8d0f2a2c6aa55e5418f languageName: node linkType: hard @@ -3148,6 +3128,15 @@ __metadata: languageName: node linkType: hard +"ansi-align@npm:^3.0.0": + version: 3.0.1 + resolution: "ansi-align@npm:3.0.1" + dependencies: + string-width: ^4.1.0 + checksum: 6abfa08f2141d231c257162b15292467081fa49a208593e055c866aa0455b57f3a86b5a678c190c618faa79b4c59e254493099cb700dd9cf2293c6be2c8f5d8d + languageName: node + linkType: hard + "ansi-colors@npm:4.1.1": version: 4.1.1 resolution: "ansi-colors@npm:4.1.1" @@ -3300,23 +3289,6 @@ __metadata: languageName: node linkType: hard -"aproba@npm:^1.0.3 || ^2.0.0": - version: 2.0.0 - resolution: "aproba@npm:2.0.0" - checksum: 5615cadcfb45289eea63f8afd064ab656006361020e1735112e346593856f87435e02d8dcc7ff0d11928bc7d425f27bc7c2a84f6c0b35ab0ff659c814c138a24 - languageName: node - linkType: hard - -"are-we-there-yet@npm:^3.0.0": - version: 3.0.1 - resolution: "are-we-there-yet@npm:3.0.1" - dependencies: - delegates: ^1.0.0 - readable-stream: ^3.6.0 - checksum: 52590c24860fa7173bedeb69a4c05fb573473e860197f618b9a28432ee4379049336727ae3a1f9c4cb083114601c1140cee578376164d0e651217a9843f9fe83 - languageName: node - linkType: hard - "arg@npm:^4.1.0": version: 4.1.3 resolution: "arg@npm:4.1.3" @@ -3354,6 +3326,16 @@ __metadata: languageName: node linkType: hard +"array-buffer-byte-length@npm:^1.0.1": + version: 1.0.1 + resolution: "array-buffer-byte-length@npm:1.0.1" + dependencies: + call-bind: ^1.0.5 + is-array-buffer: ^3.0.4 + checksum: 53524e08f40867f6a9f35318fafe467c32e45e9c682ba67b11943e167344d2febc0f6977a17e699b05699e805c3e8f073d876f8bbf1b559ed494ad2cd0fae09e + languageName: node + linkType: hard + "array-union@npm:^2.1.0": version: 2.1.0 resolution: "array-union@npm:2.1.0" @@ -3368,6 +3350,35 @@ __metadata: languageName: node linkType: hard +"array.prototype.findlast@npm:^1.2.2": + version: 1.2.4 + resolution: "array.prototype.findlast@npm:1.2.4" + dependencies: + call-bind: ^1.0.5 + define-properties: ^1.2.1 + es-abstract: ^1.22.3 + es-errors: ^1.3.0 + es-shim-unscopables: ^1.0.2 + checksum: b4c76571adf6c3cffbbbb8acd7ac39d94af6b120dd388dcf44637c22d77ba3ae13dd43d1be25d90956848fae5a01191fbdebe48ce4c0aa0989d7ee269a94a5a4 + languageName: node + linkType: hard + +"arraybuffer.prototype.slice@npm:^1.0.3": + version: 1.0.3 + resolution: "arraybuffer.prototype.slice@npm:1.0.3" + dependencies: + array-buffer-byte-length: ^1.0.1 + call-bind: ^1.0.5 + define-properties: ^1.2.1 + es-abstract: ^1.22.3 + es-errors: ^1.2.1 + get-intrinsic: ^1.2.3 + is-array-buffer: ^3.0.4 + is-shared-array-buffer: ^1.0.2 + checksum: 352259cba534dcdd969c92ab002efd2ba5025b2e3b9bead3973150edbdf0696c629d7f4b3f061c5931511e8207bdc2306da614703c820b45dabce39e3daf7e3e + languageName: node + linkType: hard + "asap@npm:~2.0.6": version: 2.0.6 resolution: "asap@npm:2.0.6" @@ -3451,9 +3462,9 @@ __metadata: linkType: hard "async@npm:^3.2.3": - version: 3.2.4 - resolution: "async@npm:3.2.4" - checksum: 43d07459a4e1d09b84a20772414aa684ff4de085cbcaec6eea3c7a8f8150e8c62aa6cd4e699fe8ee93c3a5b324e777d34642531875a0817a35697522c1b02e89 + version: 3.2.5 + resolution: "async@npm:3.2.5" + checksum: 5ec77f1312301dee02d62140a6b1f7ee0edd2a0f983b6fd2b0849b969f245225b990b47b8243e7b9ad16451a53e7f68e753700385b706198ced888beedba3af4 languageName: node linkType: hard @@ -3478,6 +3489,15 @@ __metadata: languageName: node linkType: hard +"available-typed-arrays@npm:^1.0.6, available-typed-arrays@npm:^1.0.7": + version: 1.0.7 + resolution: "available-typed-arrays@npm:1.0.7" + dependencies: + possible-typed-array-names: ^1.0.0 + checksum: 1aa3ffbfe6578276996de660848b6e95669d9a95ad149e3dd0c0cda77db6ee1dbd9d1dd723b65b6d277b882dd0c4b91a654ae9d3cf9e1254b7e93e4908d78fd3 + languageName: node + linkType: hard + "aws-sign2@npm:~0.7.0": version: 0.7.0 resolution: "aws-sign2@npm:0.7.0" @@ -3502,13 +3522,13 @@ __metadata: linkType: hard "axios@npm:^1.4.0, axios@npm:^1.5.1": - version: 1.5.1 - resolution: "axios@npm:1.5.1" + version: 1.6.7 + resolution: "axios@npm:1.6.7" dependencies: - follow-redirects: ^1.15.0 + follow-redirects: ^1.15.4 form-data: ^4.0.0 proxy-from-env: ^1.1.0 - checksum: 4444f06601f4ede154183767863d2b8e472b4a6bfc5253597ed6d21899887e1fd0ee2b3de792ac4f8459fe2e359d2aa07c216e45fd8b9e4e0688a6ebf48a5a8d + checksum: 87d4d429927d09942771f3b3a6c13580c183e31d7be0ee12f09be6d5655304996bb033d85e54be81606f4e89684df43be7bf52d14becb73a12727bf33298a082 languageName: node linkType: hard @@ -3627,7 +3647,7 @@ __metadata: languageName: node linkType: hard -"bigint-crypto-utils@npm:^3.0.23": +"bigint-crypto-utils@npm:^3.2.2": version: 3.3.0 resolution: "bigint-crypto-utils@npm:3.3.0" checksum: 9598ce57b23f776c8936d44114c9f051e62b5fa654915b664784cbcbacc5aa0485f4479571c51ff58008abb1210c0d6a234853742f07cf84bda890f2a1e01000 @@ -3744,6 +3764,22 @@ __metadata: languageName: node linkType: hard +"boxen@npm:^5.1.2": + version: 5.1.2 + resolution: "boxen@npm:5.1.2" + dependencies: + ansi-align: ^3.0.0 + camelcase: ^6.2.0 + chalk: ^4.1.0 + cli-boxes: ^2.2.1 + string-width: ^4.2.2 + type-fest: ^0.20.2 + widest-line: ^3.1.0 + wrap-ansi: ^7.0.0 + checksum: 82d03e42a72576ff235123f17b7c505372fe05c83f75f61e7d4fa4bcb393897ec95ce766fecb8f26b915f0f7a7227d66e5ec7cef43f5b2bd9d3aeed47ec55877 + languageName: node + linkType: hard + "brace-expansion@npm:^1.1.7": version: 1.1.11 resolution: "brace-expansion@npm:1.1.11" @@ -3779,18 +3815,6 @@ __metadata: languageName: node linkType: hard -"browser-level@npm:^1.0.1": - version: 1.0.1 - resolution: "browser-level@npm:1.0.1" - dependencies: - abstract-level: ^1.0.2 - catering: ^2.1.1 - module-error: ^1.0.2 - run-parallel-limit: ^1.1.0 - checksum: 67fbc77ce832940bfa25073eccff279f512ad56f545deb996a5b23b02316f5e76f4a79d381acc27eda983f5c9a2566aaf9c97e4fdd0748288c4407307537a29b - languageName: node - linkType: hard - "browser-readablestream-to-it@npm:^1.0.0, browser-readablestream-to-it@npm:^1.0.1, browser-readablestream-to-it@npm:^1.0.3": version: 1.0.3 resolution: "browser-readablestream-to-it@npm:1.0.3" @@ -3819,17 +3843,17 @@ __metadata: languageName: node linkType: hard -"browserslist@npm:^4.21.9": - version: 4.22.1 - resolution: "browserslist@npm:4.22.1" +"browserslist@npm:^4.22.2": + version: 4.23.0 + resolution: "browserslist@npm:4.23.0" dependencies: - caniuse-lite: ^1.0.30001541 - electron-to-chromium: ^1.4.535 - node-releases: ^2.0.13 + caniuse-lite: ^1.0.30001587 + electron-to-chromium: ^1.4.668 + node-releases: ^2.0.14 update-browserslist-db: ^1.0.13 bin: browserslist: cli.js - checksum: 7e6b10c53f7dd5d83fd2b95b00518889096382539fed6403829d447e05df4744088de46a571071afb447046abc3c66ad06fbc790e70234ec2517452e32ffd862 + checksum: 436f49e796782ca751ebab7edc010cfc9c29f68536f387666cd70ea22f7105563f04dd62c6ff89cb24cc3254d17cba385f979eeeb3484d43e012412ff7e75def languageName: node linkType: hard @@ -3959,33 +3983,36 @@ __metadata: languageName: node linkType: hard -"cacache@npm:^17.0.0": - version: 17.1.4 - resolution: "cacache@npm:17.1.4" +"cacache@npm:^18.0.0": + version: 18.0.2 + resolution: "cacache@npm:18.0.2" dependencies: "@npmcli/fs": ^3.1.0 fs-minipass: ^3.0.0 glob: ^10.2.2 - lru-cache: ^7.7.1 + lru-cache: ^10.0.1 minipass: ^7.0.3 - minipass-collect: ^1.0.2 + minipass-collect: ^2.0.1 minipass-flush: ^1.0.5 minipass-pipeline: ^1.2.4 p-map: ^4.0.0 ssri: ^10.0.0 tar: ^6.1.11 unique-filename: ^3.0.0 - checksum: b7751df756656954a51201335addced8f63fc53266fa56392c9f5ae83c8d27debffb4458ac2d168a744a4517ec3f2163af05c20097f93d17bdc2dc8a385e14a6 + checksum: 0250df80e1ad0c828c956744850c5f742c24244e9deb5b7dc81bca90f8c10e011e132ecc58b64497cc1cad9a98968676147fb6575f4f94722f7619757b17a11b languageName: node linkType: hard -"call-bind@npm:^1.0.0": - version: 1.0.2 - resolution: "call-bind@npm:1.0.2" +"call-bind@npm:^1.0.2, call-bind@npm:^1.0.5, call-bind@npm:^1.0.6, call-bind@npm:^1.0.7": + version: 1.0.7 + resolution: "call-bind@npm:1.0.7" dependencies: - function-bind: ^1.1.1 - get-intrinsic: ^1.0.2 - checksum: f8e31de9d19988a4b80f3e704788c4a2d6b6f3d17cfec4f57dc29ced450c53a49270dc66bf0fbd693329ee948dd33e6c90a329519aef17474a4d961e8d6426b0 + es-define-property: ^1.0.0 + es-errors: ^1.3.0 + function-bind: ^1.1.2 + get-intrinsic: ^1.2.4 + set-function-length: ^1.2.1 + checksum: 295c0c62b90dd6522e6db3b0ab1ce26bdf9e7404215bda13cfee25b626b5ff1a7761324d58d38b1ef1607fc65aca2d06e44d2e18d0dfc6c14b465b00d8660029 languageName: node linkType: hard @@ -4010,10 +4037,10 @@ __metadata: languageName: node linkType: hard -"caniuse-lite@npm:^1.0.30001541": - version: 1.0.30001549 - resolution: "caniuse-lite@npm:1.0.30001549" - checksum: 7f2abeedc8cf8b92cc0613855d71b995ce436068c0bcdd798c5af7d297ccf9f52496b00181beda42d82d25079dd4b6e389c67486156d40d8854e5707a25cb054 +"caniuse-lite@npm:^1.0.30001587": + version: 1.0.30001588 + resolution: "caniuse-lite@npm:1.0.30001588" + checksum: 2ab5fcec8fd3ee5d817a44bf1fb69804a6924d190e476863fb519692cd3e85a3a775bf4a2b6ba793f8db592ca61255b7f77f3d773ff7d42b452216f180bcdd2f languageName: node linkType: hard @@ -4029,13 +4056,6 @@ __metadata: languageName: node linkType: hard -"case@npm:^1.6.3": - version: 1.6.3 - resolution: "case@npm:1.6.3" - checksum: febe73278f910b0d28aab7efd6f51c235f9aa9e296148edb56dfb83fd58faa88308c30ce9a0122b6e53e0362c44f4407105bd5ef89c46860fc2b184e540fd68d - languageName: node - linkType: hard - "caseless@npm:^0.12.0, caseless@npm:~0.12.0": version: 0.12.0 resolution: "caseless@npm:0.12.0" @@ -4043,13 +4063,6 @@ __metadata: languageName: node linkType: hard -"catering@npm:^2.1.0, catering@npm:^2.1.1": - version: 2.1.1 - resolution: "catering@npm:2.1.1" - checksum: 205daefa69c935b0c19f3d8f2e0a520dd69aebe9bda55902958003f7c9cff8f967dfb90071b421bd6eb618576f657a89d2bc0986872c9bc04bbd66655e9d4bd6 - languageName: node - linkType: hard - "caw@npm:^2.0.0": version: 2.0.1 resolution: "caw@npm:2.0.1" @@ -4092,8 +4105,8 @@ __metadata: linkType: hard "chai@npm:^4.3.4, chai@npm:^4.3.6": - version: 4.3.10 - resolution: "chai@npm:4.3.10" + version: 4.4.1 + resolution: "chai@npm:4.4.1" dependencies: assertion-error: ^1.1.0 check-error: ^1.0.3 @@ -4102,7 +4115,7 @@ __metadata: loupe: ^2.3.6 pathval: ^1.1.1 type-detect: ^4.0.8 - checksum: 536668c60a0d985a0fbd94418028e388d243a925d7c5e858c7443e334753511614a3b6a124bac9ca077dfc4c37acc367d62f8c294960f440749536dc181dfc6d + checksum: 9ab84f36eb8e0b280c56c6c21ca4da5933132cd8a0c89c384f1497f77953640db0bc151edd47f81748240a9fab57b78f7d925edfeedc8e8fc98016d71f40c36e languageName: node linkType: hard @@ -4167,7 +4180,7 @@ __metadata: languageName: node linkType: hard -"chokidar@npm:3.5.3, chokidar@npm:^3.4.0, chokidar@npm:^3.5.2": +"chokidar@npm:3.5.3": version: 3.5.3 resolution: "chokidar@npm:3.5.3" dependencies: @@ -4186,6 +4199,25 @@ __metadata: languageName: node linkType: hard +"chokidar@npm:^3.4.0, chokidar@npm:^3.5.2": + version: 3.6.0 + resolution: "chokidar@npm:3.6.0" + dependencies: + anymatch: ~3.1.2 + braces: ~3.0.2 + fsevents: ~2.3.2 + glob-parent: ~5.1.2 + is-binary-path: ~2.1.0 + is-glob: ~4.0.1 + normalize-path: ~3.0.0 + readdirp: ~3.6.0 + dependenciesMeta: + fsevents: + optional: true + checksum: d2f29f499705dcd4f6f3bbed79a9ce2388cf530460122eed3b9c48efeab7a4e28739c6551fd15bec9245c6b9eeca7a32baa64694d64d9b6faeb74ddb8c4a413d + languageName: node + linkType: hard + "chownr@npm:^1.0.1": version: 1.1.4 resolution: "chownr@npm:1.1.4" @@ -4264,20 +4296,6 @@ __metadata: languageName: node linkType: hard -"classic-level@npm:^1.2.0": - version: 1.3.0 - resolution: "classic-level@npm:1.3.0" - dependencies: - abstract-level: ^1.0.2 - catering: ^2.1.0 - module-error: ^1.0.1 - napi-macros: ^2.2.2 - node-gyp: latest - node-gyp-build: ^4.3.0 - checksum: 773da48aef52a041115d413fee8340b357a4da2eb505764f327183b155edd7cc9d24819eb4f707c83dbdae8588024f5dddeb322125567c59d5d1f6f16334cdb9 - languageName: node - linkType: hard - "clean-stack@npm:^2.0.0": version: 2.2.0 resolution: "clean-stack@npm:2.2.0" @@ -4294,6 +4312,13 @@ __metadata: languageName: node linkType: hard +"cli-boxes@npm:^2.2.1": + version: 2.2.1 + resolution: "cli-boxes@npm:2.2.1" + checksum: be79f8ec23a558b49e01311b39a1ea01243ecee30539c880cf14bf518a12e223ef40c57ead0cb44f509bffdffc5c129c746cd50d863ab879385370112af4f585 + languageName: node + linkType: hard + "cli-cursor@npm:^3.1.0": version: 3.1.0 resolution: "cli-cursor@npm:3.1.0" @@ -4322,9 +4347,9 @@ __metadata: linkType: hard "cli-spinners@npm:^2.2.0": - version: 2.9.1 - resolution: "cli-spinners@npm:2.9.1" - checksum: 1780618be58309c469205bc315db697934bac68bce78cd5dfd46248e507a533172d623c7348ecfd904734f597ce0a4e5538684843d2cfb7af485d4466699940c + version: 2.9.2 + resolution: "cli-spinners@npm:2.9.2" + checksum: 1bd588289b28432e4676cb5d40505cfe3e53f2e4e10fbe05c8a710a154d6fe0ce7836844b00d6858f740f2ffe67cdc36e0fce9c7b6a8430e80e6388d5aa4956c languageName: node linkType: hard @@ -4438,15 +4463,6 @@ __metadata: languageName: node linkType: hard -"color-support@npm:^1.1.3": - version: 1.1.3 - resolution: "color-support@npm:1.1.3" - bin: - color-support: bin.js - checksum: 9b7356817670b9a13a26ca5af1c21615463b500783b739b7634a0c2047c16cef4b2865d7576875c31c3cddf9dd621fa19285e628f20198b233a5cfdda6d0793b - languageName: node - linkType: hard - "colorette@npm:^2.0.20": version: 2.0.20 resolution: "colorette@npm:2.0.20" @@ -4558,13 +4574,6 @@ __metadata: languageName: node linkType: hard -"console-control-strings@npm:^1.1.0": - version: 1.1.0 - resolution: "console-control-strings@npm:1.1.0" - checksum: 8755d76787f94e6cf79ce4666f0c5519906d7f5b02d4b884cf41e11dcd759ed69c57da0670afd9236d229a46e0f9cf519db0cd829c6dca820bb5a5c3def584ed - languageName: node - linkType: hard - "content-disposition@npm:^0.5.2": version: 0.5.4 resolution: "content-disposition@npm:0.5.4" @@ -4615,15 +4624,6 @@ __metadata: languageName: node linkType: hard -"crc-32@npm:^1.2.0": - version: 1.2.2 - resolution: "crc-32@npm:1.2.2" - bin: - crc32: bin/crc32.njs - checksum: ad2d0ad0cbd465b75dcaeeff0600f8195b686816ab5f3ba4c6e052a07f728c3e70df2e3ca9fd3d4484dc4ba70586e161ca5a2334ec8bf5a41bf022a6103ff243 - languageName: node - linkType: hard - "create-hash@npm:^1.1.0, create-hash@npm:^1.1.2, create-hash@npm:^1.2.0": version: 1.2.0 resolution: "create-hash@npm:1.2.0" @@ -4891,6 +4891,28 @@ __metadata: languageName: node linkType: hard +"define-data-property@npm:^1.0.1, define-data-property@npm:^1.1.2, define-data-property@npm:^1.1.4": + version: 1.1.4 + resolution: "define-data-property@npm:1.1.4" + dependencies: + es-define-property: ^1.0.0 + es-errors: ^1.3.0 + gopd: ^1.0.1 + checksum: 8068ee6cab694d409ac25936eb861eea704b7763f7f342adbdfe337fc27c78d7ae0eff2364b2917b58c508d723c7a074326d068eef2e45c4edcd85cf94d0313b + languageName: node + linkType: hard + +"define-properties@npm:^1.1.3, define-properties@npm:^1.2.0, define-properties@npm:^1.2.1": + version: 1.2.1 + resolution: "define-properties@npm:1.2.1" + dependencies: + define-data-property: ^1.0.1 + has-property-descriptors: ^1.0.0 + object-keys: ^1.1.1 + checksum: b4ccd00597dd46cb2d4a379398f5b19fca84a16f3374e2249201992f36b30f6835949a9429669ee6b41b6e837205a163eadd745e472069e70dfc10f03e5fcc12 + languageName: node + linkType: hard + "delay@npm:^5.0.0": version: 5.0.0 resolution: "delay@npm:5.0.0" @@ -4905,13 +4927,6 @@ __metadata: languageName: node linkType: hard -"delegates@npm:^1.0.0": - version: 1.0.0 - resolution: "delegates@npm:1.0.0" - checksum: a51744d9b53c164ba9c0492471a1a2ffa0b6727451bdc89e31627fdf4adda9d51277cfcbfb20f0a6f08ccb3c436f341df3e92631a3440226d93a8971724771fd - languageName: node - linkType: hard - "depd@npm:2.0.0": version: 2.0.0 resolution: "depd@npm:2.0.0" @@ -4926,19 +4941,6 @@ __metadata: languageName: node linkType: hard -"detect-port@npm:^1.3.0": - version: 1.5.1 - resolution: "detect-port@npm:1.5.1" - dependencies: - address: ^1.0.1 - debug: 4 - bin: - detect: bin/detect-port.js - detect-port: bin/detect-port.js - checksum: b48da9340481742547263d5d985e65d078592557863402ecf538511735e83575867e94f91fe74405ea19b61351feb99efccae7e55de9a151d5654e3417cea05b - languageName: node - linkType: hard - "diff-sequences@npm:^29.6.3": version: 29.6.3 resolution: "diff-sequences@npm:29.6.3" @@ -5038,9 +5040,9 @@ __metadata: linkType: hard "dotenv@npm:^16.0.3": - version: 16.3.1 - resolution: "dotenv@npm:16.3.1" - checksum: 15d75e7279018f4bafd0ee9706593dd14455ddb71b3bcba9c52574460b7ccaf67d5cf8b2c08a5af1a9da6db36c956a04a1192b101ee102a3e0cf8817bbcf3dfd + version: 16.4.5 + resolution: "dotenv@npm:16.4.5" + checksum: 301a12c3d44fd49888b74eb9ccf9f07a1f5df43f489e7fcb89647a2edcd84c42d6bc349dc8df099cd18f07c35c7b04685c1a4f3e6a6a9e6b30f8d48c15b7f49c languageName: node linkType: hard @@ -5114,10 +5116,10 @@ __metadata: languageName: node linkType: hard -"electron-to-chromium@npm:^1.4.535": - version: 1.4.556 - resolution: "electron-to-chromium@npm:1.4.556" - checksum: 8c9aa48776d80c23d8709dcd4342f1b18ca5b63bdb233fb6913f0db7b382d69afa84d5f08ead84bde6378a6a7ab3d1127f7cb6f4d0642fa625e96de6559dc1d7 +"electron-to-chromium@npm:^1.4.668": + version: 1.4.677 + resolution: "electron-to-chromium@npm:1.4.677" + checksum: 19c89cf911ee476a66718efb1d2b9047639259cc7e8674ee804023e4bac6c70ff1eb35a146b2d54c38fc56047060fd1eacf4c00f870fefa4272813fe09d42319 languageName: node linkType: hard @@ -5209,11 +5211,11 @@ __metadata: linkType: hard "envfile@npm:^6.18.0": - version: 6.18.0 - resolution: "envfile@npm:6.18.0" + version: 6.22.0 + resolution: "envfile@npm:6.22.0" bin: envfile: bin.cjs - checksum: 3a3762994d7b84ccf0293c1269cdfa5ea8971bdbbf7e3571fb686a6415eee2029e43d3faf36ed4222a83eaaf38fbc4fa37b3f50b77ea417ca35561e0e54059c1 + checksum: 95e29f82be5f1365bf3dc3b324576c5df69fbc9b28238cf876cff08124307693e49cf0d9df6ba8735d42b35b6f59ec01fda28435b839319652e9618a1430aa6b languageName: node linkType: hard @@ -5240,6 +5242,102 @@ __metadata: languageName: node linkType: hard +"es-abstract@npm:^1.22.1, es-abstract@npm:^1.22.3": + version: 1.22.4 + resolution: "es-abstract@npm:1.22.4" + dependencies: + array-buffer-byte-length: ^1.0.1 + arraybuffer.prototype.slice: ^1.0.3 + available-typed-arrays: ^1.0.6 + call-bind: ^1.0.7 + es-define-property: ^1.0.0 + es-errors: ^1.3.0 + es-set-tostringtag: ^2.0.2 + es-to-primitive: ^1.2.1 + function.prototype.name: ^1.1.6 + get-intrinsic: ^1.2.4 + get-symbol-description: ^1.0.2 + globalthis: ^1.0.3 + gopd: ^1.0.1 + has-property-descriptors: ^1.0.2 + has-proto: ^1.0.1 + has-symbols: ^1.0.3 + hasown: ^2.0.1 + internal-slot: ^1.0.7 + is-array-buffer: ^3.0.4 + is-callable: ^1.2.7 + is-negative-zero: ^2.0.2 + is-regex: ^1.1.4 + is-shared-array-buffer: ^1.0.2 + is-string: ^1.0.7 + is-typed-array: ^1.1.13 + is-weakref: ^1.0.2 + object-inspect: ^1.13.1 + object-keys: ^1.1.1 + object.assign: ^4.1.5 + regexp.prototype.flags: ^1.5.2 + safe-array-concat: ^1.1.0 + safe-regex-test: ^1.0.3 + string.prototype.trim: ^1.2.8 + string.prototype.trimend: ^1.0.7 + string.prototype.trimstart: ^1.0.7 + typed-array-buffer: ^1.0.1 + typed-array-byte-length: ^1.0.0 + typed-array-byte-offset: ^1.0.0 + typed-array-length: ^1.0.4 + unbox-primitive: ^1.0.2 + which-typed-array: ^1.1.14 + checksum: c254102395bd59315b713d72a1ce07980c0f71c9edcac6b036868740789ab5344020e940d6321fc1b31aecf6b27941fdd9655b602696e08f170986dd4d75ddc6 + languageName: node + linkType: hard + +"es-define-property@npm:^1.0.0": + version: 1.0.0 + resolution: "es-define-property@npm:1.0.0" + dependencies: + get-intrinsic: ^1.2.4 + checksum: f66ece0a887b6dca71848fa71f70461357c0e4e7249696f81bad0a1f347eed7b31262af4a29f5d726dc026426f085483b6b90301855e647aa8e21936f07293c6 + languageName: node + linkType: hard + +"es-errors@npm:^1.2.1, es-errors@npm:^1.3.0": + version: 1.3.0 + resolution: "es-errors@npm:1.3.0" + checksum: ec1414527a0ccacd7f15f4a3bc66e215f04f595ba23ca75cdae0927af099b5ec865f9f4d33e9d7e86f512f252876ac77d4281a7871531a50678132429b1271b5 + languageName: node + linkType: hard + +"es-set-tostringtag@npm:^2.0.2": + version: 2.0.3 + resolution: "es-set-tostringtag@npm:2.0.3" + dependencies: + get-intrinsic: ^1.2.4 + has-tostringtag: ^1.0.2 + hasown: ^2.0.1 + checksum: 7227fa48a41c0ce83e0377b11130d324ac797390688135b8da5c28994c0165be8b252e15cd1de41e1325e5a5412511586960213e88f9ab4a5e7d028895db5129 + languageName: node + linkType: hard + +"es-shim-unscopables@npm:^1.0.2": + version: 1.0.2 + resolution: "es-shim-unscopables@npm:1.0.2" + dependencies: + hasown: ^2.0.0 + checksum: 432bd527c62065da09ed1d37a3f8e623c423683285e6188108286f4a1e8e164a5bcbfbc0051557c7d14633cd2a41ce24c7048e6bbb66a985413fd32f1be72626 + languageName: node + linkType: hard + +"es-to-primitive@npm:^1.2.1": + version: 1.2.1 + resolution: "es-to-primitive@npm:1.2.1" + dependencies: + is-callable: ^1.1.4 + is-date-object: ^1.0.1 + is-symbol: ^1.0.2 + checksum: 4ead6671a2c1402619bdd77f3503991232ca15e17e46222b0a41a5d81aebc8740a77822f5b3c965008e631153e9ef0580540007744521e72de8e33599fca2eed + languageName: node + linkType: hard + "es6-promise@npm:^4.0.3": version: 4.2.8 resolution: "es6-promise@npm:4.2.8" @@ -5257,9 +5355,9 @@ __metadata: linkType: hard "escalade@npm:^3.1.1": - version: 3.1.1 - resolution: "escalade@npm:3.1.1" - checksum: a3e2a99f07acb74b3ad4989c48ca0c3140f69f923e56d0cba0526240ee470b91010f9d39001f2a4a313841d237ede70a729e92125191ba5d21e74b106800b133 + version: 3.1.2 + resolution: "escalade@npm:3.1.2" + checksum: 1ec0977aa2772075493002bdbd549d595ff6e9393b1cb0d7d6fcaf78c750da0c158f180938365486f75cb69fba20294351caddfce1b46552a7b6c3cde52eaa02 languageName: node linkType: hard @@ -5347,16 +5445,17 @@ __metadata: linkType: hard "eslint@npm:^8.26.0": - version: 8.51.0 - resolution: "eslint@npm:8.51.0" + version: 8.56.0 + resolution: "eslint@npm:8.56.0" dependencies: "@eslint-community/eslint-utils": ^4.2.0 "@eslint-community/regexpp": ^4.6.1 - "@eslint/eslintrc": ^2.1.2 - "@eslint/js": 8.51.0 - "@humanwhocodes/config-array": ^0.11.11 + "@eslint/eslintrc": ^2.1.4 + "@eslint/js": 8.56.0 + "@humanwhocodes/config-array": ^0.11.13 "@humanwhocodes/module-importer": ^1.0.1 "@nodelib/fs.walk": ^1.2.8 + "@ungap/structured-clone": ^1.2.0 ajv: ^6.12.4 chalk: ^4.0.0 cross-spawn: ^7.0.2 @@ -5389,7 +5488,7 @@ __metadata: text-table: ^0.2.0 bin: eslint: bin/eslint.js - checksum: 214fa5d1fcb67af1b8992ce9584ccd85e1aa7a482f8b8ea5b96edc28fa838a18a3b69456db45fc1ed3ef95f1e9efa9714f737292dc681e572d471d02fda9649c + checksum: 883436d1e809b4a25d9eb03d42f584b84c408dbac28b0019f6ea07b5177940bf3cca86208f749a6a1e0039b63e085ee47aca1236c30721e91f0deef5cc5a5136 languageName: node linkType: hard @@ -5534,14 +5633,14 @@ __metadata: linkType: hard "ethereum-cryptography@npm:^2.0.0, ethereum-cryptography@npm:^2.1.2": - version: 2.1.2 - resolution: "ethereum-cryptography@npm:2.1.2" + version: 2.1.3 + resolution: "ethereum-cryptography@npm:2.1.3" dependencies: - "@noble/curves": 1.1.0 - "@noble/hashes": 1.3.1 - "@scure/bip32": 1.3.1 - "@scure/bip39": 1.2.1 - checksum: 2e8f7b8cc90232ae838ab6a8167708e8362621404d26e79b5d9e762c7b53d699f7520aff358d9254de658fcd54d2d0af168ff909943259ed27dc4cef2736410c + "@noble/curves": 1.3.0 + "@noble/hashes": 1.3.3 + "@scure/bip32": 1.3.3 + "@scure/bip39": 1.2.2 + checksum: 7f9c14f868a588641179cace3eb86c332c4743290865db699870710253cabc4dc74bd4bce5e7bc6db667482e032e94d6f79521219eb6be5dc422059d279a27b7 languageName: node linkType: hard @@ -5836,15 +5935,15 @@ __metadata: linkType: hard "fast-glob@npm:^3.0.3, fast-glob@npm:^3.2.9": - version: 3.3.1 - resolution: "fast-glob@npm:3.3.1" + version: 3.3.2 + resolution: "fast-glob@npm:3.3.2" dependencies: "@nodelib/fs.stat": ^2.0.2 "@nodelib/fs.walk": ^1.2.3 glob-parent: ^5.1.2 merge2: ^1.3.0 micromatch: ^4.0.4 - checksum: b6f3add6403e02cf3a798bfbb1183d0f6da2afd368f27456010c0bc1f9640aea308243d4cb2c0ab142f618276e65ecb8be1661d7c62a7b4e5ba774b9ce5432e5 + checksum: 900e4979f4dbc3313840078419245621259f349950411ca2fa445a2f9a1a6d98c3b5e7e0660c5ccd563aa61abe133a21765c6c0dec8e57da1ba71d8000b05ec1 languageName: node linkType: hard @@ -5881,11 +5980,11 @@ __metadata: linkType: hard "fastq@npm:^1.6.0": - version: 1.15.0 - resolution: "fastq@npm:1.15.0" + version: 1.17.1 + resolution: "fastq@npm:1.17.1" dependencies: reusify: ^1.0.4 - checksum: 0170e6bfcd5d57a70412440b8ef600da6de3b2a6c5966aeaf0a852d542daff506a0ee92d6de7679d1de82e644bce69d7a574a6c93f0b03964b5337eed75ada1a + checksum: a8c5b26788d5a1763f88bae56a8ddeee579f935a831c5fe7a8268cea5b0a91fbfe705f612209e02d639b881d7b48e461a50da4a10cfaa40da5ca7cc9da098d88 languageName: node linkType: hard @@ -6012,13 +6111,13 @@ __metadata: linkType: hard "flat-cache@npm:^3.0.4": - version: 3.1.1 - resolution: "flat-cache@npm:3.1.1" + version: 3.2.0 + resolution: "flat-cache@npm:3.2.0" dependencies: flatted: ^3.2.9 keyv: ^4.5.3 rimraf: ^3.0.2 - checksum: 4958cfe0f46acf84953d4e16676ef5f0d38eab3a92d532a1e8d5f88f11eea8b36d5d598070ff2aeae15f1fde18f8d7d089eefaf9db10b5a587cc1c9072325c7a + checksum: e7e0f59801e288b54bee5cb9681e9ee21ee28ef309f886b312c9d08415b79fc0f24ac842f84356ce80f47d6a53de62197ce0e6e148dc42d5db005992e2a756ec languageName: node linkType: hard @@ -6032,9 +6131,9 @@ __metadata: linkType: hard "flatted@npm:^3.2.9": - version: 3.2.9 - resolution: "flatted@npm:3.2.9" - checksum: f14167fbe26a9d20f6fca8d998e8f1f41df72c8e81f9f2c9d61ed2bea058248f5e1cbd05e7f88c0e5087a6a0b822a1e5e2b446e879f3cfbe0b07ba2d7f80b026 + version: 3.3.0 + resolution: "flatted@npm:3.3.0" + checksum: 8f641ab894d7d3b8282e57f582a947efd1abd2ae95c4e5e4125abe2ca9b98c874c1e1a4b38b1ba3f244cd77901ba3b93fddd79d360568bb30347d1c6d7b3c796 languageName: node linkType: hard @@ -6047,13 +6146,22 @@ __metadata: languageName: node linkType: hard -"follow-redirects@npm:^1.12.1, follow-redirects@npm:^1.14.0, follow-redirects@npm:^1.15.0": - version: 1.15.3 - resolution: "follow-redirects@npm:1.15.3" +"follow-redirects@npm:^1.12.1, follow-redirects@npm:^1.14.0, follow-redirects@npm:^1.15.4": + version: 1.15.5 + resolution: "follow-redirects@npm:1.15.5" peerDependenciesMeta: debug: optional: true - checksum: 584da22ec5420c837bd096559ebfb8fe69d82512d5585004e36a3b4a6ef6d5905780e0c74508c7b72f907d1fa2b7bd339e613859e9c304d0dc96af2027fd0231 + checksum: 5ca49b5ce6f44338cbfc3546823357e7a70813cecc9b7b768158a1d32c1e62e7407c944402a918ea8c38ae2e78266312d617dc68783fac502cbb55e1047b34ec + languageName: node + linkType: hard + +"for-each@npm:^0.3.3": + version: 0.3.3 + resolution: "for-each@npm:0.3.3" + dependencies: + is-callable: ^1.1.3 + checksum: 6c48ff2bc63362319c65e2edca4a8e1e3483a2fabc72fbe7feaf8c73db94fc7861bd53bc02c8a66a0c1dd709da6b04eec42e0abdd6b40ce47305ae92a25e5d28 languageName: node linkType: hard @@ -6247,33 +6355,29 @@ __metadata: languageName: node linkType: hard -"function-bind@npm:^1.1.1": +"function-bind@npm:^1.1.2": version: 1.1.2 resolution: "function-bind@npm:1.1.2" checksum: 2b0ff4ce708d99715ad14a6d1f894e2a83242e4a52ccfcefaee5e40050562e5f6dafc1adbb4ce2d4ab47279a45dc736ab91ea5042d843c3c092820dfe032efb1 languageName: node linkType: hard -"functional-red-black-tree@npm:^1.0.1": - version: 1.0.1 - resolution: "functional-red-black-tree@npm:1.0.1" - checksum: ca6c170f37640e2d94297da8bb4bf27a1d12bea3e00e6a3e007fd7aa32e37e000f5772acf941b4e4f3cf1c95c3752033d0c509af157ad8f526e7f00723b9eb9f +"function.prototype.name@npm:^1.1.6": + version: 1.1.6 + resolution: "function.prototype.name@npm:1.1.6" + dependencies: + call-bind: ^1.0.2 + define-properties: ^1.2.0 + es-abstract: ^1.22.1 + functions-have-names: ^1.2.3 + checksum: 7a3f9bd98adab09a07f6e1f03da03d3f7c26abbdeaeee15223f6c04a9fb5674792bdf5e689dac19b97ac71de6aad2027ba3048a9b883aa1b3173eed6ab07f479 languageName: node linkType: hard -"gauge@npm:^4.0.3": - version: 4.0.4 - resolution: "gauge@npm:4.0.4" - dependencies: - aproba: ^1.0.3 || ^2.0.0 - color-support: ^1.1.3 - console-control-strings: ^1.1.0 - has-unicode: ^2.0.1 - signal-exit: ^3.0.7 - string-width: ^4.2.3 - strip-ansi: ^6.0.1 - wide-align: ^1.1.5 - checksum: 788b6bfe52f1dd8e263cda800c26ac0ca2ff6de0b6eee2fe0d9e3abf15e149b651bd27bf5226be10e6e3edb5c4e5d5985a5a1a98137e7a892f75eff76467ad2d +"functions-have-names@npm:^1.2.3": + version: 1.2.3 + resolution: "functions-have-names@npm:1.2.3" + checksum: c3f1f5ba20f4e962efb71344ce0a40722163e85bee2101ce25f88214e78182d2d2476aa85ef37950c579eb6cf6ee811c17b3101bb84004bb75655f3e33f3fdb5 languageName: node linkType: hard @@ -6298,15 +6402,16 @@ __metadata: languageName: node linkType: hard -"get-intrinsic@npm:^1.0.2": - version: 1.2.1 - resolution: "get-intrinsic@npm:1.2.1" +"get-intrinsic@npm:^1.1.3, get-intrinsic@npm:^1.2.1, get-intrinsic@npm:^1.2.2, get-intrinsic@npm:^1.2.3, get-intrinsic@npm:^1.2.4": + version: 1.2.4 + resolution: "get-intrinsic@npm:1.2.4" dependencies: - function-bind: ^1.1.1 - has: ^1.0.3 + es-errors: ^1.3.0 + function-bind: ^1.1.2 has-proto: ^1.0.1 has-symbols: ^1.0.3 - checksum: 5b61d88552c24b0cf6fa2d1b3bc5459d7306f699de060d76442cce49a4721f52b8c560a33ab392cf5575b7810277d54ded9d4d39a1ea61855619ebc005aa7e5f + hasown: ^2.0.0 + checksum: 414e3cdf2c203d1b9d7d33111df746a4512a1aa622770b361dadddf8ed0b5aeb26c560f49ca077e24bfafb0acb55ca908d1f709216ccba33ffc548ec8a79a951 languageName: node linkType: hard @@ -6373,6 +6478,17 @@ __metadata: languageName: node linkType: hard +"get-symbol-description@npm:^1.0.2": + version: 1.0.2 + resolution: "get-symbol-description@npm:1.0.2" + dependencies: + call-bind: ^1.0.5 + es-errors: ^1.3.0 + get-intrinsic: ^1.2.4 + checksum: e1cb53bc211f9dbe9691a4f97a46837a553c4e7caadd0488dc24ac694db8a390b93edd412b48dcdd0b4bbb4c595de1709effc75fc87c0839deedc6968f5bd973 + languageName: node + linkType: hard + "getpass@npm:^0.1.1": version: 0.1.7 resolution: "getpass@npm:0.1.7" @@ -6440,6 +6556,19 @@ __metadata: languageName: node linkType: hard +"glob@npm:8.1.0": + version: 8.1.0 + resolution: "glob@npm:8.1.0" + dependencies: + fs.realpath: ^1.0.0 + inflight: ^1.0.4 + inherits: 2 + minimatch: ^5.0.1 + once: ^1.3.0 + checksum: 92fbea3221a7d12075f26f0227abac435de868dd0736a17170663783296d0dd8d3d532a5672b4488a439bf5d7fb85cdd07c11185d6cd39184f0385cbdfb86a47 + languageName: node + linkType: hard + "glob@npm:9.3.4": version: 9.3.4 resolution: "glob@npm:9.3.4" @@ -6452,7 +6581,7 @@ __metadata: languageName: node linkType: hard -"glob@npm:^10.2.2": +"glob@npm:^10.2.2, glob@npm:^10.3.10": version: 10.3.10 resolution: "glob@npm:10.3.10" dependencies: @@ -6522,11 +6651,20 @@ __metadata: linkType: hard "globals@npm:^13.19.0": - version: 13.23.0 - resolution: "globals@npm:13.23.0" + version: 13.24.0 + resolution: "globals@npm:13.24.0" dependencies: type-fest: ^0.20.2 - checksum: 194c97cf8d1ef6ba59417234c2386549c4103b6e5f24b1ff1952de61a4753e5d2069435ba629de711a6480b1b1d114a98e2ab27f85e966d5a10c319c3bbd3dc3 + checksum: 56066ef058f6867c04ff203b8a44c15b038346a62efbc3060052a1016be9f56f4cf0b2cd45b74b22b81e521a889fc7786c73691b0549c2f3a6e825b3d394f43c + languageName: node + linkType: hard + +"globalthis@npm:^1.0.3": + version: 1.0.3 + resolution: "globalthis@npm:1.0.3" + dependencies: + define-properties: ^1.1.3 + checksum: fbd7d760dc464c886d0196166d92e5ffb4c84d0730846d6621a39fbbc068aeeb9c8d1421ad330e94b7bca4bb4ea092f5f21f3d36077812af5d098b4dc006c998 languageName: node linkType: hard @@ -6601,6 +6739,15 @@ __metadata: languageName: node linkType: hard +"gopd@npm:^1.0.1": + version: 1.0.1 + resolution: "gopd@npm:1.0.1" + dependencies: + get-intrinsic: ^1.1.3 + checksum: a5ccfb8806e0917a94e0b3de2af2ea4979c1da920bc381667c260e00e7cafdbe844e2cb9c5bcfef4e5412e8bf73bab837285bc35c7ba73aaaf0134d4583393a6 + languageName: node + linkType: hard + "got@npm:^7.0.0": version: 7.1.0 resolution: "got@npm:7.1.0" @@ -6672,7 +6819,7 @@ __metadata: languageName: node linkType: hard -"handlebars@npm:^4.0.1": +"handlebars@npm:^4.0.1, handlebars@npm:^4.7.7": version: 4.7.8 resolution: "handlebars@npm:4.7.8" dependencies: @@ -6720,8 +6867,8 @@ __metadata: linkType: hard "hardhat-deploy@npm:^0.11.25": - version: 0.11.43 - resolution: "hardhat-deploy@npm:0.11.43" + version: 0.11.45 + resolution: "hardhat-deploy@npm:0.11.45" dependencies: "@ethersproject/abi": ^5.7.0 "@ethersproject/abstract-signer": ^5.7.0 @@ -6747,20 +6894,20 @@ __metadata: murmur-128: ^0.2.1 qs: ^6.9.4 zksync-web3: ^0.14.3 - checksum: 498c9b1485fa73161cef24eeeaaab749097df8c5a53df3f22e3c23cb825adf3006289778f0f5a433a7efcd58df3e18034f09dd4650d714d8f0b08c1e79527590 + checksum: 7ecce33c3305857bdd1873a25d391e27ae9f581df75757035cb028ace7bb5fbb83f053435e843bc3d925e7fd8412c3dc582797fe5b4bbe1fef7f3dd989a7c878 languageName: node linkType: hard "hardhat-gas-reporter@npm:^1.0.9": - version: 1.0.9 - resolution: "hardhat-gas-reporter@npm:1.0.9" + version: 1.0.10 + resolution: "hardhat-gas-reporter@npm:1.0.10" dependencies: array-uniq: 1.0.3 eth-gas-reporter: ^0.2.25 sha1: ^1.1.1 peerDependencies: hardhat: ^2.0.2 - checksum: 77f8f8d085ff3d9d7787f0227e5355e1800f7d6707bc70171e0567bf69706703ae7f6f53dce1be1d409e7e71e3629a434c94b546bdbbc1e4c1af47cd5d0c6776 + checksum: caaec13ab3fcda47b8768257e4416b5fd0e8ef3aca5369aa8195419d3d4a948cc182075333651df44215cfc629d088f5ed9f762c8c14ae5a4b4a4f2613e583d0 languageName: node linkType: hard @@ -6774,21 +6921,22 @@ __metadata: linkType: hard "hardhat@npm:^2.11.2": - version: 2.18.1 - resolution: "hardhat@npm:2.18.1" + version: 2.20.1 + resolution: "hardhat@npm:2.20.1" dependencies: "@ethersproject/abi": ^5.1.2 "@metamask/eth-sig-util": ^4.0.0 - "@nomicfoundation/ethereumjs-block": 5.0.2 - "@nomicfoundation/ethereumjs-blockchain": 7.0.2 - "@nomicfoundation/ethereumjs-common": 4.0.2 - "@nomicfoundation/ethereumjs-evm": 2.0.2 - "@nomicfoundation/ethereumjs-rlp": 5.0.2 - "@nomicfoundation/ethereumjs-statemanager": 2.0.2 - "@nomicfoundation/ethereumjs-trie": 6.0.2 - "@nomicfoundation/ethereumjs-tx": 5.0.2 - "@nomicfoundation/ethereumjs-util": 9.0.2 - "@nomicfoundation/ethereumjs-vm": 7.0.2 + "@nomicfoundation/ethereumjs-block": 5.0.4 + "@nomicfoundation/ethereumjs-blockchain": 7.0.4 + "@nomicfoundation/ethereumjs-common": 4.0.4 + "@nomicfoundation/ethereumjs-evm": 2.0.4 + "@nomicfoundation/ethereumjs-rlp": 5.0.4 + "@nomicfoundation/ethereumjs-statemanager": 2.0.4 + "@nomicfoundation/ethereumjs-trie": 6.0.4 + "@nomicfoundation/ethereumjs-tx": 5.0.4 + "@nomicfoundation/ethereumjs-util": 9.0.4 + "@nomicfoundation/ethereumjs-verkle": 0.0.2 + "@nomicfoundation/ethereumjs-vm": 7.0.4 "@nomicfoundation/solidity-analyzer": ^0.1.0 "@sentry/node": ^5.18.1 "@types/bn.js": ^5.1.0 @@ -6796,6 +6944,7 @@ __metadata: adm-zip: ^0.4.16 aggregate-error: ^3.0.0 ansi-escapes: ^4.3.0 + boxen: ^5.1.2 chalk: ^2.4.2 chokidar: ^3.4.0 ci-info: ^2.0.0 @@ -6835,7 +6984,14 @@ __metadata: optional: true bin: hardhat: internal/cli/bootstrap.js - checksum: 34a6b4f27e4412e8878c8612a36c92ae79acea5168514bddb7eb4654be5ea92e19f4b2618e8e789361c8f54eaf10ebe6469042c22bbaae66254e5e3a5a63c3b1 + checksum: 191f2878f18740a59afa9afa3486487a6e2c7c57d54410779349a40a1046117b6329a151f6e66bba0c2a94b15f9880f38a1e4d7053c33eca022a3de5669326e8 + languageName: node + linkType: hard + +"has-bigints@npm:^1.0.1, has-bigints@npm:^1.0.2": + version: 1.0.2 + resolution: "has-bigints@npm:1.0.2" + checksum: 390e31e7be7e5c6fe68b81babb73dfc35d413604d7ee5f56da101417027a4b4ce6a27e46eff97ad040c835b5d228676eae99a9b5c3bc0e23c8e81a49241ff45b languageName: node linkType: hard @@ -6860,10 +7016,19 @@ __metadata: languageName: node linkType: hard -"has-proto@npm:^1.0.1": - version: 1.0.1 - resolution: "has-proto@npm:1.0.1" - checksum: febc5b5b531de8022806ad7407935e2135f1cc9e64636c3916c6842bd7995994ca3b29871ecd7954bd35f9e2986c17b3b227880484d22259e2f8e6ce63fd383e +"has-property-descriptors@npm:^1.0.0, has-property-descriptors@npm:^1.0.1, has-property-descriptors@npm:^1.0.2": + version: 1.0.2 + resolution: "has-property-descriptors@npm:1.0.2" + dependencies: + es-define-property: ^1.0.0 + checksum: fcbb246ea2838058be39887935231c6d5788babed499d0e9d0cc5737494c48aba4fe17ba1449e0d0fbbb1e36175442faa37f9c427ae357d6ccb1d895fbcd3de3 + languageName: node + linkType: hard + +"has-proto@npm:^1.0.1, has-proto@npm:^1.0.3": + version: 1.0.3 + resolution: "has-proto@npm:1.0.3" + checksum: fe7c3d50b33f50f3933a04413ed1f69441d21d2d2944f81036276d30635cad9279f6b43bc8f32036c31ebdfcf6e731150f46c1907ad90c669ffe9b066c3ba5c4 languageName: node linkType: hard @@ -6874,7 +7039,7 @@ __metadata: languageName: node linkType: hard -"has-symbols@npm:^1.0.3": +"has-symbols@npm:^1.0.2, has-symbols@npm:^1.0.3": version: 1.0.3 resolution: "has-symbols@npm:1.0.3" checksum: a054c40c631c0d5741a8285010a0777ea0c068f99ed43e5d6eb12972da223f8af553a455132fdb0801bdcfa0e0f443c0c03a68d8555aa529b3144b446c3f2410 @@ -6890,17 +7055,12 @@ __metadata: languageName: node linkType: hard -"has-unicode@npm:^2.0.1": - version: 2.0.1 - resolution: "has-unicode@npm:2.0.1" - checksum: 1eab07a7436512db0be40a710b29b5dc21fa04880b7f63c9980b706683127e3c1b57cb80ea96d47991bdae2dfe479604f6a1ba410106ee1046a41d1bd0814400 - languageName: node - linkType: hard - -"has@npm:^1.0.3": - version: 1.0.4 - resolution: "has@npm:1.0.4" - checksum: 8a11ba062e0627c9578a1d08285401e39f1d071a9692ddf793199070edb5648b21c774dd733e2a181edd635bf6862731885f476f4ccf67c998d7a5ff7cef2550 +"has-tostringtag@npm:^1.0.0, has-tostringtag@npm:^1.0.1, has-tostringtag@npm:^1.0.2": + version: 1.0.2 + resolution: "has-tostringtag@npm:1.0.2" + dependencies: + has-symbols: ^1.0.3 + checksum: 999d60bb753ad714356b2c6c87b7fb74f32463b8426e159397da4bde5bca7e598ab1073f4d8d4deafac297f2eb311484cd177af242776bf05f0d11565680468d languageName: node linkType: hard @@ -6925,6 +7085,15 @@ __metadata: languageName: node linkType: hard +"hasown@npm:^2.0.0, hasown@npm:^2.0.1": + version: 2.0.1 + resolution: "hasown@npm:2.0.1" + dependencies: + function-bind: ^1.1.2 + checksum: 9081c382a4fe8a62639a8da5c7d3322b203c319147e48783763dd741863d9f2dcaa743574fe2a1283871c445d8ba99ea45d5fff384e5ad27ca9dd7a367d79de0 + languageName: node + linkType: hard + "he@npm:1.2.0": version: 1.2.0 resolution: "he@npm:1.2.0" @@ -6991,14 +7160,13 @@ __metadata: languageName: node linkType: hard -"http-proxy-agent@npm:^5.0.0": - version: 5.0.0 - resolution: "http-proxy-agent@npm:5.0.0" +"http-proxy-agent@npm:^7.0.0": + version: 7.0.2 + resolution: "http-proxy-agent@npm:7.0.2" dependencies: - "@tootallnate/once": 2 - agent-base: 6 - debug: 4 - checksum: e2ee1ff1656a131953839b2a19cd1f3a52d97c25ba87bd2559af6ae87114abf60971e498021f9b73f9fd78aea8876d1fb0d4656aac8a03c6caa9fc175f22b786 + agent-base: ^7.1.0 + debug: ^4.3.4 + checksum: 670858c8f8f3146db5889e1fa117630910101db601fff7d5a8aa637da0abedf68c899f03d3451cac2f83bcc4c3d2dabf339b3aa00ff8080571cceb02c3ce02f3 languageName: node linkType: hard @@ -7032,6 +7200,16 @@ __metadata: languageName: node linkType: hard +"https-proxy-agent@npm:^7.0.1": + version: 7.0.4 + resolution: "https-proxy-agent@npm:7.0.4" + dependencies: + agent-base: ^7.0.2 + debug: 4 + checksum: daaab857a967a2519ddc724f91edbbd388d766ff141b9025b629f92b9408fc83cee8a27e11a907aede392938e9c398e240d643e178408a59e4073539cde8cfe9 + languageName: node + linkType: hard + "human-signals@npm:^1.1.1": version: 1.1.1 resolution: "human-signals@npm:1.1.1" @@ -7053,15 +7231,6 @@ __metadata: languageName: node linkType: hard -"humanize-ms@npm:^1.2.1": - version: 1.2.1 - resolution: "humanize-ms@npm:1.2.1" - dependencies: - ms: ^2.0.0 - checksum: 9c7a74a2827f9294c009266c82031030eae811ca87b0da3dceb8d6071b9bde22c9f3daef0469c3c533cc67a97d8a167cd9fc0389350e5f415f61a79b171ded16 - languageName: node - linkType: hard - "husky@npm:^8.0.1": version: 8.0.3 resolution: "husky@npm:8.0.3" @@ -7104,9 +7273,9 @@ __metadata: linkType: hard "ignore@npm:^5.1.1, ignore@npm:^5.2.0, ignore@npm:^5.2.4": - version: 5.2.4 - resolution: "ignore@npm:5.2.4" - checksum: 3d4c309c6006e2621659311783eaea7ebcd41fe4ca1d78c91c473157ad6666a57a2df790fe0d07a12300d9aac2888204d7be8d59f9aaf665b1c7fcdb432517ef + version: 5.3.1 + resolution: "ignore@npm:5.3.1" + checksum: 71d7bb4c1dbe020f915fd881108cbe85a0db3d636a0ea3ba911393c53946711d13a9b1143c7e70db06d571a5822c0a324a6bcde5c9904e7ca5047f01f1bf8cd3 languageName: node linkType: hard @@ -7118,9 +7287,9 @@ __metadata: linkType: hard "immutable@npm:^4.0.0-rc.12": - version: 4.3.4 - resolution: "immutable@npm:4.3.4" - checksum: de3edd964c394bab83432429d3fb0b4816b42f56050f2ca913ba520bd3068ec3e504230d0800332d3abc478616e8f55d3787424a90d0952e6aba864524f1afc3 + version: 4.3.5 + resolution: "immutable@npm:4.3.5" + checksum: 0e25dd5c314421faede9e1122ab26cdb638cc3edc8678c4a75dee104279b12621a30c80a480fae7f68bc7e81672f1e672e454dc0fdc7e6cf0af10809348387b8 languageName: node linkType: hard @@ -7216,6 +7385,17 @@ __metadata: languageName: node linkType: hard +"internal-slot@npm:^1.0.7": + version: 1.0.7 + resolution: "internal-slot@npm:1.0.7" + dependencies: + es-errors: ^1.3.0 + hasown: ^2.0.0 + side-channel: ^1.0.4 + checksum: cadc5eea5d7d9bc2342e93aae9f31f04c196afebb11bde97448327049f492cd7081e18623ae71388aac9cd237b692ca3a105be9c68ac39c1dec679d7409e33eb + languageName: node + linkType: hard + "interpret@npm:^1.0.0": version: 1.4.0 resolution: "interpret@npm:1.4.0" @@ -7232,6 +7412,16 @@ __metadata: languageName: node linkType: hard +"ip-address@npm:^9.0.5": + version: 9.0.5 + resolution: "ip-address@npm:9.0.5" + dependencies: + jsbn: 1.1.0 + sprintf-js: ^1.1.3 + checksum: aa15f12cfd0ef5e38349744e3654bae649a34c3b10c77a674a167e99925d1549486c5b14730eebce9fea26f6db9d5e42097b00aa4f9f612e68c79121c71652dc + languageName: node + linkType: hard + "ip-regex@npm:^4.0.0": version: 4.3.0 resolution: "ip-regex@npm:4.3.0" @@ -7239,13 +7429,6 @@ __metadata: languageName: node linkType: hard -"ip@npm:^2.0.0": - version: 2.0.0 - resolution: "ip@npm:2.0.0" - checksum: cfcfac6b873b701996d71ec82a7dd27ba92450afdb421e356f44044ed688df04567344c36cbacea7d01b1c39a4c732dc012570ebe9bebfb06f27314bca625349 - languageName: node - linkType: hard - "ipfs-core-types@npm:^0.9.0": version: 0.9.0 resolution: "ipfs-core-types@npm:0.9.0" @@ -7346,6 +7529,16 @@ __metadata: languageName: node linkType: hard +"is-array-buffer@npm:^3.0.4": + version: 3.0.4 + resolution: "is-array-buffer@npm:3.0.4" + dependencies: + call-bind: ^1.0.2 + get-intrinsic: ^1.2.1 + checksum: e4e3e6ef0ff2239e75371d221f74bc3c26a03564a22efb39f6bb02609b598917ddeecef4e8c877df2a25888f247a98198959842a5e73236bc7f22cabdf6351a7 + languageName: node + linkType: hard + "is-arrayish@npm:^0.2.1": version: 0.2.1 resolution: "is-arrayish@npm:0.2.1" @@ -7353,6 +7546,15 @@ __metadata: languageName: node linkType: hard +"is-bigint@npm:^1.0.1": + version: 1.0.4 + resolution: "is-bigint@npm:1.0.4" + dependencies: + has-bigints: ^1.0.1 + checksum: c56edfe09b1154f8668e53ebe8252b6f185ee852a50f9b41e8d921cb2bed425652049fbe438723f6cb48a63ca1aa051e948e7e401e093477c99c84eba244f666 + languageName: node + linkType: hard + "is-binary-path@npm:~2.1.0": version: 2.1.0 resolution: "is-binary-path@npm:2.1.0" @@ -7362,19 +7564,38 @@ __metadata: languageName: node linkType: hard -"is-buffer@npm:^2.0.5": - version: 2.0.5 - resolution: "is-buffer@npm:2.0.5" - checksum: 764c9ad8b523a9f5a32af29bdf772b08eb48c04d2ad0a7240916ac2688c983bf5f8504bf25b35e66240edeb9d9085461f9b5dae1f3d2861c6b06a65fe983de42 +"is-boolean-object@npm:^1.1.0": + version: 1.1.2 + resolution: "is-boolean-object@npm:1.1.2" + dependencies: + call-bind: ^1.0.2 + has-tostringtag: ^1.0.0 + checksum: c03b23dbaacadc18940defb12c1c0e3aaece7553ef58b162a0f6bba0c2a7e1551b59f365b91e00d2dbac0522392d576ef322628cb1d036a0fe51eb466db67222 + languageName: node + linkType: hard + +"is-callable@npm:^1.1.3, is-callable@npm:^1.1.4, is-callable@npm:^1.2.7": + version: 1.2.7 + resolution: "is-callable@npm:1.2.7" + checksum: 61fd57d03b0d984e2ed3720fb1c7a897827ea174bd44402878e059542ea8c4aeedee0ea0985998aa5cc2736b2fa6e271c08587addb5b3959ac52cf665173d1ac languageName: node linkType: hard "is-core-module@npm:^2.13.0": - version: 2.13.0 - resolution: "is-core-module@npm:2.13.0" + version: 2.13.1 + resolution: "is-core-module@npm:2.13.1" + dependencies: + hasown: ^2.0.0 + checksum: 256559ee8a9488af90e4bad16f5583c6d59e92f0742e9e8bb4331e758521ee86b810b93bae44f390766ffbc518a0488b18d9dab7da9a5ff997d499efc9403f7c + languageName: node + linkType: hard + +"is-date-object@npm:^1.0.1": + version: 1.0.5 + resolution: "is-date-object@npm:1.0.5" dependencies: - has: ^1.0.3 - checksum: 053ab101fb390bfeb2333360fd131387bed54e476b26860dc7f5a700bbf34a0ec4454f7c8c4d43e8a0030957e4b3db6e16d35e1890ea6fb654c833095e040355 + has-tostringtag: ^1.0.0 + checksum: baa9077cdf15eb7b58c79398604ca57379b2fc4cf9aa7a9b9e295278648f628c9b201400c01c5e0f7afae56507d741185730307cbe7cad3b9f90a77e5ee342fc languageName: node linkType: hard @@ -7514,6 +7735,22 @@ __metadata: languageName: node linkType: hard +"is-negative-zero@npm:^2.0.2": + version: 2.0.3 + resolution: "is-negative-zero@npm:2.0.3" + checksum: c1e6b23d2070c0539d7b36022d5a94407132411d01aba39ec549af824231f3804b1aea90b5e4e58e807a65d23ceb538ed6e355ce76b267bdd86edb757ffcbdcd + languageName: node + linkType: hard + +"is-number-object@npm:^1.0.4": + version: 1.0.7 + resolution: "is-number-object@npm:1.0.7" + dependencies: + has-tostringtag: ^1.0.0 + checksum: d1e8d01bb0a7134c74649c4e62da0c6118a0bfc6771ea3c560914d52a627873e6920dd0fd0ebc0e12ad2ff4687eac4c308f7e80320b973b2c8a2c8f97a7524f7 + languageName: node + linkType: hard + "is-number@npm:^7.0.0": version: 7.0.0 resolution: "is-number@npm:7.0.0" @@ -7549,6 +7786,16 @@ __metadata: languageName: node linkType: hard +"is-regex@npm:^1.1.4": + version: 1.1.4 + resolution: "is-regex@npm:1.1.4" + dependencies: + call-bind: ^1.0.2 + has-tostringtag: ^1.0.0 + checksum: 362399b33535bc8f386d96c45c9feb04cf7f8b41c182f54174c1a45c9abbbe5e31290bbad09a458583ff6bf3b2048672cdb1881b13289569a7c548370856a652 + languageName: node + linkType: hard + "is-retry-allowed@npm:^1.0.0": version: 1.2.0 resolution: "is-retry-allowed@npm:1.2.0" @@ -7556,6 +7803,15 @@ __metadata: languageName: node linkType: hard +"is-shared-array-buffer@npm:^1.0.2": + version: 1.0.2 + resolution: "is-shared-array-buffer@npm:1.0.2" + dependencies: + call-bind: ^1.0.2 + checksum: 9508929cf14fdc1afc9d61d723c6e8d34f5e117f0bffda4d97e7a5d88c3a8681f633a74f8e3ad1fe92d5113f9b921dc5ca44356492079612f9a247efbce7032a + languageName: node + linkType: hard + "is-stream@npm:^1.0.0, is-stream@npm:^1.1.0": version: 1.1.0 resolution: "is-stream@npm:1.1.0" @@ -7577,6 +7833,33 @@ __metadata: languageName: node linkType: hard +"is-string@npm:^1.0.5, is-string@npm:^1.0.7": + version: 1.0.7 + resolution: "is-string@npm:1.0.7" + dependencies: + has-tostringtag: ^1.0.0 + checksum: 323b3d04622f78d45077cf89aab783b2f49d24dc641aa89b5ad1a72114cfeff2585efc8c12ef42466dff32bde93d839ad321b26884cf75e5a7892a938b089989 + languageName: node + linkType: hard + +"is-symbol@npm:^1.0.2, is-symbol@npm:^1.0.3": + version: 1.0.4 + resolution: "is-symbol@npm:1.0.4" + dependencies: + has-symbols: ^1.0.2 + checksum: 92805812ef590738d9de49d677cd17dfd486794773fb6fa0032d16452af46e9b91bb43ffe82c983570f015b37136f4b53b28b8523bfb10b0ece7a66c31a54510 + languageName: node + linkType: hard + +"is-typed-array@npm:^1.1.10, is-typed-array@npm:^1.1.13": + version: 1.1.13 + resolution: "is-typed-array@npm:1.1.13" + dependencies: + which-typed-array: ^1.1.14 + checksum: 150f9ada183a61554c91e1c4290086d2c100b0dff45f60b028519be72a8db964da403c48760723bf5253979b8dffe7b544246e0e5351dcd05c5fdb1dcc1dc0f0 + languageName: node + linkType: hard + "is-typedarray@npm:~1.0.0": version: 1.0.0 resolution: "is-typedarray@npm:1.0.0" @@ -7607,6 +7890,15 @@ __metadata: languageName: node linkType: hard +"is-weakref@npm:^1.0.2": + version: 1.0.2 + resolution: "is-weakref@npm:1.0.2" + dependencies: + call-bind: ^1.0.2 + checksum: 95bd9a57cdcb58c63b1c401c60a474b0f45b94719c30f548c891860f051bc2231575c290a6b420c6bc6e7ed99459d424c652bd5bf9a1d5259505dc35b4bf83de + languageName: node + linkType: hard + "is-wsl@npm:^2.2.0": version: 2.2.0 resolution: "is-wsl@npm:2.2.0" @@ -7623,6 +7915,13 @@ __metadata: languageName: node linkType: hard +"isarray@npm:^2.0.5": + version: 2.0.5 + resolution: "isarray@npm:2.0.5" + checksum: bd5bbe4104438c4196ba58a54650116007fa0262eccef13a4c55b2e09a5b36b59f1e75b9fcc49883dd9d4953892e6fc007eef9e9155648ceea036e184b0f930a + languageName: node + linkType: hard + "isarray@npm:~1.0.0": version: 1.0.0 resolution: "isarray@npm:1.0.0" @@ -7637,6 +7936,13 @@ __metadata: languageName: node linkType: hard +"isexe@npm:^3.1.1": + version: 3.1.1 + resolution: "isexe@npm:3.1.1" + checksum: 7fe1931ee4e88eb5aa524cd3ceb8c882537bc3a81b02e438b240e47012eef49c86904d0f0e593ea7c3a9996d18d0f1f3be8d3eaa92333977b0c3a9d353d5563e + languageName: node + linkType: hard + "iso-url@npm:^1.1.5": version: 1.2.1 resolution: "iso-url@npm:1.2.1" @@ -7661,9 +7967,9 @@ __metadata: linkType: hard "istanbul-lib-coverage@npm:^3.0.0, istanbul-lib-coverage@npm:^3.2.0": - version: 3.2.0 - resolution: "istanbul-lib-coverage@npm:3.2.0" - checksum: a2a545033b9d56da04a8571ed05c8120bf10e9bce01cf8633a3a2b0d1d83dff4ac4fe78d6d5673c27fc29b7f21a41d75f83a36be09f82a61c367b56aa73c1ff9 + version: 3.2.2 + resolution: "istanbul-lib-coverage@npm:3.2.2" + checksum: 2367407a8d13982d8f7a859a35e7f8dd5d8f75aae4bb5484ede3a9ea1b426dc245aff28b976a2af48ee759fdd9be374ce2bd2669b644f31e76c5f46a2e29a831 languageName: node linkType: hard @@ -7681,15 +7987,15 @@ __metadata: linkType: hard "istanbul-lib-instrument@npm:^6.0.0": - version: 6.0.1 - resolution: "istanbul-lib-instrument@npm:6.0.1" + version: 6.0.2 + resolution: "istanbul-lib-instrument@npm:6.0.2" dependencies: - "@babel/core": ^7.12.3 - "@babel/parser": ^7.14.7 - "@istanbuljs/schema": ^0.1.2 + "@babel/core": ^7.23.9 + "@babel/parser": ^7.23.9 + "@istanbuljs/schema": ^0.1.3 istanbul-lib-coverage: ^3.2.0 semver: ^7.5.4 - checksum: fb23472e739cfc9b027cefcd7d551d5e7ca7ff2817ae5150fab99fe42786a7f7b56a29a2aa8309c37092e18297b8003f9c274f50ca4360949094d17fbac81472 + checksum: c10aa1e93a022f9767d7f41e6c07d244cc0a5c090fbb5522d70a5f21fcb98c52b7038850276c6fd1a7a17d1868c14a9d4eb8a24efe58a0ebb9a06f3da68131fe languageName: node linkType: hard @@ -7716,12 +8022,12 @@ __metadata: linkType: hard "istanbul-reports@npm:^3.1.3": - version: 3.1.6 - resolution: "istanbul-reports@npm:3.1.6" + version: 3.1.7 + resolution: "istanbul-reports@npm:3.1.7" dependencies: html-escaper: ^2.0.0 istanbul-lib-report: ^3.0.0 - checksum: 44c4c0582f287f02341e9720997f9e82c071627e1e862895745d5f52ec72c9b9f38e1d12370015d2a71dcead794f34c7732aaef3fab80a24bc617a21c3d911d6 + checksum: 2072db6e07bfbb4d0eb30e2700250636182398c1af811aea5032acb219d2080f7586923c09fa194029efd6b92361afb3dcbe1ebcc3ee6651d13340f7c6c4ed95 languageName: node linkType: hard @@ -8283,15 +8589,15 @@ __metadata: linkType: hard "joi@npm:^17.4.0": - version: 17.11.0 - resolution: "joi@npm:17.11.0" + version: 17.12.1 + resolution: "joi@npm:17.12.1" dependencies: - "@hapi/hoek": ^9.0.0 - "@hapi/topo": ^5.0.0 - "@sideway/address": ^4.1.3 + "@hapi/hoek": ^9.3.0 + "@hapi/topo": ^5.1.0 + "@sideway/address": ^4.1.5 "@sideway/formula": ^3.0.1 "@sideway/pinpoint": ^2.0.0 - checksum: 3a4e9ecba345cdafe585e7ed8270a44b39718e11dff3749aa27e0001a63d578b75100c062be28e6f48f960b594864034e7a13833f33fbd7ad56d5ce6b617f9bf + checksum: 31c85bf49cfacd094dd70e52a3cba40c7eb95240f199cad06609d6e76563761864bcf9920b94a6eb8b46839a50087d44f8d5d4126df8be7502847e4b276ca8b0 languageName: node linkType: hard @@ -8339,6 +8645,13 @@ __metadata: languageName: node linkType: hard +"jsbn@npm:1.1.0": + version: 1.1.0 + resolution: "jsbn@npm:1.1.0" + checksum: 944f924f2bd67ad533b3850eee47603eed0f6ae425fd1ee8c760f477e8c34a05f144c1bd4f5a5dd1963141dc79a2c55f89ccc5ab77d039e7077f3ad196b64965 + languageName: node + linkType: hard + "jsbn@npm:~0.1.0": version: 0.1.1 resolution: "jsbn@npm:0.1.1" @@ -8523,33 +8836,6 @@ __metadata: languageName: node linkType: hard -"level-supports@npm:^4.0.0": - version: 4.0.1 - resolution: "level-supports@npm:4.0.1" - checksum: d4552b42bb8cdeada07b0f6356c7a90fefe76279147331f291aceae26e3e56d5f927b09ce921647c0230bfe03ddfbdcef332be921e5c2194421ae2bfa3cf6368 - languageName: node - linkType: hard - -"level-transcoder@npm:^1.0.1": - version: 1.0.1 - resolution: "level-transcoder@npm:1.0.1" - dependencies: - buffer: ^6.0.3 - module-error: ^1.0.1 - checksum: 304f08d802faf3491a533b6d87ad8be3cabfd27f2713bbe9d4c633bf50fcb9460eab5a6776bf015e101ead7ba1c1853e05e7f341112f17a9d0cb37ee5a421a25 - languageName: node - linkType: hard - -"level@npm:^8.0.0": - version: 8.0.0 - resolution: "level@npm:8.0.0" - dependencies: - browser-level: ^1.0.1 - classic-level: ^1.2.0 - checksum: 13eb25bd71bfdca6cd714d1233adf9da97de9a8a4bf9f28d62a390b5c96d0250abaf983eb90eb8c4e89c7a985bb330750683d106f12670e5ea8fba1d7e608a1f - languageName: node - linkType: hard - "leven@npm:^3.1.0": version: 3.1.0 resolution: "leven@npm:3.1.0" @@ -8853,6 +9139,13 @@ __metadata: languageName: node linkType: hard +"lru-cache@npm:^10.0.0, lru-cache@npm:^10.0.1, lru-cache@npm:^9.1.1 || ^10.0.0": + version: 10.2.0 + resolution: "lru-cache@npm:10.2.0" + checksum: eee7ddda4a7475deac51ac81d7dd78709095c6fa46e8350dc2d22462559a1faa3b81ed931d5464b13d48cbd7e08b46100b6f768c76833912bc444b99c37e25db + languageName: node + linkType: hard + "lru-cache@npm:^4.0.1": version: 4.1.5 resolution: "lru-cache@npm:4.1.5" @@ -8881,20 +9174,6 @@ __metadata: languageName: node linkType: hard -"lru-cache@npm:^7.7.1": - version: 7.18.3 - resolution: "lru-cache@npm:7.18.3" - checksum: e550d772384709deea3f141af34b6d4fa392e2e418c1498c078de0ee63670f1f46f5eee746e8ef7e69e1c895af0d4224e62ee33e66a543a14763b0f2e74c1356 - languageName: node - linkType: hard - -"lru-cache@npm:^9.1.1 || ^10.0.0": - version: 10.0.1 - resolution: "lru-cache@npm:10.0.1" - checksum: 06f8d0e1ceabd76bb6f644a26dbb0b4c471b79c7b514c13c6856113879b3bf369eb7b497dad4ff2b7e2636db202412394865b33c332100876d838ad1372f0181 - languageName: node - linkType: hard - "lru_map@npm:^0.3.3": version: 0.3.3 resolution: "lru_map@npm:0.3.3" @@ -8936,26 +9215,22 @@ __metadata: languageName: node linkType: hard -"make-fetch-happen@npm:^11.0.3": - version: 11.1.1 - resolution: "make-fetch-happen@npm:11.1.1" +"make-fetch-happen@npm:^13.0.0": + version: 13.0.0 + resolution: "make-fetch-happen@npm:13.0.0" dependencies: - agentkeepalive: ^4.2.1 - cacache: ^17.0.0 + "@npmcli/agent": ^2.0.0 + cacache: ^18.0.0 http-cache-semantics: ^4.1.1 - http-proxy-agent: ^5.0.0 - https-proxy-agent: ^5.0.0 is-lambda: ^1.0.1 - lru-cache: ^7.7.1 - minipass: ^5.0.0 + minipass: ^7.0.2 minipass-fetch: ^3.0.0 minipass-flush: ^1.0.5 minipass-pipeline: ^1.2.4 negotiator: ^0.6.3 promise-retry: ^2.0.1 - socks-proxy-agent: ^7.0.0 ssri: ^10.0.0 - checksum: 7268bf274a0f6dcf0343829489a4506603ff34bd0649c12058753900b0eb29191dce5dba12680719a5d0a983d3e57810f594a12f3c18494e93a1fbc6348a4540 + checksum: 7c7a6d381ce919dd83af398b66459a10e2fe8f4504f340d1d090d3fa3d1b0c93750220e1d898114c64467223504bd258612ba83efbc16f31b075cd56de24b4af languageName: node linkType: hard @@ -8982,13 +9257,6 @@ __metadata: languageName: node linkType: hard -"mcl-wasm@npm:^0.7.1": - version: 0.7.9 - resolution: "mcl-wasm@npm:0.7.9" - checksum: 6b6ed5084156b98b2db70b223e1ba2c01953970b48a2e0c4ea3eeb9296610e6b3bfb2a2cce9e92e2d7ad61778b5f5a630e705e663835e915ba188c174a0a37fa - languageName: node - linkType: hard - "md5.js@npm:^1.3.4": version: 1.3.5 resolution: "md5.js@npm:1.3.5" @@ -9000,17 +9268,6 @@ __metadata: languageName: node linkType: hard -"memory-level@npm:^1.0.0": - version: 1.0.0 - resolution: "memory-level@npm:1.0.0" - dependencies: - abstract-level: ^1.0.0 - functional-red-black-tree: ^1.0.1 - module-error: ^1.0.1 - checksum: 80b1b7aedaf936e754adbcd7b9303018c3684fb32f9992fd967c448f145d177f16c724fbba9ed3c3590a9475fd563151eae664d69b83d2ad48714852e9fc5c72 - languageName: node - linkType: hard - "memorystream@npm:^0.3.1": version: 0.3.1 resolution: "memorystream@npm:0.3.1" @@ -9127,6 +9384,15 @@ __metadata: languageName: node linkType: hard +"minimatch@npm:9.0.3, minimatch@npm:^9.0.1": + version: 9.0.3 + resolution: "minimatch@npm:9.0.3" + dependencies: + brace-expansion: ^2.0.1 + checksum: 253487976bf485b612f16bf57463520a14f512662e592e95c571afdab1442a6a6864b6c88f248ce6fc4ff0b6de04ac7aa6c8bb51e868e99d1d65eb0658a708b5 + languageName: node + linkType: hard + "minimatch@npm:^5.0.1": version: 5.1.6 resolution: "minimatch@npm:5.1.6" @@ -9145,15 +9411,6 @@ __metadata: languageName: node linkType: hard -"minimatch@npm:^9.0.1": - version: 9.0.3 - resolution: "minimatch@npm:9.0.3" - dependencies: - brace-expansion: ^2.0.1 - checksum: 253487976bf485b612f16bf57463520a14f512662e592e95c571afdab1442a6a6864b6c88f248ce6fc4ff0b6de04ac7aa6c8bb51e868e99d1d65eb0658a708b5 - languageName: node - linkType: hard - "minimist@npm:^1.2.5, minimist@npm:^1.2.6": version: 1.2.8 resolution: "minimist@npm:1.2.8" @@ -9161,12 +9418,12 @@ __metadata: languageName: node linkType: hard -"minipass-collect@npm:^1.0.2": - version: 1.0.2 - resolution: "minipass-collect@npm:1.0.2" +"minipass-collect@npm:^2.0.1": + version: 2.0.1 + resolution: "minipass-collect@npm:2.0.1" dependencies: - minipass: ^3.0.0 - checksum: 14df761028f3e47293aee72888f2657695ec66bd7d09cae7ad558da30415fdc4752bbfee66287dcc6fd5e6a2fa3466d6c484dc1cbd986525d9393b9523d97f10 + minipass: ^7.0.3 + checksum: b251bceea62090f67a6cced7a446a36f4cd61ee2d5cea9aee7fff79ba8030e416327a1c5aa2908dc22629d06214b46d88fdab8c51ac76bacbf5703851b5ad342 languageName: node linkType: hard @@ -9235,7 +9492,7 @@ __metadata: languageName: node linkType: hard -"minipass@npm:^5.0.0 || ^6.0.2 || ^7.0.0, minipass@npm:^7.0.3": +"minipass@npm:^5.0.0 || ^6.0.2 || ^7.0.0, minipass@npm:^7.0.2, minipass@npm:^7.0.3": version: 7.0.4 resolution: "minipass@npm:7.0.4" checksum: 87585e258b9488caf2e7acea242fd7856bbe9a2c84a7807643513a338d66f368c7d518200ad7b70a508664d408aa000517647b2930c259a8b1f9f0984f344a21 @@ -9281,9 +9538,9 @@ __metadata: languageName: node linkType: hard -"mocha@npm:10.2.0, mocha@npm:^10.0.0, mocha@npm:^10.2.0": - version: 10.2.0 - resolution: "mocha@npm:10.2.0" +"mocha@npm:^10.0.0, mocha@npm:^10.2.0": + version: 10.3.0 + resolution: "mocha@npm:10.3.0" dependencies: ansi-colors: 4.1.1 browser-stdout: 1.3.1 @@ -9292,13 +9549,12 @@ __metadata: diff: 5.0.0 escape-string-regexp: 4.0.0 find-up: 5.0.0 - glob: 7.2.0 + glob: 8.1.0 he: 1.2.0 js-yaml: 4.1.0 log-symbols: 4.1.0 minimatch: 5.0.1 ms: 2.1.3 - nanoid: 3.3.3 serialize-javascript: 6.0.0 strip-json-comments: 3.1.1 supports-color: 8.1.1 @@ -9309,14 +9565,7 @@ __metadata: bin: _mocha: bin/_mocha mocha: bin/mocha.js - checksum: 406c45eab122ffd6ea2003c2f108b2bc35ba036225eee78e0c784b6fa2c7f34e2b13f1dbacef55a4fdf523255d76e4f22d1b5aacda2394bd11666febec17c719 - languageName: node - linkType: hard - -"module-error@npm:^1.0.1, module-error@npm:^1.0.2": - version: 1.0.2 - resolution: "module-error@npm:1.0.2" - checksum: 5d653e35bd55b3e95f8aee2cdac108082ea892e71b8f651be92cde43e4ee86abee4fa8bd7fc3fe5e68b63926d42f63c54cd17b87a560c31f18739295575a3962 + checksum: b5e95b9c270b2c33589e2f19d7ee37ac7577c0d471152d4e2692ebf4bc606a36040da4fbadc1e482b4cf5a0784daac7556bb962ad7b23143086b34a58e43e211 languageName: node linkType: hard @@ -9327,7 +9576,7 @@ __metadata: languageName: node linkType: hard -"ms@npm:2.1.3, ms@npm:^2.0.0, ms@npm:^2.1.1": +"ms@npm:2.1.3, ms@npm:^2.1.1": version: 2.1.3 resolution: "ms@npm:2.1.3" checksum: aa92de608021b242401676e35cfa5aa42dd70cbdc082b916da7fb925c542173e36bce97ea3e804923fe92c0ad991434e4a38327e15a1b5b5f945d66df615ae6d @@ -9458,28 +9707,12 @@ __metadata: languageName: node linkType: hard -"nanoid@npm:3.3.3": - version: 3.3.3 - resolution: "nanoid@npm:3.3.3" - bin: - nanoid: bin/nanoid.cjs - checksum: ada019402a07464a694553c61d2dca8a4353645a7d92f2830f0d487fedff403678a0bee5323a46522752b2eab95a0bc3da98b6cccaa7c0c55cd9975130e6d6f0 - languageName: node - linkType: hard - "nanoid@npm:^3.0.2, nanoid@npm:^3.1.20, nanoid@npm:^3.1.23": - version: 3.3.6 - resolution: "nanoid@npm:3.3.6" + version: 3.3.7 + resolution: "nanoid@npm:3.3.7" bin: nanoid: bin/nanoid.cjs - checksum: 7d0eda657002738aa5206107bd0580aead6c95c460ef1bdd0b1a87a9c7ae6277ac2e9b945306aaa5b32c6dcb7feaf462d0f552e7f8b5718abfc6ead5c94a71b3 - languageName: node - linkType: hard - -"napi-macros@npm:^2.2.2": - version: 2.2.2 - resolution: "napi-macros@npm:2.2.2" - checksum: c6f9bd71cdbbc37ddc3535aa5be481238641d89585b8a3f4d301cb89abf459e2d294810432bb7d12056d1f9350b1a0899a5afcf460237a3da6c398cf0fec7629 + checksum: d36c427e530713e4ac6567d488b489a36582ef89da1d6d4e3b87eded11eb10d7042a877958c6f104929809b2ab0bafa17652b076cdf84324aa75b30b722204f2 languageName: node linkType: hard @@ -9570,35 +9803,34 @@ __metadata: languageName: node linkType: hard -"node-gyp-build@npm:^4.2.0, node-gyp-build@npm:^4.3.0": - version: 4.6.1 - resolution: "node-gyp-build@npm:4.6.1" +"node-gyp-build@npm:^4.2.0": + version: 4.8.0 + resolution: "node-gyp-build@npm:4.8.0" bin: node-gyp-build: bin.js node-gyp-build-optional: optional.js node-gyp-build-test: build-test.js - checksum: c3676d337b36803bc7792e35bf7fdcda7cdcb7e289b8f9855a5535702a82498eb976842fefcf487258c58005ca32ce3d537fbed91280b04409161dcd7232a882 + checksum: b82a56f866034b559dd3ed1ad04f55b04ae381b22ec2affe74b488d1582473ca6e7f85fccf52da085812d3de2b0bf23109e752a57709ac7b9963951c710fea40 languageName: node linkType: hard "node-gyp@npm:latest": - version: 9.4.0 - resolution: "node-gyp@npm:9.4.0" + version: 10.0.1 + resolution: "node-gyp@npm:10.0.1" dependencies: env-paths: ^2.2.0 exponential-backoff: ^3.1.1 - glob: ^7.1.4 + glob: ^10.3.10 graceful-fs: ^4.2.6 - make-fetch-happen: ^11.0.3 - nopt: ^6.0.0 - npmlog: ^6.0.0 - rimraf: ^3.0.2 + make-fetch-happen: ^13.0.0 + nopt: ^7.0.0 + proc-log: ^3.0.0 semver: ^7.3.5 tar: ^6.1.2 - which: ^2.0.2 + which: ^4.0.0 bin: node-gyp: bin/node-gyp.js - checksum: 78b404e2e0639d64e145845f7f5a3cb20c0520cdaf6dda2f6e025e9b644077202ea7de1232396ba5bde3fee84cdc79604feebe6ba3ec84d464c85d407bb5da99 + checksum: 60a74e66d364903ce02049966303a57f898521d139860ac82744a5fdd9f7b7b3b61f75f284f3bfe6e6add3b8f1871ce305a1d41f775c7482de837b50c792223f languageName: node linkType: hard @@ -9609,7 +9841,7 @@ __metadata: languageName: node linkType: hard -"node-jq@npm:^2.3.4": +"node-jq@npm:2.3.5": version: 2.3.5 resolution: "node-jq@npm:2.3.5" dependencies: @@ -9623,10 +9855,10 @@ __metadata: languageName: node linkType: hard -"node-releases@npm:^2.0.13": - version: 2.0.13 - resolution: "node-releases@npm:2.0.13" - checksum: 17ec8f315dba62710cae71a8dad3cd0288ba943d2ece43504b3b1aa8625bf138637798ab470b1d9035b0545996f63000a8a926e0f6d35d0996424f8b6d36dda3 +"node-releases@npm:^2.0.14": + version: 2.0.14 + resolution: "node-releases@npm:2.0.14" + checksum: 59443a2f77acac854c42d321bf1b43dea0aef55cd544c6a686e9816a697300458d4e82239e2d794ea05f7bbbc8a94500332e2d3ac3f11f52e4b16cbe638b3c41 languageName: node linkType: hard @@ -9648,14 +9880,14 @@ __metadata: languageName: node linkType: hard -"nopt@npm:^6.0.0": - version: 6.0.0 - resolution: "nopt@npm:6.0.0" +"nopt@npm:^7.0.0": + version: 7.2.0 + resolution: "nopt@npm:7.2.0" dependencies: - abbrev: ^1.0.0 + abbrev: ^2.0.0 bin: nopt: bin/nopt.js - checksum: 82149371f8be0c4b9ec2f863cc6509a7fd0fa729929c009f3a58e4eb0c9e4cae9920e8f1f8eb46e7d032fec8fb01bede7f0f41a67eb3553b7b8e14fa53de1dac + checksum: a9c0f57fb8cb9cc82ae47192ca2b7ef00e199b9480eed202482c962d61b59a7fbe7541920b2a5839a97b42ee39e288c0aed770e38057a608d7f579389dfde410 languageName: node linkType: hard @@ -9695,23 +9927,11 @@ __metadata: linkType: hard "npm-run-path@npm:^5.1.0": - version: 5.1.0 - resolution: "npm-run-path@npm:5.1.0" + version: 5.2.0 + resolution: "npm-run-path@npm:5.2.0" dependencies: path-key: ^4.0.0 - checksum: dc184eb5ec239d6a2b990b43236845332ef12f4e0beaa9701de724aa797fe40b6bbd0157fb7639d24d3ab13f5d5cf22d223a19c6300846b8126f335f788bee66 - languageName: node - linkType: hard - -"npmlog@npm:^6.0.0": - version: 6.0.2 - resolution: "npmlog@npm:6.0.2" - dependencies: - are-we-there-yet: ^3.0.0 - console-control-strings: ^1.1.0 - gauge: ^4.0.3 - set-blocking: ^2.0.0 - checksum: ae238cd264a1c3f22091cdd9e2b106f684297d3c184f1146984ecbe18aaa86343953f26b9520dedd1b1372bc0316905b736c1932d778dbeb1fcf5a1001390e2a + checksum: c5325e016014e715689c4014f7e0be16cc4cbf529f32a1723e511bc4689b5f823b704d2bca61ac152ce2bda65e0205dc8b3ba0ec0f5e4c3e162d302f6f5b9efb languageName: node linkType: hard @@ -9739,10 +9959,17 @@ __metadata: languageName: node linkType: hard -"object-inspect@npm:^1.9.0": - version: 1.13.0 - resolution: "object-inspect@npm:1.13.0" - checksum: 21353e910a3079466cb44adca71d8bef15bd8b87e518eb68bb33d82c5c70b83193993edce432cc92268f7dd02c4a8ab338663a011844367d0bd0559f6dde1fed +"object-inspect@npm:^1.13.1": + version: 1.13.1 + resolution: "object-inspect@npm:1.13.1" + checksum: 7d9fa9221de3311dcb5c7c307ee5dc011cdd31dc43624b7c184b3840514e118e05ef0002be5388304c416c0eb592feb46e983db12577fc47e47d5752fbbfb61f + languageName: node + linkType: hard + +"object-keys@npm:^1.1.1": + version: 1.1.1 + resolution: "object-keys@npm:1.1.1" + checksum: b363c5e7644b1e1b04aa507e88dcb8e3a2f52b6ffd0ea801e4c7a62d5aa559affe21c55a07fd4b1fd55fc03a33c610d73426664b20032405d7b92a1414c34d6a languageName: node linkType: hard @@ -9753,6 +9980,18 @@ __metadata: languageName: node linkType: hard +"object.assign@npm:^4.1.5": + version: 4.1.5 + resolution: "object.assign@npm:4.1.5" + dependencies: + call-bind: ^1.0.5 + define-properties: ^1.2.1 + has-symbols: ^1.0.3 + object-keys: ^1.1.1 + checksum: f9aeac0541661370a1fc86e6a8065eb1668d3e771f7dbb33ee54578201336c057b21ee61207a186dd42db0c62201d91aac703d20d12a79fc79c353eed44d4e25 + languageName: node + linkType: hard + "obliterator@npm:^2.0.0": version: 2.0.4 resolution: "obliterator@npm:2.0.4" @@ -10248,6 +10487,13 @@ __metadata: languageName: node linkType: hard +"possible-typed-array-names@npm:^1.0.0": + version: 1.0.0 + resolution: "possible-typed-array-names@npm:1.0.0" + checksum: b32d403ece71e042385cc7856385cecf1cd8e144fa74d2f1de40d1e16035dba097bc189715925e79b67bdd1472796ff168d3a90d296356c9c94d272d5b95f3ae + languageName: node + linkType: hard + "prelude-ls@npm:^1.2.1": version: 1.2.1 resolution: "prelude-ls@npm:1.2.1" @@ -10307,6 +10553,13 @@ __metadata: languageName: node linkType: hard +"proc-log@npm:^3.0.0": + version: 3.0.0 + resolution: "proc-log@npm:3.0.0" + checksum: 02b64e1b3919e63df06f836b98d3af002b5cd92655cab18b5746e37374bfb73e03b84fe305454614b34c25b485cc687a9eebdccf0242cda8fda2475dd2c97e02 + languageName: node + linkType: hard + "process-nextick-args@npm:~2.0.0": version: 2.0.1 resolution: "process-nextick-args@npm:2.0.1" @@ -10430,9 +10683,9 @@ __metadata: linkType: hard "punycode@npm:^2.1.0, punycode@npm:^2.1.1": - version: 2.3.0 - resolution: "punycode@npm:2.3.0" - checksum: 39f760e09a2a3bbfe8f5287cf733ecdad69d6af2fe6f97ca95f24b8921858b91e9ea3c9eeec6e08cede96181b3bb33f95c6ffd8c77e63986508aa2e8159fa200 + version: 2.3.1 + resolution: "punycode@npm:2.3.1" + checksum: bb0a0ceedca4c3c57a9b981b90601579058903c62be23c5e8e843d2c2d4148a3ecf029d5133486fb0e1822b098ba8bba09e89d6b21742d02fa26bda6441a6fb2 languageName: node linkType: hard @@ -10443,7 +10696,7 @@ __metadata: languageName: node linkType: hard -"pvtsutils@npm:^1.3.2": +"pvtsutils@npm:^1.3.2, pvtsutils@npm:^1.3.5": version: 1.3.5 resolution: "pvtsutils@npm:1.3.5" dependencies: @@ -10489,7 +10742,7 @@ __metadata: languageName: node linkType: hard -"queue-microtask@npm:^1.2.2, queue-microtask@npm:^1.2.3": +"queue-microtask@npm:^1.2.2": version: 1.2.3 resolution: "queue-microtask@npm:1.2.3" checksum: b676f8c040cdc5b12723ad2f91414d267605b26419d5c821ff03befa817ddd10e238d22b25d604920340fd73efd8ba795465a0377c4adf45a4a41e4234e42dc4 @@ -10646,6 +10899,18 @@ __metadata: languageName: node linkType: hard +"regexp.prototype.flags@npm:^1.5.2": + version: 1.5.2 + resolution: "regexp.prototype.flags@npm:1.5.2" + dependencies: + call-bind: ^1.0.6 + define-properties: ^1.2.1 + es-errors: ^1.3.0 + set-function-name: ^2.0.1 + checksum: d7f333667d5c564e2d7a97c56c3075d64c722c9bb51b2b4df6822b2e8096d623a5e63088fb4c83df919b6951ef8113841de8b47de7224872fa6838bc5d8a7d64 + languageName: node + linkType: hard + "req-cwd@npm:^2.0.0": version: 2.0.0 resolution: "req-cwd@npm:2.0.0" @@ -10850,9 +11115,9 @@ __metadata: linkType: hard "rfdc@npm:^1.3.0": - version: 1.3.0 - resolution: "rfdc@npm:1.3.0" - checksum: fb2ba8512e43519983b4c61bd3fa77c0f410eff6bae68b08614437bc3f35f91362215f7b4a73cbda6f67330b5746ce07db5dd9850ad3edc91271ad6deea0df32 + version: 1.3.1 + resolution: "rfdc@npm:1.3.1" + checksum: d5d1e930aeac7e0e0a485f97db1356e388bdbeff34906d206fe524dd5ada76e95f186944d2e68307183fdc39a54928d4426bbb6734851692cfe9195efba58b79 languageName: node linkType: hard @@ -10899,15 +11164,6 @@ __metadata: languageName: node linkType: hard -"run-parallel-limit@npm:^1.1.0": - version: 1.1.0 - resolution: "run-parallel-limit@npm:1.1.0" - dependencies: - queue-microtask: ^1.2.2 - checksum: 672c3b87e7f939c684b9965222b361421db0930223ed1e43ebf0e7e48ccc1a022ea4de080bef4d5468434e2577c33b7681e3f03b7593fdc49ad250a55381123c - languageName: node - linkType: hard - "run-parallel@npm:^1.1.9": version: 1.2.0 resolution: "run-parallel@npm:1.2.0" @@ -10917,10 +11173,31 @@ __metadata: languageName: node linkType: hard -"rustbn.js@npm:~0.2.0": +"rust-verkle-wasm@npm:^0.0.1": + version: 0.0.1 + resolution: "rust-verkle-wasm@npm:0.0.1" + checksum: 24258e935d50b69d25d25d958ba4515b01470458ed7c42466cbc657104e826173827b838501eea1b94c71fd6c01fccd04829f0cc85cbad5d5c5d968c6d6df59e + languageName: node + linkType: hard + +"rustbn-wasm@npm:^0.2.0": version: 0.2.0 - resolution: "rustbn.js@npm:0.2.0" - checksum: 2148e7ba34e70682907ee29df4784639e6eb025481b2c91249403b7ec57181980161868d9aa24822a5075dd1bb5a180dfedc77309e5f0d27b6301f9b563af99a + resolution: "rustbn-wasm@npm:0.2.0" + dependencies: + "@scure/base": ^1.1.1 + checksum: 9cf89ce88a9d161bce8ea2516b3037fe97e1debb2e9b86d6f3cd133e2c120c844644d37c61c27ae00475e49595a397e61559431875a61c5c52a04c40ba658872 + languageName: node + linkType: hard + +"safe-array-concat@npm:^1.1.0": + version: 1.1.0 + resolution: "safe-array-concat@npm:1.1.0" + dependencies: + call-bind: ^1.0.5 + get-intrinsic: ^1.2.2 + has-symbols: ^1.0.3 + isarray: ^2.0.5 + checksum: 5c71eaa999168ee7474929f1cd3aae80f486353a651a094d9968936692cf90aa065224929a6486dcda66334a27dce4250a83612f9e0fef6dced1a925d3ac7296 languageName: node linkType: hard @@ -10938,6 +11215,17 @@ __metadata: languageName: node linkType: hard +"safe-regex-test@npm:^1.0.3": + version: 1.0.3 + resolution: "safe-regex-test@npm:1.0.3" + dependencies: + call-bind: ^1.0.6 + es-errors: ^1.3.0 + is-regex: ^1.1.4 + checksum: 6c7d392ff1ae7a3ae85273450ed02d1d131f1d2c76e177d6b03eb88e6df8fa062639070e7d311802c1615f351f18dc58f9454501c58e28d5ffd9b8f502ba6489 + languageName: node + linkType: hard + "safer-buffer@npm:>= 2.1.2 < 3, safer-buffer@npm:>= 2.1.2 < 3.0.0, safer-buffer@npm:^2.0.2, safer-buffer@npm:^2.1.0, safer-buffer@npm:~2.1.0": version: 2.1.2 resolution: "safer-buffer@npm:2.1.2" @@ -11041,13 +11329,13 @@ __metadata: linkType: hard "semver@npm:^7.0.0, semver@npm:^7.3.4, semver@npm:^7.3.5, semver@npm:^7.3.7, semver@npm:^7.5.3, semver@npm:^7.5.4": - version: 7.5.4 - resolution: "semver@npm:7.5.4" + version: 7.6.0 + resolution: "semver@npm:7.6.0" dependencies: lru-cache: ^6.0.0 bin: semver: bin/semver.js - checksum: 12d8ad952fa353b0995bf180cdac205a4068b759a140e5d3c608317098b3575ac2f1e09182206bf2eb26120e1c0ed8fb92c48c592f6099680de56bb071423ca3 + checksum: 7427f05b70786c696640edc29fdd4bc33b2acf3bbe1740b955029044f80575fc664e1a512e4113c3af21e767154a94b4aa214bf6cd6e42a1f6dba5914e0b208c languageName: node linkType: hard @@ -11067,6 +11355,32 @@ __metadata: languageName: node linkType: hard +"set-function-length@npm:^1.2.1": + version: 1.2.1 + resolution: "set-function-length@npm:1.2.1" + dependencies: + define-data-property: ^1.1.2 + es-errors: ^1.3.0 + function-bind: ^1.1.2 + get-intrinsic: ^1.2.3 + gopd: ^1.0.1 + has-property-descriptors: ^1.0.1 + checksum: 23742476d695f2eae86348c069bd164d4f25fa7c26546a46a2b5f370f1f84b98ec64366d2cd17785d5b41bbf16b95855da4b7eb188e7056fe3b0248d61f6afda + languageName: node + linkType: hard + +"set-function-name@npm:^2.0.1": + version: 2.0.2 + resolution: "set-function-name@npm: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 + checksum: d6229a71527fd0404399fc6227e0ff0652800362510822a291925c9d7b48a1ca1a468b11b281471c34cd5a2da0db4f5d7ff315a61d26655e77f6e971e6d0c80f + languageName: node + linkType: hard + "setimmediate@npm:^1.0.5": version: 1.0.5 resolution: "setimmediate@npm:1.0.5" @@ -11149,13 +11463,14 @@ __metadata: linkType: hard "side-channel@npm:^1.0.4": - version: 1.0.4 - resolution: "side-channel@npm:1.0.4" + version: 1.0.5 + resolution: "side-channel@npm:1.0.5" dependencies: - call-bind: ^1.0.0 - get-intrinsic: ^1.0.2 - object-inspect: ^1.9.0 - checksum: 351e41b947079c10bd0858364f32bb3a7379514c399edb64ab3dce683933483fc63fb5e4efe0a15a2e8a7e3c436b6a91736ddb8d8c6591b0460a24bb4a1ee245 + call-bind: ^1.0.6 + es-errors: ^1.3.0 + get-intrinsic: ^1.2.4 + object-inspect: ^1.13.1 + checksum: 640446b4e5a9554116ed6f5bec17c6740fa8da2c1a19e4d69c1202191185d4cc24f21ba0dd3ccca140eb6a8ee978d0b5bc5132f09b7962db7f9c4bc7872494ac languageName: node linkType: hard @@ -11215,24 +11530,24 @@ __metadata: languageName: node linkType: hard -"socks-proxy-agent@npm:^7.0.0": - version: 7.0.0 - resolution: "socks-proxy-agent@npm:7.0.0" +"socks-proxy-agent@npm:^8.0.1": + version: 8.0.2 + resolution: "socks-proxy-agent@npm:8.0.2" dependencies: - agent-base: ^6.0.2 - debug: ^4.3.3 - socks: ^2.6.2 - checksum: 720554370154cbc979e2e9ce6a6ec6ced205d02757d8f5d93fe95adae454fc187a5cbfc6b022afab850a5ce9b4c7d73e0f98e381879cf45f66317a4895953846 + agent-base: ^7.0.2 + debug: ^4.3.4 + socks: ^2.7.1 + checksum: 4fb165df08f1f380881dcd887b3cdfdc1aba3797c76c1e9f51d29048be6e494c5b06d68e7aea2e23df4572428f27a3ec22b3d7c75c570c5346507433899a4b6d languageName: node linkType: hard -"socks@npm:^2.6.2": - version: 2.7.1 - resolution: "socks@npm:2.7.1" +"socks@npm:^2.7.1": + version: 2.8.0 + resolution: "socks@npm:2.8.0" dependencies: - ip: ^2.0.0 + ip-address: ^9.0.5 smart-buffer: ^4.2.0 - checksum: 259d9e3e8e1c9809a7f5c32238c3d4d2a36b39b83851d0f573bfde5f21c4b1288417ce1af06af1452569cd1eb0841169afd4998f0e04ba04656f6b7f0e46d748 + checksum: b245081650c5fc112f0e10d2ee3976f5665d2191b9f86b181edd3c875d53d84a94bc173752d5be2651a450e3ef799fe7ec405dba3165890c08d9ac0b4ec1a487 languageName: node linkType: hard @@ -11255,15 +11570,23 @@ __metadata: languageName: node linkType: hard +"solidity-ast@npm:^0.4.38": + version: 0.4.55 + resolution: "solidity-ast@npm:0.4.55" + dependencies: + array.prototype.findlast: ^1.2.2 + checksum: a33f50b48039ca6a980eeb5d2e55a32d93c48bacbe33494faad8d50262f734cdb5c10b6d01d8bda289e702e0f9d144dd120fca1aa954c5390be8300a74a48af6 + languageName: node + linkType: hard + "solidity-coverage@npm:^0.8.2": - version: 0.8.5 - resolution: "solidity-coverage@npm:0.8.5" + version: 0.8.7 + resolution: "solidity-coverage@npm:0.8.7" dependencies: "@ethersproject/abi": ^5.0.9 - "@solidity-parser/parser": ^0.16.0 + "@solidity-parser/parser": ^0.18.0 chalk: ^2.4.2 death: ^1.1.0 - detect-port: ^1.3.0 difflib: ^0.2.4 fs-extra: ^8.1.0 ghost-testrpc: ^0.0.2 @@ -11271,7 +11594,7 @@ __metadata: globby: ^10.0.1 jsonschema: ^1.2.4 lodash: ^4.17.15 - mocha: 10.2.0 + mocha: ^10.2.0 node-emoji: ^1.10.0 pify: ^4.0.1 recursive-readdir: ^2.2.2 @@ -11283,7 +11606,19 @@ __metadata: hardhat: ^2.11.0 bin: solidity-coverage: plugins/bin.js - checksum: c9ca4deda9383c1db425117e72677f8908dcb2263ad41cfc1821c96afcfd5e8070146b87cd2c4b0812612fb707896928c07b776347143db838e486b4c938b394 + checksum: f0ebc55e5e9df3ebcee35067f48025735c2f311884185c5d2ace5b09a3b3d527ccb87a5ab035d973e5a5d3fa43db507455502f97d96c45ca0526169c03b12b13 + languageName: node + linkType: hard + +"solidity-docgen@npm:^0.6.0-beta.36": + version: 0.6.0-beta.36 + resolution: "solidity-docgen@npm:0.6.0-beta.36" + dependencies: + handlebars: ^4.7.7 + solidity-ast: ^0.4.38 + peerDependencies: + hardhat: ^2.8.0 + checksum: 658204db9dc73904bf2e556015d36ca5d120c88b10ecd249f5822b75cb5ea259b039081018ad98d6d00423f0e7691c9a1bf515e640bb84fc51d0def9d80eca3a languageName: node linkType: hard @@ -11357,6 +11692,13 @@ __metadata: languageName: node linkType: hard +"sprintf-js@npm:^1.1.3": + version: 1.1.3 + resolution: "sprintf-js@npm:1.1.3" + checksum: a3fdac7b49643875b70864a9d9b469d87a40dfeaf5d34d9d0c5b1cda5fd7d065531fcb43c76357d62254c57184a7b151954156563a4d6a747015cfb41021cad0 + languageName: node + linkType: hard + "sprintf-js@npm:~1.0.2": version: 1.0.3 resolution: "sprintf-js@npm:1.0.3" @@ -11365,8 +11707,8 @@ __metadata: linkType: hard "sshpk@npm:^1.7.0": - version: 1.17.0 - resolution: "sshpk@npm:1.17.0" + version: 1.18.0 + resolution: "sshpk@npm:1.18.0" dependencies: asn1: ~0.2.3 assert-plus: ^1.0.0 @@ -11381,7 +11723,7 @@ __metadata: sshpk-conv: bin/sshpk-conv sshpk-sign: bin/sshpk-sign sshpk-verify: bin/sshpk-verify - checksum: ba109f65c8e6c35133b8e6ed5576abeff8aa8d614824b7275ec3ca308f081fef483607c28d97780c1e235818b0f93ed8c8b56d0a5968d5a23fd6af57718c7597 + checksum: 01d43374eee3a7e37b3b82fdbecd5518cbb2e47ccbed27d2ae30f9753f22bd6ffad31225cb8ef013bc3fb7785e686cea619203ee1439a228f965558c367c3cfa languageName: node linkType: hard @@ -11459,7 +11801,7 @@ __metadata: languageName: node linkType: hard -"string-width-cjs@npm:string-width@^4.2.0, string-width@npm:^1.0.2 || 2 || 3 || 4, string-width@npm:^4.0.0, string-width@npm:^4.1.0, string-width@npm:^4.2.0, string-width@npm:^4.2.3": +"string-width-cjs@npm:string-width@^4.2.0, string-width@npm:^4.0.0, string-width@npm:^4.1.0, string-width@npm:^4.2.0, string-width@npm:^4.2.2, string-width@npm:^4.2.3": version: 4.2.3 resolution: "string-width@npm:4.2.3" dependencies: @@ -11491,6 +11833,39 @@ __metadata: languageName: node linkType: hard +"string.prototype.trim@npm:^1.2.8": + version: 1.2.8 + resolution: "string.prototype.trim@npm:1.2.8" + dependencies: + call-bind: ^1.0.2 + define-properties: ^1.2.0 + es-abstract: ^1.22.1 + checksum: 49eb1a862a53aba73c3fb6c2a53f5463173cb1f4512374b623bcd6b43ad49dd559a06fb5789bdec771a40fc4d2a564411c0a75d35fb27e76bbe738c211ecff07 + languageName: node + linkType: hard + +"string.prototype.trimend@npm:^1.0.7": + version: 1.0.7 + resolution: "string.prototype.trimend@npm:1.0.7" + dependencies: + call-bind: ^1.0.2 + define-properties: ^1.2.0 + es-abstract: ^1.22.1 + checksum: 2375516272fd1ba75992f4c4aa88a7b5f3c7a9ca308d963bcd5645adf689eba6f8a04ebab80c33e30ec0aefc6554181a3a8416015c38da0aa118e60ec896310c + languageName: node + linkType: hard + +"string.prototype.trimstart@npm:^1.0.7": + version: 1.0.7 + resolution: "string.prototype.trimstart@npm:1.0.7" + dependencies: + call-bind: ^1.0.2 + define-properties: ^1.2.0 + es-abstract: ^1.22.1 + checksum: 13d0c2cb0d5ff9e926fa0bec559158b062eed2b68cd5be777ffba782c96b2b492944e47057274e064549b94dd27cf81f48b27a31fee8af5b574cff253e7eb613 + languageName: node + linkType: hard + "string_decoder@npm:^1.1.1": version: 1.3.0 resolution: "string_decoder@npm:1.3.0" @@ -11940,11 +12315,11 @@ __metadata: linkType: hard "ts-api-utils@npm:^1.0.1": - version: 1.0.3 - resolution: "ts-api-utils@npm:1.0.3" + version: 1.2.1 + resolution: "ts-api-utils@npm:1.2.1" peerDependencies: typescript: ">=4.2.0" - checksum: 441cc4489d65fd515ae6b0f4eb8690057add6f3b6a63a36073753547fb6ce0c9ea0e0530220a0b282b0eec535f52c4dfc315d35f8a4c9a91c0def0707a714ca6 + checksum: 17a2a4454d65a6765b9351304cfd516fcda3098f49d72bba90cb7f22b6a09a573b4a1993fd7de7d6b8046c408960c5f21a25e64ccb969d484b32ea3b3e19d6e4 languageName: node linkType: hard @@ -11972,8 +12347,8 @@ __metadata: linkType: hard "ts-jest@npm:^29.1.1": - version: 29.1.1 - resolution: "ts-jest@npm:29.1.1" + version: 29.1.2 + resolution: "ts-jest@npm:29.1.2" dependencies: bs-logger: 0.x fast-json-stable-stringify: 2.x @@ -12000,13 +12375,13 @@ __metadata: optional: true bin: ts-jest: cli.js - checksum: a8c9e284ed4f819526749f6e4dc6421ec666f20ab44d31b0f02b4ed979975f7580b18aea4813172d43e39b29464a71899f8893dd29b06b4a351a3af8ba47b402 + checksum: a0ce0affc1b716c78c9ab55837829c42cb04b753d174a5c796bb1ddf9f0379fc20647b76fbe30edb30d9b23181908138d6b4c51ef2ae5e187b66635c295cefd5 languageName: node linkType: hard "ts-node@npm:^10.9.1": - version: 10.9.1 - resolution: "ts-node@npm:10.9.1" + version: 10.9.2 + resolution: "ts-node@npm:10.9.2" dependencies: "@cspotcode/source-map-support": ^0.8.0 "@tsconfig/node10": ^1.0.7 @@ -12038,7 +12413,7 @@ __metadata: ts-node-script: dist/bin-script.js ts-node-transpile-only: dist/bin-transpile.js ts-script: dist/bin-script-deprecated.js - checksum: 090adff1302ab20bd3486e6b4799e90f97726ed39e02b39e566f8ab674fd5bd5f727f43615debbfc580d33c6d9d1c6b1b3ce7d8e3cca3e20530a145ffa232c35 + checksum: fde256c9073969e234526e2cfead42591b9a2aec5222bac154b0de2fa9e4ceb30efcd717ee8bc785a56f3a119bdd5aa27b333d9dbec94ed254bd26f8944c67ac languageName: node linkType: hard @@ -12049,7 +12424,7 @@ __metadata: languageName: node linkType: hard -"tslib@npm:^2.0.0, tslib@npm:^2.3.1, tslib@npm:^2.4.0, tslib@npm:^2.5.0, tslib@npm:^2.6.1": +"tslib@npm:^2.0.0, tslib@npm:^2.3.1, tslib@npm:^2.4.0, tslib@npm:^2.5.0, tslib@npm:^2.6.1, tslib@npm:^2.6.2": version: 2.6.2 resolution: "tslib@npm:2.6.2" checksum: 329ea56123005922f39642318e3d1f0f8265d1e7fcb92c633e0809521da75eeaca28d2cf96d7248229deb40e5c19adf408259f4b9640afd20d13aecc1430f3ad @@ -12168,6 +12543,57 @@ __metadata: languageName: node linkType: hard +"typed-array-buffer@npm:^1.0.1": + version: 1.0.2 + resolution: "typed-array-buffer@npm:1.0.2" + dependencies: + call-bind: ^1.0.7 + es-errors: ^1.3.0 + is-typed-array: ^1.1.13 + checksum: 02ffc185d29c6df07968272b15d5319a1610817916ec8d4cd670ded5d1efe72901541ff2202fcc622730d8a549c76e198a2f74e312eabbfb712ed907d45cbb0b + languageName: node + linkType: hard + +"typed-array-byte-length@npm:^1.0.0": + version: 1.0.0 + resolution: "typed-array-byte-length@npm:1.0.0" + dependencies: + call-bind: ^1.0.2 + for-each: ^0.3.3 + has-proto: ^1.0.1 + is-typed-array: ^1.1.10 + checksum: b03db16458322b263d87a702ff25388293f1356326c8a678d7515767ef563ef80e1e67ce648b821ec13178dd628eb2afdc19f97001ceae7a31acf674c849af94 + languageName: node + linkType: hard + +"typed-array-byte-offset@npm:^1.0.0": + version: 1.0.2 + resolution: "typed-array-byte-offset@npm:1.0.2" + dependencies: + available-typed-arrays: ^1.0.7 + 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 + checksum: c8645c8794a621a0adcc142e0e2c57b1823bbfa4d590ad2c76b266aa3823895cf7afb9a893bf6685e18454ab1b0241e1a8d885a2d1340948efa4b56add4b5f67 + languageName: node + linkType: hard + +"typed-array-length@npm:^1.0.4": + version: 1.0.5 + resolution: "typed-array-length@npm:1.0.5" + 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 + possible-typed-array-names: ^1.0.0 + checksum: 82f5b666155cff1b345a1f3ab018d3f7667990f525435e4c8448cc094ab0f8ea283bb7cbde4d7bc82ea0b9b1072523bf31e86620d72615951d7fa9ccb4f42dfa + languageName: node + linkType: hard + "typedarray@npm:^0.0.6": version: 0.0.6 resolution: "typedarray@npm:0.0.6" @@ -12186,12 +12612,12 @@ __metadata: linkType: hard "typescript@npm:^5.0.4": - version: 5.2.2 - resolution: "typescript@npm:5.2.2" + version: 5.3.3 + resolution: "typescript@npm:5.3.3" bin: tsc: bin/tsc tsserver: bin/tsserver - checksum: 7912821dac4d962d315c36800fe387cdc0a6298dba7ec171b350b4a6e988b51d7b8f051317786db1094bd7431d526b648aba7da8236607febb26cf5b871d2d3c + checksum: 2007ccb6e51bbbf6fde0a78099efe04dc1c3dfbdff04ca3b6a8bc717991862b39fd6126c0c3ebf2d2d98ac5e960bcaa873826bb2bb241f14277034148f41f6a2 languageName: node linkType: hard @@ -12206,12 +12632,12 @@ __metadata: linkType: hard "typescript@patch:typescript@^5.0.4#~builtin": - version: 5.2.2 - resolution: "typescript@patch:typescript@npm%3A5.2.2#~builtin::version=5.2.2&hash=a1c5e5" + version: 5.3.3 + resolution: "typescript@patch:typescript@npm%3A5.3.3#~builtin::version=5.3.3&hash=a1c5e5" bin: tsc: bin/tsc tsserver: bin/tsserver - checksum: 07106822b4305de3f22835cbba949a2b35451cad50888759b6818421290ff95d522b38ef7919e70fb381c5fe9c1c643d7dea22c8b31652a717ddbd57b7f4d554 + checksum: f61375590b3162599f0f0d5b8737877ac0a7bc52761dbb585d67e7b8753a3a4c42d9a554c4cc929f591ffcf3a2b0602f65ae3ce74714fd5652623a816862b610 languageName: node linkType: hard @@ -12260,6 +12686,18 @@ __metadata: languageName: node linkType: hard +"unbox-primitive@npm:^1.0.2": + version: 1.0.2 + resolution: "unbox-primitive@npm:1.0.2" + dependencies: + call-bind: ^1.0.2 + has-bigints: ^1.0.2 + has-symbols: ^1.0.3 + which-boxed-primitive: ^1.0.2 + checksum: b7a1cf5862b5e4b5deb091672ffa579aa274f648410009c81cca63fed3b62b610c4f3b773f912ce545bb4e31edc3138975b5bc777fc6e4817dca51affb6380e9 + languageName: node + linkType: hard + "unbzip2-stream@npm:^1.0.9": version: 1.4.3 resolution: "unbzip2-stream@npm:1.4.3" @@ -12270,19 +12708,19 @@ __metadata: languageName: node linkType: hard -"undici-types@npm:~5.25.1": - version: 5.25.3 - resolution: "undici-types@npm:5.25.3" - checksum: ec9d2cc36520cbd9fbe3b3b6c682a87fe5be214699e1f57d1e3d9a2cb5be422e62735f06e0067dc325fd3dd7404c697e4d479f9147dc8a804e049e29f357f2ff +"undici-types@npm:~5.26.4": + version: 5.26.5 + resolution: "undici-types@npm:5.26.5" + checksum: 3192ef6f3fd5df652f2dc1cd782b49d6ff14dc98e5dced492aa8a8c65425227da5da6aafe22523c67f035a272c599bb89cfe803c1db6311e44bed3042fc25487 languageName: node linkType: hard "undici@npm:^5.14.0": - version: 5.26.3 - resolution: "undici@npm:5.26.3" + version: 5.28.3 + resolution: "undici@npm:5.28.3" dependencies: "@fastify/busboy": ^2.0.0 - checksum: aaa9aadb712cf80e1a9cea2377e4842670105e00abbc184a21770ea5a8b77e4e2eadc200eac62442e74a1cd3b16a840c6f73b112b9e886bd3c1a125eb22e4f21 + checksum: fa1e65aff896c5e2ee23637b632e306f9e3a2b32a3dc0b23ea71e5555ad350bcc25713aea894b3dccc0b7dc2c5e92a5a58435ebc2033b731a5524506f573dfd2 languageName: node linkType: hard @@ -12312,9 +12750,9 @@ __metadata: linkType: hard "universalify@npm:^2.0.0": - version: 2.0.0 - resolution: "universalify@npm:2.0.0" - checksum: 2406a4edf4a8830aa6813278bab1f953a8e40f2f63a37873ffa9a3bc8f9745d06cc8e88f3572cb899b7e509013f7f6fcc3e37e8a6d914167a5381d8440518c44 + version: 2.0.1 + resolution: "universalify@npm:2.0.1" + checksum: ecd8469fe0db28e7de9e5289d32bd1b6ba8f7183db34f3bfc4ca53c49891c2d6aa05f3fb3936a81285a905cc509fb641a0c3fc131ec786167eff41236ae32e60 languageName: node linkType: hard @@ -12420,13 +12858,13 @@ __metadata: linkType: hard "v8-to-istanbul@npm:^9.0.1": - version: 9.1.3 - resolution: "v8-to-istanbul@npm:9.1.3" + version: 9.2.0 + resolution: "v8-to-istanbul@npm:9.2.0" dependencies: "@jridgewell/trace-mapping": ^0.3.12 "@types/istanbul-lib-coverage": ^2.0.1 convert-source-map: ^2.0.0 - checksum: 5d592ab3d186b386065dace8e01c543a922a904b3cfac39667de172455a6b3d0e8e1401574fecb8a12092ad0809b5a8fd15f1cc14d0666139a1bb77cd6ac2cf8 + checksum: 31ef98c6a31b1dab6be024cf914f235408cd4c0dc56a5c744a5eea1a9e019ba279e1b6f90d695b78c3186feed391ed492380ccf095009e2eb91f3d058f0b4491 languageName: node linkType: hard @@ -12474,9 +12912,9 @@ __metadata: linkType: hard "web-streams-polyfill@npm:^3.2.1": - version: 3.2.1 - resolution: "web-streams-polyfill@npm:3.2.1" - checksum: b119c78574b6d65935e35098c2afdcd752b84268e18746606af149e3c424e15621b6f1ff0b42b2676dc012fc4f0d313f964b41a4b5031e525faa03997457da02 + version: 3.3.3 + resolution: "web-streams-polyfill@npm:3.3.3" + checksum: 21ab5ea08a730a2ef8023736afe16713b4f2023ec1c7085c16c8e293ee17ed085dff63a0ad8722da30c99c4ccbd4ccd1b2e79c861829f7ef2963d7de7004c2cb languageName: node linkType: hard @@ -12506,8 +12944,8 @@ __metadata: linkType: hard "web3-utils@npm:^1.3.6": - version: 1.10.2 - resolution: "web3-utils@npm:1.10.2" + version: 1.10.4 + resolution: "web3-utils@npm:1.10.4" dependencies: "@ethereumjs/util": ^8.1.0 bn.js: ^5.2.1 @@ -12517,20 +12955,20 @@ __metadata: number-to-bn: 1.7.0 randombytes: ^2.1.0 utf8: 3.0.0 - checksum: a5f8db69603fdd5e984aa6407f47f7a4e0dab83af42e10de25a6d9eeaf2e7d4d18fe665b569e364b2e916233fb73b26cc70ff0d730e7909720118c4790dfb043 + checksum: a1535817a4653f1b5cc868aa19305158122379078a41e13642e1ba64803f6f8e5dd2fb8c45c033612b8f52dde42d8008afce85296c0608276fe1513dece66a49 languageName: node linkType: hard -"webcrypto-core@npm:^1.7.7": - version: 1.7.7 - resolution: "webcrypto-core@npm:1.7.7" +"webcrypto-core@npm:^1.7.8": + version: 1.7.8 + resolution: "webcrypto-core@npm:1.7.8" dependencies: - "@peculiar/asn1-schema": ^2.3.6 + "@peculiar/asn1-schema": ^2.3.8 "@peculiar/json-schema": ^1.1.12 asn1js: ^3.0.1 - pvtsutils: ^1.3.2 - tslib: ^2.4.0 - checksum: 1dc5aedb250372dd95e175a671b990ae50e36974f99c4efc85d88e6528c1bc52dd964d44a41b68043c21fb26aabfe8aad4f05a1c39ca28d61de5ca7388413d52 + pvtsutils: ^1.3.5 + tslib: ^2.6.2 + checksum: 58567b41db3acc3af45b344ba967c2de9a725a988fe8c8b4006eaf1f76050c577bd2fdfacc9294a7991f768cd1bae23ec3eb17fda630e5d7d395100910575ba3 languageName: node linkType: hard @@ -12551,6 +12989,19 @@ __metadata: languageName: node linkType: hard +"which-boxed-primitive@npm:^1.0.2": + version: 1.0.2 + resolution: "which-boxed-primitive@npm:1.0.2" + dependencies: + is-bigint: ^1.0.1 + is-boolean-object: ^1.1.0 + is-number-object: ^1.0.4 + is-string: ^1.0.5 + is-symbol: ^1.0.3 + checksum: 53ce774c7379071729533922adcca47220228405e1895f26673bbd71bdf7fb09bee38c1d6399395927c6289476b5ae0629863427fd151491b71c4b6cb04f3a5e + languageName: node + linkType: hard + "which-module@npm:^2.0.0": version: 2.0.1 resolution: "which-module@npm:2.0.1" @@ -12558,7 +13009,20 @@ __metadata: languageName: node linkType: hard -"which@npm:2.0.2, which@npm:^2.0.0, which@npm:^2.0.1, which@npm:^2.0.2": +"which-typed-array@npm:^1.1.14": + version: 1.1.14 + resolution: "which-typed-array@npm:1.1.14" + dependencies: + available-typed-arrays: ^1.0.6 + call-bind: ^1.0.5 + for-each: ^0.3.3 + gopd: ^1.0.1 + has-tostringtag: ^1.0.1 + checksum: efe30c143c58630dde8ab96f9330e20165bacd77ca843c602b510120a415415573bcdef3ccbc30a0e5aaf20f257360cfe24712aea0008f149ce5bb99834c0c0b + languageName: node + linkType: hard + +"which@npm:2.0.2, which@npm:^2.0.0, which@npm:^2.0.1": version: 2.0.2 resolution: "which@npm:2.0.2" dependencies: @@ -12580,12 +13044,14 @@ __metadata: languageName: node linkType: hard -"wide-align@npm:^1.1.5": - version: 1.1.5 - resolution: "wide-align@npm:1.1.5" +"which@npm:^4.0.0": + version: 4.0.0 + resolution: "which@npm:4.0.0" dependencies: - string-width: ^1.0.2 || 2 || 3 || 4 - checksum: d5fc37cd561f9daee3c80e03b92ed3e84d80dde3365a8767263d03dacfc8fa06b065ffe1df00d8c2a09f731482fcacae745abfbb478d4af36d0a891fad4834d3 + isexe: ^3.1.1 + bin: + node-which: bin/which.js + checksum: f17e84c042592c21e23c8195108cff18c64050b9efb8459589116999ea9da6dd1509e6a1bac3aeebefd137be00fabbb61b5c2bc0aa0f8526f32b58ee2f545651 languageName: node linkType: hard