From cebd7d0eb5540bc0d468fe8b249e2149682c2c9d Mon Sep 17 00:00:00 2001 From: Andres Guarneros <34948183+guarner8@users.noreply.github.com> Date: Wed, 17 May 2023 10:34:16 -0400 Subject: [PATCH 01/97] Update eip-4955.md (#6937) Fix typo. --- EIPS/eip-4955.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/EIPS/eip-4955.md b/EIPS/eip-4955.md index ee650ebae1e776..9a3b98b74f53d3 100644 --- a/EIPS/eip-4955.md +++ b/EIPS/eip-4955.md @@ -17,7 +17,7 @@ This EIP standardizes a schema for NFTs metadata to add new field namespaces to ## Motivation -A standardized NFT metadata schema allows wallets, marketplaces, metaverses, and sililar applications to interoperate with any NFT. Applications such as NFT marketplaces and metaverses could usefully leverage NFTs by rendering them using custom 3D representations or any other new attributes. +A standardized NFT metadata schema allows wallets, marketplaces, metaverses, and similar applications to interoperate with any NFT. Applications such as NFT marketplaces and metaverses could usefully leverage NFTs by rendering them using custom 3D representations or any other new attributes. Some projects like Decentraland, TheSandbox, Cryptoavatars, etc. need their own 3D model in order to represent an NFT. These models are not cross-compatible because of distinct aesthetics and data formats. From f60afebae807e33975c5375ed318e617f4361db4 Mon Sep 17 00:00:00 2001 From: Jan Turk Date: Wed, 17 May 2023 21:37:30 +0200 Subject: [PATCH 02/97] Update EIP-6454: Move to Final Merged by EIP-Bot. --- EIPS/eip-6454.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/EIPS/eip-6454.md b/EIPS/eip-6454.md index 10140dd1015ef0..f2dbc9a39fef15 100644 --- a/EIPS/eip-6454.md +++ b/EIPS/eip-6454.md @@ -5,7 +5,7 @@ description: A minimal extension to identify the transferability of Non-Fungible author: Bruno Škvorc (@Swader), Francesco Sullo (@sullof), Steven Pineda (@steven2308), Stevan Bogosavljevic (@stevyhacker), Jan Turk (@ThunderDeliverer) discussions-to: https://ethereum-magicians.org/t/minimalistic-transferable-interface/12517 status: Last Call -last-call-deadline: 2023-04-07 +last-call-deadline: 2023-05-27 type: Standards Track category: ERC created: 2023-01-31 From 14e48abc75d3a4345c43c8361c4fe5c00efefd95 Mon Sep 17 00:00:00 2001 From: Alex Stokes Date: Wed, 17 May 2023 16:23:54 -0600 Subject: [PATCH 03/97] Update EIP-4788: send current slot from CL to avoid timestamp conversions Merged by EIP-Bot. --- EIPS/eip-4788.md | 43 ++++++++++++++++++++++++++++++++----------- 1 file changed, 32 insertions(+), 11 deletions(-) diff --git a/EIPS/eip-4788.md b/EIPS/eip-4788.md index 492e12e23fca3d..b2d2cb378b6d93 100644 --- a/EIPS/eip-4788.md +++ b/EIPS/eip-4788.md @@ -18,7 +18,10 @@ Store each of these roots in a contract that lives in the execution state and ad ## Motivation -Roots of the beacon chain blocks are cryptographic accumulators that allow proofs of arbitrary consensus state. Exposing these roots inside the EVM allows for trust-minimized access to the consensus layer. This functionality supports a wide variety of use cases that improve trust assumptions of staking pools, restaking constructions, smart contract bridges, MEV mitigations and more. +Roots of the beacon chain blocks are cryptographic accumulators that allow proofs of arbitrary consensus state. +Exposing these roots inside the EVM allows for trust-minimized access to the consensus layer. +This functionality supports a wide variety of use cases that improve trust assumptions of staking pools, +restaking constructions, smart contract bridges, MEV mitigations and more. ## Specification @@ -34,7 +37,8 @@ Roots of the beacon chain blocks are cryptographic accumulators that allow proof The high-level idea is that each execution block contains the parent beacon block root. Even in the event of missed slots since the previous block root does not change, we only need a constant amount of space to represent this "oracle" in each execution block. To improve the usability of this oracle, block roots are stored -in a canonical place in the execution state analogous to a `SSTORE` in given contract's storage for each update. Roots are stored keyed by the slot(s) they pertain to. +in a canonical place in the execution state analogous to a `SSTORE` in the given contract's storage for each update. +Roots are keyed by the slot(s) they pertain to. To bound the amount of storage this construction consumes, a ring buffer is used that mirrors a block root accumulator on the consensus layer. The method for exposing the root data via opcode is inspired by [EIP-2935](./eip-2935.md). @@ -42,29 +46,46 @@ The method for exposing the root data via opcode is inspired by [EIP-2935](./eip Beginning at the execution timestamp `FORK_TIMESTAMP`, execution clients **MUST**: -1. set 32 bytes of the execution block header after the `withdrawals_root` to the 32 byte [hash tree root](https://github.com/ethereum/consensus-specs/blob/fa09d896484bbe240334fa21ffaa454bafe5842e/ssz/simple-serialize.md#merkleization) of the parent beacon block. +1. set 32 bytes of the execution block header after the `excess_data_gas` to the 32 byte [hash tree root](https://github.com/ethereum/consensus-specs/blob/fa09d896484bbe240334fa21ffaa454bafe5842e/ssz/simple-serialize.md#merkleization) of the parent beacon block. -*NOTE*: this field is appended to the current block header structure with this EIP so that the size of the header grows after (and including) the `FORK_TIMESTAMP`. +2. set the 8 bytes after the previous 32 byte extension to the slot number as a big-endian uint64 of the current slot. + +*NOTE*: these fields are appended to the current block header structure with this EIP so that the size of the header grows after (and including) the `FORK_TIMESTAMP`. ### EVM changes #### Block processing -At the start of processing any execution block where `block.timestamp >= FORK_TIMESTAMP` (i.e. before processing any transactions), write the parent beacon root provided in the block header into the storage of the contract at `HISTORY_STORAGE_ADDRESS`. This data is keyed by the slot number. +At the start of processing any execution block where `block.timestamp >= FORK_TIMESTAMP` (i.e. before processing any transactions), +write the parent beacon root provided in the block header into the storage of the contract at `HISTORY_STORAGE_ADDRESS`. -In pseudocode: +This data is keyed by the slots containing the parent beacon block root which in general could be multiple slots for the +same root. To find the starting slot of the range, read the storage slot `SLOTS_PER_HISTORICAL_ROOT` (interpreted as a +256-bit byte array) which contains the big-endian encoding of the last slot value written to. This encoding should be interpreted +as a 64-bit big-endian integer that yields the starting slot. +Clients then iterate from the start slot (inclusive) to the end slot (exclusive) found in the header +and write the beacon block root into each slot value. -```python -start_timestamp = get_block(block_header.parent_hash).header.timestamp -start_slot = convert_to_slot(start_timestamp) +*NOTE*: if the slot stored at `SLOTS_PER_HISTORICAL_ROOT` is all zeros, clients should use set the start slot to one less than the +slot in the header, e.g. `header.beacon_block_root_slot - 1`. + +After writing the block root in the relevant slots, store the current slot for use during the next update in the same storage slot +`SLOTS_PER_HISTORICAL_ROOT`. -end_timestamp = block_header.timestamp -end_slot = convert_to_slot(end_timestamp) +In Python pseudocode: + +```python +start_slot = to_uint64(sload(HISTORY_STORAGE_ADDRESS, SLOTS_PER_HISTORICAL_ROOT)) +end_slot = block_header.beacon_slot +if start_slot == 0: + start_slot = max(end_slot - 1, 0) parent_beacon_block_root = block_header.parent_beacon_block_root for slot in range(start_slot, end_slot): sstore(HISTORY_STORAGE_ADDRESS, slot % SLOTS_PER_HISTORICAL_ROOT, parent_beacon_block_root) + +sstore(HISTORY_STORAGE_ADDRESS, SLOTS_PER_HISTORICAL_ROOT, end_slot) ``` When using any slot value as a key to the storage, the value under consideration must be converted to 32 bytes with big-endian encoding. From 04ca241eecc297b27bb812c4d554505255c40a52 Mon Sep 17 00:00:00 2001 From: Alex Stokes Date: Thu, 18 May 2023 12:02:58 -0600 Subject: [PATCH 04/97] Update EIP-4844: Update eip-4844.md, fix typo Merged by EIP-Bot. --- EIPS/eip-4844.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/EIPS/eip-4844.md b/EIPS/eip-4844.md index c8b35be69e4241..5060f60bd9326c 100644 --- a/EIPS/eip-4844.md +++ b/EIPS/eip-4844.md @@ -110,7 +110,7 @@ rlp([chain_id, nonce, max_priority_fee_per_gas, max_fee_per_gas, gas_limit, to, The `max_priority_fee_per_gas` and `max_fee_per_gas` fields follow [EIP-1559](./eip-1559.md) semantics and `access_list` follows [EIP-2930](./eip-2930.md). -The `max_fee_per_data_gas` is `uint256` and the `blob_versioned_hashes` field represents a list hash outputs from `kzg_to_versioned_hash`. +The `max_fee_per_data_gas` is `uint256` and the `blob_versioned_hashes` field represents a list of hash outputs from `kzg_to_versioned_hash`. The [EIP-2718](./eip-2718.md) `ReceiptPayload` for this transaction is `rlp([status, cumulative_transaction_gas_used, logs_bloom, logs])`. From 1d001b734162c9ff1cb01f586f6df52c14c04e49 Mon Sep 17 00:00:00 2001 From: Charles Cooper Date: Thu, 18 May 2023 15:38:48 -0400 Subject: [PATCH 05/97] Update EIP-5202: Move to Last Call Merged by EIP-Bot. --- EIPS/eip-5202.md | 54 +++++++++++++++++++++++++++++++++++++++++++++--- 1 file changed, 51 insertions(+), 3 deletions(-) diff --git a/EIPS/eip-5202.md b/EIPS/eip-5202.md index b7b35009adcdf8..bfd327a2f974b4 100644 --- a/EIPS/eip-5202.md +++ b/EIPS/eip-5202.md @@ -4,7 +4,8 @@ title: Blueprint contract format description: Define a bytecode container format for indexing and utilizing blueprint contracts author: Charles Cooper (@charles-cooper), Edward Amor (@skellet0r) discussions-to: https://ethereum-magicians.org/t/erc-5202-standard-factory-contract-format/9851 -status: Review +status: Last Call +last-call-deadline: 2023-06-01 type: Standards Track category: ERC created: 2022-06-23 @@ -12,15 +13,18 @@ requires: 170 --- ## Abstract + Define a standard for "blueprint" contracts, or contracts which represent initcode that is stored on-chain. ## Motivation + To decrease deployer contract size, a useful pattern is to store initcode on chain as a "blueprint" contract, and then use `EXTCODECOPY` to copy the initcode into memory, followed by a call to `CREATE` or `CREATE2`. However, this comes with the following problems: - It is hard for external tools and indexers to detect if a contract is a "regular" runtime contract or a "blueprint" contract. Heuristically searching for patterns in bytecode to determine if it is initcode poses maintenance and correctness problems. - Storing initcode byte-for-byte on-chain is a correctness and security problem. Since the EVM does not have a native way to distinguish between executable code and other types of code, unless the initcode explicitly implements ACL rules, *anybody* can call such a "blueprint" contract and execute the initcode directly as ordinary runtime code. This is particularly problematic if the initcode stored by the blueprint contract has side effects such as writing to storage or calling external contracts. If the initcode stored by the blueprint contract executes a `SELFDESTRUCT` opcode, the blueprint contract could even be removed, preventing the correct operation of downstream deployer contracts that rely on the blueprint existing. For this reason, it would be good to prefix blueprint contracts with a special preamble to prevent execution. ## Specification + The key words “MUST”, “MUST NOT”, “REQUIRED”, “SHALL”, “SHALL NOT”, “SHOULD”, “SHOULD NOT”, “RECOMMENDED”, “MAY”, and “OPTIONAL” in this document are to be interpreted as described in RFC 2119. A blueprint contract MUST use the preamble `0xFE71`. 6 bits are allocated to the version, and 2 bits to the length encoding. The first version begins at 0 (`0b000000`), and versions increment by 1. The value `0b11` for `` is reserved. In the case that the length bits are `0b11`, the third byte is considered a continuation byte (that is, the version requires multiple bytes to encode). The exact encoding of a multi-byte version is left to a future ERC. @@ -30,6 +34,7 @@ A blueprint contract MUST contain at least one byte of initcode. A blueprint contract MAY insert any bytes (data or code) between the version byte(s) and the initcode. If such variable length data is used, the preamble must be `0xFE71`. The `` represent a number between 0 and 2 (inclusive) describing how many bytes `` takes, and `` is the big-endian encoding of the number of bytes that `` takes. ## Rationale + - To save gas and storage space, the preamble should be as minimal as possible. - It is considered "bad" behavior to try to CALL a blueprint contract directly, therefore the preamble starts with `INVALID (0xfe)` to end execution with an exceptional halting condition (rather than a "gentler" opcode like `STOP (0x00)`). @@ -44,11 +49,36 @@ A blueprint contract MAY insert any bytes (data or code) between the version byt - The length of the initcode itself is not included by default in the preamble because it takes space, and it can be trivially determined using `EXTCODESIZE`. -- The EOF ([EIP-3540](./eip-3540.md)) could provide another way of specifying blueprint contracts, by adding another section kind (3 - initcode). However, it is not yet in the EVM, and we would like to be able to standardize blueprint contracts today, without relying on EVM changes. If, at some future point, section kind 3 becomes part of the EOF spec, and the EOF becomes part of the EVM, this ERC will be considered to be obsolesced since the EOF validation spec provides much stronger guarantees than this ERC. +- The Ethereum Object Format (EOF) could provide another way of specifying blueprint contracts, by adding another section kind (3 - initcode). However, it is not yet in the EVM, and we would like to be able to standardize blueprint contracts today, without relying on EVM changes. If, at some future point, section kind 3 becomes part of the EOF spec, and the EOF becomes part of the EVM, this ERC will be considered to be obsolesced since the EOF validation spec provides much stronger guarantees than this ERC. ## Backwards Compatibility -Needs discussion + +No known issues + +## Test Cases + +- An example (and trivial!) blueprint contract with no data section, whose initcode is just the `STOP` instruction: + +``` +0xFE710000 +``` + +- An example blueprint contract whose initcode is the trivial `STOP` instruction and whose data section contains the byte `0xFF` repeated seven times: + +``` +0xFE710107FFFFFFFFFFFFFF00 +``` + +Here, 0xFE71 is the magic header, `0x01` means version 0 + 1 length bit, `0x07` encodes the length in bytes of the data section. These are followed by the data section, and then the initcode. For illustration, the above code with delimiters would be `0xFE71|01|07|FFFFFFFFFFFFFF|00`. + +- An example blueprint whose initcode is the trivial `STOP` instruction and whose data section contains the byte `0xFF` repeated 256 times: + +``` +0xFE71020100FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF00 +``` + +Delimited, that would be `0xFE71|02|0100|FF...FF|00`. ## Reference Implementation @@ -95,6 +125,23 @@ def parse_blueprint_preamble(bytecode: bytes) -> Tuple[int, Optional[bytes], byt return erc_version, preamble_data, initcode ``` +The following reference function takes the desired initcode for a blueprint as a parameter, and returns EVM code which will deploy a corresponding blueprint contract (with no data section): + +```python +def blueprint_deployer_bytecode(initcode: bytes) -> bytes: + blueprint_preamble = b"\xFE\x71\x00" # ERC5202 preamble + blueprint_bytecode = blueprint_preamble + initcode + + # the length of the deployed code in bytes + len_bytes = len(blueprint_bytecode).to_bytes(2, "big") + + # copy to memory and `RETURN` it per EVM creation semantics + # PUSH2 RETURNDATASIZE DUP2 PUSH1 10 RETURNDATASIZE CODECOPY RETURN + deploy_bytecode = b"\x61" + len_bytes + b"\x3d\x81\x60\x0a\x3d\x39\xf3" + + return deploy_bytecode + blueprint_bytecode +``` + ## Security Considerations There could be contracts on-chain already which happen to start with the same prefix as proposed in this ERC. However, this is not considered a serious risk, because the way it is envisioned that indexers will use this is to verify source code by compiling it and prepending the preamble. @@ -102,4 +149,5 @@ There could be contracts on-chain already which happen to start with the same pr As of 2022-07-08, no contracts deployed on the Ethereum mainnet have a bytecode starting with `0xFE71`. ## Copyright + Copyright and related rights waived via [CC0](../LICENSE.md). From 686bc3caa60b59360da59f1a8b696485de26b542 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Ernesto=20Garc=C3=ADa?= Date: Thu, 18 May 2023 18:24:54 -0600 Subject: [PATCH 06/97] Update EIP-6093: EIP6093 Corrections for ERC721 Merged by EIP-Bot. --- EIPS/eip-6093.md | 45 +++++++++++++++++++++++++++++++-------------- 1 file changed, 31 insertions(+), 14 deletions(-) diff --git a/EIPS/eip-6093.md b/EIPS/eip-6093.md index b932c65be7c375..9077991f36ee5f 100644 --- a/EIPS/eip-6093.md +++ b/EIPS/eip-6093.md @@ -13,7 +13,7 @@ requires: 20, 721, 1155 ## Abstract -This EIP defines a standard set of custom errors for commonly-used tokens, which are defined as [EIP-20](./eip-20.md), [EIP-721](./eip-721.md), and [EIP-1155](./eip-1155.md) tokens. +This EIP defines a standard set of custom errors for commonly-used tokens, which are defined as [ERC-20](./eip-20.md), [ERC-721](./eip-721.md), and [ERC-1155](./eip-1155.md) tokens. Ethereum applications and wallets have historically relied on revert reason strings to display the cause of transaction errors to users. Recent Solidity versions offer rich revert reasons with error-specific decoding (sometimes called "custom errors"). This EIP defines a standard set of errors designed to give at least the same relevant information as revert reason strings, but in a structured and expected way that clients can implement decoding for. @@ -21,7 +21,7 @@ Ethereum applications and wallets have historically relied on revert reason stri Since the introduction of Solidity custom errors in v0.8.4, these have provided a way to show failures in a more expressive and gas efficient manner with dynamic arguments, while reducing deployment costs. -However, [EIP-20](./eip-20.md), [EIP-721](./eip-721.md), [EIP-1155](./eip-1155.md) were already finalized when custom errors were released, so no errors are included in their specification. +However, [ERC-20](./eip-20.md), [ERC-721](./eip-721.md), [ERC-1155](./eip-1155.md) were already finalized when custom errors were released, so no errors are included in their specification. Standardized errors allow users to expect more consistent error messages across applications or testing environments, while exposing pertinent arguments and overall reducing the need of writing expensive revert strings in the deployment bytecode. @@ -35,7 +35,7 @@ This EIP defines standard errors that may be used by implementations in certain The names of the error arguments are defined in the [Parameter Glossary](#parameter-glossary), and MUST be used according to those definitions. -### [EIP-20](./eip-20.md) +### [ERC-20](./eip-20.md) #### `ERC20InsufficientBalance(address sender, uint256 balance, uint256 needed)` @@ -90,9 +90,24 @@ Used in approvals. - MUST NOT be used for transfer operations. - Use `ERC20InsufficientAllowance` instead. -### [EIP-721](./eip-721.md) +### [ERC-721](./eip-721.md) -#### `ERC721InvalidOwner(address sender, uint256 tokenId, address owner)` +### `ERC721InvalidOwner(address owner)` + +Indicates that an address can't be an owner. +Used in balance queries. + +- MUST be used for addresses whose ownership is disallowed (eg. ERC-721 explicitly disallows `address(0)` to be an owner). +- MUST not be used for transfers. + - Use `ERC721IncorrectOwner` instead. + +### `ERC721InexistentToken(uint256 tokenId)` + +Indicates a `tokenId` whose `owner` is the zero address. + +- MUST be used when attempting to interact with a non-minted or burned token. + +#### `ERC721IncorrectOwner(address sender, uint256 tokenId, address owner)` Indicates an error related to the ownership over a particular token. Used in transfers. @@ -102,17 +117,17 @@ Used in transfers. #### `ERC721InvalidSender(address sender)` -Indicates a failure with the token sender. +Indicates a failure with the token `sender`. Used in transfers. - MUST be used for disallowed transfers from the zero address. - MUST NOT be used for approval operations. - MUST NOT be used for ownership or approval requirements. - - Use `ERC721InvalidOwner` or `ERC721InsufficientApproval` instead. + - Use `ERC721IncorrectOwner` or `ERC721InsufficientApproval` instead. #### `ERC721InvalidReceiver(address receiver)` -Indicates a failure with the token receiver. +Indicates a failure with the token `receiver`. Used in transfers. - MUST be used for disallowed transfers to the zero address. @@ -145,11 +160,11 @@ Used in approvals. - MUST NOT be used for transfer operations. - Use `ERC721InsufficientApproval` instead. -### [EIP-1155](./eip-1155.md) +### [ERC-1155](./eip-1155.md) #### `ERC1155InsufficientBalance(address sender, uint256 balance, uint256 needed, uint256 tokenId)` -Indicates an error related to the current `balance` of a sender. +Indicates an error related to the current `balance` of a `sender`. Used in transfers. - MUST be used when `balance` is less than `needed` for a `tokenId`. @@ -157,7 +172,7 @@ Used in transfers. #### `ERC1155InvalidSender(address sender)` -Indicates a failure with the token sender. +Indicates a failure with the token `sender`. Used in transfers. - MUST be used for disallowed transfers from the zero address. @@ -167,7 +182,7 @@ Used in transfers. #### `ERC1155InvalidReceiver(address receiver)` -Indicates a failure with the token receiver. +Indicates a failure with the token `receiver`. Used in transfers. - MUST be used for disallowed transfers to the zero address. @@ -241,7 +256,7 @@ The main actions that can be performed within a token are: The subjects outlined above are expected to exhaustively represent _what_ can go wrong in a token transaction, deriving a specific error by adding an [error prefix](#error-prefixes). -Note that the action is never seen as the subject of an error. Additionally, the token itself is not seen as the subject of an error but rather the context in which it happens, as identified in the domain. +Note that the action is never seen as the subject of an error. If a subject is called different on a particular token standard, the error should be consistent with the standard's naming convention. @@ -337,7 +352,9 @@ interface ERC20Errors { /// @dev See https://eips.ethereum.org/EIPS/eip-721 /// https://eips.ethereum.org/EIPS/eip-6093 interface ERC721Errors { - error ERC721InvalidOwner(address sender, uint256 tokenId, address owner); + error ERC721InvalidOwner(address owner); + error ERC721InexistentToken(uint256 tokenId); + error ERC721IncorrectOwner(address sender, uint256 tokenId, address owner); error ERC721InvalidSender(address sender); error ERC721InvalidReceiver(address receiver); error ERC721InsufficientApproval(address operator, uint256 tokenId); From 749bb69b50e3512392196e1c03aa200d240de7c7 Mon Sep 17 00:00:00 2001 From: BogdanKTHD <120460094+BogdanKTHD@users.noreply.github.com> Date: Sat, 20 May 2023 07:38:36 +0200 Subject: [PATCH 07/97] Add EIP: Registry for royalties payment for NFTs Merged by EIP-Bot. --- EIPS/eip-6786.md | 105 ++++++++++++++++++ assets/eip-6786/README.md | 27 +++++ assets/eip-6786/contracts/ERC6786.sol | 67 +++++++++++ assets/eip-6786/contracts/IERC6786.sol | 21 ++++ .../contracts/token/ERC721Royalty.sol | 33 ++++++ assets/eip-6786/contracts/utils/IERC2981.sol | 14 +++ assets/eip-6786/test/ERC6786.test.js | 65 +++++++++++ 7 files changed, 332 insertions(+) create mode 100644 EIPS/eip-6786.md create mode 100644 assets/eip-6786/README.md create mode 100644 assets/eip-6786/contracts/ERC6786.sol create mode 100644 assets/eip-6786/contracts/IERC6786.sol create mode 100644 assets/eip-6786/contracts/token/ERC721Royalty.sol create mode 100644 assets/eip-6786/contracts/utils/IERC2981.sol create mode 100644 assets/eip-6786/test/ERC6786.test.js diff --git a/EIPS/eip-6786.md b/EIPS/eip-6786.md new file mode 100644 index 00000000000000..125c145e5cfabf --- /dev/null +++ b/EIPS/eip-6786.md @@ -0,0 +1,105 @@ +--- +eip: 6786 +title: Registry for royalties payment for NFTs +description: A registry used for paying royalties for any NFT with information about the creator +author: Otniel Nicola (@OT-kthd), Bogdan Popa (@BogdanKTHD) +discussions-to: https://ethereum-magicians.org/t/eip-6786-royalty-debt-registry/13569 +status: Draft +type: Standards Track +category: ERC +created: 2023-03-27 +requires: 165, 2981 +--- + +## Abstract + +This standard allows anyone to pay royalties for a certain NFT and also to keep track of the royalties amount paid. It will cumulate the value each time a payment is executed through it and make the information public. + +## Motivation + +There are many marketplaces which do not enforce any royalty payment to the NFT creator every time the NFT is sold or re-sold and/or providing a way for doing it. There are some marketplaces which use specific system of royalties, however that system is applicable for the NFTs creates on their platform. + +In this context, there is a need of a way for paying royalties, as it is a strong incentive for creators to keep contributing to the NFTs ecosystem. + +Additionally, this standard will provide a way of computing the amount of royalties paid to a creator for a certain NFT. This could be useful in the context of categorising NFTs in terms of royalties. The term “debt“ is used because the standard aims to provide a way of knowing if there are any royalties left unpaid for the NFTs trades that took place in a marketplace that does not support them and, in that case, expose a way of paying them. + +With a lot of places made for trading NFTs dropping down the royalty payment or having a centralised approach, we want to provide a way for anyone to pay royalties to the creators. + +Not only the owner of it, but anyone could pay royalties for a certain NFT. This could be a way of supporting a creator for his work. + +## Specification + +The keywords “MUST”, “MUST NOT”, “REQUIRED”, “SHALL”, “SHALL NOT”, “SHOULD”, “SHOULD NOT”, “RECOMMENDED”, “MAY”, and “OPTIONAL” in this document are to be interpreted as described in RFC 2119. + +Every contract compliant with [ERC-6786](./eip-6786.md) MUST implement the interface defined as follows: + +### Contract Interface + +```solidity +// @title Royalty Debt Registry +/// Note: the ERC-165 identifier for this interface is 0x253b27b0 + +interface IERC6786 { + + // Logged when royalties were paid for a NFT + /// @notice Emitted when royalties are paid for the NFT with address tokenAddress and id tokenId + event RoyaltiesPaid(address indexed tokenAddress, uint256 indexed tokenId, uint256 amount); + + /// @notice sends msg.value to the creator of a NFT + /// @dev Reverts if there are no on-chain informations about the creator + /// @param tokenAddress The address of NFT contract + /// @param tokenId The NFT id + function payRoyalties(address tokenAddress, uint256 tokenId) external payable; + + /// @notice Get the amount of royalties which was paid for a NFT + /// @dev + /// @param tokenAddress The address of NFT contract + /// @param tokenId The NFT id + /// @return The amount of royalties paid for the NFT + function getPaidRoyalties(address tokenAddress, uint256 tokenId) external view returns (uint256); +} +``` + +All functions defined as view MAY be implemented as pure or view + +Function `payRoyalties` MAY be implemented as public or external + +The event `RoyaltiesPaid` MUST be emitted when the payRoyalties function is called + +The `supportsInterface` function MUST return true when called with `0x253b27b0` + +## Rationale + +The payment can be made in native coins, so it is easy to aggregate the amount of paid royalties. We want this information to be public, so anyone could tell if a creator received royalties in case of under the table trading or in case of marketplaces which don’t support royalties. + +The function used for payment can be called by anyone (not only the NFTs owner) to support the creator at any time. There is a way of seeing the amount of paid royalties in any token, also available for anyone. + +For fetching creator on-chain data we will use [ERC-2981](./eip-2981.md), but any other on-chain method of getting the creator address is accepted. + +## Backwards Compatibility + +This ERC is not introducing any backward incompatibilities. + +## Test Cases + +Tests are included in [`ERC6786.test.js`](../assets/eip-6786/test/ERC6786.test.js). + +To run them in terminal, you can use the following commands: + +``` +cd ../assets/eip-6786 +npm install +npx hardhat test +``` + +## Reference Implementation + +See [`ERC6786.sol`](../assets/eip-6786/contracts/ERC6786.sol). + +## Security Considerations + +There are no security considerations related directly to the implementation of this standard. + +## Copyright + +Copyright and related rights waived via [CC0](../LICENSE). diff --git a/assets/eip-6786/README.md b/assets/eip-6786/README.md new file mode 100644 index 00000000000000..cc3a5481a726d1 --- /dev/null +++ b/assets/eip-6786/README.md @@ -0,0 +1,27 @@ +
+ +# ERC6786 Royalty Debt Registry + +
+ +This project provides a reference implementation of the proposed `ERC-6786 Royalty Debt Registry`. + +## Install + +In order to install the required dependencies you need to execute: +```shell +npm install +``` + +## Compile + +In order to compile the solidity contracts you need to execute: +```shell +npx hardhat compile +``` + +## Tests + +```shell +npx hardhat test +``` \ No newline at end of file diff --git a/assets/eip-6786/contracts/ERC6786.sol b/assets/eip-6786/contracts/ERC6786.sol new file mode 100644 index 00000000000000..8910fe39930d8b --- /dev/null +++ b/assets/eip-6786/contracts/ERC6786.sol @@ -0,0 +1,67 @@ +// SPDX-License-Identifier: CC0-1.0 +pragma solidity ^0.8.0; + +import "@openzeppelin/contracts/utils/introspection/ERC165.sol"; +import "./IERC6786.sol"; +import "./utils/IERC2981.sol"; + +contract ERC6786 is IERC6786, ERC165 { + + //Mapping from token (address and id) to the amount of paid royalties + mapping(address => mapping(uint256 => uint256)) private _paidRoyalties; + + /* + * bytes4(keccak256('payRoyalties(address,uint256)')) == 0xf511f0e9 + * bytes4(keccak256('getPaidRoyalties(address,uint256)')) == 0xd02ad759 + * + * => 0xf511f0e9 ^ 0xd02ad759 == 0x253b27b0 + */ + bytes4 private constant _INTERFACE_ID_ERC6786 = 0x253b27b0; + + /* + * bytes4(keccak256('royaltyInfo(uint256,uint256)')) == 0x2a55205a + */ + bytes4 private constant _INTERFACE_ID_ERC2981 = 0x2a55205a; + + /// @notice This is thrown when there is no creator related information + /// @param tokenAddress -> the address of the contract + /// @param tokenId -> the id of the NFT + error CreatorError(address tokenAddress, uint256 tokenId); + + /// @notice This is thrown when the payment fails + /// @param creator -> the address of the creator + /// @param amount -> the amount to pay + error PaymentError(address creator, uint256 amount); + + function checkRoyalties(address _contract) internal view returns (bool) { + (bool success) = IERC165(_contract).supportsInterface(_INTERFACE_ID_ERC2981); + return success; + } + + /** + * @dev See {IERC165-supportsInterface}. + */ + function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) { + return + interfaceId == type(IERC6786).interfaceId || + super.supportsInterface(interfaceId); + } + + function payRoyalties(address tokenAddress, uint256 tokenId) external override payable { + if (!checkRoyalties(tokenAddress)) { + revert CreatorError(tokenAddress, tokenId); + } + (address creator,) = IERC2981(tokenAddress).royaltyInfo(tokenId, 0); + (bool success,) = payable(creator).call{value : msg.value}(""); + if(!success) { + revert PaymentError(creator, msg.value); + } + _paidRoyalties[tokenAddress][tokenId] += msg.value; + + emit RoyaltiesPaid(tokenAddress, tokenId, msg.value); + } + + function getPaidRoyalties(address tokenAddress, uint256 tokenId) external view override returns (uint256) { + return _paidRoyalties[tokenAddress][tokenId]; + } +} diff --git a/assets/eip-6786/contracts/IERC6786.sol b/assets/eip-6786/contracts/IERC6786.sol new file mode 100644 index 00000000000000..9ed6d35b9e9f75 --- /dev/null +++ b/assets/eip-6786/contracts/IERC6786.sol @@ -0,0 +1,21 @@ +// SPDX-License-Identifier: CC0-1.0 +pragma solidity ^0.8.0; + +interface IERC6786 { + + /// @dev Logged when royalties were paid for a NFT + /// @notice Emitted when royalties are paid for the NFT with address tokenAddress and id tokenId + event RoyaltiesPaid(address indexed tokenAddress, uint256 indexed tokenId, uint256 amount); + + /// @notice sends msg.value to the creator for a NFT + /// @dev Throws if there is no on-chain information about the creator + /// @param tokenAddress The address of NFT contract + /// @param tokenId The NFT id + function payRoyalties(address tokenAddress, uint256 tokenId) external payable; + + /// @notice Get the amount of royalties which was paid for + /// @param tokenAddress The address of NFT contract + /// @param tokenId The NFT id + /// @return The amount of royalties paid for the NFT in paymentToken + function getPaidRoyalties(address tokenAddress, uint256 tokenId) external view returns (uint256); +} diff --git a/assets/eip-6786/contracts/token/ERC721Royalty.sol b/assets/eip-6786/contracts/token/ERC721Royalty.sol new file mode 100644 index 00000000000000..94a7d652ab0f19 --- /dev/null +++ b/assets/eip-6786/contracts/token/ERC721Royalty.sol @@ -0,0 +1,33 @@ +// SPDX-License-Identifier: CC0-1.0 +pragma solidity ^0.8.0; + +import "@openzeppelin/contracts/token/ERC721/ERC721.sol"; +import "../utils/IERC2981.sol"; + +contract ERC721Royalty is ERC721, IERC2981 { + + address public constant DEFAULT_CREATOR_ADDRESS = 0x4fF5DDB196A32e3dC604abD5422805ecAD22c468; + + constructor(string memory name_, string memory symbol_) ERC721(name_, symbol_) {} + + /** + * @dev See {IERC165-supportsInterface}. + */ + function supportsInterface(bytes4 interfaceId) public view virtual override(ERC721, IERC165) returns (bool) { + return + interfaceId == type(IERC721).interfaceId || + interfaceId == type(IERC2981).interfaceId || + super.supportsInterface(interfaceId); + } + + function royaltyInfo( + uint256 _tokenId, + uint256 _salePrice + ) external view override returns ( + address receiver, + uint256 royaltyAmount + ) { + receiver = DEFAULT_CREATOR_ADDRESS; + royaltyAmount = _salePrice / 10000; + } +} diff --git a/assets/eip-6786/contracts/utils/IERC2981.sol b/assets/eip-6786/contracts/utils/IERC2981.sol new file mode 100644 index 00000000000000..406d2a3ea1673e --- /dev/null +++ b/assets/eip-6786/contracts/utils/IERC2981.sol @@ -0,0 +1,14 @@ +// SPDX-License-Identifier: MIT +pragma solidity ^0.8.0; + +import "@openzeppelin/contracts/utils/introspection/IERC165.sol"; + +interface IERC2981 is IERC165 { + function royaltyInfo( + uint256 _tokenId, + uint256 _salePrice + ) external view returns ( + address receiver, + uint256 royaltyAmount + ); +} diff --git a/assets/eip-6786/test/ERC6786.test.js b/assets/eip-6786/test/ERC6786.test.js new file mode 100644 index 00000000000000..07a03e33bdb865 --- /dev/null +++ b/assets/eip-6786/test/ERC6786.test.js @@ -0,0 +1,65 @@ +const {deployContracts} = require("../scripts/deploy_contracts"); +const {expect} = require('chai'); + +describe("ERC6786", () => { + + let erc721Royalty; + let erc721; + let royaltyDebtRegistry; + const tokenId = 666; + + beforeEach(async () => { + const contracts = await deployContracts(); + erc721Royalty = contracts.erc721Royalty; + erc721 = contracts.erc721; + royaltyDebtRegistry = contracts.royaltyDebtRegistry; + }) + + it('should support ERC6786 interface', async () => { + await expect(await royaltyDebtRegistry.supportsInterface("0x253b27b0")).to.be.true; + }) + + it('should allow paying royalties for a ERC2981 NFT', async () => { + await expect(royaltyDebtRegistry.payRoyalties( + erc721Royalty.address, + tokenId, + {value: 1000} + )).to.emit(royaltyDebtRegistry, 'RoyaltiesPaid') + .withArgs(erc721Royalty.address, tokenId, 1000); + }) + + it('should not allow paying royalties for a non-ERC2981 NFT', async () => { + await expect(royaltyDebtRegistry.payRoyalties( + erc721.address, + tokenId, + {value: 1000} + )).to.be.revertedWithCustomError(royaltyDebtRegistry,'CreatorError') + .withArgs(erc721.address, tokenId); + }) + + it('should allow retrieving initial royalties amount for a NFT', async () => { + await expect(await royaltyDebtRegistry.getPaidRoyalties( + erc721Royalty.address, + tokenId + )).to.equal(0); + }) + + it('should allow retrieving royalties amount after payments for a NFT', async () => { + await royaltyDebtRegistry.payRoyalties( + erc721Royalty.address, + tokenId, + {value: 2000} + ); + + await royaltyDebtRegistry.payRoyalties( + erc721Royalty.address, + tokenId, + {value: 3666} + ) + + await expect(await royaltyDebtRegistry.getPaidRoyalties( + erc721Royalty.address, + tokenId + )).to.equal(5666); + }) +}); From ec29e01f976117de558bd1de9892d14b9d544845 Mon Sep 17 00:00:00 2001 From: "xa6dou.eth" <118254027+a6-dou@users.noreply.github.com> Date: Sat, 20 May 2023 09:47:54 +0400 Subject: [PATCH 08/97] Add EIP: On-Chain EIP-712 Visualization Merged by EIP-Bot. --- EIPS/eip-6865.md | 155 ++++++++++++++ .../eip-6865/contracts/IEIP712Visualizer.sol | 43 ++++ .../contracts/SeaPortEIP712Visualizer.sol | 192 ++++++++++++++++++ ...ent-EIP-712-signature-wallet-interface.png | Bin 0 -> 155621 bytes ...ion-EIP-712-signature-wallet-interface.png | Bin 0 -> 212926 bytes 5 files changed, 390 insertions(+) create mode 100644 EIPS/eip-6865.md create mode 100644 assets/eip-6865/contracts/IEIP712Visualizer.sol create mode 100644 assets/eip-6865/contracts/SeaPortEIP712Visualizer.sol create mode 100644 assets/eip-6865/current-EIP-712-signature-wallet-interface.png create mode 100644 assets/eip-6865/vision-EIP-712-signature-wallet-interface.png diff --git a/EIPS/eip-6865.md b/EIPS/eip-6865.md new file mode 100644 index 00000000000000..0bf78ab6806b7b --- /dev/null +++ b/EIPS/eip-6865.md @@ -0,0 +1,155 @@ +--- +eip: 6865 +title: On-Chain EIP-712 Visualization +description: Visualize structured data highlighting the potential consequences for users' assets +author: Abderrahmen Hanafi (@a6-dou) +discussions-to: https://ethereum-magicians.org/t/eip-6865-on-chain-eip-712-visualization/13800 +status: Draft +type: Standards Track +category: ERC +created: 2023-04-10 +requires: 712 +--- + +## Abstract + +Numerous protocols employ distinct [EIP-712](./eip-712.md) schemas, leading to unavoidable inconsistencies across the ecosystem. To address this issue, we propose a standardized approach for dApps to implement an on-chain view function called `visualizeEIP712Message`. This function takes an abi encoded EIP-712 payload message as input and returns a universally agreed-upon structured data format that emphasizes the potential impact on users' assets. Wallets can then display this structured data in a user-friendly manner, ensuring a consistent experience for end-users when interacting with various dApps and protocols. + +## Motivation + +The rapid expansion of the web3.0 ecosystem has unlocked numerous opportunities and innovations. However, this growth has also heightened users' vulnerability to security threats, such as phishing scams. Ensuring that users have a comprehensive understanding of the transactions they sign is crucial for mitigating these risks. + +In an attempt to address this issue, we developed an in-house, open-source off-chain SDK for wallets to visualize various protocols. However, we encountered several challenges along the way: + +- Scalability: Identifying and understanding all protocols that utilize EIP-712 and their respective business logic is a daunting task, particularly with limited resources. Crafting an off-chain solution for all these protocols is nearly impossible. +- Reliability: Grasping each protocol's business logic is difficult and may lead to misunderstandings of the actual implementation. This can result in inaccurate visualizations, which could be more detrimental than providing no visualization at all. +- Maintainability: Offering support for protocols with an off-chain solution is insufficient in a rapidly evolving ecosystem. Protocols frequently upgrade their implementations by extending features or fixing bugs, further complicating the maintenance process. + +To overcome these challenges, we propose a standardized, on-chain solution that can accommodate the diverse and ever-changing web3.0 ecosystem. This approach would enhance scalability, reliability, and maintainability by shifting the responsibility of visualizing EIP-712 payloads from the wallets to the protocols themselves. Consequently, wallets can use a consistent and effective approach to EIP-712 message visualization. + +The adoption of a universal solution will not only streamline the efforts and reduce the maintenance burden for wallet providers, but it will also allow for faster and more extensive coverage across the ecosystem. This will ultimately result in users gaining a clearer understanding of the transactions they're signing, leading to increased security and an improved overall user experience within the crypto space. + +Currently, most of the wallets display something similar to image below + +![](../assets/eip-6865/current-EIP-712-signature-wallet-interface.png) + +With visualization we can achieve something similar to image below where more insightful details are revealed to user thanks to the structured data returned from the EIP + +![](../assets/eip-6865/vision-EIP-712-signature-wallet-interface.png) + +## Specification + +The key words "MUST", "MUST NOT", "REQUIRED", "SHALL", "SHALL NOT", "SHOULD", "SHOULD NOT", "RECOMMENDED", "NOT RECOMMENDED", "MAY", and "OPTIONAL" in this document are to be interpreted as described in RFC 2119 and RFC 8174. + +Contracts implementing this proposal MUST include the `visualizeEIP712Message` function in the `verifyingContract` implementation so that wallets upon receiving a request to sign an EIP-712 message(`eth_signTypedData`) MAY call the function `visualizeEIP712Message` at the smart contract and chain specified in the EIP-712 message domain separator `verifyingContract` and `chainId` fields, respectively. + +Wallets SHOULD ignore this proposal if the domain separator does not include the `verifyingContract` and `chainId` fields. + +```solidity +/** +* @notice This function processes an EIP-712 payload message and returns a structured data format emphasizing the potential impact on users' assets. +* @dev The function returns assetsOut (assets the user is offering), assetsIn (assets the user would receive), and liveness (validity duration of the EIP-712 message). +* @param encodedMessage The ABI-encoded EIP-712 message (abi.encode(types, params)). +* @param domainHash The hash of the EIP-712 domain separator as defined in the EIP-712 proposal; see https://eips.ethereum.org/EIPS/eip-712#definition-of-domainseparator. +* @return Result struct containing the user's assets impact and message liveness. +*/ +function visualizeEIP712Message( + bytes memory encodedMessage, + bytes32 domainHash +) external view returns (Result memory); +``` + +### Params + +`encodedMessage` is bytes that represents the encoded EIP-712 message with `abi.encode` and it can be decoded using `abi.decode` + +`domainHash` is the bytes32 hash of the EIP-712 domain separator as defined in the EIP-712 proposal + +### Outputs + +The function MUST return `Result`, a struct that contains information's about user’s assets impact and the liveness of such a message if it gets signed. + +```solidity +struct Liveness { + uint256 from; + uint256 to; +} + +struct UserAssetMovement { + address assetTokenAddress; + uint256 id; + uint256[] amounts; +} + +struct Result { + UserAssetMovement[] assetsIn; + UserAssetMovement[] assetsOut; + Liveness liveness; +} +``` + +#### `Liveness` + +`Liveness` is a struct that defines the timestamps which the message is valid where: + +- `from` is the starting timestamp. +- `to` is the expiry timestamp +- `from` MUST be less than `to` + +#### `UserAssetMovement` + +`UserAssetMovement` defines the user’s asset where: + +- `assetTokenAddress` is the token ([ERC-20](./eip-20.md), [ERC-721](./eip-721.md), [ERC-1155](./eip-1155.md)) smart contract address where the zero address MUST represents the Native coin (Native ETH in the case of Ethereum network). +- `id` is the NFT ID, this item MUST ignored if the asset is not an NFT + - if token with `id` doesn’t exist in an NFT collection, this SHOULD be considered as any token within that collection +- `amounts` is an Array of `uint256` where items MUST define the amount per time curve, with time defined within liveness boundaries + - the first amount in `amounts` Array (amounts[0]) MUST be the amount of the asset at `liveness.from` timestamp + - the last amount in `amounts` Array (amounts[amounts.length-1]) MUST be the amount of the asset at `liveness.to` timestamp + - in most of the cases, `amounts` will be an Array with a single item which is MUST be the minimum amount of the asset. + +#### `assetsIn` + +`assetsIn` are the minimum assets which the user MUST get if the message is signed and fulfilled + +#### `assetsOut` + +`assetsOut` are the maximum assets which the user MUST offer if the message is signed and fulfilled + +## Rationale + +### on-chain + +One might argue that certain processes can be done off-chain, which is true, but our experience building an off-chain TypeScript SDK to solve this matter revealed some issues: + +- Reliability: Protocols developers are the ones responsible for developing the protocol itself, thus crafting the visualization is much more accurate when done by them. +- Scalability: Keeping up with the rapidly expanding ecosystem is hard. Wallets or 3rd party entities must keep an eye on each new protocol, understand it carefully (which poses the reliability issues mentioned above), and then only come up with an off-chain implementation. +- Maintainability: Many protocols implement smart contracts in an upgradable manner. This causes the off-chain visualization to differ from the real protocol behaviors (if updated), making the solution itself unreliable and lacking the scalability to handle various protocols. + +### `DomainHash` + +The `domainHash` is much needed by protocols to revert against unsupported versions of its EIP-712 implementation. It identifies the needed implementation in case the protocol implements various EIP-712 implementations (`name`) or to revert if the `domainHash` belongs to a different protocol. + +In the future, if there is a registry that reroutes this EIP implementation for already deployed protocols that can't upgrade the existing deployed smart contract, `domainHash` can be used to identify protocols. + +### Amounts Array + +We suggest using an array of amounts (uint256[]) instead of a single uint256 to cover auctions, which are common in NFT protocols. + +## Backwards Compatibility + +No backward compatibility issues found. + +## Reference Implementation + +openSea Seaport NFT marketplace implementation example is available [here](../assets/eip-6865/contracts/SeaPortEIP712Visualizer.sol) + +## Security Considerations + +`visualizeEIP712Message` function should be reliable and accurately represent the potential impact of the EIP-712 message on users' assets. Wallet providers and users must trust the protocol's implementation of this function to provide accurate and up-to-date information. + +`visualizeEIP712Message` function results should be treated based on the reputation of its `verifyingContract`, if the `verifyingContract` is trusted it means the `visualizeEIP712Message` function results are trusted as the this proposal implementation lives at the same address of `verifyingContract`. + +## Copyright + +Copyright and related rights waived via [CC0](../LICENSE.md). diff --git a/assets/eip-6865/contracts/IEIP712Visualizer.sol b/assets/eip-6865/contracts/IEIP712Visualizer.sol new file mode 100644 index 00000000000000..63e2f4a27f390c --- /dev/null +++ b/assets/eip-6865/contracts/IEIP712Visualizer.sol @@ -0,0 +1,43 @@ +pragma solidity ^0.8.0; + +interface IEIP712Visualizer { + struct Liveness { + uint256 from; + uint256 to; + } + + struct UserAssetMovement { + address assetTokenAddress; + uint256 id; + uint256[] amounts; + } + + struct Result { + UserAssetMovement[] assetsIn; + UserAssetMovement[] assetsOut; + Liveness liveness; + } + + /** + * @notice This function processes an EIP-712 payload message and returns a structured data format emphasizing the potential impact on users' assets. + * @dev The function returns assetsOut (assets the user is offering), assetsIn (assets the user would receive), and liveness (validity duration of the EIP-712 message). + * + * - MUST revert if the domainHash identifier is not supported (require(domainHash == DOMAIN_SEPARATOR, "message")). + * - MUST NOT revert if there are no assetsIn, assetsOut, or liveness values; returns nullish values instead. + * - assetsIn MUST include only assets for which the user is the recipient. + * - assetsOut MUST include only assets for which the user is the sender. + * - MUST returns liveness.to as type(uint256).max if the message never expires. + * - MUST returns liveness.from as block.timestamp if the message does not have a validity starting date. + * - MUST returns a set (array) of amounts in assetsIn.amounts and assetsOut.amount where items define the amount per time curve, with time defined within liveness boundaries. + * - amounts items MUST include the minimum amount. + * - MUST returns the minimum amount if amounts set contains only one item + * + * @param encodedMessage The ABI-encoded EIP-712 message (abi.encode(types, params)). + * @param domainHash The hash of the EIP-712 domain separator as defined in the EIP-712 proposal; see https://eips.ethereum.org/EIPS/eip-712#definition-of-domainseparator. + * @return Result struct containing the user's assets impact and message liveness. + */ + function visualizeEIP712Message( + bytes memory encodedMessage, + bytes32 domainHash + ) external view returns (Result memory); +} diff --git a/assets/eip-6865/contracts/SeaPortEIP712Visualizer.sol b/assets/eip-6865/contracts/SeaPortEIP712Visualizer.sol new file mode 100644 index 00000000000000..43144c633901c6 --- /dev/null +++ b/assets/eip-6865/contracts/SeaPortEIP712Visualizer.sol @@ -0,0 +1,192 @@ +// SPDX-License-Identifier: MIT +pragma solidity 0.8.17; + +import {IEIP712Visualizer} from "./IEIP712Visualizer.sol"; + +contract SeaPortEIP712Visualizer is IEIP712Visualizer { + bytes32 public constant DOMAIN_SEPARATOR = + 0xb50c8913581289bd2e066aeef89fceb9615d490d673131fd1a7047436706834e; //v1.1 + + enum OrderType { + FULL_OPEN, + PARTIAL_OPEN, + FULL_RESTRICTED, + PARTIAL_RESTRICTED, + CONTRACT + } + + enum ItemType { + NATIVE, + ERC20, + ERC721, + ERC1155, + ERC721_WITH_CRITERIA, + ERC1155_WITH_CRITERIA + } + struct OrderComponents { + address offerer; + address zone; + OfferItem[] offer; + ConsiderationItem[] consideration; + OrderType orderType; + uint256 startTime; + uint256 endTime; + bytes32 zoneHash; + uint256 salt; + bytes32 conduitKey; + uint256 counter; + } + + struct OfferItem { + ItemType itemType; + address token; + uint256 identifierOrCriteria; + uint256 startAmount; + uint256 endAmount; + } + + struct ConsiderationItem { + ItemType itemType; + address token; + uint256 identifierOrCriteria; + uint256 startAmount; + uint256 endAmount; + address payable recipient; + } + + constructor() {} + + function visualizeEIP712Message( + bytes memory encodedMessage, + bytes32 domainHash + ) external view returns (Result memory) { + require( + domainHash == DOMAIN_SEPARATOR, + "SeaPortEIP712Visualizer: unsupported domain" + ); + + OrderComponents memory order = abi.decode( + encodedMessage, + (OrderComponents) + ); + + UserAssetMovement[] memory assetsOut = new UserAssetMovement[]( + order.offer.length + ); + + for (uint256 i = 0; i < order.offer.length; ) { + uint256[] memory amounts = extractAmounts(order.offer[i]); + assetsOut[i] = UserAssetMovement({ + assetTokenAddress: order.offer[i].token, + id: order.offer[i].identifierOrCriteria, + amounts: amounts + }); + + unchecked { + ++i; + } + } + + ConsiderationItem[] memory userConsiderations = fliterByRecepient( + order.consideration, + order.offerer + ); + UserAssetMovement[] memory assetsIn = new UserAssetMovement[]( + userConsiderations.length + ); + + for (uint256 i = 0; i < userConsiderations.length; ) { + uint256[] memory amounts = extractAmounts(userConsiderations[i]); + + assetsIn[i] = UserAssetMovement({ + assetTokenAddress: userConsiderations[i].token, + id: userConsiderations[i].identifierOrCriteria, + amounts: amounts + }); + + unchecked { + ++i; + } + } + + return + Result({ + assetsIn: assetsIn, + assetsOut: assetsOut, + liveness: Liveness({from: order.startTime, to: order.endTime}) + }); + } + + function fliterByRecepient( + ConsiderationItem[] memory consideration, + address recepient + ) private view returns (ConsiderationItem[] memory) { + uint256 recepientItemsCount; + for (uint256 i = 0; i < consideration.length; ) { + if (consideration[i].recipient == recepient) { + unchecked { + ++recepientItemsCount; + } + } + + unchecked { + ++i; + } + } + ConsiderationItem[] memory result = new ConsiderationItem[]( + recepientItemsCount + ); + uint256 resultIndex; + for (uint256 i = 0; i < recepientItemsCount; ) { + if (consideration[i].recipient == recepient) { + result[resultIndex] = consideration[i]; + unchecked { + ++resultIndex; + } + } + + unchecked { + ++i; + } + } + + return result; + } + + function extractAmounts( + OfferItem memory offer + ) private pure returns (uint256[] memory) { + uint256[] memory amounts = new uint256[](2); + if (offer.endAmount == offer.startAmount) { + uint256[] memory amounts = new uint256[](1); + amounts[0] = offer.startAmount; + return amounts; + } else if (offer.endAmount > offer.startAmount) { + amounts[0] = offer.startAmount; + amounts[1] = offer.endAmount; + } else if (offer.endAmount < offer.startAmount) { + amounts[0] = offer.endAmount; + amounts[1] = offer.startAmount; + } + + return amounts; + } + + function extractAmounts( + ConsiderationItem memory consideration + ) private pure returns (uint256[] memory) { + uint256[] memory amounts = new uint256[](2); + if (consideration.endAmount == consideration.startAmount) { + uint256[] memory amounts = new uint256[](1); + amounts[0] = consideration.startAmount; + return amounts; + } else if (consideration.endAmount > consideration.startAmount) { + amounts[0] = consideration.startAmount; + amounts[1] = consideration.endAmount; + } else { + amounts[0] = consideration.endAmount; + amounts[1] = consideration.startAmount; + } + return amounts; + } +} diff --git a/assets/eip-6865/current-EIP-712-signature-wallet-interface.png b/assets/eip-6865/current-EIP-712-signature-wallet-interface.png new file mode 100644 index 0000000000000000000000000000000000000000..9e2a8fb009ff3fa8f046873141f9fb43b1bd4812 GIT binary patch literal 155621 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

e;3xnfrf!_FJ# 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 z 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 literal 0 HcmV?d00001 diff --git a/assets/eip-6865/vision-EIP-712-signature-wallet-interface.png b/assets/eip-6865/vision-EIP-712-signature-wallet-interface.png new file mode 100644 index 0000000000000000000000000000000000000000..c7bc75c4bb97c8edc0b11af59b7a5da0b4f0c69e GIT binary patch literal 212926 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

vrF*7iujl_JBgk*pcMqesp)l$Xv?NKM)NY`=t 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 z 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 literal 0 HcmV?d00001 From 2a4285b1aa6fb2224dbaa79bf826b9198d97bd00 Mon Sep 17 00:00:00 2001 From: Alex-Klasma <107881025+Alex-Klasma@users.noreply.github.com> Date: Fri, 19 May 2023 22:54:31 -0700 Subject: [PATCH 09/97] Update EIP-6065: Move to Review Merged by EIP-Bot. --- EIPS/eip-6065.md | 51 ++++++------------ .../{ERC6065.sol => Implementation.sol} | 0 assets/eip-6065/corporate-structure.png | Bin 846219 -> 527857 bytes 3 files changed, 15 insertions(+), 36 deletions(-) rename assets/eip-6065/{ERC6065.sol => Implementation.sol} (100%) diff --git a/EIPS/eip-6065.md b/EIPS/eip-6065.md index fcb237a52c204d..f36cf08b809a24 100644 --- a/EIPS/eip-6065.md +++ b/EIPS/eip-6065.md @@ -4,7 +4,7 @@ title: Real Estate Token description: An interface for real estate NFTs that extends ERC-721 author: Alex (@Alex-Klasma), Ben Fusek (@bfusek), Daniel Fallon-Cyr (@dfalloncyr) discussions-to: https://ethereum-magicians.org/t/updated-eip-6065-real-estate-token/11936 -status: Draft +status: Review type: Standards Track category: ERC created: 2022-11-29 @@ -19,7 +19,7 @@ This proposal introduces an open structure for physical real estate and property Real estate is the largest asset class in the world. By tokenizing real estate, barriers to entry are lowered, transaction costs are minimized, information asymmetry is reduced, ownership structures become more malleable, and a new building block for innovation is formed. However, in order to tokenize this asset class, a common standard is needed that accounts for its real world particularities while remaining flexible enough to adapt to various jurisdictions and regulatory environments. -Ethereum tokens involving real world assets are notoriously tricky. This is because Ethereum tokens exist on-chain, while real estate exists off-chain. As such, the two are subject to entirely different consensus environments. For Ethereum tokens, consensus is reached through a formalized process of distributed validators. When a purely-digital NFT is transferred, the new owner has a cryptographic guarantee of ownership. For real estate, consensus is supported by legal contracts, property law, and enforced by the court system. With existing asset-backed ERC-721 tokens, a transfer of the token to another individual does not necessarily have any impact on the legal ownership of the physical asset. +Ethereum tokens involving real world assets (RWAs) are notoriously tricky. This is because Ethereum tokens exist on-chain, while real estate exists off-chain. As such, the two are subject to entirely different consensus environments. For Ethereum tokens, consensus is reached through a formalized process of distributed validators. When a purely-digital NFT is transferred, the new owner has a cryptographic guarantee of ownership. For real estate, consensus is supported by legal contracts, property law, and enforced by the court system. With existing asset-backed ERC-721 tokens, a transfer of the token to another individual does not necessarily have any impact on the legal ownership of the physical asset. This standard attempts to solve the real world reconciliation issue, enabling real estate NFTs to function seamlessly on-chain, just like their purely-digital counterparts. @@ -55,18 +55,7 @@ interface IERC6065 is IERC721 { event Foreclosed(uint256 id); /* - Next getter functions return immutable data for NFT. You may implement in a struct like: - - struct EIP6065Immutable { - string legal_description_of_property; - string street_address; - string geo_json; - string parcel_id; - string legal_owner; - bytes32 operating_agreement_hash; - } - - and store that in a mapping, however this specific storage method is left to the implementor. + Next getter functions return immutable data for NFT. */ function legalDescriptionOf(uint256 _id) external view returns (string memory); function addressOf(uint256 _id) external view returns (string memory); @@ -81,17 +70,7 @@ interface IERC6065 is IERC721 { It's recommended that administrators only use a single token type to denominate the debt. It's unrealistic to require integrating smart contracts to implement possibly unbounded tokens denominating the off-chain debt of an asset. - If the foreclosed status == true, then the RWA asset can be seen as severed from the NFT. The NFT is now "unbacked" by the RWA. - - You may implement in a struct like: - - struct EIP6065Mutable { - address debt_token; - int256 debt_amt; - bool foreclosed; - } - - and store that in a mapping, however this specific storage method is left to the implementor. + If the foreclosed status == true, then the RWA can be seen as severed from the NFT. The NFT is now "unbacked" by the RWA. */ function debtOf(uint256 _id) external view returns (address debtToken, int256 debtAmt, bool foreclosed); @@ -106,7 +85,7 @@ interface IERC6065 is IERC721 { Real world assets operate in messy, non-deterministic environments. Because of this, validating the true state of an asset can be murky, expensive, or time-consuming. For example, in the U.S., change of property ownership is usually recorded at the County Recorder’s office, sometimes using pen and paper. It would be infeasible to continuously update this manual record every time an NFT transaction occurs on the blockchain. Additionally, since real world property rights are enforced by the court of law, it is essential that property ownership be documented in such a way that courts are able to interpret and enforce ownership if necessary. -For these reasons, it is necessary to have a trusted party tasked with the responsibility of ensuring the state of the on-chain property NFT accurately mirrors its physical counterpart. By having an Administrator for the property who issues a legally-binding digital representation of the physical property, we are able to solve for both the atomic transfer of the property rights with the transfer of the NFT, as well as institute a seamless process for making the necessary payments and filings associated with property ownership. This is made possible by eliminating the change in legal ownership each time the NFT changes hands. An example Administrator legal structure implemented by Klasma Inc. for property tokenization in the U.S. is provided in the [Reference Implementation](#reference-implementation). While a token that implements this standard must have a legal entity to conduct the off-chain dealings for the property, this implementation is not mandatory. +For these reasons, it is necessary to have a trusted party tasked with the responsibility of ensuring the state of the on-chain property NFT accurately mirrors its physical counterpart. By having an Administrator for the property who issues a legally-binding digital representation of the physical property, we are able to solve for both the atomic transfer of the property rights with the transfer of the NFT, as well as institute a seamless process for making the necessary payments and filings associated with property ownership. This is made possible by eliminating the change in legal ownership each time the NFT changes hands. An example Administrator legal structure implemented for property tokenization in the U.S. is provided in the [Reference Implementation](#reference-implementation). While a token that implements this standard must have a legal entity to conduct the off-chain dealings for the property, this implementation is not mandatory. ### Guiding Objectives @@ -146,9 +125,9 @@ These identifiers, especially `legalOwnerOf`, allow for individuals to verify of ### debtOf -A readable value of debt and denoted currency that is accrued to the property. A positive balance signifies a debt against the property, while a negative balance signifies a credit. +A readable value of debt and denoted currency that is accrued to the property. A positive balance signifies a debt against the property, while a negative balance signifies a credit which can be claimed by the NFT owner. This is a way for the property administrator to charge the NFT holder for any necessary payments towards the property, like property tax, or other critical repairs or maintenance in the "real world". A credit might be given to the NFT holder via this same function, perhaps the administrator and the NFT holder had worked out a property management or tenancy revenue-sharing agreement. -The `debtOf` function also returns the boolean foreclosure status of the asset represented by the NFT. A true result indicates the associated property is no longer backing the NFT, a false result indicates the associated property is still backing the NFT. +The `debtOf` function also returns the boolean foreclosure status of the asset represented by the NFT. A true result indicates the associated property is no longer backing the NFT, a false result indicates the associated property is still backing the NFT. An administrator can foreclose an asset for any reason as specified in the `Operating Agreement`, an example would be excessive unpaid debts. Smart contracts can check the foreclosure state by calling this function. If the asset is foreclosed, it should be understood that the RWA backing the NFT has been removed, and smart contracts should take this into account when doing any valuations or other calculations. There are no standard requirements for how these values are updated as those details will be decided by the implementor. This EIP does however standardize how these values are indicated and read for simplicity of integration. @@ -164,9 +143,9 @@ This EIP is backwards compatible with ERC-721. However, it is important to note ## Reference Implementation -Klasma Labs offers a work in progress reference implementation (*see pull request above*). The technical implementation includes the following additional components for reference, this implementation is not required. +Klasma Labs offers a work in progress [reference implementation](../assets/eip-6065/Implementation.sol). The technical implementation includes the following additional components for reference, this implementation is not required. -Summary of Klasma Inc's implementation: +Summary of this implementation: * NFT burn and mint function * Immutable NFT data (unique identifiers and operating agreement hash) @@ -177,23 +156,23 @@ Summary of Klasma Inc's implementation: ### Legal Structure Implementation -This section explains the legal structure and implementation Klasma Inc. employs as an Administrator of this token. The structure detailed below is specific to property tokenization in the U.S. in the 2023 regulatory environment. +This section explains the legal structure and implementation a company may employ as an Administrator of this token. The structure detailed below is specific to property tokenization in the U.S. in the 2023 regulatory environment. -This section details an implementation of the legal standard by Klasma Inc. specifically for property tokenization in the U.S. in the 2022 regulatory environment. +This section details an implementation of the legal standard that could be used by a company specifically for property tokenization in the U.S. in the 2022 regulatory environment. -![corporate-structure|690x388](../assets/eip-6065/corporate-structure.png) +![Corporate Structure Image](../assets/eip-6065/corporate-structure.png) -The Klasma Inc. legal structure for U.S. this token is as follows: +The legal structure for this token is as follows: -* Klasma Inc., a parent company and property Administrator, owns a bankruptcy remote LLC for each individual property they act as Administrator for. +* A parent company and property Administrator, owns a bankruptcy remote LLC for each individual property they act as Administrator for. * The bankruptcy remote LLC is the owner and manager of a DAO LLC. The DAO LLC is on the title and deed and issues the corresponding NFT and operating agreement for the property. * This structure enables the following three outcomes: 1. Homeowners are shielded from any financial stress or bankruptcy their physical asset Administrator encounters. In the event of an Administrator bankruptcy or dissolution the owner of the NFT is entitled to transfer of the DAO LLC, or the sale and distribution of proceeds from the property. 2. Transfer of the rights to the property are atomic with the transfer of the NFT. The NFT represents a right to claim the asset and have the title transferred to the NFT owner, as well as the right to use the asset. This ensures the rights to the physical property are passed digitally with the transfer of the NFT, without having to update the legal owner of the property after each transfer. -Security note: In the event of a private key hack Klasma will not be able to reissue a Home NFT. Klasma home NFT owners who are not confident in their ability to safely store their home NFT will have varying levels of security options (multi-sigs, custodians, etc.). For public, large protocol hacks, Klasma may freeze the assets using the Blocklist function and reissue the home NFTs to the original owners. +Security note: In the event of a private key hack the company will likely not be able to reissue a Home NFT. Home NFT owners who are not confident in their ability to safely store their home NFT will have varying levels of security options (multi-sigs, custodians, etc.). For public, large protocol hacks, the company may freeze the assets using the Blocklist function and reissue the home NFTs to the original owners. Blocklist functionality is to-be-implemented in the reference implementation above. ## Security Considerations diff --git a/assets/eip-6065/ERC6065.sol b/assets/eip-6065/Implementation.sol similarity index 100% rename from assets/eip-6065/ERC6065.sol rename to assets/eip-6065/Implementation.sol diff --git a/assets/eip-6065/corporate-structure.png b/assets/eip-6065/corporate-structure.png index 2fe581eafe4f7406d3dcea1773b0d4e857305943..75c442293345cef688bec5ae2ad050c5668d5d11 100644 GIT binary patch literal 527857 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�N-9-XOtl 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≤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

aP|28k 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

q5MM&E4OJARj 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

ebz48hhLS{ z?OPHEvYyV&sD#wpic3mhLiPChb3vaFVC(p0eC&E}4&FDgLb)FbHCWDn>h4ZZfhC@p z0ENSMpRoJM0oD~OGe@$KA^qb<%Sxzq2C zGS(siO7dcILl@Wt^9u|07tA@OLjRL*Vu65$`x8?99@E$3{)jTkP#+r?eRL+Dq^Y%R z6fL{@JN^58%FJlG->j!>e@tNIImsYO$|J_p1gH+;ay0#5&F9rcpL2y_q>&pK-TxKW z5;zk=I5LB`u+@IOv~)|07sjc!Ron-td3Np$PPGgq@fhN>Ug1f0VJ77-^)%8Q*>2Nu z-gvhF5Ug*Bu_hhX7tEo|h>P9@YdJx0e)P|I!8_?W8=vyoSvi52cJDCpw}agPu=Wm( zRR{v$VaOx3077FQ(hc$RnE`*rwE(YG0gn)1tQR-Nj@i}1g2VpS$&YAa&>DYf`|<_g zyQ>uQpR-3gdve(VD z!hIoKUcB$k`lxlr_cwlK3hFrl*9VDD!P~?5)>GL7l8z#$w_pgQ2-tF52#=0N;sS%c zH^})`t@rd^{6eTM!QevVsx+31tKq0agk1>zOwldT-Hx0TOekQQGZ&M_X4FVYPn0Z5 zBG&0B_?Xa-uAwR=4kUhY1Nml}pMq2D3yu63&Ym5%8(2z$%8AbiG!5?GsFxE<958u_ zR{`~+ys+@pZ!_0N%7&7F>T(9ob1Th>G(&DJO(r`x0#Xr3LFH~Ux5J?+)<>Bub+`zz z8h9gAa4ji;QRB9RYc;0B3m>KxXrJ$kp+sS*d6}CZRJmg`BGXu8CI9Yw4{Pb!_C)&UR^78O70Qq~O&ViG2T6ClJ)=4KD z?(avUhcz-=QG!t%Uz~@1Y&jhRvM-7vCPp>}eVsnNy^v4-^_Q;sUi*b4(fK`EF}9k> zCPq_ZHTo(igh?q3&LkcVeU&TlC3=(7j>Dy!fq2yGL&~DT1^%*+V_ywE zR-?KkOXnR1Y7ZKXB0vI=-%Z<3&ZA8Kpa?iFZ=d;(4*Op5fLb$mruR8Q&+_VK{=XqM zJN!3BlFj^92ge+%H?pQ89aUdJT5;cJ8G z;H$Cd(d;5G5s6*)<(`Xg&ljY>o}d1e;q6^9)i>5Z5K60h{6p~JXaD0Kko^XXFdec? zY|}$=sgP$tZlh~;Kl}DGU4uW1i}&U1LA|}3@ZLb1L`X#|dYA^CQAdD)u&{37Cq(N2 zS@>}Tt8-IvlVY0BH1B`}9>j%R1VIWE4yf9p)TPaYSn$C&iVC=7GBxaCR_pHW2I~)^ zt|<`zjNH|73c%u&JvK&7>0iP9&e=7EY$3Q5%URM)ft3d7eLdt650c-7psZ)I1W)X6 zF%Vtgt1rDAG=D%_9x~&q`flnkY4V?C|krA-e^Q4C_ zT;oda6d{vM6=l2jdf<~3;BNYlb#;d?+cd>pq;Fhb=aAzP6q#KKN3ujzaKm+rJSG|Q z1vIE-)+dtOIcqsdvE(cc_V(Ygd*{&*CX?M;Q$xtSQcWsq!YLugWAiRvd;Q}cgIz9> zNQ5N57=9VnJ%{1;G*~#?-pc?;b3)@m2ml3U+6)h)~Yr>6M@%?4H|&phZV)X^h8TCAM= z5Lwz+^}C&V#%E>Z(e~N8T)WKZPknumv>qcEa3Yd;cwj&+4Yr-Lpmu@paF-Cb?~Mp% zS4tw<)GJ7`X2=85{P@l}dUv#RR##G?nv#C)hYH!^p zA4d;oEa8Lu!KynOe!5%tD?D;iu8TMi4-pRT-c9%e9IUUSgXGfzh<@}!Xh=x5kcsvP zs%tcdOvs5-do-P5XYHKN1;B&8xo#4|WGr7X03X`ieEZq|!j)U!^JIs0WDeZ@_3G4% z37mB|K4}|6^Gv>X6E_dIyOgnCNO>g)^_^~!bnrvTB)}wa|C*m+*s-~$#^Q7phH&l; zoaR?Rb&A~Sfz2A~$e!OH^MYQO(hoTk3?iZf%v44n{1o_< zF5(3}kcIK#zJl{*Oz6@SCcyCLXF5wcNE8IHWvtH8_q{|}Y&LL)g*b#t|DN!6zl*brvcnhLW%_mR5f<5f#PrhifYGQ}paKh}#= zBH9u1GkmS;jIRb)e7k;ZN?5V9dUS+Eso>(ljp@6|s%3v$*#OSm<`r5yG^lfg%myj) zXVdP%Jrj5uEJ&6Uyb}mL?d{GmL5Q&?`LONAGzZ$;$9%?ydS(V4EiITdCX4{lZAn+^ zZfk3U&ak6{c`3UeOVkGTLzzt*q{Z&g&|%hz-QK>bWVje;!cghg*1Uh~G+ATFKW_DN z+3P=ps|HDaUkn+QGnQ_Q;ic@rKywt%G5J7qMGP1UW;0a~4$_8bTy0Y1fx%TPss%hz z?VS8>&d%yH@UK?;JIRz|F%l=B1Bf8|HVH*f+$j`G@PtJ;R^!0_A%%s=5_eS?0Toi^~ z2hW%|F{)h~S^GuLAPxi zsn(KqpIO+Y093WgYG`NxC2qmU(6AI_YAoO;C+&_tEFO^jkk@rv|Nr0yP>|U;lf!K! znOD_)GhL#u%w?(LrQ5OMs;Yv~-?!s$;B>w5*7#4h%LBiNe6z~)89q;6FHcteY;HVn z`iNoSucP1GJDn-Be!pdF!uqe%>-uY@*a+r% z)6=)FqV@q9cBrN%;$*0wZl(_6`Ny?+V-;P10^vQc3D3(*TGe_|MG(GFpaX6wKd|vvonJyCzCbLm)k#= z{o<_Kv;sxoWuY%4`W|sD$sMD+=Pw=;;wWx0u%dFgeqH*zMoOW<+z7PeD@XA&h=D{1 zRN@~J!=WI?yVP9%*3;%4%hUwDH?R$jQh(RjxK~h6kXEm8d#b4cRdnPRD)>sm2wDAF z3rTPMsEB%K>>X-lQ86vzyR798G508$5d~*vp)d@ND6(x1w6^;z6 z|6h-+FkyZEc=Z|Rvi$=CJ?Z=?tHrBSZg9gZjJL$^`y!+2@#Q$kyfHz%fpwi|;s9y= z)>=Ce;1o?r(|f3y+7fR?UQk+E%Bq&Y*Lqhzrar+w-hstb)o~WYk|?e}u#dTP_3F>D zF*YtP{Yb)&a}gG+?&tWfLfPV}mVD>VnQLe#N=>+ljcaBLJAtzg4yvy;(%TfDhGWI2 zPxXQ}#cvfLZD*ni7(|BeoHz<`Z!kOfFmQ-^WlaFGIg=8f&zVAfyA|f#$RPnSAw|xf z)1hXnsCWGn5AMBB;lpcDBHQnzoISXcyGhaz6P^>W$Xq=ezq+ zB!mneT8bA@5;Z$2-zUSns9f-qce9q|Q43Mj%djLOUIWvwHjFsTVRHQZRv zUTCwc=t;4JepULA!eFPW_wtJ8tD}Wo<$i}GCQrPuMIftUX#BV9J$u}5GPiaEjLiM= zOjBBEl&b3? zED3oRk8$eVyU5GxLZ8+-x#jK)JhYTVW|n5FS2dwQL9m%SZZ)2ujyBHFOLP#tyBD{% z($RrnAn31s51a$_T^f%|{pf%F?=CPP5JdZp`E3mPkdJTG+2WsH{>fR z-u+`X_kD{$kK%PfG8dq1uo6HxNsMvb8)oXF3Rvqhs^u_^O5+^7L4n6F3{M{PoOp%G zu(L(G1JRG^WnYXF3jB+;7lwA$+NXy1LA69lEG8b<2|LMCu(CisG%?{+mQ|23A;6VA z#zVlrAqZxr=!fs33TMD;E*Y}}h%qW3%_vSk>HJi&4V$ck&GqeZ%)AM+N6OZ^ z$z-3sre$pr`7Kxns1;upQ-whdgmbh^tCCeWiA>D&5>)M-iEtQds zf3;#j8$`I5T~PRE6Wh*bwo11Z8`Chv^o}!X{J4bO7MV|0)dFqSE#$HYF=qV`15HFT zU>3w?Xh^#N`U4Qjj2Z}~k<#kX2s?afD7PWE+^?Zc!`qN*KyYKZMnIY53Se6H1=hmF zEelusY99`Z?I2sgw@IRZEzb^O17XV{TXIm&`|x236#lW|LYd*9>qvrV9{S4XoCSqLs!B+yn@`@5S z?c3L{P4wfhH0mobnC$)F!W_zY4F6fwPEiue>~G5RB!aBAph`k)wtziV@q-5=0MNL1 z?Shs8Q7%wIIS+agx_6q)iCScnDl+Z>B32ej@PzRgNnZ8A z-qtp23pIHI;d>At)qU`V6}VgcA3d_x)z!7M%;k>b-mxyOz&Ck}95IdOqnhjMDburs z6r~%2r)~OQo}$P++27W7oSYQV_mAUTD)n}>7C&Bt%GxYgR5|gd#odx%XPhsvl}4K6 zw&;oSY0^6>O3$yGx{oc8x_G!3ZF#wp}=vQ59bH(Wza zHl77H+eL5ibUaCQNs-(AJVgA(bF8OS1nVblN7WNlEHdU_qj99+O&kV!_sc|HqX;L#;u%kXn zxU;Fr7I}W)vBF*5v@!*9+Z_?C{PY+1DC{%MewaX|hWKnWkyz@o?$|*bRnWdc!xzBk zZ*>qvY^L*Y{`e?=l_8W7t>IP0=W-OBuu;Vpup&ruR%d!=b26sA@^C>1db-10GFJ3| z(=lilMeX?luAFh(J$Y7se*Syu=}bJ^JK>$HrHFX7W%hO;KZ>xLnXd$}+VL|E$r1=E zjDK^405?HJ#j=-=AJZ&3^b~_ePG@1+ea}+NK6%hK`4o@t`%-vdhQKb zEKWllbC6KeB-mP6b)h*Yx4DJ`E0>qzpK|`Y>3d{nW?S!#i~N`tFVXAE6J)^Jf_%Yir13eI__a?18Xr@@NLZ%0}+MgsyWGZ?v%Bb;GVCW3N zMB?AIMugSv`9LEi^*-t{FfgEJ@|qpEHOHW_ymz&Ft-0D8K@$y*YdOJwKFV<0Y%t8o z#nx3o@KCb|`mxP!zxD3TdB2S|ubK55@{49^hx2fnq8vM478VsrrQ+5$I12Au--XKM z7*9#8PZOcM;3{VcGafvq7<>zDDKjU`q+BPB$Zf7R#qS|`TS#9y0@EYgeU32^5vV}d zcSL>b=(vsyL2$uA4ips^*A~R@SGEG&572Y7b_ozJ@*g4vY(gA-pC%I}`2Epzt-j(G z|A!F2^H@-x(z!Ry|AwS|#ZAz59}aokHkZGHe>gZhCr2t`Ecm@2-`XWb+71JWArceg z6V^8x!yO$RSb2C)wCOG?s?HK^Er*=FCWFEO98wirYW zP6pTkz|V<)!JW*&?r<7?n@MK4H(PFm(P8vjr!92JKb~2be0VmhZgEM8u2<875XK{VOrnwHvBrnbpfb zB9V3XXQm&3#ox4uP51Rbin*o;#2WhM@*LpK7dzNFC=%tYYMt}uNCE@6rzueOy}9`sc#2ZB6%-c-E`Abx_NuTD zlU^*ctANgv=-x+;V3UK+_YOvyi-)#l!q~Q$aPat0Ov`S7Rb%2Wq%R-#@l@;X>cRvA zQ4j2&&w*mb7Ok|E5M6^<`J#T%zzX*TT%(|*2qbLu2KaKjpRp;E(3d?y&Euhc|RlHIqD^cuZ0g_k^%uj z3isE7IN~J0YYs6A(>>aywXtN;S+669uh1v#Yw^~*b95B%h+w+|)h}y3JL6O_I3Hc^ zVd85Di;FK|QBGz*V`_Sv4nef;4d;!n^#)LZ;w=d43$0bj(U0)IoY!_~rkRV{2Qi@L z5Xd5wMCsClW?^<|3m$-!U?ceDx(%t}{UX-lKPs%isK~F_0OR)dhP2F74UYBS2NThv zK_7O+$k#$gioz4QxJF8#sud!%L9gx)nB=H;h&CWi8 z7@5n((I%O{{i_Sp>&ItGlx@5o3%}*n40?p-&W)!NT3_prX~AyL>8wmV%D6hS>PN1& z858U$nezmV7-#hy+k)ZfiJy-$e5I?V{LU|jO4U}m&D@{kI&x%_8zMXT2^>zK(Uf;I zOP5>9Y2-uVYWWYFV7bh;bCw(OSIu46fFjCBQ#f%7^#CSnyB+?20c{BJX{au-Jc3wZynwe>a+5x)wERZzK~qqWY@ z7xFi?b+Xnb#m=?#oFv%XxG@iy`cplddk*6+v2%0;gEP^q%gUFjWT)dfh?byRWkKFY z;_i_q1Tl^VMK@PTBCv&n@}qPq z48e`XnW=WejtGuBMiQ{<4bGYMOu9Uj4=cH3QRDc%^v{b53yA^6FO$YoUAWi)^u44r zQn&k#2dC=kVg&&}CKJn(aWvo; zAu;fodzTZd(tTR@9}CC!v9*qkS}cUJU6z$P{zr{Tqh@IOTuv_Vqy$CXOG)Vz1xg=vqX6I^GJVbg5GF`rL@dR z7K`wRE$Uit{pmVRz7$vt`NE|6Ry=GAR|r4wc#I*%%w4* zpdgYt;%#zqG$`IHBgwC>ey-)Xa9P$o`wP!y77cXco@&4XijH8cIlw>5%NlO z`nqyOU6EUho4zSCRsHuh(|6tvXr%<@?>vp0BsZ63cyD$*FC zLCO+Y@E_$@-?Na{;4gSp^DWxuU9hmZecsqOQS3alX6MQox$9rmmu=IS`~-bXq|P=z zn>=@5?j9T|l|vd|zS|QSG*GOD2OBmCadS-#ER^6~9!7ruHQs8te;G%2f}pmwh|- z{sxk2?cs5MH)+>-_C)#ozu8qKbIPJtE_q6Co_%#`ldz_@Pfz2Cb6c;?EA=wEpiFbOe%$^J&u&yEe94%GK6x^MHOEOTYUJ#Duy{h&SrVDw9{P7< zc<%uZJ?VLME$1n$cvoL)YidUED5sr_k24@KM%*qtlSC5mgZ`qZk$VqD&^qd_K_8*C zr!zBY@DF+NKBmRS2Eu);MT(C&XoR(4*sLfok8hOn2QZOmP7xtvq6?mAJ1H8e)}hu+ zb_#|%c9K!tufb1!EQseotX8*o3Tn6}bwm}#4n^`1k;raAPe=OK;}8hH|3SK(0t8y} z@xj{dJ}Jvy{;pTwr>EYUU?M+daVRdMNW0|M<8V#&w3c~fn zgYIFS_)hI}ff@WCzZ$z<=&*k1EDgHC=WHI0`5jC$g2rKjX_B0a79*6Dlq4}i+Q|ds z^#&owSX)-_%Gw6dURH}K(5$~I3VLm$McOJH%pVDshu^l4tzvw7;k7jD`HOr2x;)k7 zJ7}+k+(});!_=nVbpLW8oKO&|sk4!{Wh?!G^AYRJ#<5#X$!r3>IONoxP514Sp7^lU z%b9dR_U)uy((dJR&XDEi7`QR~8UgcidSv7GJg6UeO8m0j+4dZ2i0iS*T4ZryNeiU27(LKyi#Xg4=>Sij92P@_ol4L)d#_#Vto#%Ul z{sEAfSPVAzSJ{H(9Q&f4xodUb4_arhLj}R{etk4mx+AxGeaaDB-q+9<$;q5GGE%?> zw0d)WMtWX{*XI*dI(k8%+zU(S4dy-{1T#`W1~ZvQhz0|2&`l&DTRy4Y_)`FH@OLL~ zLfI#&t}6)EHmjv?lq=>D)8K)`J_pj}iNDKu#Z1-0@Y zp^9Ks1J2i3lybkMOg@{h{Cbfhd`(x|3i+_)0_6&8XUzW6*)+fDc};hua#FES53zj5 zuts~bFmKjI`w=pkZgoKe=@g3C)+{cG@6n2)CIkaI<2;iC#augg?oke46Eg`4pd|JN z#r87BgdiHGeFe*9Jq?`dj?T_GqVenNd-e|w5V_L7=LX7%WdWqI>^vN_e71s?ui>7} zDGej((>fP*>G&_{-ScQr5Aq@UzM}!IAx$rzB|{mAC0f|V4;HftR)hV~cJ8Z}&R${w zMv!>eGm>eyzg1_U*db%)dhy%zzsSsm6 zd##OX+kuvbZte1AuH{r&41GN(kO2rleQn`M_RuR87E*7td877XT&Yg)UIrbiWo{3L z$LHP{@cU0&uq4abH&5}-^i|Du@u;pljWsLUXuG?UGB}>O9s@p7xAfxI62DfaUl8-Bwdg$>cVbT0??;Q*)ywc;CR< zK@~kyV7hBBFsoOJe3g5u1Tx2<*oHSXCUZDghIU`P2RU%kS5vyox!)@re`ki)5n1K8 z&N0747)O;QrD)phD0pJy46+#}HAyam0sF<*ttYW#-hOsa>`wkyA_j(yv$j&}qwGi4 zr3le%-$C~9S!mY*l#H(S1$9BMyN=c<2#4$Q84`qwXNCn`k55u0L;6|)!*R<7dSs6g z1VXw;o0H*3ft_REJY0m-OVCx3UMCTcef}i(C7>P~Yh$WQzq%!ql(@7m9mRJP$0Bxh zJw4+WVF8ii{h&DEof8GQWra=DXyE71h&A*VI+ugfUho*XTu+|>x zxn{jG3KY2uRK(cj6ar@{J`y&iK{66AX1Emc_o-}r+hx2MYKM|wE3NI<2I>QAZsat& zl@W2j1^)(n))kI*LaAnhzwd-l&?0;Z0gZ$_Nw%2WRPpc5$fp>V5;(x}^9#Nz*Gr64@l;T-$%sR*c%+3%q$JJfQ(Z%Ho`t@)^t+$55&pp$+CXIUY+9&XZ3FStvnBx>jUWzeEYSbvD-TIJKu?< z0l;BaRy>O*JFaG5y~ZRNxAL)#fCFPd#lr^poH9n8rYN~YOQ`&fzBGZP*qirqs zh+cY^nqPnac}(J1hR4FIaQ&E;PTm6#N_7ivJwoq;aMdOZ$tD17?n*RFN^HxVE79Y5 z8eH3^RTcv8<{!+o62YZD_iCOcn-YG2llu-U?L_^@CiuPnSw>5UA*=Jo#=0`0r?HXx z3f4z?O{Ykw)IK(vWAi0D(T`rOZWM3_ud43_uMNE5?3BZ1FE0llS{ZI)sZ8IPIPQm; zBTmRMuEeqbcIi4Eqh=Xp(_Iwh3jQG@J4Mc|Ef2+jt?;DDC>KQf9IZOEY*+zajeI$%qpz0L8GuMu*l2szYd~ z43(@hLYpEe#sT9s*4G0FXWa1vhT`$N-E(I*gX4NlVi|5u^?XJYlW>v`pNf@l!ydI{ zQcfKwgRzm(nLLx7_R+kmJSFYQtjANKXv1f9@v_;u5wvlfKO@t1ddKw8Z{Y+}Qrg$$ zy_Dk*2qqe)d(#7p7PfZfJic9@Z4%V$a6$3R+A4-a9eoIk#PDz_-_LI#15yi&^8*LtPn+(s!?08w}-LI5I&t zj_3^Exp!>t{a*V%lANBtnILOnEokL>T_PKsYkht<6b@)^{m%06TY%SXWK0 zhM{;A>Q2Ak!{I{B`U{N&7-01mY;?R696GRxCnW(LW>3N=;Q3BZz%l<#Z~CWy-)O%0 z1Njn1%1lr#*7nQnu1pyEi3HP;R7m^==uNv1y!QQ!Cs1;$k>M)aojzAm@73X;p&QoZ z|NbA!MxAEnAogdwF$gq2-iC|g#>}Sxen6m@a|IQ!iv^;NQInk-rPf`X_9TE z*P#MTI4$XL7bKT) zfkra7>(@sM z7jcH&PK}k9?2J`IO}Bl^DD?Kj2S-F? zt549YWwbn3O0<_Fo}t@SbCbNnu1uSW*F~yzq5J?_ZHfX-ziI2Ppt1K@sY!7zWC{e+@io|nD81aY2 z@d=c$_}ef~#&dWAvX+Z0F#yu)loM5fU4Q7XxGe=e+mdTjO({EO)Bj>9{Fn^Ukm;wbMK4 z_#acbCuR*nruq$wMzT-qym`m!TW@AZJi5{n&We=osUvDr(iMmx5T(4%KVQd<@w*q*J9YUYziXUma83TuH88+fqRMeH61| z>mUFU!#^poC|DMk$j*qTJK;}V zg-+ec**P3^)^Up7G^ecy{biTu%YC%Bbm9i{doG602*p{7fVt}4J$t0+QSo)6gy}2{ zR-<6T_LZ@tQd8!=^&WLAnr(2-l_mM2oT4N`D2Mi^&g0Cn>7!{#zG7lwsrwOBy}Yov zSn}Ck1FyW5rDf1JE9f+&bIy2ruHrRhVP@71-Q$n{|K(%qOsTEHWtZPY0D>SzGMl`j z+a3uC-$2N|*NRHgXY3?(`>pjdu4rIvFJ~tndv_>vPrR!;hkw`o_H1jfLBq&^7u37J z^lxcxB`sb!N!mr}teyFz!^4*ZUk>AWJz4Hzi<-BP%tKsg+VkcnbHj_9f|nGjV#87? z_`~In=QIA;Gu;IqHHUmdl5CR2F&7aj*>eMsvD1_(RzD6>xa;qg%1HYMR|fwY3>oCt zI4sgGX0E4r!oOMX=2uEzrDd_)h;;VwERL2m=Vucf24gnQe}b(BV(&wISFmc(`Dpo} z!%D;Q;mX%sJ(e{!$rCngBB6fa7%mUq_m4V?v>@ut>K)UI@70tPMWr8+6GQmxihp{< z>A#=f%I158Sgnb}4075o=+kiV=bJy@kgrx;sXOm? z;m}6RyiT?1jqz_R6$LzBuA7gg$#6;E&e#3QHJI_a?z*<~LQ5Tnd9B~o{B`@^_^f`M zWpa03U+6qOC;lk9Hj6rQt}C>_y*-g*At?E<&)Dj$9*aF=Qj z$sb+)wV+K{9g0!yil6?m|MWw8)2IJ8%ur2u)WMVAkV_#W1v+K)J7eemYnhbDk*qk~XU-%mL`@){uc0Os&;8300Q z0RgO7w5ZbW-CO%?Xr`BWv;!}?pg)f|{~5;SY+n}!*ZAGnlrtxK4Rk{{;1;)Q0zReM zQc2=XSThMw&hSWE()r zOUym|CqFhd8G{~)m*vFv!%i=3OT-!2v%*W%2_L1b(|muqEGII4o%l$$px<_h#Fg;8p;MN|qhlU57OMDyATPT}C@(`K=*`1*e>aG9V06eqzI{;`wLi z#L5lzU0Z^JCQdv%mj~jE47xB>Q&GF9oewD*E=`F?yq3 zGVj#>@Y?greN%oOv&+Xe0=fEGFDSar4{u!alDl`FyGY>0$i3u)>TWU_DleDfi$eX9 z!xWlsnOC%!~t=X@D-0Tmn191o*9S)uWxLHD$&(X#y=QCiPhbLxFtk}oB&?pjEB|BXMNpj7N$n1Z zQ%Cjm_zH6+un>f>Z*J>VkUfHfwMIT9IF~B2wdF? z3HNx$knHU+VVT1mgWL*$CS0_H=pR@kBZI49o#8<&uT>`VnPU;5LU2P(*ZPE^5xq}h zCJS9Qm6(4><(oI)A{-siC4AhyQvr(6Zp_kICc`>zPNgo4ExR%>wOTASu>cRaou4IE zu4-**8G8(4L&s;%&xIGo{IwrFJ(m~Z3l(gKsvEvztX%2Mq4J8hotod|D>ptO~w?>xV9V_iGAyMyA-6gy$!7w1KFi%fZ+2 zWAM*`XAdbSF9*3HviK+kFP~ry`p1hR`Y&kf3|JCGdeUTKfVs^NT=o6KXtHP_c8WBc zFZK07JVY3bLUE7ZAN^e=4Fz(R+8-kHR`fQ#bhw?=Ltq>GE1kl#GH%oR(BLjpZ6fR;j<6QR9^Ml!uEh*zb=FHutCVGQomUqTv zVd}@SxQ|)wJY5ZaSIar>E&irJaI@yMvq+ZYtQr9XPB>9jxY|S94SM;>bD(`-53y+Y zP3L~i!BnuFuUd={sRmy~ACy{t=2G=}$Nu962Jgt<{zi_TOBVVTN@BDN50U!|R$CUd zS1N@a?v)v_UH8OcFcM?W#z+;lbH6pswl%d&l~_d=F{p-To%8?>wAn`HtFk;{0Nedd z?%F2I3Inu}yjt*2v#JK8>G9K3500?2Mpep{%Rb}xAI)Id;V(ynhTju%&6Uq0o8(ge zIp?a^2dY9V`jsiZ-8^ypKdsK4BiW`~GUdgUN@RVlbN#wv&)uN<()QCzz7Ae*v?(~VT^SG0&_}w&TuaHW7KRAhKJYc^N_l^GQpUJN>mDC#}5`M2i zGn>zLIvUdqUIV&F!*;#A*`I$%i0Zpj_en0j7?mw8Eupm(GiXpH&wMaj6qBu1q|U~%pGy1t#f zii+udxMV*mBQ^F?l+>w0H4jL6xH%R+FP~(-d@1D+xSTb3%E?J`a02k?T!m{_@WA-) z%WCq>sPZ`Pn8;zD$i!}p9$wH#dmYq8)Vmvu_mTDtUqalyFr0gx25#8Skk3Le$J1wnwG6zM^ zIfcF>1bY!~FK2;ZGIst3bANVE1!OOONgk5>y_0YdfrZCjE%$;d230nmr1c8t&*vzW ziJoc}Ewq{DhfFSDYX|~;DHL>PZNN~twqGIOaAzx#O3gFM8Wfp(l)7$>@GH{Y z5nU188%C4J@jk#fDMR$L?y~cZdO`PBYzlV++veYs_-HKxtlNdy4%`8z`p=rLi0S{) z_2%(ZukRZ0G836ICo^TpR2eg7D3k`7lG!Q|Q6$qg&q9Q#C6q!4g_MjX(?U@y84^+< zDvElq)jsEZ-uIl}+kbm&Z+zGDy`THO?rZSHJmGG4w;yI3Je85z^7uSdF=U9Aado|3LiZwV4;BIlCV=5coUne0~6=3OD z0rDA3u8{d+5@Y`5#U zi!U+M6g*Wd54r_Xf9Q1Y(%PDs=ZgZ?vn7+Ccl%VdZl1R>eHs1jh8_jz*;brha+GSu zyeoCO=u2PR+ce?&Z(~`BKih$p;MgbJchhdfcqQ6+VX_<4w<-Ru-s?9XM)4}<@v9OK z_@>&{L|oQgtxfah(l5vU$5Lp%*miXN0$~|rSi=34M!tmh3sR4+XY%?zJlN#HQf%VB z*jpA5ij#uNCO#gB&1A`M35j_*s~kkk5daf$H=Q2+qrw6fss^!1!p_7#nIk zGYbn$moz)YkJ)dI`la}Vla@R>I+`K9UrGeCXh$NS!kQnPhk(o5!^%WD#|^M0 z1QJqJJ2nj6KEf;w^&j6xm*SUfK9H#aEyPx>!FUPZ4WLVquDH&zY;3+vUN1PF@%0sL zkPJ84+CcE*(to3l*xE2I)8qHQ-1ow$vuv@*PrPS z*kx1-jwW=4FTb)<+x?npVOtmHO8S}fL!MiupKN%TRj>~a`jnv@_X(DhGw+&oI-KAH ziDf-vKPbf5&Rk>@{i8~sHJ0sh@v-aps}W3?uo++>j5^hBI+(WLx@Vx74YBu5C(K*#EqQ z|JcPt;?XzeO3fKJ8lsn>n7SV{P5TSk;N;5Ckun`_4?iA6|2R=z1}ekTaNd3fw%=2% z$Axrtf>+q*9o6F3Fm`UM0euO-B{pM)HSGY>VK?EI_e6SBIDRXJ4Ry!I;ec3px99cw zhusg}8XmL2nmQ5q`m#qTmu_ndlIJFhSx;Yqe~qUrUZ*u!v7n>r>*+Di((wDh()~Db zm*z@p*qRI2RbNl~K6GbEoO_xkPHD~G{rgd9A-9Uy*>vE*-4RP?t`SW~-5Owxt*VT+G+3as>6b&^@ow^E1Wfy1EvKHypj$kh` zNw3_tR!CKtj1T9A$|*?aUb`hK)*<8|IZ9B?`z9X)#$#zJ(s10v6^U@E?L#zVyk)gK zV&O(M)H48bAWp-`y=h~oqd+^=@_}O|8-ui$iiEbXK2@wbTQr#Xfc04g=eMs(YadJe z&fj=?N%Ckh_#^uI9z2)NKQ${JR8Ufl;dME3(_-^-?uizn1ugRcy_ux<@4z9-!3VEp z#ZX|sS@49cf>MJjea;w`fBRQq3ZEpZhVM=kl&|8I$UnnL(2$aH2caCMsibQ4sM`nB z(|$nFbYK-km80dhAYauJ`>%t;RVK?H5&7#Ehi)PBPU_m%v(}BVu?(MZ({Nd_QmM9@ z?YkD#u*bz5JcjMyXp4#IQxj*YK9^9D*IcRR7*-d9hn0yMdR-=JCJ4-?@^pk~Oy&qs zCtw%Isw35g2_B$qmb0xWWQ(nt-2XGQQV49tVp<`|yVn+4L8e$kYdmtW9boiWGYvex zff)9UOrYLAs;HPpzg??d0Fn3jv2_R>$nK%Wr^q+Y7KLo0z>)E#rLtc!ge`RAn4%A! z(7vZ1y&*_mA2z!|RN6+V!ae)2Pzp8>@O` znn^|P_w#CzrK(2vCZ?uf@`71fK`S7IakGX$5$73ulrHEvAznY^g4+&lq}K3v;MXvY%(f2F z^(;JZ5=-RU9-!7X0fVQ6loTUhYGP7qTidw?0$Io))Oit8p|*koYwB5U#PB^|ij<0H z-MFz`nURr^vbJ+$AzGEvk+;#tQrZ!U`u*Uxt;*fgaZa|yhdGN0H3R$3;tZ@-@Qilz z*V*h3oNGN&eyI96Dlx?jLzz{gsA6&7S7c8}}IFt%F54pCz(d*cW}*^JHqJY#x`A9vu+F-`qWByhk* z1Az3{I0HuedEwY52fvreU4pApnQxY zeuAP3LV^fWehPEd2sYpan^bf09ME26WyR2m8~BihF@ahM;2j7rG$(AVUbK(&dLw6f zy3{~R5+_i(?Rz{h0KP3r6h8|$M%K^d#Q?q9)9-d`Xyg)d6Z#q1W?-I{^xAOo3Cr5K z14pp(JULWmTK(C7IVbI;z=o}CM1wS(f9ze04j**Q?&D~!*?UU@b`KN}lHxztDT5q` zF7vxr$JbrKzzBGbV!|&dh_qoah&`$NaT6W0xBui1BQ4(i93>K92Sq(1JS$fuI3>kn zkSk^R%z-xCTZCGpQ0}8gT{!Gp&b^}>bR4M0bW}~eiazc;I5N_jE<@K)#gZjw zL!H4$s`}K#eT5wX5BVMZLWhzvb?ti(2p?RIzu~8S%BU6>v2{)fRcjno+so_jBc1&& zJ**8nSW+PMIuUga7Qp}?jGn=(*GFswwjsFX@pe!c$ zO8(a-2Jpmx&^5W$ZY z<_Xj9-*;0ig-9%QM_x8fpOga3J>+GpQIj; z=*Z$x75=`wCpyB1B97*Wgxnikm0QYKJNzMFD7syQSE{o;4w%NqjOhL^XwDGb*iYBJ zwc$7nj_>Mk+IG0aw)S??Dp^;0nU^MdM@*)>_ylXy23>?QttUL!T}g3`~(14%9aoU*0} z+Dr5>NfP7>s`I5nF5qcF&4ru%y+AXhQ_vSfbv{_$Z?K;C2i@V+XSscNbSN!B3oHdk;OKeMe$rO{w|D3tG zIpwLhes)HB744|t5c4iWx!XwWIjpw``<{5mru$Pqh(Upuer z)X$GhsqFF&whNU0)4ZKc7|;!3V_=5eBGjHGY+KCr-r z)14zGVI(?|R~eVM+TmY6E2FPVGQssLxbsw8M#(j~%-%*M?4oQG<3U3Qs82C{BOH=iO)hX;t_LoSH51HRY-))82^eYa*ym(s7QcelGy<#u#i8$suEQWB;zz&u**HQcvU1@|PA5SZM?qH1{ z{O#kB;B++#`f)}QCZQ}7ILXRL*DK#Nu{dDJCkN=acQ$}>X#_DY2UTfBMA}KIk+96HC)tC z;$hfT%m?>O4U8AsB%3Qj8dy%5{0Bg%@r6#v*H4#YQ|EbhH?D?^*D~+gzoqU`*iy8- ztVP+?Fdv(iFM9^>Z+>(8zl!X$FnaJ;#c}O`NgUCD z4Z>rKQL&e($p@Fi@s_FbPXPx9GG~-vTj8J`Gq&*c>jsYWD1;(dM2*e7sjsdkkY(Cm zKA|Q1M*tYSevomaDd8=oiMY)QnIym&U{o+YoaTWGt0d1MhnCFR()7}SBDf3IGKd8uxM;#=iaz;_DkVu%iPW#xF}i2|K;MBX50Q>2 zmo7_+`0Sz+FascqkF*SVy&}tUj;b?uKUNu_vHi7GuiDIW|Hu3QvXXtyV^cY{a_uu| z3#T{LB+O!F_NR;*KrqX}<~#o9=db`=))7VL&^N*^l+K~K;jUcYjN+#Xv8X9Y2gyO{ zJ+(Z(-Bpj#wnx{G)+IQL`Gp*lXJD&@R7@9W%_$8HgKB*fkM8ReExNJsLK1f1hHyFr=V%>HgRE&E@a%w3pw0W4`abJ~{m$nk|fu zoS-vz7=E)CFDjmSZ^CH?;4GaofN5Wnd^~G!qVc%ZllceqjYuS&rqVj2i?c8F+L+2{M<@ z;}JqdEAgT20Wpn`dpKWI4fZn;R#4GUS}~MP1ad$*aIxALd$>%hx0mG+dzLdubwsi&HPf6x4QcdTK35Y+AUwT1px=|B^xx{n+l2vJDUSJ-g}Im?*5IMI0R z+O-T;N>-C1y+6h?d>9n_MG#F$B+__`68~F6cg|pzT1<{qs!46qd&jlPKVO`rdLjA|9Vt6q7e!kuWt?na5hgIWfiEC+G! z`LxTa1|-y#%@!n-m%qFfhurtJRdvcmT=e@!{;GPmLHzD)8@*lbwx=0SpS+LE23#X#(#~+z-$~!HeEuiEj zVOeKQGxOk06d8t!%%EKkc-)JiOVZ%C%>BiG6~149p@@{52SCM3lskYuFcJqCFHp9> zY!|F+=bqn+eCHU#@p#0N*S*am_UbEh7AY(7x7P+$(^&+XIMxnUj@$(3aoi0IgBpVE zP&Y^6FTapl*f9MkY>kGz|I54e;<2HJTkdSK*I1ui)IR#7Oy~aj)x{S}Yzq6|RG;bH zz3%*X>fHN>*Y^Ix!q+HVpb6Bv^RO-q{*k%wX6V}ZNxk1a=>69so?uL{g+&@nPVEl1 zfW6`ALSf(BjH99$)Ly2Z!AGO~w$jPKTVD-^_CdP)^VB%5$tj!h=ATFA8^&%Q_CIr5 zycW~5EIAKhvsPnDNIpo677YPGPV(VyvvU`+8r1AX+T`J_ZHvKN*>Ex??~cmJ}e8efBJ(c?13>`ZpuR+HzEzVICr zqs~(AF9D2|5jXtL7bHN}J$R7u(3xOa319()L3IVEU}_o~OWJR6Wc7k~V{7yUwSJWg z+qm*JOEE@t-m;{5FgrCR*<6+3-KEFMaWhi!=oRB%nI1LAMIjcVCi2DiGjg^Vj`>|; z_i~}PeSLHP7WwcyD2*B^y^k zmWF*_zP4Xj=R)9of8Xkl)4@jrzpeGC#6Hr_{?UV4w@XevH={vE#kcRr<Aj(BHuY^2P}2mkB+`S4`0-o#loBa);??N?DX{O z45ZFq*wDB#rc~({U4z;ZEHXcCC0T6OM(~Cec^S63z8|I`qv5-eXs)%lnyDZ%(f~|P zrW>XfOlCRnhKKK;U;42815T`oZ?+P=U??ZLrLLz!0-pM)E&V?KEWqXjfEKs_Gex~-{E zP2tm|TU}Wpao)YajUJx4gUY2{_(Z?rsf-+@Ui`&x3k#04PAnoyvfbZ*{4lf-WV z+B}z=pI;rZ9KDxZd(66M^_F}%X7%sMUdd7-B_`%^i;LV+r7#@M+uPe`pX+CurLYf{ z8S}vmQ+%s<7CLB1a@Lk;{%j*1b9@T!-BGYy_wQZ>k%^XUe+ITJd5k;FcaDJQiXD+& zB>gv($hnQl*G+(WKu2b%*>K1O=tE3H?`Nj!B0I;kJE-4RwktNK#5#cx%h3aqRFAoN7QQT+iQ!0czY2x@q|-9 z0AjixA*!KMvPFa%s?PtrSBSnJ^u=IhW;_F}nfJT8rS;6$y!(IqIM2TbxzaoBcFq3J zw=~p1Z->ye&dHlUqyJ(emwuOA)&4bo?^6bbh_d6sYNw~-Lj?QK{C%5<-}0!*o;$3N z$k4*j^hLLXP;*H*T==^)V~WPvk9>lHKR&+j%wzBTfa+e%;19JN{`GqatuP#^v?kar zoZ+H4ZlOS0Y5Ymy_O3*vEH&}W!LYC}RcQ5w0l9JYU;k>P4_+7UOv!a^%(d2FzGh#} z&aQK8jsVsNdl~q3EAHHR4(*NM`_`y^wJgp5M1YW>yY+BNHzbyDt?TRVMzD+cozEac zJ{XhG_u*zB1I~Yq!T=rr?C)+qa(c;KPSt4{U9FL?3k$jdh}w7=aIz?c!vIt1S6oOS zclkZW|B6lUqPm0xZL3L_qPyNZMc1kPn4j#SQXW4W}^NG zh2h}gtqlL%1axx_&<e+=JSTl5O#R)bAtm7Hu1!)wE2E0XRJL1RDeB|ZiyxIqcmY5btbe5`M zYJlWPS9Pzdg?GC{w-*!dhVjeFz@_90j#3dB@)=Zzi#9Yn{fE)xK&Oll+n3!xSHC~J z@@|vE1E0CI{`u6;kM5oxT>V^XaoRRCczxLT`{_pu%bhCgE&txir|)?5{XXydr1(vH z>@IoDd)m{_A0M&K3xVOC^6>UPeMfc_E<=zk3Wn5GsE^ zzv@lDvx5k^!emVEh<>^p=LMkS6WwdE8HvNSyrCdGJ+1ejJ&3y=ooKo}HL+$&LW=~v z?$maDTkI$RK~ZKFP_<7CN(IAO=i*1!!DyG5W?~9Kz(p+NqGZ60BWrsJ=G{H)LJ&k2 z(~>bu5C@7nG0sUr=XPSC2s)r(@T67TyB|wOhWhYilVTEN`V3SBIiE%G=xRRXb27NG z^~q%~{gO<>YsxpVx9-U4q8VyA-0%uPUwGTjC9!8wxx`JHVK77WfYw>V?)KqZXgv3E zj_976xJgGYx^8Wo9pZn0{>PZ~c~yz!LsAy`Q3VJm%>2UE`=5-#x%47=+?G8s{Xw(=KJ2qgf0hb^a*&*bTnlPLnzvoz+pSEb6M}P4b8IA+|HZfxtmEdB9UGMv4 z*wFd!4z$rEU<~4eeA;rqdUWR`S5a$ z$>tgu0Cj*?4%V1^^t>2TD4Tolx49(t4l%>)=1K#q7q-RHeRJWga;(hT z{p*v8swjHxP=@AO(=(q9-xKd1y{#7R9+93mVzqXH_Qk;5D~ue%l)PmWaX0CmuiKv0 zW2J}D7)Z>S)vsA-R^+6J z)hF~f^+j&nDQE{LGD68~n&wc3^91|*`vdqxi-<+>Nhc?&D{k}F^`9>PtFzckIZC&R zp8l0qXF?WHVX1a?_l2)Bv#q~U7e~T=b>wfkGj&`uZ0SmdPTuao^_4HOvG+s#eCFEM zuPA(a9r(NLs%+gd&f1lC>t*078f^Y};K{sJXrq-6Jai8Isu;J7V0Z@bMQHTg?8=u? z57y8Ni*0Nuge@7-&AWu(Tv#ssRh`hZcpY*djF#d`i$2F#h#h@E83t*{uD6!M@8M*E zb&QjV#80S-TliK@_b^4Qn(kJ!j~WrNxuF8b-W>^WKqqmcC4$hJfsSq?7iIhBkHLUZ za&c2ROv^+tvLB=DEFfW~h3HuIOcA|qA>-F8xw*>p%Nz3H?`v}LVPhjB>2vgKRn0F|P7`wB4hyQ`JbU?43D^or3978r3&8AvJdMLQPz5h0$2X zW&N{zWCLcUewpKs8n0XtjB&<%awz(*wuryoIlK3>EvJvI@+UXeVWD&H4Tl*O;+=CG z6*uy7>^H!K@-)Ag(Z@-B;OpR%CmspxWs($vM!upGwNB1OkIIYWA8`9|t_6EvK^;QZ z*Up3nlrC{YT~7JPEJ0y#LWDf zRYWfe-S?UPRvRvwkv-Ghb68eaU{g?*AY#py%E}?C_9^=485AB^usFf<6uW3V7r-)b zAEr%wym^2|KwUEY9Jea}s?$|iYFR}ArU5AEwEZawJZ0Ip$Ix!}r=gUJOk-Sx)i$g} zu{xYp>t+{<@}03oZ~mEf%M(U+a4D8Cf?`&Rir}k)6Ow9M$>4iX@0Y`|HI?mUpru`g z-5W+13a9l55Zx!bN)}JCEw=ZEHu~*b&~Cg$4`ZlgF#$TGXvng@mU-atVeT?W&x#ow z`IWCp=vnU9CkBoQh#v<#7`^vnPGvXyffizLEtjR90~_hYPCH-j2b#{7z!1Gq=lM3s z9V@#|DTKR&SFo-?GuJkaEhH*E#i$)u1a?SwP`oj)w~i^&*VJTn_)G}Vo@#g-mKhPh%H?O;unH?=Q(}aLH)wySAO5T-JjQp+Cnh#`pjD!m~Trry_25>6l=}K{y>cJ6}(7QA9Qkp4JG{ zWhXcvzy&a=RQIP4AKy##8t7-KVT3RKw&uhjwoMb;w8K`_57y1?71jWiM${li_4H^S zVFbQDFJJN@IE{?Lh}8zTuTWTtG(p4!4hrqo4t_CpSIW9Sf{uA+3{(|CA)#*4<7H-i zd1#0yM9&y)5YT*V;m-hexOc)ux9}HsTA~731Pyt4c_^$f6caDa@E02~Ri)CBEh3x? zk1O((Bk4x?2*viH%(@CFBvv7?IsL$=?7(2#riQfG`zK#)cm=~T$#CQ)e1qgdEJ{pV zTuF{7aN@gn-NiiR=cfDKoBllRClvFMy5OlfqvUb-h_!ybz!iT%@nP%u1lVmp~=());9~zN%U5%G>M)e zrEYa>3H%We5tV_JM2G@*|5@|Hbv|NUfCe=_^OM-`IBJ(?m$(0cy=KeKOXV=y%Gzk4 z<#NLj0i>p?Hu9}85XRx>5;-?OMdUs$BW7H9q9&Su9&i>^E*-R`0hr$?iB^Eda2p|c zv(|Ug2q?6Cc-E$o_=_TCLzdm(FCDe8U>%yqf@&8dhXF;&FDtt*X3`p><-L11SaHxF zV$(f@wsGP=w2g+PGVBcNr1qGoCau7=u`h*`g+_1K#jvGOfY+z7;lRX#f;qFY81xSg z;oqA%Y;4SrmW^A>D)i?ftFRJKnn_>3KfT)nmleO#&w`KK4wM?(5D}~bUc?sq;{G%i4DpnFyBxnt}xFVm;ZZ`X_4bbuEcuk@JBMJRx13ZNWrqK)f z=SlEx_UHV>cMUEHC}+jzX~`yBR16FZ`&Kj?`NF?1F8Xr&YB^qc8218E5w@^BNOGch z3V}Yj;jIKK;27yz5MQw1C3#k6%&6NJn&g`d z_?~@sX{)#)Eho!iya`HM(W&4*n9(!aE2|{S$+wYZx45(C!`oZ=LlKWeXux1$Elq(f zb02eC+u3ndKhuy5xuK|*B$NEbQJb`w>t%Vaq+EIeo(Xt#E{UR9~oh^>&o#?B2>PYl{xdwBd9c`^(Q_4Th3bMfiQpzmcki;8&jS#Z7iJKUo#fOU}kB)I^GcS zhjC6a{KNUDuU`v(F!ec(4+C&-!-EHfP0Maz_pE;`t+39+a-pvQw+*K*7Nop12O;3h z8y}6Nm;z?h)zx9wM@kJM*j~w62+8)D%L+RTLERbG33vEqQxl~EGwsu_U3$p)Ti3Po zRCbUmL#wm1vwL?ohdh$QBnzsqB5U$V5`Uypa}g;0p50)8I<;Px-;(y2QRK78n<^$d zrM-M&ayl`sH>7tAUUXJGT#H zQ+J2baMTLz@QXFDnkoAAI$Txw_~Md1P92IJE{{gEe-u3$hgghM{0-R};qZ(hObdvmxudVJgi8jknEk`kNxtgV(Xdu5loUK5;V{sX)tk^`p3BEq` znG_edEo5KE}c`|)>lD{el)E(K3R9{ z)q|{6j2J>*_S3O)pMMz1NNsR}N)?b7LPmfxWTlTyQIkHva~sP1~gT()4u5$YUo_$)o>CBN61;_Gd-Tbh$z?_X*d( zvt_Kt@6QH5tj7<3Un>7NR$sy z6Diy)$;cQ=)~WcbG!ANAIPkr+yy(VvsL*I*HVo|Vxpt;w`jS8XNDHD!ht?U9PkQ+! zd4ycWJ7`W_AEb}pJwq&c`S9YxWe;+I^te&71>Aus3}b-zXzvr_PkRP4T_fIRz;i`A`v#EV0AqZOp~=@TK=A=JqLRE$%0@8jMJA z5ZUT6&e*;0eZP>8mvFpi@x_fhT3ZbB730(OCNqwae3(2Gr4;!#Z-?oIMkxa+?OtuI z6lGb%LIl~NM)LF~#`UA8i4v8z4j&Ji z^OYxSB>$!W#-6vpbB51v4(bRZq`y0Qd#5N=T6D&lW*w&?t!7@13pf2|mNO-~EhrnS z{@b_&Q7v98)S!T3poS2G-N4U7pMJ_3yESYC73t8#|9+pbU-4@amAq%x=j-YeQ{Vry zufKorPei}Kw(|d}8afHuHkU$g!Yvew{hH8Pyq)PHnS=(cLE#L_#K zjKR5W4&k2}-h%hRw-U9aEZD%(E4O`t&bJn`J?kdtMG$Oa#)!{L(f}?f7gBVczym-k z0QD{+GIF;0nK>g93Aob+-~)p+6kRk#ge!TP0ScY9%hghn{>U|Fui7ow?i~w$Lk=cs z&in&W4y^!erEYehifQvl(0qoh`)pM2F8iNW;z$kBK`M#%b6KhyWbXa7eZV?N6<{r= z>&tkaoL2}3eD&&;#WYp&s8h|{i_+K#+^=h35RKeFjXkVc#9Mff`2$6YHgUOO^6-SZ zQcX?Nxx2s42+@Au{w(#p1n1d-_Iz>+b$FpX#1K-NBXuR~&JY~hD>o!Y zDUqs@5GFHY!%F>N^7H4Or@|{m8MW{GwK_{zG%yja@%;S$IWZS+3c@Vlm9<-5PVOT- z-cEJd(DoV)Gv08b58C@oPRI0G{d<9U5kA8gLk-9HEmb@R1^Q_BF0yIO?BMA{QxA1w zHIUdKgVQi}+qH|=19>$*OtS2rw{WI#Wk)P3QpUKi(kDt^+gQT$_Tv8rT`7$Y<q2LfP1M z#~T}cfvqiET&XD_s9{@9OO{Cy;`Px;n|TuZk?g{Ovckuh;QLt zk5m*Hjapk<0lx^(bj{O}@jFnehECY-B-g~5%|G?89r7>7b?jQfse2znBPl6*H(Ym? zLhfNmM2B-RG3}w?&$~oHaerTRqnW5v+1r)BpG&bHJ3+-=9`0c{kX*a6xdDztEf-f9ZdeU@fXeg!EyPdT*SU6Cm- z{I|u<9O+qVjN-u6wng)toCXN+FhQw(7^xUyeL<#l*irEF|1qNYmVjodFL z#c^V&dw)&zS%*TSWE4Focc2oCVNRS0KE?eN^)kPsFA75(u~YO?t*L6?BN3g;3LmZm zpn?{7MHC5-j*kHcAuJ82pEcbZS_AFx=nH2jZr>wlLv@Of4L z7aT{Mn)^I`v?uD`3M67nNQ*ML#-w4)DDoPz#-m4%1|1)u$t5FW;#1=GM>C)&VZnvb z!0;5WkdU0^)?O~%!ShRhT;|Oi?>2l5p8rESO8-P=oAT2#Mwz8nmWl8r<@f~UrzNC_ z@b1WP7Gex;uaB70Iv+GEpvfz0THm0DCn!G|;5bwlB{$(b;OOWGsU6B38ktXUeBqCy_LG3CWt<~qYgb&j8Xp!Kw=FI8txG{i;75l zsEHufvJeeh0YE4j9yYzx>7!)!W^`m^n@2*k>)@|te)3ldrX87lm$>FFNnC$maV?&gQZZyLlU)9H$P7TFD?hFCNA;9bcf7b^G=Eq#yBz0bvE*8RPvF^fQ#)9y(i5ZwpL1KWHGt@TVfd*Xb#=`M zktJx$wmGa1+YHJ6r6nFu{5>ZZ`k?2Y1F-0S|2)*{k8rtWa!~4SQgZTHUfownrLL-L)wVi**OB%2-ymDG#(z(deVj$-1M!_ zsfmgQ#CP$}1&w^#5mf};W19dJ~X z^c+&22@%uLwmZ$zb2o{80|I{MsLUUDTnz{l6}3$`UVnn18f}f2lJ(;b5eeplAd>M> zPlW3^ISFa_GiH)$MxH;vq`-CV+&NluHsevzoe9)KeEP2^NrJaMUC?FMGMwRn|JIM_*otcR$K@jRjwbV@OtJrs!1^Q(7{`IB|VOo$BXy ztn?&ZqRILoPH(q6WfOlSY6d)8fqibcT`6Yr)saUM1fCXp5Qw{)zNDi)|Ki=B_3ovAD^FPR0)6uZ z+S3^}#jjR-DTcRy{{)>6`ni0<(^FPSG8Mq>i&=lnJb1}K8L-h`IeG2zlV8zK=qzs_ z`v-7+&0o0h@naEn_4?blKQ4^7b_;_qDk(q3arWoxYJI|=cVQTnKmhdKPMCqdl&DP! zR>TrX;BIB5t{v`^&nTIkrsQKSG`U7%MR#P_bssR@H6uL4CfL1F`DkwBGfp0%I}w{F zC$h8o;9c=m)1PpEOd?;2ta_)Yl%C$?_P!C2NJim&ZzV>hdh)SPw!j;lWgMF4&kYZD zqgnceDZq@4$V9?TSA&ijCM6l=KbDurMmsxApNpT^{Y2(T*HxcK67e70y2E>U2)T8u z+X=+a=fBzrzolLF=h!-6cwZ~k8WBLIgph+K4W|rN;+EFe*W(DOjEJ3$2G;~ewWLl; z6oV9yT^+aA&9vo*|2Nw`0kBLM8d-GYuP&vy$Q+ zfgDOV4&V3GGLZNr72lCwT2WC^R@Npb^1LLAAV6n(k_4r&$N25$p9r~vt2JS>*0vpA z2HM-(XQXpeQd6HOKbFV%gGF1rK@E_s58f{Fz8B2S*~RR6wr6cywN=wY(d{IEom~Ov zIQf4t?og?nE$%%~moN(Ci?lQD>-WxD(EJ~$n>5gnLyoD>UDgrbsA|irkj!)k*P?xLm%jiQpTb{#5 zj&v5i)o$SzM`(8IfqZWhd_pD0HmtQ*+1snk!faM=Q*jQO7MzOp2 z_WgVMheLVFH|}`E%bgOE%yehJ8^%gv%9RYi+FTg#yfyTahe`2yqYabo52K@_&HRu$ z^?qvsq;J)VT3TAFs!`&-j*Nwcg)-udJ9g}_rs)pP;t@jVYURln+sY)bA942P#zJ{u z6z)LUK0@Sa8}Z74^+LN-#_>O^zW+^qJdsxLEnKQQlfb)0Nwsb7#3$BqhaPeM8nft_ z$^q0}_LGM-#c6Wy^vFE;t#yQ7mcO*YiqYj}<`buf@BDEOU?3dnj zc5XdM8W+&wqC28rKRaG4S=-WZ#2zs7zicsg! z&9f^0IEjt>m`T3;cYt6~6u#&fkZQ+%f@&E|6f0&JTVRXe455C1e?M-3I!_a#tLuBb zxFvfBg5#Scsroo4PBYy-s@1gL=j8KQh48x)y?5o7@@wC59)EWFd<@+)^T3Uiu;^Hv ziHwX4V1muQ5Q7*p8g#5GiRR^HXY2k`EyT|Lm}Q2aAkZ%r{vpUk7FV3!48+(HZ;cWW zBQ~DQFWzQWrlw3E*Y*&~qpR2AsGJixe168eY<1q_bhfARmq@zN6x2P|I<%Cf zKBo7Hg>9l@jy5`0XP}pQ$X>1`qb1TEe*=O*b~7^>9vxxH0WVqEQhtk`vOK!4M30cK z%1zhpqo?BJmMop`sAlxkei^9iu;FVl(Jv<~my!RhUF*B>ZDp4ZoWoU`{=FxDb|DS! z|EEeYk(d-D!yT&KlkxF``TaQ_^hZ!eodpH2pu9l(k5ZmrsR(N-W&{b0y+CXK_^~61 z8MG(67bzPW8p*2m&#;#I($e=2VZ_|pN0sTw(W6U2Cz{9KzegBmjQ32`=1M%-`uh5Z z4?~U}+q|n#oTn`r*R6tLjms0(H~OR)y@F#J;#^(Ihq51vg-d;C&8!)FoQ!K5IxZpy z&Fq&i?#jxlT3X#3S-?U|a~f4uzl(aZ+u5+2PMDt`LM_A7)zN)SM$-xd-IC!q=oq|J z;Xu#QpA1od`nZLeS)TTVb0<%3FyEpTsAxC;OZ3W6O0-7}o&HJtJ{!Mb1J`t8DYXo> z2TawD@kQqkN^=&U{mDYSnzjRoA`0WNI-l|DWUx!(3c%FezW;i7sz-FklP5@^5fBsv z#4D{r!hKS2bt)LtBkx@EHTL9x{-KJZrgC!Lp$dU#0msP?ba9*+WgKBJi{d-nySTT? zowcp2OIAlGj7T&Qh+#KSsj~fG6%hZHTj^$IOLXhAXB)m1o&gTUL_%-fyN`~Zo@djh z9UFEqni`)FlFaUS0!mI036!u5??I6(-|FJ8c}cjP<9+ppQ6S__zrs~!f5?OgwxcE% z@EPkuAEsTF!%uG1rJ8wleS1@0a;N9tLQ#Eu?HzGJIL9lu_WylIc3+DyoKe))XU1QH(*bl)LqfYp3$3q;qDa_)zGuQpXwK}kybLsjhqv*To=H)hzqe1-2g*Q7NY9gfdTz@Odl92 ziG?XH{@yKl0=}czeqtoYoiZEV=-j>mZ85-i+yna&_}&tpPXf(Pm`zyT)&J zj$o`F`N`~_Nm`8J@qwooN*BVfrcHK>a}<^Cp0$?tSxSnqU_WUyG)v`gZoaW0;P=`p z?jy?S0OoM$(4o_FJHGjiKWlE*YZFC;4?&>Xlu+Ii?jGj)BW{u-)>M=``{ep{cBQuR z>gpv78+@z*ui+Og$z2rA!7Qf%R1QsAKl0Y z#il@>?EP=$8jH66o}o@NH+b>l1sxq-_HG<1cygW_o+p*8oA4#`iDh?1AyA_C`H5wQ zW`B;D56ClbwqYhA{mNrDjOEYzma74un$}wXr^B=f3>e!O@#E>K!LpF)ZT~ZPNO0)R z4{C}dOkP?_DuxgQnLSPf7^}cjMjnM|Hc5_yxd1h8__<9xc>!L4xnP5xFgPEjw{J6& zaC|$@ONK+|mPbYMy!) zHMlm7WUgI43s#n*_dRE6jke~Vo{g8s6>iJ{tS_jp&QOAFYJYsbFvmaG5&?2n{&SfS z1mh97K-O_=%*VOF?Lj&0LEpCh6xk(usVv8s=Wet_wDj#!S$ktfQmyK%_37DejWkD# zGSiiP3Y{vAk3Z89lGSgQmS)tQw=I;_pZUH+lzV}LhM$k`aj=sAuUOoAFvXBZNL24MbZtdC|{z*s%PG>X3>sl@@a#Z6)W2-uz!; z;aRt!r@6#o+P(V&Zz{`rVHK!V4e+(l3?-9`s`B_t6ZuNF!Le+5v-w*#Y1SVe2%sgUcHIbc>VPLYCkdH*Z2T#lTH{|NplSpHj zO=?7R?Pj`hjNscgbE>pi*rZ9+jahyDL%Fuuz>Z!+%L@e3EN9+BhsWdJj znG<*qK2r!Z9kx?}ou7*cTsnrB4wf0fJxXv*9eo~3-EV-Lk z9`O2NNxrmA@6c)elEG8bB~$%c>f-NmnC|uYd4Hn|&`y$~!I0T52Ror@SjPY|2|79h zGV*-mQtw&O0S{tOP!J9RY6zAgUuI{UO8^<0%B*Uhm-X0aeD7|^uXBczw~dNkbNUtf zfc0kxF|Hq@+QggZ&!a9N%<|yjUdzfBe!|G>*AI${qWFhwcd>oRm)TgBmU(j>CyT^Yj?$8mdvH!c?&~sK3iKV23*-oR_c4uUGEYrSRk=rufJh5GbCCzzIY_=p z!uE%b965_zRq8ppDkdkeEkbA*N%4(LBwrUdH#ZdSJ5L_YG#TDe7Uz3QqGR|72C?x2 zSYM*qfhoO_PQOA!vmiix@|NdGF8F0*eRyqTcZ#~w`(sM%mzb4E0VE{!T-a%@>bSK} z-N%QOqn=3-bluqUc%i|Yor#H3TgHe-GCc{X3I4!Xyu7rQ&Y;y=U7Kck?Z z{(d5^7am@Y8j9A-K0!eO=%{{u2j>Da+yz*V1~}O=u1Q}zQ`{RmW zh*6%dxktgUQHlGG8Yf6owi`AB4UJv_v|Tm^((M_(mq;0_T*oXT;VS4%K<0IKBe)NsJnR$*Ihwkp| zrBp%ZDpJn2h_vln&nZ?u>n*PKaJDYXl%7nTN$EX)@BKVSXT4hPH_CTZSf&qnh>nr% zRY*G|!VDLGR)v0RUlYsf`@-+(Wc}*vFVR@3$hv*kfOPQt_@gh+PtPfM?GnY#`6f1x z=7D3$0_-MC9sDQgp`a};&c6S3#n4i=*3%EQC+ScB_K>Bo zlhZ$zC#%{ZLnQu;?Cc9Z`-tK5nt*eydTm3e?i1!-;?JuVDlAM;aw|MOhK|?Iuk89+ zG&vvGDCw>-9)7fpi;Ig;6{Wzju1QEeSZ{Olz0`0b5H;W75dxWHF zP-OKhx}bYHbRV#EHb1|=kQ(UFfL=IGRlj54sSE;65C1hr*3z8xKY5bqIf-Wi?E)n6 z$WpA+Xf5t#f*~^O;e!V%IPXeIWVZBqtQ3udm@)S}HfOMLa!T$IU0bqsv1pCPx1@W9 zq^t5O<;ordX~~KneGh)D$kSQhqM`E9C>ZE6u;=#5CC5PQn!YCCecoy`nh2&PleigU zaRscyUMB%0HCb-&yGlVu*y>%ElxH!91GKBHO;fb? zIr7$-L2V&nZ}E!fsy2s^$xBVoc(HY=mJITWO;~)ZYBOyzA*NpdA82kMRf^ zrL@dUldsHmwY9_a9Pky}QYg18Ll{+2ICkuK30Vpd$|PN&4m{DxiR~n+e@*zy?rveC zHL^fslnUOfw;4<=x+f712x^b@R3xQ&LNf>eb+@_smErW_%VX+?UwFCFBf1}KBc(a^ z^V@gtvNe1ij~wZR;sbq>3pujlpfnA?iNg3ZlllDvpozgw7IZIFF(v%L>T-(#dT=N}H zoFvGfv7g!Tl>-~r{)+m#_85BarQ3S*_1688HmH69E6YUePlNL)UaOG#z6)4qv&)j} zV~nG04KS<2dh-EO14d;sTO=@8xTK4Brk_90a3E4cwIoAGWYX=Sx+~XgHn)hl_^!e6 z@o`HFdTPKvY9I&Aa)Xca5vx!iAD>gFwgjF0HD)DZdcu2$`{rOQ-2|i{*V5j;Tb>A# ze`&qYLK3+QIxl~vqU7O20T=CE{CYA#112RyS!&LmJIs{h!l3rOuR|isn9Yo4*y@&d z6~BR~xvRStv43`4_2(gM7P>vOvhE&)X4=42Rwiu}fx$6IbwWp3#YWy`|CLb7{a zG;CQFEUGAmO7bC>=~Fi_UuvrCWCt~2;jkK2^%#YMI|Uq{IzUhr6%{QlV{te6uwN4s zRN7%k!86m+j`+ci-+CeVdEZqZcZh*|uU%MQwHV2$_S10~<7E6>Vo%ESklD@eA$ZZ} zqxydGAC^P&dY_*ZghDeclv~vrwi`J_ai;UZ*ofSLT$8c)%JjRA`!l56Ytf+iYU@6Y zd)avI1S<#gF&6+xd&lf|{TP$eUKdcmbDotqGp~1jL{Y_I z$$AejuXcDo*pKtw8GgX5_TCiF;!*Onf~oyMpo>D zH-y})U8MDnvnuFb`47Xh@Ntw#9tK)_M@j+ZlaR>82B+J%Z(|5(y>xj$UKG$l$rG@rXlZKpg@66(XoIYV1P^LNYZz9muY*xw zKq1*5uYL3(EBOT6X#l2AM>dpQLiP;@2X4b*p(k2ON=iC9?FUfn4!tb~V0TrF>{N`~ zOQ;}H_1-=ogcbc|BXDbP*3%&jQuX}oy4D-!r7A%P++$cz)2*&k--D-K^q@0)>X(k0d z(Az!R@1;N~u2H=6R1!^`l$yHwNkG%ETBdCEkUCMI{3$>T+LmIWKOn9zl>{*5Y-FQX z?+rL`+b-(kNyj?muBqk-AKlFrYG_%YlH+#o&-j;+g{r$%i-!hv|L$U5HVsfr)af@n zJ6GrVw&?5Cg1ePta(=1smGnKVuOFe- z-6)WX&7bh2!pTI|Z(*ajSD%e1L~TePM@c<%CacSwAofu@ZoeK;QseAvHzhJqV^eU) zSlrkC!nw!G|J|ogZ9cwxWUxal_w;RjS_&!@Es?qX6Lx9H#JZt$e2+ub*$itl7|4Kp zG*?MUoscBLToeMi5eODY2ERJRXXHD*7L}H5eOq~~QJi@o(4P~%xCysZi^^U()~S9r z_uRXcVnbRn!A$UBep*%aHgDhYqktwnGW`L&m*YJ4I4vI< zhL;H>1G5fci?90K=BK(g1utg79q^^VFSg(5l=L+3+g3iJ)iWQt-*hRxvZ<64STtH5bLN&S794Waz z+(ykH+AZ~vf+QrUCA(CczD4kjFNqXJGSb&Qz_LwK6IPhEW~eQ_B0bo%Qt$r*c1G1uuqdG=~c+ zU!De*78IC-pWJ)}1Is3on%DJJ7ZMUW@R}bJ^?{K_B4bD%s3&D7?J#hVT}kY5VZGY* zF|0x?H&sjJ^PDe^|9D;O&XE3P%J}OD=0LwbYN}Dn%9fBnQbsazMhZ{j_#J`cA9!Lt zR(D~T`{~!)ug`gIahR-5p{K5&z5b|nc|PjkHyJq%Cd+OaFMTEDU{qSPfFQbn0&#pb zGFU=X4~Rr~zCXuubC z?b*Vk(8Z>h{z>nUrT);xN%PQ*z_WjwodU_Ht0okBy;B0Vwodi9jatn7*ENg9cRxcOv8`=zVLKTt;Z_@d{I+%=tinENg6J#DSr#C-**(k7Guk<7l;F#f<$E zhRy^BcU;{%2LcrNlPR8GCHu27GK^c}4nfxmu-RK#D}w1|?qRhP>E$w3TMhEuqSJ)k z+9g@1*2go6Fv}^cP2NAG+MXD2w4>r#v5ACM>_%LpX%Kj7=RW!zgv(y$GUuBL@mv3{cHXFFyKY~I(%sq-Jcx=phK{ZZ;(oFN_-MjukLM>2p8hS#DLd&xm zB?Irx+v82c4Y11Q+M9*B&=q&{ns0Zg_RI4xIaL++5Hw{Fe?;iYq(JX?($C25vBknS zMc@Cc0)-Yq3kyah>r4tc1#y1!(-72x0IIL6Ga|K}!D^5W5_RAykhf2O*I>tlQ8*?h z1_423N_^}t&d!C0AGIGGV~-;A%4mP_4PA@7phMZdeftIn4X(RiBDnCGnPY#aA7}6h zKR_XdkJCTIxU3c{- z0AL%WoEc^yQbudM{^yWa1d`_IXv!Wvn#0v5rX4VWXXKt2fmzkRu@~b}S~C{@u7F0N5UOXq z+q9H>pBOV=s;Z!uY-1}4L4t%tTkXbc)wC~JAf?lDvwRFxZj(*Hmx#o2cUB581|nGt ztL@P{SfS+x+aw(5R(mtTuQ(=Ej4v)MRuL@Y=JvBet zBEHhHeQCaEH_MAkl6QoCQb^o?&GRd(LHiJ?LAA}- z(}{v~4n!t^X5h_#^&yJ1lv8~)+vv!GDBFmJ5)d%fYtF}fUHAGmEM=RpF-qg$E4MSX zMmR*SPXPvUky{F#ac7q8v$OjQt0gcLgb-1wN|I)2V9K4PRNn+)%EQGEIsp<~w_0o- zF2^VT+I_PG5xBt3`~eH5ZLtR)`WGT);U9-PB z8lWROd+SeE_QL+q70o{rMOuH3HB?RbeM}q{_C9O>>0#N*{P#2eHPeg7kTS-Sg?t$Z zF%f2p9?6G)kU_YP7}%i=b3x&Tki(vy`rx>XynI_nN5YH}MlkHX5NqJM>l$<53(y`{ zG9jE|4gvyje+>|2jkf>;A3ai?9(3yzDE2l%1}m z(ZuaVe8pRLH@6FY{RMyiglKs`#p?+s9a&Wzquq*GTb#4uX^Ltbul*C(8g?x$ZS9Gr z;rxW>^Iv0dg1E~e%w75_9YNW$abt91hO&{F+0LcC{O7}%)&_l021aEi5^i34Y1_Kx zbbA2X?tLoEiV})@rG@Vgl|YaFO21Vso#@#;#a!;q=?b&$7`9(v9K%h zsRaj(Bf|_)OBkPptSo-1V#-NpStfd=GxG!i!jGLR2_%u(X+c)>D))n0JmsFE+-bw+ z%qt;x9;%VyVCcsQWJV(+)4-&6<0> zfp;*hgP8q6I|U*S8gaTOhMs!ZI(&zMK^#{Jm@FE?-k+8w+qAJV=|*=16=05>T&x(i z)dghoV^HU~tWTXfWpDol&J;k0PEL|RhCIen>(>Va29|iYy2QuEYGVLl&nXuWMWyL? zL6DQsbEvoWN*k0xB9VnW!}W7wPfvaqpz-teRy-`>S*MKSu+1yWP&>}J;uC2coaV25Q^GD3I-{q=v zPcla4+Z|Q zxV17{6|(d$H1N-g>&OwvX8dmQ^-9kG|C~9`^hP*W)F0Ltta5>!N+rR1C@b*5s+T?#J^s2HJ%b zNLAH77pep9%@xQdzsoR_z3ubS?RlrwhF?S>Xt}(6a025$_XFm#M(^ldO*zaC$Mx&tMHX#V^q+N0n3U$hlU*TYxKicLAZ9E(WMKrC-zEp1 zN6>{^+}A%LQ+naSWylX~h(6mRB`2NHY%9l;6J$$Q%=Rxf?R+5>mMTp3T4*s@a0l^7K53P$I=O=)k;Bz%FY2Zai%pgD-so@CB zSDnfhN&J=2@3PUi^)uqzPmFzKm^29#CH|OIITK^*M%+A~tD1QM5LjS|`N$1&?x)7QiH>iv0M9!_Nv_S$0 zx^CPYm5?XK0`O3imuH_u>;TutweHG#LNtTGl|i-yeBi0tGR@-Xnx(~NZVb=-zJ!_fhhIT zB~-?*;AaW!=h2rC+1GhhxP*(IFN^}sx^3)HT`ev~&7!BWUCAU-aRJoXA|!1P8t3hR znTW-41f(sdJ>Pqd^T+o{6@mAF>M-E$(X5x1*LZ(;oR3SCmkjyP0upxJBGH^qByrY3 zSO)AF0W8IQvYR$dSV~OY7S1(j8{2U1#j2)kyMHYl!H~6a-@iNF8y048DXk4CdVeI5 z?__y#Z?AL&G%Y~>l8@sX1|dq7i8UU5AE&N2M)!1@XXp`#6(V1%?1u(;(p+QYr^-lL zfNSLCVX8X@_Wy-2UQMhpuWM+?X9fzmiO2S3O^wgl$`_UN)ZxQuC1DB(4PEK&?Zx%9 ze?RZ)wpXVek={{G3ZhV=wsIkmn%Gn*+esrjC>^2TD6WTO?O2XkA{6zm9l}w!V~0!W zJ?8LS81k-?CYjbe0nHlDF~;BBqtV>@1Kkx+WY-r!;JGJ=%@ejyy0B<+%}ZOHaZtwS zz=0*oly-AP(M_BFt~A}?E|!uSKc{088yMZ6 z?X$6IRmTGL0`=iWf%uPUO!CAY-5UdSmLye@8mlE+)Ef|gY;0_J!WX!nK@1bcQxkdc zLZzsvs1MDkgqdrkr9AZV-y7zhN+|F=uz1^BIJfZPk>%+$CbsL(o-ISo12Am?tynR` zo;To3-qQfJwajmwab}JIvsfH*4cBrVX8B*;ZbZrP4w=q`%sPJwOW+R3gnlIVLC1*V zIh;n1RP|q}J?V}e%J(Wljvwb?J?#mp6vdP&5(22J+JO&>ia4(p-MhC9QQ6mY^gn~N zW6jaDWX@UBB^~iE<+!5J=)XIbnY$y{z)b{umPkp0OtD7rHn3BT%QCO6oXH-9t|$_` z*>hy1v^F-bJ^5+z1c{gdkfscB0v%07CxN=u)^>Jsm-p3U#zLV14XnY+IgA()Of@My zAG*7n*eG5P>&M?g;DdEfWVx2}FrIuk?&I@OIdUD^53G^(?H0wt`LIDb)756wOPfYWUe#9jFsDk^= z(BL4(IIykI$bfG(u6e%8lL=xjYpg#?Bx&s*Gf3Mw_15T!RP&`oi)5>G(R+)53~F`L zeB0MKMxB685GwB{r_dCPj*g-XXJm++!HyHBb=siLpP4(~M7Wbv@hdE147%4ya|P3$ zli?c3S`H>jvDISKL%}YI@WED!H<(^vb%}_Qw=6yao&fWpld;OEjZ}n3v0O?0fKS=- zyAc|-Ln7U>ho0wiDVL?Zf0ejPZf8*Y`VAW-uiZ`&?nbZ@1Sn*a`nVc2ho3_h#}y-p z^8z%Rdz+KInYnqttlT|FgnFt%#Tx*T;6m?Jh{Ylp8nyiD46C(aVyjng4gIsEDKS!~ zj4?@D+w@!pgwu%Rd01A~tE{U8@uJ1DUA*YL^<|p>e;ZBx&uv6dv~V&s8Q_1#j1@%w zHaN&lP6>Gx{t}%~M~C9Nb>X!F;(INtLW1}0&;=;z~OiBwr2wdj2z zA3{0iSfh2|&>{cc7c@OF#(OmP?;#Mo#*d(!aE{vB@8k7;^ymtk2%rgr=yP+->#`CP zd&kG`@n%Zp$*U33y4u=>ZDG>4Ax)y0!JG)5*1#D+G6&{pn`c3n-S1K>e?D)yy1HB* z4sD>+Cb7Gd+e=DK7H2AHk$#xJb63)hN&sT$pkfK}A4XQ-h&ViGMRf;JNuXkkYU+D= z0T`UMt?e^&@p`$wA&Kn|T;)$mUvKBDqE8Ha9e(cBR|_j2elb2iMW1)hM$-y`lB`h& z!LMss0eyrLz{27kmFj~HbIr}z1^x>BT&w$80|@1r_`+lFg!ad6QMzn-M1?Mc?+*r6 zxlL>m7WvCH3Jf0Z2rU4rS-mPvu_vay3^F`Kiah;2lqu6IIlAk>ICw(Qs}Bo#iw}Rb z*tIQ4`V`vl?2|kUU#2qDYdq@kxp`FUa>C7k)k7@bzk%}jz3{y#opE`xL7Wf-VQ8$M zMBAIEJOc|Mv2zbXl-cOBuNPO(b~J{e4yZ*O`MQ9I)}jYf?Nf|)D7Pgw$ep?&r6!g- zG~{Z!2Tj|$l`AxA)(8IC9D|1ShT*e+>$B|Cp$p{1dbWWyZS0N)w2u}UOImy&3J0Ll zZ0o7r7=dsFZ||SbtDy(#rA?+T>+vMKx~qZrXYJasJ?}q!2!dP+2el&S?%lh9F9F%u ziDMN!4?$ePm$F+(E8hvq(X!s*k&!-~h*#k|f*fYF!iIK09l?eP2S(f|S47ayUq)hXMP zmVe^iVq5@IecPASZ%4OiUT3;$JFC$2^!$~*D&A|hHK^Ea+$@1Ei(fWrvQ~BWN99j~ zC&ymgPv~P7KLXS%KpTS~0c2rKnALMY%ka%ecKgSM#Dh?SC2+tN&?G&<^deu(%@N z2(`%8@2^vk1_0&$*BLCY^}?pIT?Pg)vG$3etDq&8EdzM7=1mNEpyzt`V(`?p*YB5W zgfd7$a5ci@ik_wdk*>w4GH~ELe{M%haV3BEdxBmaCn-LKGIjp{I zo7o}*zjHHdWiCsdD~K9d)3X$LKUmgWJXj2aFDE z>_I1IOb2mJ}_ENwX)icQpCfMh;Ll6x^Pzx&Q*JeW20#`P101 z35>S|*3=g|=-%fRqgpC?n#9C*hDNyf`OUy)L3FLiz)xdoJI4H2Rl;G0QT$Ap2eCpe zJp<_jV&nscD_s6zmNr{c5ndoS1nm*A;NycfMOyd7ogI{A0CngyUOJ}0H}N8`oEiIrEP>{cmjzW*-BlUxT`ae8yVWlaH zY0Lzmr?UJQIWQ$9duyy7@{5ZnoNgMU3e<-OoxgCQgQA^d)0SR3o69z0wVA z?Ch|*I4IN1z_V){QE>d=!8gP`BdQtx`E6I%kyz2S5qHy;Op>1k=elT@+lt#VbKJ}1TB zVDsMs@^nwsOgaLxxXe{Lp6nS5k1Ad}hEn4Nf6MLA^Q#z*ewfc&G4Y;_xdIW;&hYk} z)$2Q*sZ);O*79Kn?P;qhRa!WBSC7VH6P7T*RWkg(T_o z=iMZEc@4{4n+c&+yEpxNB7X2cJqYx8{!8<|u2cKqLILmH8fI7G7zw_H#?Q`9Y=6)k z3z5z)E}o5{#@viSO<3kqT3S>Qa-(2sYb4J_oA#NOFy|Kd6p(o_SfLnTSin?`L+L@G zfMRBtL6QKP53s1MVPZl;M;K;wl9)`H#Bd)KfbpEs#GsRhPh z8}TI^RNv9z(NPG}enJ~@_pYAIdzRmdjFD4BI;vDDMcKJan2&D&L$QlXo$VANihZxq zTUq;%LFfow1q<-$u=g_vqb<=m03$$#1G*odU@(p2?;l^RwwCbwQ@p2~i=_f3$Fu1DIc`-w zR*oR@iYCcy;NrZfc0l4Gv7J@x-6zkg+`ry(p}c%Hn~u6Y&Me_wNh?)`-9gC;QpA^? zNREVhFE~Xh!z22=1#6D72L`>T0_6Unhc)H&eF}mO9`O|p7bnAVveWiQu*wqJ=0}lm z%7yQY^2(vJCf(z0`tZQ|>hN#0eYmD!|MK4{>E0l*oP**HIeqRbD%u}OxLDY%|JkET zn48zl{+nD5dNYHZ&tJd%c}&BdXeqDAu4H8QifZ_f?8iYmL!G1XRfIE1#gsIj+i@OK z3B0c#u}c;g(BwUMBJcx2Xj(e6bqFH}EL5jX72Uo~!BdCQAk2UlDA(;CfNE`R@@i^+ zSdUm6N(k`k>(NmB_#u7Hl|fC*D97}dF)PO@ho3PIl~SXkq96?Z3x`ZX@!mzIY<)>b zKwyR(r(jjhVelIPxo)~edU_}4oX7Q5RCF)v=Y>8HD+1vmIEqOy1AAHb>7g9i_;f6Qg@uCw!Oe#Dsd57P?s8PlfjfkKy&6CaJ_ z%jwgxRQTJC0E26nh7Wy?(!_EQi1WARLA$VIxgml!NliK^+mO@{{+pF#{ZW7gq5&q` zNV^Y(qYxH~xzFsiu{kr*tJ`HxGUFT;gv?TcO*}?aq9%?&jTIRyT3);eGk6svsAyo} z%V2Ap|K&pBi8iZJz)e#Y^zPk-F2h+KJ$0U7?1fWcG8X&fK8xS&YQx$TRc@b7hiSy5~w*+M!L^hsQahV-(N?s!>3%OuL=+IwZ zYtYF5^a>E~;+cIc`qIMj;mOH@%F3-H#pt9V0KrsLk#GBuRLMieod8PnLS*EKpO#I6 zlaEg^6eEzE=O)5P;q2^u^ypoI1oTfvtQ_)TfNXPD?Ltccgbi>xLOieo2pZj!JY@XX zSGk}&uAYQ6!|&1iTixhXht-2PhcP!H1u%{!m%%@pByy!Mhz%=Au4uP6G;F{&?d1*c zK11~K?uoQ#)H(d2&s z3cTlpZ|;tM!SP)>;MoKPuK;3{l9o>PoKi_Q`3~6)R2wLpz_AeEwR7UAvvb61z?;AU zF?so{KPmMLV=~5cus%R5+S=ksB6oq2AZhDY$F>|8SfQuF@&gcV(0`^fnULBlnQ|5v z7Kn|#n3$E7&kkvf!W(|>IR7;^beO}cBl6QxR`9 zjdVc~up}Zgk}3aAkVLJ-_U+;h5@DN_ zl>@oS`ErXd3`**Y^_->Ejmj>i>hECEc!GeN^NE}{|y($)hNpq>G>(iOlgT31+-=p>FYiX zssC_{x0LTcH-!xxAgq7?S^W70Y%O3LXX?y3TtRtKYVokx!xxDQF*%d#tNYGJ-O7Rv zo7NFD{y*>bzM%gd1XM|c(9F}b5N#T8uHCmjJ`X;P0Nm=ykfcLdQor6xhS^p60~I)B zXcz?$0h=JuOrysVfS?W@bXgN)GPnXLWsuC*VlnTZ75QKci=tl8X7_#%ru=hEj%2`Ov|PF>p$#JQyQVC zS~^ADYgHUl8qCqiL)WTx+R(ww_%P?a;@09aRCRQPSZiwoT+4LJ=!P(Z6=jxnwgw%x z1HIS@`ttkzFRV#U1A2q%HX*+pCHFArbO*`_xo!L8FQ_e2Ai@fKatxg~@TtdOX`!0I zJbAT1?^R?!F7|+ZN?0kDl38jknDpoAA*SyFbbJ2~G{Ie7;}?rtAMy$;9HjaN2eG{` zTs8S54$tNBOiOJV`plBwa-OTIY~Chb-F z=+PDg2t0YQ$MY}u0)pTok!+or? zV8$||%UB~VDki1_uGP!oXsPMKTV~QYGDO9o8@V}Kd1SCcOdWg6cZA!9U|GaJ)D2>H zpCFeESOb1O_*iobV80nwHS$Fi9v#yvMn)$;gb>!m;dvo~2y(Ku2W#U{(kcX0@b!O&S&(i&TA}0SH_u8+^R)92N|qz?3Df3t{b{);`7tsS)K>PIKw zo6V?xQ0wR9z{$pj;6!2p^2|8{!f;{b%(7+$-=rY`EP{aFXZ`VT0K>}(@c&$9S*>PDw zo9gdxOtJ-bk&+^rB)gtw2Gkd^d+0eg8NUY`2L}*Zo@0~EU_?ugbCxhmFzhCov2sXj z5B}cu3r!pVMjr}w70E%L~$|m!$E2P+`^)w zT{4Y1!uy77Oh(%dc*sfEAkRH&GVd-5(xs57j>z^ScT`V5F?et4A+Hl)z;Yr(O4I@= z6q}SUyb$Lp^E5RG#@g1%U}T1=Y6HOVd&BBNDj; zo_$i(&cU19nV6q1`9tr^9!}e>O3poY2M*NQjlVBBclk7hq^1KPA%6q#R4`o^;X|IB z>=OdorF2v;kmG1oW0=2S<`!d8+;JBdsrottY<=1IXj>QUFnlVY!jYo~K-SDtUSe@# zLW!mhB_($Z?P=*5l`grJ=eM->ngWb?egNbE06?AtO90qI>v=Pe!`1nh~rS}kTMViSjE43&6>E&v8t%p zH8A?abd{hGAEfH_udVlRk6-Niw=81h;Ol?kR+GCxo0QI_V8hoG)sH? z?39$3eon`aUfnGyCiWbl-j5HvNO6**-X0z)mjuLJc-Pn9A)+;U59dr`X4l}iZ~6S` z#&T%xmJi`gcMuh+vp|c-#Dw6?I5Qk!FI{$1<}109*a1@i7JUvO3ak{;nGQ#XiF1LS zUxpEw1^j3O`xjuFz7H*{K_f^fcA(5n174zNc@fXC$KcT%%Pl@ik>TzQenUM*q^nYA zG&Qt%0y7E>eVW2|PY}k`mMOLbz>7?*`PZ)xlu@G$<^znQ2m+5S7x)%35OCcQet|HO zNIxi8#O7^`*g1ECv_@Ds`ti-~Qwi@+BuBsDnl2QUx*q|jiCh(Q{CGXM$ob5A4)Iak z)cBf~7S_Fv9O|__qnk@I9b*WA>@%HW9Wc{Mvz7z51!ntYRCC;&pxTTT6XR`NWp)En zUCuRH5h4>Z4$+Rs@=x|av5TDUJTNc>ooZQd`^4q~K9A7eP*@M@C)A|4o10{Df|(W89FPn>8nNH54tO2USc zbeg#1z|~UBUFy|n)N~!d4$zbp7?!&-ARor8;C+AmFILKKl|e)^?5+5*Fh5^gU(eH? z+|(@L{qbSj4xq;g9#5Y=+k0~h<`bmDb6e|gLk$qx3#uF;bPG*~)_*fIG&~|o-2!@q zb{KwPYx9}eS%Sf{3wMfOI`%k9`#UIzd#f0?<$x4%hv4DMb`6cF(~33~)Q=xelgC00 zpSQm4rupT-fJIrU^;E#kdrzGK_xE$%M~|H?pdn=;>|gz{2bDFIs*mXbNQ-rt8P?fof5gP zW_M1i+4NWtd0Is$VYl9YE&%=izWSwMm#H4K>-#CEd-ukTK|F92w3Ax4=sYn)C>SDz z?c&86VOTw_+wxv~M>h{c8rm?x!Z@_V#tjpbIc7Q+$Nk7G?Q+$#1H*X<69vUD?C|<9 z4&+AHutMoXn6Le@fe&%1htV10%b?q7h?pP(h-ZKDl0*=;N)NNs<_IFf!LWlx=CIJd zlsDjSH^Ac1*RN3HJ7ngxXBgfZcIy$ocyVZ-hc~4wnr%<(YUNg@3xa9jHrFYXX~a~Z z4FQ&gwO72tlF9Vc_L|*6K!qOGJaGVB8SCKZ2a8Kl9W?6i-xCs&31vmagcL&c`$8q& zG-=3ij)gVebMkd~s^V$N(p6@)Pcxb|`(mpu{rL80wFYo=0YSn13pi0iy;ixZZtbxU zca5lHRht2meV;ZhzGwyJc94!~*o;Ld;){majb0SypxrLwOgY>aAvVaBc;K1tZ1#&i zcXh?h%F5Lq%(5)At&L%>dMK%CtyFL4Q-*RsK8Z5V3awGmG{bB0BSo z(H6HdENU%9CZC|h!>9$QKkO|n8?!A(BjQCh*9DgOf81ene&fqmJIm2o-uM#Jv&o0S zYKY5bRDc`~0T+4ti?wZ0etGAi2_JRk3s~;JW>t{Qn*@|CdwXA-hGh4Q{Kk zJC}9ppP(bcPf+3O7 zXnEhMga#HBmnIs05!wqk)2)dG%TibNb;W0XA1^}#@&P{q@Bk!cqWMRR;ZRhURbPk$ z%b4_-j?Xg!#>$ll`bedc!_OcXlu$`*%V}aqWns>dD1&PYaS zXpRHy6tkY*7HrmzKD#y+^$uMt_MiRU{UN4A!BDgv?PZx6U%NsY6I1^LE zwWankQqxMVf)bk3gt7m(Twh^fHc8~{jg#tT1x9)4mS)_h5c@keO}g>OeTrli#Q92z z_sZv=$v)Q9>}vxry@NyF-dqETWXgiE$(ydO-XvrMB1^F$U(Kyuw04)ZPx0no*-pNK z&ceR=k!pDjWx@9YErO4#HkfFS-*uxpFSp(sa5VQ$l^!64OTefWr z2Ci?SCu9Fx%8a#7rM4JgDxh*uZ*<={g|1IzF`e2rX5awi7!oAMAa(uJ;2#~x6fK13 z>X}{u)ES!~a?xV7b||(y%cS`1u4d-!s9bp1&bYu1gb01gJE=Vp^-!`4Y0H1bc;8`JMF5aokmb zMY+`-FbZe|0)dhR2~<-zmDj#bExj|7cVw*J3cI; zr$Xk4O$Gg8!R<8)>7N^b#83h50WNrOT0DNWyJ$`BJadHb93#aXI`C{6K2S>bCoXsZKaGw zNYaUGS&Wl&m|S(acGg8`rj~@?>d*|{_2tJ$my@EW{7$`D)X4rYeZNNQ+cWQMt*WOX z+0~X#Kgz#l^lkknc6z?sKHF;FK44CkmhgMICR;iBT|%tDol99+g{7AzE~#FgH-tPV zXz~C=iXziwTN@jtVE9h};9>JwXJZARDWrcRMroiOp(H@eDWo`R=jJC*pJE+IKSAH_ z$B2sCPnMtcElC8UOqQ|}dV9Vjw8Kz{^e3S;S4pS#5(# zZ$i}RGR|~cT&>#GW2#ahJ0bO*@_Pxdzha32Q@d2Dg6v6X+aDhvysP`}(jM{}eW-<1 zw6%L+(ymCVk(7RZzB=a$?pXbN#OpcTj>}}?=-x72w1|9QntQjLoGY@JRC59?*I9H^ zoXq;9mkSA2)%HRh=wmhKMlQ6`d`vk_ROJ{Q+aq&B-@bXsa%!C>`(6256tO1q>eF41 zE&3(Nq_!C!_8fIN*HXEB-#>B@X7QYou5lfF55MfWfx)4Fx@N6Y0Jy{V9h5}>j|QZ+ zB?=8S_-Bm%x+KH(3&*6sJSP6a6Rn?}@f?h@N z6G-a>`S=h}e*$N;H5t5Drq;<#chgO!t$orCXia1J3#IyO{Yak4x1NK|J0s{*UrU6! z+PR@6qM3o{6{-cLhQvg!*sRjs#>P_zN8UU?&qk3h1Hhb*q_FFq>(|5?jYBU-C5fc0 z3p21ptCUuE1~4A3O`HH_4&)DHwL801D+e$5J+RPQ!N)@g49wlXT|`F*Ar`JI{8ACt?N=d{)Y5~)Ay~?hp4+JyBkP3fxI3E?Ce5X3c-VY-a`=93A)!i zh`h}+zg1{4ktJARUCi^=FzK-KNN~7tkye07SBd8s3%kFp#6wiJ_0ia}X1Zesok1ic zT6Tpr8nYyhQkP#mTwGys4TVRwcW+71c_kn&q^+X@39O|YEyeS6nKw`u{&#z87971_ zvx|P+d-0(0Or{RDoVmCRLPK5rdZN18tqnI1+EkP#d}qcY)?pdA3(@b1GyeH}uA>I1 z4~C3y9ogdC+-EzCqG1UUKQi6l3oVVfEHWI9bC4qKR`d zW07>`+r_^ph9~$avPo43|}b&HDt6$PX_-*R+jY?x-jJrCB~E#1JPhoS$4D8P%N%?s=Jj{HzXKpQG{$X zmK1b(D$HOPJ+=Q*pc;dXt!>*t5Al#;OMxaU*U-eI-)~Pg3F`!y);bd29X4V=BWgv! zL%gg2^&mNes#(oKcku?Lxs_?SdU(-Bv8#c9|FpWsR^F{VQ^_eAYyzTBJ08tkO%Si% z2fYgfjVnKjn4P3!&okXT9TWt{;T_cY{QStLXAg`1PQW5Hhqf_{-G($#vdcA-iukq0 zoOFM7+ou8CF_Ddc(L4~)8Q=Y2?{gM1-WH|o482oo{F<=o3g}6?m&H~?9QvcXlyS!z z*fz6ish;V%FL&eq*2+6zZ{HCv;J@?WL4ILBclV7ttLDdY)?mqkCj%{IO<;-yX9m0^ zFWlU2SuGgu&?@d%4PP#Xa=lRJW^`M$xlB#C>*D)^(~?bB6-m}aJy_RiZ!&dNmiQY^ zz?~5o4Y2BEZPFmipgp&sU_*Zw`fGe(>O@>G`{QqTMG-)-kE8_$^mWU-zrrvNd@gp_ z0m2dp^`6G|_P1i(tzObrzYYk9VqB2v)!~%yL70PZ+Ei+YIF8Zfh z-j6uzAQ0eR&O=jHRkeLu3*A2$4#;Cb>eVNRi?3cC6AyJv<1w7)p9S%@6= zen4dlFLp@le;=UGpMdXWer+$EAuGojHg4gc_QoBwh_XQ7hK!utz@76;-ZT-N6;()B zIrCt`2z~Ave_KHR^_sZ%wJxlc^Gtl)fsO-PN=RjYZ;-sI)Pb!Qf6q?R@c!2@s$(#X zzLq=KY=;Nu^t8FY9B>ZSj9=9eqXx@qoZ)|VBUknB4tLP4D5kOBS$5>zXP`=_L?>uy zXb@`|(TN5c2l&Kk875xf!pFHNLQ)fBW@R-oGiz&a9||+FIN4sbd+5p)Px z;5j%jfW0(((O95uwzsbWk>j!{Q$t7R^RCBHIjp zAc{9{>T-0QzZV=}D0|c$e(siFMyoKDXhx3@8bkPrmO}FY_LMAOs@iE_kcX&XOi;K- zoU(=^4R~j+kXZxHfIrUKc-qb3MswKPEmvfnC~a5O?`)x^e6`>!V=T)~SLF5LX`hN0 zuoqd49Z%%NG}nLN6^1|rw;cZl4i<%H=CQ7Q@GSoi8#L6oGNXvCE@{_deMWXL?H$si zn6ja<%k75f9{wjox5N3tdgB0*@jB79<+TIF_ubhFwDYEEx(Ya?zY6G-vIkZwHro`n ztW;lS_`gYGs`>os)3Gzru23p`djCFZnTXq@;S^D0igWsyADnUCX%!^wzU!bfKoDY0 zVMz?N2K9BAEu>3M>|_8!h7QQe$@L(0R|Gmna{mXq1-H+I3`O6$P zX_)u#A;LZW(!`W#q>oiQU|w-?dBaFnwD77KNTA2f(4_-5oR*Tmit#@E&4?O$DmVve z)v$U=5ULd61gdfv5qNp~oEkS@CoHsgs)nWPRE9<8z0av!E;BvJ!!tyMHj2S9?8 z3b6x(cStG1`MDSq(`^VVn9&W3#Z9d7*g2-O`VvXxDqvCQbf1H$K<`LEcHkUQ9rH_S zJeMbx!+y=pd3$;eklKD-&DxhMRiL(PI&U3my+ zjj9@<{4S{>tRxE8Dw0t8`7^&kNo4r|E8=iUf3Gko3D$U>kE)K1ih{!I6)EFk?-Nru z&ayygPk|hIwk$23VGHPeah8(h_xUO9c5~e;+-JtJ(Y~OKHa#n3O*j0>xbhO=hqAr+ z>})9ygF4ei1k+wpjf5D;G1rAc6;iCZv z9jL8E=AH5mNI_rOT>iCoLF$g09dc<8yO2|u;H|(luZ9TnhYwM)9+Z_`N}z_*#pVCO zayYz!dTihBYUc!>IRl;u3GI|9-3;6a4sD?pcd7VUI@?iInv_8SK)~$xwU#;l1U&6* zB1GT78jpR|8k(ATX~F}HGp&h~23!zAba`F3FsK|o*VNl`sfw|VMV9@!C_UAn$5ij= z)BKj(-QR4Vs?kzX*5%spxwh+l-sH4~73_cx60yPg%gy041!#qh63A}^(&@s(MI%w^gnQ)ZFUAX5{Wwx}o-qGSkVNXU?38zPw!DN-Wy z5F(*ch=@cWt25(yy46#bJ@BHRoP_fBd&1y|r4bXgIs+v9Hm8rkwDhnhPbivPxrkIg)Y) zuCPwPqlZuot-|>G_k{-^TG3IC)p8&qSHmeOJxV+ETO1joDZK%rw(uV@Bf> z@7_`WE;|od-Eta2a+jSES7~Ti7}r_YkX@ga4b&U7+xjX-5)=F3V?@@sdO#w`}HVC(B z^7e=}IjLS&1*Y-W5u((bNI`_K?o4!OsF4WiS1A*D4f9J#@E(K9IwMs477A1lw{h+K z0*etB-y^FdKXCno`{DuH*z}_V8DQZ5;L}gt{rGZ{h`Oh4&#~1CHOf;EblK3#H({s; zh8r3RB&NO)4+A_8KXbjNi*Fo8RaI3FKKAEhgG%<-v}ExEm4-wR8aybJC)?nxg22If zr9d?^CMh+w3J5dyx$bTCzsDuZ!f-yYudjvZ_fWM2Hy;-yK$LAIRAdj~ zw{h9+0Obnm5R=`_Tj{7W;~z%mFr#YeyJ#aI7ulr4MOcVZ*L>M4EiNAXBD_D6l(OqI zCL)6Dv2ELv{SQRg*>S9HN>cTh%5 z>_}rIpO2X<#97&i=paW1AaBJ?)cf)!JQ)s}oP^_iIO*`mdsBPIrP>6QPXI{+ zR^jy(uVpZtXmrs?fudlf#k5v1ywMGR+f)J1p%E@GR2*#1w0yuNI3(&{?3K|cnDhn> z%WQr-LWY)LrRaPql%{*ld<5;p%3=)L3h((JBY7ehrkAh(d#RW$rZ?Q*`1sUZ$G_u| z#FF7Wv?;*e1&WaBE6VEYR;z?|4D%hfqsJ?^j8$}shDaKTVtN6RYJAIpd9z2qE@RZx z>V_*V22nhMhgu1j^YgeDFpZ3p5b@byzzijx6MYxJU#VWCyrSi>0vK`}tO|mOxbYo7 zhWOH9TTUBph_z5?M!s?c9zS+W8>!O}<1T!D+qp9eF%3aa-@FmBfDAu76zV{LA%qYn zk5(TGfoaOkEpOCSRTH+Q5&sNjY3T_xo8B7;r(7B`*L9`Chn;IL9uiA<{X)iniMq+~^TD38z-|4$hd865fpOco(GCta?e{oxi`9feH>jH);=7KHISu3kczn&N{cdxhW zQ_5+VTW~OPL83RtHgS{a-oCyO+iCM$ePp$;iyTX%k2+Xypab*5rSG3h!irw?PSq7H zw$M-}zPXz=|CyF2O5}bgivJfeiO>-WfN}{QEC=$Hog!2}blmum|2i3y3ckl|LjPb} z7Qq+@Auals4La+y!?gux;GB&h8dZ}LPBc&S7g zK_wrDNmIdE(fVF*`dRLw+a)ERXJ&F~$eoOZMMVemyUNZy!7@^+qK~f&Jfw*+hyyU3 z_(O()dmdr1ZLLTJo@Thb=gY3fhrCipjypO+`%{H$7E21TX~UMB78Z_&ea@FjDPH5% zy|E!8&m^1}%=eZ#ZVhHCZ@lZ2tK*WvIyArcd{=;QrcKlS0o^$HuN8fXQwc^>O z!P#J93PTU1I7N8YL|=T9Y7qX`690R#Y3s-m?8hGY z%+b1Yb8zSpDcPFjf)@3ge4Dr-Sg^HiamhSU^9#B>^9L>_<-ecorzb2qD6F5dy_CJH z`s|Hu0*VV6=Ww~eVwxK2ZDGMy!T#ugbTx*+R_6`mSBN=i8JSafyht0Bt>?jF931OZ zrqN8a-1+%#fTAGIxKw=mw(_`MoFUwq+(>Vr6fgHEfA>zkl5E3l{sE$h3qPNRUEo}a zsrmHZ(zC(8^St`E?`;3+XgMQ(UnnGccXiJvNm?MUYAGb#Fy}oA6ZW*RkL>!wd)D#u zYwX40xcU2o4$V9m`=%MVd@`Ps{6K!j6y)TJ>~0(6%3E+B$mBd{>w1$$clpPUzh|aB z?p|4$0FVwOo&cdk({&K2CZaf@iMGG0LC0SN4e%4|v>UGNfyXh+tO~&igJH;6Z2(qE zkH=Xiu*V4uB-MGHbP`FR3Bc3=C}ZgaE{KN}6=y2VrX;_HDsqS<9P8-9<%9ivI;Mt} zI4MLHUBH3{D!y0XJyM)pT$cFPiefGr51t^4iP4I8wzhtJnz$-HYV(%82M^^le_LIq z$K-Zz?jUSpS{U2nOU&|AuQ`wGq%{k&JNYVOu8dRG{w{NTK>@+C=PNH&7I_)ovp<%S zJMjEu{m@YQCN7^XJ6C=7le@KJ{WFs;+7TGbCWDQ+W8dDr!Tm=z!n$JV;|sZ{oC`4Y z$qv-CkuiK;S4TTl%qH4vXp?fmWPAKcjb)afj?1TshC52MuI;A&<}16>&qiPPS|0 zEPC5-#$Bq4^g97VUe@k3$Ccl|0QoLj9=VIo+_C?jsv1)}YfFUxWztf{%8#d8Bi?S? z`L_&RP<^y}>Mh&D}K3eN#q-e@poR)ZX zLDhqY_USlI8uEUZb(oN*Jr<@1d`wrHTbd<3JWwg|wNSqo@59(+sMR6awq-(k>(-j` z@_96HsHwo{HX+=zrN#E`fW}sl4_`HB56oVGd}`z09W^i?ran6!U&ktOHqZI?8#5$B77Pjzr=%~ zx%&0=4Tqc-?$PYhFS1{|qvb3&Rg6EYe_g;*`CRV8DynJf>4C$dZgI7AgPrztpWMfr zQ%r8O=XWv3M@4n$-o$Nzj{2G|&kZK8C-hOb5`QLc?|jRdnwEAC4EOLR0eN-rymm>+ z2p5{D_0{3~(UA8E6JgL9zUHp#QdpQ!ZFdhJia5bdM!W@x)c^H#5udKs7?sve7 zcWSY}_C%dyVWg>jhxxYAcJcOGYw&&UY{g4LT4*n*eeS`wCh?d>*9vPrz#oLG_4ixS zghg-AXp_hVzh57p)?B`@nE84C-EpsH#R8l#6` zH=}z_wZ!$YA#f*IM4v+674imdb`%iLi1-Nb5#hvQPaG5>&5;+(RJRQd&d#BI2-ku} z28=me@yi&apdUV!i=yMRPR|kPsM~0-@N}&eOD&qO{bFmIeP^AvX5;1gWJ!Vg9^;w9 zH5wI|iAM_C{N0vRNks*vw0yTX;I(z>5F%%z|KJ;*|y^}%ZqIgjGC z$*0;U57#Dg#ghYF6m(jPLRWP^IOmd>3W@hSu5uO_Wc%62_45Tw2V8Iu7@#5u7 zg-oC=hK)*9ett_^Dos=)aTpR8p9sTavWXYYe_8%8E>C0c(1J+eDD4Ck==4lX?xbVn z@9#{mK_c;kn}$5kc41{$r18Yt=B<%`=G~>J(9c%>Pe;!2ysh}}Kx3vAay9VUdxGDd z-b!OjHvv}Lv0Y-tfK$^|-LJ|BYvyPKCTAFWKAQXu3eZ9>Q1xAoBpobI95vm<2cn?(SDEUq)C-q#?S@7jNHY zjMg6@mNjqi#jlzKtlnL>nxP5(FS?PWc*ZW28VZH#_8D+6X2BO=i~(ot2vQAHlj$#l z(u2Q>ut9)5&EaaFIpndR*-?6yBqYbBYhbR~APB)GhgfzPD@7P1Q z(7}|u5OWBQhfhQ^0O|D=*iJmX)E&moPg8#B4fokAVVq@|ral2IwlCzbnk-8%USWjt zr~4&9lsj9toO~O@yNR2d+Y$+tuYW29N(T3Z5*C$s`RHMR&&=OEXgIOCL+MTva^P^U zVrF&_(6T-?R!hPpCUbKdXUm!~yRD{~jV1#JI2=N=aGzds_t z^R{fU;-5bY9tqBXJ-E38KF`sU@VDk37n zO2xcxm>3g7Gml`KuI$`mfVi?H$-X_PAQUFm7@Td4LFi}Q)~q$}GEwpdFCH)b$MW(i zjp;QfGS}DIa^-w-(-*`*34OYHhOl)tkt3K;>QTlpc50nCNlb5s@yKg`W+CP2(L8DHOzVb1Su?O%PGmM+6)>-R{q|S!!&OwrQ6m)JmnABKd-iy7w;ZV@Y9H{cx?oBtlcXhbQ8G zw`-=D^)T|kB02D>d#>kG8f^Nlgl55J_;TlV@E*>-4G3d`c{C(x*z3)#cG2Bx={Nh1 zCI#*82wJN-YUqHy9b3BiOXtTDfydq5HBnOe$cK*P5mX*oIM!C@=daSNfSCh8kqqTg z(GZq(;;^iJ5RgS$%46Hw8nF0bu5I1cU!PareBbz&7_g!}y#JrKMT?gjz8C%(fW`jZ z?qJWgZRuxiy`Hl!R}RFnc*Na(ebH_UmS5 z4+p1db_|BP;#vWD>DSMnvxO+rs7a7UfjCZ%)}W+f(<9@^uJ3RFmq+;u> zzAy5pl2=h78=Myn!3ZN4-=ZuzQS`i^d)*r&@pb~%J5PpUK*a0jSe|8dPfqw+bfEPlBgmd^`fzkXR;s+_6v*?npH zyE_qQ3RLd6DWvW|#jqr8O6411_J~M_evef4h%u^Q$iN2pT5K zbqIG24Gq2Dg*^oHf)kY<1Ipvi{d|3QfB*(Elw<*!pJpUi zJqdn*9wL%gsjjwG6x1ZR!ac&AZ!z}c%BEb4jOd_;catH7$6c~kM5kSX!o4u_rU2e# z)+bNiZ82}0iw8%j(6$WgoSjMg4jeFN`Upx6E7kY0*wp*PTir=_Kt2NC&2 zC_P;z>FYnhNm4}X6Dw&hPV@~dGfZOM5ZakKol1_doapXtk-IbLDT zBuTW=cY$Wuc@~mM6i|rVdU9bmvm{G578n=^pcfS;?&I@;fcar7X>z$-w zBJ}O+moEs-zU$J#?;Q&}ET}tix>9_s_j{^C-zco@2Z9)!0SgKXojAQAw?ksC%qyk^ zMCH_7S#EA4rM8yv<b{mjCK6J5>tl1|2}2ME32hjBfQwkwIs*pX?Fd zH;ChjoA~z!ap<}i?HYI;skK^!>!_bDmfht$mHGtxnzIAi8(ZsZahwL2b0gG&4V?_@ zlBn$2bo#7_g^zY@<;6 z(ObS`CJ*|qpa0MZ4ZM2Q(-8Dj?b($_KKXD<9m$W>@&D&j!vaCgS~vtB@GNUA7hk`Q zym?`Mf^ZNm<=W*6jKHxm(rZr``}2xWxy6gxHx8+^G3+19&gW)b}@pw=QUy z7dIUh(`4Qw>!B$O3|2>SERE$Wj?ZdW1Z~|HQ%O19v72d_jnL!M$k5lZ!`lO z-JroE4U0t9r$dxoVCSHJ+byzeLPr2)^~tvPH+^(MO3Mk{#|13ZQn7GG+R(cwEIiK5 zS4D%->p+!?JukF|rV4J=syNGgCc)>>piAMJQnSfG0F+?Q4=-x&(b#v4III+BacAz?)NjY!8w7D`2~mzL>L-dbwr zg!~NU;>0;tuVD^I2Cnt97%V9t4MFcjgUzf2M z2HP=CtO5-K8XBEeL2=OAv4OJ~QE9z(LgLO~kb#us!^%pq)Ie{u$7Bk`hTx{fGr>G= z76)Uu3Mzt_Sl!_?R&_idtsprS>SP@aAoF6|vP-?E69(w2*aD3;VVjOKXv{`|wZ}Ss zT@}3>q^jcLoe#GX29sbXp)5^@dSQG#IH1v)qS`ine(pm3QI>mHuP~Ag&rHGr)y-`S zTmh;$#pN+Ey~bV_q%%lCJjVq24vC+2@lXv=kE^+uIIyEAZhBO2(-wQ;u)jBq)?2lz_dMa92*hXZ>Gvdt%;j(FHJ-r0AV+cQ6TEStOqdP@C`^ zQ+uL#)!{e$01P{e+DqSs9gxwO(G{LKc756j1fRkOyILZ!k4Nw?m?jyR%Tzui4I8eQ ziD*jgZfonaC{6I~04(_jODn5Mp(!d=9fBvor;i`8Uk^6UGbXVj(6vkf%opzv8&O*R zCIhYTn0HADn5{xuG46zOF6oz}S0hq6@GjtQTJH~bE>UO9*;B#t#l%s@(2*AL?c0~q z*I|0t2}Bv+M2T`-&PXs{SCW3Z z9!{L04UxHe8nbK~&8IAXQGh5fv8Z$OGA)%E-z#p&yv@q054WL`rXlBO(-5!f(Ox3L z`Kwgej@WzhD5OV37|frv-hnuhiUec z`vhSWH5=?n^ANr+-s%F4v^_Bu7F%Rw@=^Zt@;(4bni#ug8&Iu&=R@g_IbYF0j;fI`WlYV}zKYMFY=PxyyGXiwz zbAx>DJ6pMaXkq;e2{m{_4q{(X?5*>2#)**>{v=bPz5D5BO5Un!; zrC~TI?C?dQm?9-1QNO=*5E$VF7Krp7QM$!|UeSOf?dPhcRnnk-GCHmbmc=32t?56F3y- zWJd|sh@pweRJ~I)lLFRTm}Y#qF6tjP&xzWlf7n|N-46lga+uc}YTDVK;r)cg4&Mdw zv$<9>%iM2-GF9YeH`B2MZWW*e<-6VeToOz9#dG-XJ4f}9tNMkC>->(}e?nhzk>-SI zxQAbuEhyi-tIjafzQCG8euG*PsFf0@?cb?ypryQ7=LaR4RP<&u*M06Wlf;d}=H%+? z$N?i>_7-qGMsFXK{~b>bSlGoQNPkzyEJgfWfy&bBj=I1(n%di2G&GK6WIstvTGO|C zuSeWvm9)DYmk}g0orP^$HPp?(QBgErNO5uM5_Vp=0-rFhVP?klSW!=ZT4O`)<}K=B z^^FkI<8$o?bL9;cpQD>FtP(||q?Ppc}cge@v|Dl*P~S_CnVIds^V;{#RdO zhCRgxPb z7YRV(RXql@N<`JJne6R&ZmKa4(&Z=X~@4Sj=#Bmu_U)0z~BK+ zI>{eE0uKQ^JEW|#uGSXZ-l5j^_W6BKPeeyUu=eIMY8DeKKl#{TISAe$a|OFK(0Abv zePKJ4qROS~J}22!@p`(uHW9PP%T>?Lw+0y)nDbP3xU!s=zw0K#5E^xrzZCyo{n@iJ z90sFRJ?n>ZP`N7fe-y0Wg|)}iEc-b7k&tv7$+`))%BIUhclXvaY1TL21J<8)+E29= z6Qh23mrjLJ%qDC!$$Z5wt#+wFC4&+Z>t6VzQp2{e4L0d!*^cj@k^N=+>P(Ntz>c)+ zaGox1rBasxjWXUC@gx21T9q8<@-g6o0ftgb&?T1UC-E?`gYACt;wDYGQoxNOw;#8v zry;~Aly}&ofNdT+S~txg}_FC`aX_wkMgS|-r}Yf5juL^?=R4QSgg!` zUtu!nAwoR10;5JU!~9k-9p790`OoLL<)@q1KW3Ucw(UM^RQg<$jLG7^B>RYRALh*1 zS4T;o#>P|~8(FIHZ#tC!#ebD{6v<9Rf1+4k6Ep&(D7Armnk~q~a~)I;04n*?YvuzN zeoKR6<%jD-D?}0RN?JO+n(ZK(q#N1SFt>EDALC zJ2;!`uGH5X?i{eN^`xh#pQv`z3ZFGKPXC zAr>E0dYs@S27?`>j>7$stG_Ghvr_SuMot_9egL0@34WE0n>IBHuA=g_9A@YOK0g{b zB^#Qf8kkGA>WjB6+h$hN`%k3vQE*-Qh3UHiE5?UeG*eayQ4ZDj zTjz5gDWq*~CfhQFLfN{QbZj%sZLlf9CS_uJ+5_kwDmyGh!H0+B-2>#`p4=V$+FTKY z^#&8uxqJg=#0)~93Frug0~H@K@2G=0d3ilSboiLjU{sl2)bb87nO*-eF(E-n-IKZ} zKSrCuZ`!ezSifXuoySDx=r{_w9*D3luBw5?0p?r52;Dotp(q8WKjSG;Q`a^*%Mq1I zl{^>t0%m4ph-8HY0!`vXYxS49mx!}63lb)izVPgbm29kDtp?gFZ-sFfL$1pQ1$)?&b5)hoIy z#Y7qTFp+(?4Q#l)9XEKech~bxg9$Dl4f&OmZH&nBPjraDovXopz;oV>rmmdB1k+1J z00bFO=Fc4S7});fD!cCJW75RRSt8_TUSZ|u@XETCUn|o$I3zE8k^1wW?=nA!1=!yP zFRIm_&HDFPY@5%Uf6BIXR!jS&dEFT9ZA>44!xikx!%Ah^r$bTiq;M#-&T zXdz<4#lYFdEZw*s*HD-nwgE>T(|7U9xz7}KO1yt<&AU^wS5-A|!CK52_`p0(SA1z< zWnON^gNWjWMzqYuxJIHp2S+5$LO5y!>aS@A?#kd zHvS26O6TUS__~O8c#V-+s9EFuQ5PG>mGy)gHEUEYMM%*;5Da@_Bg>l?yyeJ!iU?cb zx|q%Nk~wMQ3b^zA!r~5)4>9NbyI|hthf>)8gTCv1w+5Zv_mLvO>rw^1ZsDmfxBGfi zEI(y)mPXu`%I}eJn*hn!$fw98S`%J6(2>_*#(`MmxXc^1HO?s~Aw>HIWB@mJ|3d!> zM3s?JI7xqo*ncq%{MXW_Z#WQw8s6bf$&o%#-lcz3)P}klh?q+Db@RP>`b|wu%PHDa z*!62As9ZvO43r&XJ367wvU5r5*LEGUE-+xm=ICQ~ph7wZ{8PZp@%}rwm}9NMPeW@C zDa%=3-z^8#J>TE}0VcSY*nIRfGd}T*`(KvOV{KH&f)Ap_=P=NPf>R$qXI0cW={0N9 zXjnUd`rHiq!V+|;J7pFhAPM>%x&S3s!g(01s`_a~AxULi0@Nw=H;TO=DNe)^u0>h^ zeP+0@VN6mACK$h;-qvKi7G!9TeKhrLB#T|CL@`6Vd01)O|7<1n733e*Yk04XcQ576 z-HhS8{bl3fh7u(c57GAMAr5)Z-Obtg&!6w9mPg$we)5DI*e47nfCk-QlRvZQY8&;C z-DMunj~z0-sTyNUql!0?fqSLzw*n2><>EixExk+4hT)Lmsl;qP0MqL0m$a&|4MdC3 zxCpwlJsstC+d@mqw*+?EnqG#q4ILD!47{SIofRdzJ5ns;F%V)4ipaZ{0|UO_KE6P! zIs_+3SjCgh@A}Z?Da`nA?(YnbbX_9WRcS5AqL(53?P36cM<35y6No7wjUsP zV`F1u2rPp=1-|z)aNootjteBG*KYHHkO8M?`6~CE2brk`odI@LDJN!k;Y}aC_XF@_ zT?wWQ6g25kNugBRW1%#BOO|x>EbQpK%xRau0f#hy;5|8 z*xHi(AkM?};kZ_vkL>l;%;@I8nx;s1JG+#;lgz`l-gu#gEckf`?Ci|4k9wQEoOEur z579p2ku(U9xG72?Y!^UhY%$S!a_>g6si*^NO>Y$!>ztY9<%ed`*5R37-}c-l`}fc6 z4jkys&^%krm|b7;Sj6}EM54&s?igNG=T`2JM=(9PV;dIFoW1*r(BtjfqWFmB0-YJJ z0az!n*dqrTPb4u$C-IsV#GKTtJ)+c-;@f9_S8d$(>xLQeW&-?rZhsc`l>lJwzc@84 z2(Z>CT1+KBKPZTn-$Edkyl}?FMRK79{89KFVO5PrOo=YV(mE!?OnXRl4R$*quu9{t4xkHUep_FR+vq3o@Lh=K8bBoZh z9lc2)0GoK(j+IEsG<^VuyY%A+2Sa0h{RFpTG%G{B1a_($HaI7&PE>mg;-Kqm$S_e> zaypq$BKga>t(8)r!>$EZ-o=aEI{mO^Zf#wyWN4{c*%*jI0<{f}hoQMeVY?er0@qYk z@A>7UyY57IL2m8MSV#Wdg|X@aV|jaWPAC6^wd|cf$aR5`@f&0Z&W`LXdd{(d+mowj zpz@T|nNXMqbq5)I_?cx+>JX~)0{;XCB605GlJ#9o9a%Kt&nkw%R6le`m^PHLW^rT< z6t=wDhaE?`<9;O@KXUC9W~H7jQ2FOx1JeKz*uZhh!%jfp29R|7M|c_rCnn}Tn(LeE zeLZp_VKQ>aB$D^y#)~aSqWj(A5*WfbjF+W%e#-Z#y(bzG%-LEv>HI8V0e&ew<#(hP z`$xVu1hbY-EV78Hqea)mXb3|hHCU=n888oM&TTfWBK^;Kpc3Z+vc=g%;yk1$S8I86 zAo~zNyul@w();&eB)H*(kl6JUYiEKU&cGDX|){DI%n$#00yf_qCUwI@)ftSy} zu|0K*3J9{;%J1OdljFLQ@ku^>2ap2vH_1x;aJMRc)M1*!+X4~&_%FJXn$w@yJWKkZ`I1SJtiHl7_({?(VzUUzk6F_3jlG%D1oCi0;Ea7k%k| zmxW8ldCd04#+MR*I2mE?MIW9SxjS|}#50)Uyzv1$)nf!D@zW3*{ZBDMf`UE^Li!=C z8WFtiy|~Bs?SmjDVZ8oBOvBkkx!80CmHj?IZ2dbX+a>N8CiB*~+!c9QFC>znag4E7 zMAkm)PAjV!%x`zNWVYWh>`Wq>S%kT-hT#Fe4~WYd$)?ghVY`iAZ?k*!kMe?5jV|m1 z{hqkSgFXj$r<`qP0brWdY2XrdCD7@>S@)469vRg zmc4_{?Bfyq$;T)V=xx(K#VhBtSQ zrw$*fpRb-5e=NIOTV9@Jc?&SW&B+gxS3-e~N(;ot@O$62K+xl<~|U zR3iXWxYnVkZ)o}ff zA7;9EZy|7DA8F9SS@)c;FDRu15WHmzUnnS{oM)Jrn9z+N73rj__7y-EYhy@QD0Wjk zfr#R>bt)k+gtda}#rwk8cUqYU!B&h*7t9a%U@|HZ3rVgF!h^Jl;Aca-{dA7^=DwQp zK^wQ7O?`Urb{w1-r8%}F{dSK^9T;fGMz!CZ!}<@ymbemdBPedBrqm+sx>TF3xFrC4r4wbci@(T)77QA z>`e0wZWfl3&j=G2A0PFZS2CITs0$+;^KE1sR_bnod`vS>?;Hlikx~wYDIrszeg||L z8tJP~ablfFQgUn7vQjxt(Nfaon_K}zK(vdQdbh6D78CKl!J7?aU&JV@WC&v(L29~edC`stxZ0#{%F z#72>qi<>}3%K6q!yL8F7+n9{{6_e&`=@8-)k+O6 zUUNRKwk`PNv06QjJr-&o4*$n`;a?Jk1m`ctrQt9Un15NPL`hzkyYQjq<1Rf&520KG zfM{rJyvg=1{Rz-wV#SHpA71>vzVK)@F*5R%qjT0m;)hMI1-#qNE4?DSj2<;E+_81> z+6Zaec8E*><&hPfS9de%Vx+Bn@W2Bd6+Tq+AeTKGhm~I)IHn$gutq85ZdyGv?3CDJ z++9l|1(Hk+^(-p{JIxrV0ll$-6G)s%Z)ICo7m2h02rOrtp{X(3z8%CuU{h?64Ve7j^ojs zmjqv$I$74B@-npBk#yS9R*ja@k$B;rJ$=^$SZ02W&N$L%SI7=IRbnEsLBae8XbPR= zOf~1~oKE)DOFEK!Pyr4ch`fq6Hzx}leCCIY51>=xU=4{L7sjf@NO0-Bm3X!EC>SR; zAcy}7+zmnmrpv2p>*%}cryA$>CW)W%07*5jaPqU>6}CaYS#zV?g@r6PSg*{ydl$H% zbl!tgUZX1eL}L?=VA3=IL$^7-Q*3^IU3Pw8klUpMto_+c-rn9w_}<(jOK@BO$3Rd9%*e7)oS%tHd++r2;BIG^f+KxW>z_3@ zC#fCdcN+w~58~$?HS}Gmjt)9*0FPA;MFgLY!FpkSU%cSc?WU&PbO(k4Rh@p=R#ejE*6b(3ID93nZLC=yK5W% zSHW{!(1J|0)^MXi=6)FV1Hp~q zla-!g=4V_6Ztc5-cm!qV(d}`fQYkDcr@fQA;uwZjtzHfL0wSVmdb;{nNFBq5p-D?P z5x?7EPOk)o^VZx#ZBU#W?{Y$RzeA$grc~NzwUU$W&Vs_D)lPNyo>krFC zMk@j=H>#@(RpjS6?jiXBm?ru)zxi8gcZ_3Y| z1@13)He2qf8?p<@~t5)6=*eU616gGQJZGk2POL7<8 zo*;49<7jH0gYM%&@vfzPB-Y{Rl9ChP&qxj$8x}M~hX>23A@#HpWVh>4ghvMe9{pj6 zqGA1{1bROf*}#DCvD9xray%-*cZi=$i^w-MbW8qWsMB{Ke@~5)(23CCZlO;__qd92 z+MLF6Y6bUay~js}ij;9`n3CDsYe@@lqo_0NuR!1I4j93a0&LoD)kx;h726uJ85+cD z&VX{9$JqFIZ^UY&a$<>v1BP+<4MG=oV5xpx;!Sg!b@FI+od?UKy4fqVM~ino@dMJF zvh6O_OGT#aadw1CMA4=s7MbVOz&WAdB}|xbP7>pHJ!x~V;hyn6dv>%4-#3mS_(+g$ zqX~||(()c-myIng<#IM*_ZHMye>BbEO>TW6`(gd?J>URcXK`<3!6I&9Ur#SbmsfK~ zM}smkq@#mSDX@)jzB>u-I1xYwhz~6-3{L*IaM@^1n=jefYs9ghX=j&gd#gy1J$UHQ z&cl;vGNN*RoWxa%hCrSC8CmRZJk(mqSo=Yk=YPI^Rzp%znw(V%LDm;mJ&Kyj-Ce}k1%4j(NBp|kf}ran zav(iDI;H+0JvIJP9rq8J-SUUB;DN#e)08vF3GQN^`O2=ZknlNT6ZH1}@!OxkTOPmx zMs;)tm(V6*uoij=F5FQ~ml5motEs8&ChOx9^R?W?2FF@E`3;;qKx1|%X~UIa>uF|D zE+g=SXMMn_R8!Z%OoI{*P7I8yjcRxme>^DoviS}kB$m2(>EQk2awe3gy}fsIAhP*0 zV#3=s5x5#IF(v!?7oZA)e1R?Kn>SEb9AkNBtxe@Ss?E!zuG*fmAj6Iy?>WDl{kraT zg#gP#cVZO;))boR7o9i~1>+Vn1+iI`#om~CZn&V9U150LWQg?!Vd^TQLN|!aKF}}B z)p^%;nryjcKNC(zbN|vC_T$Q(DW-ik{Pcoen2j3CaCDs3g>MvaYLj<&7$J5gGkUIUe&z!C z^8nKb4-DAj)zd^dzBkTui5u8&&`CQ6QXA}L*BdUTGSbtpj|5kumWLnVM<7zn{%D9E z@eTG)aEMl6G$j=o3>SSt+;~(gE%iUk#(&$wnv1_DGk)hIMvQLaA33XbfKE^SnKSX3 zVtjEta)h#|ONydBVW$Sux_?WjwmaoR;uJnFWbRv7%nQ?wlSxOaRkFn zdN=&V>yK&B`Q81(h(&rE6c08J&m2Rt^7u15A4HN=Tun)7jdc|Jt7X;=hFHWd`1G}#n7eHK7g@b^G3StDl_5{W?u?a4Hopq}dKAS)8q|9zC zv=m91c7NAqc-2K>S%kwYn?1h?g2Z_@VEN3KsZ(Z4(niPTymnUFInKggh*AxzwIK~ zN=gZKU59H^0i6*U0HcFo8l^8Qjrk(tQ?nF(tNB1#;g$?^E3}2YJ&iB#(zv$ub%S#ART={l*h2U%QzvJA5 zdL0R~PvEfl3i)BA62^XQ7{1t@)^k1id-D+J6HYB-V|-!n9ctFF;jD`S*vf$D5FrF# zp8i;|b^8H^-p(9=&V8f;&W>1~FUlIYLaS@XsPe+^X03U!b2JU)7nvCvA?%N+JIG1M zwK}8K+Z{xq|0?F&^zhbbu@-d|72;&dFfeIz{ouC}c!7N+3{;CIqqEs)1*)JzzIR9Z63g!nXF4Je(T{#X@lNs^8Qw}khC(g)2cP055c9)(m6SvdibZc-KCM6gxxP58R7&)7ftzYCmm z=guKzGMH8}XaXK6+_l8ab!Od#ou1ahBhu?>nRPTb@ETc`>VmB}t$JnGjZh$q90msM z6_5SCeFVe@>5Jkz^t^>suzo5AOdy{nFp}W%)tUR5BhI+GN->%*v1E?nMz-^}pIXaL z4mWM3WYpMnK{I#USXE3ctGYVXL~@Uoa`(h$SbbmFmNkfzN5m)^GgB*HZP_`RwM!b^ z{Xg8?_F6zRaKy)IFR{CXEMuvGs7bEPz7&cyBaGb?4TT*h9cwSDyAzT+$^V$^{CBsM z_z^qGpZ6~;-$&8rIIO&14L(Wmz}c53O@Sc=bQJ;u58<*3@wYrUPtsdNMQdNaJd2AQ zy$-ZkIh}H>@;)z2Uh|#Z1=KI*%9S<9699qof!Ck^*N;Zc$vNAK)hSy zH9-6hnrXR~JbVZ*m6W(KMJoYis;MY+0Z2$V{5Wz6ZOl33l0f`nfPu!*2Md|s1U^lj zjbA9ipJa^g5Gync6rD%AJk zRX(>q9MGWIc!RzN77fO_im?PMf>$x{H!tc$dzBFlM;FQNEH>zunb}W)In5mFbnTw; ztM8!I!1thzC}z+M7ZFxW(++;RWvZj^zNI~R@&pU2#(^Z89l}NVWVI*oP`ndfezDOH zOT|QCfp!SSwxhNSi`I;mTF+cr8T=KDSZQSN1?s&YCje><5F_Ha+~33Q6<;d}`= zhC4~76P;Hy;}&)GcPXi<)q9dH(a~Rx2A`VCaeaV6veh$>@O4`VK?oj!P_rT#I+3y5c1m7vLX?L2z6g@)yFv?NOmJIN@V7QF)50 z;K?Iu%~cCWlI!m81lbw^x*IuURMI0o@g8iC8z$&okrXe#%HkR_;N$iR}e${$ob!0?@jJ$lkk0L_{?%8|b zc9y}$&EvesKhqxwnUXQgf{=k_b@2nc8RK8`w*SIR6PwXofg0sVV6lEsV&TERKa9;9gPChZ=YKKlas^(yd~{nCJn?baVG9tesWM=jr!^&KTF%(zlgigcrX^y>!owA1 zZrJ5Is=P{kcRGr*wqQ5DZ2x-ju%73bqVY$IhhGJKLHWtz!ov4=pkAk$2T%DYnAPws z1$qZhrN$0)-DnQF-(R$Cp}5|IFIyDW(7U#V+D1ajtf)AP!e-t}^cWD@LWiVxC^a_L zVNbKbH&lCHFhlJnu0Jsm%Hgs(5B^lrcxSw+>eoGT$1n@8KDsIt$m3L1d&X7n=C3CIBu_A0e7H!ytNNLsp|!HWZIU;^d&h)pVm8k>npl5 zIqPEVtfA%v%)oxID=1jr#=w=wM+$Q+AaOE_UcX36L;S~~p+oZ87CJbHvP*Tp^NWic zbDyhqfORe0b?D=)`5PUzp;&Q~@(XPYWxF8!dTNz3Rj!saROT8}3eCAfF!_?P!lFOC zlfFtA9HHE{F%_Q#z>8cm2NiZ*arpowUs5^zuX+Cu;8P+h!r`;43O3)t=#pPgCe70D?q5Nxw-KuSd!{|Bq3xJiN{pd(m z`2dqCt=A>szF{x+v~gEJJpA60>~wWWBDKvpLC8M2apMN+c1tW_JA+mLPBO{|G#FmN zRko5iDC+8qcnP=KbKapq!iyj}q3rHm*od@sXlk2fUqR-%y{Ot6rJ5$6TVaOva7$VP(r-raSlHZ!U*BHdB0O+G9;^3-=a!b}RohM$p|+f-RpQf1 zhUpXmvCqbPEfRXj#rU`WHeMAlyrD68mm?iKBiZY8Dxan*py*qIG-`O9y9&ZT2Ck}Z zj-stFe2Z=*EQIeFEcaU@u*qoo=ckLL6t@NqR}d+yN=xT(%k=wrbLK@lOPV<5?X$8H z%P}t*SI`Y-p{wf)uLy`=jF1MIR8go{&#yhFR*RDC%f%6dqUQZf&IaA&tS2)PQLIvBB-;iikS7%d8KE)^}vA! zF3*~H@5QAvL+=8bu?vK9Fpri~7m`tB6Q99yxAyNj3{2hok;a9Lt8I2(9qsLgF-m5F zcO>h;z<1Sk?8m7biw(qXHNT)>v=Ag$|9$%R5vilE4=o3~#+TVyDg)DTge-MY7E#N{ z7odjWrPF7xZp8Y(%p@(I!Nk+k6Pu`&r$gr+J0}#mKVH#2`&ss%Hk+()dqeg}=`H!v z*SP8RcCjl4GBdXCy2<-QF!t8^^~RRh=yx0LQgT)78!E8KcvLez<()7!zmWQ{@zGFe zo{jt2jIwEqsY-9?gTTFZ!lMbKP8lq#1Ysaz%Y)whI0(No2&Fi5m3_<&L~*q5OSHGaupAB(W9dny}Ph(m1bL#-F_N$Ra z*5~vkz{(q>pCmY54&rSQx?srnaf-zc@M>N91(G26jWy@KueJW^4`D1ShZQu}(BP+& zMfH-mS+XgJiqgccQ0M1HP2Q}Z$GOjP&9%=C^u(@apS884J?ucP=u_I{_=g(kEtmo*>O#L zQVHirwBBF!?dng())1Nr?0|HU(Ym;&iiWb|dD@GG#&yVe%H)z9O9?r%Eh`gG#07NW zudrp~S@Sa6gw4Za?JMr!8WP21%v$_^T3OZ{73$suqo-yYzL;IJ?EtdhSOoSaIC5^S zbv}PT?4}~HYf(`M>0t^v!iw`vmx|#``x2T|7Tg^8w{Mk=0)4H#B}g0tTEakfeCM{!X%Cud^Rm~)cE5`&h_AfNA?)O`x`&lKGix<91nLCt7BO2*rZ@;!_7~GP%kuv3rGgpu3sN6F$4XK zVI*JI>n-q{GKY${F7zeHnY+%z+>KviuuoqB4Q)YDkt!{vzHdO{&4W#jn=sTIMF3d) zoW|aw!*Y&O>&*B~4T$JdH#azg(7NnMWRc%I_;N3miJWcH9Ym+6s1acxt++9zjt-p| zh73)ZX4)+qkc!3%t>_s-mH>_>7mqm z&~EcB8uG|iy|tp;|7zI({jXn$J3<1WV0W4Eb*B{LAUDHgpFOZ5QBa5nro08A?@MgE z29G-S0+6mT_a{8Cfwr9gIoAYK{rl9*5_H&fj4ad`8YQweH7bl9lh;}NADx^gaSIeC`0Hry+k$%sfu=yQ?wV@%F8VN*#!sZnYQH=CWe%Bho3i zxcE3m;MDam^`B1cYYlN~0DToGG`Mm{`>Y1@tpzm#kgm7?|7_S&T@n^$uAU z2U}7P9H9hRZ**lS?B>?L=!Pw;<4sgwC}gKTe0T{yXvjJ_G%XfW4(FUhkoWeuEmN!l zO{T_Fa+fXB2QUbR6Bu5P?GBsB!b|O!fO+H7@qX{x0jF9$9gxHiRhi`4ahYe&p`&t? zc}PPE@Vp7O%x+L;ivhcwp1M9~X}Ws!{i@5mFiC<5Sz&ej_$L093}nHL&>_O2em_<; zNG0q=Z#Ji55y7h=CG`Qd8x-|HP{I+Ft2iL6?f34ALEB+E3PGv;SETdDXbU530G%6Y zhq>wTf}RZ3z@1h{_8ddx1r&Ps?|&y|y=XxzTX-=g5!;w`6Z6RsWWHNbL7<(?_q(?T}3m2_8@96?2DByfgndIY(Mj0lUDz( zyy8)e6903`S@QXDu7g+{7gG%FJc}ILJL| zhy8soUhK29w09LVqzKlc2~PU+f4!skRf1X~*JME>#S6$#lX{nebQu5`S)fLeH?-dV-!%;fUGMQnt}imd;Vnk{@C& z#9xBlHvRxY|A704loHOPuenpUB#wl2m4>qN-Kwf3eBNL$pydR4a-_PPiChew!`V}( zvN>pI$mhij%TJznevYxIIqh^kEQh;egHO^l8Zr~c1rze^Id9<9T{i-W;k>FB++MjP z7k~V4I3o>yocLPayvoWgDMm2}-L9L4oE>`mttGZ)#;*CN4kq0%-kWayt6MZgKJT`n zoB3O2>OJq9SH7Gb@7(IoIp_ULd5fKiO`J3B4k@El)9o^Qb`G7kG=7@&1!Jd)oYaVn zY(NrU*Mq5}U+6@iM8(7)_`PfW;?^$QM&OTr#S8_VDt*NbhA`o>9%~Z+xro9aB0G)* zH!AxQS0YNIjkR@{ahDE%Q*J}^j}P>Ap1gY-yjWMQ%D;Vk#P^a-9~P+phpjgOr?Oq& zhZhQkGL#IZ%!+GYBHwKLWC%y&`6e|$ag;P z{(ay7`|bDNv5#Z#2pDk3pTEokI)U%kK}haLzkVGqJStZS9+OLB4oh0%%VMd2 zUGop%h6PdCisbxM^>^vF*NHS?;KdWa3@ry?sDr-?*j<3%obTz8k4u~@m{U55r8FU0 z0R$7Do&IAHZjB*OoTAD~7(0n$CC;%)-5czB zplp2p*sxc1{|7%Rjg~LqT)$q$I7@eLvODg;^lT~iZQl?ruV}PGqwg(42th0LAztXE0+(^c5YsQj-`Uf2EJPqhJljI4{E{X`tD~~Wt z-EA*=k&kpZ>QTo4|RSl)t;?|WJMzOzXHmgW*+Kg&u9( zdQ1#~(|YOZ<0AnukHbgQ)c`PdRUV8MJ<)35PI>STL)N<9uMBPmasu1c_zdqm$8CF# z;{!6fm#T%MzRalD~#N|K#HvE(Vz;>f4MxKOCQftHam81VAQXjjC zRnjA}xrCs!S;6*QE?ABsvpF+UkV6DNsTQ(L2;InLZR=Y)Zgfq<^wV$<u>3uZ*W_BU??JBaxQjUuWNU@gZ!zfCF9W|!|JB&>}_W5@}IRAtvh zs5yasE2Lq~4U_j`Fsm@@LYq)o>5XTbUpamcGE)vB-Ois8t7s3b5|D5^pzz5iMYJNe zEi8QT)!Vm1O3g2!hs*o!2_XdVv+}m@VaGSJzEb`WtJOKq0EcgXWM`llqyH7jysWeUUEv(aLrYkqLMO@w|_DaCa%^EBlp(Q}`hgQAFaLeP? zAOcdM;RKSa0pDuCn}~>k@h09in^135Xdd$$rWr{B)h*Z_nVQ6)t5L{KDCmp6==>ei zIay*X z{Jw8PJKG;-vMBGiXjcpm-xNE66A;r8$zg73>HnWomZKHOTSu=v3<1LN<8N^zfRYYI ze&k(-%8J3Y?26Y6|0mDj|3G4=Q#wN>9ys}KSD<4UZD?!++JNe>eribVx9b%-rFZEA z&(+`Y>)?wxg-u|ri|Dy;h<}eK+@=;5u)zUvu7+_ACfjJ;u&D(V+aZ~SPVr$Ky(_0h z4G#;0;po>Q3rS`rB)WKKBqjCy!+;4gy;EPWxqW;5tCWv?z~CsnrL)^Ps0;f**u~}| zeG~W$Gn#9K9b>+!IXxYnnzB54^cTiAMau1p3ZCK7X0)gBfB1&&p7gMj0wCbWX*1a4 z*ta=_g$^4W(4|j&!9L3M7KP!fSmwqDb0=0N_P%4n_HU<#h_l1fy*Fzz*1b-)i;jzP zJXvAl*{7WT*?#l#KI`r-N55=wu1K5XD&Y>p(*CT=TV_-_rEvdc zO{3^YL2GYp*7OdnyI1ZPS4tV*C%@0H_=f80&QFU^0G`@90kOyBYw~4vhRMjMv9a*4 zmk#;NhW4>ru}NoNyLKt%Q%gqOEq&?HGCVabOvva2zcOf?DDsU;0sKj+&WWh2&XDcyMnn zu8IE)$EV!)2PIJWZxpO#$#n8t^?!jkIP%vDi%mLS{tD;|uWV>|IGuWzOR492`doXH z%d3P#x7a{p?tY(6t9fu3=Z*+e!ui7HIYDqoCmJi5PADoSPWpqU0U#7@5S%E11kFxQ z+n!P>IT5Hkwwr^BXV|r=uMo`F51Gpcfe1Hb*`EE z*^lgA@&QdrUC`)7qLavCa&NoBO`b{W7t_c3)wWeZddocyh*Uc)EbA|~!Jc`k?NbCf4*k!-Fh*{)Rnz9zj0k`Z#v_}eKyR5ACnek`f zEFkh6`hPxNRkua93x5B-PJI*~yfk+djx-i!BDmkN@EA#}|2}etFa{rDn#7mw{UWr5f{umg=uuP$w_K^e zb$4uabaK;UAW6buX5uSo$h zXR1M8!a+DG{|vejgRO^*^2VKBq}my(XIV;W&nB=$bQ&=`P{O84Azg|h)4$vR31zeA zQQ3{do)uhw58qBeat;ZK(2X{>vQd1gs|s~&pM+w$-W9Mikm;Bc4zocwDt-I8f{=@O zio-36UApO%-rXPUHPU6&_Ll5qwl_Uk zi*yhO?wO(75B2ssIntzhKICCT9&dXX*RyEo$JM?}v?CM>1+iMo0StD_)bs8(?gH0{}l(5m2#H&^?2{Ip+!7COGZSeu|0LV)-Z*wf%I8ccIFc;z$E-5k8dh`t( z6;6H7J2s*t0TFQpO?BJRtQjB#|L_eZP{biw z#1^5SrKNH`g{|P1L{p&kF0PRxeH|H*$AXuG3cf7H$Yrb(&{_gCY-6Qj;06H}ThsD# zP&-y7+!JM~N4&>q(ftw6L;o-|z{K1R^u3@!qPq=0oVTy9cJLy83=1X-(&CG=#0hQz zwrB(!?=yb8W+DZ$%PY)_<--i#4}TCjaJ5 z(7$-I?7O^nz%c=hl#-LhJ-d4ch&qZd2E1Uv+lhS1H}p9VI-khckQ8rX-q}SClZf;^ zjEt9ZgSH|0+jhP?lZqf-3Ln2OW6Ih9%ASCrAdGl@05}1o6H`;sx}(P&#xgW2oJ>;V z$9RB)J-mTN&F70*10@lroS!fV+ZG}|ab&;FnQ>Na@hpboW7!4P#*>#DG*A6|t6~=N zcQyy}Gyl4E22GlMwpBN3lvG-5t9HdsY)*cxR5ObKCE*8Tm!M?9?g`$H8W7w+d-e=| zTL3T%^79G7FVR~iE1&Cp`BDc6JNyOU{etcex>;rQTo!N0h!K>V$8D(Q)+YnqCkM5w z8Av!RRbgN}52qS}SqW1OtU3`5V)-yYWkz~7;}#|r&4dRu388{2Mh4}n?U6ApGklSo zczGkY(zx`PCNU1Wt!QH(h>2Nk<;f|P2m4AjM#4Ub904E$n4lHLJ?Ho>`L|6Ox*YWM z!axb|&w)!BDdV2DgoFgv$9TE3Rfr9$CP~zvZZ7Ee#V}+ZnthJTb?;Y+Z_?2$5;6GNZ!_(isvs{4u5)VM`4eTkMMoVhx_&7 zBN&weBfn&`hotp!Kie8DuVN@K+?Cu9DN?*&(P-2pY8C#316k@RnVFxze@`e~-y!nK z``X7X{K|V~{)J~rFa7>piu>NQfUL07WAUOkkGk8X75E8vg)?`(uX$jEvO(Bu=`1$t z(4?Lq)foxfK+-fdgRrZePrq{I3Lp&F0f6ke-xX&bcQ4+u9DawpcTZ9%K*d@h0llyg_7K=#L*5chsaoa%y&6I5FEbUyH_sAEh)fk zczis+$FFM;Q3C+jR6Pch@5U+4qrKg(mewzb5X4p7x(Cct30M2HkC>6tZHNNM?u@~D zQg1@z>}B<_%R&>! zcXwgB2F5C4grXgiA6Imq6DmBMP242Ye;8#QOPtLYf@lQFdhrS00rCvDn^_DjOPS62(SkmxK(S`Al2$? zenElkvHL}tER}`(T(afu7@1MG0BHO{!;F3T?A{01qhob4IsOjqi>(-Ff<4J{N(7VD zS>!CdXK%;{c$-?j1g!?MvtKM zlvs6_fMaqH^i6M|U)Uq7s{RHf~%qm%eRd2EjU z9uERwiusDbHpmxeck_2aNA}#BRnb0i65m#r$sl>v%;;2@!>gIdh)#oU8M5gkX$q(G zUeZ^pjGD5$c;iWzleZO7Usn-Qk8Me z3MN^{zJfY+L_E^u->pgtGcErm&Y2XUCdCAYl@$3bX4XmaH%$s{3u-wqYOK7vTtrn> zQ`>4ViVVR31;`okUoS+qZ8~2Mu0&+inSU-czfA74<$q z8-=e1LfaEe6tY%7`^HMON&c*?-Y_)9VElazX1<8ww{Nwv-@`oa=Y;Mc%?eIcpkEG% z3fc)bN8I<3t1db6p0wrd?r;I=+2?eZ9X$%+CK6}u5=~S6V@s={n)9Ed(+#ed^$}l5 zSEzhw&9R-4xBMb469dN{3#ZdxsV39<{C2|Jz4z8@Y=eJ> z21gk(EE|~mC0Sp=lIhR38@8uTl~m+&X%%hK+o$1hB$wJ+bgLy@J#&qc*o7=-wO(5D zlY%*>_Iu8cRCUs^w4|Ot@*dE|DF(O!Db-d}hRAl(XqI?0S8FVwh@+tS@zq@>S-I$b zJ~ZXLlk3azFE8sPFihm(KK*ErvHAt{&i;FOv2I; zj)|GzGFXK78WOg!cp)gG85+xtxQ{~qzFc0Y`~HYPi?e~Q%>4R=sE5B{E7=H5;n*1J zL=B2iTwEOZ3%}3h_$syL*@GZhQ0=kYd7{7ZR4kjup_^OKrcQF09 z=q4Qc$9_90iHD&Q%a#iD>I70Pl}hc&$LYak@OCXIz%LMcb zzT{Z9!g*hDZ8B-_#S73&(n0I8@*HV~GA>aYmLlwwCRiczPR`wUIs-|84VefkklL~( zRGG(AP|@+(TAjtvIzQ>{+dUA-q_aflIi%eXD>M*wD&AUSclre}aq%gWfvYoZSoqaF zB@GTIj}$3phg>VTp3$FpFlqD$e|@Z$ZaDNQUoZl~+#m!FGVrXyU>+2CI3Pg1ByG({ zjEXSCJV1(Pb?|{sdo3k-AWNtPCbsfkVP8O87LiF?=gT_y^zHP_%v0^Bv6@0Wg6ji` zwQ_%ZfA?*JBW1}O&+fQq!u8nX&>7_cvMIQB0{RCI{oJ}@2q=^k=Ejeozp%ae1I!W_ zXM-W!ESMB3uNsW~#&`m1kLLN`>oUK>O$~eh_yY$`I@Yxov?iSSC(S@mTPnzWz8dt7 z@KW}70?74U#ex0@*+0%OiC-5kM{n*P`cbhSv|4Z8oQ1)&~$t;kKp9+mc|{D+zee;5C;*Afg3@ecPBgr zoNJJ*ji2K;0EX{Kdz)kn7tRq6Rdpur5nNSq#FyjnErgZ&u)aQyR10YFcs+guw9#F$ z-%eHi2+c0|qAg)^osXM4F*!LoE$vwzqfeybwze<@Zu&*p0@z`+cOu%UNL@C8BoJE; z@uf2_!XHH%(0T&6Zm3UgZF%hA)a`M`CFkBwDR)vSCif%UtfW zqce%WuNYaENe7z~n^E5+d9L=TJzOSf@}pS90f^+FW|{G-?g3G}Rp$)lru5Z4W4sMv zYPcUoP-p5^=ILpiPrmmco-}CuRphcYKFg-szupvGG*N zDu{9}6D}*uL5Y|i)eo{p{(|Ub446SqXlYljTnU8=ZUsH^y>~E_cX`ec9UZsfU-k#@ zO29=9`Gasaf~SF-XIZk*x)I zZ=P-S>I?{wqu+pY41t~sSb{(ve0_YnOn%{v2a#7na9^7lJz~@HgERXtdx> z41n^MYVgzA4*m_-`HPn>)k*UiXTyc(>*(kO&d~*EAMn1xMW*H*aaxM|_AIPxue-a9 zF&`Bdt@zffYecu)o&k9G>zAaWA;<3wDr)i$3~s1k2Bcvu9jfs*&=jMG>3hVBqA|I_ zOCr?yk<#v#;dqsb>DMG>{>sb?+7&HkoAjOqto4z&k=a%dt|H6KwuaIANQp&RShgTv zzP3lA*q{X!hbVH!c7t#|(I%;TOBKZRdU<;rNTq4R9Qeyhuf|k;sry^GJOurfXN#iq z%cM}zA&7XQJ=I&dfk9c|b@5b-Pkho36JdjIsSFDbJ%02&;nJ@O!{_lG!msJ;F1?!ZYfB z>{9;czaHJtMq8`%w{>}bHfMS9bLnI3AiS_yAD-s0k@R?$7Zx11f&0IjPph_MqO8{Mc1pAqvC{rt zqFEiUQY~W6*M_ImM!kXe01zb2YdFt9Grq>wkZ&!6H$W{U$+Uk>Whib%n|=>iVtYFo zCdy_m+ivW#PPdEyofG^U^cmy+LNG4++xlB3!-Qx8J9vf#TrOQ~RKiz}+^Z4Tsoy(H zY&p##W_`Wa%7J2>yXqvSg>>Ifps#hBY&&hWBlkjSY@2O{#pbI`CQq`TzDMNVnqoW6 z_RwtG@)272!~qwdNqaJx3`#prld{*NvlDA{l&uf7*aU^67C?sp02rUW-gs3F%cXI5 z63v?JUpLq3A~^bm02U~P;W~^*UixOjf*9>A;dJiwf;a02yOWCxR+sW%`xF%s+Gbo! zhyf##P$-n!I6m;n-HJX{nSr_x$*bUv9TGlf3>1!z;~0fOyMctRlEwS3dO-s3MzF5& z1~Y+itlFC0Go5W+k!3 z1Wp#6(D?qA(0O3$O`AC%+b^$vU7e;K0}V>$*K6W2zjparPfW9^tM} z`+|(9MvVJw(n!i70$kfa+mIi%TcvFkXr2Ce##{tep0chCx5$pw8`O?W>uUjA8k2@_goJG|5B)W4=)mFsoPW3h*dBHbo$=fDt5AL?e@nDE3LX*))6Z~%!P2p!(nQDiPM80 z1S2pG_jg!*k_1GbT6=EDvj1jC(!#2eaq{bPYmH-BU(O-Y*kILb@E0pqay**59XFIN zs$Ao}*vuCIh&@BDuCU#{{AliB#e=+lu}9A(?Yb1ad&m0%l5&eD^x};Yn+~h{O;ZhD z8h#z9U@1%}6RuxD169j{9{rpo;HA%*7SnkXibZyI17+nAi5JcRRh{)8%Ps*Z?=MM1 zXNnXN4#KSi`e`*e)n}C_QnSod>51a|CqG_DX*elSxN&hM8?UYFG^xee)wOMQXO}a& zzV?oevb+{4h_njYd&0uMRyffWdmT&JU73pmcU)Zl)ymph)>d&LMShVFp`DO;*_k2e5D00_!kiI&edD^n2tL|Sg&5k~> z-XLfkpPJeUUj|I0XkGvDOG(CXgc?JXJ}@C65fRYBEx7;&R`0(2m)KB9@#yZr#uFl_ z$HALk15LryghdkmYUCVkEp>H);?Wdzr?}HuOIKuSQoA5|Chxh(N*xBdje)p?cI|qK z0j=tWQoy@fAL$#@Rv%X2URXuNqKTD?W_kXF++)}n3N87*2=z7de_lBPdjKmqejCX$ zoQgSfT%vzBvaDX;W}kF@{*CFpoh&@zketg%q#EWToUyFJ#yec>V60?T%ry%HrkDf5#=x znFkBh?>slaO%0*w_PC(49NDfCj(@v$nqe_;Cm#nStm4HSmf( zzHx=4AE*;G*l?+;B7qh_oaq#Ob<81LaBpj<&CWjkdz&XX&4 zg8F3Ik}If0ol9%;m^<*Z9Eo@$?lH2P>A$ul6ueWe#Q6l*96&0u&4S+mDdSXE<;c8% zuEt$aUWHu(UX-f<^EJ|oa*cAL#~^qV^j29k3$5@}^(Tvl_E*kF5632~d?)a;AA>F^ zy0LO=-pM@bBWy6V&lBpEKi?m>j?B~`YWIkfdwjusE9w8zrMwINQw;D7yc@K97$$(! zN+DvC;5ehA;2{va6=Wy)``0+rAUV$1#iO4m0b&ZUU1D=n>+K3r1kT1bCmtA+6L$1S zd(V?5Y8>t=Z|2H>3hmg~7;2aaXIvdXJ^PqR?2?cO0nT6S4EBg8Nj7F?Rp^R1s4x|a zPPw%$?>MFykEa)oV)4{ZqlNk_IQijT=zPw}bd)@R1-O_j${HGO1%;~vO&Fz`;&85U z&H=>!(ygoQ;^V~;!M%jBjQ1Z<*+90)`884-@N(8?)$$~o$o9NtfjaZv@yaPQr<2sC8alacPx(9{(itUd*XjvMdua8JY z!pnks?M;6_r*7Ua#}7~T!+fOV9}2?@?0_v zD;hsnzu={9l6YZowEaA&{4ku6S_WelE-m`>GiT3omEpd*x&btwuJxv~b93mGk%OZn zFMnky$EYbvGZ)uhm&4)1+%-x@%2z9$JFo<@sX6Gc`+1|wYdNpk*E_o+Di+%UuIZGI z^n)SmdJ}i;nWX2*@=mWD9<0lZh<0>xg5iGNMeOW>6uAS54&l(P5M2kjij~U6V2}qI zC`E9kLx9R`DVJl!CR1Ne&v|{4@!Pv~q4I1ilKOhdd3_BBBrJIjjGgU=aiKZGu`qCy ziZZg)uX7%CUt5%CauWCLhM~qZ0f|`gmRRtZpRWI7ki!zS^n{}{Z&!kA@=hym7nkr5 zy7Gt2T~k7HOpBrnY$g)n2m=i8&{zINODI$M*R8U2x(mq)=Esih-=cv|9tKiP&CMvs zQV?Z<{5@%zWWczG^&&n$%%32H{G-Nr05%(SrRLcW&(|x13Val?e74*QgbekiBoToM zf*-g0A9;h37%A(;64_wRRQz&Qj6jn_T%zYu-|i$T+n(V~Y2qrh4NWGaRGPyy1a z_+L(1yDq{h0vdlH5>2yM1%W=}t%qF7rUNkDNJe~~5~vi=JH9^!zNVFxz@LWo+o>u? zxP5VG?L=@A_&(wKH`-4~`$2%h*jIi|NKXyQ56$okSZ-zhdb(y z+ieP|Z?F~{o)I&mJGpN>Z=9pONicGaP}(1qsWOrNc#K4o0SytWD2|}r=xl?d8M~k= zdwkwjD^Cikqwo4-BvG%)DO$5rY`%{@BVp#Q>->?Fu{Z|NSJ=Vd|F=QF*Es~up#@Pm z=ND6MWwLj#S^!!%CF;aeF*|rK_D3;=2d;w(q_~C=_$0%R89ltHUb7xn- z0_pMzQRj}Vg(Ol&gu2-4=FOjpoDgRb z&AyCOnUsCkl4XOplEvV|3VcahTN_67_wPfv&yy0k%1-&JRBO1KpPwJzk*n*Sx4}3& zcG*=W`J66I9so@M$WZR#Uqt1?MH8grtYS~0hfx*c1zt0X7YVqZ4_jj!NysO z4;amVaPdtJoOE??m_8&R@P4%Napfh+;#aoYt3? zR`}6<-#ceR`G#W_>V)VAMUih{3Rs%?Eqk3PeCcM2Waek&br+VF zO4f>pf{sqmETgl1`p#nIy$!2D@Y}w9{w(+p1YU_ljmq)k$C)7;q_je+giq0h9QhFJ zqZ%=-Jm9T<6g%*=2H9CzsViFnV$G;?ZC@+w4M*-3w9ajAX}lXzMxfN-N}^)?u{1TU zfEgj9(>^8&>xXq85{r5+SOS^Q1h=lt_9^4J4-Ce8UBJITB)kR?i4G)X>K$NP!e-e2 z78^_5XJ#s37ll_aBt0Bxz|7NH=eBMu-U!*c88!wp@8L8PiTaIE9ex4zJ|Elp&jcB) zEz_fN`rfC-Yg9;>Ws%eFUN%Dbn?(5&mfU1GeZ7#4(dLm&az1%{%6@NlFM9^bD$m6n zk>8?+~(;aexVjE%ulp;iIr93AHkzsEHwMJ0hW*#<&&AVgvxH) zrYBW>$NN;3?5yNP8@SR7$E_{{X4n-L-ZM^CX>9gJ(|h0n=VAAcrh*T(Em~A0C0Xh= zy>xJ(e|>Wei+4c=?+3Ee>F{dUs5(hi-*xqpRN|fl*Gi>m6D~2K*jqIz1%I zIJ~oeJ<89nTjBG3V4S7+PGz3D!@-Kbc%N=ZIwWu1VW<4Nsg#2?M)q4wY(TVvp;^gw zL6=Jbkb(XXTWRjUTEMF6%z9JpCE7~vBM*`JAjM2}*(^! zp!tq&k=zFQk=4F)7qWVQg`qUqzL7t+Sq0%d8+10iB-K1c} z)NUEI{|%cPygQDr5j>$SwKqTGEsA7$!q~42Q9DEg#r!;sCjX+xLWA7iu2P_?kB8X! z8KE`9QA%u_Jq`rN2*2Fiz@kK0M8XOhMo#eE!M=0}aQ5_+7xLTzDZ#=ffQ|6|z)~FV zoanP*U3;*PtO_k{Z|{1ZU7`Sm)7T8FPWEo=?q4U~FeC+!F)b>v`War~VQ>x5mmGwJ z^E;5h(t`I(AsxHy9funD6V)xv%~KmK&|PP#uMcmE#f*pEHO(hDSi3cHpr*Q-Y@W+f z30`b%V|`I^ameBfh{xv@4n}eJeE=*!8Gupo`j)Q-YFq_7ORZ}XZL@5qPwgNL$E%(D zGxftMOsN#TNYO3}R^@p1SC}lZCIIkw`qZgMUSrG&*Xrj|tdgg7LB7Nzg4Xe8VtV=j z#HGLj5xj8Av=h+~u!M+19+=&?L8I&5b#L=Qsj*7Bmo@DO)?6xko;YFWI*#Eb>#=u< z?S-T5UTBF|&;nBGqNjSRkAa4RofbTGzw}~jX}2g=W18&qLrvWH62F;@m$`YWDxEs- z^kICQldKO#7SN>AFuFpIB+ov(&k0F8z}P1%HE*O6q*+kE>zG`U^<=AEco*2(>~@)$I&iyHQ?H>TxKeWa~0C? zb&r2uAu)O}RmM^;B4#T=h#4B%m7%tD<&+1H2^DXZJ5*Tp;?fMc8Ls#4A9*BAI6W{X5xf30`KJb%HkA&{7tiSGJ~^PX z6fv`i@0~!ztmNPe3jgoPbqq~crY(h80sIl(VqV~JZc%eb!DWKjr=ED@BeeH zTsqCQUG1>hHzFAk0HC^ScRuJE)d-#-!Ey|a<}3H zepaL6TxN(L+b*&ffu9{f(+5R*^zr*djPO-78c+g8u#<&DZT%$NUZ=p|18f2?k5wR- zP;H^Z#kWNLjBY}Hz%tW4Kh4Da6)EF`4suMy&oR+tt}L9KY-g$MUHov~lnq7kWk(0$ zhzJ$1*ZI3mIk>t2y=vc4E1vKh!Vj!OV3s$?buZ z{P0QchKoz^(+WKoPi)VU#>?BIVaE-yKFMC`VaA=lp;`;=5{(Ft&{6_WCel^zLC=?TNZT@KA zfwZQWo4;hUL_oJbm~`dJJ-n<%F((PHzRp#H8`2(eRR7@A^S-48G@AgYf;Vt;>yeO| zD6noFco}I}$+p}za*I*Spk?#9B_~xCGSaR7(uoJR{$0m+P(~6!}GLfn+pC};6K*ySFaS0+g zf?o|Ca@4c2?YaLXe^h%hUBrk2L8G3_8JF!Q1{Ka)cY6zXHk65^2^%c*j=dsszjND({xh`TNNApP@elpz}qlcB{nfgrB_w!tF;?*}3cxgP=(08Hl|=&l)2i>@as znwgeNn$)3Hw1!w+^BXmuSY9~2EV1H$o5)O_MqCn1$~SD@{2jiUE-nvF_TDAjWCI!| zr^r_|lG^p!y$F{*tX`)@D$c2RJt~1!H2Hdf=^YSFbaXL9lA_G31M9(Cj6XOVi2XAF0`Tau?();ZQUHvS%1T1Yi7!C>rg&(JLkTm< zIL8{w+)7V$z7pO_n`>^~Tp3S0Z8iH2Vi+r8s-#CJVDTHemzzb@pyYXuKoHjp&oMQQ$TdeYs1jyt=2Nr8jw9yNfl) z&Mxo9`E!d!${-iF&j234GLKL<0n#Ou=@_XN7tSV9)&X_uy+bh2S>)y1GpDDg0X@Ry zjq58gauG&)_{Z9_wv(`+x=~e?axl|6Gd^#qtLwtZv>bmNasAvoY+(;a48}>IKU?Yp zPKtH4Oo17PPGAI$Wt^(gokOY5x!5n4mA_k!J>*{ARrh{{iGx=tzB4IKhDiA*P0 z?lXLZKh*&bo8qx8q}sY{orNrI$(H2*wm$zY(aldo+klsa7^D5h#)y$aa0-KRml98o zTk;L1;_E(-&ieSw!QII8@L_D03rzRG4KO-8z59g&6Da1u88DCnmBZ>3S{%Gv4+n<| zI42!R5na5*yAkxbmLroY+n6#|_!g`0>oRi!jTq2mt{gp((37sLPy>(;3#;l;A3YZtmFN)ORH*aY5ii zQF;E>Uvk^kZlmWF$v@2=fC~q!8fcFrq95R@;GH*urDUAE$UJK84kaZ);CUkMpn34y zd8tf$B@;=$XY2ocMsP`a$8W!62J@i+6mB2p%52umUL9dL zB?5@hQjE$MTq$70%+H68gvwPAS^@?X1py zN=-o%r~^m9Lw83HC?%Mb==tF_IZOh*Ff1YA<&h5~ znxOVz&Z*v(v5}9j+P-vTcg;QlUAXg(HD8l>hz=iT3?vn7Cc29(&$`64bw+enbCYM=RJKVH zoAss+$JUYp)4%gc%BI(b$rE#B+4P>Yly={s^XDN3dJDA^YLGSL8P6{Ai+BFUJW&0| zWYt=#5TFXhM3`dBiL`_&1(+hZ#<{v=HJYAZ%)$bc1&r&gozh8ZE=z!I0joHqD5!ex zYKiYZ^QdLYQ>6Nb)b4H%)!g0vOOPJ6$7%`$k}@a259hnbOhZRGzA7DPqBV*@Al5Pv zFa@1ZDNx!OeWQ))R{L2 z-_U;mPNawXDlkyk1MAf@yUe^i;&KErxLAigCjFju>7ICZHs@bQL*JF{GT>x2b#*K% zpq2tPllI$k^Um8@JLolGoU6Ux=zc)Kz)}M$IU;Ca_M`EU+=~S1p{WUc4PaI~w6q?A zxD3iyrP`BW^sLxpT;^ATbBhFGGjUVO%63A>)R?C31D^XmWDdnD8n0nz7jtf2ziB%J zHV>d3_&7C{o|d*(guJB=-s`A+dUoy2_~RgE!LxzXa1;z1wziY7ndxc(X=Hj4kGrc2 zz48<*WdG309Kpo*xov+-F{P~&<{8sjbjt*f_~)S#p?$P; zzgLZ7zjXAvhfl`Q)A`PUDThAlFGf+heNt#lvx_Vn-zP|nUO=B}s~#n04u|L!Gz%wZ zUF>%J6-qFDL1%KIY!mO^hi!SnzDu8arDb?Ta81@e5wZ=xzLKFVn@x$zWe;)~ zBE#YxcqawsLT(W!=R0cJUkB0&RCQ+rPC?|L;FN6!A=2wpdGaJesoyb9_zNK(+CuR0lddk zh2#FZJoitMjBjixdWCNt9R4^b$a}qMYm9eSuMoJy;|YLteO(!d1%u@DH6!=;bux#$ zN~x(;gFlB0anQL*c- z8TDY^b?e5ZZ)`2l!~N_Bbi7{&m2Fuiw9jzkP)kSx-uJ}v#D@x<;sfe+CyiXs$ox$y zKC=9F^?xxge)Eci9{*c_l2T4y_s{+(@t*){dY7^oR#n$4aR$VOvFYS(z7*u;FT~_wVe(T60W* zpWi5Zf5w-S^4?&F1l|^9iC1Z1@#ctd-T?(4dQ`Y?LVyp-+=@?F`0)MI2^J^k!-Yan zmuV8KI{Wv-iqtxvcu#&MYCP%p*tJ)J_T0*j8TRrypQQ)t$n)TL=_M}VYvd`i}sFaG5O ze#806y${M>`s?KhZD*(~m>4R|PygWHzo_Vn07!az5Ub0@ zYvpPCx=iJ@90UEG12Y|B?h{&ndRp>-^m>UGj+xwg|1Pm->*HnV_5T&gKsPp6i|BXd z@*`lFniZPEOcbVMYbUq)IA?S*)!w+lAosoxdV!-w77AYP5zO9-u8*L2K@|rOSySRN z-Ex8}sddyGDh>An!vVx|(krmJ>JG=K$(jW{nySup$Kx?{w*v=1s!lXDx9kj%5 zy}}XI-Fus`;b?1fg%v4q4!{r~fABdXbnon;F1fAS13;8Mm%?C7f}aiRIiJ)KFk8UU zZ#X-B{85lU79OIXE<&Iay`}A{!ZSP{OdB>?4}aBNXu(9uwWDA^_6wohCz|LACb&(M z;pgBwp1p!rIb#gPUBxbQ#J=*n&OtAtpkgd0r>Jbbt+rQ#ROyoxVVMwe#K8KdG3~*36lTn)vMFU9`4hh8}_WE!43KA z%==IVCZw~#Y&eb0`3B3&83(4Zz^5Pm|1R!a4!yDIrhkL*KMQPaDTAVW_c)8sb5M<9 zEUDHhZvI|g3R6lEuji`p8>1ZIKJeRuaY!TJF&!)pb;xLtaKwRsez;EU*I8#18|L6XrN5SB8+=(>v^*rCfN zNaZd5Q(=Yb5%+H2X7&2^wj{C4OLGdb9zgpqK!oEVc|JE+FHl$M*8)B@Y&Gz467R>tA`NstZ*Mx_ zT5qUPhO8b1?fis$xa+Prbl2xU+;OAimzQ%NRfYRhC@&^pSS6zH?A;6f*o}!6a9i+U zjsYD{c6W818W}l=>*F7SM+int3{#6k_5Mm7J1SRRdUKSN!AzsG;}uSF#plUcyFPs? zhFb-i`ue$+@s*3%BcjX1CB%I^iLvyrB9p)kfGSU7(>A@V$~!L~mIsriiV9{L_TL%S zd97#*92TM4PcCSqe1fm6#U>GFMv8>SS<-mt)=w6@vwQZMbV!;m>$9!tn{>4J6V9=s{NUxz$OJ6fE1MlV9(tYRImKu$)$SqJ-}g*TAr7=l4U~_Dd6rI zo#ncUk^WTcdM8WazaGcUBSJD$|NcFV17pzrz3%UuiI6{wQ)6<=OS@W^d%Y$ezdQYB zZrA71wN}A_eq#^zyw(|gHx{z|YofJd`Pb(<=w94@Y5(sd_4nHx&J-lvDh2wi5FEhj zY4*nt=#n}i`39H`)84O}(sCIBN7_j9FTC z`mRYWfBvm1C)2k_Qi-R|;iv)Ek%PMoZmy2X$_>kv+FctJy3)X)Y{L~15h-d^Xw1Vc zTUP%Jv)?0=wAG~Th@}0J(66L(@03arAzxF|R-5z3^1HfQ&iS7MOOEEji|2jK%)tA^ zyW&%i4*-`ZT$#Ze9Y2=#Vxd20W_B&1-U07pZ=+97Um*>?dQ}PVMe2HLYD?1E!i)GM zaj~s(+zJYlU>1uqx*dch2R!rq0+0l#fd%HN`H->l#{K4Q*B9avGPfUrJy$umK18C$hT z9Xe~Rp`sED7ou52p{VibR;ZfGvP7*gKZ(*?G*R(VyXTLrHbikAXDN(tNP&Xikqq4Z z>{--tUaJjU5C3A}!>}~^G}4jAei8H7M+`lbrVG-w=TY?CRfCNC7y@(%APibvQIq*!f&m;Lzs24-c<;X!8w!x$q`) z?aYJ zvrs(d^ruhl&=7+}=2r zEP5Xl{>-0b)ZqW;AsUuUg!16A;PU{Cus39_SWIjz_Pf#cMy^gPlo={<{&I5O;r4fJ z4n*Gu+A3ttBkL=p5-|<*H82fAd*MX|);HBx4Cu=gWBQbE#0pWWk&mc|$iYFgDcj z54~aVw!MqZH`QYCJBiYEtx9w7+j^3*>*+R+bo~Ig;@NLhF}{@RM+@di${f-GzrMxK zz?(XiB;eX7lc^gEC@QTMyM2h?U`S^#dHXeh|gG4uSg zmzq1{{_EGSwWb7sT;_t$bm~@4@Q*f0KmtwYF09zxcC(53Nr^rOw7SX1d57dJcCqj4 zjEpC>&L8*ND83wbVS7Y25!Z%qY;l(TWF1_he~OjNdlK0327ZS4!Gjgo^)0twJSHQp zEmDsxL9U=v^X20k9t8e6b>!m17=E;0Z!iXeVc7PeiezOj&OmpYV0fseDLM7w^jPk_ zYmYC!m%K`k&+0uI`P+tH?Z@DjTY{>6b3c~^HyVFm^Y!nydnVuG-It!GNvs|Edpqyt z_RYOt{NB#LyQCAc**tY2$op?YbJNBBdW|BpJ5Dc6<|WLnUOv%P*tmFU?m!Wgc>n)j zQzuICN&pKXp+FKrq$r$#3L#5^-2t{eBIlqRMXNA$&rTob5SJ?&T%#+$*p5!3V}aso z#j1KC0RgKcM^Lm(v~&4V{P9$=?_#Pw2rCE740+(4i{i9_Y$?ShO4trNB6$n`Z}ht; zI$*A$SHbcVXGQs?Y6Ok2Y~Xr~SrZ2Ou$m9|=H1B5%nZ&AYBzue=JS4CS`C(!6loG@ z-0={94L<_HElOvjD#ck1T=vr-rvJ$wmdh=UslDASnzf;=fR}AM;yBH}Sr{~fe zn5@?7DvfSw+Q>*Lo{w^U6t;08S&96anQ~9oAY;U$!8m3*nVOWG)b&2iMSAqa%(l?` zJZWhcrh{TbBt6fZX~?%L0S`P??nHJ{Qh2W>=!ZY`apS^L)HxXHp+QzkxpSg*=ILXe zY8o2AaMO>!;o#sP1YsidnO3>zcak|lxf~${EBC;RcAM)!x%f60&IgOLOsb*x&(M8Q zB~U`XfAWS`^Q%x3!fy3wjqp|7i5ZUfJx_*m&ukC9->X20{?_j z@##r`vtuue4;&zN0xM{7#m-t*q(FTcwM-3rG)|Fn#-kue)Aij*lc|wB=A_5FH<8{CR3*+1OB|Nw=BIgwjAgCeZa*{$9t?G zXo*GVFnSYNIURM+=_^YtYo>GnX8iwu{np9F(ZxPvKM7fNN3G#4Yi(nL6izh8U{@WG zTN9N^G%*z>RX@E=N02H!06#wLV zUoqC8SWy5l3$bKXf#xg(W6TPgcR7(mEK`(99H`OxKYw2L^{FZ=%U|cW5g&J2LC2`( z*~>Ty#G6ZZvsOT|s(>c@G-z6rO6t-74_n_Ik9FVveUcfOC0n*aW`$&DQ>o1Cby`Wt zC?g|;6xj(WEkag96f&|-DnwE$qbNcl<9VOg{k(p!>;65@`PcQjuj@|E@8^4bj^lm2 z#|4r3Elf=OQYZFIQkXDY`u5F}OZol;h0nY#*_WC7==Pn)*QyCQ30zv8g65alQcJ9G z-d+qG5x-FUDI;P&Qp`#0XwBN*NU`hvV%|FOiXBJWKD|h=+>au{NFmHE(an7GD3ymy z#a%jvbs6aO)3dYR-A8#G_T5CR|J8R^%Uz+%Gh0_~fvPguHb%~AM2>7Ncq0K2tH*(Y zckE}PYrVB7iR%+-dAn5dK(q2mdDvlWs=;*=Ha3kC7oy^cup^{WLnxwG&^zVz2P& zXdflfO8RzC0i9{Y3}NA7ywqxjp7(QKuJG6USPXiyFU#GSZ_GQ;)U%jv=Jn&a`&4M) z$MWy}Ots#$AI?k$wYGn`ZZx2tLj1En$-%5@qposfWo%A(?OuaX9FxG*;N#Xq;VZ)r zMnXZ|OvuIwy3Vn6y(L%r^61?}zpuUbFsH6X5DIEJIGnTEcTTM^hu@S{hXB}jwBoE^ zyXl(ye_haqh8ud#bi@!kN8D#f{bc3g$%SSO+5>SS@%CZB9WEr==7v9dIoCP{25_-$ z{VEzs_9~)arRb7>1b4bj8g49yxIxmv9>v7i7#-l$#Kdh{a;gH{-3>ktHbg{R&(DCI z8%mYMZ^!w^FQ{PCRYg$QvE#WNZ2^9^gTszj3K`2Ny_1Y`KXA#@=lM`a)@+ltrksTK z;@I)y2A3E|9{XbxNQ}R>ojzc2Xeh_;^(bwDoDu9M%c;n5hPW_Uov(=o6;IX(`YD_> z{UOCpMUqc@Z`ER$R+_f=w0yh4PPM*YuI+iZyz61&NnP2}7>FsMyX2We^BsXOw}mH< zXCu+T&L?m@tE*eu$LK+~TdvBupc^a@Ck5+@CRGrPBBGCuu-P3_Vp zK>}Ja$?*$+OAXS*0y0~^v9vPx^Jy*RP)@$R^4+4xvcYiG zyt}Q@_n?k>NzhPyH$&dA)Sx48NK3#_Y<-%HRZYYcEeg&+G>{#%IcI*DWU2rCF#G<)rJ5OYeVcY zBKOM4X$s*B{YSYF0WKB3V>m+Z0{J(3Tr+ARKyAnREp^*HfENi}<;06~-NYM!>TwE^ z?6Ec!8d`+;DwU!lB)b6f(HCOUVAFsDcM7Lm)M2tOl1@0Z9giRh4hsv5CIQLhkh0v7 zAWIfg^4W30^;Edv$OIb1_|+dDo;|harRS6;RAK*@uJrdLSok$%1mc2K;*Pl=fM9Qc z__|l<4wo;h#(rgGYy@R*)T;hwDRT%PyvU)EM#HAj@tJC>=DbavmcLKS9(K8oD!Ztv z9M;!Y8bw45Cn!t|-b*PL$K=+icrl56k^HT~z~sXu<_>^sG8Z*EGjjl3Ls=>?8L&>N zoA2IFK6~f|fa2=kx{^@cRIhbjO^b>&>hVI5YtDgH(L~>n;8T=H=@w->#$tK;@+s;U zS0VN+kUl_=juWGWyfrH|HEJY&#t*YCHrlLPj0n=1>tQBTigqHAZW42&6eQJ{!`7z` zM?{mj1=;^{jc7QYwMAd7Nb7aqN|=eF7Tw2S{v>n#PX532y;rm^Xnp?vJkEe{06tJ+ zCONos^WLwDMh=)fOeaMSkT$8fj;pMu3MkZ@QAKs{&i|d=%K1yA1#d+}AzSHZU-5YYZH_X0> zPO&tjAnv3tfX~stKI`fvnee$pbnDRV!Kc~E+WPloZxj6V_Us9SHU$_oISHF(0T1r? z=3bJOAwvNK({u$_{Lyq^WX9#0ujHq7+MO(a11WG2ZC-Hj5;X2G;>DQxgcUo9>FLfa zEBXRji0|6F(b^%VDICWXts4-3FABvF$-KNH(MedqiT!#*?L$cCJGc`*+|H^PlWv@XUNi`3CDv2C&RNgnq&JlbSrz{_0xm63EKiW;WfR!XcH!{R`3sp2PF3Kbbm{B^KD^TZWScG{N@qkU>Ds|tZWue$y;B|^rEN-#O&=cvsQU<`wk#YvA;7jzrsBy;Gy2fbZwuMBPyb|O3Z$>DfGIm6bK*qJxj+Zf zLiQ1VL!&}DxcB7QKO#<5JukocvZGhDZs}7T^XAPL8ynp( z#OR)UHIh^+X>G5f0{|R5oUCYyz znP-%(9V4;XvPrvkVe|Ig*575Vy5ONzf3U^c$6|cU@bxvXv<6%=#7_?GL z?~-G$G$Bc`Dm-A*Xvis|?%MkJUf%9gS&?r?MgQT`k`h2Af0Lb)^NoTiQuTwyg=F@nyoTGJ^VVPQJ9TreZXg^27sdYY$Gvf@8N!EhBo2 zr4g%G1_bBXR&MOvX}yv(y0>Y0&jGi*A6$MlL8MrRS%096x5>ekp8yd19y6Yn$3BAxXXLaE@rb z6s|v&_N$);8rIl79ojcIG{{~Flf9oaHhCY}War&iGUFTm=eGK4#q!PebE0A{O0VkI#GvuB5h}_I60R;F33bZoUi8Q?4q1gxJePjByqKYvm#U4l(GHg08Qz97(JA>6BQh!s}RnH(BMtQtik zb}30onCA;R=D~_UoelzM3bX;1W5|C(V*`>OuwHOS{sM3ZodnAw6yTe-GTe|GW8p}4 zM@rst9Ty;vf?E>2(l|7H2g?iV>(>D={%KB#x+AWpcKv4hbxtr)5dy=_ZOCxxPr#*4 z@~Vn0j%A3RnW#81Gn0IQbKeMZSfnE}7`eL~O*vgVIX!hXJ_i~(ekDg%UvHLZN-H|} zNbw>od&en{tF72TzmGSZ`+>h!99Db9Om^@U~(a$YFMYiTl_M8>w$1D|p-GA{h2WQen&_3IWiN8Hi2wbsn2?y8d`);T-bHQ)n$ zanTr(S8!*VyR5Hh&i4qyiX2`*VEnwOY2NNABc(LEYh&i8ZgPnVP|1x$n4G%^5+txW|_ z1NQiF?Hxa4GQ49gPJOS;t`F-24eQ5kejO(#SFL>#ejh%UA8~cT>Zdrx!b-_CQ(L>5 zU+m}8MR)Rl{uc5{Yi7V+osn^K#Ny)5zn=mR$&m9;pRok*bM%U|?BB;Riih#6RqkUr%^&MW#oDbY%GajCnN8{u=KQ56!VLX7zKk zph5vA10^*$GCgcQgKw{kua!Y<7qI>F|mt)h`)hD=CFyMI5ergw60@60hQCmw+L zb2=d4%_cGlE`4D+%<+ZhKKF#s-fIhyy3C*`Of^UeU!gB>os~aOz~yPkOuS)+r34tS z0QFM~tBK^e-Yk{6YA}wPn{`B7$`x`mN|X)ti?d;jT7)AbFPJcoj(v!7NIpw)nj^p) z48loAGqXOYJdSV8w~d=yTZ>kqutTXu+O6*y7zCgR%W`jY5^p3}-EWq#K2Fq??XH z$6>~I<1Z3WIlhoAvlspQkhZkw-F!>`2AMnqYawpfzFS<#X5!UY(zi5!-#Duh@2=!S&3{V<%U6c{EP1I{C%I7;4iCn3u{T4@U5O zS^Z_~@pb#L<9vrq4fcI^UUa5FI?KR`5!Jsr%qk(@s`hSRX9ra9^UK=xH`WXV zN0#^dY}xzuWIsoX0}uBPCFK;YeC&H;Qzsp9zg)an+aV8MPZhs0#RnUUIk0&6*Qc-H z1ZV&cYikj`1Ja7Td=BV~o}Rl*^8ZY~gT3|Gc%~Rh=*x0}QcQVCNs?X9qYLzqcEP_2 zny!@XIdaarXsZq$dH@z+RUsy&%3)&<}MP5(fDp^=uOy+1^kfZz$zCxr3fJuf= z2$#mi9Jue!-lHZPJL$AzE`+oSCGjaj!VvrodJnzl6bDEukm-XYquKZ<+PBd58Qmmm z3j86`cFtcMZ@W5|fmJ;k!scc+DuowSRHVyKStu08>p*otU&e!ZJcU=M3urs8GIVJG zbMKZ=q$pWRdu3$he$0JIqSf_8OmIh=RiCjzhNxeL%kqAIk;vkut!pP9y0k-9fD0#f z+aXphNODV7?H?~FPYSqr?E2N z7`v>k_y&2>l*IQ!M;lMp#E;~rr^ot!>C9FbT!!D^P3EKw&DXI-pb`nZ#2L%Gb`5ry zu`*g-FJ7EHMg4V~{dY_fbN#Sjm|Rb?87i5#=a*$a8;r*?Si97pqv)aa-E-)YQO)iH z1@`+1dHcmfVn^@&yxBuV(%Zse!LwV*QSr~!_D=tCh4s@*@8??&EqE=zNF}TcfX6Y> za4wp(S4o8OsaDxd{>b`>4O^S1h3Dj)ZTl^drhQ@(f1!DHjw_l7Hy?Tb47O%*Fq-;U8y)dI**J@vyD#c98nL8Ec-QWxsJb*49z+!Yhbqv(Q1$*y zsBdt|+!!vSBnk)!fcZ^13F&UY%+TB3-YbL^d}Z2+lghf!+`71Hq8@Z}Abz{LvNDa8 zG^FJEiFK_n+uF>TlDM+fnTS8(SgaF9au`LxHPX7q8<57(z2o;m?+|XfW3{b!uL5B5 zzXeKDX(YPG1&>om|FOtx5i3QDtSW0mMWJ(TAz$B*{G72%!w>T)5Uh0t1?qPe#=i?1(H_!~ z{oj>6Thz+XX0^t8K^2123FE%j!$gC8jE}JwI6;FO0WtVZr-KiV?UI6fbn)ayt_`f)A+r&UfIjb6Zv|r%|ewP^JgT@#Uf^3#Jv{2;Wu1z@b6d2 z{>dTtb{P(l-OHZ{D_HF7Nfw9E9OJv+A0ZYn_QeA;5_V6ItuwPr?M)|tjGX<=)N~;w zKyL-Y_iPT%^$z=I9{oYjhu#F@{PxR~{?DlX&p#~uL_+Il^1`vG2so!ljw-y7DJQWs zhaX=YXDBL(P7hk8I7m3mP`=H~9)c8w^9o0OXe%H`z6wcp3AjIZ?2d;kRS%e&Bxg1Y&=?^fcoXJH_At|Wbe2ZUo5 zO#9guXVb+gY zqWh|n!=lu>+AMyOYXG*EmraDvpQF)HXs$;)pA^|2s_|NzE3tdM+;+jSGfNI_zIbB> zhd|Ojv6PlTZ1TbX%@XK*3|A(c<6XW(RXfdDo>IT=D17IoT5wB0Lp0J&L-E1j>e6o6 zvo!#HF;nrsX49zLNc}c6MNqVJ>52~g^cI}IfUBT~w?1)DFPP72A@AVn-+gBi)R~wP zaFQOYekZp(xs*VH>Sd{Z$#pJ8B~WXrndrC4_R*ye(y;>i2GpUM9jI;;*#5NcjCt3MYS-tPy{{P5EQ{mpHK86XdEMv2b`}OFCb`2*%EGG?Wnf=XzMnfxn;n-*(-9@Z(zT_nZT9xQf5?vk`gfCBIZs#V9+_W0rCYgrX zsV+VHH8JnWLfcUJk%4ui!il>c->H7CYl2^#qHb{FQFCKo@$Wv@HR!T?@>-8dN1hxg ziYfM+tsD)zH%*CHRN5>b2=HZe1D%wXts0Kt{v9@Uh^AFjowFZ1MLhv z^2K-TD8N&tB7vz52zM0FKY7ZgOV7wi)f5(&k?{o)9L)``1Ej)2ANH!P?fG|oXcLa1 zlgMXDfv=%B%-3>BatFg9@hAaxBo-l1cz6iQbke{Sfvei*<>qx zyo?ZlK;V&ZqDbe&JY4kPB2P2rlnqx*I4@z_ZTd7C&yZ}2hIRQr@no&KoLfFaaxFqh zRE#muD1Q3%FGlL|p8P|Ny{qBdXK7FC%@B$0+(8q#DRT4_=YWFDLIXjlpNVA7hr4{G}T9~-SX}768lFc z4nPOrP50~gXXRsfse5`XUL;3BxJ-VCTN3@}g%>x#44mfB)uvbCtDnw2yif&CDDqEDd4sI@b{$yF)Ahu7?E_&(RL>+J^~ zk~VolhH^-Ef>-FSA23HBAL;s79u?cCXSU?Ob zRhCEHS`#8^w?1ahadEUiv*9>(#r-o{P=R28t>hx&;PG~XL*fZ=;tmDgTzd)4~PHF5im1bv5>?v1lSA8A^d=`DU(*(>-*uv;lt&a z{4iF4F$596n~RHxh)BU84iA(DJpBA*KYrC)+5yP_Kog6F9Cj$?rALn+e~UZD@0RUz z^sBg*gD_FUn0*@W5m>zo-}da?`+ITGHE9-WthTAytNf(sJ**@sl3{&{_6g(wbZdy! z(6^mRD6IatNnNkjq+m+NcU*Poqri#4uL#~r z{pqi-Fzh;RLs0RlbkNh44J}oTCV3Zq?3u6?s(!zGoFJWDX8!ALG@Y*4k#yCqDWnza zWV1bRbuk*C_fWM(wpIoW4-Na`ZS}Rg01-IlVKyJx(()QR=*BQCKm@xUA^?S}mFX>jXLhJQVJZ74TRAx&R zV6b|6_2OJ^Z5{E$MWGi(K{7q7)6pq*EahrmTNmDa`+j1+%wL+jrzChz-GLNJ;8wnE znm_e!cuYO~_x{z!#-f{CRs50bU{~?w>E7t}OJ)i5ID;cTR(RYFCMIt;!nECwLG zMuXHhGI9VGBw*7bHs{OESjA{q)!3uq$E!eA#(q1tvza(aHaUa-3(5j~`O4r>V0wd$ zs9-Vj_xyZfFM+tC^DJ7PsA6CqQjr)uh+crWz=w^ABxc4~@Ek6oCb9h#I?As#h`++oqpwlhs(gm~J3ASxS?}UtpKDJQ zZEn8#)?Dj>7RMN!TGD;6*|0T!J~&mU>HHNkjn&mvw09*;tiSP=i3GTn4RSGU?1#T) zT1!{z&JIOiIa|gnQ`0KMy^$ZIMROU+RjG_9nZ-{;ZS z{QP+&2d{hqr-zivuv2Tf1b*DhX^-B$B3JfpdO%++=ZuS&Q{G%)|3$(Rv;}vvN!g5< z9y=Lbuw+c~Pk|U&Mp}lw~ zWI-U;B-ORQjJANw58uRepMztWCY86Ssq6H}Q=n4)@?LJ2IOQl46VIc01mgbjDU_)? z&|L-!Vo}YJKa7_5%+C*{$&ncqZ)={UaoQgxJo8^STRqche_{0ZQf9+5NqM!uhx;a4 zxmUc`1M8QYqSliq*5{NaEhrYy=T-Wj9uAzm(1}&W%%YXDefaX*L<@rAX$~2y-iLwW zS|6?ywLCB|ZSswO9Y5MI*Vn8~Ir(RFW5=%0la(AZxwX@>!l(ORM7vILSuLdKj<=XB zZ^%aKGOfG6|KP}ZI(%h*l!xn2wn9+&_{#Lh%UqM{(IpW(A}@UV&U3EV`1^;Zl7Inz zpLMJv!3`V0a2!g=SvzE1cj7FQU>|yrDK9nB&CKPqKcA%pb-dao>m0G%;r_4_#7;F= zPlq^DU3tC#YJ?2Hcw|;v`iRCFH0!**J~@vchhU&UUv2OQJPe2qXQrnw0JP=hg;T*8 z*|d3LVmqW5-*tkRP9Qvr9RGB7648P3#34To@SC)8!|cJkAaVh206kzSf}m=0O^<-Q zK^%M8vAvW;c+VpKj#cAz)c*~c0;+lkR(Fz;D4!5)Q&CgDWB9WP?G(S3J~PpWY5{MW zvtk^JA>n|2mUM7vXzK6OS+-wVZ7*Wlu31F|#a*~CL?^&}`U_f!j~CSddpbWM!#+%q z73D}-hH5Zx<>2MydneiQ7BCn5c%81J8YZ;6^U8gY#s;#pQ%5^>zfrT)*&73g47L1q zHJE$z1oY#lB}6Ey_U0=`&}wLB-G@C5R(?KjB+&ot-+vZ*Ix8)nn9G(8;bE{MgSnPU z^m!vf@>?#EYi2}8O+u;9RvrR-*7fVV{q~k!jp;RZ_<-Hpc2-tLPfwiwqn+Y81p`zG z(lcWE=O4cyvHTv!?%jM!NBlcT$B4hKij{LRa^3)y*TG}u&(9Q<-VOXxy~bS1n_@*3 zTcVDzNDNO+SC$6${$ROyWj=Lzh|Y+Z5wT69gN~R{@wbLyvw|`&OtXKCjmd{D5RJF1 zIi73dWUc8UH$oI+{!M=XWrt6D0>yjk`McSAg1wQrFu>u`@#IfuqRpARSBO!`S%2R6s>mZ_a@TwL7Zb#x$b$}?(xdU!*A z;b}$1-1GBIxRKsE@U%V@-X;;fVJu}|L9_OUna;KBUz8H^KdwtRZupelyO)DxagfuI z>VE$G3-lAP$bv5q1j*&F$ij>WI#q=R@qZXgLSe<4v@v=RGNaumFDNinOmRHJq8oib zpVBD}A&)2i*I+~euE~G4cGd(Fo$p`-YsKBh`>nf=1`HH{h`Ji?E-p|7{DaG4C_smR zBDNq@P|d-MKkDTvEZ-m4JsW}xb1i^hbTsiqjQqV9ufrie;A+b;6~l?3^YuVk3+bb5 zRl6KRz27GJ&Fdl4%|ushd%-rn2RlAD_P5Re(NKI*_n zN?Gpg?#7zj`KcWDkIpKWE_wHi@;jHdiU~d=b6U=yV4fhmpnS(2R0jO&y@pl$w5^R=-%c`TP&aod6$|kTp z!dEioH)AZQYo|b!I|Y^jZc`^3*?fow_1G=RiEs3;+kIwYT~x5oIVc=bA|yJaRse6? z&f5(Q>c1U9*d|3>AHNL-=3i#V!mgO|SA&A)V^!KwZmIS+W;Gk5mcgxmfW7P0WLfr! zrw?tTJlcyZat7T#eE6_Lbr`sD23~5$_inT>`M4bxHj0(-hgs!lgs$y)~1 zht)ixQ)VMzqpr+0(XuKyt-q=2I;7J!e@N%>sig%81|u)}f+N%GYeCvgLIzdKf8WWh zJNSGK_@YmCi&+;Zti;A2-o10@jF0EeLrSY}eLwIkhn7TWOpW`pynKG0BXfPE0Z9tF3y7O8cAd>4bM@N6+X`;n5&QT2a4) z{?R_X_q|LFwZCCc2L*N^n-xuZ3XeLyLMP>aGxiKOIMCb!zk%N~i$>75Hy!}KA@u!+ z7Vm+V1lHs@a>D_;5ZeZu`rY7-(k+8Y4^OE!scpd2x0m7RizUF(q9G|oH!=7n!h7Dl zxq6ZY`e_(ZLRg9wfUB_tMO7&sml&BCXmIFI103n#WZ}EnLs}``UT$-}mIVA^gWlA^ znj}dGvS9d)hre1VF6TJk_kWQkAtpgy2`MF9X6}>C1WOPLu`UP*&UpTwm`G3&5utiE zBh$@>#feZPKu!&HEuY;WdJP5G{Fvb|c5BCsQ`zn(^Qa=)@hZV@mxBF%FtG^_# zzL=pEICp1{S~wPt)n5C4{bDdLGZ?Y9d`~(xk?UK(JfA%viI_MLo%q-NFi@1j!*vGS9h>zm>Z z)366lnemC4*l7IkR!c?~Ee{6SM#P+fAN`N_0Qn$=3ihz{DjWw0izWQLUL@B z|1!1@w6(Nnn0_-PR!b*$Gsi=E zq(%BS+qe&gq`{Uu_we;WYjV-~ipSoVWk-kVepwye<3_$-(@(G^xpBIrfQr<&DJS9^ zX%mU5aVO7HZk|5){eT?O)!STzn;miyU*R`cpFcdUFmfdBz0u$|jz;xn^NE@l@g5=R zF4+X@2i*I2Y&XpicM`kMPf1i0TGw62JJi7;I%bhxH*RE*Z(kR@KCAgTHgI(M`mAiv zFVV0MB}F|iQ`K@e0`r%PHm&8KuwQh3rgZ)L&5e)gdJ(q=74p_iKmC*{4qH)gcUfni zY6>#6x$x3%=C+;OGrh8mf!EAC$wrC)`YgyC#WsLU_H=dzYpov~dv&3wI>uP@f&+&02-U#3b zp4hZ$6D%kdu-|$Tp`@e~j2MciPno&oUCQa?K%d@Ev4DOX{;?sQ+}{A^h-Zs(XT-4} z`5h;m#khyfv4cfUad{dJjwP{1WqD$h+_e~XF%s97mrvr7z&z1g3y3K$HdY!oD;UAC z7OZ*`O6qsR5F%!+T(DjuBOb)_m}`4uHwp}ffh&-+Y^R$njD5u_c>j<*ddhjwtE4`z6qx z+V5wcym*uPZTtQD(AiJ5vR{pKSEgUi-|ndo-Doe(OSyNW{+-8$NyW>3!+{GSWjKoC zDNNb>G8Q93{oke}M`LI7U!Tws9l`-1k_81jFu37-A!`ai3aTBZnHiNs?mG_*wLNnC z@_7*qO=}+(6$Qawf5`CJ(CXb$RZ|NGxgH)XZgjE_s7NsPLJwTCov@V}{T-YkoS+Xw zS%M?Bw|5jw$48DbxTD78Qrtgh8GnA} zZ$O{!Q|BERFkwX<=;tRG+2ZNcLNmoAI9*iv(ZPN25F(t>{wiG0$-UfWBe@)R87KKo z{?)57n-OrjZ=ZOrYi)LhmLx8ev;dnNb1#FcfYs+TmgID8uD5I&;DfMxnM`c9w$W$l zT!8^#!n$ly&XqS+e+wS#8NTZ9R|CBwd4!FJha77^LZ$_A8?$S4s2LS^#*~(KPs%82 z1T_{io(Z37EmZj7P_NU;(fHs=!>P<-OPWRvyZwYPrql~qu%!PN?RGBNgurDgm(4gX52AhFqW0{7Za z7_1gQKzx%|M_{!q)l_eqa0=4Uc$>5EH3?x5s_Z8&Y)a z^OThKby13|kGQficgV@f#T^VjjpZ`y7m(}_dV`?=))KN{{=#n)1r*1r@H*1?u;2dG z3IbDHObm<0)5nilHQ6-a@yIsB&BOC&vR8QLP7mmkU}T5onN?k|+>}2a8kgc$US6CU zY8sl<;ndESc;}VN^LfzL7Ai2Z?va(9M2>cjL|=1cQ4b8FTb~kR7qDg+!LLaj-6`5bWQ_a0LZhwi>?=hASdNnZpISXIV|?Jqo8F)~MKMel@LL z1`v?mt(%SY^_`;+KMOvQb)S)@+5LKmlJSZgg_|KRd8q>jo;`W8@`#0PkCu3VO31I9 z#=;Hv?rk2XzrPn28K#-eym3Q_ZvKr2E&B@MaQdGyU?isdJG z96#&knNG?*yL0g*&wJl#@ewVeg^zU7P1?Mn(rn(iGw{E!} zKFqT6+@ehYd;}#J#UX!e;Ua5}c8mvhK0*l!I=oU-3Ma`2v~54!h9e>(l3X$J+~HU( zdJM}}bWT@xcu~OZtrl7{{zy{;14qUsGD925VRCNn?v;YS>_w^wPf(-5_iOY)sKA`4 zTM48M<>jX`=qy{dvKBilVX>)AhokxZ`}af(7YBHaeFfF<3VJ<_lFrch>!M!QZ!x^e zU?uhO7@y3GL!7oJ10TX8VYtFP`y`@NJQ+?|MD?usIy;&kdB+%5eb_|G7z+qU#`H5@~ zIvi}jt3Jw-N9+t|@y>L5?^1GC#WP>Fb0PUkVgITP!-K&MRb#fVXx&F1x*9Fm^J{@_ zg(E2))*^-6I#1_MTm~jSBTv#>cOiRf0tS>=QHqK>@)Vf{Tqg`^@oKf*y}YM#zOB`m zJRzV_#2)hImQV+WkAR@B<>f8+P^+AoUIJ06imkD~QCf^@zSGj<+}X((@8r2_(yIaD+R9iYA7$bbYKjFyh0xY41lsOuF{-N{Do2O&gk%P?&`_s zkrYXhi1mUpR!UkJMsd?9MPp-8Rkv@8dnP6%2$D^*E>V%LQa!|$2njTd-*nahlz?0S z+A*5+uXp|Kc-APzky=~b;W;BFF$98bh<3UA`#{CwI`>*L2`r$8BF%OUf? zI6+^D5(;SfLgL9WDyG>2IQ^7;5$wM?lbWY@8`pcyZhz#C8nnMR~5&M8%E(|f< zPoAg*Jguqu4YEYF7W@mIKZ2t|IR_OfVsz7xro$ZiMq|pUy|<{}-;TusE!sx)9!OtK zJ|F71emmhhv|72j$%4|%RV%A*W7*~lg@t9V$#~C{sFJ=z&?o@8=L3N1T4Br~$ z7z(o=#}tb~?AYMw?A%*%5Jn+!Idk+5XW4!H`EOFwHt76s(IFWiZcinsC@Q`IV%6Cx zwQH9r-oK{-dYuM8&gpMoGIpPU^7aHWl`_$2W@Syn1zYCaSqQK5u3txVvFXX_ELCLeC01d*T+d&<+NG*`4$OE2XQ1=s+4TiHk*{C(V1e=`NwGrav4R|wI_IVQ zWaU(JHH|2|yuM@o&&kDA7|zU`f>$09vH>tCRDI=({UH?zSQv0k&>j~go|Cbx9qN*j ziA}A~l<{m6#-JJ9(kiV+Uu!`?8$x211r;k^EX;-9}T83KQ)_LOgXw7864f(}qo0LT$ihwz;?Y$(`&;UPevwE9{a=oseNoyB1$^~kbb{96d_nb@uq{3NfR{;=4Q8w4FO3s4eGy%GY%JHf@NaoZ>MvvnZ!Y00Ks`;*)g? zkr}q40dCbbjZx0viK2n)+S+&h)FX2VQBi7JTLhTk_*U$j_1m(we{iyrid2%kQ5X5} z+z68({-FQiL+3=G8Ht;FCz*1izoPV=f(Q%u>~ZOiHrSuo+;F5lf737V;7$pNM-b_0Yc~O0!7b*?0LE@&9jC=j zo)}04q7~0HVta+!wqs3>u0ZY+A%cTnEry9NWZ*+-WZn-M|h3hYeh4C9eH~=0h zq~V$@YrJ z{rv66k4wHfUUQm!B(AWJf636o`EW)kuZP<%{HP0yU! z8yZ^$az;`DnQLCp;7#ML3Sr`1IwA_oe|>Ik*m?*T#Lj4(*&g7fgl*wCn+ts!0Fc&#Ik5M<_`6)9l5{C;d?Dw?QLI{pgaOMHQzq|lIlY7+_*Tpvae+8J7ifiFpZ4}sxX?ok<3^5rm9l)aypQo^lO{c zVMHGvD8$!Nls37GCQ)?!gk!>$XuY5He|Nvyk=zw2tq4#r%q z^l#A@SBQgIcpVJ%YuA$A?TBp2m@HF{xm<2}=7Twb7+}ZmLHCu;BP0OyZfM0&>MOR) zZgxY&_h4Ysn;KRQftx*yU(E^sO=1MPJe6Mp9wWXuvH}qBTRee;!1zct7#E?EqCd>|(~8IF2}03j{^3@7|8P0n(gTO9B8A>u0pUShy*aF!cPn1BhQZ z=zRvxP_|K3gTuUnCr?L?Y{S0i5;wYgF)kGqd(=Ce`X8O$EE@lGA*_6=!H08>zznOv zqvj4ZDN7fd8cM)xCIpj}q#$xyF*L#@reL0U?g+|=52^W~sMQ&X`IwbdxreaQkQ`Y| zSMXIj@A$%pMoP!HRV(p;)QWbt9AQ1RFktvF?@ytB@d4)E_xhuv7cv|_CPilW6!K(k zF@9PSlK@uo_G$zEFunLBp8Z>LJ)!+4QZk%B*u22DIjzc?LEW|S1f6zAXQxa4k#<`_ z5zhXu$dgQ)ElL7T;bZaYZxrp`S@({1-~8!4vdmcuO(4_>Qf_v zU9c>lt4uiM*0<|BrL2BZ{Wp->Ickgyz*Wcv5BM|%*@PnQD-LT(MM6!(&AW>qBc2C zVP=AS8b2jrgERy1)4)wMQg;oev*$r$<7i4PbhfVg)C08@R@^wdWG1P9eBs-H0fjri z{}QU6KHX0dAmGSvLg3@#N@#x!%hZs`1FZHZjvr5lAA5hv!OqH!-H|OqLh9Dnswa2o z^q1Uf*CwlSYNe!Z#o=n9#wIfS(B#^mQFkpi_nqU~C=@^NeU!_g^tn(~foV78gHr}4 z&59h6(ul-g)wTFlT9J~ovKVgT&8=`|`IoDA8#ud=gO((gnDp5c_p;DbgBm$)AeEL> znQ=JRN$r89$wCB}U6%W$BgM1_Hj%uY@J0;ETGoRZHK%Ze=5;{k`1!a&X|y;UJv}|J z8;_}ihaZHE;=G2F-ooc@SxJ{IDT0;RnZ{Ugg!~d?6t1gNJwQY57>T_?=XP+GBt`1h z`ovzTVvG=r)UE&Dek$12Zn*SDIpfAerK2KYX24<=9pELQ{yich|+pO5(m<|>hAoCC$#Jt^=FTS0e#yPF(|i9E?O z`;n@dK_Y|yrKPltoX>;Jc>L%DrIlc}eG*AAXpV=DE1cpvfTsdZ!svF2?zCgiSOXG_HXX=80KWW@B!8dD1j54P`e_y>U-&yJy7l>^ zash-d0GGX2{qZt^+sIAE>Fhf>k#a%U1>TNQXyS1FzIA*V%pUCX1}pwi%~6p~*YQ5x zdS(Qzdxdey^6@_D`HD-E8_IsCi?Nhl|4Bu<<_?hQYU}##yNVkogqI8dvAj=Eb8ecI zXaqZ|aQ+T&9!g-QE>~MEhv}Yc0>{)4wFNjGxD{BsA4lL2f-YPzP9zjH{mzym6sHr2 zYJ{zCky7pze$t)n6T{}8DN3c3{uiSKBa20|HXV4kP*Q;2hrlPS@c;;OA($ET65ysG zTR-8PBe@+$x$T4Q7ya_|J9G9(!gwC4w^C7?mDVj+w>5R8g)&@8Ds3QBh4bZIK{X-ocZn321ykrrhbha-l znvgS`6e0d`+OhE+#qU>k!SH&nbTce_`6ob@`)INl2-3QQWU-{=WOOKHeA|1=x1Qnq zox&SyxAySmA8HL>BJnwYi+H3O0+9?UC-KDP`s-85EBb53zJ84@8-HRt$?x_VJ}R7V z0L5TNNGaPi+6MI#`u6f_jO<5pt3GN}mvouxXr!qfef09u2=s}NQJD&g9i~^?++IYk z9FR4m4;B*@Ro=fJzr@+RYQ}^HZXPQaR*R}p(2U+ z_?*JJKO;RIohp$+@fr1{&Fm>yym;g=BGa^B%QB8W+MfF*C0{(eQTJg7Oui)cdUHO& zGlfP>dkd%^m{?%3!%R=FIW#iDcL#pMe^+~%;ZxnEy@ zU3^5a0=3|sN^~O8kFnr4OCx!5h3{dt<2Tt40EbYOKci>OI>13j<|`_=b|~t`6Nca& zgoPnqEO1bWM)HRZDTxW!-4pM)M~zDqT50iS?ltG8*VRbdq3!a@nm_r9=ck7py=FB+ z-!eQh-~cHitt4_I?9eGFRHXK~@!U^J*OEJda%T&MJ#?{Xv|*A&5`aMIs3vTBm;|c^ zD2VZw28Yb;(y!e@8%!20HHG5uZRTAk zEKfNsBGpZaO31clI~Y@r`L9j6b0;!L*byzu5Q4XgH!vA*FQ&`oN`D=-DPPd-LYUaj zj0o}a?fTpu7cI)GXG6w>Uv58dL!*$fu|)49m6bhSJ1pF% zmAid^Z0lUl_y443(eubM|8c+X1FP%G16`SMa_O`SxV6YOGO&4>PbRZWCXLH%tj}oN z9F&%p#@z?h92mnWo;6uGn6I9nnhMPNA)YTlh%t++V6cLf`tiq)lbF88#>^}%S_eD| zhv67^{kkb3?~aZztGM`WYI~e`THvf`qs5mY|<2tLUqFiyB&#gvrdphW0gCabLn%FG?!m+uo9x{ z8GLkSZ@?=NJvJt(mTRM$d73^el|I99At=6lb zb141->uxDMn7JQ4%3ed2vF(1+S8#QkFYX`?$|A}6dAH^xXtKTjiRJ`{yTUm54><2U zYjP}dltigC6jf|OPncYIGtK>X7OuB+jT>ewMk<}+mU)1h9e)-ct-F7qV2=mv>Nqb9Z4&j@iXYvn+Ku=fKGbIrijV(MjaMOZTG>rs_Z{LJk5Z?rJ z6h425Eo=bJ`Ss89{L%Bo zd4A6K=lwp8<9!?`OPHeoNA5E*K?>jpq78=IyEF1XHbdXC5eCD-`|NQG?LacQ03Tn| z5MhJ~S9UC5HEA6iI8qmK|Mu-!)GD~EDr6(40UZWv9suflW2iqDEO+FQs?kySd_wWRtkO_#XlISy?!|rt*c6EdV{%p#VAl`QX~ep2>Pmli)rD% z$MAQjHoSbFxsGTPaPPyw0(%KfCCTmGGRAADHObQ%AJgSm9cff5qb+oJR_`_0(v{}F zaE`k%hD`0SKg&4p=*9N}thoU=9%CQuv=+r+`g8l{%^LXrgy}Urfg}s;i_+O41`2-H zWD?&5?sI2(BJ?_*Hq7*#YSxOqyX5M(=kic}U_gPdSqH>b3D=$$DzsZC4P-?>eYR^I zb(PVelF3)2)|71u7uRcKOOR5e$OfH>PHbcRjr0vkUrj{ggoK5!*QxJxK>B&I{F*%8 z6hi*POC83wI@~^<)bs&*tB2T%4(|pHt~MroE}IK+HK|`Wan%BawxV@pZ)&>8!M!fS zN_sWr&?iZ~MM={C8$7sgG1k560~j1CsRjUeb#;y*^`%M8=>>^8`9PsSG++4Oak*jg zy?_=Z(CfERN3v#6)?u6=ojg1t97ePu=r-AyncrYJ4@G!>9ErDJmL($M!2g)PyXT$+ zt7sTw0g^^Hb>PSm*g@$Rr9nK2^mbWwY8l`ThzaSbA|fJC3WTA+%0KxXg;7a*nL2oKGm8v=4+=`R>DpggWS_8s;8$;wZ4BZ%(XRQ zP>6~%)|mnz<`sCFclf_T9Rz9ZgD)*D7^e%K`>u`A*pI70%#m&x6wB=~1W!w?$>;m|enan3yq(d?ZL1Gej zY^pRQ7(>=jc<4%2OvOAnY*fY&&{=ID>0}Lsx^ced_ou?)1Ka|a?`L%U*wTJY;S#v1 z_a<_E!TI4H4I5dMnr&w?G~@mJ{HTUB-J54uRotrr_$E*V>7x%kXsNZa6=z^p-@3Y%8vfZ?O+{M=0RsiFpxy#0 zB@i0N@IR_pW{G6!BZXY!466T+qz=*EO@mlH>V+5Aw{b%j3f74`okLAJSFsB7O;@kjfFNh zE;bevXJVo*5d?;T3pbBk$IVAoRhdHlu0}k}`9-}a_4L-Ti5&5%_>hf7DDcbh7%61q zYzZXWVZnI~IYdX9@!%O9SMN@jxUfIpUt*y{RARh)l~HGPvEMAAfS$_!E}xc?SdBO^ zB;6Mx3mZGl5E$2mwE7oVRY)trdWsy0qA>%vQUxMyS@qLC9T3dS4Tjaq84M6z z^z5M_i|q{k^+R@c2P#?t#~h@c!3>ZPh+WCGUqSMzv;heQZ!T-5u*K5bYth1Gu}xBP zvz_PO&zZA4jOu%v*31@2bzWfYH2~h~A?nfPoLIbcdE*i0eIc9?lN(j%xkYOY1Rw96 z(@b3WWOv|Tlxf@gNZ^SVv>VeFtvq#RoDn2E35rThO^LDQZDwMcUY>4kYaeD$q`nq) zLDmVO;M1n2C^_!Srd0ujYo})I)Hdta2+Q+bhd0M5Ue`=X+Ww91b3Wwm0&P{H#1W*}t*eGlk& z;N{BzJ0)2@YhUKinx93>V(F=xYjfAS+N2F4gwe#==B{FL^3b#V6t#X_oGtXHEDW*1 zad}Ni^OK!2_BEMHAD9`IhwIPoP}BIcUBa1cZxA^t^i$6K6*SUFpp5SrT+|OH0&54Z zb9CX86X)!D!aQ=TWgXtEot0Ibf~ZUaV_RZ&hV~BL(1VYb{xfkhvA$yE=U5s@UBaG1 zJ9G$fTwn=d3;QT^=>(8dlrAV>?d zig}RHQ#In0Mf**;k~ePn^^Z0dB#!J_UFt!~gUa^pPzt$Noq#(UxChm}5E`&TIxQ=* zm?Q-EkaSrdHyOhWB;SyOXY2dQ}r=6qy`F#M4-imb5crswU#tn zQmozYPqVXvKygyeRikji5z6(W({tw@it5qE$hjJxXFtVBDOuRRZsu+^opjt=vHvPS z10+&@mb{WR2{)A8xvE?{p^sh=*THNu1tl9=PrTcf$H901(bHm!2EM=8fCuxd ztu3^XReJXAj+G|&==H)8ov8$er#{DtOKtN zk1_>iY<6<8WTz+trB_`$iL%i?$5*gK64jaY>GUiysSJ-x|5XP4CAoE z6>()T#?3Oo(?fIN$AUHcLtxl8c6P3F*=yRqx>bZ-5#O7Uq)4MuV)l|lKbhL!7RVrC zc(IqOOdAQ%l2`;Mn@Z(lo=YxCc^)E8-(uys7=+O>$Cnmp_f3%0G$79S7Ncy z5&8*TTFvF4pdeSNlf&9~ApZ=`=fy6-O0A7wyP9kY|76H=G(E}NU&9f#< zjD^y7z}*uIlWu{5fxfC7f#4xXd^k8Rk&;KFiB9<*0KjZ-d_dK^t4O2l6EY74~-3Pkwp_OdSLd-IKM9vj|A1TW6W~YSZ35 zEyj8s21krP3h+Jmy~vQYG_aUG7|(tn=5~m!C_-dBe&^IJ@Gk2m(u#kf7fQ88HNJTO}lvHmR$s5=8pe zOd@C$Vi5eaI9gPp$gS()vQh9JokzNM|5{s5B9$6>=a@*G6{a%BYl@0oIU`P~oz~%} zQ4#vYOfGa=+($CmF*#;Le$&_(DewyB=Wr0P#{nu7>lD0Ddh6D1>a!?DO79rl#?}BL zJ38Dl;3XCzp+5MN#|)}jjxDEd23$_d)lq&fkQ^2~FfNd?jA^s?V9@OoLsWrRT_nm@ z3$FtQKLwCjoPVR!d5t`9kC;T_NnmDuANFe&BXtQV0@t?WC#!$H!jD8xhoQt`o$`Il zLb~|-_f-oJ$jcFGaxw7;ifbm*x=1Mznf6kHyN~RPI(4dA<8Nzzq(YAIT5=}0_L?7I zI{4Ym_W?i?SU134(E89JfPyN(DM6yBs*Vg79<;Yl=}Nph$L;Zynaq5JS#WIc^=^qg zk5u8j4sx54Awa5T0@j*rImQd1XR;TIbH<%ZCptppeli1VnsdLPy`p8b*irdfPw$( zPlAoZ;{ouCGz{^el7M55j>2i$Me%J@QFIjsa|<#d^1&hl&MtQK@dYEln1JrF7Y2JcL@(%k#ou0x@Zem;7y)hE zSDf0L5#PYpunDLupsiMf5P<$GB90Ub)Fma!uwO(1v|nH#X3XoAdd@G9bUmEYV*~6XY!aeSj)h61P6P2*?59eT1n3Vj0MDjWJxI|9&67N<^H4j|3Pc zep_Jc`VObD_uK*k8u49GS7J@?IovKQTzX0hOnD*B>Y*wt$bP_@K|0~3;tt;{4GlV< z1IlFd&h2Sw>+b1!>QDy)5kB)b!E%(g_|l9$)%-Ma_pFD`D$I_=yH}t4Rfs%qp{|;L z>H8@+w`cP)2(w#%G=E4;OuTY(S#2yrdUW;YyzA#rKx^WS9!;zYP?>YXaLxd{VU=#k z7p3^M$o;Jm+)S+h57H^xd+8-ylY)XCg2lxu1g;F=42>CJ2e6~XAB%-9uyPK9OZ!8)IEfdWmfqvJX-c2%j16@G!7c@}7f{l!fP~|hSvlHTp z0agKH>I6m>W>C~a7Ue@1>jJX$qsVTTo`E2MG44dNsaIkePlQ#Utp z`Z?62qm8;^N$68GN~723AG-Gms?YWh3>152A!_D>4^DR!H}dfz_w^b2`dQ$r5qme> zThps>Jjd0PROi(%A*7e^g-WQpIL1-YAPnRc!{dTp?$@vPt1IB^%a2qmX=>UAX_ig| zUn^R_Tlv!EH#q?U}Xn$@@k1XoY8 z7iK7BQuP6c?h1e28mLp)_NHob^QSG}Jt}c0L;dvnk$+KI8e0?^ucfZ-?>qChrwLIn zN8RUi{HX3vto#GVziY1=U9$4Id0xI?joQM{5YG>y@R1wuHl43GaVU#V$$>Bhf39Zo zTGt$0Nb0{xW&cEEeygdO0@xMYX=AGY@0%xyv+1gCp=0YGa2BLM zc5na&$vQZA3d}G%*|*@!ukZtEuESsa^9OT>Bz8fyu>*pAs=&a5zm88WdTJg&uf6cQ z0goOjfZ%6G$8akwFE7K|L(34hM`mX7GBTY#J$pwWB*S1s@TmyD0mbp|EI}J?Swy3j zbca!AUX-Q^&UaXI0kd#X&K^@w;vLoL=ASux0ik~`PNfaB5Tf!CtFVXMb;dS^oYmnu zwSPZT8ZF3D_jmp%Xhq-V8y;gyzHV8mxFx5$FO-hM!+mk|R!sfWyNEAyen3u$D+CkI zlV4wUzzjeO`S8LX#diH~a@6~*mlFg$O+Vw}O~cKZ3&;>!kJ zH*QXR`GQxNTH!j&e%iq%qR(Vh_R2yUFK)2L6QMAwL$8^QEMGt~TO-t1>FKc0)-v+z z>l4Da|I^s1*mnEev60#%8zVemt2Ykv5E*P7>q9y(GckpZx_wIIju0&cXcnKWGtPEr4YG*&mllTO_~O6DZ2pm9cF9V&y6 zV{C+j3CGBK{P+{xl(@k>J-6~M;(N=cF`<8p&m1FbMuxJM7Oo3d3D-V~6~F&)-+fVW z5OqM^1DV^r71WI#m_Q!^1+QUR zbRf4()#{G~$4r8tH8~eS((eMLiA&ndYFt0z6r?p(SguZDXz6$Oa9S%;nB9TWIGuwq0%`ljl>JX z^JX3&Jb9am*d!JiMB@&t({mp!>|`dFEPM0v$}wruWz%nJxhGz^ym3=TYrH8}N$Wa8 zIj%d35r*6Xl2ABl%gWxy{s=zWp9kTSFn&!x0=7%zm0RmC*qj-9KnJnaw8 zdYKh3{nbd?6xUm0kI&rcr1XBk0l`o|?@mWcyZPJVn3|B@4Ow-b?KIT?-JJg2c@)aa z%+lalVi6ARo_#RG9Y@IhrAyXURsgfn98uY7z+E9k0>dkueju!YAU(A^u1!@;jChks zk5i%L;pgu+q!#xq3+SyUq{O&8V4hCQ3IhW%a=CeV^Ry3vP+*G_3$eJT5T}`h^09tB zp_p~(<)uneW}x>PHT5{~6uCS}KYtv-^epdtKb|sps45K1=39&@km^}8JV{gKfrKRG- zMY9v+=htA|%kU0ADt0ON?30H~mfIz(QaMriOs}kuR*JMRifbl4)u6s}tL>e*1^SnK zq^hueS}8X;HC=D{)%kTje?I280r5Wj3W;O#LIbjMgRr>|x`>3wL_^F-Xs_Vb^{6}I zlxnZvV$@Fs1~5k18$_e4eW6!^ewsn-U6VsTE@bQgBf#YsfHl;thp;~tJT~uFkbYZ} z$6R^Bkg>aS)jdkNvNq*sHl4P!>ZDP*(rM$OAP={UpdxuOu{f32d-e{U2mRbA)K=(J zE=nFU1H{rCw!%tY) zlYVh-P9dc6(tRK#PyWmvAFj#m{ZMQrmBHof)E>e8e~mUcJ!emQkpww7?n2xK+!?ZS zxPhSGJcw6jZT(Nw-#@)IxQ8sB<^N${KYzyV_zzrr$erBHHU$=BWW>2hO18IBJJQ_q zZ}&G`LEwe3L0wg~h~rOYH=Clh#|~vY8c9Mj1fwE=gMhcdr{c6x6MoE3O;5K&u#N>z zGqdY7^XOhfp;@e}!-|I$b|_(7`%go*7}1u!3KvyvWeQjf2&EPNU_3+-b@k?<*DJ1G z@ISdmB!+U9m7+=qZ&mHUDe6db{OSFqx&uomLGHhL|NiRUInb4k^T#0N$KkQH<(rI+ zeb&*@N69&y^RTAj9*0h4=bBM9sm2_-voqd0eW5P2RG*FM9+5r%NFGZ_Ol&_? zx$9;l;hq-=MP>3<85!nOoVj35&qW z=24f&*qeX-^5v%6vJSO8&X+Y$ZW}dZBbz=wRN$79E#>0AH)A2L?Xh^R%v7$aL^#`` zi>GIN53L~>KG zymIuUuEaU+GhU&gmsb>^Wf=R|z)TMHU%tu)6mst9Xf!yT0g`Rr89#3U@r=j+1szq1 zNKH=0kva^aA08vVdgyXs=7ZZ}-&L?_43u*F$Ajd#SA~F5L><(+l z@NhL2C~#U&7DPwtZZV04g$gwv?4&5jHA9N zB_gKrCcqtfff!onYeBR^qlI!u9?$KAi2B#BU!c@`EeIJD5gU%0 zs_+1Zot__!J++_{w6wG|9QYH1E1Z}yo?{65Yi@3{b24^ko*0n2#3x{S z;u*b;kQJveVDo8gATo^hai&27pH9XSf%fZ8H0a@&g2a7f4;yK=UB7j%x}Xw5NOAXs zn_F>4;R{+S2qxeQv{b@6PtldW4JqYuiR_i4R~YoLR3)lV>Ihyyh#L4Y!FnqfuKB0i za8Y`dF?%H#rcM`T%a16vdgrQ^tFn8aZPnJ52a9>QL@y)Ry=YEgCV}L#3;|(v#yh38 zd`YeT_n4S{(amFlMYB0qCeP)j>K;9lzp`*&GBG6qN)fpdc=y8*bt#j0sWQ54GLRaf zNj_ZuH50-{4WB_7>{3Q~p^r^w5gWhxN*dMH+0l!QynKWFm~E5gO%yh+qg*Ox-|`$> z(-rG-g{UE&N2Kb!g9RIPb>>b(o%zA1>0$qM6?OGzyMAj~H$80I&2aY?AsShwrM%iP z`Cs%Gt-Bcz-3iPZEBScea8tq<;gc22>P-Bn&#ecM5+Rd0F)Gn*s`%-EAY8v5zqo{2 zLYOL`CE@2kgYdErbOucUA%Pzl!@v- zueZIWMJa$TOeyH_TJnIId0*$H8=GRORP)6qfx~!qaE5{-kp~REu`!6c+8lwPKFnLs zA7;xPEl+*kycvosGL|kMf}Ix~4F@dIIa;XsN*){4=p~@=C*_Lul5&}C+32k`v0G$q z>qoB6`JkjBA1M)8cEKp)%%`n)!ha;9Z0o5QnIP%_(b`6L)8)(|NP*zO^~4FKxR{Di zXaknn_3r(eFiJ?Kr+(>(5>rr^!!XOB*LXE{W6$=)gPJ>b@c$B5Q{$!~XmJ{q!kaXU zw!61Iv^cW4MNLWR1gbCwxNq3T3RN_fNvW=0f-ubkX|Q$hr>zWIp1zJQq1TCTmdjY) z`XUv_oKI0X?y8;Nl(FZa$nD7m)om=VvK_h_EpvS=CAoNuB6cEvp#nBsp-&EP@KtNM zUQ@#-ETe4}>Im-y$>Xo?wPw@Y-h_5~QSM)i{Di8aqCezv5;sE5oB^VQUlu~s0cptT z9&Wp!jh$$pk12RjxJ88aB>0><^#kt~r64{FY1lQ7A6v{qoP*lkwgA}TN$`9WYd5a6 z-Gqc0?FO*72GUP%nn1u`h?luTz#Tg^G?u{D(^5g>j}L3Pve<)_1n}Co8D$a-Vh$l_ z`vNrO-OHEp9*J4#wxABwBbgXI-!Om^!ucVLm69^_*Q1WOLE~2#v_TDO(Xibfc?p7t z`AX;=J#$P!NbwO}Lv9haL_6WqBp+pt4VWWGE@OECX4D!aJDi8|s+ zU*+$>Q+;LA$Aq2b{Wo$9Q|tqAT+0L(zT9=gXTigGk$(66s;bLqOstIZr1~{;c&Yj| z$yxAY?p3}x#n)isjJ!Kv*pqVS9&0~;!k-ndp zsp%W6h>UoQ>&WeDXgSJx^vAysf#U!GFGoj5Xxk1R+(1Ksln^d@Ex!SVe#cEK_`JsR zhgn2#gxLXa7uGV^iO{M>g9@QILjCv}r2%Z|AvhZai5^tplx3pTf4^3t$(NGH`i-Fnv8M zYnwim?$Fuv8b5mz#4&K}g*0sm3FZw?wCZUKy2Q&TtocBAlbC1di)&d9Jd zH;Z`_1(TWr6@wEV*+D4J+pKA`!y_2RJpm@^>VPOPl=zT~OosC_+f;ywTkMjij}i;FFV1JE4|3^--o$^^^c-zqEo&3Yv! z(MeE|sl^*IZoKDT;WShLDSIV5vKa2|H|}%K_e;rjdxP&;D+c>OvE+-zS#Jc~*Bsey z$rlVdssG0PC-IZLH4VFt6R#c?IY5H3MqnBWSeQ*)0(c50Bx(xA*n+g^zpXm6TIG#XW?Uy$IQ|b%YY5{w)6!NOg*0 zQT0KoVtof71zr;f;9k=5CC4z4vy+itRZYRGD?7umF63OJ!lFs+e}%z*8CQ?L?6z$X zJ-VP*B{-W9Qfz4LFLG0QglSxC4dJMhnre`S#|feo%6Tul{;}HZ&A)i^WyLdK^-8OVApCVsaaG>uPx) zysyQVb^;yDEkF~S7&2}AAk|VZTrEESHjAHL*jr@t;Y`dt23u-kEJLGg5W%gGDAaV* z-NOUc*G|iA%w*d44mR7kbc(PT&9+%OMI&ReSJi$SimMy zoDh;@WUQZby0xWcgH#6lZq4sczLnl5FGjv-p>IBcQ!jV8;)6U`+z;O0lx=Pm)*#fT zlcQNdS-H6lYp8>0o8~}}yZC~+ZJ9Y7QroKHof2_LdUqONlfKfNH#x3@0k{woavs?P zc(OL{>9Y1TC{oI}-&=Yt=j6V-{~9}1q={29J>5$RfpZUbny|zOvbAU=&Y-6=1bIAP z0BK=RfN%(^n`}$w3)*8EX}Tyvy!pA|OB0tM;6et{544iT;VTg1V6-rY7*!bJoS$o)N68XA}N2Bh~fPPlLY?<`cJ;IQD>rp$np$7MJ_3U(L<%k#HVQo11U;+8u? z_VIb_+#FX?QDI2pGYh0&1S#X$l^bh)z|sA5IYhR*Fk-A$I3YUe+EHiA7Gb86z9OLGYLWe>ZZPwkaY-4|@Aibe#O&|o zUnEGk!$l*sgT5Te(>2bBH=is`2d;vH2Fe7>Z$qY+^N=tRSFkXVULKR5{AOPbaDB!Vl0#rft zY#3%yC~{TL#+f5M^y<^LHgdf#$;3JZM+2O*3Q%^v_sQ57ftw?GM6J(<^h`?j6V@ai z9u6?eMn5*ZHYBC~!|`Fwj~EPTbepa4i#6Ip1bk>MxqJV^rLP*2pHu4^jlIt$zA)J3bJO_M1=rVN z#X}q0cC#w_LYW%OI}1L3bYs7N;u6kVU+J>(r>)s-Dky#xNfj)xO<4g{h7vLT+V|7K zfJc<;*)7o$fgY+3OBoqP0RaA7>HdXxt`@>99{r$d#2}iLczo-}Ev4E4OJWMdn%Wp6 z)?`lOl%rMrGCj@9!vopI6R5ci4HLCR&QJGLg{hV7%Fx~o!I^$6Dg$(rcR*B@mO9ff zij)4JQvhc~;iFGnpF7h_&*#d-z(6G}7jx27brW;movSu}=cy?RqE&W1Tso)gK& z61SwMmNTx**+T;sQ*-MUNC3O4HBa2r<;Gs3hi2U(V+Gf}2j?Mq?T(NLERk;!XCsIB ze;&Ti)Vq01;`!iKXNT>E3&-@!C=}9#y}>EG)Q};8YPrfypVy1E-YGBlY&v;6y}Neu zy&hFvG|fXb;z4EQn6PYF*0ZR5V^1|uMsNUl@T^#Gi)|=%F#26T1Jh0C7gJvqPktJ} z=f#C}wa2B&9^8wv%dPv&S)8k^O*dPg972KdQ4v-0$1@r^ZSvM_0Jh`%j!2t@o zB-8Mf?=Ky5R(|L85ibS)8hFeG26)_L`V{*1$LOnpW&z6fYQ%N`4;Xww!IZ5(Hwrq7 zcW#?#^rxj#A-K<>fmN(QZTbxXY|JW#DcO|ladkM>aU5cr`VF5qtJMo93vGPmLOK651mMrDLl~YjgYFQO$jQ%Y?G)T}H5~lFZ8QR-WlmpWEp@ zWys-P!+Rp$qD@j)lVE-F>N2c@6nlf4?$>Me<6wmT&6bHj-Je_KgOT z3)k)a`=3J=3lcRo9GFjbYDo=qE~wE{Ym`e*Cx~84GaKL*9%>--&Lk)zt(uyh;J@(^ z?GZtS0&GV#PZp%DgD_}Uuha0GHv+EBW;`1?G+d4G= zW0*CIGY%0$1t36(0%PFPRb0Gb<3>Dws2NTM1^opBFDb?O)6iLx$qWBH$ou?g(kGS^X90Hvd^((};*tx}=k2DsXxn{QmXLSTJhIz%QGd&^jDmqvttW zp*vdU9@AY`+F!^>*_owv&_nS~sNRRigX1)}+siqIy{AeIC1Vr-*gL(gUXG^sx7HaF z8J3}YO|Mvs+#Aq6j08Sj(LcrHT;44Lu{kJCcNr?`al(Vube{ztWBs2PKodCCm`^o9 z08~Y{E_chrliLp`O}!Ff7_!!K?Z06-{i3tBO^q_P1fJ;0(jtu0|e1{o+2mOj$(3#Z0N>7DBtD3@gIutNLd&6~0XXSAWIciM3^<1|2VG5=H; zuUFCc-gD5VIIJM&1T6cw1%NY&MyT2P;YkFb9hsVnYY*aA-0O!H1X(p{rCfB_J5o98 zp|(9=XYmF|&wM_t=i(@7siaA4Q=R)5zLxw)-{QBAb*_EvhBogyaLw((Y)f=S-#!n-wJoV~Y z^7j7fQ1R-RY6hks%u)}yhjYe-^^VV!lt`$At^7XyH*lSP^uZ)9pw_i>h;_DLI#%@G_z|(uv6wAG{N6}+65`^r#Cw3*(f`OFssrK|;XLyT z8k6E4fCO$&iQjW^isKFpMELoY*T9<5(T7-gx{cOAX=16KvvkWbG=a7b4h{zo#`xe~ z!R>(V5mBS3WE;$e_g#8p((gHiW{s9AejN+Wm9Xvc_kZ;`NPaRKTFqt2%jQDV;BMwA z)T2i=HGOGA|0pX#;iKL0Mm<2wANEI6FH+rUpMKqVEk?Y*ZMvoi?>eG5F!6{uOixWU zNGBY?g<+#0icF#^pn-vIixCb;!3AUo=@VEoKz*wxhl@Hs?V014MFk{QlvI?FJ#YuFs0@iSJ^iv zAEi0pp753#(>TSd`=GmG^4Ngk;Ls9Apu>OA8v7m}cp3tV?T2baTVO)s$xXPU6F9jK z3il*j`+a$@n9PuMRc>RLPUzwXugno|rNGIGw;R+63*H~se`K{iq^xd@2v3ikdogFG z1QE*6HSBxcr-x96g_6@D`>&G`3uLkP_3Ql?KTS?P2wnOH!~ot9q60t@OLqBOb<91^ zoLjqzfnp)Snnz37>aN4jt8%4CO2u@SBj?e;ULb2AJOKc}LF?+(p5$(*2Kp2>f#1Lu z(BFVCm-XL57E}RzV9-Uu1PU@x^qY-CR9ie7zyuCjC7khqpm1vgGI%p^I!F=&W#8Z+ zclmE(t!u3}_KGdHM&Odda6%r~&nd{qXXIm#{f_!a7%l@_eEn;`VOGVvy})6%hM*lX zlqibgwR@PD7-)1AK(+>8BlVO~nen}{y(c;|Q*S$~_y}1V_M_<)i+rJDb4jWz^!u!> zCA~`dF^Nq~_B0}x_*zFXx~{*Ke826S>kR;9v@LJ}eZwf9X>Py_{*KUmF1p$JQN!2L zUHR~_ro2W&JjXvG>@jCC#l?F6XCz_&sQlr3`ID6p09h!y zFREXV&&vs@jB)>~f&3d>nwi0uj`gRSni_Bb{Y<0i8pJDFs5?8>=6YQ>U`oX>2+|Q^ z<{uGiO5`J;wqpmWOtNXcGJGu=7cX*8YG2CCgp~UV5J2eg#l)hgst+$6AD@`8|7Qt9 zLxY#j)-RNmf_IJ2oR5d+FjW3SL&4ua9SVdU*2Y3RSNcFWg?4ndVc!V**mkf9qeoC% zKA?-8=3C`lQgLmCf_A_XKKot#_xo7#!|UncJBLOHlr(}ZnaaNUZ25g|vy%hSelX3ZVNtQq zuB8#Pto?-4jD?_fD39*X*3DIheJOGk{pkFEyb%vfu|IdH4VEoh;^zaLpC8*cV`J9; z`t>ikS-2X78x2{d?9S#;E-w%|spaA2B{c}mOUkvD4Hu=H*Bc*}c-`s-iDE@8UemMu zrA>mOUSe?wh-!%IK}?e*yD*<|kxg7wuiv5S7nkWmUZFH-$FJWKD&JPbij}o%A8xg5 zj}p`)9d&k&oR#JMPfg5fI9f+IAY!HOTtb4MC1GW7k(UbM#%V>~UR@=k&{qeNPT4I|Y0T|MZ9~pR`yygJ8(h zOhu;yleAkdN~wh%d9}i4QkZs23n$JARgTU5aY2q!ojQX`PM~p1>HWd;+$M3)mH1KO zynKDfozu0q%#LsqIbnwUF4FDOitE7wqqu~8G$-@k zzTi_dXT?b8tMR!L70o#q8d%R+kB+gDIVu#Q{K=H7Pd!F&CaPUa>u)*nLHY)42F)>y zo92076X?bDBnIWooMHiXc5{3Cu9lCe%4V+8R0aR%PEUO;K!oLAzZfZS;sykb z%7_;Ya(%j~;3%cwSIKS$uNImMRq$QKw#CHcBsPV!mx{%M&@c2&-wnQtk;aBmw#a4! zx?bRi;AnaUyG|ije6F~nVh#f=rU(dx@c?Pd@mzptvtq*>`UR|A6F%ggQeI4{P~s9V z3v(#gsNP;4YjR>JFN!3pxeyf!--eSUMeE-*4wq~!0?nC5F z6d79JnZq(fj>Byl727e+DZ9*hk%QLO3;UYm;^@y7JKyItRMD0;W`BM}V7Xu*z@$++{SMe@%?_{vg%*xs# zE`C|-bUFzPJ-X8DU+~xh6_!m?ht`leqBFlg6ejY!cSqAV`if(Rh?E=8jx07abnXBk z5*R=2LW_;Pb^J8N&44H2NPrFuYlp!&szz(c`eC7=zi&%<{szX48vr5^-mYP{wJtXO zeyoXmWxUOWI63v|%Q!0QzpG5>E^K9?yfv}u3%yY-OCxyiDru(q@v z&T}=$>(SA3_Bi!8hes2hH)%h%c*@u8;Qq<=$%%XD;bEIKQ^bz?RVS$wl5LPKsqW}& zwNTx_IjZMYRw))%Ru@YSL)YlHwWqm+86NE9!!J|QTbfgpuW}-jqaD?FMFS;)dvmCb ue&5jSPnEg$vO}a0EFrCuAeNWUTxHRE(LJBLheMZyKZbiu_3!98Mg1>Sp=GE5 literal 846219 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

tI!u4FCme8SsU53U*pMB!;o7bLIkEO}p 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 _@0lFGs)p{O2JGR z6!t2(a!_X@Om6qK{8Hz(2tJCX(i6!o<=IpmFao(ry)1>I{#pS^A1Ff9kYJm$zo>x_ z+_&m~;krifcF$bhUCa>x*A88JnR(8s0_KaaiUQ8X5rlVe8w1<|K#8RhJU|TLGnb$C zyYl?$huaKiNP@1t97n~>c;{|us#qnmU~33hd5DxIu22XrS3H9*;C^70^|j6D;Q5&J ziZXsX!!xIYnMnYrkXLUj`s_X^CSJS-6xH3NkFOdy|7$o(%4?$_yg{@2p3A75c^%9E z$7nMwC^;$*I?gkDqZ0M5mIJsa0rkZZfPHvyuu=WtmZeVp^aLcZf~Q`263p5s zo`m+m;N~gIw0Z-NxD3vdIZy-4(iru1F?*qvFNx2CVB)J3gj@$oIQ1qo#=x!L?qQTi zKy!N->L#NJ$_6LHVu}m$+ig(v9l&C^dHDdA|J%y6`hk;HJM`HC7 z4V&YvJ*o9*`{se4*zYx5pSdqyKMv8)u8K^0bxUCMWuJbdi>CndJOsG(3p#kvwAw{W zSvwgY0Y@m<7&TZp2DLtOWLS?u8f*}}TUf*dANuN_AAsPJ3ZfzSvNRnO9j9NQLjRAq z-vbBOhoDWwq?b9|HryR#)1gllcb9P-lp5y$T1QVqA6~}QXh6< z%Inl(KgL^MC!D!PrM;E?Av%Gt{Aj=m7hn@1e7AkCkNLu75qA#v%rq}2$TBou5vUc> zSPB^e`r~`=S|R!@lL@@B#7#%+vG)u|2Rj@c3+jh(SFf<406`*z^Gx7h-@IQG^*3ty z-?+Z4_-)IsAKwjCy|ak_f6mr5X)~O0a*RhG*UCVlp1~aBB1pADGI#8g<6U?!sNbKd zuD)uV$qjt=+NUQW((LtuDaIOl^@%e-sprT8L4~02-pe>h-P|D0++Vf@A}p6Xz&osr zVG^t>st(N;l{4vOIMa&rQuGAQKU6rvot+l}_MzSjP*o_V`l=_OhwkDEE*wz*r}fXt z7|XEl3pDT$_LdB41#$aCjZbwJrhBQkO;{M?O6!=e@T~u_)Vo1`Dcx-lp`5g!WB}4r zFQGogXv~8a>B~(D%*}8+0c+<(u7u$HFCNKm5KoB+N8ZJ*-K}6}ehsGHlL8q&Vac0P zUs4Cdz^4yIj`wWi2zdgRDa&6P^=`431-K{v`utNIy&leLITGA8TNkG5kEc$mkMBtn z1Fy;%=hYQ#t0?9rs-%$%0%UR3Zo3S3a-n{;!UI5F-C+8W3>r{Kk0VkqzA2_FTR}A- z_1Shavwp;l?wIy?J?iA8I-O1MFFsPR27Sy*Wdkwz1)#qLPYLwTl?DbQwlOYP{_*B` zFqhHH=DaSjV$f_mha%AR$*@@=0A7)WBD0BGE5qEvh#AOai&!=Bh8GI+(h+TmlX^+u z{p>AiN^WU`@~4x}i22RaZ?}~MimvmC?Nf}@^!2ydGO^q&?Ky1W-ECUz8&8Q8&Y`M5 zdWu`7^}AHrR+O`M(sp*x{jLR`cK zXG+?{+9e`6s;xb$0(zg=;2cU*kzO42i!pE%@!r3ORY;!?4e$n4g7SPbc`psU{8%+a ztop$}rZ2B^zf5o45-Ma3ltJ4WOJ!0JMVQmV$YH{$^}uzc|?z z58~zA#RcAGXn(74PBusPO2go*lW7YlYv9zoqGs$3RDa(3et(ZJPKV;o4G08_XpD#t z)1HlE3@NMM`jKHLm#`>(hhpvosc$)zQ*?kC*%t9|$U&ky@}AJvM6qWe*zu%u%v6Nc zI3}ZaEZ#X}svM5d-Z9o-78ticIY6(3msrA6MTB!qx@KQJ0ez~vNLq@5bU_UfTe$km z=E6gUE1dmgBnN=sI>O7JJ!G^&DbhEibk_-6M7`0n@MvrX46jVRy^IDZ+2ee0;2aqU z^`^nud6X(Dj;ahRz-9Nu~5UwiT zBYA3iSQ2=7kQp5CQa|V*I{09FS42mRVM4JFdu*fOXQuu?hh7#t%W$*WU7)vpFxbRs zGh#qj2UFa|eD3~?77Js%3RJ;?=f`#?ce8{8tYOTL581=6Wncyhp?Qksk@m%td}t{K zZJWGxLVXpf+T1Lmx{QAIfISjLebxy%mAj_k(z~tpwuN8o7^^?uaRAFhbSgk!I11JY zQjaN+>L)fK0nQGvfsFsZeDT}Y+r*vv`8#Q%Ir8N&l1$=JpALh{8(~p$4tO_+X{)}Y zP$weqcw96`Oc_S}%p~+rer`B|4NVk|4zOH&Ab4`mHlvaG^|!e4L-;tHEz(xUX9KR= ze>|ZcU{_~~|Jyjn3IvPbsClag#_DH=MbmSKq2A5F`^suwQ7~s{qHxtdf52Oe*-s9O zlF9T1n7`Q>_F$BW`ycrH5l$%O9VrYH=fvD)J?G6i9i;QmX-g{%pn9aZH6g3ZZ?|sG z_g4S#=f-UZC3~$0|KJt(l+X$&J&l2Xdg@guTvaRQtydJ9fLAqe`4uxG4b+1;W%=NI z1t-gOxF;WMFRxt#8fya+v_Mqn8D?BI)Id-R&urmP1UVh;EPX3M0nuRkA>h=b6>+gJ zS#mQ#JPY8~&z z$9)Urct=m}RsYF?@!9*6z7P{UVKoQ{7s0?!#3alg=gC>(V+rD*Z0gOMV>!j9>tW*(>OH9Hk7 zFl{fZU^xibpl{$%Q#sZ~Mm`gC+hlgCfBC?BFNZu~*#pjieta^O!(O)w%s_9pJtpzl zTtc9^GRMA53_{UVptLx=_5OEUfX)>0n?&3?3faO4esl62U1DIcxN}OZCmgrHUg~Z= z%^=@_^M@+LGZYWGT8EZhaMs&7H}`BXj+CXM#;ul7F3@S^#v%mVI?)f#;j0_fcfQFS z2lf;$se)LyMVC$fb!nXiEIxb#H_R@VEuDiLTzFP4_@{3Nh0Z}Tkj`tts-3~?ud!hK z`-vak3juKK?$e@2R&>%cHO<5>=aZ6-W>XOKv<+ZZ5YWpK18^zzE)WNc!HzhFpgvt6 zo5d|DXce&=LNCUI#j7+c7WS!^W2YeI_sJoBgN%;g{J{^NT+P%4bkuo|aLu0JaASBN z^NnL+)`s5&R?;@|;ZtL$k3jwXi+W+R^nLi^3-C70=;5&*a$MVNV2p-(lrs%P49s}x z;-W8#HUW2^hgNqo9Ty8S)Txg4ZEdWOTlGywj`NvL?y69qmpb>z7+gA)ppBI80AI-n z>*X~;z3r0DCGZr11Wo!5nIY!ocOjWi26ST4?UXWL8P*3z%K=>Y3;S>WvdK7}0}{CF z6*3$utHfe_xpHN?qCw?IXQ#jbuDM<$aqw=&X{gVDZY^+=AmKWHLTW@vbe)9aJ&Om#bpiR9I*}ZPl1lJKT+0Ol>C_PhW zsBfG7IjdC{K5k`uepbSA`s*`4*QbZ11as1Y!kfQJtA*-go^CUo_E2mvd;zXItT5Wf zTENxc2`NEc6Z%G4%K5UI>IF|Lfd0MTt&C%rFDrIs?hA@JKNrx}05JB;iCF(u94HpNv7BmU!FSCAm{Au1%{6RYG&_*sk4G#1ShJ-;_K_xUf7KbXr z9BT;ytDW2k&aN2dh@2fuJe2 zX=6Eu90{s1+)$E0%<7(+e|zNt$Q%3ZSA&^d1Sa5Rm>vMbP+Hgg>8oR0M)sMcbDH6p zaaY?18Uv{tpf%_k09BxS^WlzTnsZ>LS+Gex&-%rbhcC|uOt6d#DB!gLCK2EYYQOp{ zxcmuVrZ$|LVS4uF8xVqe5jKdj$q6y$7(1X%1S6QHo9rHF>MiJ;JfLcbYaBFIk-1bZ zwIh;wg&^^8PC)MrSRLoVFfj!Ta2W>0S_#3d1U`N9V@?K$b>+EtfMK}!zN3>7<_6U- zab^;v(H{7_bgGH})>}56Yq0yo2d<*=&kvY3KONJCz#Cq24tK$ui^B1{PWg25<>Nc?YQP&=n2($c4k; zaUtcwyvkCLfFat+x&T-~=N>tGAWO^)?S{2YJiHXZw3(YyALHf*Uw94d9)0olj?bQg zX-WZ`sm|-MrbG<}Gn9)LQQzXl9`qVDK{YUy?rrD^oYNQ29}q_^#k=pjJKt*@u+z{) zxwl^T<&%@12p7u>pa&+#?y?X*GVxUIO+h;Mti>=Lm1XLmG4R~_4G$`-UdbY|c&E;Z zg;5P!53+$afINGqL&RtoLLBVsN-yzth`%mh+FoC46{-gxKEGKC~h zn04NlXUbuDzL56*#Tmk6QJ)hohr%-$@X8i20bQTHY?!U~b;=nLFH7O>R?!(6_c@yw z9r2KD<=PUTu1_EBgUR&bItjRN0$!Ze`@`qN4i*944+@SeiVvB#LTm0~zy*PNT=x10 zfA9G1-xZlH$9|trW*HqrVO3lvj#;{}lU*S8MOKr&I-haVT2nSbhG?SYuB^|e8Sa=!w- zBJ={o2xPpj9v62-hDbj2ojb@?3LWOUFZ{C3zIw2WKmwk?ikdZBtUkHwt-k2#{4?CC zwf}yc>%grFZ0itd5+OX07LNr?ja-7%9`ad6NC%7OPl13aJqxek#+&zvtBV7xU>MjA zV)O*6q!=#<%^4k|e}3p$CX4#hPW@zOv`=qN4Rc$dGu%D1WpK_6SKGAsdC}j$c={2Y z1h9%t>VHbo49?6C0CDKv7M+hAv$d1~&v&}%b6l>TbZ6nF7AD2 zF6Vd|cL0zYBa+LiBbQ_^?$T!CKHAd=HUQ$<=uks5&=S4H3&vV;RMpiv>#&O>hE)id zzVsOQ#KeewnFiD0iDN9jfBJKtoY`^^P&`(>Ml^6Pt@|<^tpxs*}c&GYe9Nu(+ zQV@?5bVHnbW2N>D+?x-r29zGUejH-MibnNPA*>F@>7!tqm}D)wet2hv6_xFV1Bj{@ zDLffs&~R*r#w+2S72w&NSP>NvaO!17*Vo~FpX&CSDy@_K$vpMSNiqFu&m7`;*I&DI zLMO+W=cS2V4uSOY`$J_$nF|ZSf%!MN$~(iw0#D=6Sy6z+6~FML*gAS#5MG}75F{<& zk?x}UtA83zb8Ud?4C={pDE`U333xXSb6GPg!31NS zh1?!(_M89p{r>h8|v2Sv0Qyf(&4Wvq08(GjdsTE+H-rkUVy6z>*!ft z?(SuCVr$_E%RckeO)$UT|HYl98|QV=P{P!&2tiT5Y8u8^?b-##tOU64d3**(4{Q;! z&Zj0Q0cyS*SWs@dxjs)C(sm3oFM$>=Tk{1SK&D>FnaYB92U^AUV}av(=#9v3f@(T3{9h6gmIrZY2_6Kn>a(gjhP$kK$6nZPM;&%#L!bQ!P@cp1I7W28NfNr zipmT2x`QqLg0#5J5NfKB=O0)cL)$bj9|&TNT`b_=s-mIZd0m3urFuwR>Vbu82Bd>{ zON=T43m^B)r^CKlX)A(Y`|bdX@LIVcjAQmo(Nkv1v-FgMYEAxu%`d^6iqZl6a28XYMH>iA1>=+fj?BKWiCokT(gObJ3#(^G^+f*se||gRWwbCT zj+k`f*doNm2p+{UvzVEzoiKRd!Wq1v6I!i&HoY8<4__1I$JPv)rC5Kr`Y} zU(X{d`(T>$lILD;1<#)K2NztwUu0m5{kFV1lMB|uRRTC1K~oR+j3YR$#%@kfuLGwK zG<4t{rD3A0{DV5E$FE-M&Nff`!son=DFx(-_~@C`WzfD~y~crhY`hIkfd-tpr{Z#X zrQTIw%^=Rjb0b(Nh)c^Iycz_YvzK95Wgw4;&=QCs-UB;97oN`SPFz3#a8(5_&;)Ak z?_!o0gSLVq2EmwIYzIDgMn4lm=O&n0cH2V1vm7L-ftX~U;c8QflbZzS5W%?eFhPZ( zLCFPiljtRfR#_A>2~pMn#%>erNzVfTW|{gT5A}5+I~X4(zkv@P^0vX?(ls%F2FC1% zb#wa5yZ3@~w=fW-`3H4D>$W;%C|5ZxikZ1Ju8aGn9s~r5;4F3OKx+xg5qGxk!L*u_ z^A@LY&RQ_h!b!1;IO6g#AImpKPQaxD32oaP7}I&ycze{1w_$$y=0o5iCcShzx*R1F zotqtCO2-XzDY*5)xfXs!P_u%9vj8iBEsPJ8XD7hxnYU&k$yCS#Vs5)G87KM&A|fX2MS(R zRkY;BQ$v+HrBWxkuYejY)wgSR>cUow1}=kcgSImf45;cq`-5~*-8oy}>V6mS730h# z=lVJIUkQ%Fzy@f0cXtHW)-!iGTYxF#!npuBjD|qHh%QiD5Ds~tTubM*lRQ!n0UBc* z2LhOVZJ=&YGD{PXH}?;`=kxDoVg8aW(p88E=R8QpQDB9L9gY}rVqF9l?gtBX=Q*uG zoI4K74&F)ytq|3q3$J|o zQ(iBRb?(E1VA-Jfp>}YNJc9SQuU>y;oKx5lVx55yn7BR7h6!b&(XiG+`#qlqfW`L- zKwV$NF{g+>tTKcf2Jma9!Ylwxutf z?%sTOiM~pkXIqGCy!k6`P-S&_%?|~J1xKQ<$V8POxP!7>qAck;z$Myt6OBQI8<8k>`SZ9CQyZF5~ ztuWc${G%3dj>*JvP%)ruk}GeJ`qDZ*8Qzb6n`GW#g0hnpZd{eMa%lG?feG|IK#bEb zr$o0#8*N#Zga#PhOsXpnfK8<5Z^dyqg{`I7p4X3yWG;`e?A zn8;if$}kp(IJraUt-{+sfR|IEgg~4-kXr2RT@pm{ZoYN5buW z<2h+8W*NMGG@onjEiUk!Io^Hdk9Ts_fFjdkrCSM$Z5ch*4rwd7@QRmcW3iCDGBEhX z;bRaSt49-<`faT%Z$axWYXQIQ{>QxFxuuLDpg#D<)jj3!2q7l@YI;Bv^eCz8WVUL zC=Uemh|s+({ENP1lyC5G9gBehZbwdUgUt-iHLGv}W4OjabdH_>DMQ7pheov}KsbW? zAWZ$`7)l{?7TB)WY@3*jEYQ*omeU9psD767{12=q?yvk|FkXo(s7IF<4*kEIn>aO) zv*0LLoJV!1T(-5&ex3A%kBs-RtN}NVg5_mRMI=EkKl_v(JPh8ebDhHH7?+t*odz*# zJ9cjBU5pqSfoYIGX9(O|%mTWz+!AVoq?1zvx)@1diz`?Xe$WGgOSZQ#g6WV7DjEa> zn(BwQHMXDHFBW(Js4^IgF{|Yk(9u4%4?2({Lb$21aCS7jqMiFOr8kia%6Y|1F_mg_ zPCw`dsq=%62Mce40hu5k!U3y~V6of?u5+I_UwlWb=#e2ED7CHOWEC*5D;sK15Lm}} z!wkf3>lnK_d+7RW5aE-0ciLb8{h;mnqOTDlyoi|%SeYcL9bfI~o#5-3)g92ye&w!Rb5y*z~OjppS8; zB8OQE0z7=2eVyVaBUvVxU`@_UFV@Mw{Pt&D*6;zaFpviqp>=pOoVjF^uw-^@I3}Qq4bFPVuq6QRA=AI!fSc7aYgwdSxt zegF*MHTa;KC8l{iSd}rcm~DQbidcVeds*O2nQZ_wn-x+O*qYLw(u$5Ln0k{GK?O?H zFZx-aojN3*bI&jeB!Sg@^#y2*5|G-%Su%V20~*1-1HpQ_89!jyIy|R7w@D}H(-Ylw z5boo{aS%LosIdl|RJ?tTD{cb;10ul9y!7I?da{+-0+gul3l_b|7cvKAWi{a51-jyx ztVy5j^Yl;W&>Z2-$FaXfl5czp^TJ8rMgE5mk$4%N;JNH>z7F{En-je zU53Z>V)QaI0X_sov#(xu%2g=RdxJ+a?K!^rN5NRK zxLiQnr!RtYYbJs?zaWrc{Tvr$j>~1hx4SXeFz!&QzJ7(N0&py`HDHshw?G1u+`t`w z1O3iV5B&WDq&xLifgsL^+h+skepl`W^CTw>Fjtvt0;XYDvgqnZK8%)+9}F<@diUQxm&=a*b@-V7&37U^g=7u%MbPZd*0D{Qtg8wf$*41v%z^-5j*kbQ0&V% z11mWN><%>7F$BQEarH#Y1>}~95ifY_=&g4lxQS=HIOoc8&YA(^0Fshf%ER1sM)sOJ zit2dO;wK9#px=SLhRyslGdczF1MNk6Uv;%fdz6T22wMvSI?I-pxGGJ2Fze-Mq<^DF?O>20>}O^yfJb!5!O6d7Mslc<{g5QR3935<1Qxwx^|s= zeI<-7ovfzn3u_>~L0x)Tp$h)(@n0MI*f6^;1%3EqygFCk5&A6|`27;sX({?@so0!h zg)H8(K6K>#0cevTrXj$10inz)!IhWv6krx_*%tcgqdHW(FFjw*{aPf)=@b-W3&grz zmw&>L`12rUac6eQmnRQGshGRI4}yDwi^@0%*4J?zd$t-5C|q3ue${rjVI+5uO?ao^AuH zU;Jj34$if(&=k{AIvB4vMm$_V1%t?(1*ihk*O+yH4rWyube*VXX%W5&f|~(|%Sg;% zIcN5i)qt(7Z{bXAx@(qZ=8!?7to-92NmGKk|I~3&g?mAq zdk&0;-YdQ~rdxyPlYEM;wBIho3%+y}n0?!F4bnk)Ta1n|m%9Yyw1+pkZ+#sUfJUar zw;q5t|7FgsMLI#EI=#GBo&6^#CKq1}0eK$bExDo^Jk0`ig<&$Vqp_SWFu`2@@EI|{ zr=m8G-0df3P6XunBVbkH$P+P;(mFH${OO;2w~5Wb1hBmQ@kfU@Uw>zB7F6}&X6BhX zp9{vL1m2AzdFj0%dk%m4n;B^mu2;cp@yC7jI)8E^Rwoo=9qN1j5R-s)n%O#ktTYY+ zIQtq{LcJKmvol0m61mra$O*7DqO-T~6n`d}MLcxeWvEbiG|=nl6TN z?hk2OE5hLVp50;ZMz4k*R9vARrq^81wa0Lpi9_q1v5r7oel{U-ENbx`-Fm5{YrQ34 z@TLjy!qW-%%cM@~G#PYZB1eOm-OTt6pwmwE=Ds=5Ea0)MGE#U59k_&hm;E|!@IL`4`=tW;1GuPh9 zjmOI5vA(cBqJf(j2p<;-UhK5aO!!OXMm9)?(X^~d0Wptdn4EWr8pl!^X_!;n#; zGjFqaP7_G|AQbP+Km(^c8QeQ7X2S2E69t@=hI^GyDxA*EcbvIWj^MT3a`tTIc-aGc zPrxrCK?p1&x+7Ar-sf9(nVlzGe_Y?wm>(sr{k_3*5V+pf9B9U=2gJ=j9TCM=Akoq3 zs521-3>}|UID>3)v9hd9WdkQ3bma*fM8UZ?z_*5Q3O=A<&=BbC0mgIw1Q;-Q$A|mB z_aE+YuEVjbmcp(pw(1pwv1TKf9(4+1v#v6lBaC3;PS$e?8LChaP-L=*!aL*?C_d3& z9N>H%?7;*#;K9AyP{c7aw15qy-gR9db{+)hmdl#3TYTUHUmkrcS*I^! z#W9V8%w6iux`j{!K&ep`>ah>%!oHoYR}Vz;lF6VupsTHTIdeyRao}fbqKCXV2j9uB z?|%fchVvF!`)C_xE3}1^V4P?I2ODLFFHW*acMiGjeP`EgE3IR!Z9CFD!EvRJo3ZG#KYKais1u7MbUIl zKcufo_X53I{S+S*0h*>p?Q3fI<6D`YSMD<$vCWHL18leq#S$p$9!AT6721`5GE68e z>AcqE*TD3#%(DoeInIyu2q+3-F}jBnpobEOy!DVM*Yuc5EU}I*IpSgUv3DOY>F#Nf>rux)pe2lhleVPrxAq?cV9)LD{$Ke_X?p`2< zN$1flMq$Lg%$jZa+rXJF>lh~HI6Ga(>~(mz340N6$1|uvT>eK-L#$dBH97xFae2j$ zGO!G3f0DR53pPTT7DMBKtw&+*nY-svvL@!H|rl zpLq*H{Z%Pl+#kFH`SsC9dTn1HKX&0?y4(F>hc1yu&a5}2MT{W`@0{%RPaX*3=I8cy z1nbg*-eKam=gux}S+6rMh`+LBdfdtw{`J^V?pT1OPfti386vv-+zp&z=BPXSs8*9IK}(hAOb!LjqQ{N~>XVMFiC=MK&3)lT$ee9-!+! zH1#7@%a#Vl^p-Ilb>t)LYgGp?Fk}K_bh&b4jNDGvBJNK|v|W9C^_KF*k1eBR-1di8 zA)4!0=mhL#6YFefQl;U95_IJmF=lEvvc`9VmoLc!Z)Oz# zyH6fCHHn$&#lkG$c$`72J;6Hf0dxBJ2Wz5uK_`C~4|~0dfM+Af4b`Po%N$tI0d`vb&6=S#P&Xy2PS#V;r(`5fCoKMe+mx<5OL&=3?hvy+Q2i7H?1r%l z^-UJJ(D$~VdJh8Njt}YY4dNEg1{Egz6+z7ZY%!}NM_>Xrt~F3zDiVBGnGJl@u%S$Y zCN!}TU<{iXaY2ku#vqt1L_iLROQ%~tct+d?AKW5p4pW!;%JcfU$!9_J!HwX+!uwz= zR*QijDHcU|_9!nB0y41*MUEFTEA$09cYxE+WRJkPgZQHir1!1gTtBE1>3`+#Xi@o0 z!R0P2KfYXc&V;Ee;KK!wOSvV4sZn1kF7HI0bvK`J&W}jA^;ndD-g-3UgBIT=05wvM zzVvuJly=ZZ`^95$SFVsC34%Lu7_`xe>*3eVJps_|h>ChxtON}8#NxN8`<*>BG~P6G z`OQhkW7~I$)vEV|dt;Mhv*>!JU1shg?v^tTN95H(PS1dGB{(|4<)17ZPvWKkN-r4GsrJ`mXql36qkC(F7trX-2-w@tZwG@xiYb!$Z_UC zcqk_5-$~$^O97mG2Il1bp^Ob}Cpi z?#2Bnur@{3cmz8$C_VO?#y|Nm0Kg#L_sjtf*%O=FKMzy^0=DT5y^Xs;Pf%LGT}rga z#|2hoWnZE+#iob3Zdj8EW2TTt^bUYk=uEAVW3nK;|9tR$4xMo^@E_{)7qwiSoDl}y zKwTg+AX$aca5C02QDB^QG3&#P!(3$b)hc7^0}im5DqPnUCNLm%l1augV z4Zd)IIR&imt`sGMTMA&LfMO9G+7_M$B=mFyM}P9B7)(Tf)o=O=wP|sLj_`g5=ngp6 zG4toIaen|+EXIHqdKbabEPgKF!r|}|Dl^?lEeh~uokeJ-}a%NHptHb|!h_k`AZ z_%Q8iL8;<&qvUhIrcevG4mY$C5Fcy`JMUgr1qoDS?2elAtY>t$if4Ny?||V+zOE3F z*=?~A=YAtC;C`a(hm&!2reta8GCA6vi_gW9QxjH?b?0bQXjVP%p@;=XZ~K zV`17R&yUj{(G zdN&)SBffd%DVRE=leuy$EW5XSt|KZ(atHv&>Sht0i>T8qXS%DXm4_@m1jdEq9#UV| zu)@q51kC8Q^M|g!&)8~HzljMmZYe@;TQ3 z<(rQ%fqD0d&b18wPpToh2wuv2tbr}x{FY^Cy*TnA*3EH_oCV;to+~QQqhoe@n8n3$ z6|+DBnFAc5V0Q-O=y$0oxadc%xdcLjtYT9p{ z0_F58yiVßu~8T`_RV~2mr-xa9oItB;=Dy$CS{(j&<)ESmAa@B@(J5>h zZ+(J-;k3I%(_3)Ey)a#jb`ERZa?f>5&fIpqA$92KY~awM^i2z@pv2Iibmouss~@H0 z^Y`L!-P#{?dpJoCwlOEww~j#ag{=B-HxuhmN1rQ&0M0)N=JnB&Q(lm2V^;*oAF@fm71F({x2AK@E3L zcmLu8>sOCIaPBBP9D?4(az?*pvQISohQMDtjVDKG^G$~wX}8=ueA%8y+?h;JK`KP7 z-gi&~j0U}Mu*Z^5zXwsqdk(+_+D<)0>=_Oj;0kk0H(zR*ftc$7vw`e2ve^tX2sC(Q zKRD22Hl?@G3#k8>6!2LBh%e;4*d_4a{cDm+ZS}9#719xSrP&?4!WL#VTsyc5-d_4* z(A@%4&fQcq3u8dV3Iz^0K|t(gx1;S$Gp{{*jn5 zj?4nOEi<^53?eJp7^wW*kGVjn9-srLN_7=w;rSKeIkv$jSc_j2$PLP|0u$S&eFsDZ z4+Al?BQwNR3*jefs+M}c!#Nyaa$%5x)fv0M*^hk(bMKdBfqkxX9xC7_VnenSN++Mn z44ghPT+TTJ z0*Y!xI`VE9%prkGdOnmmy}@_3)P-|>+y8R>RR&ZLEkci_43?A8wo$Yyh{c}|<OfWNjcuS2a?OOqaLh@mmk{+CWsZWr;}^I6=5Z*;V>3nE9v)#j2~jg z0k+^I@XwC44L6>7|N3Ll3)v$lasHVe){=1$z{B!DTz;SFjxQd02Z{lvo4~#rHaIMK z+`@Xge5?c9lRUr|KhNTklnkrC6^s!Z%jUz00bVUtedpFa%sKxg6F5r))IX9q z58xk8QHR=!Y()=x9MCF)IX!@zF+G?QU!^|3#fo0W`n8wJR?f8sv^z94u?`YwVUmQ$ zvHT7H<)t?v)DN}=LJ6IJEZLboEWQEOr9}OlD?FU0fmCQ}7Z{$Up{qr2>*!?vy}U5M z#nsmp$I#$dPG66=Yt>ipye*zT{rD{?dhHvVd2b7!u`*|xI1fP@1alU!Hi3DnS4Ju3 z_1BJxH;@I_K*K21a!^JTvjd3hT*m@sbNCrWtF(ZZgm9q~#?=cZ@rJ0c`gM2N4U;i8 z1+_4nxlx#FK;9Z&(i(079}^e7pzANO>lyKJ)PH&4X+6IjX6zkE#g9(qN5MJ0iFIuX zbcM^(70cob^bfOj6NtTggLus|Pl0jOiquQ;rPENC=7N>?c!JNhbFB8w^~uZsJKt-< zzaV<~fa$;%KyIYF2yoq#eamBF&30x<5PuQ@|qJY*-$_Z5d45hEUc>0}IC@q4P2T^MdOeceoj=k)_aO_`wQ-PI0G5Y z9iR$6lJl_P9;VIe_D^1S)9VSd1tiGwgN&czF{+3{a_+2(SNq z_eWwUOzSev90s@(buL(RX1;-Qo`(G*`d~ zvy7?F=j1Z!>`NV57#jhHE?pks(67Ikl>yPfcr83dPaH^43*ox~jI-iV{ve)Q(*|Z{ zUh`seAfQ`+UVu3}*0hG_eR_OXf;6VzdQ}v45An`nzz0F6_p@#=$i@1`%<|Y$RKaUU zab8S`^bB2HpbPr09WZn#H8UA0o#IGk72{5A(+R5Alf^>7zBrSC9&>3d)tC3jG3fz!=UH(7M()?5{2TikAbZTLidl&{tvqN# z6U5dcdw3V$&JTBQOxLFmK}KbafHyHu2F|nam(&e${L4YWZTBeHQy{er)zS_gKlvFp zAQbL`qGis*bAeDIyTO3GAoan}lHA}-;7`}c0H$@lT%uyH33onv~>FMiI{mxV-- zzYDTr1=weAk3>Q6o&z|85`5Nv@|;%$U%vrgKKO|GfRtFwOTeSL`25kCZ6E!r|Hkt$ zD>D1p#{%`S#R`~r;eMyBv7!CUpemhBP=V4i4vYoj@&g+$KGUIh;Nl0{?~= zqKsDovX+U=6|rz!eO0FzA;Y(AH-@4J^uPB`C3m@w@GW)g5}}m_rZS+FAkHI>#S35* z)o0>s?v3RB3kEf$gy!-T!6XwG(6wER5Oc6+YbN6ZWPJ0|VTdY5-JDR=NRiI4aWAr% z7)WEX+UAdg4}A0l4L{JC7eYEZd(;C#Hj7ggh-O)2856Cr$Ub&`{H^z>u3>@*F;uDJitKFN}B^*}lJ%z35?V*+%GP<~yy zYHgk0Jn|4zj9J0VW$P$Nz}X7)oD;hkBOuRcfujBkU7d0D3Ftmdk5Fk1yE40(0Br-M_4tFU8_M+)ZI#dgPZ8kENedTAy z5vw@}1G5oJyz|8}wJ|l4)hA-1ocfIm2Qu3GKl!(g4Lxj*i~(0)!wmV=bNj&oH-~?o zy20j6b4kH6_3AJ%v<22ojCzFvP3Idl13FhTd4)01r-#AD!{W`!(K;@=Xs{=MscVS< z(`6u%4&dt(C&68KTL$cRAs9N$p{>vZr9Eo4vk{uZLl>-mE7(YTGdR<$#l-Yvx}^^C zRDes%;ix<2{0rhdbqtdE#f-QI^zlP$!43TR#do0hlrcEwkVf^E_H1TNf@$$R@w&dv z|9F<+*a>2Dwn*mHkk!@^UN1JdPBrx%5-?eIcxPgWu0A=Y2MeQjHP{+2Fo36TVQQGf z&S`?=xF^)_GGBNGs@^|xz~Xl~eg2-?h}%;ErF z__;SYOBz?T^&j{q+`oDCgY$1bx}-X{s9G;J99~0T9eAzc=HpPq_3aO;iPyL1T=9-S z9XZL&2#sK-8PJ(k?d_kL&rt%!M&lLs$xRECGhz#mfUN|5!WMy!D2$1xnJz zqb0gnbhQj->kPDCft{8GH?B1I#+o-m52`ZGc4laOPW{*darvh$Ts$5PEdB^MRDDz8 z@&-sFpArmkER77r|4-VRxK(+bd&8R1U4W7Dx;_jGHhhaB$I&5 zY)DT|o1__Rn$`@>&@?BpX_BTHnyESFx|&3dnrIT^7-LU++H-o^ujl&S_aFFvzjd$u zY_#qB^}UYQ?;h6uOl#fK^RV56UNcksV|2_MAI#`Ik{_yI*|(Hi>`f8za~F>cvK|IR}F1sbrp? z_bgx$G%xCBKcf8CM`Z*)0h%>N%M~u?n{RQ|I=EGr88-U@*Y)Lhz|yZjUZq!y(dAd; ztgU*n3=oeL&};hoUY3c=ytrMqoPOGsm19-g3HaoO#&JK3on8Z`khf z56o7% zW&3qqh|HM25U}YX3%I#M*O>azCr+~jG@yPO2}*9pocfUbOb!M>sdee|ry&_7pxLIr zYD%Y%ZVRx7rGx1>L*qm?fo4JOH;F(!^<%J_g2i2~F5RG5I31$TW zAq9tc>tb!?1umVxA2JrS1X4dGwra04z!t^@ZTKS;paQnt;@i?<)H2=G^*zFJpp zkzp1uR%)Jdt#_>4am2TcYv$}HKRm|N5U_Qpu3}aLwRE$AYcE2rDd4IG|MI|nVt4SQ zz|{2@heYG;G?^y|E(K$?(&xa1lVkl5<%K2;(O5{O_D z@Ve}m2^{DGu7 Ys@Csp`k+%%Tb0w-qpugo9YLrAsd5xRSO=K{URa!y1<%N?E`03 zs=xcIY6i_M%YMC+Wz4jUWacvmn>!}=`#^sBfWBz&l+G;}>BXcv&JsBDaOfh$G-$A| z2%NqI#z85d?b%>+AfUPf>;UNM17ct_0j>Zz^JB31&Sn{Xq6*UP+=yYe%^5l%<|CCO zA<$S4|Ib4YX0z4W-QQOM-4qB`;0q?$ow}7ijxh{S#vD8sXB>0oePcsQ@r|F3^3*_k zOtmPLBAPup#U(mHc6y&_)efq1e_O!b;sd%kinvo4U9&Ig#>@Y+`>P}vP6c>_7}hv% zCMz%qVnNMBaMetrl|_4^5+F;CwlZ@a$dId0%^Xx0v#IDuAm37zpmbX$w~O ztsLk}zJfgna(mXGl?D3GnbOyk=3fkE>*lCzni?emS zsR)?zO-*gwmVNr(e26&ak&Xvx?GpP10D*B4z{l5teL@<1!e}&WC82pLcVxH zS3h(;4_-Xwzh1gK4H5`*sjvH!K@}(7D0%?>LJFH7=7fMNKT$vC08KlI0XfnKR$>c3 zk}$@J2sW#ayRn*B0?~zFwob5cP+W7|!fMD!&JyrnutY=X>4_~a+awA&``?CV+G$L_i(;A3ftq4hG{q-lmAvE>l#Qp2UC`|5#WBO6xr8<>2&y z3|1X|(PINU0`k`lBON-|dGS$BUoRm5Dv+XA664jpfFV5v(0x22tc#blcr|zuPyHt} zJ?EpJ=31avr1tlG_7)T%$ed$dICD2NW{Lqep=!3nFh0B)=$P*Ck^wWmHjaw`23bY` zXIJF_^Ms=uqxiN9-)d3+yTe2U+%F%R4`DFKzymz^;}eU{A|{{X{I|ur)(lz6NOh~H zW3g_F9~_Jk6`ZlunHsIH{Q0p07}=yUK)~5!V4vU361enSkJyAK^9o%f@m;Ol$QgF= zp(mGV&g2xV>SO0%wE+x@i-qYKY7dOTq8qVGHnQJx|2&>l!1l0B)FcRIfsQLQC)dig zF=Omhbc*s748i}jSw^<_nKmbuG3Nn4rbM4NbuH1dP2QjA2P=}QC1J>VnUfTwO8ui zT?qs0Atyn5yLf&ILtc7S^8RE8kB=g2k!8x#ixkTrD;y`>D^7rPg)D+m;I(FdbY=;li2k-%Xbi7>`c6X*V zMm;)4w#OzU@GMbzoU(m<0enIy4E9@rS* z+yC^H{lRq?&?(IkQ!2iPvHu%?Cm*Ff6EqD900D;!I(I}czg7-qrv=Fs3RCTGvZLK}_6J_v*$3y$Phn)t~e&9Dv^M$t!NP@o<6q z6(XonOnqHL7v7O=tY9F+1;!i*bAp*24Rsb*J~V)lh-m5uZ)L&@xVY@FbSA?80a3dO zxPYZe*@r~}Fr7w0^wx5y7BmY>ljXo6=Ff6?F|MmXp^O$MS=Oc!2((W*1H4|)^`V0fA0I|_Mnh5|US9V{A@#@^DF7Gv#!ECp3@MgWt#L{xBk zfo{x8)ynN%_OEaD*bQLxfCGzhX3-95hy3Q1e}W+k#9OL2XwTn!uw8Lv4>tcbR_jyh z8^x`YvP-75916=~Ik*#-yc_{0ztRfdtu?G<0r%j1fW9gAX!Y~zGfnAGV+UnJX~IHa z>_O2(>lvFkuBnOD!Z0%NfaIQ255y!fXL8zx&)*X%R`59xooLS+^ATgch^V54AZXdC zY@n(C_0tohkgQLDCtjBrJ@MfOI@|o1LI$E8P><}Xw64p9GVu9x#uh_ijd>+71K6b4 zVcHA90QZm5u1k@zJ&vgWgqy#3$XOPu%dxu_rfct8)Mt_EZ3!5$R%$~gj&kYhY1w_( z@q>Z4k1i09WYdW>d*+zVPxbvh*u*>)RMH!Cr+OHGY_?@FL8m|hc1XZX535&dbHotK zTe5+!%B(I`J7U=iVP=j4x(e5_Fv?E9bM^P!_WDpE|msd9Q3pQX#JpuhX#el@)e zFge*PnfA*Of&p`wMNKK#z8|s!R9gi$6gBMUTf*Y@Z3P3IF}klncZrE}0=Ppj-3g2w zwwoqR2cX4>0h~zMljiw1!V@LUbAu;8%{kLQ=ZL)`|368|9<$M zhj#EZYXi6g=adr+2GA4Ca+?gnt2)63K}gw|={O~botZ)+Jiu;htz$%6Wcp#b(Vo^`u28Ub zAV#GH1pH&kFZ&|>p@i)j{_hv@i2Lr37=q{A-+LJOU9*Vz8^X4XDT%n=8p`;)47M3 znR&e_;A>~VhIzu4Eq7&rf_b)zdW!W$nSf&8O$u_~#8;AoFaADVvFF8x;2MgMWHWH&5BZiDZv6y-&jXBfl4rmSQ8m**c%bAKr`x6GyKGh(1h zl3jJ=i=Tk=ezAh3&^lSkYB`b?4IWJw0DNQx>P3L}da~yz4+U)Odu&PD7`nh2Fad+? zI^a}4@dVY*n->rd`t_q{?&*WfVRG_Xu5B*uKnwtzh`l1f)o(sUHN+=YH>`>~1j7Qe zlHn3?0>J05kHuS@99;jIk4_&9qRlZ2Z9HlK#7+PV^W;lhZCf)~i5C+Ppr|coQUG~p zf4K*OcOn<4o8CYBVgXMD>@HA0q6N*?lfdu+U7+lPI$K#QH;+YE6?ez5j+w{>pfpg( zPO#M=fqyaN4la8Wh@owxUjZkNoM4r*oa?^%vFB#8F}J=Aw(}2yt-zC#UO}xz?_9;L zy6RR=LthT&05Bg>t$y&H>BA`j?IK2Qy(0=sYpw$<{vW$Rlrm2NHbbDshn=&+yH|!x z#c3|bK*98WW}y9dFL5E)pOp=I7y64i#Vn!U!q>O*48ZN>kt{~=po}RW2ybtCalM#% z{(ZVs4{#zYm^yS%C+OPU<+%_#p@Z6MF^JsbXW9tK{eXi>V5@q-fgjBW$Y zJO`%!><)#}KMv;p@9z}o0H>5>X5H3U!~%ZiryFeAk=67cz(ur%^X?HPhSheilM4iR z_SLQHC;K7)?Zh$g7;Xb7;OrmfnP51xE zbOdsD0od)&GPkEHHoO1Ah~TOP^AKe$JqL5i0Ba{hz24XQm-iWx=}T|P#v4yX1Wpa~ za~kxp=cv?kuQKt9WH<0ePz31CNp;Z%5-gqnIh3uSj71-CZ*LzHCBr=ATIBh&hrxgm z29me9Mkb5dp#z;in@k6+RX>ip#jvI>%fZg#c|dSN-} zOjFB8_s$*&FH455Gg18-2#?KVNDQ!sfHj7po-xcDmoe`b0!G6H(h04;(^Iynr#Gl0 z)?)CzbklN_^HI}h!K6No5SfU<1WU;P;}7Uerze@$8#4IdGX)Y9t%p2#;a$TZO2J1D z@_Gzwx%%olYJ-e8z$)TdxJSKSv|0T}W=R5b9B_ejzv$z-Tb4#-12`Kc(5zKYI>KNd z;1=GJc=SgsPeCy~>|^f!`gz^Mm?8hrf0SZBmLhQDb&=o!qUp3P4wWGn1~AY7XHh6B zcman!#;~TVw3{BT0}btNv(vDg@($Vxx;Z6`H0uh24#qr(%p6Nr)# zhzD_te+d|qvJhi1YU4Lh5F_LW{D4EQV`_yW_)1)>gOv1t(q z=^PCMUn@p%X3{K((;w!!f&K#SGiTy8gV`Sddb7$A0$vZ&t8Zs`|M1Yy^;Eoc;w5Uia@aW$CHO z{@{h8r5FYux-*-*aVfy$UNg^Y;M~b{L+4}xE)j54vk95U8L7l|^b+6_0nQi!<+RWl z&LKKbTN8NF877Wd=k>ak7|>SWxcUm1c|mBsmd|}!JJ_-Wb`oKOrDFcIR$4}I8&W97#I|8AlrmbV4CAQ-p0ok3$7=^T2Zc{Jlp~AzQ>oPuzGRUk2c;Y4ug&hGj~$ zoXf{@4v4Drwm%%hYiwxh##78&WnUTH8<_tPsS>i z?{r4n5JW{An1Crv)9MW=!|MJHoeK=`U0u~N!Ak)pG_v*>z&%zl12u-W&(NYp(?SN$ z_@is}eaG03kNnYWyG%_1&+Py$G3$Wdl|wv@vjeOiG;s4({fLbL{m*l>gJwYn`j$A% zV0Qsp>ta03yJA9&t7>YYbb;1^io^)M_75+d)aP

Jz;faSQ<~= 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

Mm!G!}p=CiULwcWBK77-5_E7lV zm_XdZo(`G;V%-vGBw1~qC3AV$bU!4%7ST~^{!WUOE!JQu{R7HAPo^S0*0z{T`heNdQc zftAr!0`*^mw6>aWuc-a>b!l=gK!pg4H$uw=>F!!~PDURT@XhREc64jjPDH!z-WhA~ zDlXwKLPL#9XifyX{Y@}Vg|)~+llpAh#RFFZ)^%gmXB?l~#+2P_9bzeMcV8Br9%1y4 z;(tG`^EzMk&q_EH(2ZNliXY_z!|gd!x^e@Rg#))GGiQOzCq;s<0`*Ra08h3p1D{1l z(;K8x^Ok_-OgfmZDZYK=!8?$G1tL1k&uc*E_Lw*SPJm(_E7zAm^O7-ESu_9*!X#CD z#A@*mzFAhflJitw7qLFvKESFd$g?y{*{C5|$PEXwaz8fjX14}xkMVE~fxDH}Q$rW= zGL%=T_9e#&#{|GiS3@U8lelC=08>sx;c0u#*wU$11 z{6H}p&0H8qL|Z-f1gP<4t3P^AOzxqMCD1sVt>?abYyZGHA9r1F@f1(MrPMRB9t!md z=FbQ$3KIwRsAIWZwICqJ{OZS7e0PVO0({+)t>8stz&x7837rEh)E~Z-c30Ee%W}uq z8V?fGcba$QnaE?{cA1|^l0Ng-u0iPLgZt1W%&$S(-j;PG{gqv@AkO4MkVu39l zd>ZKDa|;3vlM&|U9O*S+Rgy^XB1_9@&KzQpERR*kNze2P$4yLG$bmdj< zPcV22hU0GzTh`6c;>@p2StcmMC$sGjT`LsE$NN(y4j5lCibaaPTeyCqZe=1`TxeKT z%Gya^JbAnTdOZU$fibqL8VvA?0G~C)i7==#xK<0bdXQY6p0;bl*AFE>?PxI|pp;ahbmcN^2!UB!5#TLyk!aPz46L6v54-ko_Q= z1FX>7C+2!i@!l(7jcu%M|NZ>8rK4k7(>0oTcewKEY)-u{oIcP483^-00()4`$d|1Z z!cuqRJuM$I(7Nz_Fh{eSF6HHFK)_lN!r2G(I{Fw5fDh!^8*uvAlD+;2=C6gGfHsH0 z4$LpNY+9KZc7vdOE2XC-5wfAg{IBWmk5O_^WiGr!`C zj%`nH7Yi%E%wKpQsS9>lnx*hR9{>ZT88rOT95J*&Y~o}Zxhp^`qe@S;%g0XBVwXa$4w z2(=6`(89LTr43>$)2Abyt{7P+xDOUaUOQQkJBG=ZVqOhnFmknfwoC+H2r6pnT3ax; z8(J``%B>Q8{Qx(LC+@y- z5}YR?0i1JMM?5$mQUI=ovl^H*p0_ce&j*$bYL>Rw%`@>n$4%yq*xmHm8>joBgxkS5 jjD?kJidL;%yq#5 From 9230fe3fd4089bdfa8e9bd5d10033994af8198e3 Mon Sep 17 00:00:00 2001 From: Thomas Bergmueller Date: Sat, 20 May 2023 23:26:55 +0200 Subject: [PATCH 10/97] Add EIP: Asset-bound Non-Fungible Tokens Merged by EIP-Bot. --- EIPS/eip-6956.md | 652 ++++++++++++++++++ assets/eip-6956/.gitignore | 8 + assets/eip-6956/LICENSE.md | 21 + assets/eip-6956/README.md | 12 + assets/eip-6956/contracts/ERC6956.sol | 491 +++++++++++++ assets/eip-6956/contracts/ERC6956Full.sol | 206 ++++++ assets/eip-6956/contracts/IERC6956.sol | 165 +++++ .../contracts/IERC6956AttestationLimited.sol | 40 ++ .../eip-6956/contracts/IERC6956Floatable.sol | 43 ++ .../contracts/IERC6956ValidAnchors.sol | 28 + assets/eip-6956/img/erc6956_concept.svg | 16 + assets/eip-6956/test/ERC6956.ts | 355 ++++++++++ assets/eip-6956/test/ERC6956Full.ts | 445 ++++++++++++ assets/eip-6956/test/commons.ts | 77 +++ 14 files changed, 2559 insertions(+) create mode 100644 EIPS/eip-6956.md create mode 100644 assets/eip-6956/.gitignore create mode 100644 assets/eip-6956/LICENSE.md create mode 100644 assets/eip-6956/README.md create mode 100644 assets/eip-6956/contracts/ERC6956.sol create mode 100644 assets/eip-6956/contracts/ERC6956Full.sol create mode 100644 assets/eip-6956/contracts/IERC6956.sol create mode 100644 assets/eip-6956/contracts/IERC6956AttestationLimited.sol create mode 100644 assets/eip-6956/contracts/IERC6956Floatable.sol create mode 100644 assets/eip-6956/contracts/IERC6956ValidAnchors.sol create mode 100644 assets/eip-6956/img/erc6956_concept.svg create mode 100644 assets/eip-6956/test/ERC6956.ts create mode 100644 assets/eip-6956/test/ERC6956Full.ts create mode 100644 assets/eip-6956/test/commons.ts diff --git a/EIPS/eip-6956.md b/EIPS/eip-6956.md new file mode 100644 index 00000000000000..21005fd96a0d99 --- /dev/null +++ b/EIPS/eip-6956.md @@ -0,0 +1,652 @@ +--- +eip: 6956 +title: Asset-bound Non-Fungible Tokens +description: Asset-bound NFTs anchor a token 1-1 to an asset and operations are authorized through oracle-attestation of control over the asset +author: Thomas Bergmueller (@tbergmueller), Lukas Meyer (@ibex-technology) +discussions-to: https://ethereum-magicians.org/t/erc-6956-asset-bound-non-fungible-tokens/14056 +status: Draft +type: Standards Track +category: ERC +created: 2023-04-29 +requires: 165, 721 +--- + +## Abstract + +This standard allows integrating physical and digital ASSETS without signing capabilities into dApps/web3 by extending [ERC-721](eip-721.md). + +An ASSET, for example a physical object, is marked with a uniquely identifiable ANCHOR. The ANCHOR is bound in a secure and inseperable manner 1:1 to an NFT on-chain - over the complete life cylce of the ASSET. + +Through an ATTESTATION, an ORACLE testifies that a particular ASSET associated with an ANCHOR has been CONTROLLED when defining the `to`-address for certain operations (mint, transfer, burn, approve, ...). The ORACLE signs the ATTESTATION off-chain. The operations are authorized through verifying on-chain that ATTESTATION has been signed by a trusted ORACLE. Note that authorization is solely provided through the ATTESTATION, or in other words, through PROOF-OF-CONTROL over the ASSET. The controller of the ASSET is guaranteed to be the controller of the Asset-Bound NFT. + +The proposed ATTESTATION-authorized operations such as `transferAnchor(attestation)` are permissionless, meaning neither the current owner (`from`-address) nor the receiver (`to`-address) need to sign. + +Figure 1 shows the data flow of an ASSET-BOUND NFT transfer. The simplified system is utilizing a smartphone as user-device to interact with a physical ASSET and specify the `to`-address. + +![Figure 1: Sample system](../assets/eip-6956/img/erc6956_concept.svg) + +## Motivation + +The well-known [ERC-721](eip-721.md) establishes that NFTs may represent "ownership over physical properties [...] as well as digital collectables and even more abstract things such as responsibilities" - in a broader sense, we will refer to all those things as ASSETS, which typically have value to people. + +### The Problem + +ERC-721 outlines that "NFTs can represent ownership over digital or physical assets". ERC-721 excels in this task when used to represent ownership over digital, on-chain assets, that is when the asset is "holding a token of a specific contract" or the asset is an NFT's metadata. Today, people commonly treat an NFT's metadata (images, traits, ...) as asset-class, with their rarity often directly defining the value of an invididual NFT. + +However, we see integrity issues not solveable with ERC-721, primarily when NFTS are used to represent off-chain ASSETS ("ownership over physical products", "digital collectables", "in-game assets", "responsibilities", ...). Over an ASSET's lifecycle, the ASSET's ownership and posession state changes multiple, sometimes thousands, of times. Each of those state changes may result in shifting obligations and privileges for the involved parties. Therefore tokenization of an ASSET *without* enforcably anchoring the ASSET's associated obligation and properties to the token is not complete. Nowadays, off-chain ASSETs are often "anchored" through adding an ASSET-identifier to a NFT's metadata. + +**NFT-ASSET integrity:** Contrary to a popular belief among NFT-investors, metadata is data that is, more often than not, mutable and off-chain. Therefore the link between an ASSET through an asset-identifier stored in mutable metadata, which is only linked to the NFT through tokenURI, can be considered weak at best. + +Approaches to ensure integrity between metadata (=reference to ASSET) and a token exist. This is most commonly achieved by storing metadata-hashes onchain. Additional problems arise through hashing; For many applications, metadata (besides the asset-identifier) should be update-able. Therefore making metadata immutable through storing a hash is problematic. Further the offchain metadata-resource specified via tokenURI must be made available until eternity, which has historically been subject to failure (IPFS bucket disappears, central tokenURI-provider has downtimes, ...) + +**Off-chain-on-chain-integrity:** There are approaches where off-chain ASSET ownership is enforced or conditioned through having ownership over the on-chain representation. A common approach is to burn tokens in order to get the (physical) ASSET, as the integrity cannot be maintained. However, there are no approaches known, where on-chain ownership is enforced through having off-chain ownership of the ASSET. Especially when the current owner of an NFT is incooperative or incapacitated, integrity typically fail due to lack of signing-power from the current NFT owner. + +Metadata is off-chain. The majority of implementations completely neglect that metadata is mutable. More serious implementations strive to preserve integrity by for example hashing metadata and storing the hash mapped to the tokenId on-chain. However, this approach does not allow for use-case, where metadata besides the asset-identifier, for example traits, "hours played", ... shall be mutable or evolvable. + +### ASSET-BOUND NON-FUNGIBLE TOKENS + +In this standard we propose to + +1. Elevate the concept of representing physical or digital off-chain ASSETS by on-chain ANCHORING the ASSET inseperably into an NFT. +1. Being off-chain in control over the ASSET must mean being on-chain in control over the anchored NFT. +1. (Related) A change in off-chain ownership over the ASSET inevitably should be reflected by a change in on-chain ownership over the anchored NFT, even if the current owner is uncooperative or incapacitated. + +As 2. and 3. indicate, the control/ownership/posession of the ASSET should be the single source of truth, *not* the posession of an NFT. Hence, we propose an ASSET-BOUND NFT, where off-chain CONTROL over the ASSET enforces on-chain CONTROL over the anchored NFT. +Also the proposed ASSET-BOUND NFTs allow to anchor digital metadata inseperably to the ASSET. When the ASSET is a physical asset, this allows to design "phygitals" in their purest form, namely creating a "phygital" asset with a physical and digital component that are inseperable. Note that metadata itself can still change, for instance for "Evolvable NFT". + +We propose to complement the existing transfer control mechanisms of a token according to ERC-721, `Approval` according to [ERC-721](eip-721.md) and `Permit` according to [ERC-4494](eip-4494.md), by another mechanism; ATTESTATION. An ATTESTATION is signed off-chain by the ORACLE and must only be issued when the ORACLE verified that whoever specifies the `to` address or beneficiary address has simultanously been in control over the ASSET. The `to` address of an attestation may be used for Transfers as well as for approvals and other authorizations. + +Transactions authorized via ATTESTATION shall not require signature or approval from neither the `from` (donor, owner, sender) nor `to` (beneficiary, receiver) account, namely making transfers permissionless. Ideally, transaction are signed independent from the ORACLE as well, allowing different scenarios in terms of gas-fees. + +Lastly we want to mention two major side-benefits of using the proposed standard, which drastically lowers hurdles in onboarding web2 users and increase their security; + +- New users, e.g `0xaa...aa` (Fig.1), can use gasless wallets, hence participate in Web3/dApps/DeFi and mint+transfer tokens without ever owning crypto currency. Gas-fees may be paid through a third-party account `0x..gasPayer` (Fig.1). The gas is typically covered by the ASSET issuer, who signs `transferAnchor()` transactions +- Users cannot get scammed. Common attacks (for example wallet-drainer scams) are no longer possible or easily reverted, since only the anchored NFT can be stolen, not the ASSET itself. Also mishaps like transferring the NFT to the wrong account, losing access to an account etc can be mitigated by executing another `transferAnchor()` transaction based on proofing control over the ASSET, namely the physical object. + +### Related work + +We primarily aim to onboard physical or digital ASSETS into dApps, which do not signing-capabilities of their own (contrary to [ERC-5791](eip-5791.md) approach using crypto-chip based solutions). Note that we do not see any restrictions preventing to use ERC-5791 in combination with this standard, as the address of the crypto-chip qualifies as an ANCHOR. + + + +## Specification + +The key words "MUST", "MUST NOT", "REQUIRED", "SHALL", "SHALL NOT", "SHOULD", "SHOULD NOT", "RECOMMENDED", "NOT RECOMMENDED", "MAY", and "OPTIONAL" in this document are to be interpreted as described in RFC 2119 and RFC 8174. + +### Definitions (alphabetical) + +- **ANCHOR** uniquely identifies the off-chain ASSET, whether it is physical or digital. +- **ANCHOR-TECHNOLOGY** MUST ensure that + - the ANCHOR is inseperable from the ASSET (physically or otherwise) + - an ORACLE can establish PROOF-OF-CONTROL over the ASSET beyond reasonable doubt + - For physical ASSETS, additional [Security considerations for Physical Assets](#security-considerations-for-physical-assets) MUST be taken into account + +- **ASSET** refers to the "thing", being it physical or digital, which is represented through NFTs according to the proposed standard. Typically, an ASSET does not have signing capabilities. + +- **ATTESTATION** is the confirmation that PROOF OF CONTROL was established when specifying the `to` (receiver, beneficiary) address. + +- **PROOF-OF-CONTROL** over the ASSET means owning or otherwise controlling an ASSET. How Proof of Control is established depends on the ASSET and may be implemented using technical, legal or other means. For physical ASSETS, CONTROL is typically verified by proofing physical proximity between a physical ASSET and an input device (for example a smartphone) used to specify the `to` address. + +- An **ORACLE** has signing capabilities. MUST be able to sign ATTESTATIONS off-chain in a way such that signatures can be verified on-chain. + + +### Base Interface + +Every contract compliant to this standard MUST implement the [the proposed standard interface](../assets/eip-6956/contracts/IERC6956.sol), [ERC-721](eip-721.md) and [ERC-165](eip-165.md) interfaces and is subject to [Caveats](#caveats-for-base-interface) below: + +```solidity +// SPDX-License-Identifier: MIT OR CC0-1.0 +pragma solidity ^0.8.18; + +/** + * @title IERC6956 Asset-Bound Non-Fungible Tokens + * @notice Asset-bound Non-Fungible Tokens anchor a token 1:1 to a (physical or digital) asset and token transfers are authorized through attestation of control over the asset + * @dev See https://eips.ethereum.org/EIPS/eip-6956 + * Note: The ERC-165 identifier for this interface is 0xa9cf7635 + */ +interface IERC6956 { + + /** @dev Authorization, typically mapped to authorizationMaps, where each bit indicates whether a particular ERC6956Role is authorized + * Typically used in constructor (hardcoded or params) to set burnAuthorization and approveAuthorization + * Also used in optional updateBurnAuthorization, updateApproveAuthorization, I + */ + enum Authorization { + NONE, // = 0, // None of the above + OWNER, // = (1<0) of the anchored token + */ + event AnchorApproval(address indexed owner, address approved, bytes32 indexed anchor, uint256 tokenId); + + /** + * @notice This emits when the ownership of any anchored NFT changes by any mechanism + * @dev This emits together with tokenId-based ERC-721.Transfer and provides an anchor-perspective on transfers + * @param from The previous owner, address(0) indicate there was none. + * @param to The new owner, address(0) indicates the token is burned + * @param anchor The anchor which is bound to tokenId + * @param tokenId ID (>0) of the anchored token + */ + event AnchorTransfer(address indexed from, address indexed to, bytes32 indexed anchor, uint256 tokenId); + /** + * @notice This emits when an attestation has been used indicating no second attestation with the same attestationHash will be accepted + * @param to The to address specified in the attestation + * @param anchor The anchor specificed in the attestation + * @param attestationHash The hash of the attestation, see ERC-6956 for details + * @param totalUsedAttestationsForAnchor The total number of attestations already used for the particular anchor + */ + event AttestationUse(address indexed to, bytes32 indexed anchor, bytes32 indexed attestationHash, uint256 totalUsedAttestationsForAnchor); + + /** + * @notice This emits when the trust-status of an oracle changes. + * @dev Trusted oracles must explicitely be specified. + * If the last event for a particular oracle-address indicates it's trusted, attestations from this oracle are valid. + * @param oracle Address of the oracle signing attestations + * @param trusted indicating whether this address is trusted (true). Use (false) to no longer trust from an oracle. + */ + event OracleUpdate(address indexed oracle, bool indexed trusted); + + /** + * @notice Returns the 1:1 mapped anchor for a tokenId + * @param tokenId ID (>0) of the anchored token + * @return anchor The anchor bound to tokenId, 0x0 if tokenId does not represent an anchor + */ + function anchorByToken(uint256 tokenId) external view returns (bytes32 anchor); + /** + * @notice Returns the ID of the 1:1 mapped token of an anchor. + * @param anchor The anchor (>0x0) + * @return tokenId ID of the anchored token, 0 if no anchored token exists + */ + function tokenByAnchor(bytes32 anchor) external view returns (uint256 tokenId); + + /** + * @notice The number of attestations already used to modify the state of an anchor or its bound tokens + * @param anchor The anchor(>0) + * @return attestationUses The number of attestation uses for a particular anchor, 0 if anchor is invalid. + */ + function attestationsUsedByAnchor(bytes32 anchor) view external returns (uint256 attestationUses); + /** + * @notice Decodes and returns to-address, anchor and the attestation hash, if the attestation is valid + * @dev MUST throw when + * - Attestation has already been used (an AttestationUse-Event with matching attestationHash was emitted) + * - Attestation is not signed by trusted oracle (the last OracleUpdate-Event for the signer-address does not indicate trust) + * - Attestation is not valid yet or expired + * - [if IERC6956AttestationLimited is implemented] attestationUsagesLeft(attestation.anchor) <= 0 + * - [if IERC6956ValidAnchors is implemented] validAnchors(data) does not return true. + * @param attestation The attestation subject to the format specified in ERC-6956 + * @param data Optional additional data, may contain proof as the first abi-encoded argument when IERC6956ValidAnchors is implemented + * @return to Address where the ownership of an anchored token or approval shall be changed to + * @return anchor The anchor (>0) + * @return attestationHash The attestation hash computed on-chain as `keccak256(attestation)` + */ + function decodeAttestationIfValid(bytes memory attestation, bytes memory data) external view returns (address to, bytes32 anchor, bytes32 attestationHash); + + /** + * @notice Indicates whether any of ASSET, OWNER, ISSUER is authorized to burn + */ + function burnAuthorization() external view returns(Authorization burnAuth); + + /** + * @notice Indicates whether any of ASSET, OWNER, ISSUER is authorized to approve + */ + function approveAuthorization() external view returns(Authorization approveAuth); + + /** + * @notice Corresponds to transferAnchor(bytes,bytes) without additional data + * @param attestation Attestation, refer ERC-6956 for details + */ + function transferAnchor(bytes memory attestation) external; + + /** + * @notice Changes the ownership of an NFT mapped to attestation.anchor to attestation.to address. + * @dev Permissionless, i.e. anybody invoke and sign a transaction. The transfer is authorized through the oracle-signed attestation. + * - Uses decodeAttestationIfValid() + * - When using a centralized "gas-payer" recommended to implement IERC6956AttestationLimited. + * - Matches the behavior of ERC-721.safeTransferFrom(ownerOf[tokenByAnchor(attestation.anchor)], attestation.to, tokenByAnchor(attestation.anchor), ..) and mint an NFT if `tokenByAnchor(anchor)==0`. + * - Throws when attestation.to == ownerOf(tokenByAnchor(attestation.anchor)) + * - Emits AnchorTransfer + * + * @param attestation Attestation, refer EIP-6956 for details + * @param data Additional data, may be used for additional transfer-conditions, may be sent partly or in full in a call to safeTransferFrom + * + */ + function transferAnchor(bytes memory attestation, bytes memory data) external; + + /** + * @notice Corresponds to approveAnchor(bytes,bytes) without additional data + * @param attestation Attestation, refer ERC-6956 for details + */ + function approveAnchor(bytes memory attestation) external; + + /** + * @notice Approves attestation.to the token bound to attestation.anchor. . + * @dev Permissionless, i.e. anybody invoke and sign a transaction. The transfer is authorized through the oracle-signed attestation. + * - Uses decodeAttestationIfValid() + * - When using a centralized "gas-payer" recommended to implement IERC6956AttestationLimited. + * - Matches the behavior of ERC-721.approve(attestation.to, tokenByAnchor(attestation.anchor)). + * - Throws when ASSET is not authorized to approve. + * + * @param attestation Attestation, refer EIP-6956 for details + */ + function approveAnchor(bytes memory attestation, bytes memory data) external; + + /** + * @notice Corresponds to burnAnchor(bytes,bytes) without additional data + * @param attestation Attestation, refer ERC-6956 for details + */ + function burnAnchor(bytes memory attestation) external; + + /** + * @notice Burns the token mapped to attestation.anchor. Uses ERC-721._burn. + * @dev Permissionless, i.e. anybody invoke and sign a transaction. The transfer is authorized through the oracle-signed attestation. + * - Uses decodeAttestationIfValid() + * - When using a centralized "gas-payer" recommended to implement IERC6956AttestationLimited. + * - Throws when ASSET is not authorized to burn + * + * @param attestation Attestation, refer EIP-6956 for details + */ + function burnAnchor(bytes memory attestation, bytes memory data) external; +} +``` + +#### Caveats for Base Interface + +- MUST implement ERC-721 and ERC-165 +- MUST have bidirectional mapping `tokenByAnchor(anchor)` and `anchorByToken(tokenId)`. This implies that a maximum of one token per ANCHOR exists. +- MUST have a mechnism to determine whether an ANCHOR is valid for the contract. RECOMMENDED to implement the proposed [ValidAnchors-Interface](#validanchors-interface) +- MUST implement `decodeAttestationIfValid(attestation, data)` to validate and decode ATTESTATIONS as specified in the [ORACLE-Section](#oracle) + - MUST return `attestation.to`, `attestation.anchor`, `attestation.attestationHash`. + - MUST not modify state, as this function can be used to check an ATTESTATION's validity without redeeming it. + - MUST throw when + - ATTESTATION is not signed from a trusted ORACLE. + - ATTESTATION has expired or is not valid yet + - ATTESTATION has not been reedemed. "Redeemed" being defined in at least one state-changing operation has been authorized through a particular ATTESTATION. + - If [AttestationLimited-Interface](#attestationlimited-interface) implemented: When `attestationUsagesLeft(attestation.to) <= 0` + - If [ValidAnchors-Interface](#validanchors-interface) implemented: When `validAnchor() != true`. + - If [ValidAnchors-Interface](#validanchors-interface) implemented: MUST call `validAnchor(attestation.to, abi.decode('bytes32[]',data))`, meaning the first abi-encoded value in the `data` parameter corresponds to `proof`. +- MUST have a ANCHOR-RELEASED mechanism, indicating whether the anchored NFT is released/transferable. + - Any ANCHOR MUST NOT be released by default. +- MUST extend any ERC-721 token transfer mechanism by: + - MUST throw when `ANCHOR` is not released. + - MUST throw when batchSize > 1, namely no batch transfers are supported with this contract. + - MUST emit `AnchorTransfer(from, to, anchorByToken[tokenId], tokenId)` + +- MUST implement `attestationsUsedByAnchor(anchor)`, returning how many attestations have already been used for a specific anchor. + +- MUST implement the state-changing `transferAnchor(..)`, `burnAnchor(..)`, `approveAnchor(..)` and OPTIONAL MAY implement additional state-changing operations which + - MUST use the `decodeAttestationIfValid()` to determine `to`, `anchor` and `attestationHash` + - MUST redeem each ATTESTATION in the same transaction as any authorized state-changing operation. RECOMMENDED by storing each used `attestationHash` + - MUST increment `attestationsUsedByAnchor[anchor]` + - MUST emit `AttestationUsed` + - `transferAnchor(attestation)` MUST behave and emit events like `ERC-721.safeTransferFrom(ownerOf[tokenByAnchor(attestation.anchor)], attestation.to, tokenByAnchor(attestation.anchor), ..)` and mint an NFT if `tokenByAnchor(anchor)==0`. + +- RECOMMENDED to implement `tokenURI(tokenId)` to return an anchorBased-URI, namely `baseURI/anchor`. This anchoring metadata to ASSET. Before an anchor is not used for the first time, the ANCHOR's mapping to tokenId is unknown. Hence, using the anchor in instead of the tokenId is preferred. + + +### ORACLE + +- MUST provide an ATTESTATION. Below we define the format how an ORACLE testifies that the `to` address of a transfer has been specified under the pre-condition of PROOF-OF-CONTROL associated with the particular ANCHOR being transferred to `to`. +- The ATTESTATION MUST abi-encode the following: + - `to`, MUST be address, specifying the beneficiary, for example the to-address, approved account etc. + - ANCHOR, aka the ASSET identifier, MUST have a 1:1 relation to the ASSET + - `attestationTime`, UTC seconds, time when attestation was signed by ORACLE, + - `validStartTime` UTC seconds, start time of the ATTESTATION's validity timespan + - `validEndTime`, UTC seconds, end time of the ATTESTATION's validity timespan + - `signature`, ETH-signature (65 bytes). Output of an ORACLE signing the `attestationHash = keccak256([to, anchor, attestationTime, validStartTime, validEndTime])`. +- How PROOF-OF-CONTROL is establish in detail through an ANCHOR-TECHNOLOGY is not subject to this standard. Some ORACLE requirements and ANCHOR-TECHNOLOGY requirements when using PHYSICAL ASSETS are outlined in [Security considerations for Physical Assets](#security-considerations-for-physical-assets). + +Minimal Typescript sample to generate an ATTESTATION using ethers library: + +```typescript +export async function minimalAttestationSample() { + // #################################### ACCOUNTS + // Alice shall get the NFT, oracle signs the attestation off-chain + // Oracle needs to be a trusted Oracle of the smart-contract that shall accept the generated attestation + const [alice, oracle] = await ethers.getSigners(); + + // #################################### CREATE AN ATTESTATION + const to = alice.address; + const anchor = '0x4cc52563699fb1e3333b8aab3ecf016f8fd084e6fc48edf8603d83d4c5b97536' + + const attestationTime = Math.floor(Date.now() / 1000.0); // Now in seconds UTC + const validStartTime = 0; + const validEndTime = attestationTime + 15 * 60; // 15 minutes valid from attestation + + const messageHash = ethers.utils.solidityKeccak256( + ["address", "bytes32", "uint256", 'uint256', "uint256"], + [to, anchor, attestationTime, validStartTime, validEndTime] + ); + const sig = await signer.signMessage(ethers.utils.arrayify(messageHash)); + + return ethers.utils.defaultAbiCoder.encode( + ['address', 'bytes32', 'uint256', 'uint256', 'uint256', 'bytes'], + [to, anchor, attestationTime, validStartTime, validEndTime, sig] + ); +} +``` + +### AttestationLimited-Interface + +Every contract compliant to this standard MAY implement the [proposed AttestationLimited interface](../assets/eip-6956/contracts/IERC6956AttestationLimited.sol) and is subject to [Caveats](#caveats-for-attestationlimited-interface) below: + +```solidity +// SPDX-License-Identifier: MIT OR CC0-1.0 +pragma solidity ^0.8.18; +import "./IERC6956.sol"; + +/** + * @title Attestation-limited Asset-Bound NFT + * @dev See https://eips.ethereum.org/EIPS/eip-6956 + * Note: The ERC-165 identifier for this interface is 0x75a2e933 + */ +interface IERC6956AttestationLimited is IERC6956 { + enum AttestationLimitPolicy { + IMMUTABLE, + INCREASE_ONLY, + DECREASE_ONLY, + FLEXIBLE + } + + /// @notice Returns the attestation limit for a particular anchor + /// @dev MUST return the global attestation limit per default + /// and override the global attestation limit in case an anchor-based limit is set + function attestationLimit(bytes32 anchor) external view returns (uint256 limit); + + /// @notice Returns number of attestations left for a particular anchor + /// @dev Is computed by comparing the attestationsUsedByAnchor(anchor) and the current attestation limit + /// (current limited emitted via GlobalAttestationLimitUpdate or AttestationLimt events) + function attestationUsagesLeft(bytes32 anchor) external view returns (uint256 nrTransfersLeft); + + /// @notice Indicates the policy, in which direction attestation limits can be updated (globally or per anchor) + function attestationLimitPolicy() external view returns (AttestationLimitPolicy policy); + + /// @notice This emits when the global attestation limt is updated + event GlobalAttestationLimitUpdate(uint256 indexed transferLimit, address updatedBy); + + /// @notice This emits when an anchor-specific attestation limit is updated + event AttestationLimitUpdate(bytes32 indexed anchor, uint256 indexed tokenId, uint256 indexed transferLimit, address updatedBy); + + /// @dev This emits in the transaction, where attestationUsagesLeft becomes 0 + event AttestationLimitReached(bytes32 indexed anchor, uint256 indexed tokenId, uint256 indexed transferLimit); +} +``` + +#### Caveats for AttestationLimited-Interface + +- MUST extend the proposed standard interface +- MUST define one of the above listed AttestationLimit update policies and expose it via `attestationLimitPolicy()` + - MUST support different update modes, namely FIXED, INCREASE_ONLY, DECREASE_ONLY, FLEXIBLE (= INCREASABLE and DECREASABLE) + - RECOMMENDED to have a global transfer limit, which can be overwritten on a token-basis (when `attestationLimitPolicy() != FIXED`) +- MUST implement `attestationLimit(anchor)`, specifying how often an ANCHOR can be transferred in total. Changes in the return value MUST reflect the AttestationLimit-Policy. +- MUST implement `attestationUsagesLeft(anchor)`, returning the number of usages left (namely `attestationLimit(anchor)-attestationsUsedByAnchor[anchor]`) for a particular anchor + + +### Floatable-Interface + +Every contract compliant to this extension MAY implement the proposed [Floatable interface](../assets/eip-6956/contracts/IERC6956Floatable.sol) and is subject to [Caveats](#caveats-for-floatable-interface) below: + +```solidity +// SPDX-License-Identifier: MIT OR CC0-1.0 +pragma solidity ^0.8.18; +import "./IERC6956.sol"; + +/** + * @title Floatable Asset-Bound NFT + * @notice A floatable Asset-Bound NFT can (temporarily) be transferred without attestation + * @dev See https://eips.ethereum.org/EIPS/eip-6956 + * Note: The ERC-165 identifier for this interface is 0xf82773f7 + */ +interface IERC6956Floatable is IERC6956 { + enum FloatState { + Default, // 0, inherits from floatAll + Floating, // 1 + Anchored // 2 + } + + /// @notice Indicates that an anchor-specific floating state changed + event FloatingStateChange(bytes32 indexed anchor, uint256 indexed tokenId, FloatState isFloating, address operator); + /// @notice Emits when FloatingAuthorization is changed. + event FloatingAuthorizationChange(Authorization startAuthorization, Authorization stopAuthorization, address maintainer); + /// @notice Emits, when the default floating state is changed + event FloatingAllStateChange(bool areFloating, address operator); + + /// @notice Indicates whether an anchored token is floating, namely can be transferred without attestation + function floating(bytes32 anchor) external view returns (bool); + + /// @notice Indicates whether any of OWNER, ISSUER, (ASSET) is allowed to start floating + function floatStartAuthorization() external view returns (Authorization canStartFloating); + + /// @notice Indicates whether any of OWNER, ISSUER, (ASSET) is allowed to stop floating + function floatStopAuthorization() external view returns (Authorization canStartFloating); + + /** + * @notice Allows to override or reset to floatAll-behavior per anchor + * @dev Must throw when newState == Floating and floatStartAuthorization does not authorize msg.sender + * @dev Must throw when newState == Anchored and floatStopAuthorization does not authorize msg.sender + * @param anchor The anchor, whose anchored token shall override default behavior + * @param newState Override-State. If set to Default, the anchor will behave like floatAll + */ + function float(bytes32 anchor, FloatState newState) external; +} +``` + + +#### Caveats for Floatable-Interface + +If `floating(anchor)` returns true, the token identified by `tokenByAnchor(anchor)` MUST be transferable without attestation, typically authorized via `ERC721.isApprovedOrOwner(msg.sender, tokenId)` + +### ValidAnchors-Interface + +Every contract compliant to this extension MAY implement the proposed [ValidAnchors interface](../assets/eip-6956/contracts/IERC6956ValidAnchors.sol) and is subject to [Caveats](#caveats-for-validanchors-interface) below: + +```solidity +// SPDX-License-Identifier: MIT OR CC0-1.0 +pragma solidity ^0.8.18; +import "./IERC6956.sol"; + +/** + * @title Anchor-validating Asset-Bound NFT + * @dev See https://eips.ethereum.org/EIPS/eip-6956 + * Note: The ERC-165 identifier for this interface is 0x051c9bd8 + */ +interface IERC6956ValidAnchors is IERC6956 { + /** + * @notice Emits when the valid anchors for the contract are updated. + * @param validAnchorHash Hash representing all valid anchors. Typically Root of Merkle-Tree + * @param maintainer msg.sender when updating the hash + */ + event ValidAnchorsUpdate(bytes32 indexed validAnchorHash, address indexed maintainer); + + /** + * @notice Indicates whether an anchor is valid in the present contract + * @dev Typically implemented via MerkleTrees, where proof is used to verify anchor is part of the MerkleTree + * MUST return false when no ValidAnchorsUpdate-event has been emitted yet + * @param anchor The anchor in question + * @param proof Proof that the anchor is valid, typically MerkleProof + * @return isValid True, when anchor and proof can be verified against validAnchorHash (emitted via ValidAnchorsUpdate-event) + */ + function anchorValid(bytes32 anchor, bytes32[] memory proof) external view returns (bool isValid); +} +``` + +#### Caveats for ValidAnchors-Interface + +- MUST implement `validAnchor(anchor, proof)` which returns true when anchor is valid, namely MerkleProof is correct, false otherwise. + + +## Rationale + +**Why do you use an anchor<>tokenId mapping and not simply use tokenIds directly?** +Especially for collectable use-cases, special or sequential tokenIds (for example low numbers), have value. Holders may be proud to have claimed tokenId=1 respectively the off-chain ASSET with tokenId=1 may increase in value, because it was the first ever claimed. Or an Issuer may want to address the first 100 owners who claimed their ASSET-BOUND NFT. While these use-cases technically can certainly be covered by observing the blockchain state-changes, we consider reflecting the order in the tokenIds to be the user-friendly way. Please refer [Security considerations](#security-considerations) on why sequential anchors shall be avoided. + +**Why is tokenId=0 and anchor=0x0 invalid?** +For gas efficiency. This allows to omit checks and state-variables for the existence of a token or anchor, since mappings of a non-existent key return 0 and cannot be easily distinguised from anchor=0 or tokenId=0. + +**ASSETS are often batch-produced with the goal of identical properties, for example a batch of automotive spare parts. Why should do you extend ERC-721 and not Multi-Token standards?** +Even if a (physical) ASSET is mass produced with fungible characteristics, each ASSET has an individual property/ownership graph and thus shall be represented in a non-fungible way. Hence this EIP follows the design decision that ASSET (represented via a unique asset identifier called ANCHOR) and token are always mapped 1-1 and not 1-N, so that a token represents the individual property graph of the ASSET. + +**Why is there a burnAnchor() and approveAnchor()?** +Due to the permissionless nature ASSET-BOUND NFTs can even be transferred to or from any address. This includes arbitrary and randomly generated accounts (where the private key is unknown) and smart-contracts which would traditionally not support ERC-721 NFTs. Following that owning the ASSET must be equivalent to owning the NFT, this means that we also need to support ERC-721 operations like approval and burning in such instances through authorizing the operations with an attestation. + +**Implementation alternatives considered** Soulbound burn+mint combination, for example through Consensual Soulbound Tokens ([ERC-5484](eip-5484.md)). Disregarded because appearance is highly dubious, when the same asset is represented through multiple tokens over time. An predecessor of this EIP has used this approach and can be found deployed to Mumbai Testnet under address `0xd04c443913f9ddcfea72c38fed2d128a3ecd719e`. + +**When should I implement AttestationLimited-Interface** +Naturally, when your use-case requires each ASSET being transferable only a limited number of times. But also for security reasons, see [Security Considerations](#security-considerations) + +**Why is there the `IERC6956Floatable.FloatState` enum?** In order to allow gas-efficient implementation of floatAll(), which can be overruled by anchor-based floatability in all combinations. (See rationale for tokenId=0 above). + +**Why is there no `floating(tokenId)` function?** +This would behave identically to an `isTransferable(tokenId,...)` mechanism proposed in many other EIPs (refer e.g. [ERC-6454](eip-6454.md)). Further, the proposed `floating(anchorByToken(tokenId))` can be used. + +**Why are there different FloatingAuthorizations for start and stop?** +Depending on the use-case, different roles should be able to start or stop floating. Note that for many applications the ISSUER may want to have control over the floatability of the collection. + + +### Example Use Cases and recommended combination of interfaces + +Posession based use cases are covered by the standard interface `IERC6956`: The holder of ASSET is in posession of ASSET. Possession is an important social and economical tool: In many sports games posession of ASSET, commonly referred to as "the ball", is of essence. Posession can come with certain obligations and privileges. Ownership over an ASSET can come with rights and benefits as well as being burdened with liens and obligations. For example, an owned ASSET can be used for collateral, can be rented or can even yield a return. Example use-cases are + +- **Posession based token gating:** Club guest in posession of limited T-Shirt (ASSET) gets a token which allows him to open the door to the VIP lounge. + +- **Posession based digital twin:** A gamer is in posession of a pair of physical sneakers (ASSET), and gets a digital twin (NFT) to wear them in metaverse. + +- **Scarce posession based digital twin:** The producer of the sneakers (ASSET) decided that the product includes a limit of 5 digital twins (NFTs), to create scarcity. + +- **Lendable digital twin:** The gamer can lend his sneaker-tokens (NFT) to a friend in the metaverse, so that the friend can run faster. + +- **Securing ownership from theft:** If ASSET is owned off-chain, the owner wants to secure the anchored NFT, namely not allow transfers to prevent theft or recover the NFT easily through the ASSET. + +- **Selling a house with a mortage:** The owner holds NFT as proof of ownership. The DeFi-Bank finances the house and puts a lock on the transfer of NFT. Allow Transfers of the NFT require the mortage to be paid off. Selling the ASSET (house) off-chain will be impossible, as it's no longer possible to finance the house. + +- **Selling a house with a lease:** A lease contract puts a lien on an ASSET's anchored NFT. The old owner removes the lock, the new owner buys and refinances the house. Transfer of NFT will also transfer the obligations and benefits of the lien to the new owner. As a lien-interface, the proposed EIP can for example be extended with [ERC-5604](eip-5604.md) + +- **Buying a brand new car with downpayment:** A buyer configures a car and provides a downpayment, for a car that will have an ANCHOR. As long as the car is not produced, the NFT can float and be traded on NFT market places. The owner of the NFT at time of delivery of the ASSET has the the permission to pick up the car and the obligation to pay full price. + +- **Buying a barrel of oil by forward transaction:** A buyer buys an oil option on a forward contract for one barrel of oil (ASSET). On maturity date the buyer has the obligation to pick up the oil. + +The use case matrix below shows which extensions and settings must (additionally to `IERC6956`!) be implemented for the example use-cases together with relevant configurations. + +Note that for `Lockable` listed in the table below, the proposed EIP can be extended with any Lock- or Lien-Mechanism known to extend for ERC-721. Suitable extensions to achieve `Lockable` are for example [ERC-5058](eip-5058.md) or [ERC-5753](eip-5753.md). We recommend to verify whether a token is locked in the `_beforeTokenTransfer()`-hook, as this is called from `safeTransferFrom()` as well as `transferAnchor()`, hence suitable to block "standard" ERC-721 transfers as well as the proposed attestation-based transfers. + +| Use Case | approveAuthorization | burnAuthorization | `IERC6956Floatable` | `IERC6956AttestationLimited` | Lockable | +|---------------|---|---|---|---|---| +| **Managing Posession** | +| Token gating | ASSET | ANY | incompatible | - | - | +| Digital twin | ASSET | ANY | incompatible | - | - | +| Scarce digital twin | ASSET | ANY | incompatible | required | - | +| Lendable digital twin | OWNER_AND_ASSET | ASSET | required | - | - | +| **Managing Ownership** | +| Securing ownership from theft | OWNER or OWNER_AND_ASSET | ANY | optional | - | required | +| Selling an house with a mortage | ASSET or OWNER_AND_ASSET | ANY | optional | optional | required | +| Selling a house with a lease | ASSET or OWNER_AND_ASSET | ANY | optional | optional | required | +| Buying a brand new car with downpayment | ASSET or OWNER_AND_ASSET | ANY | optional | optional | required | +| Buying a barrel of oil by forward transaction | ASSET or OWNER_AND_ASSET | ANY | optional | optional | required | + +Legend: + +- required ... we don't see a way how to implement the use-case without it +- incompatible ... this MUSTN'T be implemented, as it is a security risk for the use-case +- optional ... this MAY optionally be implemented + +## Backwards Compatibility + + + +No backward compatibility issues found. + +This EIP is fully compatible with ERC-721 and (when extended with the `IERC6956Floatable`-interface) corresponds to the well-known ERC-721 behavior with an additional authorization-mechanism via attestations. Therefore we recommend - especially for physical assets - to use the present EIP instead of ERC-721 and amend it with extensions designed for ERC-721. + +However, it is RECOMMENDED to extend implementations of the proposed standard with an interface indicating transferability of NFTs for market places. Examples include [ERC-6454](eip-6454.md) and [ERC-5484](eip-5484.md). + +Many ERC-721 extensions suggest to add additional throw-conditions to transfer methods. This standard is fully compatible, as + +- The often-used ERC-721 `_beforeTokenTransfer()` hook must be called for all transfers including attestation-authorized transfers. +- A `_beforeAnchorUse()` hook is suggested in the reference implementation, which only is called when using attestation as authorization. + +## Test Cases + +Test cases are available: + +- For only implementing [the proposed standard interface](../assets/eip-6956/contracts/IERC6956.sol) can be found [here](../assets/eip-6956/test/ERC6956.ts) +- For implementing [the proposed standard interface](../assets/eip-6956/contracts/IERC6956.sol), [the Floatable extension](../assets/eip-6956/contracts/IERC6956Floatable.sol), [the ValidAnchors extension](../assets/eip-6956/contracts/IERC6956ValidAnchors.sol) and [the AttestationLimited extension](../assets/eip-6956/contracts/IERC6956AttestationLimited.sol) can be found [here](../assets/eip-6956/test/ERC6956Full.ts) + +## Reference Implementation + +- Minimal implementation, only supporting [the proposed standard interface](../assets/eip-6956/contracts/IERC6956.sol) can be found [here](../assets/eip-6956/contracts/ERC6956.sol) +- Full implementation, with support for [the proposed standard interface](../assets/eip-6956/contracts/IERC6956.sol), [the Floatable extension](../assets/eip-6956/contracts/IERC6956Floatable.sol), [the ValidAnchors extension](../assets/eip-6956/contracts/IERC6956ValidAnchors.sol) and [the AttestationLimited extension](../assets/eip-6956/contracts/IERC6956AttestationLimited.sol) can be found [here](../assets/eip-6956/contracts/ERC6956Full.sol) + +## Security Considerations + + + +**If the asset is stolen, does this mean the thief has control over the NFT?** +Yes.The standard aims to anchor an NFT to the asset inseperably and unconditionally. This includes reflecting theft, as the ORACLE will testify that PROOF-OF-CONTROL over the ASSET is established. The ORACLE does not testify whether the controller is the legitimate owner, +Note that this may even be a benefit. If the thief (or somebody receiving the asset from the thief) should interact with the anchor, an on-chain address of somebody connected to the crime (directly or another victim) becomes known. This can be a valuable starting point for investigation. +Also note that the proposed standard can be combined with any lock-mechanism, which could lock attestation-based action temporarily or permamently (after mint). + +**How to use AttestationLimits to avoid fund-draining** +A central security mechanism in blockchain applications are gas fees. Gas fees ensure that executing a high number of transactions get penalized, hence all DoS or other large-scale attacks are discouraged. Due to the permissionless nature of attestation-authorized operations, many use-cases will arise, where the issuer of the ASSET (which normally is also the issuer of the ASSET-BOUND NFT) will pay for all transactions - contrary to the well-known ERC-721 behavior, where either from- or to-address are paying. So a user with malicious intent may just let the ORACLE approve PROOF-OF-CONTROL multiple times with specifying alternating account addresses. These ATTESTATIONS will be handed to the central gas-payer, who will execute them in a permissionless way, paying gas-fees for each transactions. This effectively drains the funds from the gas-payer, making the system unusable as soon as the gas-payer can no longer pay for transactions. + +**Why do you recommend hashing serial numbers over using them plain?** +Using any sequential identifier allows to at least conclude of the number between the lowest and highest ever used serial number. This therefore provides good indication over the total number of assets on the market. While a limited number of assets is often desireable for collectables, publishing exact production numbers of assets is undesireable for most industries, as it equals to publishing sales/revenue numbers per product group, which is often considered confidential. Within supply chains, serial numbers are often mandatory due to their range-based processing capability. The simplest approach to allow using physical serial numbers and still obfuscating the actual number of assets is through hashing/encryption of the serial number. + +**Why is anchor-validation needed, why not simply trust the oracle to attest only valid anchors?** +The oracle testifies PROOF-OF-CONTROL. As the ORACLE has to know the merkle-tree of valid anchors, it could also modify the merkle-tree with malicious intent. Therefore, having an on-chain verification, whether the original merkle-tree has been used, is needed. Even if the oracle gets compromised, it should not have the power to introduce new anchors. This is achieved by requiring that the oracle knows the merkle-tree, but updateValidAnchors() can only be called by a maintainer. Note that the oracle must not be the maintainer. As a consequence, care shall be taken off-chain, in order to ensure that compromising one system-part not automatically compromises oracle and maintainer accounts. + +**Why do you use merkle-trees for anchor-validation?** +For security- and gas-reasons. Except for limited collections, anchors will typically be added over time, e.g. when a new batch of the asset is produced or issued. While it is already ineffective to store all available anchors on-chain gas-wise, publishing all anchors would also expose the total number of assets. When using the data from anchor-updates one could even deduce the production capabilities of that asset, which is usually considered confidential information. + +**Assume you have N anchors. If all anchored NFTs are minted, what use is a merkle-tree?** +If all anchored NFTs are minted this implies that all anchors have been published and could be gathered on-chain. Consequently, the merkle-tree can be reconstructed. While this may not be an issue for many use cases (all supported anchors are minted anyway), we still recommend to add one "salt-leave" to the merkle-tree, characterized in that the ORACLE will never issue an attestation for an ANCHOR matching that salt-leave. Therefore, even if all N anchors are + +### Security Considerations for PHYSICAL ASSETS + +In case the ASSET is a physical object, good or property, the following ADDITIONAL specifications MUST be satisifed: + +#### ORACLE for Physical Anchors + +- Issuing an ATTESTATION requires that the ORACLE + - MUST proof physical proximity between an input device (for example smartphone) specifying the `to` address and a particular physical ANCHOR and it's associated physical object. Typical acceptable proximity is ranges between some millimeters to several meters. + - The physical presence MUST be verified beyond reasonable doubt, in particular the employed method + - MUST be robust against duplication or reproduction attempts of the physical ANCHOR, + - MUST be robust against spoofing (for example presentation attacks) etc. + - MUST be implemented under the assumption that the party defining the `to` address has malicious intent and to acquire false ATTESTATION, without currently or ever having access to the physical object comprising the physical ANCHOR. + +#### Physical ASSET + +- MUST comprise an ANCHOR, acting as the unique physical object identifier, typically a serial number (plain (NOT RECOMMENDED) or hashed (RECOMMENDED)) +- MUST comprise a physical security device, marking or any other feature that enables proofing physical presence for ATTESTATION through the ORACLE +- Is RECOMMENDED to employ ANCHOR-TECHNOLOGIES featuring irreproducible security features. +- In general it is NOT RECOMMENDED to employ ANCHOR-TECHNOLOGIES that can easily be replicated (for example barcodes, "ordinary" NFC chips, .. ). Replication includes physical and digital replication. + + + +### Security Considerations for DIGITAL ASSETS + + + + + +## Copyright + +Copyright and related rights waived via [CC0](../LICENSE.md). diff --git a/assets/eip-6956/.gitignore b/assets/eip-6956/.gitignore new file mode 100644 index 00000000000000..74956f8d80a992 --- /dev/null +++ b/assets/eip-6956/.gitignore @@ -0,0 +1,8 @@ +node_modules + +#Hardhat files +cache +artifacts +typechain* + +package-lock.json diff --git a/assets/eip-6956/LICENSE.md b/assets/eip-6956/LICENSE.md new file mode 100644 index 00000000000000..1d853863a3b82b --- /dev/null +++ b/assets/eip-6956/LICENSE.md @@ -0,0 +1,21 @@ +MIT License + +Copyright (c) 2023 Authentic Vision GmbH + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. \ No newline at end of file diff --git a/assets/eip-6956/README.md b/assets/eip-6956/README.md new file mode 100644 index 00000000000000..dffbad5b12688b --- /dev/null +++ b/assets/eip-6956/README.md @@ -0,0 +1,12 @@ +# ERCxxxx Reference implementation +This reference implementation is [MIT](LICENSE.md) licensed and can therefore be freely used in any project. + +## Getting started +From this directory, run + +``` +npm install && npx hardhat test +``` + + + diff --git a/assets/eip-6956/contracts/ERC6956.sol b/assets/eip-6956/contracts/ERC6956.sol new file mode 100644 index 00000000000000..39543258b1fae4 --- /dev/null +++ b/assets/eip-6956/contracts/ERC6956.sol @@ -0,0 +1,491 @@ +// SPDX-License-Identifier: MIT + +pragma solidity ^0.8.18; + +import "@openzeppelin/contracts/token/ERC721/ERC721.sol"; +import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol"; +import "@openzeppelin/contracts/security/Pausable.sol"; +import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Burnable.sol"; +import "@openzeppelin/contracts/utils/Counters.sol"; +import "@openzeppelin/contracts/utils/Strings.sol"; + +import "./IERC6956.sol"; + +/** Used for several authorization mechansims, e.g. who can burn, who can set approval, ... + * @dev Specifying the role in the ecosystem. Used in conjunction with IERC6956.Authorization + */ +enum Role { + OWNER, // =0, The owner of the digital token + ISSUER, // =1, The issuer (contract) of the tokens, typically represented through a MAINTAINER_ROLE, the contract owner etc. + ASSET, // =2, The asset identified by the anchor + INVALID // =3, Reserved, do not use. +} + +/** + * @title ASSET-BOUND NFT minimal reference implementation + * @author Thomas Bergmueller (@tbergmueller) + * + * @dev Error messages + * ``` + * ERROR | Message + * ------|------------------------------------------------------------------- + * E1 | Only maintainer allowed + * E2 | No permission to burn + * E3 | Token does not exist, call transferAnchor first to mint + * E4 | batchSize must be 1 + * E5 | Token not transferable + * E6 | Token already owned + * E7 | Not authorized based on ERC6956Authorization + * E8 | Attestation not signed by trusted oracle + * E9 | Attestation already used + * E10 | Attestation not valid yet + * E11 | Attestation expired + * E12 | Attestation expired (contract limit) + * E13 | Invalid signature length + * E14-20| Reserved for future use + * ``` + */ +contract ERC6956 is + ERC721, + ERC721Enumerable, + ERC721Burnable, + IERC6956 +{ + using Counters for Counters.Counter; + + mapping(bytes32 => bool) internal _anchorIsReleased; // currently released anchors. Per default, all anchors are dropped, i.e. 1:1 bound + + mapping(address => bool) public maintainers; + + /// @notice Resolves tokenID to anchor. Inverse of tokenByAnchor + mapping(uint256 => bytes32) public anchorByToken; + + /// @notice Resolves Anchor to tokenID. Inverse of anchorByToken + mapping(bytes32 => uint256) public tokenByAnchor; + + mapping(address => bool) private _trustedOracles; + + /// @dev stores the anchors for each attestation + mapping(bytes32 => bytes32) private _anchorByUsedAttestation; + + /// @dev stores handed-back tokens (via burn) + mapping (bytes32 => uint256) private _burnedTokensByAnchor; + + + /** + * @dev Counter to keep track of issued tokens + */ + Counters.Counter private _tokenIdCounter; + + /// @dev Default validity timespan of attestation. In validateAttestation the attestationTime is checked for MIN(defaultAttestationvalidity, attestation.expiry) + uint256 public maxAttestationExpireTime = 5*60; // 5min valid per default + + Authorization public burnAuthorization; + Authorization public approveAuthorization; + + + /// @dev Records the number of transfers done for each attestation + mapping(bytes32 => uint256) public attestationsUsedByAnchor; + + modifier onlyMaintainer() { + require(isMaintainer(msg.sender), "ERC6956-E1"); + _; + } + + /** + * @notice Behaves like ERC721 burn() for wallet-cleaning purposes. Note only the tokenId (as a wrapper) is burned, not the ASSET represented by the ANCHOR. + * @dev + * - tokenId is remembered for the anchor, to ensure a later transferAnchor(), which would mint, assigns the same tokenId. This ensures strict 1:1 relation + * - For burning, the anchor needs to be released. This forced release FOR BURNING ONLY is allowed for owner() or approvedOwner(). + * + * @param tokenId The token that shall be burned + */ + function burn(uint256 tokenId) public override + { + // remember the tokenId of burned tokens, s.t. one can issue the token with the same number again + bytes32 anchor = anchorByToken[tokenId]; + require(_roleBasedAuthorization(anchor, createAuthorizationMap(burnAuthorization)), "ERC6956-E2"); + _burn(tokenId); + } + + function burnAnchor(bytes memory attestation, bytes memory data) public virtual + authorized(Role.ASSET, createAuthorizationMap(burnAuthorization)) + { + address to; + bytes32 anchor; + bytes32 attestationHash; + (to, anchor, attestationHash) = decodeAttestationIfValid(attestation, data); + _commitAttestation(to, anchor, attestationHash); + uint256 tokenId = tokenByAnchor[anchor]; + // remember the tokenId of burned tokens, s.t. one can issue the token with the same number again + _burn(tokenId); + } + + function burnAnchor(bytes memory attestation) public virtual { + return burnAnchor(attestation, ""); + } + + function approveAnchor(bytes memory attestation, bytes memory data) public virtual + authorized(Role.ASSET, createAuthorizationMap(approveAuthorization)) + { + address to; + bytes32 anchor; + bytes32 attestationHash; + (to, anchor, attestationHash) = decodeAttestationIfValid(attestation, data); + _commitAttestation(to, anchor, attestationHash); + require(tokenByAnchor[anchor]>0, "ERC6956-E3"); + _approve(to, tokenByAnchor[anchor]); + } + + // approveAuth == ISSUER does not really make sense.. so no separate implementation, since ERC-721.approve already implies owner... + + function approve(address to, uint256 tokenId) public virtual override(ERC721,IERC721) + authorized(Role.OWNER, createAuthorizationMap(approveAuthorization)) + { + super.approve(to, tokenId); + } + + function approveAnchor(bytes memory attestation) public virtual { + return approveAnchor(attestation, ""); + } + + /** + * @notice Adds or removes a trusted oracle, used when verifying signatures in `decodeAttestationIfValid()` + * @dev Emits OracleUpdate + * @param oracle address of oracle + * @param doTrust true to add, false to remove + */ + function updateOracle(address oracle, bool doTrust) public + onlyMaintainer() + { + _trustedOracles[oracle] = doTrust; + emit OracleUpdate(oracle, doTrust); + } + + /** + * @dev A very simple function wich MUST return false, when `a` is not a maintainer + * When derived contracts extend ERC6956 contract, this function may be overridden + * e.g. by using AccessControl, onlyOwner or other common mechanisms + * + * Having this simple mechanism in the reference implementation ensures that the reference + * implementation is fully ERC-6956 compatible + */ + function isMaintainer(address a) public virtual view returns (bool) { + return maintainers[a]; + } + + + function createAuthorizationMap(Authorization _auth) public pure returns (uint256) { + uint256 authMap = 0; + if(_auth == Authorization.OWNER + || _auth == Authorization.OWNER_AND_ASSET + || _auth == Authorization.OWNER_AND_ISSUER + || _auth == Authorization.ALL) { + authMap |= uint256(1< 0) { + from = ownerOf(fromToken); + require(from != to, "ERC6956-E6"); + _safeTransfer(from, to, fromToken, ""); + } else { + _safeMint(to, anchor); + } + } + + function transferAnchor(bytes memory attestation) public virtual { + return transferAnchor(attestation, ""); + } + + + function hasAuthorization(Role _role, uint256 _auth ) public pure returns (bool) { + uint256 result = uint256(_auth & (1 << uint256(_role))); + return result > 0; + } + + modifier authorized(Role _role, uint256 _authMap) { + require(hasAuthorization(_role, _authMap), "ERC6956-E7"); + _; + } + + // The following functions are overrides required by Solidity, EIP-165. + function supportsInterface(bytes4 interfaceId) + public + view + virtual + override(ERC721, ERC721Enumerable) + returns (bool) + { + return + interfaceId == type(IERC6956).interfaceId || + super.supportsInterface(interfaceId); + } + + /** + * @notice Returns whether a certain address is registered as trusted oracle, i.e. attestations signed by this address are accepted in `decodeAttestationIfValid` + * @dev This function may be overwritten when extending ERC-6956, e.g. when other oracle-registration mechanics are used + * @param oracleAddress Address of the oracle in question + * @return isTrusted True, if oracle is trusted + */ + function isTrustedOracle(address oracleAddress) public virtual view returns (bool isTrusted) { + return _trustedOracles[oracleAddress]; + } + + + function decodeAttestationIfValid(bytes memory attestation, bytes memory data) public view returns (address to, bytes32 anchor, bytes32 attestationHash) { + uint256 attestationTime; + uint256 validStartTime; + uint256 validEndTime; + bytes memory signature; + bytes32[] memory proof; + + attestationHash = keccak256(attestation); + (to, anchor, attestationTime, validStartTime, validEndTime, signature) = abi.decode(attestation, (address, bytes32, uint256, uint256, uint256, bytes)); + + bytes32 messageHash = keccak256(abi.encodePacked(to, anchor, attestationTime, validStartTime, validEndTime, proof)); + address signer = _extractSigner(messageHash, signature); + + // Check if from trusted oracle + require(isTrustedOracle(signer), "ERC6956-E8"); + require(_anchorByUsedAttestation[attestationHash] <= 0, "ERC6956-E9"); + + // Check expiry + uint256 timestamp = block.timestamp; + require(timestamp > validStartTime, "ERC6956-E10"); + require(attestationTime + maxAttestationExpireTime > block.timestamp, "ERC6956-E11"); + require(validEndTime > block.timestamp, "ERC6956-E112"); + + + // Calling hook! + _beforeAttestationUse(anchor, to, data); + return(to, anchor, attestationHash); + } + + /// @notice Compatible with ERC721.tokenURI(). Returns {baseURI}{anchor} + /// @dev Returns when called for tokenId=5, baseURI=https://myurl.com/collection/ and anchorByToken[5] = 0x12345 + /// Example: https://myurl.com/collection/0x12345 + /// Works for non-burned tokens / active-Anchors only. + /// Anchor-based tokenURIs are needed as an anchor's corresponding tokenId is only known after mint. + /// @param tokenId TokenID + /// @return tokenURI Returns the Uniform Resource Identifier (URI) for `tokenId` token. + function tokenURI(uint256 tokenId) public view override returns (string memory) { + bytes32 anchor = anchorByToken[tokenId]; + string memory anchorString = Strings.toHexString(uint256(anchor)); + return bytes(_baseURI()).length > 0 ? string(abi.encodePacked(_baseURI(), anchorString)) : ""; + } + + function _baseURI() internal view virtual override(ERC721) returns (string memory) { + return _baseUri; + } + + /** + * @dev Base URI, MUST end with a slash. Will be used as `{baseURI}{tokenId}` in tokenURI() function + */ + string internal _baseUri = ""; // needs to end with '/' + + /// @notice Set a new BaseURI. Can be used with dynamic NFTs that have server APIs, IPFS-buckets + /// or any other suitable system. Refer tokenURI(tokenId) for anchor-based or tokenId-based format. + /// @param tokenBaseURI The token base-URI. Must end with slash '/'. + function updateBaseURI(string calldata tokenBaseURI) public onlyMaintainer() { + _baseUri = tokenBaseURI; + } + event BurnAuthorizationChange(Authorization burnAuth, address indexed maintainer); + + function updateBurnAuthorization(Authorization burnAuth) public onlyMaintainer() { + burnAuthorization = burnAuth; + emit BurnAuthorizationChange(burnAuth, msg.sender); + // TODO event + } + + event ApproveAuthorizationChange(Authorization approveAuth, address indexed maintainer); + + function updateApproveAuthorization(Authorization approveAuth) public onlyMaintainer() { + approveAuthorization = approveAuth; + emit ApproveAuthorizationChange(approveAuth, msg.sender); + + // TODO event + } + + constructor(string memory _name, string memory _symbol) + ERC721(_name, _symbol) { + maintainers[msg.sender] = true; // deployer is automatically maintainer + // Indicates general float-ability, i.e. whether anchors can be digitally dropped and released + + // OWNER and ASSET shall normally be in sync anyway, so this is reasonable default + // authorization for approve and burn, as it mimicks ERC-721 behavior + burnAuthorization = Authorization.OWNER_AND_ASSET; + approveAuthorization = Authorization.OWNER_AND_ASSET; + } + + /* + ########################## SIGNATURE MAGIC, + ########################## adapted from https://solidity-by-example.org/signature/ + */ + /** + * Returns the signer of a message. + * + * OFF-CHAIN: + * const [alice] = ethers.getSigners(); // = 0x3c44... + * const messageHash = ethers.utils.solidityKeccak256(["address", "bytes32"], [a, b]); + const sig = await alice.signMessage(ethers.utils.arrayify(messageHash)); + + ONCHAIN In this contract, call from + ``` + function (address a, bytes32 b, bytes memory sig) { + messageHash = keccak256(abi.encodePacked(to, b)); + signer = extractSigner(messageHash, sig); // signer will be 0x3c44... + } + ``` * + * @param messageHash A keccak25(abi.encodePacked(...)) hash + * @param sig Signature (length 65 bytes) + * + * @return The signer + */ + function _extractSigner(bytes32 messageHash, bytes memory sig) internal pure returns (address) { + require(sig.length == 65, "ERC6956-E13"); + /* + Signature is produced by signing a keccak256 hash with the following format: + "\x19Ethereum Signed Message\n" + len(msg) + msg + */ + bytes32 ethSignedMessageHash = keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n32", messageHash)); + + bytes32 r; + bytes32 s; + uint8 v; + + // Extract the r, s, and v parameters from the signature + assembly { + r := mload(add(sig, 32)) + s := mload(add(sig, 64)) + v := byte(0, mload(add(sig, 96))) + } + + // Ensure the v parameter is either 27 or 28 + // TODO is this needed? + if (v < 27) { + v += 27; + } + + // Recover the public key from the signature and message hash + // and convert it to an address + address signer = ecrecover(ethSignedMessageHash, v, r, s); + return signer; + } +} diff --git a/assets/eip-6956/contracts/ERC6956Full.sol b/assets/eip-6956/contracts/ERC6956Full.sol new file mode 100644 index 00000000000000..d7e67a22c55009 --- /dev/null +++ b/assets/eip-6956/contracts/ERC6956Full.sol @@ -0,0 +1,206 @@ +// SPDX-License-Identifier: MIT + +pragma solidity ^0.8.18; + +import "@openzeppelin/contracts/token/ERC721/ERC721.sol"; +import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol"; +import "@openzeppelin/contracts/security/Pausable.sol"; +import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Burnable.sol"; +import "@openzeppelin/contracts/utils/Counters.sol"; +import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol"; + +import "./ERC6956.sol"; +import "./IERC6956AttestationLimited.sol"; +import "./IERC6956Floatable.sol"; +import "./IERC6956ValidAnchors.sol"; + +/** + * @title ASSET-BOUND NFT implementation with all interfaces + * @author Thomas Bergmueller (@tbergmueller) + * @notice Extends ERC6956.sol with additional interfaces and functionality + * + * @dev Error-codes + * ERROR | Message + * ------|------------------------------------------------------------------- + * E1-20 | See ERC6956.sol + * E21 | No permission to start floating + * E22 | No permission to stop floating + * E23 | allowFloating can only be called when changing floating state + * E24 | No attested transfers left + * E25 | data must contain merkle-proof + * E26 | Anchor not valid + * E27 | Updating attestedTransferLimit violates policy + */ +contract ERC6956Full is ERC6956, IERC6956AttestationLimited, IERC6956Floatable, IERC6956ValidAnchors { + Authorization public floatStartAuthorization; + Authorization public floatStopAuthorization; + + /// ############################################################################################################################### + /// ############################################################################################## IERC6956AttestedTransferLimited + /// ############################################################################################################################### + + mapping(bytes32 => uint256) public attestedTransferLimitByAnchor; + mapping(bytes32 => FloatState) public floatingStateByAnchor; + + uint256 public globalAttestedTransferLimitByAnchor; + AttestationLimitPolicy public attestationLimitPolicy; + + bool public allFloating; + + /// @dev The merkle-tree root node, where proof is validated against. Update via updateValidAnchors(). Use salt-leafs in merkle-trees! + bytes32 private _validAnchorsMerkleRoot; + + function _requireValidLimitUpdate(uint256 oldValue, uint256 newValue) internal view { + if(newValue > oldValue) { + require(attestationLimitPolicy == AttestationLimitPolicy.FLEXIBLE || attestationLimitPolicy == AttestationLimitPolicy.INCREASE_ONLY, "ERC6956-E27"); + } else { + require(attestationLimitPolicy == AttestationLimitPolicy.FLEXIBLE || attestationLimitPolicy == AttestationLimitPolicy.DECREASE_ONLY, "ERC6956-E27"); + } + } + + function updateGlobalAttestationLimit(uint256 _nrTransfers) + public + onlyMaintainer() + { + _requireValidLimitUpdate(globalAttestedTransferLimitByAnchor, _nrTransfers); + globalAttestedTransferLimitByAnchor = _nrTransfers; + emit GlobalAttestationLimitUpdate(_nrTransfers, msg.sender); + } + + function updateAttestationLimit(bytes32 anchor, uint256 _nrTransfers) + public + onlyMaintainer() + { + uint256 currentLimit = attestationLimit(anchor); + _requireValidLimitUpdate(currentLimit, _nrTransfers); + attestedTransferLimitByAnchor[anchor] = _nrTransfers; + emit AttestationLimitUpdate(anchor, tokenByAnchor[anchor], _nrTransfers, msg.sender); + } + + function attestationLimit(bytes32 anchor) public view returns (uint256 limit) { + if(attestedTransferLimitByAnchor[anchor] > 0) { // Per anchor overwrites always, even if smaller than globalAttestedTransferLimit + return attestedTransferLimitByAnchor[anchor]; + } + return globalAttestedTransferLimitByAnchor; + } + + function attestationUsagesLeft(bytes32 anchor) public view returns (uint256 nrTransfersLeft) { + // FIXME panics when attestationsUsedByAnchor > attestedTransferLimit + // since this should never happen, maybe ok? + return attestationLimit(anchor) - attestationsUsedByAnchor[anchor]; + } + + /// ############################################################################################################################### + /// ############################################################################################## FLOATABILITY + /// ############################################################################################################################### + + function updateFloatingAuthorization(Authorization startAuthorization, Authorization stopAuthorization) public + onlyMaintainer() { + floatStartAuthorization = startAuthorization; + floatStopAuthorization = stopAuthorization; + emit FloatingAuthorizationChange(startAuthorization, stopAuthorization, msg.sender); + } + + function floatAll(bool doFloatAll) public onlyMaintainer() { + require(doFloatAll != allFloating, "ERC6956-E23"); + allFloating = doFloatAll; + emit FloatingAllStateChange(doFloatAll, msg.sender); + } + + + function _floating(bool defaultFloatState, FloatState anchorFloatState) internal pure returns (bool floats) { + if(anchorFloatState == FloatState.Default) { + return defaultFloatState; + } + return anchorFloatState == FloatState.Floating; + } + + function float(bytes32 anchor, FloatState newFloatState) public + { + bool currentFloatState = floating(anchor); + bool willFloat = _floating(allFloating, newFloatState); + + require(willFloat != currentFloatState, "ERC6956-E23"); + + if(willFloat) { + require(_roleBasedAuthorization(anchor, createAuthorizationMap(floatStartAuthorization)), "ERC6956-E21"); + } else { + require(_roleBasedAuthorization(anchor, createAuthorizationMap(floatStopAuthorization)), "ERC6956-E22"); + } + + floatingStateByAnchor[anchor] = newFloatState; + emit FloatingStateChange(anchor, tokenByAnchor[anchor], newFloatState, msg.sender); + } + + function _beforeTokenTransfer(address from, address to, uint256 tokenId, uint256 batchSize) + internal virtual + override(ERC6956) { + bytes32 anchor = anchorByToken[tokenId]; + + if(!_anchorIsReleased[anchor]) { + // Only write when not already released - this saves gas, as memory-write is quite expensive compared to IF + if(floating(anchor)) { + _anchorIsReleased[anchor] = true; // FIXME OPTIMIZATION, we do not need + } + } + + super._beforeTokenTransfer(from, to, tokenId, batchSize); + } + function _beforeAttestationUse(bytes32 anchor, address to, bytes memory data) internal view virtual override(ERC6956) { + // empty, can be overwritten by derived conctracts. + require(attestationUsagesLeft(anchor) > 0, "ERC6956-E24"); + + // IERC6956ValidAnchors check anchor is indeed valid in contract + require(data.length > 0, "ERC6956-E25"); + bytes32[] memory proof; + (proof) = abi.decode(data, (bytes32[])); // Decode it with potentially more data following. If there is more data, this may be passed on to safeTransfer + require(anchorValid(anchor, proof), "ERC6956-E26"); + + super._beforeAttestationUse(anchor, to, data); + } + + + /// @notice Update the Merkle root containing the valid anchors. Consider salt-leaves! + /// @dev Proof (transferAnchor) needs to be provided from this tree. + /// @dev The merkle-tree needs to contain at least one "salt leaf" in order to not publish the complete merkle-tree when all anchors should have been dropped at least once. + /// @param merkleRootNode The root, containing all anchors we want validated. + function updateValidAnchors(bytes32 merkleRootNode) public onlyMaintainer() { + _validAnchorsMerkleRoot = merkleRootNode; + emit ValidAnchorsUpdate(merkleRootNode, msg.sender); + } + + function anchorValid(bytes32 anchor, bytes32[] memory proof) public virtual view returns (bool) { + return MerkleProof.verify( + proof, + _validAnchorsMerkleRoot, + keccak256(bytes.concat(keccak256(abi.encode(anchor))))); + } + + function floating(bytes32 anchor) public view returns (bool){ + return _floating(allFloating, floatingStateByAnchor[anchor]); + } + + constructor( + string memory _name, + string memory _symbol, + AttestationLimitPolicy _limitUpdatePolicy) + ERC6956(_name, _symbol) { + attestationLimitPolicy = _limitUpdatePolicy; + + // Note per default no-one change floatability. canStartFloating and canStopFloating needs to be configured first! + } + + function supportsInterface(bytes4 interfaceId) + public + view + virtual + override(ERC6956) + returns (bool) + { + return + interfaceId == type(IERC6956AttestationLimited).interfaceId || + interfaceId == type(IERC6956Floatable).interfaceId || + interfaceId == type(IERC6956ValidAnchors).interfaceId || + super.supportsInterface(interfaceId); + } +} diff --git a/assets/eip-6956/contracts/IERC6956.sol b/assets/eip-6956/contracts/IERC6956.sol new file mode 100644 index 00000000000000..a171a930ece2f5 --- /dev/null +++ b/assets/eip-6956/contracts/IERC6956.sol @@ -0,0 +1,165 @@ +// SPDX-License-Identifier: MIT + +pragma solidity ^0.8.18; + +/** + * @title IERC6956 Asset-Bound Non-Fungible Tokens + * @notice Asset-bound Non-Fungible Tokens anchor a token 1:1 to a (physical or digital) asset and token transfers are authorized through attestation of control over the asset + * @dev See https://eips.ethereum.org/EIPS/eip-6956 + * Note: The ERC-165 identifier for this interface is 0xa9cf7635 + */ +interface IERC6956 { + + /** @dev Authorization, typically mapped to authorizationMaps, where each bit indicates whether a particular ERC6956Role is authorized + * Typically used in constructor (hardcoded or params) to set burnAuthorization and approveAuthorization + * Also used in optional updateBurnAuthorization, updateApproveAuthorization, I + */ + enum Authorization { + NONE, // = 0, // None of the above + OWNER, // = (1<0) of the anchored token + */ + event AnchorApproval(address indexed owner, address approved, bytes32 indexed anchor, uint256 tokenId); + + /** + * @notice This emits when the ownership of any anchored NFT changes by any mechanism + * @dev This emits together with tokenId-based ERC-721.Transfer and provides an anchor-perspective on transfers + * @param from The previous owner, address(0) indicate there was none. + * @param to The new owner, address(0) indicates the token is burned + * @param anchor The anchor which is bound to tokenId + * @param tokenId ID (>0) of the anchored token + */ + event AnchorTransfer(address indexed from, address indexed to, bytes32 indexed anchor, uint256 tokenId); + /** + * @notice This emits when an attestation has been used indicating no second attestation with the same attestationHash will be accepted + * @param to The to address specified in the attestation + * @param anchor The anchor specificed in the attestation + * @param attestationHash The hash of the attestation, see ERC-6956 for details + * @param totalUsedAttestationsForAnchor The total number of attestations already used for the particular anchor + */ + event AttestationUse(address indexed to, bytes32 indexed anchor, bytes32 indexed attestationHash, uint256 totalUsedAttestationsForAnchor); + + /** + * @notice This emits when the trust-status of an oracle changes. + * @dev Trusted oracles must explicitely be specified. + * If the last event for a particular oracle-address indicates it's trusted, attestations from this oracle are valid. + * @param oracle Address of the oracle signing attestations + * @param trusted indicating whether this address is trusted (true). Use (false) to no longer trust from an oracle. + */ + event OracleUpdate(address indexed oracle, bool indexed trusted); + + /** + * @notice Returns the 1:1 mapped anchor for a tokenId + * @param tokenId ID (>0) of the anchored token + * @return anchor The anchor bound to tokenId, 0x0 if tokenId does not represent an anchor + */ + function anchorByToken(uint256 tokenId) external view returns (bytes32 anchor); + /** + * @notice Returns the ID of the 1:1 mapped token of an anchor. + * @param anchor The anchor (>0x0) + * @return tokenId ID of the anchored token, 0 if no anchored token exists + */ + function tokenByAnchor(bytes32 anchor) external view returns (uint256 tokenId); + + /** + * @notice The number of attestations already used to modify the state of an anchor or its bound tokens + * @param anchor The anchor(>0) + * @return attestationUses The number of attestation uses for a particular anchor, 0 if anchor is invalid. + */ + function attestationsUsedByAnchor(bytes32 anchor) view external returns (uint256 attestationUses); + /** + * @notice Decodes and returns to-address, anchor and the attestation hash, if the attestation is valid + * @dev MUST throw when + * - Attestation has already been used (an AttestationUse-Event with matching attestationHash was emitted) + * - Attestation is not signed by trusted oracle (the last OracleUpdate-Event for the signer-address does not indicate trust) + * - Attestation is not valid yet or expired + * - [if IERC6956AttestationLimited is implemented] attestationUsagesLeft(attestation.anchor) <= 0 + * - [if IERC6956ValidAnchors is implemented] validAnchors(data) does not return true. + * @param attestation The attestation subject to the format specified in ERC-6956 + * @param data Optional additional data, may contain proof as the first abi-encoded argument when IERC6956ValidAnchors is implemented + * @return to Address where the ownership of an anchored token or approval shall be changed to + * @return anchor The anchor (>0) + * @return attestationHash The attestation hash computed on-chain as `keccak256(attestation)` + */ + function decodeAttestationIfValid(bytes memory attestation, bytes memory data) external view returns (address to, bytes32 anchor, bytes32 attestationHash); + + /** + * @notice Indicates whether any of ASSET, OWNER, ISSUER is authorized to burn + */ + function burnAuthorization() external view returns(Authorization burnAuth); + + /** + * @notice Indicates whether any of ASSET, OWNER, ISSUER is authorized to approve + */ + function approveAuthorization() external view returns(Authorization approveAuth); + + /** + * @notice Corresponds to transferAnchor(bytes,bytes) without additional data + * @param attestation Attestation, refer ERC-6956 for details + */ + function transferAnchor(bytes memory attestation) external; + + /** + * @notice Changes the ownership of an NFT mapped to attestation.anchor to attestation.to address. + * @dev Permissionless, i.e. anybody invoke and sign a transaction. The transfer is authorized through the oracle-signed attestation. + * - Uses decodeAttestationIfValid() + * - When using a centralized "gas-payer" recommended to implement IERC6956AttestationLimited. + * - Matches the behavior of ERC-721.safeTransferFrom(ownerOf[tokenByAnchor(attestation.anchor)], attestation.to, tokenByAnchor(attestation.anchor), ..) and mint an NFT if `tokenByAnchor(anchor)==0`. + * - Throws when attestation.to == ownerOf(tokenByAnchor(attestation.anchor)) + * - Emits AnchorTransfer + * + * @param attestation Attestation, refer EIP-6956 for details + * @param data Additional data, may be used for additional transfer-conditions, may be sent partly or in full in a call to safeTransferFrom + * + */ + function transferAnchor(bytes memory attestation, bytes memory data) external; + + /** + * @notice Corresponds to approveAnchor(bytes,bytes) without additional data + * @param attestation Attestation, refer ERC-6956 for details + */ + function approveAnchor(bytes memory attestation) external; + + /** + * @notice Approves attestation.to the token bound to attestation.anchor. . + * @dev Permissionless, i.e. anybody invoke and sign a transaction. The transfer is authorized through the oracle-signed attestation. + * - Uses decodeAttestationIfValid() + * - When using a centralized "gas-payer" recommended to implement IERC6956AttestationLimited. + * - Matches the behavior of ERC-721.approve(attestation.to, tokenByAnchor(attestation.anchor)). + * - Throws when ASSET is not authorized to approve. + * + * @param attestation Attestation, refer EIP-6956 for details + */ + function approveAnchor(bytes memory attestation, bytes memory data) external; + + /** + * @notice Corresponds to burnAnchor(bytes,bytes) without additional data + * @param attestation Attestation, refer ERC-6956 for details + */ + function burnAnchor(bytes memory attestation) external; + + /** + * @notice Burns the token mapped to attestation.anchor. Uses ERC-721._burn. + * @dev Permissionless, i.e. anybody invoke and sign a transaction. The transfer is authorized through the oracle-signed attestation. + * - Uses decodeAttestationIfValid() + * - When using a centralized "gas-payer" recommended to implement IERC6956AttestationLimited. + * - Throws when ASSET is not authorized to burn + * + * @param attestation Attestation, refer EIP-6956 for details + */ + function burnAnchor(bytes memory attestation, bytes memory data) external; +} \ No newline at end of file diff --git a/assets/eip-6956/contracts/IERC6956AttestationLimited.sol b/assets/eip-6956/contracts/IERC6956AttestationLimited.sol new file mode 100644 index 00000000000000..6667c3751af20b --- /dev/null +++ b/assets/eip-6956/contracts/IERC6956AttestationLimited.sol @@ -0,0 +1,40 @@ +// SPDX-License-Identifier: MIT + +pragma solidity ^0.8.18; +import "./IERC6956.sol"; + +/** + * @title Attestation-limited Asset-Bound NFT + * @dev See https://eips.ethereum.org/EIPS/eip-6956 + * Note: The ERC-165 identifier for this interface is 0x75a2e933 + */ +interface IERC6956AttestationLimited is IERC6956 { + enum AttestationLimitPolicy { + IMMUTABLE, + INCREASE_ONLY, + DECREASE_ONLY, + FLEXIBLE + } + + /// @notice Returns the attestation limit for a particular anchor + /// @dev MUST return the global attestation limit per default + /// and override the global attestation limit in case an anchor-based limit is set + function attestationLimit(bytes32 anchor) external view returns (uint256 limit); + + /// @notice Returns number of attestations left for a particular anchor + /// @dev Is computed by comparing the attestationsUsedByAnchor(anchor) and the current attestation limit + /// (current limited emitted via GlobalAttestationLimitUpdate or AttestationLimt events) + function attestationUsagesLeft(bytes32 anchor) external view returns (uint256 nrTransfersLeft); + + /// @notice Indicates the policy, in which direction attestation limits can be updated (globally or per anchor) + function attestationLimitPolicy() external view returns (AttestationLimitPolicy policy); + + /// @notice This emits when the global attestation limt is updated + event GlobalAttestationLimitUpdate(uint256 indexed transferLimit, address updatedBy); + + /// @notice This emits when an anchor-specific attestation limit is updated + event AttestationLimitUpdate(bytes32 indexed anchor, uint256 indexed tokenId, uint256 indexed transferLimit, address updatedBy); + + /// @dev This emits in the transaction, where attestationUsagesLeft becomes 0 + event AttestationLimitReached(bytes32 indexed anchor, uint256 indexed tokenId, uint256 indexed transferLimit); +} diff --git a/assets/eip-6956/contracts/IERC6956Floatable.sol b/assets/eip-6956/contracts/IERC6956Floatable.sol new file mode 100644 index 00000000000000..6c345fdc25fcac --- /dev/null +++ b/assets/eip-6956/contracts/IERC6956Floatable.sol @@ -0,0 +1,43 @@ +// SPDX-License-Identifier: MIT + +pragma solidity ^0.8.18; +import "./IERC6956.sol"; + +/** + * @title Floatable Asset-Bound NFT + * @notice A floatable Asset-Bound NFT can (temporarily) be transferred without attestation + * @dev See https://eips.ethereum.org/EIPS/eip-6956 + * Note: The ERC-165 identifier for this interface is 0xf82773f7 + */ +interface IERC6956Floatable is IERC6956 { + enum FloatState { + Default, // 0, inherits from floatAll + Floating, // 1 + Anchored // 2 + } + + /// @notice Indicates that an anchor-specific floating state changed + event FloatingStateChange(bytes32 indexed anchor, uint256 indexed tokenId, FloatState isFloating, address operator); + /// @notice Emits when FloatingAuthorization is changed. + event FloatingAuthorizationChange(Authorization startAuthorization, Authorization stopAuthorization, address maintainer); + /// @notice Emits, when the default floating state is changed + event FloatingAllStateChange(bool areFloating, address operator); + + /// @notice Indicates whether an anchored token is floating, namely can be transferred without attestation + function floating(bytes32 anchor) external view returns (bool); + + /// @notice Indicates whether any of OWNER, ISSUER, (ASSET) is allowed to start floating + function floatStartAuthorization() external view returns (Authorization canStartFloating); + + /// @notice Indicates whether any of OWNER, ISSUER, (ASSET) is allowed to stop floating + function floatStopAuthorization() external view returns (Authorization canStartFloating); + + /** + * @notice Allows to override or reset to floatAll-behavior per anchor + * @dev Must throw when newState == Floating and floatStartAuthorization does not authorize msg.sender + * @dev Must throw when newState == Anchored and floatStopAuthorization does not authorize msg.sender + * @param anchor The anchor, whose anchored token shall override default behavior + * @param newState Override-State. If set to Default, the anchor will behave like floatAll + */ + function float(bytes32 anchor, FloatState newState) external; +} \ No newline at end of file diff --git a/assets/eip-6956/contracts/IERC6956ValidAnchors.sol b/assets/eip-6956/contracts/IERC6956ValidAnchors.sol new file mode 100644 index 00000000000000..7de78697c886e1 --- /dev/null +++ b/assets/eip-6956/contracts/IERC6956ValidAnchors.sol @@ -0,0 +1,28 @@ +// SPDX-License-Identifier: MIT + +pragma solidity ^0.8.18; +import "./IERC6956.sol"; + +/** + * @title Anchor-validating Asset-Bound NFT + * @dev See https://eips.ethereum.org/EIPS/eip-6956 + * Note: The ERC-165 identifier for this interface is 0x051c9bd8 + */ +interface IERC6956ValidAnchors is IERC6956 { + /** + * @notice Emits when the valid anchors for the contract are updated. + * @param validAnchorHash Hash representing all valid anchors. Typically Root of MerkleTree + * @param maintainer msg.sender updating the hash + */ + event ValidAnchorsUpdate(bytes32 indexed validAnchorHash, address indexed maintainer); + + /** + * @notice Indicates whether an anchor is valid in the present contract + * @dev Typically implemented via MerkleTrees, where proof is used to verify anchor is part of the MerkleTree + * MUST return false when no ValidAnchorsUpdate-event has been emitted yet + * @param anchor The anchor in question + * @param proof Proof that the anchor is valid, typically MerkleProof + * @return isValid True, when anchor and proof can be verified against validAnchorHash (emitted via ValidAnchorsUpdate-event) + */ + function anchorValid(bytes32 anchor, bytes32[] memory proof) external view returns (bool isValid); +} \ No newline at end of file diff --git a/assets/eip-6956/img/erc6956_concept.svg b/assets/eip-6956/img/erc6956_concept.svg new file mode 100644 index 00000000000000..c9da78ca982832 --- /dev/null +++ b/assets/eip-6956/img/erc6956_concept.svg @@ -0,0 +1,16 @@ + + + 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 + + + + NFT0x123...456ASSETANCHORANCHOR-TECHNOLOGY§ORACLEPROOF-OF-CONTROLto0xaa..aaERC-69560xaa..aatoken: 2402anchor: 0x123...456{ to: 0xaa..aa, anchor: 0x123..456, signed: § } 0x..gasPayertransferAnchor( )ATTESTATION0xbb...bbsafeTransferFrom( from: 0xbb..bb, to: 0xaa..aa, tokenId: 2402)anchorByToken2402 <> 0x123...456ownerOf(2402) 0xbb...bbOFF-CHAINON-CHAINUSER DEVICE \ No newline at end of file diff --git a/assets/eip-6956/test/ERC6956.ts b/assets/eip-6956/test/ERC6956.ts new file mode 100644 index 00000000000000..01bf26982b8e67 --- /dev/null +++ b/assets/eip-6956/test/ERC6956.ts @@ -0,0 +1,355 @@ +import { time, loadFixture } from "@nomicfoundation/hardhat-network-helpers"; +import { expect } from "chai"; +import { ethers } from "hardhat"; +import { createHash } from 'node:crypto'; +import { StandardMerkleTree } from "@openzeppelin/merkle-tree"; +import { ERC6956Authorization, ERC6956Role, merkleTestAnchors, NULLADDR, createAttestation} from "./commons"; +import { IERC6956AttestationLimitedInterfaceId, IERC6956InterfaceId, IERC6956FloatableInterfaceId, IERC6956ValidAnchorsInterfaceId} from "./commons"; + + + +export async function minimalAttestationExample() { + // #################################### PRELIMINARIES + /*const merkleTestAnchors = [ + ['0x' + createHash('sha256').update('TestAnchor123').digest('hex')], + ['0x' + createHash('sha256').update('TestAnchor124').digest('hex')], + ['0x' + createHash('sha256').update('TestAnchor125').digest('hex')], + ['0x' + createHash('sha256').update('TestAnchor126').digest('hex')], + ['0x' + createHash('sha256').update('SaltLeave').digest('hex')] // shall never be used on-chain! + ] + const merkleTree = StandardMerkleTree.of(merkleTestAnchors, ["bytes32"]);*/ + + // #################################### ACCOUNTS + // Alice shall get the NFT, oracle signs the attestation off-chain + const [alice, oracle] = await ethers.getSigners(); + + // #################################### CREATE AN ATTESTATION + const to = alice.address; + const anchor = merkleTestAnchors[0][0]; + // const proof = merkleTree.getProof([anchor]); + const attestationTime = Math.floor(Date.now() / 1000.0); // Now in seconds UTC + + const validStartTime = 0; + const validEndTime = attestationTime + 15 * 60; // 15 minutes valid from attestation + + // Hash and sign. In practice, oracle shall only sign when Proof-of-Control is established! + const messageHash = ethers.utils.solidityKeccak256(["address", "bytes32", "uint256", 'uint256', "uint256", "bytes32[]"], [to, anchor, attestationTime, validStartTime, validEndTime, proof]); + const sig = await oracle.signMessage(ethers.utils.arrayify(messageHash)); + // Encode + return ethers.utils.defaultAbiCoder.encode(['address', 'bytes32', 'uint256', 'uint256', 'uint256', 'bytes32[]', 'bytes'], [to, anchor, attestationTime, validStartTime, validStartTime, proof, sig]); +} + +describe("ERC6956: Asset-Bound NFT --- Basics", function () { + // Fixture to deploy the abnftContract contract and assigne roles. + // Besides owner there's user, minter and burner with appropriate roles. + async function deployAbNftFixture() { + // Contracts are deployed using the first signer/account by default + const [owner, maintainer, oracle, alice, bob, mallory, hacker, carl, gasProvider ] = await ethers.getSigners(); + + const AbNftContract = await ethers.getContractFactory("ERC6956"); + //const burnAuthorization = ERC6956Authorization.ALL; + //const approveAuthorization = ERC6956Authorization.ALL; + + const abnftContract = await AbNftContract.connect(owner).deploy("Asset-Bound NFT test", "ABNFT"); + await abnftContract.connect(owner).updateMaintainer(maintainer.address, true); + + await expect(abnftContract.connect(maintainer).updateOracle(oracle.address, true)) + .to.emit(abnftContract, "OracleUpdate") + .withArgs(oracle.address, true); + + + return { abnftContract, owner, maintainer, oracle, alice, bob, mallory, hacker, carl, gasProvider }; + } + + async function deployABTandMintTokenToAlice() { + // Contracts are deployed using the first signer/account by default + const {abnftContract, owner, maintainer, oracle, alice, bob, mallory, hacker, carl, gasProvider} = await deployAbNftFixture(); + + const anchor = merkleTestAnchors[0][0]; + const mintAttestationAlice = await createAttestation(alice.address, anchor, oracle); // Mint to alice + + await expect(abnftContract.connect(gasProvider)["transferAnchor(bytes)"](mintAttestationAlice)) + .to.emit(abnftContract, "Transfer") // Standard ERC721 event + .withArgs(NULLADDR, alice.address, 1); + + return { abnftContract, owner, maintainer, oracle, mintAttestationAlice, anchor, alice, bob, mallory, hacker, carl, gasProvider }; + } + + + describe("Deployment & Settings", function () { + it("Should implement EIP-165 support the EIP-6956 interface", async function () { + const { abnftContract } = await loadFixture(deployAbNftFixture); + expect(await abnftContract.supportsInterface(IERC6956InterfaceId)).to.equal(true); + expect(await abnftContract.supportsInterface(IERC6956ValidAnchorsInterfaceId)).to.equal(false); + expect(await abnftContract.supportsInterface(IERC6956FloatableInterfaceId)).to.equal(false); + expect(await abnftContract.supportsInterface(IERC6956AttestationLimitedInterfaceId)).to.equal(false); + }); + }); + + +describe("Authorization Map tests", function () { + it("SHOULD interpret ERC6956Authorization correctly", async function () { + // Create the message to sign + const { abnftContract } = await loadFixture(deployAbNftFixture); + + // OWNER + await expect(await abnftContract.hasAuthorization(ERC6956Role.OWNER, await abnftContract.createAuthorizationMap(ERC6956Authorization.NONE))) + .to.be.equal(false); + await expect(await abnftContract.hasAuthorization(ERC6956Role.OWNER, await abnftContract.createAuthorizationMap(ERC6956Authorization.OWNER))) + .to.be.equal(true); + await expect(await abnftContract.hasAuthorization(ERC6956Role.OWNER, await abnftContract.createAuthorizationMap(ERC6956Authorization.ISSUER))) + .to.be.equal(false); + await expect(await abnftContract.hasAuthorization(ERC6956Role.OWNER, await abnftContract.createAuthorizationMap(ERC6956Authorization.ASSET))) + .to.be.equal(false); + await expect(await abnftContract.hasAuthorization(ERC6956Role.OWNER, await abnftContract.createAuthorizationMap(ERC6956Authorization.OWNER_AND_ASSET))) + .to.be.equal(true); + await expect(await abnftContract.hasAuthorization(ERC6956Role.OWNER, await abnftContract.createAuthorizationMap(ERC6956Authorization.OWNER_AND_ISSUER))) + .to.be.equal(true); + await expect(await abnftContract.hasAuthorization(ERC6956Role.OWNER, await abnftContract.createAuthorizationMap(ERC6956Authorization.ASSET_AND_ISSUER))) + .to.be.equal(false); + await expect(await abnftContract.hasAuthorization(ERC6956Role.OWNER, await abnftContract.createAuthorizationMap(ERC6956Authorization.ALL))) + .to.be.equal(true); + + // ISSUER + await expect(await abnftContract.hasAuthorization(ERC6956Role.ISSUER, await abnftContract.createAuthorizationMap(ERC6956Authorization.NONE))) + .to.be.equal(false); + await expect(await abnftContract.hasAuthorization(ERC6956Role.ISSUER, await abnftContract.createAuthorizationMap(ERC6956Authorization.OWNER))) + .to.be.equal(false); + await expect(await abnftContract.hasAuthorization(ERC6956Role.ISSUER, await abnftContract.createAuthorizationMap(ERC6956Authorization.ISSUER))) + .to.be.equal(true); + await expect(await abnftContract.hasAuthorization(ERC6956Role.ISSUER, await abnftContract.createAuthorizationMap(ERC6956Authorization.ASSET))) + .to.be.equal(false); + await expect(await abnftContract.hasAuthorization(ERC6956Role.ISSUER, await abnftContract.createAuthorizationMap(ERC6956Authorization.OWNER_AND_ASSET))) + .to.be.equal(false); + await expect(await abnftContract.hasAuthorization(ERC6956Role.ISSUER, await abnftContract.createAuthorizationMap(ERC6956Authorization.OWNER_AND_ISSUER))) + .to.be.equal(true); + await expect(await abnftContract.hasAuthorization(ERC6956Role.ISSUER, await abnftContract.createAuthorizationMap(ERC6956Authorization.ASSET_AND_ISSUER))) + .to.be.equal(true); + await expect(await abnftContract.hasAuthorization(ERC6956Role.ISSUER, await abnftContract.createAuthorizationMap(ERC6956Authorization.ALL))) + .to.be.equal(true); + + + // ASSET + await expect(await abnftContract.hasAuthorization(ERC6956Role.ASSET, await abnftContract.createAuthorizationMap(ERC6956Authorization.NONE))) + .to.be.equal(false); + await expect(await abnftContract.hasAuthorization(ERC6956Role.ASSET, await abnftContract.createAuthorizationMap(ERC6956Authorization.OWNER))) + .to.be.equal(false); + await expect(await abnftContract.hasAuthorization(ERC6956Role.ASSET, await abnftContract.createAuthorizationMap(ERC6956Authorization.ISSUER))) + .to.be.equal(false); + await expect(await abnftContract.hasAuthorization(ERC6956Role.ASSET, await abnftContract.createAuthorizationMap(ERC6956Authorization.ASSET))) + .to.be.equal(true); + await expect(await abnftContract.hasAuthorization(ERC6956Role.ASSET, await abnftContract.createAuthorizationMap(ERC6956Authorization.OWNER_AND_ASSET))) + .to.be.equal(true); + await expect(await abnftContract.hasAuthorization(ERC6956Role.ASSET, await abnftContract.createAuthorizationMap(ERC6956Authorization.OWNER_AND_ISSUER))) + .to.be.equal(false); + await expect(await abnftContract.hasAuthorization(ERC6956Role.ASSET, await abnftContract.createAuthorizationMap(ERC6956Authorization.ASSET_AND_ISSUER))) + .to.be.equal(true); + await expect(await abnftContract.hasAuthorization(ERC6956Role.ASSET, await abnftContract.createAuthorizationMap(ERC6956Authorization.ALL))) + .to.be.equal(true); + }); +}); + + + describe("Attestation-based transfers", function () { + it("SHOULD not allow non-trusted oracles to issue attestation", async function () { + // Create the message to sign + const { abnftContract, oracle, mallory, gasProvider } = await loadFixture(deployAbNftFixture); + + const to = "0x1234567890123456789012345678901234567890"; + const anchor = merkleTestAnchors[0][0]; + const attestation = await createAttestation(to, anchor, oracle); + + const fraudAttestation = await createAttestation(to, anchor, mallory); + await expect(abnftContract['transferAnchor(bytes)'](fraudAttestation)) + .to.be.revertedWith("ERC6956-E8"); + }); + + it("SHOULD allow mint and transfer with valid attestations", async function() { + const { abnftContract, oracle, mintAttestationAlice, anchor, alice, bob, hacker, gasProvider } = await loadFixture(deployABTandMintTokenToAlice); + + const attestationBob = await createAttestation(bob.address, anchor, oracle); // Mint to alice + + await expect(abnftContract.connect(gasProvider)["transferAnchor(bytes)"](attestationBob)) + .to.emit(abnftContract, "Transfer") // Standard ERC721 event + .withArgs(alice.address, bob.address, 1) + .to.emit(abnftContract, "AnchorTransfer") + .withArgs(alice.address, bob.address, anchor, 1); + + // Token is now at bob... so alice may hire a hacker quickly and re-use her attestation to get + // the token back from Bob ... which shall of course not work + await expect(abnftContract.connect(hacker)["transferAnchor(bytes)"](mintAttestationAlice)) + .to.revertedWith("ERC6956-E9") // Standard ERC721 event + }) + + + it("SHOULDN'T allow safeTransfer per default", async function() { + const { abnftContract, alice, bob} = await loadFixture(deployABTandMintTokenToAlice); + + await expect(abnftContract.connect(alice).transferFrom(alice.address, bob.address, 1)) + .to.revertedWith("ERC6956-E5"); + }) + + it("SHOULDN'T allow approveAnchor followed by safeTransfer when anchor not floating", async function() { + const { abnftContract, anchor, oracle, alice, bob, gasProvider, mallory,carl} = await loadFixture(deployABTandMintTokenToAlice); + const tokenId = await abnftContract.tokenByAnchor(anchor); + + const attestationBob = await createAttestation(bob.address, anchor, oracle); // Mint to alice + + // somebody approves himself via attestation approves bob to act on her behalf + await expect(abnftContract.connect(gasProvider)["approveAnchor(bytes)"](attestationBob)) + .to.emit(abnftContract, "Approval") // Standard ERC721 event + .withArgs(await abnftContract.ownerOf(tokenId), bob.address, tokenId); + + // Should not allow mallory to transfer, since only bob is approved + await expect(abnftContract.connect(mallory).transferFrom(alice.address, bob.address, 1)) + .to.revertedWith("ERC721: caller is not token owner or approved"); + + // Even though Bob is approved, cannot transfer, since anchor is not floating + await expect(abnftContract.connect(bob).transferFrom(alice.address, carl.address, tokenId)) + .to.revertedWith("ERC6956-E5"); + }) + + it("SHOULDN't allow using attestations before validity ", async function() { + const { abnftContract, maintainer, oracle, alice } = await loadFixture(deployAbNftFixture); + const anchor = merkleTestAnchors[0][0]; + + // Let the oracle create an valid attestation (from the oracle's view) + const curTime = Math.floor(Date.now() / 1000.0); + const twoMinInFuture = curTime + 2 * 60; + const attestationAlice = await createAttestation(alice.address, anchor, oracle, twoMinInFuture); // Mint to alice + await expect(abnftContract.connect(alice)["transferAnchor(bytes)"](attestationAlice)) + .to.revertedWith("ERC6956-E10") + }) + }); + + describe("ERC721Burnable-compatible behavior", function () { + it("SHOULD burn like ERC-721 (direct)", async function() { + const { abnftContract, anchor, alice, bob} = await loadFixture(deployABTandMintTokenToAlice); + const tokenId = await abnftContract.tokenByAnchor(anchor); + + // Let bob try to burn... should not work + await expect(abnftContract.connect(bob).burn(tokenId)) + .to.revertedWith("ERC6956-E2"); + + // Alice then burns, which shall be transaction to 0x0 + await expect(abnftContract.connect(alice).burn(tokenId)) + .to.emit(abnftContract, "Transfer") + .withArgs( alice.address,NULLADDR, tokenId); + }) + it("SHOULD burn like ERC-721 (approved)", async function() { + const { abnftContract, owner, maintainer, oracle, mintAttestationAlice, anchor, alice, bob, mallory, hacker } = await loadFixture(deployABTandMintTokenToAlice); + const tokenId = await abnftContract.tokenByAnchor(anchor); + + // alice approves bob to act on her behalf + await expect(abnftContract.connect(alice).setApprovalForAll(bob.address, true)) + .to.emit(abnftContract, "ApprovalForAll") // Standard ERC721 event + .withArgs(alice.address, bob.address, true); + + // Let mallory try to burn... should not work + await expect(abnftContract.connect(mallory).burn(tokenId)) + .to.revertedWith("ERC6956-E2"); + + // Bob is approved, so bob can burn + await expect(abnftContract.connect(bob).burn(tokenId)) + .to.emit(abnftContract, "Transfer") + .withArgs(alice.address,NULLADDR, tokenId) + .to.emit(abnftContract, "AnchorTransfer") + .withArgs(alice.address,NULLADDR, anchor, tokenId); + }) + + it("SHOULD allow issuer to burn", async function() { + const { abnftContract, owner, maintainer, oracle, mintAttestationAlice, anchor, alice, bob, mallory, hacker } = await loadFixture(deployABTandMintTokenToAlice); + + const tokenId = await abnftContract.tokenByAnchor(anchor); + + await abnftContract.connect(maintainer).updateBurnAuthorization(ERC6956Authorization.ISSUER); + + // Let mallory try to burn... should not work + await expect(abnftContract.connect(mallory).burn(tokenId)) + .to.revertedWith("ERC6956-E2"); + + // Bob is approved, so bob can burn + await expect(abnftContract.connect(maintainer).burn(tokenId)) + .to.emit(abnftContract, "Transfer") + .withArgs(alice.address,NULLADDR, tokenId); + }) + + it("SHOULD burn like ERC-721 (via attestation-approved)", async function() { + const { abnftContract, oracle, anchor, alice, bob, mallory, hacker } = await loadFixture(deployABTandMintTokenToAlice); + const tokenId = await abnftContract.tokenByAnchor(anchor); + const attestationBob = await createAttestation(bob.address, anchor, oracle); // Mint to alice + + // somebody approves himself via attestation approves bob to act on her behalf + await expect(abnftContract.connect(hacker)["approveAnchor(bytes)"](attestationBob)) + .to.emit(abnftContract, "Approval") // Standard ERC721 event + .withArgs(await abnftContract.ownerOf(tokenId), bob.address, tokenId); + + // Let mallory try to burn... should not work + await expect(abnftContract.connect(mallory).burn(tokenId)) + .to.revertedWith("ERC6956-E2"); + + // Bob is approved, so bob can burn + await expect(abnftContract.connect(bob).burn(tokenId)) + .to.emit(abnftContract, "Transfer") + .withArgs(alice.address,NULLADDR, tokenId); + }) + + it("SHOULD burn like ERC-721 (attestation)", async function() { + const { abnftContract, oracle, mintAttestationAlice, anchor, alice, bob, mallory } = await loadFixture(deployABTandMintTokenToAlice); + const tokenId = await abnftContract.tokenByAnchor(anchor); + const burnAttestation = await createAttestation(bob.address, anchor, oracle); // Mint to alice + + // Let mallory try to burn a token based on the creation anchor.. + await expect(abnftContract.connect(mallory)["burnAnchor(bytes)"](mintAttestationAlice)) + .to.revertedWith("ERC6956-E9"); + + // Now, using a fresh attestation, the same guy can burn + await expect(abnftContract.connect(mallory)["burnAnchor(bytes)"](burnAttestation)) + .to.emit(abnftContract, "Transfer") + .withArgs(alice.address,NULLADDR, tokenId); + }) + + + it("SHOULD use same tokenId when anchor is used again after burning", async function() { + const { abnftContract, oracle, anchor, alice, bob, mallory } = await loadFixture(deployABTandMintTokenToAlice); + const tokenId = await abnftContract.tokenByAnchor(anchor); + + // Alice then burns her token, since she does no longer like it in her wallet. This shall be a transaction to 0x0 + await expect(abnftContract.connect(alice).burn(tokenId)) + .to.emit(abnftContract, "Transfer") + .withArgs( alice.address,NULLADDR, tokenId); + + // Bob gets the ASSET, confirmed by ORACLE. Since Alice burned tokenId 1 before, but we have the same anchor + // it is expected that BOB gets a new NFT with same tokenId + const attestationBob = await createAttestation(bob.address, anchor, oracle); // Mint to alice + await expect(abnftContract.connect(mallory)["transferAnchor(bytes)"](attestationBob)) + .to.emit(abnftContract, "Transfer") // Standard ERC721 event + .withArgs(NULLADDR, bob.address, tokenId); + }) +}); + + +describe("Metadata tests", function () { + it("SHOULD allow only maintainer to update baseURI", async function () { + // Create the message to sign + const { abnftContract, maintainer, mallory } = await loadFixture(deployABTandMintTokenToAlice); + + await expect(abnftContract.connect(mallory).updateBaseURI("http://test.xyz/")) + .to.revertedWith("ERC6956-E1"); + + await abnftContract.connect(maintainer).updateBaseURI("http://test.xyz/"); + // FIXME event would be nice + }); + + it("SHOULD use anchor for tokenURI", async function () { + // Create the message to sign + const { abnftContract, anchor, maintainer, alice, mallory } = await loadFixture(deployABTandMintTokenToAlice); + await abnftContract.connect(maintainer).updateBaseURI("http://test.xyz/collection/"); + + expect(await abnftContract.tokenURI(1)) + .to.be.equal("http://test.xyz/collection/0xaa0c61ccb0c754f1c68c699990a456c6073aaa28109c1bd83880c49dcece3d65"); + }); +}); + + +}); diff --git a/assets/eip-6956/test/ERC6956Full.ts b/assets/eip-6956/test/ERC6956Full.ts new file mode 100644 index 00000000000000..fd48f5ce7c2267 --- /dev/null +++ b/assets/eip-6956/test/ERC6956Full.ts @@ -0,0 +1,445 @@ +import { time, loadFixture } from "@nomicfoundation/hardhat-network-helpers"; +import { expect } from "chai"; +import { ethers } from "hardhat"; +import { createHash } from 'node:crypto'; +import { StandardMerkleTree } from "@openzeppelin/merkle-tree"; +import { float } from "hardhat/internal/core/params/argumentTypes"; +import { ERC6956Authorization, merkleTestAnchors, NULLADDR, AttestedTransferLimitUpdatePolicy, invalidAnchor, createAttestationWithData} from "./commons"; +import { IERC6956AttestationLimitedInterfaceId, IERC6956InterfaceId, IERC6956FloatableInterfaceId, IERC6956ValidAnchorsInterfaceId} from "./commons"; + +export enum FloatState { + Default, // 0, inherits from floatAll + Floating, // 1 + Anchored // 2 +} + +describe("ERC6956: Asset-Bound NFT --- Full", function () { + // Fixture to deploy the abnftContract contract and assigne roles. + // Besides owner there's user, minter and burner with appropriate roles. + async function deployAbNftFixture() { + // Contracts are deployed using the first signer/account by default + const [owner, maintainer, oracle, alice, bob, mallory, hacker, carl, gasProvider ] = await ethers.getSigners(); + + return actuallyDeploy(10, AttestedTransferLimitUpdatePolicy.FLEXIBLE); + } + + async function deployAbNftAndMintTokenToAliceFixture() { + // Contracts are deployed using the first signer/account by default + const {abnftContract, merkleTree, owner, maintainer, oracle, alice, bob, mallory, hacker, carl, gasProvider} = await deployAbNftFixture(); + + const anchor = merkleTestAnchors[0][0]; + const [mintAttestationAlice, dataAlice] = await createAttestationWithData(alice.address, anchor, oracle, merkleTree); // Mint to alice + + const expectedTokenId = 1; + await expect(abnftContract.connect(gasProvider)["transferAnchor(bytes,bytes)"](mintAttestationAlice, dataAlice)) + .to.emit(abnftContract, "Transfer") // Standard ERC721 event + .withArgs(NULLADDR, alice.address, expectedTokenId) + + return { abnftContract, merkleTree, owner, maintainer, oracle, mintAttestationAlice, anchor, alice, bob, mallory, hacker, carl, gasProvider }; + } + + async function actuallyDeploy(attestationLimitPerAnchor: number, limitUpdatePolicy: AttestedTransferLimitUpdatePolicy) { + const [owner, maintainer, oracle, alice, bob, mallory, hacker, carl, gasProvider ] = await ethers.getSigners(); + + const AbNftContract = await ethers.getContractFactory("ERC6956Full"); + + const abnftContract = await AbNftContract.connect(owner).deploy("Asset-Bound NFT test", "ABNFT", limitUpdatePolicy); + await abnftContract.connect(owner).updateMaintainer(maintainer.address, true); + + // set attestation Limit per anchor + await abnftContract.connect(maintainer).updateGlobalAttestationLimit(attestationLimitPerAnchor); + + // Create Merkle Tree + const merkleTree = StandardMerkleTree.of(merkleTestAnchors, ["bytes32"]); + await abnftContract.connect(maintainer).updateValidAnchors(merkleTree.root); + + await expect(abnftContract.connect(maintainer).updateOracle(oracle.address, true)) + .to.emit(abnftContract, "OracleUpdate") + .withArgs(oracle.address, true); + + // Uncomment to see the merkle tree. + // console.log(merkleTree.dump()); + + return { abnftContract, merkleTree, owner, maintainer, oracle, alice, bob, mallory, hacker, carl, gasProvider }; + } + + async function deployForAttestationLimit(limit: number, policy: AttestedTransferLimitUpdatePolicy) { + return actuallyDeploy(limit, policy); + } + + describe("Deployment & Settings", function () { + it("Should implement EIP-165 support the EIP-6956 interface", async function () { + const { abnftContract } = await loadFixture(deployAbNftFixture); + + expect(await abnftContract.supportsInterface(IERC6956InterfaceId)).to.equal(true); + expect(await abnftContract.supportsInterface(IERC6956FloatableInterfaceId)).to.equal(true); + expect(await abnftContract.supportsInterface(IERC6956ValidAnchorsInterfaceId)).to.equal(true); + expect(await abnftContract.supportsInterface(IERC6956AttestationLimitedInterfaceId)).to.equal(true); + }); + }); + + +describe("Valid Anchors (merkle-trees)", function () { + it("SHOULDN't allow attesting arbitrary anchors", async function() { + const { abnftContract, merkleTree, maintainer, oracle, alice, hacker } = await loadFixture(deployAbNftFixture); + + // Publish root node of a made up tree, s.t. all proofs we use are from a different tree + const madeUpRootNode = '0xaaaaaaaab0c754f1c68c699990a456c6073aaa28109c1bd83880c49dcece3f65'; // random string + abnftContract.connect(maintainer).updateValidAnchors(madeUpRootNode) + const anchor = merkleTestAnchors[0][0]; + + // Let the oracle create an valid attestation (from the oracle's view) + const [attestationAlice, dataAlice] = await createAttestationWithData(alice.address, anchor, oracle, merkleTree); // Mint to alice + await expect(abnftContract.connect(hacker)["transferAnchor(bytes,bytes)"](attestationAlice, dataAlice)) + .to.revertedWith("ERC6956-E26") + }); +}); + +describe("Anchor-Floating", function () { + it("SHOULD only allow maintainer to specify canStartFloating and canStopFloating", async function () { + const { abnftContract, merkleTree, owner, maintainer, mallory } = await loadFixture(deployAbNftAndMintTokenToAliceFixture); + + await expect(abnftContract.connect(mallory).updateFloatingAuthorization(ERC6956Authorization.ALL, ERC6956Authorization.ALL)) + .to.revertedWith("ERC6956-E1"); + + await expect(abnftContract.connect(maintainer).updateFloatingAuthorization(ERC6956Authorization.OWNER_AND_ASSET, ERC6956Authorization.ISSUER)) + .to.emit(abnftContract, "FloatingAuthorizationChange") + .withArgs(ERC6956Authorization.OWNER_AND_ASSET, ERC6956Authorization.ISSUER, maintainer.address); + }); + + it("SHOULD only allow maintainer to modify floatAll behavior w/o affecting previous tokens", async function () { + const { abnftContract, merkleTree, anchor, owner, maintainer, alice, bob, oracle, mallory, gasProvider } = await loadFixture(deployAbNftAndMintTokenToAliceFixture); + + // --------------------------------------------------------------------------------- ALL FLOATING = FALSE + await expect(abnftContract.connect(maintainer).updateFloatingAuthorization(ERC6956Authorization.OWNER_AND_ASSET, ERC6956Authorization.ISSUER)) + .to.emit(abnftContract, "FloatingAuthorizationChange") + .withArgs(ERC6956Authorization.OWNER_AND_ASSET, ERC6956Authorization.ISSUER, maintainer.address); + + // anchor does not float by default + // FLOATING ALL, so both have to float + expect(await abnftContract.floating(anchor)) + .to.be.equal(false); // one was used to mint + + // Now alice, as the owner decides to make it explicitely floatable + expect(await abnftContract.connect(alice).float(anchor, FloatState.Floating)) + .to.emit(abnftContract, "FloatingStateChange") + .withArgs(anchor, 1, FloatState.Floating, alice.address) + + // It is now explicitely floatable + expect(await abnftContract.floating(anchor)) + .to.be.equal(true); // one was used to mint + + + // Mallory mustnot be able to change default behavior + await expect(abnftContract.connect(mallory).floatAll(true)) + .to.revertedWith("ERC6956-E1"); + + // --------------------------------------------------------------------------------- ALL FLOATING = TRUE + // Maintainer must be able to update + await expect(abnftContract.connect(maintainer).floatAll(true)) + .to.emit(abnftContract, "FloatingAllStateChange") + .withArgs(true, maintainer.address); + + const implicitFloatingAnchor = merkleTestAnchors[1][0]; + const [mintToBobAttestation, mintToBobData] = await createAttestationWithData(bob.address, implicitFloatingAnchor, oracle, merkleTree); // Mint to alice + const expectedTokenId = 2; + + // Mint a new token... + await expect(abnftContract.connect(gasProvider)["transferAnchor(bytes,bytes)"](mintToBobAttestation, mintToBobData)) + .to.emit(abnftContract, "Transfer") + .withArgs(NULLADDR, bob.address, expectedTokenId) + + // FLOATING ALL, so both have to float + expect(await abnftContract.floating(anchor)) + .to.be.equal(true); // one was used to mint + + expect(await abnftContract.floating(implicitFloatingAnchor)) + .to.be.equal(true); // one was used to mint + + // --------------------------------------------------------------------------------- ALL FLOATING = FALSE + // REVERT THE FLOATING .... Maintainer must be able to update + await expect(abnftContract.connect(maintainer).floatAll(false)) + .to.emit(abnftContract, "FloatingAllStateChange") + .withArgs(false, maintainer.address); + + + // we expect the original anchor for alice to not be floating, and the new anchor from float to be floating + expect(await abnftContract.floating(anchor)) + .to.be.equal(true); + + expect(await abnftContract.floating(implicitFloatingAnchor)) + .to.be.equal(false); // this was only floating because of floatAll at the time of mint... + }); + + it("SHOULD allow owner to float token only when OWNER is allowed", async function () { + const { abnftContract, anchor, maintainer, alice, mallory } = await loadFixture(deployAbNftAndMintTokenToAliceFixture); + const tokenId = await abnftContract.tokenByAnchor(anchor); + + await expect(abnftContract.connect(maintainer).updateFloatingAuthorization(ERC6956Authorization.ASSET_AND_ISSUER, ERC6956Authorization.ASSET_AND_ISSUER)) + .to.emit(abnftContract, "FloatingAuthorizationChange") + .withArgs(ERC6956Authorization.ASSET_AND_ISSUER, ERC6956Authorization.ASSET_AND_ISSUER, maintainer.address); + + await expect(abnftContract.connect(alice).float(anchor, FloatState.Floating)) + .to.revertedWith("ERC6956-E21") + + await expect(abnftContract.connect(maintainer).updateFloatingAuthorization(ERC6956Authorization.OWNER_AND_ASSET, ERC6956Authorization.OWNER_AND_ASSET)) + .to.emit(abnftContract, "FloatingAuthorizationChange") + .withArgs(ERC6956Authorization.OWNER_AND_ASSET, ERC6956Authorization.OWNER_AND_ASSET, maintainer.address); + + await expect(abnftContract.connect(alice).float(anchor, FloatState.Floating)) + .to.emit(abnftContract, "FloatingStateChange") + .withArgs(anchor, tokenId, FloatState.Floating, alice.address); + }); + + it("SHOULD only allow owner to transfer token when floating", async function () { + const { abnftContract, anchor, maintainer, alice, bob, mallory } = await loadFixture(deployAbNftAndMintTokenToAliceFixture); + const tokenId = await abnftContract.tokenByAnchor(anchor); + + await expect(abnftContract.connect(maintainer).updateFloatingAuthorization(ERC6956Authorization.OWNER_AND_ASSET, ERC6956Authorization.OWNER_AND_ASSET)) + .to.emit(abnftContract, "FloatingAuthorizationChange") + .withArgs(ERC6956Authorization.OWNER_AND_ASSET, ERC6956Authorization.OWNER_AND_ASSET, maintainer.address); + + await expect(abnftContract.connect(alice).float(anchor, FloatState.Floating)) + .to.emit(abnftContract, "FloatingStateChange") + .withArgs(anchor, tokenId, FloatState.Floating, alice.address); + + await expect(abnftContract.connect(mallory).transferFrom(alice.address, mallory.address, tokenId)) + .to.revertedWith("ERC721: caller is not token owner or approved"); + + await expect(abnftContract.connect(alice).transferFrom(alice.address, bob.address, tokenId)) + .to.emit(abnftContract, "Transfer") + .withArgs(alice.address,bob.address, tokenId); + }); + + it("SHOULDN'T allow owner to transfer token when explicitely marked anchored", async function () { + const { abnftContract, anchor, maintainer, alice, bob, mallory } = await loadFixture(deployAbNftAndMintTokenToAliceFixture); + const tokenId = await abnftContract.tokenByAnchor(anchor); + + await expect(abnftContract.connect(maintainer).updateFloatingAuthorization(ERC6956Authorization.ISSUER, ERC6956Authorization.ISSUER)) + .to.emit(abnftContract, "FloatingAuthorizationChange") + .withArgs(ERC6956Authorization.ISSUER, ERC6956Authorization.ISSUER, maintainer.address); + + // Maintainer must be able to update + await expect(abnftContract.connect(maintainer).floatAll(true)) + .to.emit(abnftContract, "FloatingAllStateChange") + .withArgs(true, maintainer.address); + + expect(await abnftContract.floating(anchor)) + .to.be.equal(true); // one was used to mint + + await expect(abnftContract.connect(maintainer).float(anchor, FloatState.Anchored)) + .to.emit(abnftContract, "FloatingStateChange") + .withArgs(anchor, tokenId, FloatState.Anchored, maintainer.address); + + expect(await abnftContract.floating(anchor)) + .to.be.equal(false); // one was used to mint + + await expect(abnftContract.connect(alice).transferFrom(alice.address, bob.address, tokenId)) + .to.revertedWith("ERC6956-E5") + }); + + + it("SHOULD allow maintainer to float ANY token only when ISSUER is allowed", async function () { + const { abnftContract, anchor, maintainer, mallory } = await loadFixture(deployAbNftAndMintTokenToAliceFixture); + const tokenId = await abnftContract.tokenByAnchor(anchor); + + await expect(abnftContract.connect(maintainer).updateFloatingAuthorization(ERC6956Authorization.OWNER_AND_ASSET, ERC6956Authorization.OWNER_AND_ASSET)) + .to.emit(abnftContract, "FloatingAuthorizationChange") + .withArgs(ERC6956Authorization.OWNER_AND_ASSET, ERC6956Authorization.OWNER_AND_ASSET, maintainer.address); + + await expect(abnftContract.connect(maintainer).float(anchor, FloatState.Floating)) + .to.revertedWith("ERC6956-E21") + + await expect(abnftContract.connect(maintainer).updateFloatingAuthorization(ERC6956Authorization.ISSUER, ERC6956Authorization.ISSUER)) + .to.emit(abnftContract, "FloatingAuthorizationChange") + .withArgs(ERC6956Authorization.ISSUER, ERC6956Authorization.ISSUER, maintainer.address); + + await expect(abnftContract.connect(maintainer).float(anchor, FloatState.Floating)) + .to.emit(abnftContract, "FloatingStateChange") + .withArgs(anchor, tokenId, FloatState.Floating, maintainer.address); + }); + + it("SHOULD allow maintainer to float HIS OWN token when OWNER is allowed", async function () { + const { abnftContract, anchor, alice, maintainer, oracle, merkleTree, gasProvider } = await loadFixture(deployAbNftAndMintTokenToAliceFixture); + const tokenId = await abnftContract.tokenByAnchor(anchor); + + // Anchor should not be floating by default... + expect(await abnftContract.floating(anchor)) + .to.be.equal(false); // one was used to mint + + await expect(abnftContract.connect(maintainer).updateFloatingAuthorization(ERC6956Authorization.OWNER, ERC6956Authorization.OWNER)) + .to.emit(abnftContract, "FloatingAuthorizationChange") + .withArgs(ERC6956Authorization.OWNER, ERC6956Authorization.OWNER, maintainer.address); + + await expect(abnftContract.connect(maintainer).float(anchor, FloatState.Floating)) + .to.revertedWith("ERC6956-E21") + + const [attestationMaintainer, dataMaintainer] = await createAttestationWithData(maintainer.address, anchor, oracle, merkleTree); + await expect(abnftContract.connect(gasProvider)["transferAnchor(bytes,bytes)"](attestationMaintainer, dataMaintainer)) + .to.emit(abnftContract, "Transfer") + .withArgs(alice.address, maintainer.address, tokenId) + + // Now maintainer owns the token, hence he is owner and can indeed change floating + await expect(abnftContract.connect(maintainer).float(anchor, FloatState.Floating)) + .to.emit(abnftContract, "FloatingStateChange") + .withArgs(anchor, tokenId, FloatState.Floating, maintainer.address); + + expect(await abnftContract.floating(anchor)) + .to.be.equal(true); // one was used to mint + }); + + it("SHOULD allow approveAnchor followed by safeTransfer when anchor IS floating", async function() { + const { abnftContract, anchor, maintainer, oracle, merkleTree, alice, bob, gasProvider, mallory,carl} = await loadFixture(deployAbNftAndMintTokenToAliceFixture); + const tokenId = await abnftContract.tokenByAnchor(anchor); + const [attestationBob, dataBob] = await createAttestationWithData(bob.address, anchor, oracle, merkleTree); // Transfer to bob + + await expect(abnftContract.connect(maintainer).updateFloatingAuthorization(ERC6956Authorization.OWNER, ERC6956Authorization.OWNER)) + .to.emit(abnftContract, "FloatingAuthorizationChange") + .withArgs(ERC6956Authorization.OWNER, ERC6956Authorization.OWNER, maintainer.address); + + // somebody approves himself via attestation approves bob to act on her behalf + await expect(abnftContract.connect(gasProvider)["approveAnchor(bytes,bytes)"](attestationBob,dataBob)) + .to.emit(abnftContract, "Approval") // Standard ERC721 event + .withArgs(await abnftContract.ownerOf(tokenId), bob.address, tokenId); + + // Should not allow mallory to transfer, since only bob is approved + await expect(abnftContract.connect(mallory).transferFrom(alice.address, bob.address, 1)) + .to.revertedWith("ERC721: caller is not token owner or approved"); + + // Bob makes it floatable (which is possible, because he is approved) + await expect(abnftContract.connect(bob).float(anchor, FloatState.Floating)) + .to.emit(abnftContract, "FloatingStateChange") + .withArgs(anchor, tokenId, FloatState.Floating, bob.address); + + // Bob transfers it... + await expect(abnftContract.connect(bob).transferFrom(alice.address, carl.address, tokenId)) + .to.emit(abnftContract, "Transfer") + .withArgs(alice.address,carl.address, tokenId); + }) +}); + +describe("Attested Transfer Limits", function () { + it("SHOULD count attested transfers (transfer, burn, approve)", async function () { + const { abnftContract, anchor, maintainer, oracle, merkleTree, alice, bob, gasProvider, mallory,carl} = await loadFixture(deployAbNftAndMintTokenToAliceFixture); + const tokenId = await abnftContract.tokenByAnchor(anchor); + const [attestationBob, dataBob] = await createAttestationWithData(bob.address, anchor, oracle, merkleTree); // Mint to alice + const [attestationCarl, dataCarl] = await createAttestationWithData(carl.address, anchor, oracle, merkleTree); // Mint to alice + + + // Transfers shall be counted - also the one from the fixture + expect(await abnftContract.attestationsUsedByAnchor(anchor)) + .to.be.equal(1); + + // Should increase count by 1 + await expect(abnftContract["approveAnchor(bytes,bytes)"](attestationBob, dataBob)) + .to.emit(abnftContract, "Approval") // Standard ERC721 event + .withArgs(await abnftContract.ownerOf(tokenId), bob.address, tokenId); + + // Should increase count by 1 + await expect(abnftContract["burnAnchor(bytes,bytes)"](attestationCarl, dataCarl)) + .to.emit(abnftContract, "Transfer") + .withArgs(alice.address, NULLADDR, tokenId); + + // InitialMint + Approve + Burns shall also be counted - also the one from the fixture + expect(await abnftContract.attestationsUsedByAnchor(anchor)) + .to.be.equal(3); + + // Should return 0 for invalid anchors + expect(await abnftContract.attestationsUsedByAnchor(invalidAnchor)) + .to.be.equal(0); + }); + + it("SHOULD allow maintainer to update global attestation limit", async function () { + const { abnftContract, maintainer, oracle, merkleTree, alice, bob, gasProvider, mallory,carl} = await deployForAttestationLimit(10, AttestedTransferLimitUpdatePolicy.FLEXIBLE); + + await expect(abnftContract.connect(mallory).updateGlobalAttestationLimit(5)) + .to.revertedWith("ERC6956-E1"); + + // Should be able to update + await expect(abnftContract.connect(maintainer).updateGlobalAttestationLimit(5)) + .to.emit(abnftContract, "GlobalAttestationLimitUpdate") // Standard ERC721 event + .withArgs(5, maintainer.address); + + // Check effect, but requesting transfers left from a non-existent anchor + expect(await abnftContract.attestationUsagesLeft(invalidAnchor)) + .to.be.equal(5); + }); + + it("Should allow maintainer to update anchor-based attestation limit w/o changing global limits", async function () { + const globalLimit = 10; + const specificAnchorLimit = 5; + const { abnftContract, maintainer, oracle, merkleTree, alice, bob, gasProvider, mallory,carl} = await deployForAttestationLimit(globalLimit, AttestedTransferLimitUpdatePolicy.FLEXIBLE); + + const anchor = merkleTestAnchors[0][0]; + const [mintAttestationAlice, mintDataAlice] = await createAttestationWithData(alice.address, anchor, oracle, merkleTree); // Mint to alice + const tokenId = 1; + + await expect(abnftContract.connect(gasProvider)["transferAnchor(bytes,bytes)"](mintAttestationAlice, mintDataAlice)) + .to.emit(abnftContract, "Transfer") // Standard ERC721 event + .withArgs(NULLADDR, alice.address, tokenId); + + + // Note that an anchor does not need to exist yet for playing with the limits + // Check effect, but requesting transfers left from a non-existent anchor + expect(await abnftContract.attestationUsagesLeft(invalidAnchor)) + .to.be.equal(globalLimit); + + // Should be able to update + await expect(abnftContract.connect(maintainer).updateAttestationLimit(anchor, specificAnchorLimit)) + .to.emit(abnftContract, "AttestationLimitUpdate") // Standard ERC721 event + .withArgs(anchor, tokenId, specificAnchorLimit, maintainer.address); + + // Check unchanged global effect, but requesting transfers left from a non-existent anchor + expect(await abnftContract.attestationUsagesLeft(invalidAnchor)) + .to.be.equal(globalLimit); + + // Check verify effect + expect(await abnftContract.attestationUsagesLeft(anchor)) + .to.be.equal(specificAnchorLimit-1); // 1 has been used to mint + }); + + it("Should enforce anchor limits (global + local)", async function () { + const globalLimit = 2; + const specificAnchorLimit = 1; + const { abnftContract, maintainer, oracle, merkleTree, alice, bob, gasProvider, mallory,carl, hacker} = await deployForAttestationLimit(globalLimit, AttestedTransferLimitUpdatePolicy.FLEXIBLE); + const anchor = merkleTestAnchors[0][0]; // can be transferred twice + const limitedAnchor = merkleTestAnchors[1][0]; // can be transferred once + + const [anchorToAlice, anchorToAliceData] = await createAttestationWithData(alice.address, anchor, oracle, merkleTree); // Mint to alice + const [anchorToBob, anchorToBobData] = await createAttestationWithData(bob.address, anchor, oracle, merkleTree); // Transfer to bob + const [anchorToHacker, anchorToHackerData] = await createAttestationWithData(hacker.address, anchor, oracle, merkleTree); // Limit reached! + + const [limitedAnchorToCarl, limitedAnchorToCarlData] = await createAttestationWithData(carl.address, limitedAnchor, oracle, merkleTree); // Mint to carl + const [limitedAnchorToMallory, limitedAnchorToMalloryData] = await createAttestationWithData(mallory.address, limitedAnchor, oracle, merkleTree); // Limit reached! + + expect(await abnftContract.attestationUsagesLeft(anchor)) + .to.be.equal(globalLimit); + + // ####################################### FIRST ANCHOR + await expect(abnftContract.connect(gasProvider)["transferAnchor(bytes,bytes)"](anchorToAlice, anchorToAliceData)) + .to.emit(abnftContract, "Transfer"); + + await expect(abnftContract.connect(gasProvider)["transferAnchor(bytes,bytes)"](anchorToBob, anchorToBobData)) + .to.emit(abnftContract, "Transfer"); + + await expect(abnftContract.connect(gasProvider)["transferAnchor(bytes,bytes)"](anchorToHacker, anchorToHackerData)) + .to.revertedWith("ERC6956-E24"); + + // ###################################### SECOND ANCHOR + await expect(abnftContract.connect(gasProvider)["transferAnchor(bytes,bytes)"](limitedAnchorToCarl, limitedAnchorToCarlData)) + .to.emit(abnftContract, "Transfer"); + + // Update anchor based limit + await expect(abnftContract.connect(maintainer).updateAttestationLimit(limitedAnchor, specificAnchorLimit)) + .to.emit(abnftContract, "AttestationLimitUpdate") + .withArgs(limitedAnchor, 2, specificAnchorLimit, maintainer.address); + + expect(await abnftContract.attestationUsagesLeft(limitedAnchor)) + .to.be.equal(specificAnchorLimit-1); // one was used to mint + + await expect(abnftContract.connect(gasProvider)["transferAnchor(bytes,bytes)"](limitedAnchorToMallory, limitedAnchorToMalloryData)) + .to.revertedWith("ERC6956-E24"); + }); +}); + +}); diff --git a/assets/eip-6956/test/commons.ts b/assets/eip-6956/test/commons.ts new file mode 100644 index 00000000000000..9b411c3e970bec --- /dev/null +++ b/assets/eip-6956/test/commons.ts @@ -0,0 +1,77 @@ +import { ethers } from "hardhat"; +import { createHash } from 'node:crypto'; +import { StandardMerkleTree } from "@openzeppelin/merkle-tree"; +import { float } from "hardhat/internal/core/params/argumentTypes"; + + +export enum ERC6956Authorization { + NONE,// = 0, // None of the above - a 1:1 relationship is maintained + OWNER,// = (1 << 1), // The owner of the token, i.e. the digital representation + ISSUER,// = (1 << 2), // The issuer of the tokens, i.e. this smart contract + ASSET,// = (1<< 3), // The asset, i.e. via attestation + OWNER_AND_ISSUER,// = (1<<1) | (1<<2), + OWNER_AND_ASSET,// = (1<<1) | (1<<3), + ASSET_AND_ISSUER,// = (1<<3) | (1<<2), + ALL// = (1<<1) | (1<<2) | (1<<3) // Owner + Issuer + Asset + } + +export enum ERC6956Role { + OWNER, + ISSUER, + ASSET + } + +export enum AttestedTransferLimitUpdatePolicy { + IMMUTABLE, + INCREASE_ONLY, + DECREASE_ONLY, + FLEXIBLE + } + +export const invalidAnchor = '0x' + createHash('sha256').update('TestAnchor1239').digest('hex'); +export const NULLADDR = ethers.utils.getAddress('0x0000000000000000000000000000000000000000'); + + // Needs to be an odd number of anchors to test the edge case of the merkle- + // tree: Nodes with only one leaf. + // Also: When building the tree (see buildMerkleTree fixture) those hashes are + // hashed again. This is intended because of the way Merkle-Proof and our + // smart contract works: + // Proof = H(leave) + H(L1) + H(L0) + // Our contract uses hashed anchor numbers as identifiers. + // Hence if we use direct anchor number checksums, H(leave) would + // be an actually valid anchor number on the smart contract. + export const merkleTestAnchors = [ + ['0x' + createHash('sha256').update('TestAnchor123').digest('hex')], + ['0x' + createHash('sha256').update('TestAnchor124').digest('hex')], + ['0x' + createHash('sha256').update('TestAnchor125').digest('hex')], + ['0x' + createHash('sha256').update('TestAnchor126').digest('hex')], + ['0x' + createHash('sha256').update('TestAnchor127').digest('hex')] + ] + + +export async function createAttestation(to, anchor, signer, validStartTime= 0) { + const attestationTime = Math.floor(Date.now() / 1000.0); // Now in seconds + const expiryTime = attestationTime + 5 * 60; // 5min valid + + const messageHash = ethers.utils.solidityKeccak256(["address", "bytes32", "uint256", 'uint256', "uint256"], [to, anchor, attestationTime, validStartTime, expiryTime]); + const sig = await signer.signMessage(ethers.utils.arrayify(messageHash)); + + return ethers.utils.defaultAbiCoder.encode(['address', 'bytes32', 'uint256', 'uint256', 'uint256', 'bytes'], [to, anchor, attestationTime, validStartTime, expiryTime, sig]); +} + + +export async function createAttestationWithData(to, anchor, signer, merkleTree, validStartTime= 0) { + + const attestation = await createAttestation(to, anchor, signer, validStartTime); // Now in seconds + + const proof = merkleTree.getProof([anchor]); + const data = ethers.utils.defaultAbiCoder.encode(['bytes32[]'], [proof]) + + return [attestation, data]; +} + + +export const IERC6956InterfaceId = '0xa9cf7635'; +export const IERC6956AttestationLimitedInterfaceId ='0x75a2e933' +export const IERC6956FloatableInterfaceId = '0xf82773f7'; +export const IERC6956ValidAnchorsInterfaceId = '0x051c9bd8'; From d7eeef544ca2aedaa0f9c5d900c962edea0b416c Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Ernesto=20Garc=C3=ADa?= Date: Mon, 22 May 2023 16:02:30 -0600 Subject: [PATCH 11/97] Update EIP-6093: EIP-6093 Adjustment to ERC155 error Merged by EIP-Bot. --- EIPS/eip-6093.md | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/EIPS/eip-6093.md b/EIPS/eip-6093.md index 9077991f36ee5f..86e2211d9bc7c7 100644 --- a/EIPS/eip-6093.md +++ b/EIPS/eip-6093.md @@ -178,7 +178,7 @@ Used in transfers. - MUST be used for disallowed transfers from the zero address. - MUST NOT be used for approval operations. - MUST NOT be used for balance or allowance requirements. - - Use `ERC1155InsufficientBalance` or `ERC1155InsufficientApproval` instead. + - Use `ERC1155InsufficientBalance` or `ERC1155InsufficientApprovalForAll` instead. #### `ERC1155InvalidReceiver(address receiver)` @@ -189,7 +189,7 @@ Used in transfers. - MUST be used for disallowed transfers to non-`ERC1155TokenReceiver` contracts or those that reject a transfer. (eg. returning an invalid response in `onERC1155Received`). - MUST NOT be used for approval operations. -#### `ERC1155InsufficientApproval(address operator, uint256 tokenId)` +#### `ERC1155InsufficientApprovalForAll(address operator, address owner)` Indicates a failure with the `operator`'s approval in a transfer. Used in transfers. @@ -369,7 +369,7 @@ interface ERC1155Errors { error ERC1155InsufficientBalance(address sender, uint256 balance, uint256 needed, uint256 tokenId); error ERC1155InvalidSender(address sender); error ERC1155InvalidReceiver(address receiver); - error ERC1155InsufficientApproval(address operator, uint256 tokenId); + error ERC1155InsufficientApprovalForAll(address operator, address owner) error ERC1155InvalidApprover(address approver); error ERC1155InvalidOperator(address operator); error ERC1155InvalidArrayLength(uint256 idsLength, uint256 valuesLength); From ef5fe548ea04551e27aab392d6f6b77e997207ac Mon Sep 17 00:00:00 2001 From: ZhengQi Date: Wed, 24 May 2023 13:27:40 +0800 Subject: [PATCH 12/97] Add EIP: Order Book DEX with Two Phase Withdrawal Merged by EIP-Bot. --- EIPS/eip-6787.md | 93 +++++++++++++++++++++++++++++++++++++ assets/eip-6787/image1.png | Bin 0 -> 350070 bytes 2 files changed, 93 insertions(+) create mode 100644 EIPS/eip-6787.md create mode 100644 assets/eip-6787/image1.png diff --git a/EIPS/eip-6787.md b/EIPS/eip-6787.md new file mode 100644 index 00000000000000..0656bb65ba3d60 --- /dev/null +++ b/EIPS/eip-6787.md @@ -0,0 +1,93 @@ +--- +eip: 6787 +title: Order Book DEX with Two Phase Withdrawal +description: An order book-based DEX Interface that ensures the asset security of both users and the exchange +author: Jessica (@qizheng09), Roy (@royshang), Jun (@SniperUsopp) +discussions-to: https://ethereum-magicians.org/t/order-book-dex-standard/13573 +status: Draft +type: Standards Track +category: ERC +created: 2023-03-27 +--- + + +## Abstract + +The Order Book DEX Standard is a proposed set of interface specifications that define a decentralized exchange (DEX) protocol for trading assets using order books. This standard provides a set of functions that allow users to deposit, withdraw, and trade assets on a decentralized exchange. Additionally, it proposes a novel two-phase withdrawal scheme to ensure the asset security of both users and the exchange, addressing users' trust issues with the exchange. + +## Motivation + +Decentralized exchanges (DEXs) have become increasingly popular in recent years due to their ability to provide users with greater control over their assets and reduce reliance on centralized intermediaries. However, many existing DEX protocols suffer from issues such as low liquidity and inefficient price discovery. Order book-based DEXs based Layer2 have emerged as a popular alternative, but there is currently no standardized interface for implementing such exchanges. + +The Order Book DEX Standard aims to provide developers with a common interface for building interoperable order book-based DEXs that can benefit from network effects. By establishing a standard set of functions for depositing, withdrawing, and forced withdrawals, the Order Book DEX Standard can fully ensure the security of user assets. At the same time, the two-phase forced withdrawal mechanism can also prevent malicious withdrawals from users targeting the exchange. + +The two phase commit protocol is an important distributed consistency protocol, aiming to ensure data security and consistency in distributed systems. In the Layer2 order book DEX system, to enhance user experience and ensure financial security, we adopt a 1:1 reserve strategy, combined with a decentralized clearing and settlement interface, and a forced withdrawal function to fully guarantee users' funds. + +However, such design also faces potential risks. When users engage in perpetual contract transactions, they may incur losses. In this situation, malicious users might exploit the forced withdrawal function to evade losses. To prevent this kind of attack, we propose a two-phase forced withdrawal mechanism. + +By introducing the two phase forced withdrawal function, we can protect users' financial security while ensuring the security of the exchange's assets. In the first phase, the system will conduct a preliminary review of the user's withdrawal request to confirm the user's account status. In the second phase, after the forced withdrawal inspection period, users can directly submit the forced withdrawal request to complete the forced withdrawal process. In this way, we can not only prevent users from exploiting the forced withdrawal function to evade losses but also ensure the asset security for both the exchange and the users. + +In conclusion, by adopting the two phase commit protocol and the two phase forced withdrawal function, we can effectively guard against malicious behaviors and ensure data consistency and security in distributed systems while ensuring user experience and financial security. + +## Specification + +### Interfaces + +The Order Book DEX Standard defines the following Interfaces: + +#### `deposit` + +`function deposit(address token, uint256 amount) external;` + +The **deposit** function allows a user to deposit a specified amount of a particular token to the exchange. The *token* parameter specifies the address of the token contract, and the *amount* parameter specifies the amount of the token to be deposited. + +#### `withdraw` + +`function withdraw(address token, uint256 amount) external;` + +The **withdraw** function allows a user to withdraw a specified amount of a particular token from the exchange. The *token* parameter specifies the address of the token contract, and the *amount* parameter specifies the amount of the token to be withdrawn. + +#### `prepareForceWithdraw` + +`function prepareForceWithdraw(address token, uint256 amount) external returns (uint256 requestID);` + +The assets deposited by users will be stored in the exchange contract's account, and the exchange can achieve real-time 1:1 reserve proof. The **prepareForceWithdraw** function is used for users to initiate a forced withdrawal of a certain amount of a specified token. This function indicates that the user wants to perform a forced withdrawal and can submit the withdrawal after the default timeout period. Within the timeout period, the exchange needs to confirm that the user's order status meets the expected criteria, and forcibly cancel the user's order and settle the trade to avoid malicious attacks by the user. This function takes the following parameters: + +1. *token*: the address of the token to be withdrawn +2. *amount*: the amount of the token to be withdrawn + +Since an account may initiate multiple two phase forced withdrawals in parallel, each forced withdrawal needs to return a unique *requestID*. The function returns a unique *requestID* that can be used to submit the forced withdrawal using the commitForceWithdraw function. + +#### `commitForceWithdraw` + +`function commitForceWithdraw(uint256 requestID) external;` + +1. *requestID*: the request ID of the two phase Withdraw + +The **commitForceWithdraw** function is used to execute a forced withdrawal operation after the conditions are met. The function takes a *requestID* parameter, which specifies the ID of the forced withdrawal request to be executed. The request must have been previously initiated using the prepareForceWithdraw function. + +### Events + +#### `PrepareForceWithdraw` + +MUST trigger when user successful call to PrepareForceWithdraw. + +`event PrepareForceWithdraw(address indexed user, address indexed tokenAddress, uint256 amount);` + +## Rationale + +The flow charts for two-phase withdrawal are shown below: + +![](../assets/eip-6787/image1.png) + +## Backwards Compatibility + +No backward compatibility issues found. + +## Security Considerations + +Needs discussion. + +## Copyright + +Copyright and related rights waived via [CC0](../LICENSE.md). diff --git a/assets/eip-6787/image1.png b/assets/eip-6787/image1.png new file mode 100644 index 0000000000000000000000000000000000000000..e940ea3d2054addb3b3a022e1e4d3e940587d746 GIT binary patch literal 350070 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 P;?E%~P?z#_ImQZP>G39UqStxO?e= zi(N=O<6cJBtCX^ZA9>LXT2i}RDGuS*If-9&{yhev*Ps@<9y&K+1SPY4i0{3SDe5Ds z?-^$83p)!6xh}(OxudTLr+qcb_?1R8iUMA~dU1tneA+O2oo`6uu&2%5Y%4KfxN~cZ zmEL;jRqMU29N5f|Qf?3_{?HW1RXNaYsRb>2~H% z>EGH+>!Nby=PJy?XS^^d@&`)7?SFnoo4hXr7rb&Jy64*oP~ILzn^jBTU7D2Ni%ej; zVLSMhH45B~@O;V%F9PUd9A!~23G)&?Fn?e3K8U0{k3ul~;mJ z%DG(gR|cGwf?K}d($hh;?K^~jD@PoJ;g5lk zG5Wg_*#7OUS5^l%bj&|1EVNgb>B`gpgjLo^gJl(=<~Y5ygWKfQ5ysf0C*~4J>bBJu z!Zs@*h(}T3%;eTO!Z>vlg-7Qh>1Zvx7bWFLfw|(;nF(N;v+Dl_irNVP?wp{&#|_Aw zY$cHmZtb}sTJ@)Kg7LEpEkIVzhMjMxc?X<1WEuHvGX%rJ1-~KeU}}=9V9umro><7? z>9RO<3SWikAFx^phz!NRwLXs@DZxY@xsBq|E6#47asUUF3PYxn?1%r<$Ry_>B0i?K ziy^y612H!8@2PYwMfm?9X@W2QgAEh?VsBf=LryNS3qo=**uQYD=Pf1CXJ=>Ubto~W zzA5p@{{HoaAnB@A7b@9zZ+`A)Wr_9cHg~m~>o`cVCLiBhG3HARguPos#TH65Q&|yW zQr_M-xuIbw^#`G@np;>*ys#pf6O3xJ`BDCsZ>fdSs2RGynMc*o ze{_c;;@ODMaIpnJFfknl*p{+1>oGJORB~ZmT~ULA(1k1`(5ZH_I}bcg=tgTSD=qFf z67U2qNwgLAUAS{E1GD@5vVbDZZbxftgZ3SRCsh2FSLm#|Q{V1I(_9r=VC9@Hfx@QY zFMZGlW&k~b{ZdE*tkPr>OX%M7y}Yttat0u0J5rXCw2=OQ0YDgE^Ng1RRR@k5VM^%dhm00rSb-UOGp_$m*YhP}R2O_4@$wix|@QM_FgU?nuI#aNl{%s38*^=H77eedmIu$&Bh6+mhYss z)uZ2pjSB5SIBNSj{k_7*rqEwI9j){=Qy|yZ06bru zhd$2)$rxCkqQTQ#+X;{Awrv6$`>oADVf#Z;RR9x+;NW?hn0RS=dOCMs^PAh(bjb<4 zjBYc~SB8fZDl-AHE0egSNLutnF#30=CZOCU-#MYB@Ip5FFi}C`&gR^A{@&{&buJP8 zwY$GwMy6zodTr%qnSYL;yHhP0415Vb*99$sH=$9$Xdyat=1i_$2@9>~9K%gWs2574 zLx?hNJ-^KQ6k*z+pf;XXur%`d)4#AYj1;W;(&khb-qmazI(^o7dALko zSy={JhwFW})$&GCzwKRgWSUgNbhkxSLTA@xraew@DxAOXD$?DBG`h%p*U6#-dT4!x zNg7OfGOMGtBcIQ^4uuqeQ2s-!^F4-!KgqwLT>x8y_uLB_r>)Ph?fPru&xO&BcuuU{ zmP3uW{jkf`d3%{fH8~V&LL-X`a!Go*_4AHQ;vFg3nUEV3wWXv|8oEpRl)KDpx+)jW zb@eFm)Z&oJ;}X*bq29-!+sWSEx`0ufNNgXiY%-(V*-inzHEIy^%P`R(@f z;8^1mf;d4>q%KY8c>9o4F3o!bU*>+>&bJ)An~b6#P{d0;Ss}yPWYkdj1;H+Lh5Ed2 zs)))&Xcmu|Q_9wfNg;wsFGWm-IyXcCTmDm&NkvWX@op`M`c5k6biNSEU_}Q2BvkN2 zs2|p7EXRiGMw+<-^KOVY+JJR8tq-acueFc3bjeH@Xsl;omPLW}Lc+`PC|D-BwY!*_ z$#fcGO{-cv`jphD9n)iLphvL>1TJl~k_roTu|9e((;9m9v}FK3JuhvOUGLw4{8P6gjNXJR3oj{y}NssE5-`Rh~!VVo*^X` zKirH_Y^KMSaf{Dx?cpcA<}@qs=2=*~bvLd>H7u09jb*md*=4$wR4Y$YcH}pyiCL`3 z$_HtSDsmIFY;jv#Z8j7-e@aj(F(MMt)~fAD4(k>f-YwhrG@W;aB(ASwhYfI$x>)hQ z2e+5ec4Ku0hnz#((?@Z5GNf{U4_E#ANyVw;Y$LP08bh8OccC1*J)bI;>0bX+j_3I@!cuC zE! z_~ZNR)z_ak)Oh@+7r7segT5y_TEQf{;`jcz8Pkh&L4`ymHbJq}AawGOvyoXj0VI*T z*X(}^{&{>?L0&S70#Bu!8D>)i4##S_$gO>-ZtV^lKi!gKIX)cE4Bd01W59t`w$e)A z3{}cpjJ#=i6E?@!xh(2M zoZ>3xhcng-| zAJxr&cSactqqLwu6BsrSm2w*;#JA)E-BdsZUFz>Gd@sq2C~fn_ahZK-FS<{f-U7*< zDhRefht+!rB1nn+Z1Ki@K0{k_QmEXCwA3um5Nk7xA$~N*@1T! ztK(UgvEY}J{PO>BdpD3g*t`ghHNuln_2b3IzTd=uJPCnzgB`GP{I)W&95M>P$E3353u*!{*pg4{@Xa)v` z>2h5Y31D4>N|_HC10luMHA-OO%_Je+Yn`V!%WF*O`!kvqwDZyaR43EPZ+q?$-2{ak zy4A_aiG-3e1n8vrz=5Ux1`LwIdzB7m_#HdNr0PO%j@oA=a|hVP3|PFE_{{M@+T~xpQbkZ=`K1wZ@#nx+g`}WM zy}bX8UN6S|baB$6hs4g{hf7egBwxfZfv^O$6Ei8_k5|_QQLlvlKe0UFLdqyxRI|5G z0PT)&G8urLq#iuT-&>vONZ^pXhG5Ll4{-;uZfzoj&UAZaM7PR?&GXN~69n0x`t-aB zC_u4-dvjS4S|cF%Vz_?&VhpRA4&&D10C7_Y@#n$!W<4cVYFdT&s1Oz;nchE{X(-gV z;P|<}wS0R!70FGTwSg)do9lFU!gHlG6nD%Bi0k~n@Q~swUG_L)Mc+#5J;kXxx$`Bw z8ig2^2Nk!1o>7o;0##RiG8dRggO$!XWKx>u32eN)q=1XxksFagwP7@20{UkG?9i!} zL24>^j`x;dE|=Q<(D7lZR_hksMiHR|{h_y(<-NP%{wvAqYn7`F^Bc%AgFs`)=I8=+ z-Zw_|qwAj+mITx8my{teu83GE29~(wNlZJF2v=Q}IbPI;Br1f81L#{ag9lLU9rLO$ z0U-Qd_!|p=k$&F`4ZOY$B5je&*KKo~H4F`Dq0uzbsOa|C9!R}EJs00T5sP7TL6>LO zg}#QoFt<+D_Rs2=5zUN#t*1bXhC2F-szL)W>_YhikfWFLWJ!xY`yk723k-kQ_DZOU zgz9uE>C3kdbV@^nydUEbTPV1Fu4ON`}clAg4%^He|VPt}u zOaW4Wvc=+6{d!?TpI2$qpZ`iMMojjg)lq178^G{8A~FP&+**@!&u@&XKT7)GY+j)! z&_o9MIsUO4OzqkO^Lr=NvV7H{lO8aMz?j3)lj1BbzvXw5Ky^Ev% z8AH>r@d2QB{N3H%4}eN*qj7eZ=5x|?+Q<+hD)Zf6T`2`*+^vW7z*~i!h+1@`l`*oJ z(CLlpLTd_Ip_Km7(`n~6353U<&*)WLz$7<^6d8X!EG=J?$vQ2my5*lg&K6w9+I|nF zj_iChBrCcM+bv@OR+cCdVI;5_BPZ6G4%My2e>P^C`M3HNL z*eBjrjB2_vuLn{njMMY@UCrn%`(0+q2FT?V+s zEnRIR&@a#~_;u7dM=vUB@JB!E7GYV;wBGcgtl!Zt>)q1(0e})-e5Se=PuZxGr`b|? z|8()o|FwB+qXqev;vd~bP7Tox5#`f%k|$Sx(#t|M&xTQ6h#sLp>Wtfs|Dq+8Bl|s9 zqu_j@I9VF%;idO;>JPW55%Qj^7Uq>ZHs8Z4x8*SVk%Q_xU4N4KJN{3< zVxCjZOi#57mB#CDsT~~;eJ&{6>$aoz?6_=C;OJtzXnH1cXn|8C!q(~%-Rp9KB*yb6 zyC3P-IrFdhb4W5Gc_Z=kU|0hbW4zFXwkW}4GLj`5aMpkFuwr=ZQmoJ$hrECx6-HQ=Sy}^PMhCc<`Hfz^uKRuCV5>nl7Zh5ksEta z4gz+5?o#$vMAqBtKU8aUvRVA@z`KqPK*Lw{VK35FGK!E*!t!1>9l$5Q_!nO{Zo(hy z^iL6`S01d76&KojZi3hzgiIRrn}hMlf>(yaj#;ZB_37*P9Ju7Lmf)Ck%1C3riakM6 zX6ooDBDdj1DvWl|ZmmDu-{$F;9Pzk(iMiYj8*&y_nItjD&<7v;uS^!|cVATPmG3}) zqUsOl>Q%z?Y$veVC!)xens09@HD?7A|AT}^Pli9oy;AiD9YyMMPV_k2;Mt^gkl`Rd z$<_wnh`fVrE$NJ1$=Uw^kwG8uDLLZ;EHz1Vdi96J?*!3FOW#dSMlNI`tJ)B+)gb3z zS)1YfcQXn325Mx5J|tQ@etShIgwL~T`&#)4De*?7{Xb z58y=#8UnVH0nGm7eDw!R!5v60iGzr6QlL8NdH=TXh7qg4@H=HReU?U9FE ztmNh2(t#HzgJS!U2Id;_e&LF2`i|}#2Pdw9| za;1DU;z>#nhItZuJSLQyQ$mT$up&4{Jj-#VaQ~&`^}m4h-!5cHy>vmo!K8?7d9rJF z7CrS51hEl>$1KWevk#FY001q5WU*J1PNK^E_h5?j$tojik*_#pN=M>i*ZS;Bp-^Bt z20m7~11RMi6^TcV18=SD9$Kdu;2p0?xAm89cVV*N$E^t8-G35?9JE5hrO)A@)xbHv z6U<{dtH4_)lk*~DNf3Q<@1*!oRg)Bf-YC!4&-~Efal1-2pMFYShLshBoetx1*pHQPv#S1Qxc#dolj&lc72NyUwP356IRS zPaczwiqCQ%SxyEb`=aI%hAhX^QPUaren=Vy%3LjR=@^6QWKH*S9w_4%H}#x5i$v5w z7a?!2oHNWMhk=MQI*au+gcP3u|7M2|F0 z;5x0J8n!U9Rti(P5=$Ado*myLqaGRFE!b!;F&vG?;Jn#Jjre%6R#wb%@jY6(SGm#7 zAxgy&=tO*S-(Kj7vEI&3W$V6N()yhuthdN;mV9J(n_xU1&MvvROAiu}CK1l(j!x#a zov8>VQ`5`?D2klM8?bh#W7N#ImWKF%`ma~*_V%9ldW(}ufqByPMG-byKjn*GQWzlb ziW)HVQh`zn{p=!FG_TpG+*7^ZzGW*Va4+nQR6kOxupco8X9_;>{-C;HpSLjHqk$jO<~m@&x;^GsPo_vB1L$ltRD>K8{14a9v3Xf? zSwGrk=9_K{Kw1Em%jG|&M;?vE&G+VXL^CTM?7BHP$u1|879WL$AED#rMYXmeBHMd-z+@xR5K~N42RAe zby3&lVQr*yz%F$^gqSW~SmmYC%nL%M+2Sg|Ou2IfU+|g*lj+@ebadQ+oVXR}csWO- zpf3Da5fsCs5_a{R;fmbJhVYKJZ+G&vQTV~`Y#PE)DT|0S@|F=JKqAUunzp45_uQYk znd2od+wF{**1-ldpVFZ~W;@mVK4sOo7k0OQwkP?@MV+EWgeI?P!@jC7>s2~gTqn+F z68K6c_km~tR|lgm$!=8V9WMyPn0SP^v#^RtMT=WB#jca#!4iY*jJt1LrD6bXChjK) zRa*g5h_%zBso%j9uSTYp+gq)(GFnR1vl2Oj-Fki}GgijI?yk=-SO1&I|D_I?xL7oY zlD7YX21z^_vtlkTOM%bY`n935)yUGC9Vu%!`>8iR_)yW+kX?tk(|)aMIsh~<+sQeg zXGTH)%;G5{=g7xPP>#n&oy?o;LWK3eqW3yhnvvh3YuS>3L$`*iV>6G~W=R1uZJTn} z2afNl=l{8S|6cTC94ZKUc>lPSz2~>F&jY0Six=C>;;wL_q zL$AmQ0QdIEmS=1j!LdxJ6@L}lP+rK%5)AF4q#NYXg;tpM2qA^s!6f5>48U{-)oY@> zvx>;QKc3R|I_;Qf($eb!G$x_c1>9|q!=s1u?yM?0lAv>rPaNZO#$Bu7+ zSG#JmcAhB*aWb2Be(c_Bs%5Bcqt9Jnmj~{TG;IiFq{N4l{dZ!|WWm*)euk2+ryGOp zNzZ(7wj$&+?8SR)Jp2AV;Qk!V8hd-Y(Xq)+!`7}lA(7FI(wBb<@6O!-q}lBx%W!3P|L`O+=#Y;f)|W3XjOgGdW*8NS5yJew8g z&}sX2p)sm{82XkBgh5c&1$ zLZrRXEv$5YBn7bgpA;agg;X|*<5wg{O17Yr#qiD5(v>fwH$=kF-D(kuXD+qXbh3rf z53~I=i&wluWc&HR*<##9*b*oFf*gP{2_4+k%FC>cb!b$QZCQiQt)c*~7ro-$ot>Q< z3}4e4(t6Wwhh`>0Z!CJuTerj`Bp+p`w69WbzoX)HG#&Sdb&`;k+vaad*G-p9Kh`4y znT=JB=$g6kg5G*n@qpcL9uDWdb|!>@uOxE8%Tn|OO^uotKMIwCuQch?*c3luuYi2P#YkTvnWv{uZCo#D+r ziC&SLoqihY-!qB#@zobvPHSgPi%HWc71`ljh3?*Yw2H{P9KlJ{)hLNvVk|%$y4*Us z#Hm#}^Y?wuSr|&?n$b#8=uKXkJzdaG=O-p;KSs;s^5Kwf6-I{ zy*T$6F%MXB+Fzr+NgO<-c3%0V>dYo6S97S2y!28PDQLGBwbf**Y{mmm#h)!gIxqf|c;hDN(D3{QEp6|nwndXTbQ?iQL(Qee zq=e*Wzh-*g(mvt;`|~o#;q^d&4qyOuv6sCFh&DvpDiY>6Z<;Q+c(y$x#;ce3#vo5^ zfF0GT6vkxGUfKbU5Wgd|6zEadg%{-}a5`-e7F+}9^3FsX@!9z%Qz-nJ4W)(rDj7X~ z&M~&mw~mSVcd4-IU8Ev`KMwp@N=)kx%r~r}>SFvW@GtRTYM!U{{4cFqA~1$qW0k)~ ztF@3iu*R!g5 zfg{D#uZYQ3BWP>Li zgJGpf3j5-@&-2-=cx%2ZPp@6RfYTDCF`v%ggKi-1y&v^U&<)WL#IWoaKZ6s=fN4lg z5XW7dIOOuXwg_O{&W7;duQl~0SU>XlN+DOMmce=&Dq8cq2ILg0vxN$AHYfo@lp|M( z&9CSJ)J#ZT!8ci}ze)fc-u{S);8-kM#KqQqSJLjuacEApkczux30yc3AQD$TjC=S_ zM#*tHPT7-#Xf&rbPOU<=X}|IZpJg5NDv|LPmhjK{Aqb)=VO9T}ej)HH3X=5axY_9c zNy(P6VZYK2T1tMfKRdGjkD&CQ|M3rnzrFmw{}y=~h=l+ClZ-a@o(Z){64FLUE&uT+ zQxfuC3PL|SsJDC&dKVK{6CR;R_;bVe)tn9L@rF?EhhDl*;JT( z0?{G-YS|e^k*9pX(z{BZHiK?tm3gPq1*`qn_n1hSA?!4;znFksRIgoUJ8o?cV?*!4reF_y6^{E|0~ZhH z(j|!S+3+Gn5;-D6Gq;*X=a*1#bwn@n_s_GXL!TJbNTu9!%@0zUv4utk?4`DxR^|0F z?Kj@7Hq4DKMX$=PSsK>TUI0nkpYzrHVz3C|)hA&CHECYVF~6F@iB*+b^|yJ)9i{0C z6S{WH8IIDLH-lAq*Dm#`bbWZ86knV6e8*&AcB%S?TNvZ^uda^N+b9pA>R+Ef?N{y! zIlT;_kPEh465p;z`_=G@a;`3H)=F}_*ZS!W?9HHk6Ze>VN5f(!TlIH06|Ygq8MbAM zOu^)*c<>L|+zDlTV|7dE&B!P7`0^dMjaFVg_olyX--X027T+bu#>gndnrbSaQ(*X0 zZRVs*)W$Hx=w+U;)NX0Syenlb;FHTlAq3=xlvCo$LX1BV=ZoPW6vDp$HH0^yr^Ta+qVe}5?{>R?PvP%1dADn_ zaMjpt6%XlU78Up6;qNSq(J*iu+Vf+LcH4oX4LmN>6^i&Qk`MMen>i!$6}9u2;);(_ z2WL&$_6KL8)iZ)x-;+Dpeo-BAo23xiTP){%xm;{;6kT6@G&(oG^3B|VConUc1A=D) z*;gl`r(9K$|55#BG4>H}t+dKGXlGv?_K7EooecXv^$+8DE^oFj(DY}rYcemcTF^b< zx)59;?z7pcJTz!7b3LF`yF8ygx_|iax};+NyI+yBOUIDt|7;F52+R_B^DJ$Hx}sv+ zkdxc>?gbPLi{leA89u(5ad;V@!xX#bc(`W!ueHo;Lq9j3+iuxdyj_a%S+Ekuy>T(ArONkpGhGzZ^ZUd< zbT$Y+DaD~%^}%KIw`?8JgrpmoD-}N+W0SNfLyAmjq|ml?cAn=-r~f|Y{rmYn*M4oJ z9Ib@zOuzIFv@f{{FJFsH;F`;9 zW3r&6q-1se)fokDFv7X3-@S{xQqRyNp8fYuL?Y2}Ve*R4p|^sf>iUwks|e*G+F4&L z{hOvtn7p)gqFwaGTusGxF~=u+L#Y+Mk!JOF37R8aaqM)-d*w&tOZ^)I0%oc&2Mf&O zP*IEvvv&>`we!AaI;O^mznHuaT^UWNH!HzJ$b4hEO)oAJArop}=@S3zt^IaGKTwce zJ>6e9iI3SbW8kg+ox2tGTqG^`!PX+A23oo7atMd{$Y*yZ;Tw=Dcfr@`m0_)CG$0Gm zJdcH8G*my_+phl$it3W{PR9SFE8u2|2b(7vzl&?2kXrP1{3cc2&z5-?f$UqUg_J_| z`C3VX+UHUY3@6XAT&WiSQNtW^@s0TMi|56>iXN{N zSVXj>7`JEiim<*KRB76O=3#Op!E&@f%+PCDAWyI4H8jGtk^Wwp%lUrd(6Ta{fp)M{ zVgmo7ED8FX&{0-A)i4GC3PBLTWUxVwY6?zG7$r|3JFA-LpV)l2kM&3u0jrG#IB^8l zs2!9tDx>&!!)ao?d`@Fukj=G|tKDRHa_)lgb6!(#h&PMr)~Nh%f$iP=-8Zw`XA?L$ z(++@jV1BswM{(1iG|?=%EZ;;oCmDS*17ygA(5q zkLe)W2S;HjgUUapN)A^}6In^vY$!jp-t1fU*eYPe(BCukoM$exeE>KAt>U4PHdjL+ zd;BMGQ&I>%PnG$pq4>>bS}$eMQ_{)^_f%8@9Jvl3>|UUKL&O zxO+eBt5vvIn*>SdIudy9NZ~6DLF+ubnU9*eK|8qTFGX_21Bq9&J%NWu<>hs4We|GxtuK+}tno85&s_TiQdsRt ztT!LYvCANW75%4S2JLDlf~jMTWiVG+oSxT84;cB?l9kQn026`F_rRTs*EHy^PRIkY z0|`}Lae99SOaq}=oxIARHm5>CkJo zgX+sXm6Kt&JO0wYD0*~eY(W||A?ex@c46U>`-e|WVmRtuTd-d!mObe2JAETxl0@#q zMdGRZ?hbPOI34R7HY9Q+;%iuhQuyNfWe?)+7UT9jW|xE5kM(b?%ZFC4oc4#WMQUe> zzvsqIe7xyEM-)UtyPy#uX>smILdI^WSeE7b02LXC9=4Z){L)jvvU zpF2-VdD&Z9;Jg$ItC?0iJ)YRk_-Tu0(md+@O#zgg<~ z$iFK|k|})uDPyRg{d2m1aRIu1#`l}lNyubPd_Aj0#*peD--Mut%`}(UT}eja1+SB5 zQvnMrBeMctDFuo)Iyw0bd&oGEA4BxjfritSpCr+`qqv3NYxu|0Je#?}C=p3}iI999 z1-7YWh;`y{?)_W^|4DiB*ci)?aJk)k-g&pB=FIm@Tuo_wb-V`n^{}n&=Ksco`{Y1! z#1(7d>OQy(oYVa9aed!{S`f4@WKa^1?_8%H`58xhhCvdif(JmPA1hmdi} zGgxmS6csN4SyyRU8{gL5;nV86@v|{$RLV^cO;Ig<;vN#FO6?Tv{Q#1M;j)682Ww3W zpLH{FqXLZ^%T*94DE)*xvIRWxvQ3-2)kX2m!=+L5H|d43sb$oBD<5+WN_rp6ivQK{ zyLCkR7ufJ`OyyJ^iVXm`3=CuBd|3^Aj#vT`g+w{sbGYxHq0FA5F8@01u0MGtk~*Fv za|4(3*#cQJLo;zRsSN#5V7;IKu_?aTWV7gWIvm~knKN;>{wW2+7$45`+VueJ#%11oX*b~AuWKVjjKghB%UoFgC2e2(k^Feki5;s@ z#zo1?^(E{AB<#7tIM;9XnHu3^+&(pN(Kc&jyvJ;R5*)lizVsFQW}jKw(=r@FvyA*F z>=f+uYajEkj8D-0&CoQ#Z|X0&qXa0R_7j51D{FlMoUZ~Cu_?7ofN;SB7;3q&Ikqx= z?D2rd2hOl!9KvXPi3=~`5-RmXlH)}thkqpO)DV&kBuN(aDsR8zTUosKL^mL`)Cng5 zn`n(3O{IOg)Hp6n!aiQGaWn%CnA`L#kq@se8A#uZ7d$t;g;?>04csyEVb(Rp3&1hr zbi|=+IE5=Cao__oXGM1tS`&QQEd`HP8YmCun9;C6q<(PGhx)<3BXRc#%D{u-c%k~N z8iIaq9)SU|*Ot9KMip(Zf8SDAFL#~kq^ec>QWUPN7qcc`K6G(GV|1`2AjCeDYN-tX z?{LqrOZ^22`8&pR=h=mGIZfut;?qpj2ylY_bWtx^d>m!g!d0JiT$KAYD-oF#ep#uLzy(Nk) zwHI((qAE7#%kN*o{EX-QeF#v>?u_(}K_%nvQ4y_4r4FGE{udJOti$(|MA{Zc;o zoP~kz{yTWyq--*zv@+}I&lCx0$KQ@gt4rjjdt&qYKit;vk!%VS$)_3Y4a9wfI(OB3 zXN~hOeY%4?7EWUS+EoJHC%j)d9fKUzpGyX|ehd_fAJXe+U;7$0>T+ z)XWVc+VQ{?oe*iRhHno@Ob5N5G+lAx`xGtCSy{5vXjLTJ&sBdfZ7PMb|WDCgUoMFL4a%df19iab8Z`?y)8uf6kD~ayl{DoT_2_%ZS zK|Wx)uh${*zW$t0NWD%Rff8X99gjd5BacO|$oricvE`I-4-T^9O(Y10Rk`(X=+eGV ziFZ%BT>K5e_e87%dT))(Wb*24)0tvB3>kz3w~2SF551y2Hf7?uRCAjYTy<==f8elb z*S~PfCgCO#5{#suO{HIY7$D!6dQnRSo0?rxw>O>5c~Mm&_P- zl?FZ$JbD`sgCgJc^zaAg*(C+9NPecf8DxfPw&XG>*j<(*xhA|cmZ2@X4t zgH?zXnB33VG5hlq{>6wtURpa1m!!_eWgCCF%Z?X7Xu>1enq*G z-10S(aA2_Ce9o(`(vd_!LpNgE)VuIAS#))8CE)_?=$G_r#wlypm9Dg>qqk91v2k&1 zQ_}-hES4Tx+WCsid9h!bu&v^Clot55XyT-Q4|KGp;1(bHR@)}jPxn=<-+!LE!mV<4 zo9~LE&mFKwI?~SJkf^_h%Xub9Ah9ZY9VsQss<3o%$49%cxs^VQFyXr)iTf$dQI~ zPt%~SbA!fPA8_I~JMmusSE+(rWEE*Cb5^iMpkkifI7qWiaeff-yq`Xrj9DX0;XP*t zj--n`Q5)@0j0(lX3-&fj#e#Wh<_!6x%=V(Sd7}Tqp_;>?``!A^Ch0WseLPpUzIm^} zduyJ5)p@c+|Lb!*FObi54-IYflkM6Kh7_B9JjZqZg8q%Tvw>A@R0G#~i*rc->l={` ze*qt>G`@cDdusIo-M22kL$sIQ7?a$i6%9km!pJMH7VjjSQ_zgiJZrA6Nt*@SD{fHtR z53x2saChCofwfP&=F3_`uXl$D{L8vi?g)dmSgTO^l8_)^GJ*V=viAY2lbVvXi69vd z$veIr#KBBmp?s#GlS!k`IA2Q?akQ;NXiXY*GAg0UvQ#ka*)wN0ohlUsi|ZnlD9Zye z8!!eZf6^}{;amgo#rkn(5+nR9>f^$q>hp_ot>?vEd_=`*2vWgzJ;UO&B;K@+P$Tnq zEJ6}dQP0iR3d+rZTaL~1me^RMIV!D>{d@r8s;_*+4x4XIYq3!l{+bJQR_~PcEc`_% z`T#d03xsgXHwmLZQb_|`Ocis^NVsvolBaj&J^$ehZ^oLUvSTVyO*s5A*0lR^U-%!cVd0lCHikxs{w!T@OGiG*u7iHf=Q zUlu>k_#dQDuimBcD73Lf>xyjNXn*-EH5IAGkZxY4+yM7QZ?$AW1|&&GddZr=9kAsN zrxm^1CAxjj`um$CyF!ziiKY-G;1HZ)P4)#5krS|o<$E$^f748X<#QY;oH~F8knm*% zdbF{C?X&~DasOq+Qs^;u(;$iyPARt{si1}+t@L~+SLJ)ySiLv?F;Fv827ed0)ChTD zNEqp29*q4xOhc;S3D?vP?GPfGXz1e}OS>P!x?~4oQA8}q9quvS;c`0;i}u(k&`nyE zEJE6uos-i6oN~M0Q8Xvz=7$gfRK1*J)$Eu6dbI_irtPs%bJ^CJGYA7AgwRF4N(XZMc}*z@4AtLG|$ zON}AdZ?BCu*8b>v1U>?Ig@>nhGdgS?^aMIS8Q8(Ee2oLf48SU9f|a5D&W5O*#@Vik zV$$)$Wb#IPh$uI3&?}^GAijMkyX}$cLKv+$bn%OI8)A=>MjNN!fP2t;FUDr zwXE>kwr57u#}?he$3E-jm+G}5WDU-%WP*@eCP2j8<$4rIxF_+~UAzyT#PP*3IF#)A zT~E;*G0Z6jsa}6KgvTpDaPLmGlBr)>L_iTla|fE%w=yceK4z=rmxHw6jU;hJFZnFO z$oyuLoiQ6ZkR3mcAz)adZ&>5!l=cQ}!yJ67i@|kAAej1cOB8kSv;m!m__n>h*#)W= zjW?~%KNHDdM^RpPUb~400w8!U|MF(i{F@}#0_;G`2CpXuOwtKJoO~bg#esJTHt%Y6 zv~`PE@h5Y2-2OzK*0C3dsLwM?Tqz;Mx5}3p}clUtyO3QE1FE%kT z*Y+J4_vGDqms+#_iTds&9uDbRugUO4_( z5B*mNpSP324v6g20;B}dk&*NWRj#hu_!CtW7^4UW>%*CHmO&yUi;L1zPef;wQs;sS%` zsGXf1PAw86kZvaCZ%Cj_=4s;(zrdSqo@N2I$1a&*1k(qPQ7LiX#CsDzz>0<#GZWC( z)|Q`-L-*^;OID?LP7N{L18feJ_pN4E%r?Ym&T$R@iy(Nc)J(u}uX@hYYw!K_WShlW z3}xgDwE3DIK!!qGzZ)mOUR@)OEc6U#L5C75!!#(L{3uYR-uKXap)W7zX;x|JwKCgP zP`g|R(QFZe4U9?cr`!p9s|ovW8oC8mPb(#QO9o40G`y@Mq5C( z6|c?=JW3aoB0_N6vifr&Jn7wlh2}B4AaL~g%h%+Wg`{RcTduQk^{j(`WXEo5uI}`0 zE9F$39OV_ue6$mgDRL55f-|=$Ll7O8{`R6R5vC7jb_TD(L5qr ziE4yX_K|>u7*Mua;ZQ7WoH*udoT7p0A5$5%JngIISzNu2 zU5P>6WkeIrIwF~vK5q^zp1 z14V~{8>Mx@8myidRt0^C_utWzFknDzOkUPZJk@~9IdYorBwY)b19f_sm@`HmNdqcR z7R_t3(Q><&!*W4p#XTUqX9u5v*1KmD68?TT8$vbSd}HZO`#VYXjIf|rc7hh%Rwa9l z-Jl9#{;uF0Pt#1>Oi1M9KZkGoagV4})NwLs{JsO{dZ1u&{DvgzEtm;tcdvQv7;~Mz zChE6&{1Uesq-XU^&q5jQppXesLN4FK|7fME5BrATF^%99esk)-X*Z3%3#Q^mb6C(( z3_L!1QUVK$ZC>Ib#0+)GCI*uC58TJdE^qn0N6t9^F{JBwkV^jvx{l*?$7gGo`1B=f zCY-BjnzwKF6FhLFKO?Kjbj^bcKK%n>4~YhDigRM$9AV+Kt!Xtm`HIP-p;|dS-ATNO z@h6o65Bl&FnAS^$Bb0FxfGJ-L3!+BP0 zz_P+bD59FTQM=aViIg0xv%hAVm%(ZKpQ{~QB_yEcaY}^myk9D!2z!o`%;Im>_x=XE zu5=52Irt-gRNnO>D|!yC-SP}`xxdWt7Mr|(HKCsq3u`$xhp128UO0#AT!8xMxFlM< zMJKtlIoHED=I%24jwAi6!T{_hKLzrfo@W)3$mw>6$Lqdio&R8INwsoCT$xZUQf;Ky z=R;rFZ?;>(H0Xe2IFDrGcfNxRz>T3w4#=qqaP4GzH}b2;{DBcRD?j9*?1Hy1&57Mx z7*4vx=))HQ*_u-ry5lye4sEPxu{@_Op>bU;S%6hI2YH1Ec+(^As<~F7dmd& zcz8!%*WyBalhOK>L%)>dC3K3K@UB6rBoduwl6 z?1aqfgEPkq6PE_5{4U#%@Hn7>+{dmWPN;Ibg{w4sPx_ciT*=}ftO)b31Sfo*vPd8c z(9%Jm+4QO~ns0M@!{dKU5U!A+MGdwK>#a{ScJ%?fS{A}3G% z=oD2^7My^ODBkgih9x(LUtt$0zroti_D6# zk)X-!U5^Ap=N0H@g2Jv!9^N$9=RQ9_&u7wzgV0}R!1|(d!vumy6C6Jjl$B!zY`(XG zRLS#&ADsD_h>2Z0x2}?sQcSnlzVcZj)TPdAEcLU8H(3TnMZt77r?+E#1L!KZy9ob( z9~OOM)IEy~4~V*LzkK1?H3u9H6S4_deVd+D3NxJiG2k+izbzJNPGWmPa{yDS&;ZDOOsC&z(EZgm0RJt3a9;79t8$`NM8VN}iP(&pJL6AmDx|NWSl2#E>X{1vS zP()HvI;GCM;eFq={%5Uy&i=N?9s@q;c!2x9a?bgS2_0h80JWR}XxM15)aQ8rC#9-j z2NRAP0mAL0LU947d0@cy#F(OR-%sf z-_SHbTM~f2X@s=C;4;XMMkJyAZ|@kTNPASQzXR^(I?Px*M0SQRaS}4X-czMpVv2C& z-TjQ~XPEUX9ZcRsi^W0b%H3Ue*B>CFV}^*+C<~`X7Hl%?{{wU*okCdDRy8+Ti06mP zv%UVz=M_4O-0Ed&rc8JVt|IL)Ko`Kb@akyqEEv}0*bf#uL!QlPsVmtYLI1x7-}pbS z`ajD&!QWK+-DRT!&y{vT;!ZXj1Qe*yoe;9OfwB!mC+I%lvcU<&#;}SHAP4@aL>Qq7}hqKOoGSKop=P-3TYWHozAlpHD*ss!PQ#vJ_Vz zumygvg8?4nGALYT>49wYfOg742~yo_l@7WINucv>2ls}GbL+ZS3Uo3RYNq5!jXfjj zpnW2*iv%ee6_3Hoap6gYfcyDR&FS9pi|*GDq{O%+r2VWC zPoXAhFsUqLhkm;xN0S56A?&*$6g$xYz?*p$c9tHorCNg5Sy-$j8Fy@j!Bo({`1*6ok7IOIiG7dtjQple*%9=>g@oFIAl<`F) z4)NXHho?(eZ8&1%sc)3w5+fIg_*YEK68iRg^5>|dlU;Q8bQd|eJZ0E>_SY_IK*Ro8 zAC$u;2G*j6o`8isX++PSxTKe8eDMtI6_uYq}vCmC^q96Jsbm%)d!VB9XLtMopf>+zJsD0O99DkPTp{Yi{#67^Bm zCMYEqC4BB%l2PkWnUJu6CQ9wtUXH66+alJqmiH!cgC(qb&JriqiRNRY1^=9-$7#q%iBUA_J&^Y{mPw6n7GLD3c}d$r*xKEKcuDlEPr~CfD%@lJ*gQ;k&HO{tnpB$Rx`Jt^;w}tfIhmeN&6L){P=jj zGp-@72(GaR?p4&nnK4OacJC((2??6G>;?@r$48#*`Ir+gFqfS0zOIs{gHPl3 zqOs;s(I*XeffkHikg3Gi;X07A7(YA3JL+Qrs2erCH-)*;_2-h7O=G_tuAo7zzv!I; zCQJ(}MbsRQ_d*$-Smc&xnH)Q=;d865b+ke8MW&|*C4S=yqjU5(UOY<_h7*NwXXj%^ zux8}Y3}RK_(t}#c_?rvRn1s1&f%#wW+}BNH#F`;FSYg?~RT7UaaW4)BChqd&H0^>^ zb4+Gv=Cy99Z56!s8u4`hE2-GLj_v2RpH0XG>nM}2%<5_; z+{bnflKA%eUX2DWFl)O$K9JV&PL?{MKc9q^e1z2QczCHN0@ZJ1f_RwZ(B#hO>uoPm zwahTKu^!2crSq_EHJ)EG?*Eme(KT&QFp|hm@Y)l7_pL0@M@2VmTZ&KOdbc;5-Mpu9 z{k6&5j6P;xj{tp4jBA`Mp*tIM({0+>r)iLAI4ppPoBxsINc7Y44%q0rk=AP}kFc;> zaVw@e-1;=jRg241wZ_im; zKjRQn_ta}MxU#{$e&h0u$JX`dux zw2T4_Pq|O?%d1#wCvqZD3F2QGkeroVrcZ<942bfG8Z?cXRxo$&M2YU!7v;ra$~qP-i0g)8NsY?_^F>F|Q|46WGkYpR_>P z(CSi(DB0iMP*7u{L1OW;GrOJ$TCj?L`e%)*1R{sY5dpkgdBl_K53q0G<1W_@HpTzI z4$A^VD>|UM57I_sRy)$2{0swGoG-)a#4yN|lN^IC8gyev%q?n-kf~GhNm|U>BNg*k zUuI2aT@k@&I#zRC)`_6}oARIs@vld)ST%;ax8!Jirx4ghwG$0WB2G82U!99X6l;-6 z|CXB|`kfO2=W+CnoC!eN@RLxbE~1DIH?QY)_aY)!l_m)DQ$7`xh8J$2I=A5QK!CdF zCvc_(0X=@3JY47+f}2BvI1pnu0CH5>^`%PAlZU$(o^kZ-RE3LxB|`9PkP#Qv`eQ@< zpV`Z==xmM>X!<$5u<7yD<7DRSc`sol}BE=q;fTwIBb2&qSxB5nk z;1*GNe$eiE`r3az>hUV=Iq2rL;wW92wc)_^(ZjW1s_;MEUO9{xlG z*!x^oY-dj9Ek?edYv{DhQGy{CeB;DN;9Ii@4e>HQvOm=*(%zi1@JBLWy(0@5nJ=|d z!8YfA2(}^5K9Celi+ncOdb?ps7Im^QKR9}gi?T(>olFU<^?!(+Iqz;;sXve77LC(? zY5Seh$2L^=J2Vq-b<0`m1r0N@wdu{SQv+tTAc1pTLvCk7Ylttm-qFzrkzp%8o6GqD z!hy6OO8**+dlkeiv!IlBztpfgPluK8N?uKc8N5AZTj+`DENMRp+(3`o%r~ClUx?S zS*1Mr!C5W|!p~$#6-qVBHjizb$&Z3Vs}(5Le2C^3LhiPK0{t1VM(w66hpgTihyWTu z>_lz)n}2|#9g+1%5YD~!I9*a6Wc{phCp+n4+>Mv_ZDBBlSV=Y;nlZsmGohFEqFa&K zgFa>Fxn5>2i;q>8)1^)By`MRId$2Hp$Fjx@q{^He+UfCdwRJ#42OC6S?Jz9B1$^l6 z?7T&QWDs%k$UOZ%`Pw2iBXTuIx`h5uUjP_iL~~D%hZIjB%jg8eq2%LwyIHd?2&xg7 z(B2@VK>Vkd{&MZHcZz_u|AUpWA1e2U6QERr9D1Xj4VXXonp+BZPIeWA^P(H$0o#Bp za`Jt5(LPRtBFnV&jYumDKWN#j04_6yg@VvCA_-}3Yul5~3+(6wgm{cF<_ZNMKrqaf z_kt(5pqHaYhLCr?0N`DR{Hnb^0A~iO^RYnOM!?<#-o)BVfXX^U+TT(0cz+s|NBVehjG)fo?~-Eybny^}%7)jB%b z`}zzz=&={>ld?kLCjojVbIKzH6ZS-%gcPy6&kzB2q5qfnE_NQ^Y?b4&@e2%;qFSLJ zqzy1kH4czwoV<4~=w<~jyoRWD9U9fD1K)c3+nv$`AmX+~Gb;|PJlbC3LhvE!wI&J; z%mgld6}$rIK_hSIU8Zyo=&|;aKcE6MQ~CX#egh|{#YdaSCVfL1#eMUo%l}$^L`r+j z!FwkC$W{AG)ge6?c^Bjw{J7N5`UUsomJ+vg0&-05m5jMP45v+`u(dkTIQSx;^qNqFTiMQ^c|4P2&e|y4QmCKp;Y;8}j(G=bO3vmc3 zzu%T5@r`7Gp0K2$edQIwP=?2$ENIelS2ASGk^Up1_Fyz-D9UNq$mNtzBd?a(5Ksvn zmkVG!rcdHNo>F=b_^&3Q_|6gdnsnYrdv=EE4OOJqfl{F}$by^g*rW^YYn`c*aUBa; z5>b~KHBL_TM;}+CEWMI5*iY*0_Dz%vwzewBm3eYqBL!#mkr(_P3JSHr#!V?j)JT$TST=de3R1}mc>Ex=$TEUm(p%83e+k;pRK(`(Zlr_J4ay`?ClrsT~ibkrT44=<91uCBHmRjUN7~Pu-gPM52s!`!`3cRE&!G^XU z>9~r{t!2FZWX5gyOCb9L@H{f|i~v*oEC8qitH5b_(2q#MgV-~2^+T#>q`*CJJCiCP z_9yU6W~yeYLaLRv>6l);AU6*lIX?4%QOfoA<%mRuADx{iahGs*j?sBI;Dxy8H`%q( zB}CBtaR5YQko7i8lfsd|E*ipu%WM$jSk(aTc6r{e^DmRy!3LrfOcmrvl@T}h+7I)& z&!;Vq|0I3O3zX$ItI}ckRR#p~qC2vn?qRPO^ErO}9=H+)TX;k@UeK?@-iIP`DjghV zrLK@@ZZJhU7Mdfiq}lHr9q8}>>eVTLo;f2?H;Kc;_3=O;LkeV)w^*fGw`aZxX~*-bCh5CPFN(fXa=2 z4Z?@Z0QO!|GtQ+RcBI?|tT6{9EDP};>aca6WUNiUkN(n1aHM$>eavE)fnCM{&k3lb z&zh?vE-ZYqzdJeS6VwsUiT4Ox0$Rti| z<{(=AhBd#T-EiMmO}Z~Q{ROTMwpzv|^u_uPom@3bR#RL2(TE$tk@8%pxO*1z^Vt{i zgQ{IVo?JIB=@oXRq#%mS;#_ZkAj}a7()!l9Q2m+obBAK#$*e|LO6lhsQLzbo2x_GwAl>F*LSMd?y{*gQ+21{$h|WTxt$pC4zp zN#%5#Xs00{2=2DZVmOk2qhEC~f$RSEotA@*^Ry~6lxR1a$s%PwleG?O2R>H*`ur6d zi(`iFxL}*sF^c1b3GZL}`oRCGuP-*Qlq1erF_2m8%=oyztn_iB$>w+Mmy}?w&6TFw zaJ8ey%CXdGPOg83<~al`rAQ+ENC+sEwSJr%xt~9n{!!_oGTE#i8w8mwnJsr3nXQT> z6a+}s{Ej)@R~00BBdCs=WR(syhiw>S%5= zZYYUbYoAf#UcUE}KOnS!oG-nxE;~@wK=zwb`Mh^~RZpId3^f_UPWA`>mRt{qHxlSY zU>IWaXV@U6%sA)rZ!!CReYO;_h|yUv9^H5Tg%hRt7#HasRx7vO*c9UQG_z9^*L5_T zIhV&Ne#38YAxf4pHDRO<=h3=kQ1hf!SAkWQ>cjNUyBQS057Ceq?XSaLjA|mlm*7|Y z1+#;mFvE%m&D@f;w-w*NxUFckdzs^tHmtDpFOi0BD?Jg$Dl~uV>;DJ|uhyU4a0Otf z9TWX$1)d?LQor_imEU0?x1Pe5Y^;;(0pVL8hGRtrae*k0tx{n=xaE%r_dOkedhzV8 z_NP_RRrxcT7{ezBBmw5CfbT=6EhPJPTz_QzQf<9~M}Yr{<1hBvEDw(duT&>GW#4_) zsO@4J*KoR-`C6mc_C*dgf>)B#qAfZGS$&d|n`r**!7DsLtyYh_zLQBBa??VOElA;6 z<$K5je5$V6-A8f7fhY--_VxZ#D+o!gt_M-tXS}|Db%|2lb|zp9QnTqRkm9_t`{AW- z`A)8V;2tkzmI6u0Upo2XW48)rJ6AH@kJ*2hd=(9n$QTmmI@14_xR{U$GG00IIfYF~ z4y)&cXG3Brh6R1zJ6M*Pale&O<*tfc#6DN*w14WZ*e?VYZP7bWT=Ovm8I!IyAp?e-*Uf_m_X5 zB%5QNzn(S!$rbtW`89DRkOKqpijOgZTGgy$sRVE4?0t~aCSLCAk%QzZmE=6aixs?Z zv=+MKay%_%8gnA%rY|lSFLeTeajBOlyJ;9}>COIYPOCD%i@mCO>Bf3~AVl+*5<;@7 zo4sg2OZbeIztr!9*jPC=p_mBK%_hjOMJ%q~6bV9Ebw;`OaFAHWF z3fkC^s{MC${QnWLy}Ky`N0B+^uC+b2`Zfj9`h09w8U+HZ`xn;ki-3!@ z;?Pfufr2@hMoN?IMa1EmW4>a=5pPw70g5_yI56tJU$n}g!_PX&{NFFNe=cMCtBo*J zGbHNSb3o^a-rmQ~l32e|NPCM3d=dOM>Lb7vfmPhLYhPyL5@^hwEXdL&+?B+%)A+yt z;!F6UIn-Kz<@?NZ%#B!`oM_5Y3-$JNOCxSe*BXPxQ5Aej{z+WUu^tA5Q_L0VmF9hn z-9w^({A;W$Mj!QF(sOJpZL;;l`>qQWalujTrHbd<7IgI!Xz;%>B`y%n@kFFoo0Er~ zCAK}+zv3ZFf=3-83Z=%|a#^7}xZru=DY>PnM5*fCTCsl}OlT~-S=QVam)I+&$8?`EJQppm_Hc84ypYY$}k?P|1K>@RadC}Z41lL*_QS)G-(+ho*} z9!RnUSD3r>RmsN=ye{S?1*#%=I^Z!Ows*mNv#;HIrl3YvtC)w|DI*amrb`qjJzrF=v5@*WZG^(|2d%UsCy}+v!ZO>!f2;eqz;s zS@247Hp1+rI#;5mucUQutn!+z=mNXy!{7Rclu47ZZ0dSy_%@60)Hdv$f6aax=n-;b zjD3U6Z*zE*jEW{(( zcM7yzj=5A}@zrj`JVVUHQ3nGc!M~hZNd9^zcr1aZbu0Xj*<@vJwYD(>M1*7PrioK2wgcXowqw|09FogV8D1`T)ACligGd*@rkmlHc#IdXJ9h3$p0qI%18#R_F! zu~~8^b$JUWGCMnvx2hntBCk{8_37I-J*l%Zyhn~|_5G?wS8z$yuUKxdU+>PwacEO> z+pom?YBLWn;!vp$yKKHXD6FpcBV>4|6@JALm4N9Cm8hoM6Pn0%aN_hLUCg&a=?w_G zUWu6`Qjtjo;o+~I41Pqc54}}dzu&Lr{ZZ{22j;%j-o(i?XN=sFld1N-{s=5X+S{G9 zp}ko3XA%c9Z-Bw1!bD8e$I$-h=$4LCpjKjge^E`fO*g@J>#?3jl@@{xxTKp3;EzK+ z8`%1PUhJi3AHNh37S^W|wP*XwIZzEK+<8Ywz$9t~e7WGr`}^H@Z6Mm`2L5jXe78Zv z4f?OBT_{8tS^~E{fkinia4Bu0AbIm?pj#(F9RZ|OI4^B)} z14-X137>aCX{RqJ{#q+3{MGCxuhJ;$Ko4Wg4_D+5z+hXywH+&Me<7XKm zR2kFb0Ia_-q4(*L>)xNm(uA`2&@IOXy6yBA=ySY%cnc_1759EfscUNLcg(9qq6!i} zf-qGRaXTz&>8}RcJTpX7TmS`!uNBozO-k(P2)P-t)*!!3st$_sB!pD-4|S#%s53c8 zzr~*ZDyJ!g0Ao+0-;v0R&|9MaE?9{yj=av3-X6ZO-bA78?(_{SB6O0Ilf{UB`eFRT z7=rFt^4|+~;r!*61nQjEF7v+qzSU_qvOh*HS>vHCMt?DC{nz2>;Fk`ySqSeAdPSYb zs>ZmyldENdY6$CIP2y?}GCk^LQu>P`uOEEjMd8iEWvGA^+GCKpfXc!4+EttwET=$w zlElHxKX0x#D{}b@!E1 z7?x`!tqa0t{l)bH!(b}*ZmI4t6y z7uNe4kzRn_tUKoVvV=0;|2?+F#yiyn-NL@+#(VVXj#}qgE`=@&;fE6grP`ig381X zY>zRVsP|@BGFpJz?3;T(OhLa}nz)>48uUqxR73KD>M(s!BW)Rqq~lDVPN@H!zqSM0 zxH7tXPhXMBr|G$p$J`$$^~~Tx1dE;Dj!|ubBTV$uFHq9#73~SJcYGM~#$1|I(El#= zoLH)QsW8bp1wNKGF4=}EF4r1*OyDIsWA0!Zr``LfHj9Olpfr~^&RiFq<)LcgH*H@o{3K>Q>(!@aCgTivI}=G%?6S#Nar* zMKSAsdUcs#GDWT)F)um>AeI#jj=tPv+XoNk`;~vMl+$_tEWe?;H3S^S4q#9st|sfi zCbauBJBOIlqvNiyS8Ssuda(@h5eXY6DVm7rHqa66gvI3>Q%MEYrMj*R$ zKH)@~+8q7VL>=y~H6E{7;6skg*ubAtA&z3?s|0? znMXRlT=|stpD}iVu|EyB#i!W#OSL5iH49z^U*AVia#}RS^fr9TxHw68aSIb-SM8h_ z`9KY(0ciBHtiQVG^eIy)_tPQfM+oBgxyoB^A->aDS4NlCgtTqd%oMx^QVF-b&xy83 zMBjmo=DnEf18H*fYQ|i@tX8_HNlx;yme%$IrInG_!&e}WO@cq0k7?TCzOH7LEkt3#2w5m zruXjHzV>kilZb_@6snifTNadJ$VRvdFPJ(tPdfhCG?@HuDhoI|>fb#4&fgs4$tv9{ftc%4_pv#a}c*yT!@(>GOy!2|T~YupwQS^$PUZ zuLXUD9_K6|BZ!8cDRLL|5xo^c5Ozk$oxnhQTTNN4ad2;xlgv%hr!}R9l(Z}5xb1HT^$I#g*5;2n9B_I-jipBeiTA7udeBjYCWYdsTDH+O@kj<41bYz^rYJ`GIg7-+c`*#AfwjMAu0b9Kpm&FDFEp|FQ@^aoP#z3Igy(1h@H1QVCUxvNpws zo4Cd-cpXbcpVS{2g*BO?kOL3#vubN3k>%kveG?6srNudqX)^Pjw@c|hM;{{wa0ZU zj1J%(>&pC@V=d5o8Ma;veJ|0UAXZsm!PN?CzVpxpGCnW;kw&vOgvGG2*DHOFz16j} z62V|e5ux=qS3?&VfI3TY3-4GB*F5(0Ks=oQ|0_@HM5X<;{-iZvVP}Wh81GSp49<%I z${4%Bxe8h=#B6sm2WAIxfZ~pM1H|VofrFVO%fcBCM6~$FQd&TfjmP4nFV08z6c=Ohc}5yt2M*RZXDZYXxkBCQTjjo#UB&ZFa^YYR0cthc9x4je~0ebh!W2H8wm0|mdaZOR&=f)y0_{Q;Ja%Wh=Q$7 zy7!;k?A%2*u6xY{XtcvjXLKJ|B(i2jk+G_@0;8TXPv_8UGL$0+;_NW~D(f~zC2gz5 zpB?dB*@3^IVbKeRGD0UnH`|k9SXB$zT}Yn+=5COMqd+!ExrY%96UlWCNxH~&%g}^z zSp?(6CpNYP(_jy!+A7{(ac2;ot5A7Ji14g%1!CBXl&XnA9OTxsSk5 zZYMV6$7SQ;xCrJ$kII16bxS_rmOp8oHA!{H!g@G$mYxwRXpsZ(s|Oyxef&cLs{&rg z+mN8YJAqEI_+AA#Du@z^LA)9R;Qy;sMUh#vtHJnW-cgtC+-emqjB4$owM(t{`O0R6 ziMXJKi0pn1HU81_m|zsgPan0%)JC}W0KNQ=z}s!c3Hf3B{49s>l~)V{oW%@WS4kt< z(Y_&62H0_D9oAdqiAeb*=`r!SWjwa<{MI3p;$p_?TQBuFyf9Qq#!Ul!L~AdDYfNEh z`ONaQqB}-(nB{FS6Zk}U;yeMKPe_JMu2}Mg)M+j(`(QGtbT5<@w;2#pL&M01EsDu} zfZYqxZ9$3ZzT>lD2{GNke9Wxe~w1QyLSI^t!vNQehDp(k)$)AH?nG zMh6oCN>z!f7vKRWz0kP5tC7FQU&zPmbMuT8rB zdDML>!ajpAan0m9FDY-6Jm^UW&#~ij^6)o03pM#Z*2vGX(k7$hHYL3erh=K367BpJ zOS^&^H-JqY<;0mN}uM$NjSFu2gnW6Zyn_Lxf{~9Q@ zv^)&{bVGuUA(biKIV{^Bi=eQO`4_qp7ag&^@2)~Zq2olu!MiKyDhO$Wg{a1r1!`(P z6?WXmPs=E~gim$dVRpNUo!?kDViy>`N;DM;#&P5+P<)F`@;$$58r(P%>iaJ)$<{lI z^XLbR*UL~#8_y2TLbu%n*Ld;7P3us`#Bg~7EV11R5S6<|qhT^^<4)XKfySc-zeC$R z1|C4)oWXiB_vDs(taqc%;g5V+AyE-jE8*%~Px$gYc#Ez>x;H7ixn&^;OwgWR~@ngfQGSNOfnE}Ji>mT8Y*Q+`DbEjVB?dWz$ z^Be$3TaplxWoY}-1T((c_jua)Yn2!&IYN=SerdmI(fD!lFK|=AUQ({uP8e5`TDn$0 zM$Yp}QM5s-^-KaQ>Z$J~RZ^DW&ZyvfujDVk=#R6^$S)jUJ!7E1N=mX8MBOzxAzfxI ziGn!%Lg14^9Afpl2{hwxID$!E&JD7MToN$|Vj3=cK=Sy8C8^d+#elj$kYEi=kmtL} zk51^|8}#TX2h{oc*2OAlqOiind#OW+aajx|bh`Zcjq!1v0;?L(0N03EXlT~qZ{A?X?>2?*ZPp-aq{e;{XOMWSg%@UEv$#_`sfvG)P?I%RI_)9UOpOqI|mu+!le z+^PCN7Kn4cT2N+2xPnn}04|$GSuF3UGk;OvANS4w^vWrAFr8gKy#D?Q-kA@ zNB2}E8HM)~cDFJ`RDOQF_yIA{%QgAd9;V(5#^%eXG#TW)`qbaXuQo~ytzqcfA%RaDhIq@1@1TP*v@xr%%L$DP}%f8l3HbVJH;T9l0JRvPErqrjCGU|ywJ zwi+#3ESr!)=~5N>{JR~fTAd8?@qGmwZ8lOVKRMl-=Eba$MFG@IVVqADX1g!^gAJ)M zorT9gt*6PAeYxvQp)3hnjW(0J08=hReRUfBdR$>jxnbbh?#Hl^)Ul1#@ltQmCFlBc z7ilW`04IJJ49EM+AICk)_TN)qze(7Ka9+*FP`oOb&gW(vg6Z8!Vg`$3r+!HJ$-cXR zg4Q-?{VcJgk}UN&)TRc`^-H|usE_s~L!brL{_$%Z*SE$LexmQlkHhT0diT+F_`qOqQUuzGci?jGnO_;QS)6IIkhdnW+<3hvvK+*`K zvnQs6MpxOSR(%6*a7I_MZaohETLioB(~<0zA&HI~DpxhhDISxf?}y(eNf+mP9yaS0 z9g%Qu_{sdqUsk7f%EJiG*+gRgL4UdDh=oekk0msiXV--|g;caT2G8ULi6me{U6N#o z*0ellrK=pU!4xBvgaBXj$q*}brbNWkm}lN)=_6R(N_9sVBi6V7_CaMZm;M_xJ(+YC zPV)>U=s2V+a@(aS8F@?EN5q%^wOUG;|8YLgyLqvg@6x3o zWUbJP6RC-Y#$A^5nhrrpIh(nyTx2_5(n_kWyq9pv)2(CdlIKm(aXG_o;?k=Mq2#wP zBd6%lc)4yf^HgId$16pN%e*3)k{djUskqrrL-H46Z>N+lfU6kAk4J^tkaWI`tN$kv ziuPqi{7pQR844xZDaj6S`dCv^V!24UcUJ~7R*!|WY+Ki+IBqJMJ}WZadhYPYGkj^- zMb3>u>O5XhxTcB%Gnaw1u0}j3mvT5|0yxl0dQS#c|EkLja9&#VZj*MC!?#5x#VQkY zq}XV*r6h2x#ikigArO@Uz5b8_oqOgwN$vaV|lKoX_LbgEN z3Z@rpq?Sf%Y6t~aw1*ykQ+TQbS1hfO-1M|l4E#aogQ|o5mY3^mZ+h5XTUm3td>zsI z_&}1&;A0gf=T$QyFmCOv!VK-;A(Y&(v<{lzupFUELhE9uO-X^lRtG!BGD_((Rbq!@ z&7-}GSMW2Wc^G29x6Tw_QwwcUl1wM#;1Hf-W9E}5XHyKV?A%@D)&v94V_JO_mYov8 z211kGaG6#m@i0wee0@)=6LP9lGxuhSpCPQRQE}w_SVB>nXl>D*RT7dZWc)3}s3gPM z;>2=B?U-WKNR7s`yg9}r>&|S#7LzYuP=@ex;_1oZ-(*WAS6Cxel%(g@%{yB0;nim= z@lBQRzKn019vyJ(kVK_<#Jko)(oxJ{s{SgRFFI_dUBlLkO!BM|<~em{N$ z(iCKAKViFhBp76{-2PPZwy%e{B^!uMwX_bz2~rMGWAr>*OI>^YgQi1WhxDnS*u|8$*;`QSa}u#oKa+o2NN z88HJPKIklwlRgm(leo&L!Dhp#49Rebu#C6)ysQPnlOd+6I}e6SBBJkFZ+>7LeL*`z5+rM9vhzOtg@q+Zm z>vGj-B~-$(8>N$h3~K?|F{To#`Iv67nJi4AF#OdyS(md;l(Khpuc^e6PKNAt@@!os z9BufN^@LF5S})3~ex1sFZeEvDB(~RcyszwWTQ3o#$WQ=@6d^vVd&utKNN*a`s1BOQ zJ4}xe`smm9D4boK%eXjjGIiA6_lmYUgn)xA^CxT8few58h`Z0!)wcHxZ?=6EO%Sk~ zm->3Qy?Jtrnd!O$Tgr>Uo}Pkl?kopF#Wypx%3srtI; z$*pfWf}pt#eY*L8iaD#%%vzWEYN>g^%&VarH!LzMj)*@AJ@HUY<43%iGxY z%;E-q*`vF}4nIh~4_Z}QCo9vJS&yyEjffB>rFmjkKfFznal6hrrP|KdDKCwROm(J~ zK^c|Mqh{YEi$+_fGgWM)zm2zId+Y?2uf7H?*0lMo{k@PKHZ$V{W*gE>3F4HLDL8&8`HLq9`u@&sTAJ6@DyQ z7|u%huDZHvVNKW${^N8HBus`lE9T9uqA>4LGkR@uSo4%24W4kzZZWzu&U#`fl1Hf5HSB(|P6D$(RFGcWa8^WjBa4a|D08MEIbdn@K_ zT}obtFR}S|#UUy#98BzQkT20J2Buetu%qq1qbdigk0m0#XpD-D|y$jBr zC!@Y-V{I2eGSmBjG67R?t)p~p@S*H=Ljm9TL~}B&yM!w53B_}oQn4^@<7VF6%V;%U zy?C$YCT^sx8!6!zoS}#u+~w9bttQ>Q`!`@>gk$MW-+&1dUMGJM(>?>3h~&Mw2p*QeJQ9KoGZh)l`)^@In;_SdrT5@ z4h7km7*}|)f7VKUTI%x$!{m3hy!L%UO>O@hyYUy!eOZbvW(mC7(^5zq=eTplXgrw} zyJ2>tz?!rC?G-X7gQM@p@HS6#p8PW#OqdH&e#m~G5lZ@fHE)z!z-LW}P-aI6<#S}H zc7FsbGPf~Gz@Hm`is?NYeR%HU;4Gq7Ys0K0+48m+bGc|;y$NUfEtUrXKZE+@w%mYPV`!u^NcIn3 zjwF0E=97tlb@d{WG{n=%;H#7lO0d15(d2!L+V8GRqjz?!o`>iv@0){><@#yp-!a?B5$? zH-1gd>y|Rb_fw|)u5P$e9Ce+Ss`?IVGoSyxYr|!Z=S?N`1h=Cnb{NHvATa|=!yxgi)gVUwtT!I$9Ci?pk_0zRR*e9vA z+G$_ZGz8G$+T=!dnbEGhcH-{-TY;LN_FHx1A40Gw&boy zJLRa;EJGFa7D%8~oLBG@Ui;FcQ|tYBX(*3GI>K#?kEg}2XT@lH>{K+p6Q5ebRn?o!alrxY!HzE&&?7<&m|H zmu!7@c~r*SM70>bay5E{H`V@Rgk%qog|S3lpJIDE`P?_vh4Sa3zL6@&ENXBtAu7tF zLsE6EocQf+O1uk^x1LzdpL?JkQ12jx!$}swep2T>&3Z-5}d~J@h_;N zYrEoNT^UbQm#fjB1gj)?An-sjjaBK+a%t@zo$TQzMfb%W=?6>0PM#YWt}l3YMApuR zp!gR1g;KfP+XMZs2m7>PBnr0pm%Ffgbo45x!+nC^Ibf??I$|c%I^wO;C_Eny+JuWAs_O?PDzMPE5(ZC;Ky6dqD=YYj#4g~KO` zj6^!55(h<;ZAcym27q`?c0p8kS%F{J0G2UW}Va^S0bRd}|} zrHO!ciVMS)DR;_-;-f|5m47^}+jG|I1s509+Cwdl-8MEPy+WNU!)vVhcXJa@M zL$Z^{!eM1Kuq8~U`i5jnSiX>wk|tAieK0X~^Bcs?H<|7G1STy|30s*RtuZa}Qe8oJ zgI33mYwB8LyPCWMv=mx5SbYUhL%zRn8;j4{6{T#kT0H(um6Ky9XJ?=`%g0XbHmnz1 zBvqn`aAz9+-Q{8I;3vV6gM@_Wt*bVNV2gm zcLh=L`7H*n%`xm)-yT*Bkij4$q$l%q%b ztG%IW5b;g+4Sn;C2Vn(1B^7x5PJRc`0Uyg=HIa$seSJ^2qh%r>K}?@4IKv@*G|IW; zw7S;1GZ<{0y!!rW>^!HL7=3+hZIj*9n7qB|6LQtqt42q3|Kux^SE-Nh7*MNn-g9+z z8l1B0hW|Lt1$rk#zJ42J6|t*V7+o9Jmzdjq{olYu06MHf+Sbd0=YY(M% z_4Mj!i0^(ll*u4J+bk{M)`rhxUW09Z@uAA13N7v}KEk+pw~HEyuj=}f$W@7(W2U&A z;u-tL?Vr-k+xHku=bR^~o>F-CczEvYc)90tOBRv52(6<8s>NX1Y5K$8T!7CMj;?Gt z8v^@rMo!0FNmKC@QAPo`hs&(7unomuK_>Hjk?-}{zoIp`V&#-^+1^O_-%u2OOtZH8 zI{Dps#!G)l{O{(TDZ$FHuDefVy)e5nks24(+}DD_`~DVgl6Py+W%dTN^OOK3o7Ft? z!Jf9*z3MGPN~%W^NBJc*j}AlCh%sN>t_dp}t+~hLbd!|@OwJlPD+nc?WoD^AyTj^p zXn*;+6qfn+lK-WPTXHo&KmXLv9e=X8ELZBn=a(4!a$9yJodoUT)6`n;1`DD~(%a*X zHsXA+xoyZ#Ha9a8q@Bi`e$`q`PR-!><9mboT^VLe#$zt*R1wU1Ua2!RY;#&Pe1w5t z`5R<^MmENg$cA(#-X+C9I{_8#Mks^_0?v09C}4Qfc{J~p&p(ND$9es$q^VqW^RsIb zW6+-h8JqU9YcC0%49LZ-by2jwcm%TE+jz^>^D2ZgvkGQTv*x|--uh0&C7;%%CqGM9jv40GnK9Z!neD}|4Ag0!C_TLc z0fX3d>OG$;Q8YYF?Pf1Kl?iE4w>aH=Q?ms86aC7%=VEXg39@f>X?Sh)wakf*TZzoS zCFyTCD^g7J(`$z}{oEFs)Hzpthq$4f3sY+Y4bnHYX~XyLRZ}7qtl)l)5lPtE&cTof z{2jf?;l`^nEjR0$fOTTO1Hr?m?wH~DBAb$vm=e|6zsJ_b>sqe`zdJ`CX_W3siL)t- zOZ;G0jB&uU`bt;s>YCM^a|)HgSAv+OH%2eq8hs<#Ej7>i#vvK=2SKA42Ck>nLHn};E?&Yz*icyMe|I{aXH+*Zad*L&8R{Ns11@*r+i!Z5~ zG&&wnq_d7ebd(F$&lIfH8<6hGGybbB> z{^o#RdUTR6Zlunfu^s{xLHcQi0NHy>=4R@jL164=qHaB(C;R-1%gGuI2#;CMBBFt2lb*b9f=w%%w{-e$d8M4GyNg zEh$NXgV(gmQLvjq^i( zIp=L9r<@z+-nc>5M9;J?tQD6U;nd$dtLk`3;woniYD7BhTIbuqY;B*uLH{49#S zNr-)biQ+2iZhKojNu1ATiqelkjanZ_6J?3cHHXbMlo71$B@a3F6$ChL)8^HScBz>% zSmrWaw;%o0dPNB(xYc#F^u2)m^T62a1QvBsr9Qh18IS*99l6w}%vIXaC(CF{wv?CL zE?e$y>Z{#PNUnItCyT4O)95B$l}_-bccQoEyFfhqd#Tj3*qo8$lD(n?8BvT;4{P_a zwjME{ec5W@w!xS`}O_4m0@90p;&{bDghBXW2Ro0wrkzDLUDQv6fYV- zfnrd-KRO!+N8{`U7lDIeazpM>kM(u>aoS#KjFQE=O5Q*o5`CXzf*Ufsgux_I=p3l8 z^y=Oe*jQKJLG?$fS2Pw^@C*fkddH# zsBX%7{>_*zW~<^vwN0|f#1*f#F?tQcu4@&P+R}S$=;xKA!ZQ_vvrIOAJ!ci=ZsUu+ z-m>U1%#DQ~6iab+KU|?C(&wr}Q~uDH^1Dmdri$uSnJ<|H=ccSmGgOywkxf^n3*E6g z6CT5KZgb(*|HIZgkJ!2moJ97cA zmR>f^a?~x{U+!T17&LMOUYdbLt;(bKTW++MXk9Fl?I&yVg}DVEwSR zg|1%G-^E{c7nn5%$uTVsS=HK{^u;_EHrJ02uLV6y&QC6He5^HV@d(j~MCB|(%M;++ zIYifUQb-{wF7r-#Ck8Dy;L;G=-pB@2 zxWC7dy~CCAbOwpW!gr>>UftuXPm@6+YM7X{4TTwWHv3Fq#hrco!QpoQ;iLJ?my`RU zB5)DeQEsNcP?Hi@GhZLH8;)9fR`JY~JCUN?eg2^Fh3N5+bk|1{dY1j$3e5&5TIJDE z7WX~{x65TIyCuNK>c!v6OXJFE8<)#WqnJ${$=5?2f{ zP`i(fjYV%>jQ;ftCn>K0J$GK!fO400PeEg)XM8@Cgs18e3Gq`(sru={5)D1C$FD0Z zS=Jg+GY~(rIv-O-`fP~7H$a}g&d85qs}K ztL6$ht?WiR@s~?#7h${nqfw#eVVQ2|OWJtH0rYmqv|pEpK1akwi>a&AbTx9L3woaV znI8I0hIVpakgUf|L6O`KotpVhLhnZ^Q#@1LzF_GRO9V|z%brtm*FHLEKI58T(1+=S z%m>94Gu-gGKksV17p8I+!g--zDch<7^Q@ol(LAI7LS&DBzB|PgJTkdQR}ub2b7$Np zna%Sbxjd(p13r7P$oTc!hQdLhF0cZG`qQ=lSL)?(Vp%1U?4l-ktc&|M#ol(DjaYF$} z5OrWQK#$M=zG|w^S-={K(tZq0k|&UbjPT7(F~9^`(3XRg6tZNhXn3~PTFZ}7kA7uG zuT)nBXV?ri9ZpNF9!+a}Qha}qt+e_1aH|@E*cfFsLg&jw`oju3Q=RAt>+|&NqVq5U z&)WC6;UC&ypvVfAG?IN>)h1#!F^3m_ZNo*EZ)mj74aqfx6F%X0Kmjj{0AfAy#OlS- z`=yf$egDLdfxdTI;X#hSU*!6*DJ!dtfKId=vmE*eo2X^tI|bffTf^hgSl2cLOadhY zHG7Zr*xK+8|KO_}p2TSpxb^(#>0^t1XTI5J_A)1rMs)g@MKB-LgtKljqrKAFW}(fG zJb|M*^KiX2voB`V9s?+mo)|kkbWH7S#7FaXv3(&r>O6LlmtWU zt~RiEe5pPt<>~!I@>vsl$!xWBBY#=46r^Y~?3*4ZhJFL~KO?yOr*QVnus)-hPoDw~ zXm0(?7H=@0ylKJ_6+~_@Yd>v6!bLo~_0?}Vp$y4tUr5WOd^A5{a7|E&gsbIG1(CFvHg2R%{1>08_|SyF~i4)i`@4iyKS%QPCv2_^RW9-r9Z~blZ`*o z)ELWfiZjjNA!rMJj#f%K#fGr2@9_3c>JR+7wHZOf6`?v(5b;EtG&*^%o;USiaZErr znLDKa8%~B6MovA^t2^>GZMGX!vyAseICCEBf6T#Qea<<$uz88%td|oWVXws`ng5#+ zJ$_M635U!GyGuR6FKu#!hcz#GOv&Kj_$^N#>LPv;a>EWe-}fW7Z6IQL7Qb)GTO*sP zg4j~%ElLXM4@06Ff~#7FszbFoG*45-pzn+(cBu*Ok6fp!R!Mo50|R0{X1!P%Gc3*g)`G9_EpbR4@C@Jj|BsczMpa5zeC{udK;1LUMOP2 zca)UU?xTLV{5s?V;d`iKey=|;u6Jd z*LHMuy+VcUhYYbS@x^lRefuPX5ScV_QN}V#$g12N#pCG-2{5BXX8PjeMwQ2)8S?W9 zMnIRU06nf@dPs0<)D({eM9;^A3QW`h`7lWQ^?uY}yT%-P?gz|#xCbTZQ6WeDEC_S= zxL#Qpa3h8C%%HhB06Qb9a-JFZv@OSG`Sx*F0l$+{LKN;?thQvbFL=Sfag4gm$g+$J z$y^29_)kx9sH|jA;5x%ig2orU`G&}jmk7`qKvKkdG&se~dNp4bn_##U7R#Mwydx=n z?6g^mJ`gJI!PQSfN9dN(`vLYLBP!Jh^~F4f6g%bfK6^^fWC3m?;y2vfo6uM*a{L2tHH zIUCSZa@Fj$xxAH6yFyein-8UVO`NGSiEjR@oK!wuNQwk|nz=)s*LeX`<&-0%#UWN7 zN4$qKgHXn9(_3o3-A<{XLEuTRiy*u~w%xpg7stL}_0BIeL=qPQrvb!nv=%mNuj^$V zfs^g;n_kE6<<`I-8n0z1KwhMj-Qa$qZZPrJo2!;#RX_(% z7X?NyD@Kc^MgfF@cqEnNLKg4`TuB=IxC@MJy(|s z1^khp8aV`|edD4iAAN`c*dJ%)U@`7dNG{H$yC_t=+Lu!NQmut$0gM?Nx95r^2c z$74}QJ@Hb<)c57U!x+XSFtVI>SF)oYR~fRCa6^|BCYeBN(WO0%224F`mmc5sZJH8ajD^4u<_* zOrdlh%fBuf63+*lOo40wZx{wg3L&47pIgAhIpOR_aQ=+bfJrJLK7 z&1U_{@!1c3+)6JlN~&x6aU?i<_2Ttd%>-! zYy6SV?VNu}ZtMJgNKt#r8GKZ`v%A(uf-P-e-_e6b$Hwz!`IJwfxPujA* z#;{4^L8+yXiBH;Shtx~GQ*PMh>SlfUdUHN|C!vNIK-ex^dEx&`SFo4)WiH)ZB95xhH}RUc2R_%FAEQe>$(X#~)w^jrTk%MO$*|D~}} z5&3uEN$H70j#?%@mPf@ZH2LZO{wdYWUg~E-)p}}PW%D>0q1I0D2iY|p6YsrOs#BZ2 zEV=!G!dgtGvS&ctp3AS?l*uaDHHE%(gDFuTdn8dryVt_jGq0wIoSY@GvL)w&JA?%Z zY;$bl3%@p8P3E+YbMT~4s>o8f8!~+1#jTxpz+gj64XrkvH=Gg;tj2U=M9U-Y3Qia9 zC`W~X8Y>L$nZDB|sB5@Qc0L57_+p955)T~%e+z}=twz^m; zdy~wNx}nUt?jaAH(xTd!GdT^lH3T`9TX%8HdHq4y^jz{mA|!H3FEHYcY&D0W^5cB4 z(K)34%py+~*ZpBx47!_1W&L9DIBpgak9@&w!Q@KnZYP*G`e%tHeh}~m4S8a#1%}pk z1pIsbBwyr?m|@siJSiRBVX)S2B8V0^d^C}_8y1{)-7-AQgb|NMK8>9H?&!dLt++G$ zVgdH_vsNDsh|zbc98~ZAP6R#U{@F-?2^S{$m;5QRrLNI1Ebos|<9o}A$UT2S@HEwq z22RVfWz^|%j^(BSm7bs@{0}?p?f0RhHe<>PjYOv5Px5X!GN*>+HuCq*M5OMgN~x|R ze|T;-jhD83Z~}D$859Ugr;R|75<+lvX=hjXpWblrMQdU|>SBc%D#zkaua z5C^X=tzL8)&6G8-{N~>m2{2_`QlcujccuNRn3NdtlFS$4TiPQz`y^US^Malg7wA4S zOw_KproOy**<{VAPp;0@l_-fM^4UL9l`!R9=>8RUvO3en|E~=H@F1UuiCQ{s&3tn^J?B5#iKDIC8IiIZKI(2A_v%ZYJ++Qo!!_8|Ianzws2Z_u zrd(1eL!5Oq^dxEvCZk=ZSo?WN`s90U=REgY^fAXJw&RYT_!piqBkx*?xu?eT_WQPE zvs5|iB~)O6`{tm9?W4S+o_HviG>i?xQ6Oa1LA=1Ibv8YixJtFd`K5%SKSm~O*4#g8 zIThuW59Acf{r*`GiTM5xYLVGcM{hS;hy6@NVN?qw`hObc-2Ro#Oq3{eIWQ~`D(z>&KGBZ$Vn`Uz44Tp!}a8FDUCZ@ ztDS@T&Rn#${av;mI;eCVT_mJNDB7DkNDN@dIKnJ_(B8q%KKyB|G+zep*jw+@sg>E{ zw>OX@{aX_Hz|Q`J)jncdv5hC_Vkvrvnea4Td5_)rIJyHAYAY;m9ptZX1R=k^zGV8b zi$ZYsE`C=X;;@8Jr{5c}IK0e*wPS-ffN;ls{yNfgM-Aep=u1G0c6ia&S!aAX-(xuk z`GPmS0rrg@%gEC@j-cTYMEHpByCF$Nd4%gNt|G~ z!2D^LL68JL)fJu3c^{6Q5#hz#5UE=JWOj4E$HYYQM;zGA_X5ZYQH>bU0>=c}-wr~r zNj(UzAyfEL&-k9c=nt}Gd4)j0H2~q@363bYYAyQ=?H%a;pw+zmM?uFLSuZ z@9T9;R?zt4>V(hmacdN2S5kGqt10dJdcU@CSP+)_>tRL`v7#w-Wj(*;M?bIhNvhkKY1dbwl)u@lejTvb_0w5f^vg&!mW< zeoyyF58CK%#HdvwraBnGZdD{O?Dt=NT(jEhAVBrqFff7HugZ|n!{s2*`}$1c>wX#* z5>>%vr0pf8`T`6!9eqljpseYX!YkN+q3NQlgZW2GhHV3IgBQ4o96Wfu&B& zMk`7%tJy^Q1Fn$u{j||#va@)GJ9l6d2dDae1RUj?#veJ45F&iLw-B8=B+SynMU=O> zTo)&<&A{?{#QoJPNj>$muF?re8OCpjdXT6bfRyTm6?1TMsU1DTlKjx;bQ|$&up>72 zabACu1W{Wl?6V`j!KPSrX1R|e$Nun>8fKD)rY;d4_hS7ol_>WL@*;zhXc0v3KwAhnH z0EN&QuE@bvr^1xiwrRt*m^+2sd+3MV$L-b%lFMb4!S@MUZNs`bGfX!UozOo0uHr*iT-|z7-U0i$GS-k=uyiQ-4ZfA9}r1i%(gY0OGgi?;*pW+3U%8T8x(&v*n`23QM6I$DJpO$jtb(x(lM6`=Ut3e9?h_C+ zdir7||9HV+#a6|gAvbrM5-gMB-P#`EX?}I%orAKL>Ox>NWnOvCO`Y0Mn7L+4fSSb+ zN!ZUvT+iSuEZ3hmUftneT27!))$Rp}m|Cr0cHN2^#-n^~cM`mWAeJt-9WrcE*Oymm zv@!NPO=TI~F`-}-BthHBrKDZbputEkr8J-J>1P%(G{kZ^M#XxjQ_e<2saVG9C1YWC zO64rgFt+!MQC}jV?o*h%Q=W0=yLMSB+~O{akb`KIXo%nGqaiuAxIcg%gl(@nxmd*J z`@bOx=xFq(qfy-H!0HU%=k4Ph^hY*F=LmfCHpFHJ>G%3l?V{OI0e2VWq;+8Myhj^q zPMhPFD!yN~r=1gGgDGtY-&GqSQ@cXx40cC=5y|X_9nC&n4j4@Ci(+SvW4WmNW#F?*}}^mdVt``FV}(Il*n;%WIZt7EM|h-s%|1MRqKE zM6;3~zKA^9_%AIl?WH1pC)PJ>+Y6q*dja4nIU?bYbSd+SS>aY2g4u*v1Tg3)ZCXys z8vPIMQ=_{)U8H2&xu9I^io0@Bn%qlcD9gce21Gu%+D4w$zt35Jx1+rRUE$-OP%-dI zzHbFfN%4LO%h{5yBpFX!t+Nz5!@%oe?(C5TZJ zpPN7O%~lt&^qvYPo2wM(fB!nSW@}i06wXR2P)XH`R;D8#(@IKA07u1-q@pljzu|Cf zuapXDs3In%32Dn#sDb-+w@k=cw@{PE*hvbFtB!W4GimY5;Agm*)XqWwx}O#pG6+EF ztd{#6iXu!hX(OL~kysn4Ykj3;kM)~T&tGQDbm>|@FO#MCMU#nZjwx4&$tBjPHvqWc zk1o4fQ%4YxWEm(|kPy)i{}Gj;L4n-;)K^iQMw$|xswa+VvVH+)izG!lMG^w3<8G+7 z@;{Axr-`FyDzXXu94r%`LF!rm4OvpJRR)AjzbK;Csw$+wVw(kF!p2MFLkZ_ z#VWy%$sGBr=iez|&~T0@TgRJE?Z~3rH-`z_7WL}rh*8ef5zC1SznZp>DEr?WIclPl~fQj1YHR%xFQ$EDS-4y5;`8^{RpsTF9=v#y70y}h zXB>53o+O^n_@qC7Z9DY}^qb!4m19OEmb4Ud?kpwwT#m9Yogf-qJ{d++L8kju;JnNt z8y>N&`2t?<(u@F&eRQ}`LgjRGhLAD&U0e5Sxkx&oaMYzsPsR`M%x`iuOepE9mD`c2 zXlrXDlzrTGVEQokBupBpY_c6{MYqOGI|6Mp!j7K}1u(&m;-(oi!x=pPTq;8E9#R$3 z1pCN2&8i|}n-KQpLO<{vp9K4aQ&|Z~mFw{zmJ;i%Q9Wl+*;6Hn%Z&~PwLMiOBjskc zhi}4UG_FS4AhC0#EKwj_qRjgTNhe3n3%^HBCMru5ftV;tb#I%_@yP;i^_wKrMUj3X zJzNiKcXZ1ZTn3Qi*N^F50JTWATsE8aIk+zZQJHT^$h#kTlD%f^iZAU(6W&0BiLzPQ zVv)tto>e>BFOd^ZYet{RGDyf3sUT+D*Lk|~Y4)1H+!=F?5RiI8ED#K2#_PZ}p|%OH zo+^j?g;Lg&{3A*T>Kr+>N^iX}6P|fRiK=BDH6gt}iT7Gx*f=CkmWH`?Ms7i)jIrCn zx+R$Lj8D&z?MlGW=CjkfSgp%~8>b*Wxcx2Mm^;@XpnJT{q?uIZeEjE2sb$;f-5^rW zMg1IE{OgQYE9UFnDlA($hB{rtkb#kB;HdiNc66z1EU7&^uVn<{ik#IR#w7;j+F76Xs6Gf`=ThXPdjcOW!LsUfTpX@K$1#dv6QCcsHpTnnVY%CdRUZ zV%z$FIFx_C^WcXOKK!sP4dH-4LsI8NBVL)f+BOIU^P~LBR%4Gk7nwxN2lg9mo(kUN`Lrk(l54GB$~^YZz}WC|EP6E*a367A~d~^b+XS-PX&feM1=u9c{Xh zEbcH4g96($Jb#f#;FR!jg5m2_9xPz5)&>qcBiNkW05A3^zzahMKnK>*v0A*?5!A_I zEzsZXiJ_ruA7okO^k4}d^Z9cau)$WHIVI^UC(qoL+>hD#l?=!bNIORQen4m;PSTY)V?$kmzhhoJ5(Ixi;5cInNmgxvMIA($m zwl9FeBk0jQQ(IeGYhkGoz6b*V_mp68q+Nd;cq5WFxE{bJ^*qr4x}np)o8+qxDetj< zNb`KqF@Tp8xD4@bKpM{`biR+z0US&)@Pb^~E-G8FBt6@iTr6>+zcv~=saer(@V2il zu%7vAv8rv@&S3CXjT133aZ|0E|hQmFlv`8y<>8o*79xN_q!$XgnjgT zi5LOXbjK}??}lQLnCI%oshM=^yLv#heKhSU)+BaJ{ZDp9{{^^3_hpL3<@z5T%kIh1cc^Aj7jJC&?`Vbvj-NH z?KL*epDpgJ+$z3flW|(&kOC`k-1V7x2jDhMhXwfH7n!F5F17Q0KYVmbb7vDBvFK82 zsx?R+>LmXelpmyC>EBB*xvBlB)+A~Sx9jJu3Bt74@L!DZV{dkYgSjOjYg}_j^=w84 z7R{zSKl5U%D-q6uTL&;~C7O^Vl0w|KUC$b-TPu9;xtY}0W5m#vJU`apN=FiK+RWep zs|cYt!naPiBn<$OZVz~Z#tV(^m%u16Ha)$JLewkD!WqEX1Qxt6-ZE&Gi_~w=al1ssk5y(*-`?Ix`g5;aLxcaXa9sO9$f#sD?$W z&5(BU10WZ!%!7I7FM>aw=j;G2&&iFF_%+=}+n$2`yj@yLQnJhCLPSO;Y~=>zbpgI+ z=?@N?+Z)aIx6D3QTQA4a`+?=BT^FHQJ}){U+dKMF9On@VvON1E^-rRzF<_fOf%~*Q z{tD!+-wYDo^pTSEFb+QoQ7v|Io)A$LAVD)V5cR_*-8rCxBK>dw*bfjUY*rHtxPLMg`v(Ss zez-^DXPZRI+Am^vVo4C}?B>V4DWYdQ&RPk@;*w10IsD?euap(*xHL!0L%3xa7<#g_ z!*D~A?F`&vU!DBEM>#NH30+%zhwE>g6J-JrlyoTFIHD*Wl^sgpTn$)FJ(!LSwWkjV zEXw%6w^oSWH!3CZ@V!A<3-mw3uU$8?S;*?hPP)x;JU9NMfBgcg3kf^rkWi@>iD1;A z*;^!He5r?$Eqbh8vfjjnX2l#PFqOzuRE}a*p?*tO@|Hcdd^3#%mX#;ulzkn2$)evd zoVK523{%>&!eNa}0`4Rtx3B_RfJG7qv?Vo5;XPXpM+os4Q%D)n>o)@dSRT35f(2l(k?IzLi+igbMT~De*}r%SKT0Asl;D zf}XZjVx25*>sbs;)SMi6uw7+Mmm?13BQ2)NeE+A=6^NA$|;wtxRxq7#ekoXl|aaArf3EpOvFZ0Oiq_D3@#-4$X|^N2p{! z>&rqU(Qf$14lApw#`Q=fb1oH!Hf5d4&^z(QW*=;yziotOTugS&^r^q&BVDe(`^hdlkBFUWr8W9;P8P}5*jFww3se)wuLo4@R zk)TK#g`%PTJ6xRA@9pnjomYqUL*$;a#fhw>o5Xvq1+<0wO3MBANweSNj&4u<^4xVL zzqpzYJq`;qnM{#j7x+f&bS)IB(Vt-on+-zF_$3{ZJi0d#QOEioAZXO3b(1t6gIJwd zD)Vl4m?SGuf~*3k#xLH7+Iai)4ND(TRkb1at3NUT%?kwq0YO&tNL#WDN+FvFNI#-` z?%|S}!RRD~9dE1We6IKUPDM-1B!k&(4dSe%g06kty0Ef^IHE%b1FquuMX~AWjH{9~*sG0295qKK_jAe#@FikdY7s?x zfs-L}tJT0ESj>IZ2;)#3>MtK zbD#_(co#WHMbV9WKdbLAcn0qst3XH8{@rw4XxFr0th=Y!%zCuvaIskF5}q3|Ut^)sqcqnBXnN6g5z zN6OmVk^y=o!*%z~8x(5Rq2JY0EbIkPzh=df>2=>q&T6|I%s|%)-Kfd;xsDpx*h2D_E z&@{i)2uyzZ0z%=3aP?9Pm9V!N-qP}Yd9gnxIanGJuQMum8N~Lh|5f!MkcKP)k{R6DkFM zTd`N$9!vte-hbMenE+>HrHUO1N2yrDBYLFf%-G^W%56*s|_cC*JpsHBVq&C!+b6KBT0)Xo0-@~v2o9SfY4ubv5G z*RU^=OZ`?DMHzo^GE-N`$^TWG66Qkn5flb?2dJA+|B@H~*7p3xDS(2jWD!e6gBs>U z->3P1vfqK{`QKLZO)F#%{yhstkf?~jP8L>U#HROuXHsDxh+FAe>7xE|O!=?l?=j|J zG}JTUy>9eDen2Bbk+jH3emHf(`6O}QhyqCCtcD+D)x^Q~TZCjyVyoVvM51@oAmGf4 zpUG6_voiP==uvauiUue_-=^iscGvyf+O@#lBy>a)x&j?hm+#V{g;ftmM1-cxAA*C>b@S# z*PAk>tSCT-$SO&StW|!{hH?$!Bnv--p;)@Xv#ohJd{l1+LKqhtqn{{B^jNierTf5+a z`nJJI6j;(56*B*`vaYE1@Q&b4!&@g}d_#oTJ^KCga{#yp+s~~a7Aqkg_66ILEG}bb zXD1IpN5=7F{bkuhqwpmXAYxa6`(77d6Kk8`ShdXu!>xj}QSHM@Wj~V`;4<0+>ftKL z14RxNnt->P9Dv_jbDBBuY~_3^j1;S0rY~!J4qWP9OqA%<=9U3Ar}5EB=Oy5e)*w|A zzi-3>-rIBz4h{y%ztJ~NK-RblHtTi(%Qhmq5Je;jtQzE#3uB?>f9MW!2gY* zS^M9*Lx+Oa3FzE+riX4o)JSwJ+$WKHc%{A%zA2sahT}Z){&Ah1fVcAS8UQWPl2oU7 zWfMe=2r3;(dgH(W@SzK9srjx7AX)M2?(eQE3|irEgN)X)!PC^NvwIQzj1W$e6eMN- zfd6U;6u)gVA^Ak6Rs&4W{rZ=HSLz26avce+r0{cqB&TofSgg7iJf9MK>jEC4ar5oD zN`YQ(#D;qz8SFhs`L>tSjRFh&qlGT$7Sax>xk|JHKfW%q>%`Sqg7NSBEgonX_x1EB zI$i?SBMY!Byx9=GZw0uVg1hDIhb>PqpsYRi9JX@=+;esT zmg%wCX<^wwokDo9CJZl(CH{PrY*P;-6(o9{%%P-|G$eHW4CJrv)QP&4)SV^8XNDd5 zfHh86a(p_bpfQrkf6$0+mhN368+-j9*&`YN5(_4K8jAm1dI`k`_fFC_5TLDk4FQX| zZvp_FN(qz;QkJMsSxHuXoWGOY(Xyq1cEX<9xc8qzM^-}b`$0{rr%UG54Uf3Rf~;|@X~ z+jO6I-$?r!EG0S$VqEIVI;l{MBisVw*G0x_LAR`GM*t8jDJts!oDU~Haz-3gi?t0W zYCC4f;%i#)1H(3q03{nZ6xw#4jmj~r>DEi)Wa7jDq9dw$iFOdsH4^KEa0DS3*Ph3{ zFV%#>IaEuG=bbuAN?2~bK$PHcKsOoK082pEgV6B1r&?zJ^@Qzg@xlq2F!}jrSfbo0ba`KKU9sG~eCM{Dm4qfiO$oe>mKR9R6%4u7R*Ht5qD$*;8prJaxCg|u7;=PT z;h=m0@X-8oEoi>EdJAin;v;48IdE0nLLHBx5!mQ<4;L-1ML$Q9%LTBOpk2m~+CG$! zoFMp?Wllaes!JG@X`Tk0Gs3qkSVl)d)XCXgIT12KQMv&bpkWV62NID4a}bt97uZiq zu4BE20|!4TAQzl9`*HLqv2m}{QS%wZ-5r`sxW$Y*V-8)9#0CVAo62{;+%cy zgWo;eO~X#97|3}4^005?RWC(7kU3uU7}L%2xxKQScP|^y1JDDm64SlU5uw>LRS97{ z*dS`DvpfaMwzE7+aEg=SZbP}kP98S+8B%fUl_x@sUC}#cGj;Lu|lDSKrKom@If2ugoNF1-vJV`$R%(Y#&=WSWsR_S`b7TWD-8gMv~vj#)K9f z`hUilnI+;^d^hiYZ>$qWDWq71k!O`=*MlR}zmefB|Vi>C{Vv=VNuy9HSDQ zFFbVgC9o5NJ~Cb@)NC4@7#ywKdNz+XXt;@%Y*HK(zYdwCMbf@2Xzzt8^|>p}{YU9o ziE9haBaB>%e+eVdTJ>&!r8Jf$ff~=%bC&nWBw4T8F3tU3oKi|Yj2|q|k-; zIm3C1MyDTFpmgxlOdDNC?1kOcf|4r)v2t>9MH3f_YObJ?UWhDr{T&1kBc+O;tmq=Z zvfoERyC?pza(Eh|K1O*Wq$mtB=50ex?JSJBxf4;twjNO+to^zp-bXXMBJ4yjTW*I^ zN{qbfWi zmUqZX(H@Gr(PysY^cMWRrTM4`7U4X9bybg&MQy|AN~q`8o}^c)K_e3TGIS)oM%ttZ zg*y#&D;@Vdh>}B4Ctj&=%DgSstnO1mm|#P5nDB`ZBV&tY|E%uZwq?KUM5#LnboaD} z#8aX`fnX-Q^WF{Mx$cS7c98xk_W724ZQ>&9BV=4^?gA_39UV0z(a~}{tppqb0$HQQ z#XuYb(KD8TurtEU<>o8)v~Ua6T(TA3g8a>f^BJr7Tuw?V-@89wWrwn*jTgNxzw&6; zJFF+*(1){3Wb+scCNnAev4$%**f|PizxGnxc)~@N%==WxfE!4zXEMf*P&kS34=*?# z<)hnom_O@8CA;EHOe18oi^kPbPGX^sp$PNLhCYH`$~xvEBV_aIN`MH~t{>>54c!soahBqj+jq-9cD^?Hp={G)WMB&=w4|i||ms znG@@9UTKnKj~xAw{3_}sYwPJomp#h|oOw^xlJ}%r^8Z_6ly(Dg?sFexdRMp`{7aQL zyb=;-SwUu)NBZma7U@A4nF@kuak7p^nU9R(f+zxre=h=*G2`S9;1$sq7P;l(6}mx+ zo!0^0Z3P@EdH--c+ldW5;ykAcMM#BR85Zi;5pb=^KIg4q>5R0{^b%ouYfjOEXlHwA zwk!bcfy&m6q~|>uX$!H11v%#M7!i@6p=s7cL0C)nL9n3eSSmd~YV;w?ZzU4rZcWTy zToT}&r))**X>cCnq>r@SimX*rmU4Vrs?#LE%G!FOGT~AqG~z;=4{fZONA2Q};=7c% zFs$&=I>}Td;kHfX!;i>yS_|EBmv@dV#g)KEU^;jlu6M5FQHD9d;ie$5(Z+`(%Q2oY z0)Oy?h+n+B|N7&_%WPdG?)E*uKIXqu0MIwA`1C<%w6n6lab{BYK4#~Vzr%KSOng!O zLL-VVMvV+qZA8`YNzLtV{LQO<6J=A-I%Q9bQ%Lq^4U!>b9)DOAc7BhV3?y@cHkPr; zEI3QEC&pJeQE&vvhJj|Y0gALRrn)6K6S4uJKZkE)+bRwpH&#Pe&zu^KsUqPhh|mh8 zzkkY$ZQk@O+**6wb0;bjF(WgGdw32O$!Lo$82pebli1dN(Vitp{!<+H854)r!Y zW-&R0uk_i2l9(b-WR>i31VcFnL+IQ8b-GPj@!|hFE$8Xqa{Lw+HcXV9JSzM&yixC) zHsDea%hM2g9qi_!z@f$f3#JkKm-3P?0kVwFX(PT?7Me7UXI4LMY>Hw{D6r3z$Y`bg z$$ZYV2@G+v3F>>iUNf9a(}f`;MF$FGP#HAEa!fq48C}_a(LV_ z^CS!F3t4V)w$h*+XyN_FMbgDjp>E#68P8_VgKrBLwL)ZMg9|%vciewixi4P0e);yL zbEAGBdo|AnM=Bv|HVY49`;MYa1SdY0P3r@c+3`hOO>d1g1@d(aQKL7VqGvDt&}_ zvjbDlbggK;WO#Wqhr^C{_McRKzh{^h{?@aNWgD|PNiYVUyQ!G9$&soa5YXSL$uh=W048MWmtI? z2K!C5>fK#?3p7Yy8+wBu^XImw%)v51cyma~<&KVoje4%iljDTaLLws^dn_X7HfQgf^^4 z%MCf!_5@D?lTW#>yR&Ljhs$fSaUvv2q?{gyg=n$dmV%eP%Z%4+MaN>NMO9xcsDla< zV;9d!;z|beeyWqTA;BT9=ZqSGRI1_G-2 z3#_r(()MduUG*Xs78aEb>-Pz7XGGK0JAhLJRNbMGDHZ^mpUWiLY)F9*gkRkVX#+O$ z$a6W7+j%*mg!;3C@dQ*k!+J%gpA&MK5q;7@<4vdRyUbTd_dnuZjSnS=_1E@bj0t1? zIjhwz(SEtJ76TbQD0TOZj4Re)d_3`e`rY6z7mqFuf>93eOmJ9gd5kL#It$b)0`q@@ z%>C3rP23Kg+oJ@gRUd&Zog7dGOu)pcG#wzq6$UK@lO{F`%k{wc{u3zV$${!q?t}Rh zC{^|^wFZ0>hS<)Q=?fFG82E)}fF_5c7=Q=;Ecsw^zxcx&G^qn{&?qp=z?I}p9ABq_ zEg_0S&Y>@kJ641qn-)3xJ`31Ck+a7Cuj((e;xCXn;L zMJR|FC>-P0qsV<(!+$k>&>V4dAwep9*RbQ~<-G-sg03^9m^iARH)s!?e~jc$(OD`< zqY;4!g7lXSq=1~5N;$yL;h`{nx&ay$WI#3IUNI|uz{Ij%es5Q=k7P@?@!7UU;tED}}4gOrgjSmPh|LhUO4 z3v+&i3`zHkU+HlgF0Z9PTL0Ag$z-p6bsU$h#2CVM z$^SJI{vh4LXCH^{Krq3!@e($;Ij<-yG%Y`Jb9aI@?KVixTkk+iTU(xzYG?HL*6Y^d zcD*(o-K<^8{@tBE9-JwNF0@v1LH5?bfF4UxR;*d^ij9qJEu6kI1|*;+j8Osk1zJ^k z;gk$t+rMNqd0uS$q=VE(4%n`!LJY~Ueu#+!2Z?MsNbUPYCVrRQ7$DRY@w`IW7xX;e z92E@Bmia`}%UC=2{2R|JN&ekv%jwG8NJ9252)xyQvG5|H$UHA#=eD{~Tw;v4>d0V! zNa0PwIIfL~Sf9Kg(b=EnsBe`e10z*2eZFq#I6vx&@2*qm)8o_etb4jb`nP|6m3w2) zVfhRCI+O*NA%o-|SCk&tMPODrHk?=W5ccMLi^8X+H@*w|Eo8`M*y`np_vY7+=be0Cw}7ja)YF zZhC}Tce-N)@j`ZaMrw$8M%O0k=B5{BU6&No>UB?IV@(p6i6LJy#OO*n2;8#$_WDQ zswKl{Y}Eg{JH_}B0ysST8|1S1_jCuh(X#$oL2DOcQfn!at80O92syiRr4DT}2ogTm zZ+}3i_*0_f*S&9Eun*VD z3EQMZ!szO3-&Pva!1;75b;??bRhNZ$FMW?<$h&8H7Ux@X%DW%3`wui>&ks*b!>giV zOwd2C)2a4+2~KO2X;A>T=rj6G#|NP6k0YpN!-D+MhfXxFHaJ@;feH9XQt4mu%4su_ zq82T^S+CYKgFxnCm~yomC-3qa_Imflk2p%5=ArZ3H`BB_CRP(>YGnK5<78X!ViR4G z+ENNgRz>Kuz@>0Vm?z$#gPnNI&Xla44vMm1Pf?u&CKMhF9 z_zj&v{VP0vfW7osA}$#v7MUpP+tSTGcMr9~S>$=8;<(xWYwgX$sa)UpVPh6b%ba?D_fr$J=+E3+6b*<+_(`XL|iK zUVr^#`u5M9%ZATy#TQiuEmCqjK}$xZw@<#`&7pfCcCCgjO@m}iV3cFM&(p$H;kxI~2-h0t zw|*geYK%ZXz8X7_sPvR9f=NtRH6kU6^yZDW!#8gv(oxE)6KOAl5!d&O&r-79WUp#@ zy)XSpP;WPx?s2TNDf&3xe27rq1CW~eJwWO^9hIsvqp2@{qx`1@eLoz~y1g2Njj|ln z3z%jfQdE9l5!u|*Q*w;KkMp< zua8?n_B)%pJDSs-_sLoG{w&7&H-nFyaAAgfD}Kux^f>tj*~;#pJqPTIeghHQ3cS83 z;Ett^#w?k7S5GXL&Fh_s<&pVCeD|pcUS{=ZX|Q)BO9*)M{X}sJl?E{GxeUTaI7D6Q z^r_;CG(Gsg3Ha~KTIGY|+1pgaEvyBYWC54{C*9KEp39B6lxFyROKtjzL|&t6Z#-B7 zpD+FRdZr-V4zQra%{AAru68Q>^K~8^jNBcbI0{q7Db-NkL*C@08dZD})sMNvJqxrN zF=Xe8w>!P(&LK#=H?n#jwpAm>>{kX$u$+D?hN%F$l8#+40q`Y|X$2l}2>@x@00-Fb zZf_Vpw^erAhUBvZoDumhcga1pXUN!KJec&?b2<3?-pemY|rrJEixp+*zQ#A0o zld&OEzv!U*errSSe|CPiUA*x*e}L=R&!VSQTIfJ!TYwK|!I9-=E?zXAuN=Bet6T#M4|LVFFs~`Xt zRA&RvzP;tM@$S#onTzvxPC1hPoWP8Tz1vX8QUS8^b*u1olZwGizS1_ z9a}iBzEbux#1>lN_XzI;|J}-nw22qdZ}f%GMhI(cBjfqQn9-m4;`R99vk;fD-;`0O zQR27m*oT3IUkXw*sBj(1@hjO!s(dK{tK&kIvV&|$$j*!TYwqaF;|W5C$#m_&82NIt zY?`89m4)w2e$_7rz(hUePG_S_to7;YyJ2oW4kED!FV`NhksEsF|L*#1zivn!l!kJ@ zj=7?$)vjsZwfZnyiY-b8;C{PjXTl{^T>bo5y9Hs?qYwCuqiiP^o4C$1 zW7N!FUOfiPEWR;pymGH!JETrv{5ur0Qt0@#njs0Bdb>5>JLiQaGmV%I z=iQD{&;)~`H5wcJE~riAem!PZic4vkieiV^<3SQw4*p>8=}t3{&@D=`2w8;BAfu-o(DFY&q+X ztR2K=j5^?gF=~k2cee;%K+TXES_jHhePlFYOV*Se$;&p+XbA@iLvh?H#^M~$ern(e zCtiUB)zhC5U~>nIiCM}Ar~tb3ymYhr>_KSm26XwfRad|hc9g@&RFj)MVydpsrFuCClvJfHHdZ}|v*MXcGwf?b+`a6rAOe3v%lGSM*eMjN+hIe?D|PyI1uA|? zp0oW<3^QOO-}4~e@9@?$44OLzkp*5H54~+onmivEdo*Oc`EEQ_!TnpA6do35XYQ_! zhqX3ncj~ulU-V71jK(BUH@(@C%jwd22!~{k-aoHD zJl=evl>)!gz-;BXa`0>20XLScpA*wV>iEf44f0++#jaqvr;k=zeew0_S49fduWfzn zka~4#w$z~@r>Q)%O|;hbwO~wK&HInF)8$3H%m-g@$RBQ$9iAj_h}X@ACQM!Jkq7fuI&mI=8-(z?NO-_3lIf_% zI=!jC(9Rj8R70=6Ku+<^jxNzB7yia@v+WGh>1=^ia5`(>C3}yDjvOur>~9H zY(HMQiQGv^GVJ2b=I+q*3BT!<02)-$+7G)((LLYXBiV_`*EoH)VllT)dChrSC>Jct zYFkR@Z%CYcM>bma5390(;RlBd~K^nd&Lej8^Os*g|=a3l$12iJrXgR_0uH6Zfl>DrPR?sE#4yq1^k?JZ+NO@Ju86X|B{r zqMd&E3{UzuJ1yS{9Zk2|m8^`4UG!*2A6JZPgB3}ESW3a__KTR}kh=lMJvtn1f`!ov zKCFV^{M&wc9Ar6mAQY%f^XoV{&rtJ;_p=JNzF!i@2y2ze_6Ns@FXX3@5W{GE)x>;kzduzF;o$7OIoWxK2Cw+J^o|S zd2NV1`EaPN`;SM3mnHuINQpzj&De3+Ep#DH3jn3m{$mzdzKA6%hz1_mQI=c2@oj+u zKL!}XyY%|Z3(h=5roTdt>c%WpwU%g)W2o)mW}#L72X1 z;@%YPUSDEmmGed#HP_#!0&#h?>E|Y7?S@#xEG1$mfCLs^L-rDmAF@R8sn456l z-;ax)Ca81y8JAcb@=6jpr-c|pU*U?+oe0kb4_V7Qhu8$HZg1psW>6Ccxk$SXVr0JF zDjPoGyWT@*~#1#h9Jaqat6%313dSK zz-$_G$UR|y2(U`mb1%O3+LW-$RwkeM`tF@Ip!Ty0&R|MNGw#Q$RRgmd!{7M zT|24jxw-c9DCpIaL6~HsdXUf^!*RNgxi93^D+r>-@;2d|^*yEbZF$h^v-IH4wmO1^ zgHS(}yaT9{d;B2f67jV@yvZi#p0{?k)K2qrFxlc72xO?%=&;pFrtd?mw-LYX?I|&T zLoNu0&u%7Ki}C1E(6GlzcFL-JdIP-KxpwTj(j;#FO3;ypu9Cw%4$vm#%ds8&6ENN@ zwTe?W=AZC91;yC#VcgND4fpOt6WFFCHRYgM4JE$(#)R^tL2pdi$06yPj)&nrKHGnf z8_w)()W`OhH>nTE#ft82G@aSa=CX0?0*Tr&aK8S4!rA2=s3oJMM`Hs=hrr(%Iu7-o z1!ui<-xwq!!VqcVu*S-zL6H2+bfJ%+X-fpts^V|PxL+^{#T^QvX6{U*F!lO99w|n( zy^wQieF*?K>x&@A0P$L`b@J{2p@X+T1lg76KGizR#B&U)0q6gexL$2Z;NRSMA54)C z3AI^wj-uaYbB3J9B-oYrp;&W{qt(zX;Bp2#+^(>0!aZxThF zV?P?YsOBCHcG?^_#BI2VKOt0yE2-Mey>M)}|JwLl^(xqolOPc+Q~j`5yLWe^w!a;= zoP?G_w4-*Hi=o8#%rFTWY>ULhMIVN`ddNjGzj*Kd4mMNg1oCxq z{8>n%cMjgn#<(J2-v<4h#;Q>cIs?pvJB5IIOc!seJA)qZMQQG5A z-|hPDum&C6y1%>g%fBct*x)fZm4ja-D(B+*fi2pPb)^cpadiAqqdbjQyOP}(1fhT@ zcS1+1$Bm@@>V%A8#WcnK#(R6PUV4AuT@D*3=W6RiQm-9UJZ7#EOUOP~WK!z4w_0Uf*cR`*r`}!MXkfr&&L_kXit`i9;Ri%S&SadQH2z?-x;ls zKB>_|L_7172Iq^ztJFO>iQ$0*fo*eaM=&-HX*vZrnR? z3cD9`mNOc^-J0`zA9>2MWU=QUcOWy&WW@`;j=U#`azr&O0=nXfFf8M!?jvE$)hqtn zi%m_s%>g)cm>2dQIFaJ$*3_^>N(-tHynNY8*D1zHZWds8;;e~nDRWSin399VkcJKm za0q0_Xxn4uVZ^W*;NxHQ}r#|?bkbiZMnxMf!I7)E3 zI*y_|g2vZ!@qH)z^7dSn24MAi3h8 zW6he3Vz)8-{9t!QFj`dgtc;P45`$94SOZt;FuM4C!b{lVIV3NKMJSP3pNTtP!iCa2 zbnQ?*?bx9%8DY@RNVA8d|!V zN2h<*wF<}Z>|ptRM9X}MLzpLDAG=9Z+j2=Ct?dEw9O|||7_H~!G=8{wM&%yV;M_*g zDYTZx<3JoeFd?M^UJG*^C!Lcb_;8g_Yx7I}b1QQzC_Wko#MAh76h8n-6}h?o(^od# zoy@y@L!Gkd$#kaEo!(^V{ThCuZB?VNIO_KYST3h;Cs8Od)&w2vux)EI3p=_y)tl-# zR5%)w)OqI5t&4hI)g;`6&E|^fpG8YQF3EA$S#cvA3aFUeoL@Ge!d>XY339EC_0Xrj##JSjc>2PrCA1 z@4XW>E~mtsd+$WyH|m3JI^}}T)#dN6oY)%T(J~WL-k_tNQeY9>{Y(HzmZGGx1P@y3ga&~YcSMmncD&Dr-Whr<54Sen&b%-9fHE zS-LSMZki_xeb4tfZ*KwjMM;yt0~O}gTX`Tx#{$^QpXTA_#XyZoX_qVmt$tJHcv3_( z1?(id6D_PjHPX=UA^mA_sS-+7LmJ6g7rQ#tUS z@3&Nkm1=>E`+a~o3b*s0^Tmlk7M5!qX!8!?F5_JH(SO2~Gh5UG`Ev&TXpYr_S$WUOEul3_Vebe{u+*Q%M&ikili5~%jMVqk`TxZC9 z%skJ5Kihia0*L-6TaP~LlOzDCDF%CLMdmL;uo3Op`&4x}r1FD`u@xi{3STKh3&zFG zEnR3Sm2fH( zJG+1XI$QP%bh3YC373au>;JDp0HX8%uR;LT2!?LyNMMu^UJ-f(w86Py3YgSn00Xl( zUVipUUzr`y2i1EP&qMFUagjWbR~N){iN*tNdT_ju?Sw6%-0iDnh+(I_XJt6=Ix%gi zf>xM3dGUe|XF09zn==gRkGM$9<4BNQo&3X){oDN|F!hQ1Xj}mC{wQR%C7lbD^&JhQ zumhtbXVM&vbQ!l~(Dr`sLWo@mI;{Yg&t1caKm)eu4vi-!Y>8g|++*WzKWrEYw^4`$ zoZg8*aMzJnhOqJF=TOiJ&z&%T;d~d4W-qdixNLTxg7zoRWAab5V^rp2%kqxAX}(%yU`n8Peyf(_ir4!I4@RF;H4nPsDvyehe^HJ zF?7ce_|YUFk7eNyYYz^fA9wtEC&c--xtaX5s!#mP!u>R6A+;KmPgcZ7Wlq-VpdQP3Rs)Iy;YecYGzdB_49Gd5hy|1 zWm{CbOWaz&Hq-Ygk?J8ZOpj%2GkN$lYu@tmSt`|2wtXoXp}Cn>LU;-ovT6X3or=iS zICKv5iKLYfr%snlqrOg!co1#_h<}*+1M{jRlro1ps7NPOLOM5gNLsP$l3Ek>MaF-U z0}^qhnj~)#a)3F?wccTWdEJtZ?FdQQCkG_e_;dqCu}kC#ICSZkL(zdO4VpPc2$NLH z(_I74fDSwg_izqRK%sHn_2KlZuc4{N@QeQ+zt4pPe=*By(?q$s;TK0|hoL=4TeTmU zKGDxrp1t4csa$=aBm25PeGgtgQ{Jp>#>R=Wp0;%O#g$Jcyk^wQoICasR6OS(W$P97 z9-Lt4tDW{SP?z?+ZN?>+Bdhg!66N02ewBW*+jBr>FFT)4$eNO--P`c6o&1@(k6(8KS;;esMU&w(F)!xBEE@OIl2~;Ug-& z$odiz$4Z6U<(WXFDebRva@3)Vn%sMfTrA`%U%88$m0_N&mSd=^JR5QQnJ`ZMbqp3_Aw(G4>n2NO1-(fUpltRT_!xe0ys`F07{6F5?P8 z)T3GSJmjIdE~Ya=#O)km_e|@)(p|TBk54mYpHp!oPP#{sG^$ZzRNa({<`;u*ReYg|3U9~_>8swF05|AF&AFnV!d_9J`1hYySoP&k2S0ZI~# znwj2aCDwuZ$&+6WCR{YY@H0F=7kxo2=1Gp~rM+Ay@Gofa!C0DuXa53WAG*(}klZ`{ zg_HXi9eq3*KIsX+8-vE3V3q)926f^ixGJ;)NUkC?S)OUg@4ut)m-iG1090<(wef0| zTAJ_ce0c}+7F!+*!=Qz=aJd;h(W#5p3fup`j2CJAtfOLP#9j2BgCYPkoe!28(e%9r!(#R zBrkSg7a&^kw5<<61hJ>D=T9lTZoOOTvwS%f%1)W-o^ZBG(U1m5tjF7HF#`ZM)2668 zw`y$~7nb3ylei0T`o$3$eDjIURpmF^t&n(;IrxoPJT+#H$Tf~7+R~?lyG*inDBM7c z`<0~k^IoG{2;L_oLUmnvP08FLtzz(@#q?I%n~RzFI&yWt7+I6$er#OfYPPcs0j(7n zoTn5UzM%)2h8-lHeX8;-LKHv(I`^__8OSNnFI@)ocA@!d_MKsM`6`-#1RmkD1>)@ainpB`W3?fxQP1Q&zG>vDMK5_Gy>f{zPb(WEn%Nr+-_|uyVFBDT)Ejz!73`&W z?WFKK`~xZ5KB|{q$Fa@vjE3iC2V|R3p&o}1R7A;g4v_otERkZppeEf4 zC#mFjKRLuEjY_V31AdZ*-y>T9f*NeDU;LP zT@X~I(#YN|_`$bK!M2(Nuch^gSy>(^w2;b=83Y-%#55@<9;moiXTVuDkcpmrNU?Ri z>N}4D@4=f@mT+>;CDZr2K>0}(Db}+zlDw@m(QnT_T)qm8kVS6mENc^Py|#Xnj=gj0 zcD)%uCua!H=#HNmY-2b$OP-Esf13u*{nFu@D_FIdQhNQ9XFp<3aTMcW5spX{Gsku{ z(W^u7NC6V}2eo4IN9>5T&k)Ee&!IoV03&g@I5_3zTyAY9`&?O|QmwXpatgP*$5;sS zW5*-%-X)?JDs+5*&ma2(JgQw=@-dMx%qfKA6RTbb(n*)reY^3EZK&c(dW0y7X5}k)?AjeYYk0P4-`YAv$OQsK@ zIoDl5Zplind?8F3n`iR}P3Qt)M@|s67w81yvqzFYa=Vk`gM;!8EqEe|x;$cSG;(Ii z4o%KaH~*~*()h{ewZAnOz#bCq9mW7hP8sLAJCd#`2aJ0x1iHBlJiUwL)2)6Gqmok4C3Y!7nI8Kaj3+71KYXJgI@aOW(*n;Pe(DZxoML8^83hMDYzG6N73=90Ht{jKdI{PzNA!6Z94@4?Bkm= z==16^?C}T@oKnm^93pf`>vnu@v#V#OEUV<@D1_^)`a{WcU?k3wvHP=+iJX_>otI~0W?5Y^M+ zXbFsDM3$S+y9(iei7J28&G5J|qImkSBcj>C-<6W4L8!pYccI2I7e;c%l9$gDVb5dU zkL7=CWHzk`-O&~*q2G%9a3J~F6ob0ub;_H5n11(yrL}rmy5maUZG1R!Xu31jpnzQj zm3K)sS_gCe8WZ!HDL01|B%OjIYv|e{g9oy>i{%7q z@2_rO-(HL>AsWDc|$K3(KqCUG5n^jHn@AC0OFEexP9@+=m5A0oqMd8s+I(^q6tM8D&kK>}(>l17`>D8WF zawVUjN_e0bmivZ{S*xLu6jVgnm3gsnLd#;zICWA49-qRjv?^7ZbY zTB@hl*8t3$2lY$|I3G$5+I8(AdY4}LByCn|7hVmA_BoG1PLKyRPv0Fl9&-|kmB~m& z8?;i0Zf)}yLd-?~MpB6?&sk@N$G}xluEgn5+*NuaMueTBjkVftP?ujRwQBR3;nJ>P zU<-7d#`rGcXm_J;1VL(k)EQ5>Eh#B^iOJ--Pg{|ZE>O8i&PsD%6-bamBs9phAQ}PC zTg851;0{9ylu*<@KNkG!9RRQm*lRuIK8Mlr=0PLQ68x=gWv162bnidb;jBdwIHxK* zq5x@{h-N*R2fJAh`0iD1&A(p#sv6037lM;s$dP)wdY0XiIHhv396#b3Gd3F$xMgRx z^ks?L^HFwBfO14RM$9YeZ+9Bjreq&_cTC2w8 zTieU&7rykotPP=V11neCAMF?1r+0J>8R#38EO2;+Fq=F`U>8U{p>*afg(C0H1QdTc z__|kvh|#Gx5!c_mcroI4;kA4N?bEu|_;_AioK})hJb%pPjx>HaIJJ2978LiLFN#iG z;tq7Aocv8P`oh6nYoFk@V*>cOa zyxn}^{fTi$Ae%&7ftG!A?s@%F&}>5M29VH40daw-vNn@{1&gn5IRfM%Gf}Va;_#(U zs{-%V13Hkd-{UuyFW7SeQNV>i;JtFb+~F8MMBlKVDKA4 z1=6R}0;v&FKTBpH>8>WK$tpRvCBD%>u||E_&d%|=j1h7V&-HCO+eU^?B(Q8{M69)% ze#0aWgDyeyb&x@hY(%oJ_v~rt!MP$^rFr~Vu8p^PL?#=34Jmc{iBLe>14u*4{HqBX zMkNrleR;byRu%2;5Gq}|^5(|%*bi{d3=f#W_9uOT0~mWAH{)a=YaM#)_ZrwQ?UX@~ zW883uLqxy-9`s;fk^3=JR@fgMWyHeP8IdiBZlhMZmjx)Ka%Vgjz)YGWIg1cAgHVmt zt#xs%tk^P>`o^)b#=Ecz&QMOI2BS6C$!9=MJRw6kMhF7c)ISrn+PkU343gsEdcGuu zkQqo!75lfo(tK7VTUA!~z#bIPMo&yn?C46i0^gl)*OFlL&>)-7y!mOZ9ww7HK)gh9 zqoL^)ej*Rxc?2n?(RyU;y2F8K`!C}{@AyZMd-(H#WIF2%`%nZ6abW}PZW-ZF-4AIU9ZRFC6e{XR)xXm0u*HzkuWpbh`i_98Vqu&+xZ_0^XS?$(; zeWYb2@mqI=EX9sPE7P*TXq4<`)isrw?RDi$llCDU_^qZSx2uV~bHW5)Q+TEEeLivK zTfRfN(*?~N2^{9SHP^q~>n|HNV@+`P|%mc zK|H#tbBx@k4v%8I7!`wR_AM{Lk2BtuI=sJ8>Fq!BPBnIBaHG4}uQzJ4 zIv*l-X`n@6S8$Mnkj0-|aSSUXyI0&flucbe28(CZpbkWaKg1%ct zOKa*m6TOx;?bUOB#?Hx@pU&N}57gXo^!aA*Uw%6km7bBqu^b7w=NdwXhp;-GyhvSEO@6?|uSPQ@=e;a)ru)*V^Ypt9?r_NJg3JULKe@tQ*5e() zdo+}P1(bY)9{m$yamr^r>8LPiKH*^kyWTkt&>Cr0q55{vw$t}3cJk&?l^jO$#d7)~ zH@njUJjYXa)Lb0oSC_}#Y6YL+qt=#3*3Yu@ue_6G>%!IunN`` zJ;Oql<3ri8!FFR?Cq604kjjeddAoLJ!$LK7T_;b$_4FW8&ucabO-RN|QL5x= zj4S3@>wm!csN<7_N?m0*Ni5w%wufupCqi}ULgwrbUMrmq>bz~orLApLy`-3M!V+{* z>B2_}-C+j~y0AT@C$&X8BqeyZhs{CDm%d=>+sbMv;2>CoTJDs$wwrMqvdjFBl7|c* zAF4j~wewBB(1wW}IbB$AK#NBjk1$P5^~x&{B2JSn0&5fh6*rVgkBoS@O-{TVYR-H; ze$HYgKI7vkkMPF@o+WPLqbO_7rZ0yg^Ssr9FPV5xN`0W$96Vopm&@efgJm`7Fxp0& zPs5cwRg{Af`u4y67-4~IW9%Ce{IB*oSP`J55{h}kM#s7*9YyMq`+wr7kQ$|9zeFJk zW^1otizLPSe^3VipBjpb_fr4Q*Y^J96Hx8YhEp!aO?L0I0JrIoV-ThIg^NMNWgGWU z*Fw~F2EF6;;dy^k@};+cWVOBp^agvfiuvl^?o5x#>bmPSlq3Sv>~dqM=<5kY52p2K z(m$%5Wj9lhmpX2URKys}D$+Fo2Z!giRb1i+TJxx!CFoJ0(w)^T%>y@pS0p4rT|1lI zYx;hHtov;g=?u&gOz20J!gcu@mmg-F==-~K=g@s(ZIzz_HR+E&PpHhg3&I_xLa8f) zmrb2tUV71oGxND#av@ObU#=&fWUT#o*sWlU^;ed+Hl86V{$MiKEj8G_ z4j;VY2U0^OrJy9@kCfU9zXL-eRc<=qhP)7@?}|I7B$I{zST47E6xl6q_;#@)LmCM% zoct`ZuONNTowqd^3(!<~pb|I_*l zZ<&aaF9B|pXQuSZzh=4vB8h?*mGrN-ACJ6!i?)pBF^5n8vzYdl6elbi+R%u9{y+d( z0P(VQ3nwxU;bbkS&0Su88kG(Rpt^4!P4&n3`$1!r-s4Qn#T~BLh?8L7Q`5zz9OpJbP6jDszKTgXIP1gaHz zjpWHg3zC>SKJ$L z_8mj7E_KDi&unEFv-WA9IJI6HE1{UVBNXQGcF1b68=Zsn9Hu0-n)J9N@UY7)Lg|qa zFoK3-w)Uj3+z-T={@qph*TlxG!}|z2)3_4%&sSO#08dNIXYzNO;@_K=BC%k7_m^nu zeA|h@b`$394UNP9(+iEL?Cp`U6Xvap`Nx+7$dnP4iE*8-g96-YUF9eba-IObFUU<2 z&J*yDy0RA6<&m!5r29!IW`teFoI{W}GZHPRWSL0^2Z0Fj4-Ppg!XlzA)DQuMOs3Z6 z`?>USp?ecr&z4}G3m1k(!gE-#zZm_bgJ;-2Q8A>V*mZ@IL*`1Zth>jEqh|)}deQV4 zvH#SXqF_HT)q%FfNQx%I-o5!Y_r1Mz#Py5LF)mD6%260ry@PC&;_h}64+%{Iid}V* z{Vhv46dc%t{Lm-LYFTPKZe7G+{7B6Jk3 zLq~L1S0IC^>?1$>iPK?$Fd^%SqEpt@;J1G@D9!#u2VyDX{{)7=KhS2&j!XUhm;bDs z2;R=WBglXLO;)RBvzc~4!sGG37hW*ZJH~<@r1;;q!~bP9Gjjeft9cV?Xj<1yyuu#| zYeb95X^s96ai#~up=154$o_Df-u@vz0%er5F==ksf48>}qz$YyxSV(s9m(O&A7$)Kl)9j`$ybxq5!4ijuNe~EvRT7@n zDow8obElgybXyb#**3e;Wt#^&7OeP&V$>m%uTMWN=)wc5FAeqBRk9ntg--Y0&nD%7 zt{KyZi>&Wpna(q7R;b|X< z{{7V&ay+z!W)%KwS8Kso`%V5|$LZf;D}cJ~hpg7WF2NUfkR*zoKUiYxKht9WLrEsA zAx1_-&^LtrbfUjJkAp?9#)ONLCjxJ<{<1JEm`gVj)+en-rMbm5eMc0}->rm7z9 Jsj_v@{{b_lJuCnK literal 0 HcmV?d00001 From d810df00b8aa8f21741a93fd9391e703d69fcd37 Mon Sep 17 00:00:00 2001 From: Alex Stokes Date: Wed, 24 May 2023 17:29:17 -0600 Subject: [PATCH 13/97] Update EIP-4788: favor stateful precompile over opcode Merged by EIP-Bot. --- EIPS/eip-4788.md | 38 +++++++++++++++++++------------------- 1 file changed, 19 insertions(+), 19 deletions(-) diff --git a/EIPS/eip-4788.md b/EIPS/eip-4788.md index b2d2cb378b6d93..7bcb51807f309b 100644 --- a/EIPS/eip-4788.md +++ b/EIPS/eip-4788.md @@ -14,7 +14,7 @@ created: 2022-02-10 Commit to the hash tree root of each beacon chain block in the corresponding execution payload header. -Store each of these roots in a contract that lives in the execution state and add a new opcode that reads this contract. +Store each of these roots in a stateful precompile. ## Motivation @@ -29,18 +29,15 @@ restaking constructions, smart contract bridges, MEV mitigations and more. |--- |--- |--- | `FORK_TIMESTAMP` | TBD | | `HISTORY_STORAGE_ADDRESS` | `0xfffffffffffffffffffffffffffffffffffffffd` | -| `OPCODE_VALUE` | `0x4A` | -| `G_beacon_root` | 20 | gas +| `G_beacon_root` | 2100 | gas | `SLOTS_PER_HISTORICAL_ROOT` | 8192 | slot(s) ### Background The high-level idea is that each execution block contains the parent beacon block root. Even in the event of missed slots since the previous block root does not change, -we only need a constant amount of space to represent this "oracle" in each execution block. To improve the usability of this oracle, block roots are stored -in a canonical place in the execution state analogous to a `SSTORE` in the given contract's storage for each update. -Roots are keyed by the slot(s) they pertain to. +we only need a constant amount of space to represent this "oracle" in each execution block. To improve the usability of this oracle, a small history of block roots +are stored in a stateful precompile. To bound the amount of storage this construction consumes, a ring buffer is used that mirrors a block root accumulator on the consensus layer. -The method for exposing the root data via opcode is inspired by [EIP-2935](./eip-2935.md). ### Block structure and validity @@ -48,9 +45,7 @@ Beginning at the execution timestamp `FORK_TIMESTAMP`, execution clients **MUST* 1. set 32 bytes of the execution block header after the `excess_data_gas` to the 32 byte [hash tree root](https://github.com/ethereum/consensus-specs/blob/fa09d896484bbe240334fa21ffaa454bafe5842e/ssz/simple-serialize.md#merkleization) of the parent beacon block. -2. set the 8 bytes after the previous 32 byte extension to the slot number as a big-endian uint64 of the current slot. - -*NOTE*: these fields are appended to the current block header structure with this EIP so that the size of the header grows after (and including) the `FORK_TIMESTAMP`. +*NOTE*: this field is appended to the current block header structure with this EIP so that the size of the header grows after (and including) the `FORK_TIMESTAMP`. ### EVM changes @@ -90,26 +85,31 @@ sstore(HISTORY_STORAGE_ADDRESS, SLOTS_PER_HISTORICAL_ROOT, end_slot) When using any slot value as a key to the storage, the value under consideration must be converted to 32 bytes with big-endian encoding. -#### New opcode +#### New stateful precompile + +Beginning at the execution timestamp `FORK_TIMESTAMP`, the code and storage at `HISTORY_STORAGE_ADDRESS` constitute a "stateful" precompile. + +Callers of the precompile should provide the `slot` they are querying encoding a 64-bit unsigned integer as 256-bit big-endian data. +Recall this `slot` number should be reduced modulo the `SLOTS_PER_HISTORICAL_ROOT` constant to derive the correct key into the ring buffer structure. -Beginning at the execution timestamp `FORK_TIMESTAMP`, introduce a new opcode `BEACON_ROOT` at `OPCODE_VALUE`. -This opcode consumes one word from the stack encoding the slot number for the desired root under big-endian discipline. -The opcode has a gas cost of `G_beacon_state_root`. +Alongside the existing gas for calling the precompile, there is an additional gas cost of `G_beacon_root` cost to reflect the implicit `SLOAD` from +the precompile's state. The root is returned as 32 bytes in the caller's provided return buffer. -The result of executing this opcode leaves one word on the stack corresponding to a read of the history contract's storage; in pseudocode: +In pseudocode: ```python -slot = evm.stack.pop() -sload(HISTORY_STORAGE_ADDRESS, slot % SLOTS_PER_HISTORICAL_ROOT) +slot = to_uint64(evm.calldata[:32]) +root = sload(HISTORY_STORAGE_ADDRESS, slot % SLOTS_PER_HISTORICAL_ROOT) +evm.returndata[:32].set(root) ``` If there is no root stored at the requested slot number, the opcode follows the existing EVM semantics of `sload` returning `0`. ## Rationale -### Gas cost of opcode +### Gas cost of precompile -The suggested gas cost is just using the value for the `BLOCKHASH` opcode as `BEACON_ROOT` is an analogous operation. +The suggested gas cost reflects a cold `SLOAD` analogous to the operation performed while executing the precompile's logic. ### Why not repurpose `BLOCKHASH`? From 71660d7517f170dbc65fcb1dbe4014a5def5ddba Mon Sep 17 00:00:00 2001 From: Sean Date: Thu, 25 May 2023 22:15:48 +1000 Subject: [PATCH 14/97] Update EIP-5570: Final check on syntax Merged by EIP-Bot. --- EIPS/eip-5570.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/EIPS/eip-5570.md b/EIPS/eip-5570.md index 65218c966c2e26..94e80540f3a5d6 100644 --- a/EIPS/eip-5570.md +++ b/EIPS/eip-5570.md @@ -163,7 +163,7 @@ The JSON schema is composed of 2 parts. The root schema contains high level deta "title": "Comments", "description": "Any messages/comments the issuer wishes to convey to the customer", "type": "string" - }, + } } }, "image": { @@ -175,7 +175,7 @@ The JSON schema is composed of 2 parts. The root schema contains high level deta "title": "Signature", "description": "Digital signature by the vendor of receipts data", "type": "string" - } + }, "extra": { "title": "Extra", "description": "Extra information about the business/receipt as needed", From c9517ba5a7ee329948afeb07fa00e86842d174fe Mon Sep 17 00:00:00 2001 From: William Morriss Date: Thu, 25 May 2023 10:25:25 -0500 Subject: [PATCH 15/97] Update EIP-6913: Setcode Opcode to 0xfc Merged by EIP-Bot. --- EIPS/eip-6913.md | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/EIPS/eip-6913.md b/EIPS/eip-6913.md index e2309078e22e36..deb0b5240cd96c 100644 --- a/EIPS/eip-6913.md +++ b/EIPS/eip-6913.md @@ -12,7 +12,7 @@ created: 2023-04-20 ## Abstract -Introduce the `SETCODE` (`0x49`) instruction, which replaces the code of the current executing address from memory. +Introduce the `SETCODE` (`0xfc`) instruction, which replaces the code of the current executing address from memory. Future calls to the modified contract use the new code. ## Motivation @@ -69,11 +69,11 @@ The only prior operation changing code is `SELFDESTRUCT`. | CodeStart | CallData | CodeResult | Gas | |----------------------|------------------|----------------------|------| -| 365f5f37365f4900 | 365f5f37365f4900 | 365f5f37365f4900 | 6613 | -| 365f5f37365f4900 | 00 | 00 | 5213 | -| 365f5f37365f4900 | | | 5013 | -| 365f5f37365f49595ffd | 365f5f37365f4900 | 365f5f37365f49595ffd | 6617 | -| 365f5f37365f49fe | 365f5f37365f4900 | 365f5f37365f49fe | all | +| 365f5f37365ffc00 | 365f5f37365ffc00 | 365f5f37365ffc00 | 6613 | +| 365f5f37365ffc00 | 00 | 00 | 5213 | +| 365f5f37365ffc00 | | | 5013 | +| 365f5f37365ffc595ffd | 365f5f37365ffc00 | 365f5f37365ffc595ffd | 6617 | +| 365f5f37365ffcfe | 365f5f37365ffc00 | 365f5f37365ffcfe | all | ## Security Considerations From 6791956eba2113e1a73a2ed71a9ec42540ab2b71 Mon Sep 17 00:00:00 2001 From: William Morriss Date: Thu, 25 May 2023 10:43:23 -0500 Subject: [PATCH 16/97] Update EIP-6913: Disable Inside DELEGATECALL Merged by EIP-Bot. --- EIPS/eip-6913.md | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/EIPS/eip-6913.md b/EIPS/eip-6913.md index deb0b5240cd96c..7cc45f3942c11a 100644 --- a/EIPS/eip-6913.md +++ b/EIPS/eip-6913.md @@ -37,6 +37,7 @@ Given the upcoming deprecation of `SELFDESTRUCT`, `SETCODE` introduces a better ## Specification When inside of a `CREATE`-like execution scope that returns new code for the executing address (the account returned by `ADDRESS`), `SETCODE` causes an exceptional abort. +When inside of a `DELEGATECALL` execution scope where the currently executing code does not belong to the executing account, `SETCODE` causes an exceptional abort. Otherwise, `SETCODE` consumes two words from the stack: offset and length. These specify a range of memory containing the new code. Any validations that would be performed on the result of `CREATE` or `CREATE2` occur immediately, potentially causing failure with exceptional abort. @@ -60,6 +61,9 @@ Other account modification costs are accounted for outside of execution gas. Unlike `SELFDESTRUCT`, execution proceeds normally after `SETCODE` in order to allow return data. +Preventing `SETCODE` within `DELEGATECALL` allows static analysis to easily identify mutable code. +Contracts not containing the `SETCODE` can be safely assumed to be immutable. + ## Backwards Compatibility The only prior operation changing code is `SELFDESTRUCT`. From f3a4439b2f89e090cbe0717a75af64762522a582 Mon Sep 17 00:00:00 2001 From: Micah Zoltu Date: Fri, 26 May 2023 14:27:23 +0800 Subject: [PATCH 17/97] Update EIP-6963: Remove self as author of eip-6963.md Merged by EIP-Bot. --- EIPS/eip-6963.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/EIPS/eip-6963.md b/EIPS/eip-6963.md index 999ea33339b1d1..bbf84fe27d02f9 100644 --- a/EIPS/eip-6963.md +++ b/EIPS/eip-6963.md @@ -2,7 +2,7 @@ eip: 6963 title: Multi Injected Provider Discovery description: Using window events to announce injected wallet providers -author: Pedro Gomes (@pedrouid), Kosala Hemachandra (@kvhnuke), Richard Moore (@ricmoo), Gregory Markou (@GregTheGreek), Kyle Den Hartog (@kdenhartog), Glitch (@glitch-txs), Micah Zoltu (@MicahZoltu), Jake Moxey (@jxom), Pierre Bertet (@bpierre), Darryl Yeo (@darrylyeo) +author: Pedro Gomes (@pedrouid), Kosala Hemachandra (@kvhnuke), Richard Moore (@ricmoo), Gregory Markou (@GregTheGreek), Kyle Den Hartog (@kdenhartog), Glitch (@glitch-txs), Jake Moxey (@jxom), Pierre Bertet (@bpierre), Darryl Yeo (@darrylyeo) discussions-to: https://ethereum-magicians.org/t/eip-6963-multi-injected-provider-interface-aka-mipi/14076 status: Draft type: Standards Track From c6a3258db50f231514af8a327f7f67497c9a1758 Mon Sep 17 00:00:00 2001 From: Danno Ferrin Date: Fri, 26 May 2023 12:13:08 -0500 Subject: [PATCH 18/97] Update EIP-1153: EIP-1153 - Change TLOAD/TSTORE opcodes Merged by EIP-Bot. --- EIPS/eip-1153.md | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/EIPS/eip-1153.md b/EIPS/eip-1153.md index 3ea30688b16741..6f0be621c76a05 100644 --- a/EIPS/eip-1153.md +++ b/EIPS/eip-1153.md @@ -17,8 +17,8 @@ requires: 2200, 3529 This proposal introduces transient storage opcodes, which manipulate state that behaves identically to storage, except that transient storage is discarded after every transaction. In other words, the values of transient storage are never deserialized from storage or serialized to storage. Thus transient storage is cheaper since it never requires disk access. Transient storage is accessible to smart contracts via 2 new opcodes, `TLOAD` and `TSTORE`, where “T” stands for "transient:" ``` -TLOAD (0xb3) -TSTORE (0xb4) +TLOAD (0x5c) +TSTORE (0x5d) ``` ## Motivation @@ -33,7 +33,7 @@ Potential use cases enabled or improved by this EIP include: 1. Reentrancy locks 2. On-chain computable CREATE2 addresses: constructor arguments are read from the factory contract instead of passed as part of init code hash -3. Single transaction [EIP-20](./eip-20.md) approvals, e.g. `#temporaryApprove(address spender, uint256 amount)` +3. Single transaction [ERC-20](./eip-20.md) approvals, e.g. `#temporaryApprove(address spender, uint256 amount)` 4. Fee-on-transfer contracts: pay a fee to a token contract to unlock transfers for the duration of a transaction 5. "Till" pattern: allowing users to perform all actions as part of a callback, and checking the "till" is balanced at the end 6. Proxy call metadata: pass additional metadata to an implementation contract without using calldata, e.g. values of immutable proxy constructor arguments @@ -42,7 +42,7 @@ These opcodes are more efficient to execute than the `SSTORE` and `SLOAD` opcode ## Specification -Two new opcodes are added to EVM, `TLOAD` (`0xb3`) and `TSTORE` (`0xb4`). Note that previous drafts of this EIP specified the values `0x5c` and `0x5d` for `TLOAD` and `TSTORE` respectively, but these have been modified so as not to conflict with other draft EIPs. +Two new opcodes are added to EVM, `TLOAD` (`0x5c`) and `TSTORE` (`0x5d`). (Note that previous drafts of this EIP specified the values `0xb3` and `0xb4` for `TLOAD` and `TSTORE` respectively to avoid conflict with other EIPs. The conflict has since been removed.) They use the same arguments on stack as `SLOAD` (`0x54`) and `SSTORE` (`0x55`). @@ -70,7 +70,7 @@ Another option to solve the problem of inter-frame communication is repricing th Another approach is to keep the refund counter for transient storage separate from the refund counter for other storage uses, and remove the refund cap for transient storage. However, that approach is more complex to implement and understand. For example, the 20% refund cap must be applied to the gas used _after_ subtracting the uncapped gas refund. Otherwise, the refund amount available subject to the 20% refund cap could be increased by executing transient storage writes. Thus it is preferable to have a separate mechanism that does not interact with the refund counter. Future hard forks can remove the complex refund behavior meant to support the transient storage use case, encouraging migration to contracts that are more efficient for the Ethereum clients to execute. -There is a known objection to the word-addressed storage-like interface of the `TSTORE` and `TLOAD` opcodes since transient storage is more akin to memory than storage in lifecycle. A byte-addressed memory-like interface is another option. The storage-like word-addressed interface is preferred due to the usefulness of mappings in combination with the transaction-scoped memory region. Often times, you will need to keep transient state with arbitrary keys, such as in the [EIP-20](./eip-20.md) temporary approval use case which uses a mapping of `(owner, spender)` to `allowance`. Mappings are difficult to implement using linear memory, and linear memory must also have dynamic gas costs. It is also more complicated to handle reverts with a linear memory. It is possible to have a memory-like interface while the underlying implementation uses a map to allow for storage in arbitrary offsets, but this would result in a third memory-storage hybrid interface that would require new code paths in compilers. +There is a known objection to the word-addressed storage-like interface of the `TSTORE` and `TLOAD` opcodes since transient storage is more akin to memory than storage in lifecycle. A byte-addressed memory-like interface is another option. The storage-like word-addressed interface is preferred due to the usefulness of mappings in combination with the transaction-scoped memory region. Often times, you will need to keep transient state with arbitrary keys, such as in the [ERC-20](./eip-20.md) temporary approval use case which uses a mapping of `(owner, spender)` to `allowance`. Mappings are difficult to implement using linear memory, and linear memory must also have dynamic gas costs. It is also more complicated to handle reverts with a linear memory. It is possible to have a memory-like interface while the underlying implementation uses a map to allow for storage in arbitrary offsets, but this would result in a third memory-storage hybrid interface that would require new code paths in compilers. Some think that a unique transaction identifier may obviate the need for transient storage as described in this EIP. This is a misconception: a transaction identifier used in combination with regular storage has all the same issues that motivate this EIP. The two features are orthogonal. From d08a7569e2f174c0ef4ef9dd245b1425b5291302 Mon Sep 17 00:00:00 2001 From: William Morriss Date: Fri, 26 May 2023 17:06:26 -0500 Subject: [PATCH 19/97] Update EIP-6913: Clarify Parent Execution Scopes, and add to Rationale Merged by EIP-Bot. --- EIPS/eip-6913.md | 8 +++++++- 1 file changed, 7 insertions(+), 1 deletion(-) diff --git a/EIPS/eip-6913.md b/EIPS/eip-6913.md index 7cc45f3942c11a..a1b7c9db161d2a 100644 --- a/EIPS/eip-6913.md +++ b/EIPS/eip-6913.md @@ -44,12 +44,16 @@ Any validations that would be performed on the result of `CREATE` or `CREATE2` o Code replacement is deferred; the current execution scope and its children proceed before code replacement. After the current execution scope exits successfully (neither reverting nor aborting), the code in the executing account is replaced. Like `SSTORE`, this account modification will be reverted if a parent scope reverts or aborts. -Unlike `SELFDESTRUCT`, `SETCODE` does not clear account balance or storage. +Unlike `SELFDESTRUCT`, `SETCODE` does not clear account balance, nonce, or storage. + Multiple `SETCODE` operations inside the same execution scope are allowed and replace the pending replacement. A `SELFDESTRUCT` operation discards the pending code. +Any parent execution scopes executing replaced code will continue executing the prior code. +As with `DELEGATECALL`, operations `CODESIZE` and `CODECOPY` in such parent scopes continue to query the executing code, while `EXTCODESIZE` and `EXTCODECOPY` query the updated code. + ### Gas The gas cost of this operation is the sum of Gselfdestruct and the product of Gcodedeposit and the number of bytes in the new code. @@ -61,6 +65,8 @@ Other account modification costs are accounted for outside of execution gas. Unlike `SELFDESTRUCT`, execution proceeds normally after `SETCODE` in order to allow return data. +Also unlike `SELFDESTRUCT`, the code update takes effect after the call context rather than at the end of the transaction, to allow parent execution scopes to validate the update and revert if the update had an undesirable result. + Preventing `SETCODE` within `DELEGATECALL` allows static analysis to easily identify mutable code. Contracts not containing the `SETCODE` can be safely assumed to be immutable. From c920da0a8479bb2f1fb431222bb4ce8a29db1110 Mon Sep 17 00:00:00 2001 From: William Morriss Date: Fri, 26 May 2023 20:37:30 -0500 Subject: [PATCH 20/97] Update EIP-6913: Remove Deferral and Clarify Staticcall Merged by EIP-Bot. --- EIPS/eip-6913.md | 37 +++++++++++++++++-------------------- 1 file changed, 17 insertions(+), 20 deletions(-) diff --git a/EIPS/eip-6913.md b/EIPS/eip-6913.md index a1b7c9db161d2a..4ecb82d3b3de84 100644 --- a/EIPS/eip-6913.md +++ b/EIPS/eip-6913.md @@ -12,8 +12,7 @@ created: 2023-04-20 ## Abstract -Introduce the `SETCODE` (`0xfc`) instruction, which replaces the code of the current executing address from memory. -Future calls to the modified contract use the new code. +Introduce the `SETCODE` (`0xfc`) instruction, which replaces the code of the executing account from memory. ## Motivation @@ -21,7 +20,7 @@ Many contracts are upgradeable in order to facilitate improvement or defer decis Contracts presently do this in several ways: The oldest method uses `CALL`. -The limitation of this method is that owned state must be modifiable by all future implementations. +The limitation of this method is that internal state must be modifiable by all future implementations. Second, `DELEGATECALL` can proxy the implementation. Some proxies are minimal while others branch to many separate implementation accounts. @@ -36,23 +35,20 @@ Given the upcoming deprecation of `SELFDESTRUCT`, `SETCODE` introduces a better ## Specification +When within a read-only execution scope like the recursive kind created by `STATICCALL`, `SETCODE` causes an exceptional abort. When inside of a `CREATE`-like execution scope that returns new code for the executing address (the account returned by `ADDRESS`), `SETCODE` causes an exceptional abort. -When inside of a `DELEGATECALL` execution scope where the currently executing code does not belong to the executing account, `SETCODE` causes an exceptional abort. +When inside of a `DELEGATECALL`-like execution scope where the currently executing code does not belong to the executing account, `SETCODE` causes an exceptional abort. + Otherwise, `SETCODE` consumes two words from the stack: offset and length. These specify a range of memory containing the new code. Any validations that would be performed on the result of `CREATE` or `CREATE2` occur immediately, potentially causing failure with exceptional abort. -Code replacement is deferred; the current execution scope and its children proceed before code replacement. -After the current execution scope exits successfully (neither reverting nor aborting), the code in the executing account is replaced. -Like `SSTORE`, this account modification will be reverted if a parent scope reverts or aborts. -Unlike `SELFDESTRUCT`, `SETCODE` does not clear account balance, nonce, or storage. - - -Multiple `SETCODE` operations inside the same execution scope are allowed and replace the pending replacement. +The operations `EXTCODESIZE` and `EXTCODECOPY` now query the updated code, and message-calls such as `DELEGATECALL`, `CALLCODE`, `CALL`, and `STATICCALL` now execute the updated code. +Any execution scopes already executing replaced code, including the one that `SETCODE`, will continue executing the prior code. +Inside such scopes, `CODESIZE` and `CODECOPY` continue to query the executing code. -A `SELFDESTRUCT` operation discards the pending code. +Like `SSTORE`, this account modification will be reverted if the current scope or any parent scope reverts or aborts. -Any parent execution scopes executing replaced code will continue executing the prior code. -As with `DELEGATECALL`, operations `CODESIZE` and `CODECOPY` in such parent scopes continue to query the executing code, while `EXTCODESIZE` and `EXTCODECOPY` query the updated code. +Unlike `SELFDESTRUCT`, `SETCODE` does not clear account balance, nonce, or storage. ### Gas @@ -60,20 +56,21 @@ The gas cost of this operation is the sum of Gselfdestruct and the product of Gc ## Rationale +The behavior of `CODECOPY`, `CODESIZE`, `EXTCODESIZE`, and `EXTCODECOPY` match the behavior of `DELEGATECALL` and `CREATE`, where it is also possible for executing code to differ from the code of the executing account. + The gas cost of `SETCODE` is comparable to `CREATE` but excludes Gcreate because no execution context is created, nor any new account. Other account modification costs are accounted for outside of execution gas. -Unlike `SELFDESTRUCT`, execution proceeds normally after `SETCODE` in order to allow return data. - -Also unlike `SELFDESTRUCT`, the code update takes effect after the call context rather than at the end of the transaction, to allow parent execution scopes to validate the update and revert if the update had an undesirable result. +Unlike `SELFDESTRUCT`, execution proceeds normally after `SETCODE` in order to allow validation and return data. +Post-update validation can undo a `SETCODE` operation with `REVERT` or with a subesequent `SETCODE`, but `REVERT` uses less-gas. Preventing `SETCODE` within `DELEGATECALL` allows static analysis to easily identify mutable code. -Contracts not containing the `SETCODE` can be safely assumed to be immutable. +Account code not containing the `SETCODE` operation can be safely assumed to be immutable. ## Backwards Compatibility The only prior operation changing code is `SELFDESTRUCT`. -`SELFDESTRUCT` remains compatible by discarding any pending replacement code. +As code modification via `SELFDESTRUCT` is deferred until the end of the transaction, its interactions with `SETCODE` are well-defined. ## Test Cases @@ -87,7 +84,7 @@ The only prior operation changing code is `SELFDESTRUCT`. ## Security Considerations -Risks related to SETCODE similarly apply to other upgrade patterns. +Risks related to `SETCODE` similarly apply to other upgrade patterns. Most contracts should never be replaced and should not be upgradeable. Any upgrade mechanism can risk permanent failure. From 5adbc1f792bdce8519d3fe6fdbe0d384eedb37ef Mon Sep 17 00:00:00 2001 From: Gavin John Date: Sat, 27 May 2023 11:44:49 -0400 Subject: [PATCH 21/97] Update EIP-5920: Fix inconsistencies Merged by EIP-Bot. --- EIPS/eip-5920.md | 7 +++---- 1 file changed, 3 insertions(+), 4 deletions(-) diff --git a/EIPS/eip-5920.md b/EIPS/eip-5920.md index ce304eab67686a..2eb994c6b8a498 100644 --- a/EIPS/eip-5920.md +++ b/EIPS/eip-5920.md @@ -24,20 +24,19 @@ Currently, to send ether to an address requires you to call a function of that a | Parameter | Value | | ------------------- | ------- | | `PAY_OPCODE` | `0xf9` | -| `GAS_COST` | `3000` | A new opcode is introduced: `PAY` (`PAY_OPCODE`), which: - Pops two values from the stack: `addr` then `val`. -- Transfers `val` wei from the executing address to the address `addr`. If `addr` is the zero address, instead, `val` wei is burned from the executing address. +- Transfers `val` wei from the executing address to the address `addr`, even if `addr` is the zero address. -The cost of this opcode is `GAS_COST`. If `addr` is not the zero address, the [EIP-2929](./eip-2929.md) account access costs are also incurred (this includes the 25k gas cost for adding a new account to the state). +The base cost of this opcode is the additional cost of having a nonzero `msg.value` in a `CALL` opcode (currently `9000`). If `addr` is not the zero address, the [EIP-2929](./eip-2929.md) account access costs for `addr` (but NOT the current account) are also incurred: 100 gas for a warm account, 2600 gas for a cold account, and 25000 gas for a new account. If any of these costs are changed, the pricing for the `PAY` opcode must also be changed. ## Rationale ### Gas pricing -The gas pricing is that of a `CALL` with a positive `msg.value`, but without any memory expansion costs or "gas sent with call" costs, with a gas reduction of `500` to compensate for the reduced amount of computation. +The additional nonzero `msg.value` cost of the `CALL` should equal the cost of transferring ether. Therefore, that is the base cost of this opcode. Additionally, the access costs for the receiving account make sense, since the account needs to be accessed. However, it is reasonable to assume that optimized execution clients have the data for the executing contract cached. ### Argument order From ed61569182aa4de0ab72d8a70db80116ab557684 Mon Sep 17 00:00:00 2001 From: Ansgar Dietrichs Date: Mon, 29 May 2023 17:20:45 +0200 Subject: [PATCH 22/97] Update EIP-4844: Refactor Validity Conditions Merged by EIP-Bot. --- EIPS/eip-4844.md | 82 ++++++++++++++++++++++++++++++------------------ 1 file changed, 52 insertions(+), 30 deletions(-) diff --git a/EIPS/eip-4844.md b/EIPS/eip-4844.md index 5060f60bd9326c..3b305f1fb0851e 100644 --- a/EIPS/eip-4844.md +++ b/EIPS/eip-4844.md @@ -153,8 +153,7 @@ rlp([ The value of `excess_data_gas` can be calculated using the parent header and number of blobs in the block. ```python -def calc_excess_data_gas(parent: Header, new_blobs: int) -> int: - consumed_data_gas = new_blobs * DATA_GAS_PER_BLOB +def calc_excess_data_gas(parent: Header, consumed_data_gas: int) -> int: if parent.excess_data_gas + consumed_data_gas < TARGET_DATA_GAS_PER_BLOCK: return 0 else: @@ -163,22 +162,6 @@ def calc_excess_data_gas(parent: Header, new_blobs: int) -> int: For the first post-fork block, `parent.excess_data_gas` is evaluated as `0`. -### Beacon chain validation - -On the consensus-layer the blobs are now referenced, but not fully encoded, in the beacon block body. -Instead of embedding the full contents in the body, the blobs are propagated separately, as a "sidecar". - -This "sidecar" design provides forward compatibility for further data increases by black-boxing `is_data_available()`: -with full sharding `is_data_available()` can be replaced by data-availability-sampling (DAS) thus avoiding all blobs being downloaded by all beacon nodes on the network. - -Note that the consensus-layer is tasked with persisting the blobs for data availability, the execution-layer is not. - -The `ethereum/consensus-specs` repository defines the following beacon-node changes involved in this EIP: - -- Beacon chain: process updated beacon blocks and ensure blobs are available. -- P2P network: gossip and sync updated beacon block types and new blobs sidecars. -- Honest validator: produce beacon blocks with blobs, publish the blobs sidecars. - ### Opcode to get versioned hashes We add an instruction `BLOBHASH` (with opcode `HASH_OPCODE_BYTE`) which reads `index` from the top of the stack @@ -239,30 +222,69 @@ def get_data_gasprice(header: Header) -> int: ) ``` -The block validity conditions are modified to include data gas checks: +The block validity conditions are modified to include data gas checks (see the [Execution layer validation](#execution-layer-validation) section below). + +The actual `data_fee` as calculated via `calc_data_fee` is deducted from the sender balance before transaction execution and burned, and is not refunded in case of transaction failure. + +### Consensus layer validation + +On the consensus layer the blobs are referenced, but not fully encoded, in the beacon block body. +Instead of embedding the full contents in the body, the blobs are propagated separately, as "sidecars". + +This "sidecar" design provides forward compatibility for further data increases by black-boxing `is_data_available()`: +with full sharding `is_data_available()` can be replaced by data-availability-sampling (DAS) thus avoiding all blobs being downloaded by all beacon nodes on the network. + +Note that the consensus layer is tasked with persisting the blobs for data availability, the execution layer is not. + +The `ethereum/consensus-specs` repository defines the following consensus layer changes involved in this EIP: + +- Beacon chain: process updated beacon blocks and ensure blobs are available. +- P2P network: gossip and sync updated beacon block types and new blob sidecars. +- Honest validator: produce beacon blocks with blobs; sign and publish the associated blob sidecars. + +### Execution layer validation + +On the execution layer, the block validity conditions are extended as follows: ```python def validate_block(block: Block) -> None: ... - num_blobs = 0 + block_data_gas = 0 + for tx in block.transactions: ... - # the signer must be able to afford the transaction - assert signer(tx).balance >= tx.gas * tx.max_fee_per_gas + get_total_data_gas(tx) * tx.max_fee_per_data_gas + # modify the check for sufficient balance + max_total_fee = tx.gas * tx.max_fee_per_gas + if type(tx) is SignedBlobTransaction: + max_total_fee += get_total_data_gas(tx) * tx.max_fee_per_data_gas + assert signer(tx).balance >= max_total_fee - # ensure that the user was willing to at least pay the current data gasprice - assert tx.max_fee_per_data_gas >= get_data_gasprice(parent(block).header) + ... - num_blobs += len(tx.blob_versioned_hashes) + # add validity logic specific to blob txs + if type(tx) is SignedBlobTransaction: - # check that the excess data gas is correct - expected_edg = calc_excess_data_gas(parent(block).header, num_blobs) - assert expected_edg == block.excess_data_gas -``` + # there must be at least one blob + assert len(tx.message.blob_versioned_hashes) > 0 -The actual `data_fee` as calculated via `calc_data_fee` is deducted from the sender balance before transaction execution and burned, and is not refunded in case of transaction failure. + # all versioned blob hashes must start with BLOB_COMMITMENT_VERSION_KZG + for blob_versioned_hash in tx.message.blob_versioned_hashes: + assert blob_versioned_hash[0] == BLOB_COMMITMENT_VERSION_KZG + + # ensure that the user was willing to at least pay the current data gasprice + assert tx.max_fee_per_data_gas >= get_data_gasprice(parent(block).header) + + # keep track of total data gas spent in the block + block_data_gas += get_total_data_gas(tx) + + # ensure the total data gas spent is at most equal to the limit + assert block_data_gas <= MAX_DATA_GAS_PER_BLOCK + + # check that the excess data gas was updated correctly + assert block.header.excess_data_gas == calc_excess_data_gas(parent(block).header, block_data_gas) +``` ### Networking From 4ad3886f0783abae5a64c5bfc783be0bd619e3e2 Mon Sep 17 00:00:00 2001 From: g11tech Date: Tue, 30 May 2023 15:24:08 +0530 Subject: [PATCH 23/97] Update EIP-4844: Cleanup transaction network payload references Merged by EIP-Bot. --- EIPS/eip-4844.md | 29 ++++++++++++++--------------- 1 file changed, 14 insertions(+), 15 deletions(-) diff --git a/EIPS/eip-4844.md b/EIPS/eip-4844.md index 3b305f1fb0851e..c38f4dcc6af1cb 100644 --- a/EIPS/eip-4844.md +++ b/EIPS/eip-4844.md @@ -266,12 +266,14 @@ def validate_block(block: Block) -> None: # add validity logic specific to blob txs if type(tx) is SignedBlobTransaction: + # destination must be not be empty + assert tx.to != None # there must be at least one blob - assert len(tx.message.blob_versioned_hashes) > 0 + assert len(tx.blob_versioned_hashes) > 0 # all versioned blob hashes must start with BLOB_COMMITMENT_VERSION_KZG - for blob_versioned_hash in tx.message.blob_versioned_hashes: - assert blob_versioned_hash[0] == BLOB_COMMITMENT_VERSION_KZG + for h in tx.blob_versioned_hashes: + assert h[0] == BLOB_COMMITMENT_VERSION_KZG # ensure that the user was willing to at least pay the current data gasprice assert tx.max_fee_per_data_gas >= get_data_gasprice(parent(block).header) @@ -291,24 +293,21 @@ def validate_block(block: Block) -> None: Blob transactions have two network representations. During transaction gossip responses (`PooledTransactions`), the EIP-2718 `TransactionPayload` of the blob transaction is wrapped to become: ``` -rlp([blob_tx_payload, blob_kzgs, blobs, blob_kzg_proofs]) +rlp([tx_payload, blobs, commitments, proofs]) ``` Each of these elements are defined as follows: -- `blob_tx_payload` - standard EIP-2718 blob transaction `TransactionPayload` -- `blob_kzgs` - list of `KZGCommitment` -- `blobs` - list of `blob` where `blob` is a list of `BLSFieldElement` -- `kzg_aggregated_proof` - `KZGProof` +- `tx_payload` - standard EIP-2718 blob transaction `TransactionPayload` +- `blobs` - list of `blob` bytes where each `blob` is its `BLSFieldElement` list flattened in `big endian` +- `commitments` - list of `KZGCommitment` of the corresponding `blobs` +- `proofs` - list of `KZGProof` of the corresponding `blobs` and `commitments` -The node MUST validate `blob_tx_payload` and verify the wrapped data against it. To do so, ensure that: +The node MUST validate `tx_payload` and verify the wrapped data against it. To do so, ensure that: -- `blob_tx_payload.blob_versioned_hashes` must not be empty -- All hashes in `blob_tx_payload.blob_versioned_hashes` must start with the byte `BLOB_COMMITMENT_VERSION_KZG` -- There must be at most `MAX_DATA_GAS_PER_BLOCK // DATA_GAS_PER_BLOB` total blob commitments in the transaction. -- There are an equal number of versioned hashes, kzg commitments, and blobs. -- The KZG commitments hash to the versioned hashes, i.e. `kzg_to_versioned_hash(kzg[i]) == versioned_hash[i]` -- The KZG commitments match the blob contents. (Note: this can be optimized using `blob_kzg_proofs`, with a proof for a +- There are an equal number of `tx_payload.blob_versioned_hashes`, `blobs`, `commitments`, and `proofs`. +- The KZG `commitments` hash to the versioned hashes, i.e. `kzg_to_versioned_hash(commitments[i]) == tx_payload.blob_versioned_hashes[i]` +- The KZG `commitments` match the corresponding `blobs` and `proofs`. (Note: this can be optimized using `blob_kzg_proofs`, with a proof for a random evaluation at a point derived from the commitment and blob data for each blob) For body retrieval responses (`BlockBodies`), the standard EIP-2718 blob transaction `TransactionPayload` is used. From abb8b8c8317c09d7fe814564311565164677ad1f Mon Sep 17 00:00:00 2001 From: Alex Stokes Date: Tue, 30 May 2023 04:19:35 -0600 Subject: [PATCH 24/97] Update EIP-4844: clarify blob coupling Merged by EIP-Bot. --- EIPS/eip-4844.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/EIPS/eip-4844.md b/EIPS/eip-4844.md index c38f4dcc6af1cb..b33ca9795fd580 100644 --- a/EIPS/eip-4844.md +++ b/EIPS/eip-4844.md @@ -405,7 +405,7 @@ The values for `TARGET_DATA_GAS_PER_BLOCK` and `MAX_DATA_GAS_PER_BLOCK` are chos This EIP introduces a transaction type that has a distinct mempool version and execution-payload version, with only one-way convertibility between the two. The blobs are in the network representation and not in the consensus representation; -instead, they go into the `BeaconBlockBody`. This means that there is now a part of a transaction that will not be accessible from the web3 API. +instead, they are coupled with the beacon block. This means that there is now a part of a transaction that will not be accessible from the web3 API. ### Mempool issues From 2fd73316d4282fe3f379319da812f27c8f7f5cf0 Mon Sep 17 00:00:00 2001 From: xiyu <83746881+xiyu1984@users.noreply.github.com> Date: Tue, 30 May 2023 21:09:13 +0800 Subject: [PATCH 25/97] Update EIP-6358: Update the implementation examples and Move to Review Merged by EIP-Bot. --- .../src/contracts/ERC6358FungibleExample.sol | 16 +- .../contracts/ERC6358NonFungibleExample.sol | 182 ++++++++++++++---- .../libraries/OmniverseProtocolHelper.sol | 53 +++-- .../eip-6358/src/test/ERC6358Fungible.test.js | 53 +++-- .../src/test/ERC6358NonFungible.test.js | 53 +++-- 5 files changed, 266 insertions(+), 91 deletions(-) diff --git a/assets/eip-6358/src/contracts/ERC6358FungibleExample.sol b/assets/eip-6358/src/contracts/ERC6358FungibleExample.sol index 5b3b98ba327235..a74a7c764a0e93 100644 --- a/assets/eip-6358/src/contracts/ERC6358FungibleExample.sol +++ b/assets/eip-6358/src/contracts/ERC6358FungibleExample.sol @@ -251,7 +251,7 @@ contract ERC6358FungibleExample is ERC20, Ownable, IERC6358Fungible { emit OmniverseTokenTransfer(_from, _to, _amount); - address toAddr = _pkToAddress(_to); + address toAddr = OmniverseProtocolHelper.pkToAddress(_to); accountsMap[toAddr] = _to; } @@ -259,7 +259,7 @@ contract ERC6358FungibleExample is ERC20, Ownable, IERC6358Fungible { * @notice Check if the public key is the owner */ function _checkOwner(bytes memory _pk) internal view { - address fromAddr = _pkToAddress(_pk); + address fromAddr = OmniverseProtocolHelper.pkToAddress(_pk); require(fromAddr == owner(), "Not owner"); } @@ -270,7 +270,7 @@ contract ERC6358FungibleExample is ERC20, Ownable, IERC6358Fungible { omniverseBalances[_to] += _amount; emit OmniverseTokenTransfer("", _to, _amount); - address toAddr = _pkToAddress(_to); + address toAddr = OmniverseProtocolHelper.pkToAddress(_to); accountsMap[toAddr] = _to; } @@ -290,14 +290,6 @@ contract ERC6358FungibleExample is ERC20, Ownable, IERC6358Fungible { emit OmniverseTokenTransfer(_from, "", _amount); } - /** - * @notice Convert the public key to evm address - */ - function _pkToAddress(bytes memory _pk) internal pure returns (address) { - bytes32 hash = keccak256(_pk); - return address(uint160(uint256(hash))); - } - /** * @notice Add new chain members to the token */ @@ -350,7 +342,7 @@ contract ERC6358FungibleExample is ERC20, Ownable, IERC6358Fungible { /** * @notice Set the cooling down time of an omniverse transaction */ - function setCooingDownTime(uint256 _time) external { + function setCoolingDownTime(uint256 _time) external { cdTime = _time; } diff --git a/assets/eip-6358/src/contracts/ERC6358NonFungibleExample.sol b/assets/eip-6358/src/contracts/ERC6358NonFungibleExample.sol index c8128b910336e8..842bec82ac901d 100644 --- a/assets/eip-6358/src/contracts/ERC6358NonFungibleExample.sol +++ b/assets/eip-6358/src/contracts/ERC6358NonFungibleExample.sol @@ -2,6 +2,9 @@ pragma solidity >=0.8.0 <0.9.0; import "@openzeppelin/contracts/access/Ownable.sol"; +import "@openzeppelin/contracts/token/ERC721/IERC721.sol"; +import "@openzeppelin/contracts/token/ERC721/extensions/IERC721Metadata.sol"; +import "@openzeppelin/contracts/utils/Strings.sol"; import "./libraries/OmniverseProtocolHelper.sol"; import "./interfaces/IERC6358NonFungible.sol"; @@ -27,7 +30,9 @@ struct NonFungible { /** * @notice Implementation of the {IERC6358NonFungible} interface */ -contract ERC6358NonFungibleExample is Ownable, IERC6358NonFungible { +contract ERC6358NonFungibleExample is Ownable, IERC6358NonFungible, IERC721, IERC721Metadata { + using Strings for uint256; + uint8 constant TRANSFER = 0; uint8 constant MINT = 1; uint8 constant BURN = 2; @@ -52,9 +57,11 @@ contract ERC6358NonFungibleExample is Ownable, IERC6358NonFungible { } // Token name - string public name; + string private tokenName; // Token symbol - string public symbol; + string private tokenSymbol; + // Base URI + string public baseURI; // Chain id used to distinguish different chains uint32 chainId; // O-transaction cooling down time @@ -85,8 +92,18 @@ contract ERC6358NonFungibleExample is Ownable, IERC6358NonFungible { */ constructor(uint32 _chainId, string memory _name, string memory _symbol) { chainId = _chainId; - name = _name; - symbol = _symbol; + tokenName = _name; + tokenSymbol = _symbol; + } + + /** + * @dev See {IERC165-supportsInterface}. + */ + function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) { + return + interfaceId == type(IERC721).interfaceId || + interfaceId == type(IERC721Metadata).interfaceId || + interfaceId == type(IERC165).interfaceId; } /** @@ -129,6 +146,120 @@ contract ERC6358NonFungibleExample is Ownable, IERC6358NonFungible { _omniverseBurn(nonFungible.exData, nonFungible.tokenId); } } + + /** + * @notice See {IERC721-balanceOf}. + */ + function balanceOf(address owner) public view returns (uint256 balance) { + bytes storage pk = accountsMap[owner]; + if (pk.length == 0) { + balance = 0; + } + else { + balance = omniverseBalances[pk]; + } + } + + /** + * @notice See {IERC721-ownerOf}. + */ + function ownerOf(uint256 tokenId) external view returns (address owner) { + bytes memory ret = this.omniverseOwnerOf(tokenId); + return OmniverseProtocolHelper.pkToAddress(ret); + } + + /** + * @notice See {IERC721-safeTransferFrom}. + */ + function safeTransferFrom( + address from, + address to, + uint256 tokenId, + bytes calldata data + ) external { + + } + + /** + * @notice See {IERC721-safeTransferFrom}. + */ + function safeTransferFrom( + address from, + address to, + uint256 tokenId + ) external { + + } + + /** + * @notice See {IERC721-transferFrom}. + */ + function transferFrom( + address from, + address to, + uint256 tokenId + ) external { + + } + + /** + * @notice See {IERC721-approve}. + */ + function approve(address /*to*/, uint256 /*tokenId*/) external { + + } + + /** + * @notice See {IERC721-setApprovalForAll}. + */ + function setApprovalForAll(address /*operator*/, bool /*_approved*/) external { + + } + + /** + * @notice See {IERC721-getApproved}. + */ + function getApproved(uint256 /*tokenId*/) external pure returns (address /*operator*/) { + revert("Forbidden"); + } + + /** + * @notice See {IERC721-isApprovedForAll}. + */ + function isApprovedForAll(address /*owner*/, address /*operator*/) external pure returns (bool) { + return false; + } + + /** + * @notice See {IERC721Metadata-name}. + */ + function name() external view returns (string memory) { + return tokenName; + } + + /** + * @notice See {IERC721Metadata-symbol}. + */ + function symbol() external view returns (string memory) { + return tokenSymbol; + } + + /** + * @notice See {IERC721Metadata-tokenURI}. + */ + function tokenURI(uint256 tokenId) external view returns (string memory) { + bytes memory ret = omniverseOwners[tokenId]; + require(keccak256(ret) != keccak256(bytes("")), "ERC721Metadata: URI query for nonexistent token"); + + return bytes(baseURI).length > 0 ? string(abi.encodePacked(baseURI, tokenId.toString())) : ""; + } + + /** + * @notice Sets the base URI. + */ + function setBaseURI(string calldata _baseURI) public { + baseURI = _baseURI; + } /** * @notice Check if the transaction can be executed successfully @@ -189,27 +320,6 @@ contract ERC6358NonFungibleExample is Ownable, IERC6358NonFungible { return ret; } - /** - * @notice See {IERC721-balanceOf}. - */ - function balanceOf(address account) public view returns (uint256) { - bytes storage pk = accountsMap[account]; - if (pk.length == 0) { - return 0; - } - else { - return omniverseBalances[pk]; - } - } - - /** - * @notice See {IERC721-ownerOf}. - */ - function ownerOf(uint256 tokenId) public view returns (address owner) { - bytes memory ret = this.omniverseOwnerOf(tokenId); - return _pkToAddress(ret); - } - /** * @notice Receive and check an omniverse transaction */ @@ -272,15 +382,17 @@ contract ERC6358NonFungibleExample is Ownable, IERC6358NonFungible { emit OmniverseTokenTransfer(_from, _to, _tokenId); - address toAddr = _pkToAddress(_to); + address fromAddr = OmniverseProtocolHelper.pkToAddress(_from); + address toAddr = OmniverseProtocolHelper.pkToAddress(_to); accountsMap[toAddr] = _to; + emit Transfer(fromAddr, toAddr, _tokenId); } /** * @notice Check if the public key is the owner */ function _checkOwner(bytes memory _pk) internal view { - address fromAddr = _pkToAddress(_pk); + address fromAddr = OmniverseProtocolHelper.pkToAddress(_pk); require(fromAddr == owner(), "Not owner"); } @@ -301,8 +413,9 @@ contract ERC6358NonFungibleExample is Ownable, IERC6358NonFungible { omniverseBalances[_to] += 1; emit OmniverseTokenTransfer("", _to, _tokenId); - address toAddr = _pkToAddress(_to); + address toAddr = OmniverseProtocolHelper.pkToAddress(_to); accountsMap[toAddr] = _to; + emit Transfer(address(0), toAddr, _tokenId); } /** @@ -319,14 +432,9 @@ contract ERC6358NonFungibleExample is Ownable, IERC6358NonFungible { delete omniverseOwners[_tokenId]; omniverseBalances[_from] -= 1; emit OmniverseTokenTransfer(_from, "", _tokenId); - } - /** - * @notice Convert the public key to evm address - */ - function _pkToAddress(bytes memory _pk) internal pure returns (address) { - bytes32 hash = keccak256(_pk); - return address(uint160(uint256(hash))); + address fromAddr = OmniverseProtocolHelper.pkToAddress(_from); + emit Transfer(fromAddr, address(0), _tokenId); } /** @@ -374,7 +482,7 @@ contract ERC6358NonFungibleExample is Ownable, IERC6358NonFungible { /** * @notice Set the cooling down time of an omniverse transaction */ - function setCooingDownTime(uint256 _time) external { + function setCoolingDownTime(uint256 _time) external { cdTime = _time; } diff --git a/assets/eip-6358/src/contracts/libraries/OmniverseProtocolHelper.sol b/assets/eip-6358/src/contracts/libraries/OmniverseProtocolHelper.sol index f7144fa61d6a7c..eccfbeb55f175c 100644 --- a/assets/eip-6358/src/contracts/libraries/OmniverseProtocolHelper.sol +++ b/assets/eip-6358/src/contracts/libraries/OmniverseProtocolHelper.sol @@ -3,6 +3,7 @@ pragma solidity >=0.8.0 <0.9.0; import "../interfaces/IERC6358.sol"; import "../interfaces/IERC6358Application.sol"; +import "@openzeppelin/contracts/utils/Strings.sol"; /** * @notice Used to record one omniverse transaction data @@ -47,13 +48,21 @@ enum VerifyResult { * NOTE The verification method is for reference only, and developers can design appropriate * verification mechanism based on their bussiness logic. */ -library OmniverseProtocolHelper { +library OmniverseProtocolHelper { /** - * @notice Get the hash of a transaction + * @notice Get the raw data of a transaction */ - function getTransactionHash(ERC6358TransactionData memory _data) internal view returns (bytes32) { + function getRawData(ERC6358TransactionData memory _data) internal view returns (bytes memory) { bytes memory payloadRawData = IERC6358Application(address(this)).getPayloadRawData(_data.payload); bytes memory rawData = abi.encodePacked(_data.nonce, _data.chainId, _data.initiateSC, _data.from, payloadRawData); + return rawData; + } + + /** + * @notice Get the hash of a transaction + */ + function getTransactionHash(ERC6358TransactionData memory _data) internal view returns (bytes32) { + bytes memory rawData = getRawData(_data); return keccak256(rawData); } @@ -70,31 +79,46 @@ library OmniverseProtocolHelper { v := mload(add(_signature, 65)) } address recovered = ecrecover(_hash, v, r, s); - require(recovered != address(0), "Verify failed"); return recovered; } /** - * @notice Check if the public key matches the recovered address + * @notice Convert the public key to evm address */ - function checkPkMatched(bytes memory _pk, address _address) public pure { + function pkToAddress(bytes memory _pk) public pure returns (address) { bytes32 hash = keccak256(_pk); - address pkAddress = address(uint160(uint256(hash))); - require(_address == pkAddress, "Signer not sender"); + return address(uint160(uint256(hash))); + } + + /** + * @notice Verify if the signature matches the address + */ + function verifySignature(bytes memory _rawData, bytes memory _signature, address _address) public pure returns (bool) { + bytes32 hash = keccak256(_rawData); + address pkAddress = recoverAddress(hash, _signature); + bytes memory PREFIX = hex"19457468657265756d205369676e6564204d6573736167653a0a"; + + if (pkAddress == address(0) || pkAddress != _address) { + hash = keccak256(abi.encodePacked(PREFIX, bytes(Strings.toString(_rawData.length)), _rawData)); + pkAddress = recoverAddress(hash, _signature); + if (pkAddress == address(0) || pkAddress != _address) { + return false; + } + } + + return true; } /** * @notice Verify an omniverse transaction */ function verifyTransaction(RecordedCertificate storage rc, ERC6358TransactionData memory _data) public returns (VerifyResult) { - uint256 nonce = rc.txList.length; - - bytes32 txHash = getTransactionHash(_data); - address recoveredAddress = recoverAddress(txHash, _data.signature); - // Signature verified failed - checkPkMatched(_data.from, recoveredAddress); + bytes memory rawData = getRawData(_data); + address senderAddress = pkToAddress(_data.from); + require(verifySignature(rawData, _data.signature, senderAddress), "Signature error"); // Check nonce + uint256 nonce = rc.txList.length; if (nonce == _data.nonce) { return VerifyResult.Success; } @@ -102,6 +126,7 @@ library OmniverseProtocolHelper { // The message has been received, check conflicts OmniverseTx storage hisTx = rc.txList[_data.nonce]; bytes32 hisTxHash = getTransactionHash(hisTx.txData); + bytes32 txHash = getTransactionHash(_data); if (hisTxHash != txHash) { // to be continued, add to evil list, but can not be duplicated EvilTxData storage evilTx = rc.evilTxList.push(); diff --git a/assets/eip-6358/src/test/ERC6358Fungible.test.js b/assets/eip-6358/src/test/ERC6358Fungible.test.js index bc0cbb6d509824..86a484ffeaadde 100644 --- a/assets/eip-6358/src/test/ERC6358Fungible.test.js +++ b/assets/eip-6358/src/test/ERC6358Fungible.test.js @@ -3,9 +3,9 @@ const BN = require('bn.js'); const secp256k1 = require('secp256k1'); const keccak256 = require('keccak256'); const Web3 = require('web3'); -const web3js = new Web3(Web3.givenProvider); +const providerUrl = 'http://localhost:8545'; +const web3js = new Web3(providerUrl); const assert = require('assert'); -// const { util } = require('config'); const CHAIN_ID = 0; const ONE_TOKEN = '1000000000000000000'; @@ -113,7 +113,7 @@ contract('ERC6358Fungible', function() { fungible = await Fungible.new(CHAIN_ID, TOKEN_SYMBOL, TOKEN_SYMBOL, {from: owner}); Fungible.address = fungible.address; await fungible.setMembers([[CHAIN_ID, Fungible.address]]); - await fungible.setCooingDownTime(COOL_DOWN); + await fungible.setCoolingDownTime(COOL_DOWN); } const mintToken = async function(from, toPk, amount) { @@ -121,7 +121,7 @@ contract('ERC6358Fungible', function() { let txData = encodeMint(from, toPk, amount, nonce); await fungible.sendOmniverseTransaction(txData); await utils.sleep(COOL_DOWN); - await utils.evmMine(1); + await utils.evmMine(1, web3js.currentProvider); let ret = await fungible.triggerExecution(); } @@ -135,7 +135,7 @@ contract('ERC6358Fungible', function() { let nonce = await fungible.getTransactionCount(user1Pk); let txData = encodeTransfer({pk: user1Pk, sk: user1Sk}, user2Pk, TEN_TOKEN, nonce); txData.signature = txData.signature.slice(0, -2); - await utils.expectThrow(fungible.sendOmniverseTransaction(txData), 'Verify failed'); + await utils.expectThrow(fungible.sendOmniverseTransaction(txData), 'Signature error'); }); }); @@ -144,7 +144,7 @@ contract('ERC6358Fungible', function() { let nonce = await fungible.getTransactionCount(user1Pk); let txData = encodeTransfer({pk: user1Pk, sk: user1Sk}, user2Pk, TEN_TOKEN, nonce); txData.from = ownerPk; - await utils.expectThrow(fungible.sendOmniverseTransaction(txData), 'Signer not sender'); + await utils.expectThrow(fungible.sendOmniverseTransaction(txData), 'Signature error'); }); }); @@ -165,7 +165,7 @@ contract('ERC6358Fungible', function() { let count = await fungible.getTransactionCount(ownerPk); assert(count == 0, "The count should be zero"); await utils.sleep(COOL_DOWN); - await utils.evmMine(1); + await utils.evmMine(1, web3js.currentProvider); ret = await fungible.triggerExecution(); count = await fungible.getTransactionCount(ownerPk); assert(count == 1, "The count should be one"); @@ -193,10 +193,10 @@ contract('ERC6358Fungible', function() { describe('Cooled down', function() { it('should succeed', async () => { await utils.sleep(COOL_DOWN); - await utils.evmMine(1); + await utils.evmMine(1, web3js.currentProvider); let nonce = await fungible.getTransactionCount(ownerPk); await utils.sleep(COOL_DOWN); - await utils.evmMine(1); + await utils.evmMine(1, web3js.currentProvider); ret = await fungible.triggerExecution(); let count = await fungible.getTransactionCount(ownerPk); assert(count == 2); @@ -214,6 +214,31 @@ contract('ERC6358Fungible', function() { }); }); + describe('Personal signing', function() { + before(async function() { + await initContract(); + }); + + describe('All conditions satisfied', function() { + it('should succeed', async () => { + let nonce = await fungible.getTransactionCount(ownerPk); + let txData = encodeMint({pk: ownerPk, sk: ownerSk}, user2Pk, TEN_TOKEN, nonce); + let bData = getRawData(txData, MINT, [user2Pk, TEN_TOKEN]); + let hash = keccak256(Buffer.concat([Buffer.from('\x19Ethereum Signed Message:\n' + bData.length), bData])); + txData.signature = signData(hash, ownerSk); + let ret = await fungible.sendOmniverseTransaction(txData); + assert(ret.logs[0].event == 'TransactionSent'); + let count = await fungible.getTransactionCount(ownerPk); + assert(count == 0, "The count should be zero"); + await utils.sleep(COOL_DOWN); + await utils.evmMine(1, web3js.currentProvider); + ret = await fungible.triggerExecution(); + count = await fungible.getTransactionCount(ownerPk); + assert(count == 1, "The count should be one"); + }); + }); + }); + describe('Omniverse Transaction', function() { before(async function() { await initContract(); @@ -236,7 +261,7 @@ contract('ERC6358Fungible', function() { let count = await fungible.getDelayedTxCount(); assert(count == 1, 'The number of delayed txs should be one'); await utils.sleep(COOL_DOWN); - await utils.evmMine(1); + await utils.evmMine(1, web3js.currentProvider); ret = await fungible.triggerExecution(); }); }); @@ -278,7 +303,7 @@ contract('ERC6358Fungible', function() { describe('Cooled down', function() { it('should be one transaction', async () => { await utils.sleep(COOL_DOWN); - await utils.evmMine(1); + await utils.evmMine(1, web3js.currentProvider); let tx = await fungible.getExecutableDelayedTx(); assert(tx.sender == ownerPk, 'There should be one transaction'); }); @@ -325,7 +350,7 @@ contract('ERC6358Fungible', function() { let txData = encodeMint({pk: ownerPk, sk: ownerSk}, user1Pk, ONE_TOKEN, nonce); await fungible.sendOmniverseTransaction(txData); await utils.sleep(COOL_DOWN); - await utils.evmMine(1); + await utils.evmMine(1, web3js.currentProvider); let ret = await fungible.triggerExecution(); assert(ret.logs[0].event == 'OmniverseTokenTransfer'); let balance = await fungible.omniverseBalanceOf(user1Pk); @@ -362,7 +387,7 @@ contract('ERC6358Fungible', function() { let txData = encodeBurn({pk: ownerPk, sk: ownerSk}, user1Pk, ONE_TOKEN, nonce); await fungible.sendOmniverseTransaction(txData); await utils.sleep(COOL_DOWN); - await utils.evmMine(1); + await utils.evmMine(1, web3js.currentProvider); let ret = await fungible.triggerExecution(); assert(ret.logs[0].event == 'OmniverseTokenTransfer'); let balance = await fungible.omniverseBalanceOf(user1Pk); @@ -391,7 +416,7 @@ contract('ERC6358Fungible', function() { let txData = encodeTransfer({pk: user1Pk, sk: user1Sk}, user2Pk, ONE_TOKEN, nonce); await fungible.sendOmniverseTransaction(txData); await utils.sleep(COOL_DOWN); - await utils.evmMine(1); + await utils.evmMine(1, web3js.currentProvider); let ret = await fungible.triggerExecution(); assert(ret.logs[0].event == 'OmniverseTokenTransfer'); let balance = await fungible.omniverseBalanceOf(user1Pk); diff --git a/assets/eip-6358/src/test/ERC6358NonFungible.test.js b/assets/eip-6358/src/test/ERC6358NonFungible.test.js index ffce3741892f95..b78b2e675ec00a 100644 --- a/assets/eip-6358/src/test/ERC6358NonFungible.test.js +++ b/assets/eip-6358/src/test/ERC6358NonFungible.test.js @@ -3,9 +3,9 @@ const BN = require('bn.js'); const secp256k1 = require('secp256k1'); const keccak256 = require('keccak256'); const Web3 = require('web3'); -const web3js = new Web3(Web3.givenProvider); +const providerUrl = 'http://localhost:8545'; +const web3js = new Web3(providerUrl); const assert = require('assert'); -// const { util } = require('config'); const CHAIN_ID = 0; const TOKEN_ID = 1; @@ -112,7 +112,7 @@ contract('ERC6358NonFungible', function() { nonFungible = await NonFungible.new(CHAIN_ID, TOKEN_SYMBOL, TOKEN_SYMBOL, {from: owner}); NonFungible.address = nonFungible.address; await nonFungible.setMembers([[CHAIN_ID, NonFungible.address]]); - await nonFungible.setCooingDownTime(COOL_DOWN); + await nonFungible.setCoolingDownTime(COOL_DOWN); } const mintToken = async function(from, toPk, tokenId) { @@ -120,7 +120,7 @@ contract('ERC6358NonFungible', function() { let txData = encodeMint(from, toPk, tokenId, nonce); await nonFungible.sendOmniverseTransaction(txData); await utils.sleep(COOL_DOWN); - await utils.evmMine(1); + await utils.evmMine(1, web3js.currentProvider); let ret = await nonFungible.triggerExecution(); } @@ -134,7 +134,7 @@ contract('ERC6358NonFungible', function() { let nonce = await nonFungible.getTransactionCount(user1Pk); let txData = encodeTransfer({pk: user1Pk, sk: user1Sk}, user2Pk, TOKEN_ID, nonce); txData.signature = txData.signature.slice(0, -2); - await utils.expectThrow(nonFungible.sendOmniverseTransaction(txData), 'Verify failed'); + await utils.expectThrow(nonFungible.sendOmniverseTransaction(txData), 'Signature error'); }); }); @@ -143,7 +143,7 @@ contract('ERC6358NonFungible', function() { let nonce = await nonFungible.getTransactionCount(user1Pk); let txData = encodeTransfer({pk: user1Pk, sk: user1Sk}, user2Pk, TOKEN_ID, nonce); txData.from = ownerPk; - await utils.expectThrow(nonFungible.sendOmniverseTransaction(txData), 'Signer not sender'); + await utils.expectThrow(nonFungible.sendOmniverseTransaction(txData), 'Signature error'); }); }); @@ -164,7 +164,7 @@ contract('ERC6358NonFungible', function() { let count = await nonFungible.getTransactionCount(ownerPk); assert(count == 0, "The count should be zero"); await utils.sleep(COOL_DOWN); - await utils.evmMine(1); + await utils.evmMine(1, web3js.currentProvider); ret = await nonFungible.triggerExecution(); count = await nonFungible.getTransactionCount(ownerPk); assert(count == 1, "The count should be one"); @@ -192,10 +192,10 @@ contract('ERC6358NonFungible', function() { describe('Cooled down', function() { it('should succeed', async () => { await utils.sleep(COOL_DOWN); - await utils.evmMine(1); + await utils.evmMine(1, web3js.currentProvider); let nonce = await nonFungible.getTransactionCount(ownerPk); await utils.sleep(COOL_DOWN); - await utils.evmMine(1); + await utils.evmMine(1, web3js.currentProvider); ret = await nonFungible.triggerExecution(); let count = await nonFungible.getTransactionCount(ownerPk); assert(count == 2); @@ -212,6 +212,31 @@ contract('ERC6358NonFungible', function() { }); }); }); + + describe('Personal signing', function() { + before(async function() { + await initContract(); + }); + + describe('All conditions satisfied', function() { + it('should succeed', async () => { + let nonce = await nonFungible.getTransactionCount(ownerPk); + let txData = encodeMint({pk: ownerPk, sk: ownerSk}, user2Pk, TOKEN_ID, nonce); + let bData = getRawData(txData, MINT, [user2Pk, TOKEN_ID]); + let hash = keccak256(Buffer.concat([Buffer.from('\x19Ethereum Signed Message:\n' + bData.length), bData])); + txData.signature = signData(hash, ownerSk); + let ret = await nonFungible.sendOmniverseTransaction(txData); + assert(ret.logs[0].event == 'TransactionSent'); + let count = await nonFungible.getTransactionCount(ownerPk); + assert(count == 0, "The count should be zero"); + await utils.sleep(COOL_DOWN); + await utils.evmMine(1, web3js.currentProvider); + ret = await nonFungible.triggerExecution(); + count = await nonFungible.getTransactionCount(ownerPk); + assert(count == 1, "The count should be one"); + }); + }); + }); describe('Omniverse Transaction', function() { before(async function() { @@ -235,7 +260,7 @@ contract('ERC6358NonFungible', function() { let count = await nonFungible.getDelayedTxCount(); assert(count == 1, 'The number of delayed txs should be one'); await utils.sleep(COOL_DOWN); - await utils.evmMine(1); + await utils.evmMine(1, web3js.currentProvider); ret = await nonFungible.triggerExecution(); }); }); @@ -277,7 +302,7 @@ contract('ERC6358NonFungible', function() { describe('Cooled down', function() { it('should be one transaction', async () => { await utils.sleep(COOL_DOWN); - await utils.evmMine(1); + await utils.evmMine(1, web3js.currentProvider); let tx = await nonFungible.getExecutableDelayedTx(); assert(tx.sender == ownerPk, 'There should be one transaction'); }); @@ -324,7 +349,7 @@ contract('ERC6358NonFungible', function() { let txData = encodeMint({pk: ownerPk, sk: ownerSk}, user1Pk, TOKEN_ID, nonce); await nonFungible.sendOmniverseTransaction(txData); await utils.sleep(COOL_DOWN); - await utils.evmMine(1); + await utils.evmMine(1, web3js.currentProvider); let ret = await nonFungible.triggerExecution(); assert(ret.logs[0].event == 'OmniverseTokenTransfer'); let tokenOwner = await nonFungible.omniverseOwnerOf(TOKEN_ID); @@ -363,7 +388,7 @@ contract('ERC6358NonFungible', function() { let txData = encodeBurn({pk: ownerPk, sk: ownerSk}, user1Pk, TOKEN_ID, nonce); await nonFungible.sendOmniverseTransaction(txData); await utils.sleep(COOL_DOWN); - await utils.evmMine(1); + await utils.evmMine(1, web3js.currentProvider); let ret = await nonFungible.triggerExecution(); await utils.expectThrow(nonFungible.omniverseOwnerOf(TOKEN_ID), "Token not exist"); assert(ret.logs[0].event == 'OmniverseTokenTransfer'); @@ -393,7 +418,7 @@ contract('ERC6358NonFungible', function() { let txData = encodeTransfer({pk: user1Pk, sk: user1Sk}, user2Pk, TOKEN_ID, nonce); await nonFungible.sendOmniverseTransaction(txData); await utils.sleep(COOL_DOWN); - await utils.evmMine(1); + await utils.evmMine(1, web3js.currentProvider); let ret = await nonFungible.triggerExecution(); assert(ret.logs[0].event == 'OmniverseTokenTransfer'); let tokenOwner = await nonFungible.omniverseOwnerOf(TOKEN_ID); From e1c728e3283fb277192edf59b36562dd7ce6989e Mon Sep 17 00:00:00 2001 From: Alex Korpis Date: Tue, 30 May 2023 16:49:33 +0200 Subject: [PATCH 26/97] Update EIP-6123: add upfront payment to interface Merged by EIP-Bot. --- assets/eip-6123/contracts/ISDC.sol | 3 ++- assets/eip-6123/contracts/SDC.sol | 4 +++- assets/eip-6123/contracts/SDCToken.sol | 6 +++--- assets/eip-6123/test/SDC.js | 4 ++-- 4 files changed, 10 insertions(+), 7 deletions(-) diff --git a/assets/eip-6123/contracts/ISDC.sol b/assets/eip-6123/contracts/ISDC.sol index 0dac18912be9e9..45059fa2176a6f 100644 --- a/assets/eip-6123/contracts/ISDC.sol +++ b/assets/eip-6123/contracts/ISDC.sol @@ -136,8 +136,9 @@ interface ISDC { * @dev emits a {TradeIncepted} event * @param _tradeData a description of the trade specification e.g. in xml format, suggested structure - see assets/eip-6123/doc/sample-tradedata-filestructure.xml * @param _initialSettlementData the initial settlement data (e.g. initial market data at which trade was incepted) + * @param _upfrontPayment provides an initial payment amount upfront */ - function inceptTrade(string memory _tradeData, string memory _initialSettlementData) external; + function inceptTrade(string memory _tradeData, string memory _initialSettlementData, int256 _upfrontPayment) external; /** * @notice Performs a matching of provided trade data and settlement data diff --git a/assets/eip-6123/contracts/SDC.sol b/assets/eip-6123/contracts/SDC.sol index 02616ea3b480cb..6865c519be6c71 100644 --- a/assets/eip-6123/contracts/SDC.sol +++ b/assets/eip-6123/contracts/SDC.sol @@ -174,11 +174,13 @@ contract SDC is ISDC { * emits a TradeIncepted * can be called only when TradeState = Incepted */ - function inceptTrade(string memory _tradeData, string memory _initialSettlementData) external override onlyCounterparty onlyWhenTradeInactive + function inceptTrade(string memory _tradeData, string memory _initialSettlementData, int256 _upfrontPayment) external override onlyCounterparty onlyWhenTradeInactive { processState = ProcessState.Initiation; tradeState = TradeState.Incepted; // Set TradeState to Incepted + _upfrontPayment; // To silence warning... TODO: Implement new feature. + uint256 hash = uint256(keccak256(abi.encode(_tradeData, _initialSettlementData))); pendingRequests[hash] = msg.sender; tradeID = Strings.toString(hash); diff --git a/assets/eip-6123/contracts/SDCToken.sol b/assets/eip-6123/contracts/SDCToken.sol index 45de674b998580..0e39df3e83613a 100644 --- a/assets/eip-6123/contracts/SDCToken.sol +++ b/assets/eip-6123/contracts/SDCToken.sol @@ -5,11 +5,11 @@ pragma solidity ^0.8.0; import "@openzeppelin/contracts/token/ERC20/ERC20.sol"; contract SDCToken is ERC20{ - constructor() ERC20("SDCToken", "SDCT"){ + constructor() ERC20("SDCToken", "SDCT") { } - function mint(address to, uint256 amount) public{ - _mint(to,amount); + function mint(address to, uint256 amount) public { + _mint(to, amount); } } \ No newline at end of file diff --git a/assets/eip-6123/test/SDC.js b/assets/eip-6123/test/SDC.js index 06b579b10d4ae0..75049c9c7314b3 100644 --- a/assets/eip-6123/test/SDC.js +++ b/assets/eip-6123/test/SDC.js @@ -53,10 +53,10 @@ describe("Livecycle Unit-Tests for Smart Derivative Contract", () => { }); it("Counterparty1 incepts a trade", async () => { - const incept_call = await sdc.connect(counterparty1).inceptTrade(trade_data,"initialMarketData"); + const incept_call = await sdc.connect(counterparty1).inceptTrade(trade_data, "initialMarketData", 0); let tradeid = await sdc.connect(counterparty1).getTradeID(); //console.log("TradeId: %s", tradeid); - await expect(incept_call).to.emit(sdc, "TradeIncepted").withArgs(counterparty1.address,tradeid,trade_data); + await expect(incept_call).to.emit(sdc, "TradeIncepted").withArgs(counterparty1.address, tradeid, trade_data); let trade_state = await sdc.connect(counterparty1).getTradeState(); await expect(trade_state).equal(TradeState.Incepted); }); From b09f718431e668254178190ffb01426cf6b7f06a Mon Sep 17 00:00:00 2001 From: Jan Turk Date: Tue, 30 May 2023 16:56:56 +0200 Subject: [PATCH 27/97] Update EIP-6454: Move to Final Merged by EIP-Bot. --- EIPS/eip-6454.md | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/EIPS/eip-6454.md b/EIPS/eip-6454.md index f2dbc9a39fef15..bd51bd43638132 100644 --- a/EIPS/eip-6454.md +++ b/EIPS/eip-6454.md @@ -4,8 +4,7 @@ title: Minimal Transferable NFT detection interface description: A minimal extension to identify the transferability of Non-Fungible Tokens. author: Bruno Škvorc (@Swader), Francesco Sullo (@sullof), Steven Pineda (@steven2308), Stevan Bogosavljevic (@stevyhacker), Jan Turk (@ThunderDeliverer) discussions-to: https://ethereum-magicians.org/t/minimalistic-transferable-interface/12517 -status: Last Call -last-call-deadline: 2023-05-27 +status: Final type: Standards Track category: ERC created: 2023-01-31 From e4b33186cf9c5adfdd73f42f661c562909f8b370 Mon Sep 17 00:00:00 2001 From: Sean Date: Wed, 31 May 2023 00:59:29 +1000 Subject: [PATCH 28/97] Update EIP-5570: Move to Final Merged by EIP-Bot. --- EIPS/eip-5570.md | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/EIPS/eip-5570.md b/EIPS/eip-5570.md index 94e80540f3a5d6..90e4c547d7d849 100644 --- a/EIPS/eip-5570.md +++ b/EIPS/eip-5570.md @@ -4,8 +4,7 @@ title: Digital Receipt Non-Fungible Tokens description: Non-Fungible Tokens as digital receipts for physical purchases, where the metadata represents a JSON receipt author: Sean Darcy (@darcys22) discussions-to: https://ethereum-magicians.org/t/idea-standard-digital-receipts-using-erc-721/9908 -status: Last Call -last-call-deadline: 2023-05-16 +status: Final type: Standards Track category: ERC created: 2022-09-01 From b02ec2a578b58add33503090d6d50dac30ab31ad Mon Sep 17 00:00:00 2001 From: Mikhail Kalinin Date: Tue, 30 May 2023 21:01:27 +0600 Subject: [PATCH 29/97] Add EIP: Elected block proposer has not been slashed Merged by EIP-Bot. --- EIPS/eip-6988.md | 60 ++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 60 insertions(+) create mode 100644 EIPS/eip-6988.md diff --git a/EIPS/eip-6988.md b/EIPS/eip-6988.md new file mode 100644 index 00000000000000..f7816ad40f61c7 --- /dev/null +++ b/EIPS/eip-6988.md @@ -0,0 +1,60 @@ +--- +eip: 6988 +title: Elected block proposer has not been slashed +description: Prevents a slashed validator from being elected as a block proposer +author: Mikhail Kalinin (@mkalinin) +discussions-to: https://ethereum-magicians.org/t/eip-6988-elected-block-proposer-has-not-been-slashed/14349 +status: Draft +type: Standards Track +category: Core +created: 2023-05-04 +--- + +## Abstract + +Introduces a modification to the consensus layer specification which ensures that slashed validator cannot be elected as block proposer. + +## Motivation + +A block proposed by a slashed validator is rejected by the corresponding validity check in the [`phase0/process_block_header`](https://github.com/ethereum/consensus-specs/blob/3115d1140b23dd4c9c23fbd9e2428186cf816bde/specs/phase0/beacon-chain.md#block-header) function as defined in the consensus layer specification. + +At the same time the definition of the [`phase0/compute_proposer_index`](https://github.com/ethereum/consensus-specs/blob/3115d1140b23dd4c9c23fbd9e2428186cf816bde/specs/phase0/beacon-chain.md#compute_proposer_index) allows for a slashed validator to be elected as a proposer. This contradiction effectively leads to a missed proposal if it is supposed to be made by a slashed validator. + +The impact of the proposed fix in the case of a single slashing on Ethereum Mainnet is negligible but it becomes significant in the case of correlated slashings. For instance, a correlated slashing of `1/10th` of a validator set can lead to `1/10th` of missed proposals in a number of epochs after the slashing. + +## Specification + +Specification of the proposed change can be found in [`/_features/eip6988/beacon-chain.md`](https://github.com/ethereum/consensus-specs/blob/0ad3972725e7c22e8edf3bab2dd7730acbe3c272/specs/_features/eip6988/beacon-chain.md). + +## Rationale + +### Modifying `get_beacon_proposer_index` + +This function is modified to read a proposer index from a beacon state if a slot of a latest block header is the same as the `state.slot`. + +This modification is done to make the function return correct proposer index in the case when the proposer of a given block is being slashed during processing of the block. + +## Backwards Compatibility + +This fix changes proposer election mechanism in a backwards incompatible way and requires a hard fork to be deployed. + +## Test Cases + +The following test cases were added to cover this change: + +* [`test_slashed_proposer_rewarded_for_sync_aggregate_inclusion`](https://github.com/ethereum/consensus-specs/blob/0ad3972725e7c22e8edf3bab2dd7730acbe3c272/tests/core/pyspec/eth2spec/test/altair/block_processing/sync_aggregate/test_process_sync_aggregate.py#L712) +* [`test_slashed_proposer_rewarded_for_attestation_inclusion`](https://github.com/ethereum/consensus-specs/blob/0ad3972725e7c22e8edf3bab2dd7730acbe3c272/tests/core/pyspec/eth2spec/test/altair/block_processing/test_process_attestation.py#L17) +* [`test_slashed_validator_not_elected_for_proposal`](https://github.com/ethereum/consensus-specs/blob/0ad3972725e7c22e8edf3bab2dd7730acbe3c272/tests/core/pyspec/eth2spec/test/eip6988/unittests/validator/test_validator.py#L9) +* [`test_slashed_validator_elected_for_proposal`](https://github.com/ethereum/consensus-specs/blob/0ad3972725e7c22e8edf3bab2dd7730acbe3c272/tests/core/pyspec/eth2spec/test/phase0/unittests/validator/test_validator_unittest.py#L520) + +## Reference Implementation + +Reference implementation is in the same place as [Specification](#specification). + +## Security Considerations + +There are no observed security issues introduced by the proposed change. + +## Copyright + +Copyright and related rights waived via [CC0](../LICENSE.md). From 01029a90154a16eeedfc6ef45d033ae7b9861b0c Mon Sep 17 00:00:00 2001 From: NarcisCRO <122120404+NarcisCRO@users.noreply.github.com> Date: Tue, 30 May 2023 18:02:56 +0300 Subject: [PATCH 30/97] Update EIP-6808: Move to Review Merged by EIP-Bot. --- EIPS/eip-6808.md | 72 ++++++++++++++++++++++++------------------------ 1 file changed, 36 insertions(+), 36 deletions(-) diff --git a/EIPS/eip-6808.md b/EIPS/eip-6808.md index f6cfbed526335f..73eb8bba4f3dd0 100644 --- a/EIPS/eip-6808.md +++ b/EIPS/eip-6808.md @@ -1,10 +1,10 @@ --- eip: 6808 title: Fungible Key Bound Token -description: An interface for Fungible Key Bound Tokens, also known as an FKBT. +description: An interface for Fungible Key Bound Tokens, also known as a FKBT. author: Mihai Onila (@MihaiORO), Nick Zeman (@NickZCZ), Narcis Cotaie (@NarcisCRO) discussions-to: https://ethereum-magicians.org/t/fungible-key-bound-token-kbt/13624 -status: Draft +status: Review type: Standards Track category: ERC created: 2023-03-31 @@ -15,11 +15,11 @@ requires: 20 A standard interface for Fungible Key Bound Tokens (**FKBT/s**), a subset of the more general Key Bound Tokens (**KBT/s**). -The following standardizes an API for tokens within smart contracts and provides basic functionality to the [addBindings](#addbindings-function) function. This function designates **Key Wallets**[^1], which are responsible for conducting a **Safe Transfer**[^2]. During this process, **FKBTs** are safely approved so they can be spent by the user or an on-chain third-party entity. +The following standardizes an API for tokens within smart contracts and provides basic functionality to the [addBindings](#addbindings-function) function. This function designates **Key Wallets**[^1], which are responsible for conducting a **Safe Transfer**[^2]. During this process, **FKBT's** are safely approved so they can be spent by the user or an on-chain third-party entity. -The premise of **FKBTs** is to provide fully optional security features built directly into the fungible asset, via the concept of _allow_ found in the [allowTransfer](#allowtransfer-function) and [allowApproval](#allowapproval-function) functions. These functions are called by one of the **Key Wallets**[^1] and _allow_ the **Holding Wallet**[^3] to either call the already familiar `transfer` and `approve` function found in [ERC-20](./eip-20.md). Responsibility for the **FKBT** is therefore split. The **Holding Wallet** contains the asset and **Key Wallets** have authority over how the assets can be spent or approved. **Default Behaviors**[^4] of a traditional fungible ERC-20 can be achieved by simply never using the [addBindings](#addbindings-function) function. +The premise of **FKBT's** is to provide fully optional security features built directly into the fungible asset, via the concept of _allow_ found in the [allowTransfer](#allowtransfer-function) and [allowApproval](#allowapproval-function) functions. These functions are called by one of the **Key Wallets**[^1] and _allow_ the **Holding Wallet**[^3] to either call the already familiar `transfer` and `approve` function found in [ERC-20](./eip-20.md). Responsibility for the **FKBT** is therefore split. The **Holding Wallet** contains the asset and **Key Wallets** have authority over how the assets can be spent or approved. **Default Behaviors**[^4] of a traditional fungible ERC-20 can be achieved by simply never using the [addBindings](#addbindings-function) function. -We considered **FKBTs** being used by every individual who wishes to add additional security to their fungible assets, as well as consignment to third-party wallets/brokers/banks/insurers. **FKBTs** allow tokens to be more resilient to attacks/thefts, by providing additional protection to the asset itself on a self-custodial level. +We considered **FKBTs** being used by every individual who wishes to add additional security to their fungible assets, as well as consignment to third-party wallets/brokers/banks/insurers. **FKBTs** are resilient to attacks/thefts, by providing additional protection to the asset itself on a self-custodial level. ## Motivation @@ -27,31 +27,31 @@ In this fast-paced technologically advancing world, people learn and mature at d From January 2021 through March 2022, the United States Federal Trade Commission received more than 46,000[^5] crypto scam reports. This directly impacted crypto users and resulted in a net consumer loss exceeding $1 Billion[^6]. Theft and malicious scams are an issue in any financial sector and oftentimes lead to stricter regulation. However, government-imposed regulation goes against one of this space’s core values. Efforts have been made to increase security within the space through centralized and decentralized means. Up until now, no one has offered a solution that holds onto the advantages of both whilst eliminating their disadvantages. -We asked ourselves the same question as many have in the past, “How does one protect the wallet?”. After a while, realizing the question that should be asked is “How does one protect the asset?”. Creating the wallet is free, the asset is what has value and is worth protecting. This question led to the development of **KBTs**. A solution that is fully optional and can be tailored so far as the user is concerned. Individual assets remain protected even if the seed phrase or private key is publicly released, as long as the security feature was activated. +We asked ourselves the same question as many have in the past, “How does one protect the wallet?”. After a while, realizing the question that should be asked is “How does one protect the asset?”. Creating the wallet is free, the asset is what has value and is worth protecting. This question led to the development of **KBT's**. A solution that is fully optional and can be tailored so far as the user is concerned. Individual assets remain protected even if the seed phrase or private key is publicly released, as long as the security feature was activated. -**FKBTs** saw the need to improve on the widely used fungible ERC-20 token standard. The security of fungible assets is a topic that concerns every entity in the crypto space, as their current and future use cases continue to be explored. **FKBTs** provide a scalable decentralized security solution that takes security one step beyond wallet security, focusing on the token's ability to remain secure. The security is on the blockchain itself, which allows every demographic that has access to the internet to secure their assets without the need for current hardware or centralized solutions. Made to be a promising alternative, **FKBTs** inherit all the characteristics of an ERC-20. This was done so **FKBTs** could be used on every dApp that is configured to use traditional fungible tokens. +**FKBTs** saw the need to improve on the widely used fungible ERC-20 token standard. The security of fungible assets is a topic that concerns every entity in the crypto space, as their current and future use cases are continuously explored. **FKBTs** provide a scalable decentralized security solution that takes security one step beyond wallet security, focusing on the token's ability to remain secure. The security is on the blockchain itself, which allows every demographic that has access to the internet to secure their assets without the need for current hardware or centralized solutions. Made to be a promising alternative, **FKBTs** inherit all the characteristics of an ERC-20. This was done so **FKBTs** could be used on every dApp that is configured to use traditional fungible tokens. -During the development process, the potential advantages **KBTs** explored were the main motivation factors leading to their creation; +During the development process, the potential advantages **KBT's** explored were the main motivation factors leading to their creation; 1. **Completely Decentralized:** The security features are fully decentralized meaning no third-party will have access to user funds when activated. This was done to truly stay in line with the premise of self-custodial assets, responsibility and values. -2. **Limitless Scalability:** Centralized solutions require the creation of an account and their availability may be restricted based on location. **FKBTs** do not face regional restrictions or account creation. Decentralized security solutions such as hardware options face scalability issues requiring transport logistics, secure shipping and vendor. **FKBTs** can be used anywhere around the world by anyone who so wishes, provided they have access to the internet. +2. **Limitless Scalability:** Centralized solutions require the creation of an account and their availability may be restricted based on location. **FKBT's** do not face regional restrictions or account creation. Decentralized security solutions such as hardware options face scalability issues requiring transport logistics, secure shipping and vendor. **FKBT's** can be used anywhere around the world by anyone who so wishes, provided they have access to the internet. -3. **Fully Optional Security:** Security features are optional, customizable and removable. It’s completely up to the user to decide the level of security they would like when using **FKBTs**. +3. **Fully Optional Security:** Security features are optional, customizable and removable. It’s completely up to the user to decide the level of security they would like when using **FKBT's**. -4. **Default Functionality:** If the user would like to use **FKBTs** as a traditional ERC-20, the security features do not have to be activated. As the token inherits all of the same characteristics, it results in the token acting with traditional fungible **Default Behaviors**[^4]. However, even when the security features are activated, the user will still have the ability to customize the functionality of the various features based on their desired outcome. The user can pass a set of custom and or **Default Values**[^7] manually or through a dApp. +4. **Default Functionality:** If the user would like to use **FKBT's** as a traditional ERC-20, the security features do not have to be activated. As the token inherits all of the same characteristics, it results in the token acting with traditional fungible **Default Behaviors**[^4]. However, even when the security features are activated, the user will still have the ability to customize the functionality of the various features based on their desired outcome. The user can pass a set of custom and or **Default Values**[^7] manually or through a dApp. -5. **Unmatched Security:** By calling the [addBindings](#addbindings-function) function a **Key Wallet**[^1] is now required for the [allowTransfer](#allowtransfer-function) or [allowApproval](#allowapproval-function) function. The [allowTransfer](#allowtransfer-function) function requires 4 parameters, `_amount`[^8], `_time`[^9], `_address`[^10], and `_allFunds`[^11], where as the [allowApproval](#allowapproval-function) function has 2 parameters, `_time`[^12] and `_numberOfTransfers`[^13]. In addition to this, **FKBTs** have a [safeFallback](#safefallback-function) and [resetBindings](#resetbindings-function) function. The combination of all these prevent and virtually cover every single point of failure that is present with a traditional ERC-20, when properly used. +5. **Unmatched Security:** By calling the [addBindings](#addbindings-function) function a **Key Wallet**[^1] is now required for the [allowTransfer](#allowtransfer-function) or [allowApproval](#allowapproval-function) function. The [allowTransfer](#allowtransfer-function) function requires 4 parameters, `_amount`[^8], `_time`[^9], `_address`[^10], and `_allFunds`[^11], where as the [allowApproval](#allowapproval-function) function has 2 parameters, `_time`[^12] and `_numberOfTransfers`[^13]. In addition to this, **FKBT's** have a [safeFallback](#safefallback-function) and [resetBindings](#resetbindings-function) function. The combination of all these prevent and virtually cover every single point of failure that is present with a traditional ERC-20, when properly used. -6. **Security Fail-Safes:** With **FKBTs**, users can be confident that their tokens are safe and secure, even if the **Holding Wallet**[^3] or one of the **Key Wallets**[^1] has been compromised. If the owner suspects that the **Holding Wallet** has been compromised or lost access, they can call the [safeFallback](#safefallback-function) function from one of the **Key Wallets**. This moves the assets to the other **Key Wallet** preventing a single point of failure. If the owner suspects that one of the **Key Wallets** has been comprised or lost access, the owner can call the [resetBindings](#resetbindings-function) function from `_keyWallet1`[^15] or `_keyWallet2`[^16]. This resets the **FKBTs** security feature and allows the **Holding Wallet** to call the [addBindings](#addbindings-function) function again. New **Key Wallets** can therefore be added and a single point of failure can be prevented. +6. **Security Fail-Safes:** With **FKBTs**, users can be confident that their tokens are safe and secure, even if the **Holding Wallet**[^3] or one of the **Key Wallets**[^1] has been compromised. If the owner suspects that the **Holding Wallet** has been compromised or lost access, they can call the [safeFallback](#safefallback-function) function from one of the **Key Wallets**. This moves the assets to the other **Key Wallet** preventing a single point of failure. If the owner suspects that one of the **Key Wallets** has been comprised or lost access, the owner can call the [resetBindings](#resetbindings-function) function from `_keyWallet1`[^15] or `_keyWallet2`[^16]. This resets the **FKBT's** security feature and allows the **Holding Wallet** to call the [addBindings](#addbindings-function) function again. New **Key Wallets** can therefore be added and a single point of failure can be prevented. -7. **Anonymous Security:** Frequently, centralized solutions ask for personal information that is stored and subject to prying eyes. Purchasing decentralized hardware solutions are susceptible to the same issues e.g. a shipping address, payment information, or a camera recording during a physical cash pick-up. This may be considered by some as infringing on their privacy and asset anonymity. **FKBTs** ensure user confidentially as everything can be done remotely under a pseudonym on the blockchain. +7. **Anonymous Security:** Frequently, centralized solutions ask for personal information that is stored and subject to prying eyes. Purchasing decentralized hardware solutions are susceptible to the same issues e.g. a shipping address, payment information, or a camera recording during a physical cash pick-up. This may be considered by some as infringing on their privacy and asset anonymity. **FKBT's** ensure user confidentially as everything can be done remotely under a pseudonym on the blockchain. -8. **Low-Cost Security:** The cost of using **FKBTs** security features correlate to on-chain fees, the current _GWEI_ at the given time. As a standalone solution, they are a viable cost-effective security measure feasible to the majority of the population. +8. **Low-Cost Security:** The cost of using **FKBT's** security features correlate to on-chain fees, the current _GWEI_ at the given time. As a standalone solution, they are a viable cost-effective security measure feasible to the majority of the population. -9. **Environmentally Friendly:** Since the security features are coded into the **FKBT**, there is no need for centralized servers, shipping, or the production of physical object/s. Thus leading to a minimal carbon footprint by the use of **FKBTs**, working hand in hand with Ethereum’s change to a _PoS_[^14] network. +9. **Environmentally Friendly:** Since the security features are coded into the **FKBT**, there is no need for centralized servers, shipping, or the production of physical object/s. Thus leading to a minimal carbon footprint by the use of **FKBT's**, working hand in hand with Ethereum’s change to a _PoS_[^14] network. -10. **User Experience:** The security feature can be activated by a simple call to the [addBindings](#addbindings-function) function. The user will only need two other wallets, which will act as `_keyWallet1`[^15] and `_keyWallet2`[^16], to gain access to all of the benefits **FKBTs** offer. The optional security features improve the overall user experience and Ethereum ecosystem by ensuring a safety net for those who decide to use it. Those that do not use the security features are not hindered in any way. This safety net can increase global adoption as people can remain confident in the security of their assets, even in the scenario of a compromised wallet. +10. **User Experience:** The security feature can be activated by a simple call to the [addBindings](#addbindings-function) function. The user will only need two other wallets, which will act as `_keyWallet1`[^15] and `_keyWallet2`[^16], to gain access to all of the benefits **FKBT's** offer. The optional security features improve the overall user experience and Ethereum ecosystem by ensuring a safety net for those who decide to use it. Those that do not use the security features are not hindered in any way. This safety net can increase global adoption as people can remain confident in the security of their assets, even in the scenario of a compromised wallet. ## Specification @@ -424,13 +424,13 @@ function transferFrom(address _from, address _to, uint256 _amount) external retu ## Rationale -The intent from individual technical decisions made during the development of **FKBTs** focused on maintaining consistency and backward compatibility with ERC-20s, all the while offering self-custodial security features to the user. It was important that **FKBTs** inherited all of ERC-20s characteristics to comply with requirements found in dApps which use fungible tokens on their platform. In doing so, it allowed for flawless backward compatibility to take place and gave the user the choice to decide if they want their **FKBTs** to act with **Default Behaviors**[^4]. We wanted to ensure that wide-scale implementation and adoption of **FKBTs** could take place immediately, without the greater collective needing to adapt and make changes to the already flourishing decentralized ecosystem. +The intent from individual technical decisions made during the development of **FKBTs** focused on maintaining consistency and backward compatibility with ERC-20s, all the while offering self-custodial security features to the user. It was important that **FKBT's** inherited all of ERC-20s characteristics to comply with requirements found in dApps which use fungible tokens on their platform. In doing so, it allowed for flawless backward compatibility to take place and gave the user the choice to decide if they want their **FKBTs** to act with **Default Behaviors**[^4]. We wanted to ensure that wide-scale implementation and adoption of **FKBTs** could take place immediately, without the greater collective needing to adapt and make changes to the already flourishing decentralized ecosystem. For developers and users alike, the [allowTransfer](#allowtransfer-function) and [allowApproval](#allowapproval-function) functions both return bools on success and revert on failures. This decision was done purposefully, to keep consistency with the already familiar ERC-20. Additional technical decisions related to self-custodial security features are broken down and located within the [Security Considerations](#security-considerations) section. ## Backwards Compatibility -**KBTs** are designed to be backward-compatible with existing token standards and wallets. Existing tokens and wallets will continue to function as normal, and will not be affected by the implementation of **FKBTs**. +**KBT's** are designed to be backward-compatible with existing token standards and wallets. Existing tokens and wallets will continue to function as normal, and will not be affected by the implementation of **FKBT's**. ## Test Cases @@ -450,41 +450,41 @@ The implementation is located in the [assets](../assets/eip-6808/README.md) dire ## Security Considerations -**FKBTs** were designed with security in mind every step of the way. Below are some design decisions that were rigorously discussed and thought through during the development process. +**FKBT's** were designed with security in mind every step of the way. Below are some design decisions that were rigorously discussed and thought through during the development process. -**Key Wallets**[^1]: When calling the [addBindings](#addbindings-function) function for an **FKBT**, the user must input 2 wallets that will then act as `_keyWallet1`[^15] and `_keyWallet2`[^16]. They are added simultaneously to reduce user fees, minimize the chance of human error and prevent a pitfall scenario. If the user had the ability to add multiple wallets it would not only result in additional fees and avoidable confusion but would enable a potentially disastrous [safeFallback](#safefallback-function) situation to occur. For this reason, all **KBTs** work under a 3-wallet system when security features are activated. +**Key Wallets**[^1]: When calling the [addBindings](#addbindings-function) function for an **FKBT**, the user must input 2 wallets that will then act as `_keyWallet1`[^15] and `_keyWallet2`[^16]. They are added simultaneously to reduce user fees, minimize the chance of human error and prevent a pitfall scenario. If the user had the ability to add multiple wallets it would not only result in additional fees and avoidable confusion but would enable a potentially disastrous [safeFallback](#safefallback-function) situation to occur. For this reason, all **KBT's** work under a 3-wallet system when security features are activated. -Typically if a wallet is compromised, the fungible assets within are at risk. With **FKBTs** there are two different functions that can be called from a **Key Wallet**[^1] depending on which wallet has been compromised. +Typically if a wallet is compromised, the fungible assets within are at risk. With **FKBT's** there are two different functions that can be called from a **Key Wallet**[^1] depending on which wallet has been compromised. Scenario: **Holding Wallet**[^3] has been compromised, call [safeFallback](#safefallback-function). -[safeFallback](#safefallback-function): This function was created in the event that the owner believes the **Holding Wallet**[^3] has been compromised. It can also be used if the owner losses access to the **Holding Wallet**. In this scenario, the user has the ability to call [safeFallback](#safefallback-function) from one of the **Key Wallets**[^1]. **FKBTs** are then redirected from the **Holding Wallet** to the other **Key Wallet**. +[safeFallback](#safefallback-function): This function was created in the event that the owner believes the **Holding Wallet**[^3] has been compromised. It can also be used if the owner losses access to the **Holding Wallet**. In this scenario, the user has the ability to call [safeFallback](#safefallback-function) from one of the **Key Wallets**[^1]. **FKBT's** are then redirected from the **Holding Wallet** to the other **Key Wallet**. -By redirecting the **FKBTs** it prevents a single point of failure. If an attacker were to call [safeFallback](#safefallback-function) and the **FKBTs** redirected to the **Key Wallet**[^1] that called the function, they would gain access to all the **FKBTs**. +By redirecting the **FKBT's** it prevents a single point of failure. If an attacker were to call [safeFallback](#safefallback-function) and the **FKBT's** redirected to the **Key Wallet**[^1] that called the function, they would gain access to all the **FKBT's**. Scenario: **Key Wallet**[^1] has been compromised, call [resetBindings](#resetbindings-function). -[resetBindings](#resetbindings-function): This function was created in the event that the owner believes `_keyWallet1`[^15] or `_keyWallet2`[^16] has been compromised. It can also be used if the owner losses access to one of the **Key Wallets**[^1]. In this instance, the user has the ability to call [resetBindings](#resetbindings-function), removing the bound **Key Wallets** and resetting the security features. The **FKBTs** will now function as a traditional ERC-20 until [addBindings](#addbindings-function) is called again and a new set of **Key Wallets** are added. +[resetBindings](#resetbindings-function): This function was created in the event that the owner believes `_keyWallet1`[^15] or `_keyWallet2`[^16] has been compromised. It can also be used if the owner losses access to one of the **Key Wallets**[^1]. In this instance, the user has the ability to call [resetBindings](#resetbindings-function), removing the bound **Key Wallets** and resetting the security features. The **FKBT's** will now function as a traditional ERC-20 until [addBindings](#addbindings-function) is called again and a new set of **Key Wallets** are added. -The reason why `_keyWallet1`[^15] or `_keyWallet2`[^16] are required to call the [resetBindings](#resetbindings-function) function is because a **Holding Wallet**[^3] having the ability to call [resetBindings](#resetbindings-function) could result in an immediate loss of **FKBTs**. The attacker would only need to gain access to the **Holding Wallet** and call [resetBindings](#resetbindings-function). +The reason why `_keyWallet1`[^15] or `_keyWallet2`[^16] are required to call the [resetBindings](#resetbindings-function) function is because a **Holding Wallet**[^3] having the ability to call [resetBindings](#resetbindings-function) could result in an immediate loss of **FKBT's**. The attacker would only need to gain access to the **Holding Wallet** and call [resetBindings](#resetbindings-function). -In the scenario that 2 of the 3 wallets have been compromised, there is nothing the owner of the **FKBTs** can do if the attack is malicious. However, by allowing 1 wallet to be compromised, holders of fungible tokens built using the **FKBT** standard are given a second chance, unlike other current standards. +In the scenario that 2 of the 3 wallets have been compromised, there is nothing the owner of the **FKBT's** can do if the attack is malicious. However, by allowing 1 wallet to be compromised, holders of fungible tokens built using the **FKBT** standard are given a second chance, unlike other current standards. -The [allowTransfer](#allowtransfer-function) function is in place to guarantee a **Safe Transfer**[^2], but can also have **Default Values**[^7] set by a dApp to emulate **Default Behaviors**[^3] of a traditional ERC-20. It enables the user to highly specify the type of transfer they are about to conduct, whilst simultaneously allowing the user to unlock all the **FKBTs** to anyone for an unlimited amount of time. The desired security is completely up to the user. +The [allowTransfer](#allowtransfer-function) function is in place to guarantee a **Safe Transfer**[^2], but can also have **Default Values**[^7] set by a dApp to emulate **Default Behaviors**[^3] of a traditional ERC-20. It enables the user to highly specify the type of transfer they are about to conduct, whilst simultaneously allowing the user to unlock all the **FKBT's** to anyone for an unlimited amount of time. The desired security is completely up to the user. This function requires 4 parameters to be filled and different combinations of these result in different levels of security; -Parameter 1 `_amount`[^8]: This is the number of **FKBTs** that will be spent on a transfer. +Parameter 1 `_amount`[^8]: This is the number of **FKBT's** that will be spent on a transfer. -Parameter 2 `_time`[^9]: The number of blocks the **FKBTs** can be transferred starting from the current block timestamp. +Parameter 2 `_time`[^9]: The number of blocks the **FKBT's** can be transferred starting from the current block timestamp. -Parameter 3 `_address`[^10]: The destination the **FKBTs** will be sent to. +Parameter 3 `_address`[^10]: The destination the **FKBT's** will be sent to. Parameter 4 `_allFunds`[^11]: This is a boolean value. When false, the `transfer` function takes into consideration Parameters 1, 2 and 3. If the value is true, the `transfer` function will revert to a **Default Behavior**[^4], the same as a traditional ERC-20. The [allowTransfer](#allowtransfer-function) function requires `_keyWallet1`[^15] or `_keyWallet2`[^16] and enables the **Holding Wallet**[^3] to conduct a `transfer` within the previously specified parameters. These parameters were added in order to provide additional security by limiting the **Holding Wallet** in case it was compromised without the user's knowledge. -The [allowApproval](#allowapproval-function) function provides extra security when allowing on-chain third parties to use your **FKBTs** on your behalf. This is especially useful when a user is met with common malicious attacks e.g. draining dApp. +The [allowApproval](#allowapproval-function) function provides extra security when allowing on-chain third parties to use your **FKBT's** on your behalf. This is especially useful when a user is met with common malicious attacks e.g. draining dApp. This function requires 2 parameters to be filled and different combinations of these result in different levels of security; @@ -500,15 +500,15 @@ Copyright and related rights waived via [CC0](../LICENSE.md). [^1]: The **Key Wallet/s** refers to `_keyWallet1` or `_keyWallet2` which can call the `safeFallback`, `resetBindings`, `allowTransfer` and `allowApproval` functions. -[^2]: A **Safe Transfer** is when 1 of the **Key Wallets** safely approved the use of the **FKBTs**. -[^3]: The **Holding Wallet** refers to the wallet containing the **FKBTs**. +[^2]: A **Safe Transfer** is when 1 of the **Key Wallets** safely approved the use of the **FKBT's**. +[^3]: The **Holding Wallet** refers to the wallet containing the **FKBT's**. [^4]: A **Default Behavior/s** refers to behavior/s present in the preexisting non-fungible ERC-20 standard. [^5]: The number of crypto scam reports the United States Federal Trade Commission received, from January 2021 through March 2022. [^6]: The amount stolen via crypto scams according to the United States Federal Trade Commission, from January 2021 through March 2022. [^7]: A **Default Value/s** refer to a value/s that emulates the non-fungible ERC-20 **Default Behavior/s**. -[^8]: The `_amount` represents the amount of the **FKBTs** intended to be spent. +[^8]: The `_amount` represents the amount of the **FKBT's** intended to be spent. [^9]: The `_time` in `allowTransfer` represents the number of blocks a `transfer` can take place in. -[^10]: The `_address` represents the address that the **FKBTs** will be sent to. +[^10]: The `_address` represents the address that the **FKBT's** will be sent to. [^11]: The `_allFunds` is a bool that can be set to true or false. [^12]: The `_time` in `allowApproval` represents the number of blocks an `approve` can take place in. [^13]: The `_numberOfTransfers` is the number of transfers a third-party entity can conduct via `transfer` on the user's behalf. From 98d3bdde79ba2bcb6efc172745ebb5575541d614 Mon Sep 17 00:00:00 2001 From: NarcisCRO <122120404+NarcisCRO@users.noreply.github.com> Date: Tue, 30 May 2023 18:04:14 +0300 Subject: [PATCH 31/97] Update EIP-6809: Move to Review Merged by EIP-Bot. --- EIPS/eip-6809.md | 62 ++++++++++++++++++++++++------------------------ 1 file changed, 31 insertions(+), 31 deletions(-) diff --git a/EIPS/eip-6809.md b/EIPS/eip-6809.md index b642cc4e8a7de3..e0e5cea7361d6f 100644 --- a/EIPS/eip-6809.md +++ b/EIPS/eip-6809.md @@ -1,10 +1,10 @@ --- eip: 6809 title: Non-Fungible Key Bound Token -description: An interface for Non-Fungible Key Bound Tokens, also known as an NFKBT. +description: An interface for Non-Fungible Key Bound Tokens, also known as a NFKBT. author: Mihai Onila (@MihaiORO), Nick Zeman (@NickZCZ), Narcis Cotaie (@NarcisCRO) discussions-to: https://ethereum-magicians.org/t/non-fungible-key-bound-token-kbt/13625 -status: Draft +status: Review type: Standards Track category: ERC created: 2023-03-31 @@ -15,11 +15,11 @@ requires: 721 A standard interface for Non-Fungible Key Bound Tokens (**NFKBT/s**), a subset of the more general Key Bound Tokens (**KBT/s**). -The following standardizes an API for tokens within smart contracts and provides basic functionality to the [addBindings](#addbindings-function) function. This function designates **Key Wallets**[^1], which are responsible for conducting a **Safe Transfer**[^2]. During this process, **NFKBTs** are safely approved so they can be spent by the user or an on-chain third-party entity. +The following standardizes an API for tokens within smart contracts and provides basic functionality to the [addBindings](#addbindings-function) function. This function designates **Key Wallets**[^1], which are responsible for conducting a **Safe Transfer**[^2]. During this process, **NFKBT's** are safely approved so they can be spent by the user or an on-chain third-party entity. -The premise of **NFKBTs** is to provide fully optional security features built directly into the non-fungible asset, via the concept of _allow_ found in the [allowTransfer](#allowtransfer-function) and [allowApproval](#allowapproval-function) functions. These functions are called by one of the **Key Wallets**[^1] and _allow_ the **Holding Wallet**[^3] to either call the already familiar `transferFrom` and `approve` function found in [ERC-721](./eip-721.md). Responsibility for the **NFKBT** is therefore split. The **Holding Wallet** contains the asset and **Key Wallets** have authority over how the assets can be spent or approved. **Default Behaviors**[^4] of a traditional non-fungible ERC-721 can be achieved by simply never using the [addBindings](#addbindings-function) function. +The premise of **NFKBT's** is to provide fully optional security features built directly into the non-fungible asset, via the concept of _allow_ found in the [allowTransfer](#allowtransfer-function) and [allowApproval](#allowapproval-function) functions. These functions are called by one of the **Key Wallets**[^1] and _allow_ the **Holding Wallet**[^3] to either call the already familiar `transferFrom` and `approve` function found in [ERC-721](./eip-721.md). Responsibility for the **NFKBT** is therefore split. The **Holding Wallet** contains the asset and **Key Wallets** have authority over how the assets can be spent or approved. **Default Behaviors**[^4] of a traditional non-fungible ERC-721 can be achieved by simply never using the [addBindings](#addbindings-function) function. -We considered **NFKBTs** being used by every individual who wishes to add additional security to their non-fungible assets, as well as consignment to third-party wallets/brokers/banks/insurers/museums. **NFKBTs** allow tokens to be more resilient to attacks/thefts, by providing additional protection to the asset itself on a self-custodial level. +We considered **NFKBTs** being used by every individual who wishes to add additional security to their non-fungible assets, as well as consignment to third-party wallets/brokers/banks/insurers/galleries. **NFKBTs** are resilient to attacks/thefts, by providing additional protection to the asset itself on a self-custodial level. ## Motivation @@ -27,31 +27,31 @@ In this fast-paced technologically advancing world, people learn and mature at d From January 2021 through March 2022, the United States Federal Trade Commission received more than 46,000[^5] crypto scam reports. This directly impacted crypto users and resulted in a net consumer loss exceeding $1 Billion[^6]. Theft and malicious scams are an issue in any financial sector and oftentimes lead to stricter regulation. However, government-imposed regulation goes against one of this space’s core values. Efforts have been made to increase security within the space through centralized and decentralized means. Up until now, no one has offered a solution that holds onto the advantages of both whilst eliminating their disadvantages. -We asked ourselves the same question as many have in the past, “How does one protect the wallet?”. After a while, realizing the question that should be asked is “How does one protect the asset?”. Creating the wallet is free, the asset is what has value and is worth protecting. This question led to the development of **KBTs**. A solution that is fully optional and can be tailored so far as the user is concerned. Individual assets remain protected even if the seed phrase or private key is publicly released, as long as the security feature was activated. +We asked ourselves the same question as many have in the past, “How does one protect the wallet?”. After a while, realizing the question that should be asked is “How does one protect the asset?”. Creating the wallet is free, the asset is what has value and is worth protecting. This question led to the development of **KBT's**. A solution that is fully optional and can be tailored so far as the user is concerned. Individual assets remain protected even if the seed phrase or private key is publicly released, as long as the security feature was activated. -**NFKBTs** saw the need to improve on the widely used non-fungible ERC-721 token standard. The security of non-fungible assets is a topic that concerns every entity in the crypto space, as their current and future use cases continue to be explored. **NFKBTs** provide a scalable decentralized security solution that takes security one step beyond wallet security, focusing on the token's ability to remain secure. The security is on the blockchain itself, which allows every demographic that has access to the internet to secure their assets without the need for current hardware or centralized solutions. Made to be a promising alternative, **NFKBTs** inherit all the characteristics of an ERC-721. This was done so **NFKBTs** could be used on every dApp that is configured to use traditional non-fungible tokens. +**NFKBTs** saw the need to improve on the widely used non-fungible ERC-721 token standard. The security of non-fungible assets is a topic that concerns every entity in the crypto space, as their current and future use cases are continuously explored. **NFKBTs** provide a scalable decentralized security solution that takes security one step beyond wallet security, focusing on the token's ability to remain secure. The security is on the blockchain itself, which allows every demographic that has access to the internet to secure their assets without the need for current hardware or centralized solutions. Made to be a promising alternative, **NFKBTs** inherit all the characteristics of an ERC-721. This was done so **NFKBTs** could be used on every dApp that is configured to use traditional non-fungible tokens. -During the development process, the potential advantages **KBTs** explored were the main motivation factors leading to their creation; +During the development process, the potential advantages **KBT's** explored were the main motivation factors leading to their creation; 1. **Completely Decentralized:** The security features are fully decentralized meaning no third-party will have access to user funds when activated. This was done to truly stay in line with the premise of self-custodial assets, responsibility and values. -2. **Limitless Scalability:** Centralized solutions require the creation of an account and their availability may be restricted based on location. **NFKBTs** do not face regional restrictions or account creation. Decentralized security solutions such as hardware options face scalability issues requiring transport logistics, secure shipping and vendor. **NFKBTs** can be used anywhere around the world by anyone who so wishes, provided they have access to the internet. +2. **Limitless Scalability:** Centralized solutions require the creation of an account and their availability may be restricted based on location. **NFKBT's** do not face regional restrictions or account creation. Decentralized security solutions such as hardware options face scalability issues requiring transport logistics, secure shipping and vendor. **NFKBT's** can be used anywhere around the world by anyone who so wishes, provided they have access to the internet. -3. **Fully Optional Security:** Security features are optional, customizable and removable. It’s completely up to the user to decide the level of security they would like when using **NFKBTs**. +3. **Fully Optional Security:** Security features are optional, customizable and removable. It’s completely up to the user to decide the level of security they would like when using **NFKBT's**. -4. **Default Functionality:** If the user would like to use **NFKBTs** as a traditional ERC-721, the security features do not have to be activated. As the token inherits all of the same characteristics, it results in the token acting with traditional non-fungible **Default Behaviors**[^4]. However, even when the security features are activated, the user will still have the ability to customize the functionality of the various features based on their desired outcome. The user can pass a set of custom and or **Default Values**[^7] manually or through a dApp. +4. **Default Functionality:** If the user would like to use **NFKBT's** as a traditional ERC-721, the security features do not have to be activated. As the token inherits all of the same characteristics, it results in the token acting with traditional non-fungible **Default Behaviors**[^4]. However, even when the security features are activated, the user will still have the ability to customize the functionality of the various features based on their desired outcome. The user can pass a set of custom and or **Default Values**[^7] manually or through a dApp. -5. **Unmatched Security:** By calling the [addBindings](#addbindings-function) function a **Key Wallet**[^1] is now required for the [allowTransfer](#allowtransfer-function) or [allowApproval](#allowapproval-function) function. The [allowTransfer](#allowtransfer-function) function requires 4 parameters, `_tokenId`[^8], `_time`[^9], `_address`[^10], and `_anyToken`[^11], where as the [allowApproval](#allowapproval-function) function has 2 parameters, `_time`[^12] and `_numberOfTransfers`[^13]. In addition to this, **NFKBTs** have a [safeFallback](#safefallback-function) and [resetBindings](#resetbindings-function) function. The combination of all these prevent and virtually cover every single point of failure that is present with a traditional ERC-721, when properly used. +5. **Unmatched Security:** By calling the [addBindings](#addbindings-function) function a **Key Wallet**[^1] is now required for the [allowTransfer](#allowtransfer-function) or [allowApproval](#allowapproval-function) function. The [allowTransfer](#allowtransfer-function) function requires 4 parameters, `_tokenId`[^8], `_time`[^9], `_address`[^10], and `_anyToken`[^11], where as the [allowApproval](#allowapproval-function) function has 2 parameters, `_time`[^12] and `_numberOfTransfers`[^13]. In addition to this, **NFKBT's** have a [safeFallback](#safefallback-function) and [resetBindings](#resetbindings-function) function. The combination of all these prevent and virtually cover every single point of failure that is present with a traditional ERC-721, when properly used. -6. **Security Fail-Safes:** With **NFKBTs**, users can be confident that their tokens are safe and secure, even if the **Holding Wallet**[^3] or one of the **Key Wallets**[^1] has been compromised. If the owner suspects that the **Holding Wallet** has been compromised or lost access, they can call the [safeFallback](#safefallback-function) function from one of the **Key Wallets**. This moves the assets to the other **Key Wallet** preventing a single point of failure. If the owner suspects that one of the **Key Wallets** has been comprised or lost access, the owner can call the [resetBindings](#resetbindings-function) function from `_keyWallet1`[^15] or `_keyWallet2`[^16]. This resets the **NFKBTs** security feature and allows the **Holding Wallet** to call the [addBindings](#addbindings-function) function again. New **Key Wallets** can therefore be added and a single point of failure can be prevented. +6. **Security Fail-Safes:** With **NFKBTs**, users can be confident that their tokens are safe and secure, even if the **Holding Wallet**[^3] or one of the **Key Wallets**[^1] has been compromised. If the owner suspects that the **Holding Wallet** has been compromised or lost access, they can call the [safeFallback](#safefallback-function) function from one of the **Key Wallets**. This moves the assets to the other **Key Wallet** preventing a single point of failure. If the owner suspects that one of the **Key Wallets** has been comprised or lost access, the owner can call the [resetBindings](#resetbindings-function) function from `_keyWallet1`[^15] or `_keyWallet2`[^16]. This resets the **NFKBT's** security feature and allows the **Holding Wallet** to call the [addBindings](#addbindings-function) function again. New **Key Wallets** can therefore be added and a single point of failure can be prevented. -7. **Anonymous Security:** Frequently, centralized solutions ask for personal information that is stored and subject to prying eyes. Purchasing decentralized hardware solutions are susceptible to the same issues e.g. a shipping address, payment information, or a camera recording during a physical cash pick-up. This may be considered by some as infringing on their privacy and asset anonymity. **NFKBTs** ensure user confidentially as everything can be done remotely under a pseudonym on the blockchain. +7. **Anonymous Security:** Frequently, centralized solutions ask for personal information that is stored and subject to prying eyes. Purchasing decentralized hardware solutions are susceptible to the same issues e.g. a shipping address, payment information, or a camera recording during a physical cash pick-up. This may be considered by some as infringing on their privacy and asset anonymity. **NFKBT's** ensure user confidentially as everything can be done remotely under a pseudonym on the blockchain. -8. **Low-Cost Security:** The cost of using **NFKBTs** security features correlate to on-chain fees, the current _GWEI_ at the given time. As a standalone solution, they are a viable cost-effective security measure feasible to the majority of the population. +8. **Low-Cost Security:** The cost of using **NFKBT's** security features correlate to on-chain fees, the current _GWEI_ at the given time. As a standalone solution, they are a viable cost-effective security measure feasible to the majority of the population. -9. **Environmentally Friendly:** Since the security features are coded into the **NFKBT**, there is no need for centralized servers, shipping, or the production of physical object/s. Thus leading to a minimal carbon footprint by the use of **NFKBTs**, working hand in hand with Ethereum’s change to a _PoS_[^14] network. +9. **Environmentally Friendly:** Since the security features are coded into the **NFKBT**, there is no need for centralized servers, shipping, or the production of physical object/s. Thus leading to a minimal carbon footprint by the use of **NFKBT's**, working hand in hand with Ethereum’s change to a _PoS_[^14] network. -10. **User Experience:** The security feature can be activated by a simple call to the [addBindings](#addbindings-function) function. The user will only need two other wallets, which will act as `_keyWallet1`[^15] and `_keyWallet2`[^16], to gain access to all of the benefits **NFKBTs** offer. The optional security features improve the overall user experience and Ethereum ecosystem by ensuring a safety net for those who decide to use it. Those that do not use the security features are not hindered in any way. This safety net can increase global adoption as people can remain confident in the security of their assets, even in the scenario of a compromised wallet. +10. **User Experience:** The security feature can be activated by a simple call to the [addBindings](#addbindings-function) function. The user will only need two other wallets, which will act as `_keyWallet1`[^15] and `_keyWallet2`[^16], to gain access to all of the benefits **NFKBT's** offer. The optional security features improve the overall user experience and Ethereum ecosystem by ensuring a safety net for those who decide to use it. Those that do not use the security features are not hindered in any way. This safety net can increase global adoption as people can remain confident in the security of their assets, even in the scenario of a compromised wallet. ## Specification @@ -425,13 +425,13 @@ function setApprovalForAll(address _operator, bool _approved) public virtual ove ## Rationale -The intent from individual technical decisions made during the development of **NFKBTs** focused on maintaining consistency and backward compatibility with ERC-721s, all the while offering self-custodial security features to the user. It was important that **NFKBTs** inherited all of ERC-721s characteristics to comply with requirements found in dApps which use non-fungible tokens on their platform. In doing so, it allowed for flawless backward compatibility to take place and gave the user the choice to decide if they want their **NFKBTs** to act with **Default Behaviors**[^4]. We wanted to ensure that wide-scale implementation and adoption of **NFKBTs** could take place immediately, without the greater collective needing to adapt and make changes to the already flourishing decentralized ecosystem. +The intent from individual technical decisions made during the development of **NFKBTs** focused on maintaining consistency and backward compatibility with ERC-721s, all the while offering self-custodial security features to the user. It was important that **NFKBT's** inherited all of ERC-721s characteristics to comply with requirements found in dApps which use non-fungible tokens on their platform. In doing so, it allowed for flawless backward compatibility to take place and gave the user the choice to decide if they want their **NFKBTs** to act with **Default Behaviors**[^4]. We wanted to ensure that wide-scale implementation and adoption of **NFKBTs** could take place immediately, without the greater collective needing to adapt and make changes to the already flourishing decentralized ecosystem. For developers and users alike, the [allowTransfer](#allowtransfer-function) and [allowApproval](#allowapproval-function) functions both return bools on success and revert on failures. This decision was done purposefully, to keep consistency with the already familiar ERC-721. Additional technical decisions related to self-custodial security features are broken down and located within the [Security Considerations](#security-considerations) section. ## Backwards Compatibility -**KBTs** are designed to be backward-compatible with existing token standards and wallets. Existing tokens and wallets will continue to function as normal, and will not be affected by the implementation of **NFKBTs**. +**KBT's** are designed to be backward-compatible with existing token standards and wallets. Existing tokens and wallets will continue to function as normal, and will not be affected by the implementation of **NFKBT's**. ## Test Cases @@ -451,27 +451,27 @@ The implementation is located in the [assets](../assets/eip-6809/README.md) dire ## Security Considerations -**NFKBTs** were designed with security in mind every step of the way. Below are some design decisions that were rigorously discussed and thought through during the development process. +**NFKBT's** were designed with security in mind every step of the way. Below are some design decisions that were rigorously discussed and thought through during the development process. -**Key Wallets**[^1]: When calling the [addBindings](#addbindings-function) function for an **NFKBT**, the user must input 2 wallets that will then act as `_keyWallet1`[^15] and `_keyWallet2`[^16]. They are added simultaneously to reduce user fees, minimize the chance of human error and prevent a pitfall scenario. If the user had the ability to add multiple wallets it would not only result in additional fees and avoidable confusion but would enable a potentially disastrous [safeFallback](#safefallback-function) situation to occur. For this reason, all **KBTs** work under a 3-wallet system when security features are activated. +**Key Wallets**[^1]: When calling the [addBindings](#addbindings-function) function for an **NFKBT**, the user must input 2 wallets that will then act as `_keyWallet1`[^15] and `_keyWallet2`[^16]. They are added simultaneously to reduce user fees, minimize the chance of human error and prevent a pitfall scenario. If the user had the ability to add multiple wallets it would not only result in additional fees and avoidable confusion but would enable a potentially disastrous [safeFallback](#safefallback-function) situation to occur. For this reason, all **KBT's** work under a 3-wallet system when security features are activated. -Typically if a wallet is compromised, the non-fungible assets within are at risk. With **NFKBTs** there are two different functions that can be called from a **Key Wallet**[^1] depending on which wallet has been compromised. +Typically if a wallet is compromised, the non-fungible assets within are at risk. With **NFKBT's** there are two different functions that can be called from a **Key Wallet**[^1] depending on which wallet has been compromised. Scenario: **Holding Wallet**[^3] has been compromised, call [safeFallback](#safefallback-function). -[safeFallback](#safefallback-function): This function was created in the event that the owner believes the **Holding Wallet**[^3] has been compromised. It can also be used if the owner losses access to the **Holding Wallet**. In this scenario, the user has the ability to call [safeFallback](#safefallback-function) from one of the **Key Wallets**[^1]. **NFKBTs** are then redirected from the **Holding Wallet** to the other **Key Wallet**. +[safeFallback](#safefallback-function): This function was created in the event that the owner believes the **Holding Wallet**[^3] has been compromised. It can also be used if the owner losses access to the **Holding Wallet**. In this scenario, the user has the ability to call [safeFallback](#safefallback-function) from one of the **Key Wallets**[^1]. **NFKBT's** are then redirected from the **Holding Wallet** to the other **Key Wallet**. -By redirecting the **NFKBTs** it prevents a single point of failure. If an attacker were to call [safeFallback](#safefallback-function) and the **NFKBTs** redirected to the **Key Wallet**[^1] that called the function, they would gain access to all the **NFKBTs**. +By redirecting the **NFKBT's** it prevents a single point of failure. If an attacker were to call [safeFallback](#safefallback-function) and the **NFKBT's** redirected to the **Key Wallet**[^1] that called the function, they would gain access to all the **NFKBT's**. Scenario: **Key Wallet**[^1] has been compromised, call [resetBindings](#resetbindings-function). -[resetBindings](#resetbindings-function): This function was created in the event that the owner believes `_keyWallet1`[^15] or `_keyWallet2`[^16] has been compromised. It can also be used if the owner losses access to one of the **Key Wallets**[^1]. In this instance, the user has the ability to call [resetBindings](#resetbindings-function), removing the bound **Key Wallets** and resetting the security features. The **NFKBTs** will now function as a traditional ERC-721 until [addBindings](#addbindings-function) is called again and a new set of **Key Wallets** are added. +[resetBindings](#resetbindings-function): This function was created in the event that the owner believes `_keyWallet1`[^15] or `_keyWallet2`[^16] has been compromised. It can also be used if the owner losses access to one of the **Key Wallets**[^1]. In this instance, the user has the ability to call [resetBindings](#resetbindings-function), removing the bound **Key Wallets** and resetting the security features. The **NFKBT's** will now function as a traditional ERC-721 until [addBindings](#addbindings-function) is called again and a new set of **Key Wallets** are added. -The reason why `_keyWallet1`[^15] or `_keyWallet2`[^16] are required to call the [resetBindings](#resetbindings-function) function is because a **Holding Wallet**[^3] having the ability to call [resetBindings](#resetbindings-function) could result in an immediate loss of **NFKBTs**. The attacker would only need to gain access to the **Holding Wallet** and call [resetBindings](#resetbindings-function). +The reason why `_keyWallet1`[^15] or `_keyWallet2`[^16] are required to call the [resetBindings](#resetbindings-function) function is because a **Holding Wallet**[^3] having the ability to call [resetBindings](#resetbindings-function) could result in an immediate loss of **NFKBT's**. The attacker would only need to gain access to the **Holding Wallet** and call [resetBindings](#resetbindings-function). -In the scenario that 2 of the 3 wallets have been compromised, there is nothing the owner of the **NFKBTs** can do if the attack is malicious. However, by allowing 1 wallet to be compromised, holders of non-fungible tokens built using the **NFKBT** standard are given a second chance, unlike other current standards. +In the scenario that 2 of the 3 wallets have been compromised, there is nothing the owner of the **NFKBT's** can do if the attack is malicious. However, by allowing 1 wallet to be compromised, holders of non-fungible tokens built using the **NFKBT** standard are given a second chance, unlike other current standards. -The [allowTransfer](#allowtransfer-function) function is in place to guarantee a **Safe Transfer**[^2], but can also have **Default Values**[^7] set by a dApp to emulate **Default Behaviors**[^3] of a traditional ERC-721. It enables the user to highly specify the type of transfer they are about to conduct, whilst simultaneously allowing the user to unlock all the **NFKBTs** to anyone for an unlimited amount of time. The desired security is completely up to the user. +The [allowTransfer](#allowtransfer-function) function is in place to guarantee a **Safe Transfer**[^2], but can also have **Default Values**[^7] set by a dApp to emulate **Default Behaviors**[^3] of a traditional ERC-721. It enables the user to highly specify the type of transfer they are about to conduct, whilst simultaneously allowing the user to unlock all the **NFKBT's** to anyone for an unlimited amount of time. The desired security is completely up to the user. This function requires 4 parameters to be filled and different combinations of these result in different levels of security; @@ -485,7 +485,7 @@ Parameter 4 `_anyToken`[^11]: This is a boolean value. When false, the `transfer The [allowTransfer](#allowtransfer-function) function requires `_keyWallet1`[^15] or `_keyWallet2`[^16] and enables the **Holding Wallet**[^3] to conduct a `transferFrom` within the previously specified parameters. These parameters were added in order to provide additional security by limiting the **Holding Wallet** in case it was compromised without the user's knowledge. -The [allowApproval](#allowapproval-function) function provides extra security when allowing on-chain third parties to use your **NFKBTs** on your behalf. This is especially useful when a user is met with common malicious attacks e.g. draining dApp. +The [allowApproval](#allowapproval-function) function provides extra security when allowing on-chain third parties to use your **NFKBT's** on your behalf. This is especially useful when a user is met with common malicious attacks e.g. draining dApp. This function requires 2 parameters to be filled and different combinations of these result in different levels of security; @@ -500,8 +500,8 @@ The [allowApproval](#allowapproval-function) function requires `_keyWallet1`[^15 Copyright and related rights waived via [CC0](../LICENSE.md). [^1]: The **Key Wallet/s** refers to `_keyWallet1` or `_keyWallet2` which can call the `safeFallback`, `resetBindings`, `allowTransfer` and `allowApproval` functions. -[^2]: A **Safe Transfer** is when 1 of the **Key Wallets** safely approved the use of the **NFKBTs**. -[^3]: The **Holding Wallet** refers to the wallet containing the **NFKBTs**. +[^2]: A **Safe Transfer** is when 1 of the **Key Wallets** safely approved the use of the **NFKBT's**. +[^3]: The **Holding Wallet** refers to the wallet containing the **NFKBT's**. [^4]: A **Default Behavior/s** refers to behavior/s present in the preexisting non-fungible ERC-721 standard. [^5]: The number of crypto scam reports the United States Federal Trade Commission received, from January 2021 through March 2022. [^6]: The amount stolen via crypto scams according to the United States Federal Trade Commission, from January 2021 through March 2022. From 63520161b52d67f4fd1d5d83d467daaf576a29e7 Mon Sep 17 00:00:00 2001 From: Jessica Chang <117890123+JessicaChg@users.noreply.github.com> Date: Tue, 30 May 2023 23:05:11 +0800 Subject: [PATCH 32/97] Add EIP: Semantic Soulbound Tokens Merged by EIP-Bot. --- EIPS/eip-6239.md | 302 +++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 302 insertions(+) create mode 100644 EIPS/eip-6239.md diff --git a/EIPS/eip-6239.md b/EIPS/eip-6239.md new file mode 100644 index 00000000000000..ca08a672608b90 --- /dev/null +++ b/EIPS/eip-6239.md @@ -0,0 +1,302 @@ +--- +eip: 6239 +title: Semantic Soulbound Tokens +description: Adding RDF triples to ERC-5192 token metadata to capture social meaning +author: Jessica Chang (@JessicaChg) +discussions-to: https://ethereum-magicians.org/t/eip-6239-semantic-soulbound-tokens/12334 +status: Draft +type: Standards Track +category: ERC +created: 2022-12-30 +requires: 165, 721, 5192 +--- + +## Abstract + +This proposal extends [ERC-721](./eip-721.md) and [ERC-5192](./eip-5192.md) by introducing Resource Description Framework (RDF) triples to Soulbound Tokens' (‘SBTs‘) metadata. + + + +## Motivation + +A Soulbound Token represents the commitments, credentials, and affiliations of accounts. RDF is a standard data model developed by the World Wide Web Consortium (‘W3C’) and is used to represent information in a structured format. Semantic SBTs are built on existing [ERC-721](./eip-721.md) and [ERC-5192](./eip-5192.md) standards to include RDF triples in metadata to capture and store the meaning of social metadata as a network of accounts and attributes. + +Semantic SBT provides a foundation for publishing, linking, and integrating data from multiple sources, and enables the ability to query and retrieve information across these sources, using inference to uncover new insights from existing social relations. For example, form the on-chain united social graph, assign trusted contacts for social recovery, and supports fair governance. + +While the existence of SBTs can create a decentralized social framework, there still needs to specify a common data model to manage the social metadata on-chain in a trustless manner, describing social metadata in an interconnected way, make it easy to be exchanged, integrated and discovered. And to further fuel the boom of the SBTs ecosystem, we need a bottom-up and decentralized way to maintain people’s social identity related information. + +Semantic SBTs address this by storing social metadata, attestations, and access permissions on-chain to bootstrap the social identity layer and a linked data layer natively on Ethereum, and bring semantic meanings to the tons of bits of on-chain data. + +### Connectedness + +Semantic SBTs store social data as RDF triples in the Subject-Predicate-Object format, making it easy to create relationships between accounts and attributes. RDF is a standard for data interchange used to represent highly interconnected data. Representing data in RDF triples makes it simpler for automated systems to identify, clarify, and connect information. + +### Linked Data + +Semantic SBTs allow the huge amount of social data on-chain to be available in a standard format (RDF) and be reachable and manageable. The interrelated datasets on-chain can create the linked data layer that allows social data to be mixed, exposed, and shared across different applications, providing a convenient, cheap, and reliable way to retrieve data, regardless of the number of users. + +### Social Identity + +Semantic SBTs allow people to publish or attest their own identity-related data in a bottom-up and decentralized way, without reliance on any centralized intermediaries while setting every party free. The data is fragmentary in each Semantic SBT and socially interrelated. RDF triples enable various community detection algorithms to be built on top. + +This proposal outlines the semantic data modeling of SBTs that allows implementers to model the social relations among Semantic SBTs, especially in the social sector. + +## Specification + +The key words "MUST", "MUST NOT", "REQUIRED", "SHALL", "SHALL NOT", "SHOULD", "SHOULD NOT", "RECOMMENDED", "MAY", and "OPTIONAL" in this document are to be interpreted as described in RFC 2119. + +- The token **MUST** implement the following interfaces: + 1. [ERC-165](./eip-165.md)’s `ERC165` (`0x01ffc9a7`) + 1. [ERC-721](./eip-721.md)’s `ERC721` (`0x80ac58cd`) + 1. [ERC-721](./eip-721.md)’s `ERC721Metadata` (`0x5b5e139f`) + 1. [ERC-5192](./eip-5192.md)’s `ERC5192` (`0xb45a3c0e`) + +### RDF Statement + +RDF statements come in various formats, we have selected the six most commonly used formats: `nt(N-Triples)`,`ttl(Turtle)`,`rdf(RDF/XML)`,`rj(RDF/JSON)`,`nq(N-Quads)` and `trig(TriG)`. + +The complete format of an RDF statement: + +```text +rdfStatements = {[format]} +``` + +In the following section, fragments surrounded by `{}` characters are OPTIONAL. + +In the following section, fragments surrounded by `<>` characters are REQUIRED. + +format: nt/ttl/rdf/rj/nq/trig + +When no format is selected: statements = [ttl]statements + +- `nt(n-triples)` + +`nt` uses space to separate the subject, predicate, object of a triple, and a period . to indicate the end of a triple. + +The basic structure is: + +```text +subject predicate object . +``` + +In this format, the subject is in the format of IRIREF or BLANK_NODE_LABEL, the predicate is in the format of IRIREF, and the object is in the format of IRIREF, BLANK_NODE_LABEL, or STRING_LITERAL_QUOTE. + +For example: + +```text + . + "Alice" . +``` + +- `ttl(Turtle)` + +Compared to `nt`, `ttl` uses prefixes to simplify the IRIREF format, and the same predicate under the same subject can be merged without repeating it. "a" can be used to represent ``. + + +For example: + +```text +@prefix : . +@prefix p: . + +:user1 a :User; + p:name ”Alice” . +``` + +- `rdf(RDF/XML)` + +`rdf` describes RDF in XML format, using rdf:RDF as the top-level element, and xmlns to describe prefixes. rdf:Description begins describing a node, rdf:about defines the node to be described, and rdf:resource fills in the property value in the format of IRI. If the property value is a string, the property value can be directly written as the text of the property node. + +The basic structure is: + +```xml + + + + + + object + + +``` + +For example: + +```xml + + + + + + Alice + + +``` + +- `rj(RDF/JSON)` + + +`rj` describes RDF in JSON format. A triple is described as: + + +```text + {"subject":{"predicate":[object]}} +``` + +Note that each root object is a unique primary key and duplicates are not allowed. There will be no duplicate subjects as keys, and there will be no duplicate predicates under a single subject. + +For example: + +```json + { + "http://example.org/entity/user1": { + "http://www.w3.org/1999/02/22-rdf-syntax-ns#type": [ + "http://example.org/entity/User" + ], + "http://example.org/property/name": [ + "Alice" + ] + } +} + +``` + +- `nq(N-Quads)` + +`nq` is based on `nt` but includes a graph label that describes the dataset to which an RDF triple belongs. The graph label can be in the format of IRIREF or BLANK_NODE_LABEL. + +The basic structure is: + +```text +subject predicate object graphLabel. +``` + +For example: + +```text + . + "Alice" . +``` + +- `trig(TriG)` + + +`trig` is an extension of `ttl` that includes a graph label to describe the dataset to which an RDF triple belongs. The triple statements are enclosed in curly braces {}. + +For example: + +```text +@prefix : . +@prefix p: . + + + { + :user1 a :User; + p:name ”Alice” . + + } +``` + +In the contract events: `CreateRDF`, `UpdateRDF`, `RemoveRDF`, and the `rdfOf method`, the `rdfStatements` is used in `ttl` format by default. If other formats listed above are used, a format identifier needs to be added for identification. + +The format identifier starts with `[` and ends with `]` with the format in the middle, i.e., `[format]`. + +For example, the `rdfStatements` in `nt` format should include the prefix `[nt]`. + +```text +[nt]subject predicate object . +``` + + +### Contract Interface + +```solidity +/** + * @title Semantic Soulbound Token + * Note: the ERC-165 identifier for this interface is 0xfbafb698 + */ +interface ISemanticSBT{ + /** + * @dev This emits when minting a Semantic Soulbound Token. + * @param tokenId The identifier for the Semantic Soulbound Token. + * @param rdfStatements The RDF statements for the Semantic Soulbound Token. + */ + event CreateRDF ( + uint256 indexed tokenId, + string rdfStatements + ); + /** + * @dev This emits when updating the RDF data of Semantic Soulbound Token. RDF data is a collection of RDF statements that are used to represent information about resources. + * @param tokenId The identifier for the Semantic Soulbound Token. + * @param rdfStatements The RDF statements for the semantic soulbound token. + */ + event UpdateRDF ( + uint256 indexed tokenId, + string rdfStatements + ); + /** + * @dev This emits when burning or revoking Semantic Soulbound Token. + * @param tokenId The identifier for the Semantic Soulbound Token. + * @param rdfStatements The RDF statements for the Semantic Soulbound Token. + */ + event RemoveRDF ( + uint256 indexed tokenId, + string rdfStatements + ); + /** + * @dev Returns the RDF statements of the Semantic Soulbound Token. + * @param tokenId The identifier for the Semantic Soulbound Token. + * @return rdfStatements The RDF statements for the Semantic Soulbound Token. + */ + function rdfOf(uint256 tokenId) external view returns (string memory rdfStatements); +} +``` + +`ISemanticRDFSchema`, an extension of ERC-721 Metadata, is **OPTIONAL** for this standard, it is used to get the Schema URI for the RDF data. + +```solidity +interface ISemanticRDFSchema{ + /** + * @notice Get the URI of schema for this contract. + * @return The URI of the contract which point to a configuration profile. + */ + function schemaURI() external view returns (string memory); +} +``` + + +### Method Specification + +`rdfOf (uint256 tokenId)`: Query the RDF data for the Semantic Soulbound Token by `tokenId`. The returned RDF data format conforms to the W3C RDF standard. RDF data is a collection of RDF statements that are used to represent information about resources. An RDF statement, also known as a triple, is a unit of information in the RDF data model. It consists of three parts: a subject, a predicate, and an object. + +`schemaURI()`: This **OPTIONAL** method is used to query the URIs of the schema for the RDF data. RDF Schema is an extension of the basic RDF vocabulary and provides a data-modelling vocabulary for RDF data. It is **RECOMMENDED** to store the RDF Schema in decentralized storage such as Arweave or IPFS. The URIs are then stored in the contract and can be queried by this method. + +### Event Specification + +`CreateRDF`: When minting a Semantic Soulbound Token, this event **MUST** be triggered to notify the listener to perform operations with the created RDF data. When calling the event, the input RDF data **MUST** be RDF statements, which are units of information consisting of three parts: a subject, a predicate, and an object. + +`UpdateRDF`: When updating RDF data for a Semantic Soulbound Token, this event **MUST** be triggered to notify the listener to perform update operations accordingly with the updated RDF data. When calling the event, the input RDF data **MUST** be RDF statements, which are units of information consisting of three parts: a subject, a predicate, and an object. + +`RemoveRDF`: When burning or revoking a Semantic Soulbound Token, this event **MUST** be triggered to notify the listener to perform operations with the removed RDF data for the Semantic SBT. When calling the event, the input RDF data **MUST** be RDF statements, which are units of information consisting of three parts: a subject, a predicate, and an object. + +## Rationale + + +RDF is a flexible and extensible data model based on creating subject-predicate-object relationships, often used to model graph data due to its semantic web standards, Linked Data concept, flexibility, and query capabilities. RDF allows graph data to be easily integrated with other data sources on the web, making it possible to create more comprehensive and interoperable models. The advantage of using RDF for semantic description is that it can describe richer information, including terms, categories, properties, and relationships. RDF uses standard formats and languages to describe metadata, making the expression of semantic information more standardized and unified. This helps to establish more accurate and reliable semantic networks, promoting interoperability between different systems. Additionally, RDF supports semantic reasoning, which allows the system to automatically infer additional relationships and connections between nodes in the social graph based on the existing data. + + +There are multiple formats for RDF statements. We list six most widely adopted RDF statement formats in the EIP: `Turtle`, `N-Triples`, `RDF/XML`, `RDF/JSON`,`N-Quads`, and `TriG`. These formats have different advantages and applicability in expressing, storing, and parsing RDF statements. Among these, `Turtle` is a popular format in RDF statements, due to its good human-readability and concision. It is typically used as the default format in this EIP for RDF statements. Using the Turtle format can make RDF statements easier to understand and maintain, while reducing the need for storage, suitable for representing complex RDF graphs. + + +## Backwards Compatibility + +This proposal is fully backward compatible with [ERC-721](./eip-721.md) and [ERC-5192](./eip-5192.md). + +## Security Considerations + +There are no security considerations related directly to the implementation of this standard. + +## Copyright + +Copyright and related rights waived via [CC0](../LICENSE.md). From df55bdd3b592e0f08d7197ace05c56cee4d574b6 Mon Sep 17 00:00:00 2001 From: Danny Ryan Date: Tue, 30 May 2023 09:05:59 -0600 Subject: [PATCH 33/97] Add EIP: Increase max attestation inclusion slot Merged by EIP-Bot. --- EIPS/eip-7045.md | 73 ++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 73 insertions(+) create mode 100644 EIPS/eip-7045.md diff --git a/EIPS/eip-7045.md b/EIPS/eip-7045.md new file mode 100644 index 00000000000000..9f516b163d8ec0 --- /dev/null +++ b/EIPS/eip-7045.md @@ -0,0 +1,73 @@ +--- +eip: 7045 +title: Increase max attestation inclusion slot +description: Increases max attestaton inclusion slot to the last slot in `N+1` where `N` is the epoch containing the attestations slot. +author: Danny Ryan (@djrtwo) +discussions-to: https://ethereum-magicians.org/t/eip-7045-increase-attestation-slot-inclusion-range/14342 +status: Draft +type: Standards Track +category: Core +created: 2023-05-18 +--- + +## Abstract + +Increases max attestation inclusion slot from `attestation.slot + SLOTS_PER_EPOCH` to the last slot of epoch `N+1` where `N` is the epoch containing the attestation slot. + +This increase is critical to the current LMD-GHOST security analysis as well as the confirmation rule. + +## Motivation + +Attestations can currently be included after some minimum delay (`1` slot on mainnet) up until `SLOTS_PER_EPOCH` slots after the slot the attestation was created in. This rolling window of one epoch was decided upon during Phase 0 because the equal inclusion window for any attestation was assessed as "fair". The alternative considered path was to allow inclusion during the current and next epoch which means attestations created during the start of an epoch have more potential slots of inclusion than those at the end of the epoch. + +Since this decision, it has become apparent that the alternative design is critical for current LMD-GHOST security proofs as well as a new confirmation rule (which will allow for block confirmations in approximately 3-4 slots in normal mainnet conditions). + +This specification, thus increases the max inclusion slot for attestations in accordance with the learned security proof and confirmation rule needs. + +## Specification + +### Constants + +| Name | Value | Comment | +| - | - | - | +|`FORK_TIMESTAMP` | *TBD* | Mainnet | + +### Execution layer + +This requires no changes to the Execution Layer. + +### Consensus layer + +The specification makes two minor changes to the state transition function: + +* Modify `process_attestation` to not have an upper bound on the slot check and instead just rely on the minimum slot as well as the target epoch being in either current or previous epoch. +* Modify `get_attestation_participation_flag_indices` to set the `TIMELY_TARGET_FLAG` without consideration of `inclusion_delay` to ensure that the extended inclusion attestations have a non-zero reward. + +Additionally, the specification modifies the attestation and aggregate attestation gossip conditions to allow for gossip during this extended range. + +## Rationale + +### Extended max inclusion slot + +As discussed in the Motivation, extending this max inclusion slot to the end of the next epoch is critical for LMD-GHOST security proofs and confirmation rule. + +### Removal of `inclusion_delay` consideration for target reward + +Previously, `get_attestation_participation_flag_indices` would only set the `TIMELY_TARGET_FLAG` (and thus reward for an attestation with correct target vote) if the attestation was included within a `SLOTS_PER_EPOCH` window. + +The `inclusion_delay` consideration for this flag is removed to ensure that whatever the valid inclusion window is for an attestation, it can receive a baseline non-zero reward for correct target. This ensures that clients will still attempt to pack such attestations into blocks which is important for the security analysis. + +## Backwards Compatibility + +This EIP introduces backwards incompatible changes to the block validation rule set on the consensus layer and must be accompanied by a hard fork. + +## Security Considerations + +This improves LMD-GHOST security as well as enables a fast confirmation rule. + +There are no known negative impacts to security. + +## Copyright + +Copyright and related rights waived via [CC0](../LICENSE.md). + From 11c5d1f3f2f306a8261e495dae2b024828ca88ae Mon Sep 17 00:00:00 2001 From: EmojiDao <96720682+emojidao@users.noreply.github.com> Date: Tue, 30 May 2023 23:18:00 +0800 Subject: [PATCH 34/97] Update EIP-5007: Move to Final Merged by EIP-Bot. --- EIPS/eip-5007.md | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/EIPS/eip-5007.md b/EIPS/eip-5007.md index adea9ce2704c5f..a378410137f03a 100755 --- a/EIPS/eip-5007.md +++ b/EIPS/eip-5007.md @@ -4,8 +4,7 @@ title: Time NFT, ERC-721 Time Extension description: Add start time and end time to ERC-721 tokens. author: Anders (@0xanders), Lance (@LanceSnow), Shrug discussions-to: https://ethereum-magicians.org/t/eip-5007-eip-721-time-extension/8924 -status: Last Call -last-call-deadline: 2023-05-15 +status: Final type: Standards Track category: ERC created: 2022-04-13 From 597592eeb9cca9221a27fcff8fb7b64b7d0834a5 Mon Sep 17 00:00:00 2001 From: Marius van der Wijden Date: Tue, 30 May 2023 17:18:44 +0200 Subject: [PATCH 35/97] Update EIP-6122: Move to Review Merged by EIP-Bot. --- EIPS/eip-6122.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/EIPS/eip-6122.md b/EIPS/eip-6122.md index 79f81422c19f69..0a02be5ba06429 100644 --- a/EIPS/eip-6122.md +++ b/EIPS/eip-6122.md @@ -4,7 +4,7 @@ title: Forkid checks based on timestamps description: Modifies the forkid checks to work with timestamps and block numbers author: Marius van der Wijden (@MariusVanDerWijden) discussions-to: https://ethereum-magicians.org/t/eip-6122-forkid-checks-based-on-timestamps/12130 -status: Draft +status: Review type: Standards Track category: Networking created: 2022-12-13 From b2353a8ce0214d5a0f26f911718215d9ca362903 Mon Sep 17 00:00:00 2001 From: qdqd Date: Tue, 30 May 2023 17:33:42 +0200 Subject: [PATCH 36/97] Add EIP: Token Mapping Slot Retrieval Extension Merged by EIP-Bot. --- EIPS/eip-6823.md | 115 +++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 115 insertions(+) create mode 100644 EIPS/eip-6823.md diff --git a/EIPS/eip-6823.md b/EIPS/eip-6823.md new file mode 100644 index 00000000000000..2d01a52fec326c --- /dev/null +++ b/EIPS/eip-6823.md @@ -0,0 +1,115 @@ +--- +eip: 6823 +title: Token Mapping Slot Retrieval Extension +description: Approach to enhance precision of off-chain transaction simulations by accessing mapping storage slot in ERC-20/721/1155 contracts. +author: qdqd (@qd-qd) +discussions-to: https://ethereum-magicians.org/t/eip-6823-token-mapping-slot-retrieval-extension/13666 +status: Draft +type: Standards Track +category: ERC +created: 2023-03-29 +requires: 20, 721, 1155 +--- + +## Abstract + +The aim of this proposal is to enhance the precision of off-chain simulations for transactions that involve contracts complying with the [ERC-20](./eip-20.md), [ERC-721](./eip-721.md), or [ERC-1155](./eip-1155.md) standards. To achieve this, a method is proposed for obtaining the reserved storage slot of the mapping responsible to track ownership of compliant tokens. The proposed extension offers a standardized entry point that allows for identifying the reserved storage slot of a mapping in a compatible manner. This not only facilitates capturing state changes more precisely but also enables external tools and services to do so without requiring expertise in the particular implementation details. + +## Motivation + +To understand the rationale behind this proposal, it's important to remember how values and mapping are stored in the storage layout. This procedure is language-agnostic; it can be applied to multiple programming languages beyond Solidity, including Vyper. + +The storage layout is a way to persistently store data in Ethereum smart contracts. In the EVM, storage is organized as a key-value store, where each key is a 32-byte location, and each value is a 32-byte word. When you define a state variable in a contract, it is assigned to a storage location. The location is determined by the variable's position in the contract's storage structure. The first variable in the contract is assigned to location 0, the second to location 1, and so on. Multiple values less than 32 bytes can be grouped to fit in a single slot if possible. + +Due to their indeterminate size, mappings utilize a specialized storage arrangement. Instead of storing mappings "in between" state variables, they are allocated to occupy 32 bytes only, and their elements are stored in a distinct storage slot computed through a keccak-256 hash. The location of the value corresponding to a mapping key `k` is determined by concatenating `h(k)` and `p` and performing a keccak-256 hash. The value of `p` is the position of the mapping in the storage layout, which depends on the order and the nature of the variables initialized before the mapping. It can't be determined in a universal way as you have to know how the implementation of the contract is done. + +Due to the nature of the mapping type, it is challenging to simulate transactions that involve smart contracts because the storage layout for different contracts is unique to their specific implementation, etched by their variable requirements and the order of their declaration. Since the storage location of a value in a mapping variable depends on this implementation-sensitive storage slot, we cannot guarantee similarity on the off-chain simulation version that an on-chain attempted interaction will result in. + +This hurdle prevents external platforms and tools from capturing/validating changes made to the contract's state with certainty. + +That's why transaction simulation relies heavily on events. However, this approach has limitations, and events should only be informative and not relied upon as the single source of truth. The state is and must be the only source of truth. Furthermore, it is impossible to know the shape of the storage deterministically and universally, which prevents us from verifying the source of truth that is storage, forcing us to rely on information emitted from the application layer. + +## Specification + +The keywords "MUST", "MUST NOT", "REQUIRED", "SHALL", "SHALL NOT", "SHOULD", "SHOULD NOT", "RECOMMENDED", "NOT RECOMMENDED", "MAY", and "OPTIONAL" in this document are to be interpreted as described in RFC 2119 and RFC 8174. + +The proposal suggests an extension to the ERC-20/ERC-721/ERC-1155 standards that allows retrieving the reserved storage slot for the mapping type in any compliant smart-contract implementation in a deterministic manner. This method eliminates the reliance on events and enhances the precision of the data access from storage. The proposed extension therefore enables accurate off-chain simulations. The outcome is greater transparency and predictability at no extra cost for the caller, and a negigleable increase in the deployment cost of the contract. + +The proposed extension is a single function that returns the reserved storage slot for the mapping type in any ERC-20/ERC-721/ERC-1155 compliant smart-contract implementation. The function is named `getTokenLocationRoot` and is declared as follows: + +```solidity +abstract contract ERC20Extension is ERC20 { + function getTokenLocationRoot() external pure virtual returns (bytes32 slot) { + assembly { + slot := .slot + } + } +} + +abstract contract ERC721Extension is ERC721 { + function getTokenLocationRoot() external pure virtual returns (bytes32 slot) { + assembly { + slot := .slot + } + } +} + +abstract contract ERC1155Extension is ERC1155 { + function getTokenLocationRoot() external pure virtual returns (bytes32 slot) { + assembly { + slot := .slot + } + } +} +``` + +For these contracts, off-chain callers can use the `getTokenLocationRoot()` function to find the reserved storage slot for the mapping type. This function returns the reserved storage slot for the mapping type in the contract. This location is used to calculate where all the values of the mapping will be stored. Knowing this value makes it possible to determine precisely where each value of the mapping will be stored, regardless of the contract's implementation. The caller can use this slot to calculate the storage slot for a specific token ID and compare the value to the expected one to verify the action stated by the event. In the case of a ERC-721 mint, the caller can compare the value of the storage slot to the address of the token's owner. In the case of a ERC-20 transfer, the caller can compare the value of the storage slot to the address of the token's new owner. In the case of a ERC-1155 burn, the caller can compare the value of the storage slot to the zero address. The off-chain comparison can be performed with any of the many tools available. In addition, it could perhaps allow storage to be proven atomically by not proving the entire state but only a location -- to track ownership of a specific token, for example. + +The name of the function is intentionally generic to allow the same implementation for all the different token standards. Once implemented universally, the selector derived from the signature of this function will be a single, universal entry point that can be used to directly read the slots in the storage responsible of the ownership, of any token contract. This will make off-chain simulations significantly more accurate, and the events will be used for informational purposes only. + +Contract implementers MUST implement the `getTokenLocationRoot()` function in their contracts. The function MUST return the reserved storage slot for the mapping type in the contract. The function SHOULD be declared as `external pure`. + +## Rationale + +The idea behind the implementation was to find an elegant and concise way that avoided any breaking changes with the current standard. Moreover, since gas consumption is crucial, it was inconceivable to find an implementation that would cost gas to the final user. In this case, the addition of a function increases the deployment cost of the contract in a minimal way, but its use is totally free for the external actors. + +The implementation is minimalist in order to be as flexible as possible while being directly compatible with the main programming languages used today to develop smart-contracts for the EVM. + +## Backwards Compatibility + +No backward compatibility issues have been found. + +## Reference Implementation + +```solidity +abstract contract ERC20Extension is ERC20 { + function getTokenLocationRoot() external pure virtual returns (bytes32 slot) { + assembly { + slot := .slot + } + } +} + +abstract contract ERC721Extension is ERC721 { + function getTokenLocationRoot() external pure virtual returns (bytes32 slot) { + assembly { + slot := .slot + } + } +} + +abstract contract ERC1155Extension is ERC1155 { + function getTokenLocationRoot() external pure virtual returns (bytes32 slot) { + assembly { + slot := .slot + } + } +``` + +## Security Considerations + +No security issues are raised by the implementation of this extension. + +## Copyright + +Copyright and related rights waived via [CC0](../LICENSE.md). From 7c04c8fccd407f40dbaff28fc70facf8a5ef5653 Mon Sep 17 00:00:00 2001 From: Gavin John Date: Tue, 30 May 2023 11:36:36 -0400 Subject: [PATCH 37/97] Add EIP: ERC-5219 Resolve Mode Merged by EIP-Bot. --- EIPS/eip-6944.md | 59 ++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 59 insertions(+) create mode 100644 EIPS/eip-6944.md diff --git a/EIPS/eip-6944.md b/EIPS/eip-6944.md new file mode 100644 index 00000000000000..ed934544f9e9ae --- /dev/null +++ b/EIPS/eip-6944.md @@ -0,0 +1,59 @@ +--- +eip: 6944 +title: ERC-5219 Resolve Mode +description: Adds an ERC-4804 resolveMode to support ERC-5219 requests +author: Gavin John (@Pandapip1), Qi Zhou (@qizhou) +discussions-to: https://ethereum-magicians.org/t/erc-5219-resolve-mode/14088 +status: Draft +type: Standards Track +category: ERC +created: 2023-04-27 +requires: 4804, 5219 +--- + +## Abstract + +This EIP adds a new [ERC-4804](./eip-4804.md) `resolveMode` to resolve [ERC-5219](./eip-5219.md) contract resource requests. + +## Specification + +The key words "MUST", "MUST NOT", "REQUIRED", "SHALL", "SHALL NOT", "SHOULD", "SHOULD NOT", "RECOMMENDED", "NOT RECOMMENDED", "MAY", and "OPTIONAL" in this document are to be interpreted as described in RFC 2119 and RFC 8174. + +Contracts wishing to use ERC-5219 as their ERC-4804 resolve mode must implement the following interface: + +```solidity +/// @dev IDecentralizedApp is the ERC-5219 interface +interface IERC5219Resolver is IDecentralizedApp { + // @notice The ERC-4804 resolve mode + // @dev This MUST return "5219" (0x3532313900000000000000000000000000000000000000000000000000000000) for ERC-5219 resolution (case-insensitive). The other options, as of writing this, are "auto" for automatic resolution, or "manual" for manual resolution. + function resolveMode() external pure returns (bytes32 mode); +} +``` + +## Rationale + +[ERC-165](./eip-165.md) was not used because interoperability can be checked by calling `resolveMode`. + +## Backwards Compatibility + +No backward compatibility issues found. + + +## Reference Implementation + +```solidity +abstract contract ERC5219Resolver is IDecentralizedApp { + function resolveMode() public pure returns (bytes32 mode) { + return "5219"; + } +} +``` + + +## Security Considerations + +The security considerations of [ERC-4804](./eip-4804.md#security-considerations) and [ERC-5219](./eip-5219.md#security-considerations) apply. + +## Copyright + +Copyright and related rights waived via [CC0](../LICENSE.md). From 9bbd0bc58e7810113389ec2e3f909542d0089a4b Mon Sep 17 00:00:00 2001 From: Paul Sullivan <34427270+sullivph@users.noreply.github.com> Date: Tue, 30 May 2023 11:39:17 -0400 Subject: [PATCH 38/97] Add EIP: Reserved Ownership Accounts Merged by EIP-Bot. --- EIPS/eip-6981.md | 528 +++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 528 insertions(+) create mode 100644 EIPS/eip-6981.md diff --git a/EIPS/eip-6981.md b/EIPS/eip-6981.md new file mode 100644 index 00000000000000..fe886194c4bbe0 --- /dev/null +++ b/EIPS/eip-6981.md @@ -0,0 +1,528 @@ +--- +eip: 6981 +title: Reserved Ownership Accounts +description: A registry for generating future-deployed smart contract accounts owned by users on external services +author: Paul Sullivan (@sullivph) , Wilkins Chung (@wwchung) , Kartik Patel (@Slokh) +discussions-to: https://ethereum-magicians.org/t/erc-6981-reserved-ownership-accounts/14118 +status: Draft +type: Standards Track +category: ERC +created: 2023-04-25 +requires: 1167, 1271 +--- + +## Abstract + +The following specifies a system for services to link their users to a claimable Ethereum address. Services can provide a signed message and unique salt to their users which can be used to deploy a smart contract wallet to the deterministic address through a registry contract using the `create2` opcode. + +## Motivation + +It is common for web services to allow their users to hold on-chain assets via custodial wallets. These wallets are typically EOAs, deployed smart contract wallets or omnibus contracts, with private keys or asset ownership information stored on a traditional database. This proposal outlines a solution that avoids the security concerns associated with historical approaches, and rids the need and implications of services controlling user assets + +Users on external services that choose to leverage the following specification can be given an Ethereum address to receive assets without the need to do any on-chain transaction. These users can choose to attain control of said addresses at a future point in time. Thus, on-chain assets can be sent to and owned by a user beforehand, therefore enabling the formation of an on-chain identity without requiring the user to interact with the underlying blockchain. + +## Specification + +The key words "MUST", "MUST NOT", "REQUIRED", "SHALL", "SHALL NOT", "SHOULD", "SHOULD NOT", "RECOMMENDED", "NOT RECOMMENDED", "MAY", and "OPTIONAL" in this document are to be interpreted as described in RFC 2119 and RFC 8174. + +### Overview + +The system for creating reserved ownership accounts consists of: + +1. An Account Registry which provides deterministic addresses based on the service users' identifying salts, and implements a signature verified function that enables claiming of Account Instances by the service's end users. +2. Account Instances created through the Account Registry by end users which allow access to the assets received at the deterministic address prior to Account Instance deployment. + +External services wishing to provide their users with reserved ownership accounts MUST maintain a relationship between a user's identifying credentials and a salt. The external service SHALL refer to an Account Registry Instance to retrieve the deterministic account address for a given salt. Users of a given service MUST be able to create an Account Instance by validating their identifying credentials via the external service, which SHOULD give the user a signed message for their salt. Signatures SHOULD be generated by the external service using an signing address known to the Account Registry Instance. Users SHALL pass this message and signature to the service's Account Registry Instance in a call to `claimAccount` to deploy and claim an Account Instance at the deterministic address. + +### Account Registry + +The Account Registry MUST implement the following interface: + +```solidity +interface IAccountRegistry { + /** + * @dev Registry instances emit the AccountCreated event upon successful account creation + */ + event AccountCreated(address account, address accountImplementation, uint256 salt); + + /** + * @dev Registry instances emit the AccountClaimed event upon successful claim of account by owner + */ + event AccountClaimed(address account, address owner); + + /** + * @dev Creates a smart contract account. + * + * If account has already been created, returns the account address without calling create2. + * + * @param salt - The identifying salt for which the user wishes to deploy an Account Instance + * + * Emits AccountCreated event + * @return the address for which the Account Instance was created + */ + function createAccount(uint256 salt) external returns (address); + + /** + * @dev Allows an owner to claim a smart contract account created by this registry. + * + * If the account has not already been created, the account will be created first using `createAccount` + * + * @param owner - The initial owner of the new Account Instance + * @param salt - The identifying salt for which the user wishes to deploy an Account Instance + * @param expiration - If expiration > 0, represents expiration time for the signature. Otherwise + * signature does not expire. + * @param message - The keccak256 message which validates the owner, salt, expiration + * @param signature - The signature which validates the owner, salt, expiration + * + * Emits AccountClaimed event + * @return the address of the claimed Account Instance + */ + function claimAccount( + address owner, + uint256 salt, + uint256 expiration, + bytes32 message, + bytes calldata signature + ) external returns (address); + + /** + * @dev Returns the computed address of a smart contract account for a given identifying salt + * + * @return the computed address of the account + */ + function account(uint256 salt) external view returns (address); + + /** + * @dev Fallback signature verification for unclaimed accounts + */ + function isValidSignature(bytes32 hash, bytes memory signature) external view returns (bytes4); +} +``` + +#### createAccount + +`createAccount` is used to deploy the Account Instance for a given salt. + +- This function MUST deploy a new Account Instance as a [ERC-1167](./eip-1167.md) proxy pointing to the account implementation. +- This function SHOULD set the initial owner of the Account Instance to the Account Registry Instance. +- The account implementation address MUST be immutable, as it is used to compute the deterministic address for the Account Instance. +- Upon successful deployment of the Account Instance, the registry SHOULD emit an `AccountCreated` event. + +#### claimAccount + +`claimAccount` is used to claim ownership of the Account Instance for a given salt. + +- This function MUST create a new Account Instance if one does not already exist for the given salt. +- This function SHOULD verify that the msg.sender has permission to claim ownership over the Account Instance for the identifying salt and initial owner. Verification SHOULD be done by validating the message and signature against the owner, salt and expiration using ECDSA for EOA signers, or [ERC-1271](./eip-1271.md) for smart contract signers. +- This function SHOULD verify that the block.timestamp < expiration or that expiration == 0. +- Upon successful signature verification on calls to `claimAccount`, the registry MUST completely relinquish control over the Account Instance, and assign ownership to the initial owner by calling `setOwner` on the Account Instance. +- Upon successful claim of the Account Instance, the registry SHOULD emit an `AccountClaimed` event. + +#### isValidSignature + +`isValidSignature` is a fallback signature verification function used by unclaimed accounts. Valid signatures SHALL be generated by the registry signer by signing a composite hash of the original message hash, and the Account Instance address (e.g. `bytes32 compositeHash = keccak256(abi.encodePacked(originalHash, accountAddress))`). The function MUST reconstruct the composite hash, where `originalHash` is the hash passed to the function, and `accountAddress` is `msg.sender` (the unclaimed Account Instance). The function MUST verify the signature against the composite hash and registry signer. + +### Account Instance + +The Account Instance MUST implement the following interface: + +```solidity +interface IAccount is IERC1271 { + /** + * @dev Sets the owner of the Account Instance. + * + * Only callable by the current owner of the instance, or by the registry if the Account + * Instance has not yet been claimed. + * + * @param owner - The new owner of the Account Instance + */ + function setOwner(address owner) external; +} +``` + +- All Account Instances MUST be created using an Account Registry Instance. +- Account Instances SHOULD provide access to assets previously sent to the address at which the Account Instance is deployed to. +- `setOwner` SHOULD update the owner and SHOULD be callable by the current owner of the Account Instance. +- If an Account Instance is deployed, but not claimed, the owner of the Account Instance MUST be initialized to the Account Registry Instance. +- An Account Instance SHALL determine if it has been claimed by checking if the owner is the Account Registry Instance. + +#### Account Instance Signatures + +- Account Instances MUST support [ERC-1271](./eip-1271.md) by implementing an `isValidSignature` function. +- If an Account instance is claimed, the owner should generate the signature, and `isValidSignature` SHOULD verify that the message hash and signature are valid for the current owner of the Account Instance. +- If an Account Instance is unclaimed, the registry signer should generate the signature using a composite hash of the original message and address of the Account Instance described [above](#isvalidsignature), and `isValidSignature` SHOULD forward the message hash and signature to the Account Registry Instance's `isValidSignature` function. + +## Rationale + +### Service-Owned Registry Instances + +While it might seem more user-friendly to implement and deploy a universal registry for reserved ownership accounts, we believe that it is important for external service providers to have the option to own and control their own Account Registry. This provides the flexibility of implementing their own permission controls and account deployment authorization frameworks. + +We are providing a reference Registry Factory which can deploy Account Registries for an external service, which comes with: + +- Immutable Account Instance implementation +- Validation for the `claimAccount` method via ECDSA for EOA signers, or [ERC-1271](./eip-1271.md) validation for smart contract signers +- Ability for the Account Registry deployer to change the signing addressed used for `claimAccount` validation + +### Account Registry and Account Implementation Coupling + +Since Account Instances are deployed as [ERC-1167](./eip-1167.md) proxies, the account implementation address affects the addresses of accounts deployed from a given Account Registry. Requiring that registry instances be linked to a single, immutable account implementation ensures consistency between a user's salt and linked address on a given Account Registry Instance. + +This also allows services to gain the the trust of users by deploying their registries with a reference to a trusted account implementation address. + +Furthermore, account implementations can be designed as upgradeable, so users are not necessarily bound to the implementation specified by the Account Registry Instance used to create their account. + +### Separate `createAccount` and `claimAccount` Operations + +Operations to create and claim Account Instances are intentionally separate. This allows services to provide users with valid [ERC-6492](./eip-6492.md) signatures before their Account Instance has been deployed. + +## Reference Implementation + +The following is an example of an Account Registry Factory which can be used by external service providers to deploy their own Account Registry Instance. + +### Account Registry Factory + +```solidity +// SPDX-License-Identifier: CC0-1.0 +pragma solidity ^0.8.13; + +/// @author: manifold.xyz + +import {Create2} from "openzeppelin/utils/Create2.sol"; + +import {Address} from "../../lib/Address.sol"; +import {ERC1167ProxyBytecode} from "../../lib/ERC1167ProxyBytecode.sol"; +import {IAccountRegistryFactory} from "./IAccountRegistryFactory.sol"; + +contract AccountRegistryFactory is IAccountRegistryFactory { + using Address for address; + + error InitializationFailed(); + + address private immutable registryImplementation = 0x076B08EDE2B28fab0c1886F029cD6d02C8fF0E94; + + function createRegistry( + uint96 index, + address accountImplementation, + bytes calldata accountInitData + ) external returns (address) { + bytes32 salt = _getSalt(msg.sender, index); + bytes memory code = ERC1167ProxyBytecode.createCode(registryImplementation); + address _registry = Create2.computeAddress(salt, keccak256(code)); + + if (_registry.isDeployed()) return _registry; + + _registry = Create2.deploy(0, salt, code); + + (bool success, ) = _registry.call( + abi.encodeWithSignature( + "initialize(address,address,bytes)", + msg.sender, + accountImplementation, + accountInitData + ) + ); + if (!success) revert InitializationFailed(); + + emit AccountRegistryCreated(_registry, accountImplementation, index); + + return _registry; + } + + function registry(address deployer, uint96 index) external view override returns (address) { + bytes32 salt = _getSalt(deployer, index); + bytes memory code = ERC1167ProxyBytecode.createCode(registryImplementation); + return Create2.computeAddress(salt, keccak256(code)); + } + + function _getSalt(address deployer, uint96 index) private pure returns (bytes32) { + return bytes32(abi.encodePacked(deployer, index)); + } +} +``` + +### Account Registry + +```solidity +// SPDX-License-Identifier: CC0-1.0 +pragma solidity ^0.8.13; + +/// @author: manifold.xyz + +import {Create2} from "openzeppelin/utils/Create2.sol"; +import {ECDSA} from "openzeppelin/utils/cryptography/ECDSA.sol"; +import {Ownable} from "openzeppelin/access/Ownable.sol"; +import {Initializable} from "openzeppelin/proxy/utils/Initializable.sol"; +import {IERC1271} from "openzeppelin/interfaces/IERC1271.sol"; +import {SignatureChecker} from "openzeppelin/utils/cryptography/SignatureChecker.sol"; + +import {Address} from "../../lib/Address.sol"; +import {IAccountRegistry} from "../../interfaces/IAccountRegistry.sol"; +import {ERC1167ProxyBytecode} from "../../lib/ERC1167ProxyBytecode.sol"; + +contract AccountRegistryImplementation is Ownable, Initializable, IAccountRegistry { + using Address for address; + using ECDSA for bytes32; + + struct Signer { + address account; + bool isContract; + } + + error InitializationFailed(); + error ClaimFailed(); + error Unauthorized(); + + address public accountImplementation; + bytes public accountInitData; + Signer public signer; + + constructor() { + _disableInitializers(); + } + + function initialize( + address owner, + address accountImplementation_, + bytes calldata accountInitData_ + ) external initializer { + _transferOwnership(owner); + accountImplementation = accountImplementation_; + accountInitData = accountInitData_; + } + + /** + * @dev See {IAccountRegistry-createAccount} + */ + function createAccount(uint256 salt) external override returns (address) { + bytes memory code = ERC1167ProxyBytecode.createCode(accountImplementation); + address _account = Create2.computeAddress(bytes32(salt), keccak256(code)); + + if (_account.isDeployed()) return _account; + + _account = Create2.deploy(0, bytes32(salt), code); + + (bool success, ) = _account.call(accountInitData); + if (!success) revert InitializationFailed(); + + emit AccountCreated(_account, accountImplementation, salt); + + return _account; + } + + /** + * @dev See {IAccountRegistry-claimAccount} + */ + function claimAccount( + address owner, + uint256 salt, + uint256 expiration, + bytes32 message, + bytes calldata signature + ) external override returns (address) { + _verify(owner, salt, expiration, message, signature); + address _account = this.createAccount(salt); + + (bool success, ) = _account.call( + abi.encodeWithSignature("transferOwnership(address)", owner) + ); + if (!success) revert ClaimFailed(); + + emit AccountClaimed(_account, owner); + return _account; + } + + /** + * @dev See {IAccountRegistry-account} + */ + function account(uint256 salt) external view override returns (address) { + bytes memory code = ERC1167ProxyBytecode.createCode(accountImplementation); + return Create2.computeAddress(bytes32(salt), keccak256(code)); + } + + /** + * @dev See {IAccountRegistry-isValidSignature} + */ + function isValidSignature(bytes32 hash, bytes memory signature) external view returns (bytes4) { + bytes32 expectedHash = keccak256(abi.encodePacked(hash, msg.sender)); + bool isValid = SignatureChecker.isValidSignatureNow( + signer.account, + expectedHash, + signature + ); + if (isValid) { + return IERC1271.isValidSignature.selector; + } + + return ""; + } + + function updateSigner(address newSigner) external onlyOwner { + uint32 signerSize; + assembly { + signerSize := extcodesize(newSigner) + } + signer.account = newSigner; + signer.isContract = signerSize > 0; + } + + function _verify( + address owner, + uint256 salt, + uint256 expiration, + bytes32 message, + bytes calldata signature + ) internal view { + address signatureAccount; + + if (signer.isContract) { + if (!SignatureChecker.isValidSignatureNow(signer.account, message, signature)) + revert Unauthorized(); + } else { + signatureAccount = message.recover(signature); + } + + bytes32 expectedMessage = keccak256( + abi.encodePacked("\x19Ethereum Signed Message:\n84", owner, salt, expiration) + ); + + if ( + message != expectedMessage || + (!signer.isContract && signatureAccount != signer.account) || + (expiration != 0 && expiration < block.timestamp) + ) revert Unauthorized(); + } +} +``` + +### Example Account Implementation + +```solidity +// SPDX-License-Identifier: CC0-1.0 +pragma solidity ^0.8.13; + +/// @author: manifold.xyz + +import {IERC1271} from "openzeppelin/interfaces/IERC1271.sol"; +import {SignatureChecker} from "openzeppelin/utils/cryptography/SignatureChecker.sol"; +import {IERC165} from "openzeppelin/utils/introspection/IERC165.sol"; +import {ERC165Checker} from "openzeppelin/utils/introspection/ERC165Checker.sol"; +import {IERC721} from "openzeppelin/token/ERC721/IERC721.sol"; +import {IERC721Receiver} from "openzeppelin/token/ERC721/IERC721Receiver.sol"; +import {IERC1155Receiver} from "openzeppelin/token/ERC1155/IERC1155Receiver.sol"; +import {Initializable} from "openzeppelin/proxy/utils/Initializable.sol"; +import {Ownable} from "openzeppelin/access/Ownable.sol"; +import {IERC1967Account} from "./IERC1967Account.sol"; + +import {IAccount} from "../../interfaces/IAccount.sol"; + +/** + * @title ERC1967AccountImplementation + * @notice A lightweight, upgradeable smart contract wallet implementation + */ +contract ERC1967AccountImplementation is + IAccount, + IERC165, + IERC721Receiver, + IERC1155Receiver, + IERC1967Account, + Initializable, + Ownable +{ + address public registry; + + constructor() { + _disableInitializers(); + } + + function initialize() external initializer { + registry = msg.sender; + _transferOwnership(registry); + } + + function supportsInterface(bytes4 interfaceId) external pure returns (bool) { + return (interfaceId == type(IAccount).interfaceId || + interfaceId == type(IERC1967Account).interfaceId || + interfaceId == type(IERC1155Receiver).interfaceId || + interfaceId == type(IERC721Receiver).interfaceId || + interfaceId == type(IERC165).interfaceId); + } + + function onERC721Received( + address, + address, + uint256, + bytes memory + ) public pure returns (bytes4) { + return this.onERC721Received.selector; + } + + function onERC1155Received( + address, + address, + uint256, + uint256, + bytes memory + ) public pure returns (bytes4) { + return this.onERC1155Received.selector; + } + + function onERC1155BatchReceived( + address, + address, + uint256[] memory, + uint256[] memory, + bytes memory + ) public pure returns (bytes4) { + return this.onERC1155BatchReceived.selector; + } + + /** + * @dev {See IERC1967Account-executeCall} + */ + function executeCall( + address _target, + uint256 _value, + bytes calldata _data + ) external payable override onlyOwner returns (bytes memory _result) { + bool success; + // solhint-disable-next-line avoid-low-level-calls + (success, _result) = _target.call{value: _value}(_data); + require(success, string(_result)); + emit TransactionExecuted(_target, _value, _data); + return _result; + } + + /** + * @dev {See IAccount-setOwner} + */ + function setOwner(address _owner) external override onlyOwner { + _transferOwnership(_owner); + } + + receive() external payable {} + + function isValidSignature(bytes32 hash, bytes memory signature) external view returns (bytes4) { + if (owner() == registry) { + return IERC1271(registry).isValidSignature(hash, signature); + } + + bool isValid = SignatureChecker.isValidSignatureNow(owner(), hash, signature); + if (isValid) { + return IERC1271.isValidSignature.selector; + } + + return ""; + } +} +``` + +## Security Considerations + +### Front-running + +Deployment of reserved ownership accounts through an Account Registry Instance through calls to `createAccount` could be front-run by a malicious actor. However, if the malicious actor attempted to alter the `owner` parameter in the calldata, the Account Registry Instance would find the signature to be invalid, and revert the transaction. Thus, any successful front-running transaction would deploy an identical Account Instance to the original transaction, and the original owner would still gain control over the address. + +## Copyright + +Copyright and related rights waived via [CC0](../LICENSE.md). From f4c3a2f0b6ef4bbd218d86424539c42bf6a19ce0 Mon Sep 17 00:00:00 2001 From: Alex Stokes Date: Wed, 31 May 2023 11:20:03 -0600 Subject: [PATCH 39/97] Update EIP-4788: key beacon roots by root Merged by EIP-Bot. --- EIPS/eip-4788.md | 54 +++++++++++++++--------------------------------- 1 file changed, 17 insertions(+), 37 deletions(-) diff --git a/EIPS/eip-4788.md b/EIPS/eip-4788.md index 7bcb51807f309b..74521bc1d2dba8 100644 --- a/EIPS/eip-4788.md +++ b/EIPS/eip-4788.md @@ -25,12 +25,11 @@ restaking constructions, smart contract bridges, MEV mitigations and more. ## Specification -| constants | value | units -|--- |--- |--- -| `FORK_TIMESTAMP` | TBD | -| `HISTORY_STORAGE_ADDRESS` | `0xfffffffffffffffffffffffffffffffffffffffd` | -| `G_beacon_root` | 2100 | gas -| `SLOTS_PER_HISTORICAL_ROOT` | 8192 | slot(s) +| constants | value | units +|--- |--- |--- +| `FORK_TIMESTAMP` | TBD | +| `HISTORY_STORAGE_ADDRESS` | `0xfffffffffffffffffffffffffffffffffffffffd` | +| `G_beacon_root` | 2100 | gas ### Background @@ -43,7 +42,7 @@ To bound the amount of storage this construction consumes, a ring buffer is used Beginning at the execution timestamp `FORK_TIMESTAMP`, execution clients **MUST**: -1. set 32 bytes of the execution block header after the `excess_data_gas` to the 32 byte [hash tree root](https://github.com/ethereum/consensus-specs/blob/fa09d896484bbe240334fa21ffaa454bafe5842e/ssz/simple-serialize.md#merkleization) of the parent beacon block. +1. set 32 bytes of the execution block header after the last header field as of `FORK_TIMESTAMP` to the 32 byte [hash tree root](https://github.com/ethereum/consensus-specs/blob/fa09d896484bbe240334fa21ffaa454bafe5842e/ssz/simple-serialize.md#merkleization) of the parent beacon block. *NOTE*: this field is appended to the current block header structure with this EIP so that the size of the header grows after (and including) the `FORK_TIMESTAMP`. @@ -54,56 +53,37 @@ Beginning at the execution timestamp `FORK_TIMESTAMP`, execution clients **MUST* At the start of processing any execution block where `block.timestamp >= FORK_TIMESTAMP` (i.e. before processing any transactions), write the parent beacon root provided in the block header into the storage of the contract at `HISTORY_STORAGE_ADDRESS`. -This data is keyed by the slots containing the parent beacon block root which in general could be multiple slots for the -same root. To find the starting slot of the range, read the storage slot `SLOTS_PER_HISTORICAL_ROOT` (interpreted as a -256-bit byte array) which contains the big-endian encoding of the last slot value written to. This encoding should be interpreted -as a 64-bit big-endian integer that yields the starting slot. -Clients then iterate from the start slot (inclusive) to the end slot (exclusive) found in the header -and write the beacon block root into each slot value. - -*NOTE*: if the slot stored at `SLOTS_PER_HISTORICAL_ROOT` is all zeros, clients should use set the start slot to one less than the -slot in the header, e.g. `header.beacon_block_root_slot - 1`. - -After writing the block root in the relevant slots, store the current slot for use during the next update in the same storage slot -`SLOTS_PER_HISTORICAL_ROOT`. +The root itself is used as a key into the contract's storage and the timestamp of the header is written as the key's value. +The timestamp (a 64-bit unsigned integer value) is encoded as 32 bytes in big-endian format. In Python pseudocode: ```python -start_slot = to_uint64(sload(HISTORY_STORAGE_ADDRESS, SLOTS_PER_HISTORICAL_ROOT)) -end_slot = block_header.beacon_slot -if start_slot == 0: - start_slot = max(end_slot - 1, 0) - parent_beacon_block_root = block_header.parent_beacon_block_root +timestamp = to_uint256_be(block_header.timestamp) -for slot in range(start_slot, end_slot): - sstore(HISTORY_STORAGE_ADDRESS, slot % SLOTS_PER_HISTORICAL_ROOT, parent_beacon_block_root) - -sstore(HISTORY_STORAGE_ADDRESS, SLOTS_PER_HISTORICAL_ROOT, end_slot) +sstore(HISTORY_STORAGE_ADDRESS, parent_beacon_block_root, timestamp) ``` -When using any slot value as a key to the storage, the value under consideration must be converted to 32 bytes with big-endian encoding. - #### New stateful precompile Beginning at the execution timestamp `FORK_TIMESTAMP`, the code and storage at `HISTORY_STORAGE_ADDRESS` constitute a "stateful" precompile. -Callers of the precompile should provide the `slot` they are querying encoding a 64-bit unsigned integer as 256-bit big-endian data. -Recall this `slot` number should be reduced modulo the `SLOTS_PER_HISTORICAL_ROOT` constant to derive the correct key into the ring buffer structure. +Callers of the precompile should provide the `root` they are querying encoded as 32 bytes. Alongside the existing gas for calling the precompile, there is an additional gas cost of `G_beacon_root` cost to reflect the implicit `SLOAD` from -the precompile's state. The root is returned as 32 bytes in the caller's provided return buffer. +the precompile's state. The timestamp of the corresponding root is returned as 32 bytes in the caller's provided return buffer and represents the +64-bit unsigned integer from the header in big-endian format. In pseudocode: ```python -slot = to_uint64(evm.calldata[:32]) -root = sload(HISTORY_STORAGE_ADDRESS, slot % SLOTS_PER_HISTORICAL_ROOT) -evm.returndata[:32].set(root) +root = evm.calldata[:32] +timestamp = sload(HISTORY_STORAGE_ADDRESS, root) +evm.returndata[:32].set(timestamp) ``` -If there is no root stored at the requested slot number, the opcode follows the existing EVM semantics of `sload` returning `0`. +If there is no timestamp stored at the given root, the opcode follows the existing EVM semantics of `sload` returning `0`. ## Rationale From fb4993c0946a9b0452d1da72bf891ca1192a4a7c Mon Sep 17 00:00:00 2001 From: Jim McDonald Date: Thu, 1 Jun 2023 02:20:11 +0100 Subject: [PATCH 40/97] Update EIP-1185: Move to Review Merged by EIP-Bot. --- EIPS/eip-1185.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/EIPS/eip-1185.md b/EIPS/eip-1185.md index f46d8fcec7fed4..77964d90c4e817 100644 --- a/EIPS/eip-1185.md +++ b/EIPS/eip-1185.md @@ -4,7 +4,7 @@ title: Storage of DNS Records in ENS description: A system to store and retrieve DNS records within the ENS contract. author: Jim McDonald (@mcdee) discussions-to: https://ethereum-magicians.org/t/eip1185-dns-resolver-profile-for-ens/1589 -status: Draft +status: Review type: Standards Track category: ERC created: 2018-06-26 From 635e9c21d305728b7013bb42892856eeb99c2f60 Mon Sep 17 00:00:00 2001 From: lightclient <14004106+lightclient@users.noreply.github.com> Date: Thu, 1 Jun 2023 16:23:41 +0200 Subject: [PATCH 41/97] Update EIP-4844: add `data_gas_used` to header Merged by EIP-Bot. --- EIPS/eip-4844.md | 37 +++++++++++++++++++++---------------- 1 file changed, 21 insertions(+), 16 deletions(-) diff --git a/EIPS/eip-4844.md b/EIPS/eip-4844.md index b33ca9795fd580..3fb1d054419e90 100644 --- a/EIPS/eip-4844.md +++ b/EIPS/eip-4844.md @@ -122,7 +122,7 @@ The signature values `y_parity`, `r`, and `s` are calculated by constructing a s ### Header extension -The current header encoding is extended with a new 256-bit unsigned integer field `excess_data_gas`. This is the running total of excess data gas consumed on chain since this EIP was activated. If the total amount of data gas is below the +The current header encoding is extended with a new 64-bit unsigned integer field `data_gas_used` and a 256-bit unsigned integer field `excess_data_gas`. This is the running total of excess data gas consumed on chain since this EIP was activated. If the total amount of data gas is below the target, `excess_data_gas` is capped at zero. The resulting RLP encoding of the header is therefore: @@ -146,21 +146,22 @@ rlp([ 0x0000000000000000, # nonce base_fee_per_gas, withdrawals_root, - excess_data_gas + data_gas_used, + excess_data_gas, ]) ``` -The value of `excess_data_gas` can be calculated using the parent header and number of blobs in the block. +The value of `excess_data_gas` can be calculated using the parent header. ```python -def calc_excess_data_gas(parent: Header, consumed_data_gas: int) -> int: - if parent.excess_data_gas + consumed_data_gas < TARGET_DATA_GAS_PER_BLOCK: +def calc_excess_data_gas(parent: Header) -> int: + if parent.excess_data_gas + parent.data_gas_used < TARGET_DATA_GAS_PER_BLOCK: return 0 else: - return parent.excess_data_gas + consumed_data_gas - TARGET_DATA_GAS_PER_BLOCK + return parent.excess_data_gas + parent.data_gas_used - TARGET_DATA_GAS_PER_BLOCK ``` -For the first post-fork block, `parent.excess_data_gas` is evaluated as `0`. +For the first post-fork block, both `parent.data_gas_used` and `parent.excess_data_gas` are evaluated as `0`. ### Opcode to get versioned hashes @@ -208,8 +209,8 @@ We introduce data gas as a new type of gas. It is independent of normal gas and We use the `excess_data_gas` header field to store persistent data needed to compute the data gas price. For now, only blobs are priced in data gas. ```python -def calc_data_fee(tx: SignedBlobTransaction, parent: Header) -> int: - return get_total_data_gas(tx) * get_data_gasprice(parent) +def calc_data_fee(header: Header, tx: SignedBlobTransaction) -> int: + return get_total_data_gas(tx) * get_data_gasprice(header) def get_total_data_gas(tx: SignedBlobTransaction) -> int: return DATA_GAS_PER_BLOB * len(tx.blob_versioned_hashes) @@ -249,9 +250,12 @@ On the execution layer, the block validity conditions are extended as follows: ```python def validate_block(block: Block) -> None: ... + + # check that the excess data gas was updated correctly + assert block.header.excess_data_gas == calc_excess_data_gas(block.parent.header) - block_data_gas = 0 - + data_gas_used = 0 + for tx in block.transactions: ... @@ -276,16 +280,17 @@ def validate_block(block: Block) -> None: assert h[0] == BLOB_COMMITMENT_VERSION_KZG # ensure that the user was willing to at least pay the current data gasprice - assert tx.max_fee_per_data_gas >= get_data_gasprice(parent(block).header) + assert tx.max_fee_per_data_gas >= get_data_gasprice(block.header) # keep track of total data gas spent in the block - block_data_gas += get_total_data_gas(tx) + data_gas_used += get_total_data_gas(tx) # ensure the total data gas spent is at most equal to the limit - assert block_data_gas <= MAX_DATA_GAS_PER_BLOCK + assert data_gas_used <= MAX_DATA_GAS_PER_BLOCK + + # ensure data_gas_used matches header + assert block.header.data_gas_used == data_gas_used - # check that the excess data gas was updated correctly - assert block.header.excess_data_gas == calc_excess_data_gas(parent(block).header, block_data_gas) ``` ### Networking From f5179fa15a6a77042e68df5972e66f46d597e6ab Mon Sep 17 00:00:00 2001 From: lightclient <14004106+lightclient@users.noreply.github.com> Date: Thu, 1 Jun 2023 16:32:07 +0200 Subject: [PATCH 42/97] Update EIP-4844: clarify to must be non-nil Merged by EIP-Bot. --- EIPS/eip-4844.md | 10 ++++------ 1 file changed, 4 insertions(+), 6 deletions(-) diff --git a/EIPS/eip-4844.md b/EIPS/eip-4844.md index 3fb1d054419e90..a28109feaa73f5 100644 --- a/EIPS/eip-4844.md +++ b/EIPS/eip-4844.md @@ -107,10 +107,11 @@ We introduce a new [EIP-2718](./eip-2718.md) transaction, "blob transaction", wh rlp([chain_id, nonce, max_priority_fee_per_gas, max_fee_per_gas, gas_limit, to, value, data, access_list, max_fee_per_data_gas, blob_versioned_hashes, y_parity, r, s])`. ``` -The `max_priority_fee_per_gas` and `max_fee_per_gas` fields follow [EIP-1559](./eip-1559.md) semantics -and `access_list` follows [EIP-2930](./eip-2930.md). +The fields `chain_id`, `nonce`, `max_priority_fee_per_gas`, `max_fee_per_gas`, `gas_limit`, `value`, `data`, and `access_list` follow the same semantics as [EIP-1559](./eip-1559.md). -The `max_fee_per_data_gas` is `uint256` and the `blob_versioned_hashes` field represents a list of hash outputs from `kzg_to_versioned_hash`. +The field `to` deviates slightly from the semantics with the exception that it MUST NOT be `nil` and therefore must always represent a 20-byte address. This means that blob transactions cannot have the form of a create transaction. + +The field `max_fee_per_data_gas` is a `uint256` and the field `blob_versioned_hashes` represents a list of hash outputs from `kzg_to_versioned_hash`. The [EIP-2718](./eip-2718.md) `ReceiptPayload` for this transaction is `rlp([status, cumulative_transaction_gas_used, logs_bloom, logs])`. @@ -269,9 +270,6 @@ def validate_block(block: Block) -> None: # add validity logic specific to blob txs if type(tx) is SignedBlobTransaction: - - # destination must be not be empty - assert tx.to != None # there must be at least one blob assert len(tx.blob_versioned_hashes) > 0 From b5eabd7f0aa8fd86cf2d56f67c48552cb1df66ab Mon Sep 17 00:00:00 2001 From: Isaac Patka Date: Thu, 1 Jun 2023 10:45:23 -0400 Subject: [PATCH 43/97] Update EIP-4824: start Merged by EIP-Bot. --- EIPS/eip-4824.md | 236 +++++++++++++++++++++++++++++++++++++++-------- 1 file changed, 198 insertions(+), 38 deletions(-) diff --git a/EIPS/eip-4824.md b/EIPS/eip-4824.md index ed7404e6f9be1c..c9dd0459c40d6b 100644 --- a/EIPS/eip-4824.md +++ b/EIPS/eip-4824.md @@ -16,23 +16,24 @@ An API standard for decentralized autonomous organizations (DAOs), focused on re ## Motivation -DAOs, since being invoked in the Ethereum whitepaper, have been vaguely defined. This has led to a wide range of patterns but little standardization or interoperability between the frameworks and tools that have emerged. Standardization and interoperability are necessary to support a variety of use-cases. In particular, a standard daoURI, similar to tokenURI in [EIP-721](./eip-721), will enhance DAO discoverability, legibility, proposal simulation, and interoperability between tools. More consistent data across the ecosystem is also a prerequisite for future DAO standards. +DAOs, since being invoked in the Ethereum whitepaper, have been vaguely defined. This has led to a wide range of patterns but little standardization or interoperability between the frameworks and tools that have emerged. Standardization and interoperability are necessary to support a variety of use-cases. In particular, a standard daoURI, similar to tokenURI in [ERC-721](./eip-721), will enhance DAO discoverability, legibility, proposal simulation, and interoperability between tools. More consistent data across the ecosystem is also a prerequisite for future DAO standards. ## Specification The key words “MUST”, “MUST NOT”, “REQUIRED”, “SHALL”, “SHALL NOT”, “SHOULD”, “SHOULD NOT”, “RECOMMENDED”, “MAY”, and “OPTIONAL” in this document are to be interpreted as described in RFC 2119. -Every contract implementing this EIP MUST implement the `EIP4824` interface below: +Every contract implementing this EIP MUST implement the [ERC-4824](./eip-4824) interface below: ```solidity pragma solidity ^0.8.1; -/// @title EIP-4824 Common Interfaces for DAOs -/// @dev See https://eips.ethereum.org/EIPS/eip-4824 +/// @title ERC-4824 DAOs +/// @dev See +interface IERC-4824 { + event DAOURIUpdate(address daoAddress, string daoURI); -interface EIP4824 { - /// @notice A distinct Uniform Resource Identifier (URI) pointing to a JSON object following the "EIP-4824 DAO JSON-LD Schema". This JSON file splits into four URIs: membersURI, proposalsURI, activityLogURI, and governanceURI. The membersURI should point to a JSON file that conforms to the "EIP-4824 Members JSON-LD Schema". The proposalsURI should point to a JSON file that conforms to the "EIP-4824 Proposals JSON-LD Schema". The activityLogURI should point to a JSON file that conforms to the "EIP-4824 Activity Log JSON-LD Schema". The governanceURI should point to a flatfile, normatively a .md file. Each of the JSON files named above can be statically-hosted or dynamically-generated. - function daoURI() external view returns (string _daoURI); + /// @notice A distinct Uniform Resource Identifier (URI) pointing to a JSON object following the "ERC-4824 DAO JSON-LD Schema". This JSON file splits into four URIs: membersURI, proposalsURI, activityLogURI, and governanceURI. The membersURI should point to a JSON file that conforms to the "ERC-4824 Members JSON-LD Schema". The proposalsURI should point to a JSON file that conforms to the "ERC-4824 Proposals JSON-LD Schema". The activityLogURI should point to a JSON file that conforms to the "ERC-4824 Activity Log JSON-LD Schema". The governanceURI should point to a flatfile, normatively a .md file. Each of the JSON files named above can be statically-hosted or dynamically-generated. + function daoURI() external view returns (string memory _daoURI); } ``` @@ -47,55 +48,133 @@ The DAO JSON-LD Schema mentioned above: "membersURI": "", "proposalsURI": "", "activityLogURI": "", - "governanceURI": "" + "governanceURI": "", + "contractsURI": "" } ``` -A DAO MAY inherit the above interface above or it MAY create an external registration contract that is compliant with this EIP. The external registration contract MUST store the DAO’s primary address. +A DAO MAY inherit the above interface above or it MAY create an external registration contract that is compliant with this EIP. If a DAO creates an external registration contract, the registration contract MUST store the DAO’s primary address. + +If the DAO inherits the above interface, it SHOULD define a method for updating daoURI. If the DAO uses an external registration contract, the registration contract SHOULD contain some access control logic to enable efficient updating for daoURI. ```solidity pragma solidity ^0.8.1; -/// @title EIP-4824 Common Interfaces for DAOs +/// @title ERC-4824 Common Interfaces for DAOs /// @dev See +/// @title ERC-4824: DAO Registration +contract ERC-4824Registration is IERC-4824, AccessControl { + bytes32 public constant MANAGER_ROLE = keccak256("MANAGER_ROLE"); -error NotOwner(); -error NotOffered(); - -contract EIP4824Registration is EIP4824 { string private _daoURI; - address daoAddress; - event NewURI(string daoURI); + address daoAddress; constructor() { daoAddress = address(0xdead); } - function initialize(address _daoAddress, string memory daoURI_) external { + /// @notice Set the initial DAO URI and offer manager role to an address + /// @dev Throws if initialized already + /// @param _daoAddress The primary address for a DAO + /// @param _manager The address of the URI manager + /// @param daoURI_ The URI which will resolve to the governance docs + function initialize( + address _daoAddress, + address _manager, + string memory daoURI_, + address _ERC-4824Index + ) external { + initialize(_daoAddress, daoURI_, _ERC-4824Index); + _grantRole(MANAGER_ROLE, _manager); + } + + /// @notice Set the initial DAO URI + /// @dev Throws if initialized already + /// @param _daoAddress The primary address for a DAO + /// @param daoURI_ The URI which will resolve to the governance docs + function initialize( + address _daoAddress, + string memory daoURI_, + address _ERC-4824Index + ) public { if (daoAddress != address(0)) revert AlreadyInitialized(); daoAddress = _daoAddress; - _daoURI = daoURI_; + _setURI(daoURI_); + + _grantRole(DEFAULT_ADMIN_ROLE, _daoAddress); + _grantRole(MANAGER_ROLE, _daoAddress); + + ERC-4824Index(_ERC-4824Index).logRegistration(address(this)); + } + + /// @notice Update the URI for a DAO + /// @dev Throws if not called by dao or manager + /// @param daoURI_ The URI which will resolve to the governance docs + function setURI(string memory daoURI_) public onlyRole(MANAGER_ROLE) { + _setURI(daoURI_); } - function setURI(string memory daoURI_) external { - if (msg.sender != daoAddress) revert NotOwner(); + function _setURI(string memory daoURI_) internal { _daoURI = daoURI_; - emit NewURI(daoURI_); + emit DAOURIUpdate(daoAddress, daoURI_); } function daoURI() external view returns (string memory daoURI_) { return _daoURI; } + + function supportsInterface( + bytes4 interfaceId + ) public view virtual override returns (bool) { + return + interfaceId == type(IERC-4824).interfaceId || + super.supportsInterface(interfaceId); + } +} +``` + +### Indexing + +If a DAO inherits the ERC-4824 interface from a 4824-compliant DAO factory, then the DAO factory SHOULD incorporate a call to an indexer contract as part of the DAO's initialization to enable efficient network indexing. If the DAO is [ERC-165](./eip-165)-compliant, the factory can do this without additional permissions. If the DAO is _not_ compliant with ERC-165, the factory SHOULD first obtain access control rights to the indexer contract and then call logRegistration directly with the address of the new DAO and the daoURI of the new DAO. Note that any user, including the DAO itself, MAY call logRegistration and submit a registration for a DAO which inherits the ERC-4824 interface and which is also ERC-165-compliant. + +```solidity +pragma solidity ^0.8.1; + +error ERC-4824InterfaceNotSupported(); + +contract ERC-4824Index is AccessControl { + using ERC165Checker for address; + + bytes32 public constant REGISTRATION_ROLE = keccak256("REGISTRATION_ROLE"); + + event DAOURIRegistered(address daoAddress); + + constructor() { + _grantRole(DEFAULT_ADMIN_ROLE, msg.sender); + _grantRole(REGISTRATION_ROLE, msg.sender); + } + + function logRegistrationPermissioned( + address daoAddress + ) external onlyRole(REGISTRATION_ROLE) { + emit DAOURIRegistered(daoAddress); + } + + function logRegistration(address daoAddress) external { + if (!daoAddress.supportsInterface(type(IERC-4824).interfaceId)) + revert ERC-4824InterfaceNotSupported(); + emit DAOURIRegistered(daoAddress); + } } ``` -If a DAO uses an external registration contract, the DAO SHOULD use a common registration factory contract to enable efficient network indexing. +If a DAO uses an external registration contract, the DAO SHOULD use a common registration factory contract linked to a common indexer to enable efficient network indexing. ```solidity pragma solidity ^0.8.1; -/// @title EIP-4824 Common Interfaces for DAOs +/// @title ERC-4824 Common Interfaces for DAOs /// @dev See contract CloneFactory { @@ -118,30 +197,69 @@ contract CloneFactory { } } -contract EIP4824RegistrationFactory is CloneFactory { +contract ERC-4824RegistrationSummoner { event NewRegistration( address indexed daoAddress, string daoURI, address registration ); + address public ERC-4824Index; address public template; /*Template contract to clone*/ - constructor(address _template) public { + constructor(address _template, address _ERC-4824Index) { template = _template; + ERC-4824Index = _ERC-4824Index; } - function summonRegistration(string calldata daoURI_) external { - EIP4824Registration reg = EIP4824Registration(createClone(template)); /*Create a new clone of the template*/ - reg.initialize(msg.sender, daoURI_); - emit NewRegistration(msg.sender, daoURI_, address(reg)); + function registrationAddress( + address by, + bytes32 salt + ) external view returns (address addr, bool exists) { + addr = Clones.predictDeterministicAddress( + template, + _saltedSalt(by, salt), + address(this) + ); + exists = addr.code.length > 0; + } + + function summonRegistration( + bytes32 salt, + string calldata daoURI_, + address manager, + address[] calldata contracts, + bytes[] calldata data + ) external returns (address registration, bytes[] memory results) { + registration = Clones.cloneDeterministic( + template, + _saltedSalt(msg.sender, salt) + ); + + if (manager == address(0)) { + ERC-4824Registration(registration).initialize( + msg.sender, + daoURI_, + ERC-4824Index + ); + } else { + ERC-4824Registration(registration).initialize( + msg.sender, + manager, + daoURI_, + ERC-4824Index + ); + } + + results = _callContracts(contracts, data); + + emit NewRegistration(msg.sender, daoURI_, registration); } -} ``` ### Members -Members JSON-LD Schema. +Members JSON-LD Schema. Every contract implementing this EIP SHOULD implement a membersuRI pointing to a JSON object satisfying this schema. ```json { @@ -163,7 +281,7 @@ Members JSON-LD Schema. ### Proposals -Proposals JSON-LD Schema. Every contract implementing this EIP should implement a proposalsURI pointing to a JSON object satisfying this schema. +Proposals JSON-LD Schema. Every contract implementing this EIP SHOULD implement a proposalsURI pointing to a JSON object satisfying this schema. In particular, any on-chain proposal MUST be associated to an id of the form CAIP10_ADDRESS + “?proposalId=” + PROPOSAL_COUNTER, where CAIP10_ADDRESS is an address following the CAIP-10 standard and PROPOSAL_COUNTER is an arbitrary identifier such as a uint256 counter or a hash that is locally unique per CAIP-10 address. Off-chain proposals MAY use a similar id format where CAIP10_ADDRESS is replaced with an appropriate URI or URL. @@ -196,7 +314,7 @@ In particular, any on-chain proposal MUST be associated to an id of the form CAI ### Activity Log -Activity Log JSON-LD Schema. +Activity Log JSON-LD Schema. Every contract implementing this EIP SHOULD implement a activityLogURI pointing to a JSON object satisfying this schema. ```json { @@ -208,8 +326,8 @@ Activity Log JSON-LD Schema. "id": "", "type": "activity", "proposal": { - "id": "", "type": "proposal" + "id": "", }, "member": { "type": "EthereumAddress", @@ -222,8 +340,8 @@ Activity Log JSON-LD Schema. "id": "", "type": "activity", "proposal": { - "id": "", "type": "proposal" + "id": "", }, "member": { "type": "EthereumAddress", @@ -234,9 +352,43 @@ Activity Log JSON-LD Schema. } ``` +### Contracts + +Contracts JSON-LD Schema. Every contract implementing this EIP SHOULD implement a contractsURI pointing to a JSON object satisfying this schema. + +Further, every contractsURI SHOULD include at least the contract inheriting the ERC-4824 interface. + +``` +{ + "@context": "", + "type": "DAO", + "name": "", + "contracts": [ + { + "type": "EthereumAddress", + "id": "
", + "name": "", + "description": "" + }, + { + "type": "EthereumAddress", + "id": "
", + "name": "", + "description": "" + } + { + "type": "EthereumAddress", + "id": "
", + "name": "", + "description": "" + } + ] +} +``` + ## Rationale -In this standard, we assume that all DAOs possess at least two primitives: *membership* and *behavior*. *Membership* is defined by a set of addresses. *Behavior* is defined by a set of possible contract actions, including calls to external contracts and calls to internal functions. *Proposals* relate membership and behavior; they are objects that members can interact with and which, if and when executed, become behaviors of the DAO. +In this standard, we assume that all DAOs possess at least two primitives: _membership_ and _behavior_. _Membership_ is defined by a set of addresses. _Behavior_ is defined by a set of possible contract actions, including calls to external contracts and calls to internal functions. _Proposals_ relate membership and behavior; they are objects that members can interact with and which, if and when executed, become behaviors of the DAO. ### APIs, URIs, and off-chain data @@ -277,7 +429,7 @@ Proposals have become a standard way for the members of a DAO to trigger on-chai The activity log JSON is intended to capture the interplay between a member of a DAO and a given proposal. Examples of activities include the creation/submission of a proposal, voting on a proposal, disputing a proposal, and so on. -*Alternatives we considered: history, interactions* +_Alternatives we considered: history, interactions_ ### governanceURI @@ -285,7 +437,13 @@ Membership, to be meaningful, usually implies rights and affordances of some sor We chose the word “governance” as an appropriate word that reflects (1) the widespread use of the word in the DAO ecosystem and (2) the common practice of emitting a governance.md file in open-source software projects. -*Alternative names considered: description, readme, constitution* +_Alternative names considered: description, readme, constitution_ + +### contractsURI + +Over the course of community conversations, multiple parties raised the need to report on, audit, and index the different contracts belonging to a given DAO. Some of these contracts are deployed as part of the modular design of a single DAO framework, e.g. the core, voting, and timelock contracts within Open Zeppelin / Compound Governor. In other cases, a DAO might deploy multiple multsigs as treasuries and/or multiple subDAOs that are effectively controlled by the DAO. ContractsURI offers a generic way of declaring these many instruments. + +_Alternative names considered: contractsRegistry, contractsList_ ### Why JSON-LD @@ -300,6 +458,7 @@ The initial draft standard was developed as part of the DAOstar One roundtable s In-person events will be held at Schelling Point 2022 and at ETHDenver 2022, where we hope to receive more comments from the community. We also plan to schedule a series of community calls through early 2022. ## Backwards Compatibility + Existing contracts that do not wish to use this specification are unaffected. DAOs that wish to adopt the standard without updating or migrating contracts can do so via an external registration contract. ## Security Considerations @@ -309,5 +468,6 @@ This standard defines the interfaces for the DAO URIs but does not specify the r Indexers that rely on the data returned by the URI should take caution if DAOs return executable code from the URIs. This executable code might be intended to get the freshest information on membership, proposals, and activity log, but it could also be used to run unrelated tasks. ## Copyright + Copyright and related rights waived via [CC0](../LICENSE.md). From 9ba7e4c9154ef03ba3320b4f9ff9ba908a664573 Mon Sep 17 00:00:00 2001 From: zakrad <49591476+zakrad@users.noreply.github.com> Date: Thu, 1 Jun 2023 19:08:38 +0330 Subject: [PATCH 44/97] Update EIP-2612: fix misplaced bracket (#7077) * Update eip-2612.md * Update eip-2612.md --------- Co-authored-by: zakrad <1@1.com> --- EIPS/eip-2612.md | 35 ++++++++++++++++++++++------------- 1 file changed, 22 insertions(+), 13 deletions(-) diff --git a/EIPS/eip-2612.md b/EIPS/eip-2612.md index eecb1f7dfc77b0..e32295ba1afc7e 100644 --- a/EIPS/eip-2612.md +++ b/EIPS/eip-2612.md @@ -12,45 +12,49 @@ requires: 20, 712 --- ## Abstract + Arguably one of the main reasons for the success of [EIP-20](./eip-20.md) tokens lies in the interplay between `approve` and `transferFrom`, which allows for tokens to not only be transferred between externally owned accounts (EOA), but to be used in other contracts under application specific conditions by abstracting away `msg.sender` as the defining mechanism for token access control. However, a limiting factor in this design stems from the fact that the EIP-20 `approve` function itself is defined in terms of `msg.sender`. This means that user's _initial action_ involving EIP-20 tokens must be performed by an EOA (_but see Note below_). If the user needs to interact with a smart contract, then they need to make 2 transactions (`approve` and the smart contract call which will internally call `transferFrom`). Even in the simple use case of paying another person, they need to hold ETH to pay for transaction gas costs. -This ERC extends the EIP-20 standard with a new function `permit`, which allows users to modify the `allowance` mapping using a signed message, instead of through `msg.sender`. +This ERC extends the EIP-20 standard with a new function `permit`, which allows users to modify the `allowance` mapping using a signed message, instead of through `msg.sender`. For an improved user experience, the signed data is structured following [EIP-712](./eip-712.md), which already has wide spread adoption in major RPC providers. **_Note:_** EIP-20 must be performed by an EOA unless the address owning the token is actually a contract wallet. Although contract wallets solves many of the same problems that motivates this EIP, they are currently only scarcely adopted in the ecosystem. Contract wallets suffer from a UX problem -- since they separate the EOA `owner` of the contract wallet from the contract wallet itself (which is meant to carry out actions on the `owner`s behalf and holds all of their funds), user interfaces need to be specifically designed to support them. The `permit` pattern reaps many of the same benefits while requiring little to no change in user interfaces. ## Motivation + While EIP-20 tokens have become ubiquitous in the Ethereum ecosystem, their status remains that of second class tokens from the perspective of the protocol. The ability for users to interact with Ethereum without holding any ETH has been a long outstanding goal and the subject of many EIPs. So far, many of these proposals have seen very little adoption, and the ones that have been adopted (such as [EIP-777](./eip-777.md)), introduce a lot of additional functionality, causing unexpected behavior in mainstream contracts. -This ERC proposes an alternative solution which is designed to be as minimal as possible and to only address _one problem_: the lack of abstraction in the EIP-20 `approve` method. +This ERC proposes an alternative solution which is designed to be as minimal as possible and to only address _one problem_: the lack of abstraction in the EIP-20 `approve` method. While it may be tempting to introduce `*_by_signature` counterparts for every EIP-20 function, they are intentionally left out of this EIP-20 for two reasons: - - the desired specifics of such functions, such as decision regarding fees for `transfer_by_signature`, possible batching algorithms, varies depending on the use case, and, - - they can be implemented using a combination of `permit` and additional helper contracts without loss of generality. +- the desired specifics of such functions, such as decision regarding fees for `transfer_by_signature`, possible batching algorithms, varies depending on the use case, and, +- they can be implemented using a combination of `permit` and additional helper contracts without loss of generality. ## Specification + Compliant contracts must implement 3 new functions in addition to EIP-20: + ```sol function permit(address owner, address spender, uint value, uint deadline, uint8 v, bytes32 r, bytes32 s) external function nonces(address owner) external view returns (uint) function DOMAIN_SEPARATOR() external view returns (bytes32) ``` + The semantics of which are as follows: -For all addresses `owner`, `spender`, uint256s `value`, `deadline` and `nonce`, uint8 `v`, bytes32 `r` and `s`, -a call to `permit(owner, spender, value, deadline, v, r, s)` will set +For all addresses `owner`, `spender`, uint256s `value`, `deadline` and `nonce`, uint8 `v`, bytes32 `r` and `s`, +a call to `permit(owner, spender, value, deadline, v, r, s)` will set `approval[owner][spender]` to `value`, increment `nonces[owner]` by 1, -and emit a corresponding `Approval` event, +and emit a corresponding `Approval` event, if and only if the following conditions are met: - - The current blocktime is less than or equal to `deadline`. - `owner` is not the zero address. - `nonces[owner]` (before the state update) is equal to `nonce`. @@ -71,9 +75,11 @@ keccak256(abi.encodePacked( deadline)) )) ``` + where `DOMAIN_SEPARATOR` is defined according to EIP-712. The `DOMAIN_SEPARATOR` should be unique to the contract and chain to prevent replay attacks from other domains, and satisfy the requirements of EIP-712, but is otherwise unconstrained. A common choice for `DOMAIN_SEPARATOR` is: + ```solidity DOMAIN_SEPARATOR = keccak256( abi.encode( @@ -86,7 +92,7 @@ DOMAIN_SEPARATOR = keccak256( ``` In other words, the message is the EIP-712 typed structure: - + ```js { "types": { @@ -129,6 +135,7 @@ In other words, the message is the EIP-712 typed structure: "type": "uint256" } ], + }, "primaryType": "Permit", "domain": { "name": erc20name, @@ -143,14 +150,14 @@ In other words, the message is the EIP-712 typed structure: "nonce": nonce, "deadline": deadline } -}} +} ``` Note that nowhere in this definition we refer to `msg.sender`. The caller of the `permit` function can be any address. - ## Rationale -The `permit` function is sufficient for enabling any operation involving EIP-20 tokens to be paid for using the token itself, rather than using ETH. + +The `permit` function is sufficient for enabling any operation involving EIP-20 tokens to be paid for using the token itself, rather than using ETH. The `nonces` mapping is given for replay protection. @@ -158,11 +165,12 @@ A common use case of `permit` has a relayer submit a `Permit` on behalf of the ` EIP-712 typed messages are included because of its wide spread adoption in many wallet providers. - ## Backwards Compatibility + There are already a couple of `permit` functions in token contracts implemented in contracts in the wild, most notably the one introduced in the `dai.sol`. Its implementation differs slightly from the presentation here in that: + - instead of taking a `value` argument, it takes a bool `allowed`, setting approval to 0 or `uint(-1)`. - the `deadline` argument is instead called `expiry`. This is not just a syntactic change, as it effects the contents of the signed message. @@ -185,4 +193,5 @@ The standard EIP-20 race condition for approvals (SWC-114) applies to `permit` a If the `DOMAIN_SEPARATOR` contains the `chainId` and is defined at contract deployment instead of reconstructed for every signature, there is a risk of possible replay attacks between chains in the event of a future chain split. ## Copyright + Copyright and related rights waived via [CC0](../LICENSE.md). From e0c976e7d98e97cbbd962d212a413b56eddba656 Mon Sep 17 00:00:00 2001 From: Paul Sullivan <34427270+sullivph@users.noreply.github.com> Date: Thu, 1 Jun 2023 13:59:57 -0400 Subject: [PATCH 45/97] Update EIP-6981: Update Account Instance Signatures section Merged by EIP-Bot. --- EIPS/eip-6981.md | 12 ++++++++---- 1 file changed, 8 insertions(+), 4 deletions(-) diff --git a/EIPS/eip-6981.md b/EIPS/eip-6981.md index fe886194c4bbe0..4ac21cdf2710e5 100644 --- a/EIPS/eip-6981.md +++ b/EIPS/eip-6981.md @@ -8,7 +8,7 @@ status: Draft type: Standards Track category: ERC created: 2023-04-25 -requires: 1167, 1271 +requires: 1167, 1271, 6492 --- ## Abstract @@ -148,9 +148,13 @@ interface IAccount is IERC1271 { #### Account Instance Signatures -- Account Instances MUST support [ERC-1271](./eip-1271.md) by implementing an `isValidSignature` function. -- If an Account instance is claimed, the owner should generate the signature, and `isValidSignature` SHOULD verify that the message hash and signature are valid for the current owner of the Account Instance. -- If an Account Instance is unclaimed, the registry signer should generate the signature using a composite hash of the original message and address of the Account Instance described [above](#isvalidsignature), and `isValidSignature` SHOULD forward the message hash and signature to the Account Registry Instance's `isValidSignature` function. +Account Instances MUST support [ERC-1271](./eip-1271.md) by implementing an `isValidSignature` function. When the owner of an Account Instance wants to sign a message (e.g. to log in to a dApp), the signature MUST be generated in one of the following ways, depending the state of the Account Instance: + +1. If the Account instance is deployed and claimed, the owner should generate the signature, and `isValidSignature` SHOULD verify that the message hash and signature are valid for the current owner of the Account Instance. +2. If the Account Instance is deployed, but unclaimed, the registry signer should generate the signature using a composite hash of the original message and address of the Account Instance described [above](#isvalidsignature), and `isValidSignature` SHOULD forward the message hash and signature to the Account Registry Instance's `isValidSignature` function. +3. If the Account Instance is not deployed, the registry signer should generate a signature on the composite hash as done in situation 2, and wrap the signature according to [ERC-6492](./eip-6492.md#signer-side) (e.g. `concat(abi.encode((registryAddress, createAccountCalldata, compositeHashSignature), (address, bytes, bytes)), magicBytes)`). + +Signature validation for Account Instances should be done according to [ERC-6492](./eip-6492.md#verifier-side). ## Rationale From e5f4c0eae2a02ae76c8b9b3ca9a47e4a00415433 Mon Sep 17 00:00:00 2001 From: Tim Beiko Date: Thu, 1 Jun 2023 17:36:39 -0700 Subject: [PATCH 46/97] Update EIP-6953: Move to Review Merged by EIP-Bot. --- EIPS/eip-6953.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/EIPS/eip-6953.md b/EIPS/eip-6953.md index f0af144d603aaf..6e963f7a9fc4d8 100644 --- a/EIPS/eip-6953.md +++ b/EIPS/eip-6953.md @@ -4,7 +4,7 @@ title: Network Upgrade Activation Triggers description: Exhaustive list of network upgrade activation mechanisms author: Tim Beiko (@timbeiko) discussions-to: https://ethereum-magicians.org/t/eip-6666-network-upgrade-activation-triggers/14047 -status: Draft +status: Review type: Informational created: 2023-04-28 requires: 2982, 3675, 6122 @@ -16,7 +16,7 @@ This EIP outlines the various network upgrade activation triggers used on Ethere ## Motivation -This EIP aims to provide users and developers with a single source of truth for understanding the various upgrade activation patterns used throughout Ethereum's history. +This EIP aims to provide users and developers with a single source of truth for understanding the various upgrade activation patterns used throughout Ethereum's history. It does not aim to be a comprehensive, ongoing record, of upgrades and their activations mechanism. Readers should assume that future upgrades use the mechanism described in the [Post Merge Upgrades](#post-merge-upgrades) section, unless this EIP is superceded by another one. ## Specification From e49d2d7274363658cbaee3679b29d67c902a2a43 Mon Sep 17 00:00:00 2001 From: cf Date: Thu, 1 Jun 2023 20:38:31 -0400 Subject: [PATCH 47/97] Add EIP: NFT Creator Attribution Merged by EIP-Bot. --- EIPS/eip-7015.md | 184 +++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 184 insertions(+) create mode 100644 EIPS/eip-7015.md diff --git a/EIPS/eip-7015.md b/EIPS/eip-7015.md new file mode 100644 index 00000000000000..480ec88d067f5d --- /dev/null +++ b/EIPS/eip-7015.md @@ -0,0 +1,184 @@ +--- +eip: 7015 +title: NFT Creator Attribution +description: Extending ERC-721 with cryptographically secured creator attribution. +author: Carlos Flores (@strollinghome) +discussions-to: https://ethereum-magicians.org/t/eip-authorship-attribution-for-erc721/14244 +status: Draft +type: Standards Track +category: ERC +created: 2023-05-11 +requires: 55, 155, 712, 721 +--- + +## Abstract + +This Ethereum Improvement Proposal aims to solve the issue of creator attribution for [ERC-721](./eip-721.md) Non-Fungible Tokens (NFT). To achieve this, this EIP proposes a mechanism where the NFT creator signs the required parameters for the NFT creation, including the NFT metadata and a hash of any other relevant information. The signed parameters and the signature are then validated and emitted during the deployment transaction, which allows the NFT to validate the creator and NFT platforms to attribute creatorship correctly. This method ensures that even if a different wallet sends the deployment transaction, the correct account is attributed as the creator. + +## Motivation + +Current NFT platforms assume that the wallet deploying the smart contract is the creator of the NFT, leading to a misattribution in cases where a different wallet sends the deployment transaction. This happens often when working with smart wallet accounts, and new contract deployment strategies such as the first collector deploying the NFT contract. This proposal aims to solve the problem by allowing creators to sign the parameters required for NFT creation so that any wallet can send the deployment transaction with an signal in a verifiable way who is the creator. + +## Specification + +The keywords “MUST,” “MUST NOT,” “REQUIRED,” “SHALL,” “SHALL NOT,” “SHOULD,” “SHOULD NOT,” “RECOMMENDED,” “MAY,” and “OPTIONAL” in this document are to be interpreted as described in RFC 2119. + +ERC-721 compliant contracts MAY implement this NFT Creator Attribution extension to provide a standard event to be emitted that defines the NFT creator at the time of contract creation. + +This EIP takes advantage of the fact that contract addresses can be precomputed before a contract is deployed. Whether the NFT contract is deployed through another contract (a factory) or through an EOA, the creator can be correctly attributed using this specification. + +**Signing Mechanism** + +Creator consent is given by signing an [EIP-712](./eip-712.md) compatible message; all signatures compliant with this EIP MUST include all fields defined. The struct signed is: + +```solidity +struct CreatorAttribution { + string name; + string symbol; + bytes32 salt; + address token; +} +``` + +Where `name` and `symbol` are the ERC-721 metadata parameters, `salt` is an additional randomness parameter, and `token` is the NFTs address that will be deployed. Any extra parameters used to deploy the NFT contract MAY be hashed into the `salt` parameter. + +**Signature Validation** + +Creator attribution is given through a signature verification that MUST be verified by the NFT contract and an event that MUST be emitted by the NFT contract during the deployment transaction. The event includes all the necessary fields for reconstructing the signed digest and validating the signature to ensure it matches the specified creator. The event name is `CreatorAttribution` and includes the following fields: + +- `name`: ERC-721Metadata name parameter +- `symbol`: ERC-721Metadata symbol parameter +- `salt`: an extra randomness parameter that encodes other relevant information for deploying the NFT contract +- `domainName`: the domain name of the contract verifying the singature (for EIP-712 signature validation) +- `version`: the version of the contract verifying the signature (for EIP-712 signature validation) +- `creator`: the account address for the creator of the NFT +- `signature`: the creator’s signature + +The event is defined as follows: + +```solidity +event CreatorAttribution( + string name, // <------------------------------------- + string symbol, // Parameters signed by creator | + bytes32 salt, // | + string domainName, // <--- EIP-712 Domain Data ------------- + string version, // <------------------------------------- + address creator, // <--- Creator -------------------------- + bytes signature // <--- Creator Signature ---------------- +); +``` + +Note that although the `chainId` parameters is necessary for [EIP-712](./eip-712.md) signatures, we omit the parameter from the event as it can be inferred through the transaction data. Similarly, the `token` parameter in the `CreatorAttribution` stuct MUST match the address of the `emitter` field of the event, hence we omit it as well. + +A platform can verify the validity of the creator attribution by reconstructing the signature digest with the parameters emitted and recovering the signer from the `signature` parameter. The `creator` parameter MUST match the recovered signer from the `signature` parameter. After verification, platforms can safely attribute the `creator` address as the creator instead of the account that submitted the transaction. + +### Reference Implementation + +#### Example signature validator + +```solidity +// SPDX-License-Identifier: CC0-1.0 +pragma solidity 0.8.19; + +import "openzeppelin-contracts/contracts/utils/cryptography/EIP712.sol"; +import "openzeppelin-contracts/contracts/interfaces/IERC1271.sol"; + +abstract contract ERC7015 is EIP712 { + error Invalid_Signature(); + + event CreatorAttribution( + string name, + string symbol, + bytes32 salt, + string domainName, + string version, + address creator, + bytes signature + ); + + /// @notice Define magic value to verify smart contract signatures (ERC1271). + bytes4 internal constant MAGIC_VALUE = + bytes4(keccak256("isValidSignature(bytes32,bytes)")); + + bytes32 public constant TYPEHASH = + keccak256( + "CreatorAttribution(string name,string symbol,bytes32 salt,address token)" + ); + + constructor() EIP712("ERC7015", "1") {} + + function _validateSignature( + string memory name, + string memory symbol, + bytes32 salt, + address creator, + bytes memory signature + ) internal { + if (!_isValid(name, symbol, salt, address(this), creator, signature)) + revert Invalid_Signature(); + + emit CreatorAttribution( + name, + symbol, + salt, + "ERC7015", + "1", + creator, + signature + ); + } + + function _isValid( + string memory name, + string memory symbol, + bytes32 salt, + address token, + address signer, + bytes memory signature + ) internal view returns (bool) { + require(signer != address(0), "cannot validate"); + + bytes32 digest = _hashTypedDataV4( + keccak256(abi.encode(TYPEHASH, name, symbol, salt, token)) + ); + + if (signer.code.length != 0) { + try IERC1271(signer).isValidSignature(digest, signature) returns ( + bytes4 magicValue + ) { + return MAGIC_VALUE == magicValue; + } catch { + return false; + } + } + + address recoveredSigner = ECDSA.recover(digest, signature); + + return recoveredSigner == signer; + } +} +``` + +## Rationale + +By standardizing the `CreatorAttribution` event, this EIP enables platforms to ascertain creator attribution without relying on implicit assumptions. Establishing a standard for creator attribution empowers platforms to manage the complex aspects of deploying contracts while preserving accurate onchain creator information. This approach ensures a more reliable and transparent method for identifying NFT creators, fostering trust among participants in the NFT ecosystem. + +[ERC-5375](./eip-5375.md) attempts to solve the same issue and although offchain data offers improved backward compatibility, ensuring accurate and immutable creator attribution is vital for NFTs. A standardized onchain method for creator attribution is inherently more reliable and secure. + +In contrast to this proposal, ERC-5375 does not facilitate specifying creators for all tokens within an NFT collection, which is a prevalent practice, particularly in emerging use cases. + +Both this proposal and ERC-5375 share similar limitations regarding address-based creator attribution: + +> The standard defines a protocol to verify that a certain *address* provided consent. However, it does not guarantee that the address corresponds to the expected creator […]. Proving a link between an address and the entity behind it is beyond the scope of this document. + +## Backwards Compatibility + +Since the standard requires an event to be emitted during the NFTs deployment transaction, existing NFTs cannot implement this standard. + +## Security Considerations + +A potential attack exploiting this proposal could involve deceiving creators into signing creator attribution consent messages unintentionally. Consequently, creators MUST ensure that all signature fields correspond to the necessary ones before signing. + +## Copyright + +Copyright and related rights waived via [CC0](../LICENSE.md). From 9c79a0597d3ddcccb06d2c4743a50b4b8dcd06fe Mon Sep 17 00:00:00 2001 From: Eduard Fina <67655321+eduardfina@users.noreply.github.com> Date: Fri, 2 Jun 2023 02:40:26 +0200 Subject: [PATCH 48/97] Add EIP: ERC-721 with transaction validation step. Merged by EIP-Bot. --- EIPS/eip-6997.md | 381 +++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 381 insertions(+) create mode 100644 EIPS/eip-6997.md diff --git a/EIPS/eip-6997.md b/EIPS/eip-6997.md new file mode 100644 index 00000000000000..3cccd5a21f571e --- /dev/null +++ b/EIPS/eip-6997.md @@ -0,0 +1,381 @@ +--- +eip: 6997 +title: ERC-721 with transaction validation step. +description: A new validation step for transfer and approve calls, achieving a security step in case of stolen wallet. +author: Eduard López i Fina (@eduardfina) +discussions-to: https://ethereum-magicians.org/t/erc721-with-a-validation-step/14071 +status: Draft +type: Standards Track +category: ERC +created: 2023-05-07 +requires: 721 +--- + +## Abstract + +This standard is an extension of [ERC-721](./eip-721.md). It defines new validation functionality to avoid wallet draining: every `transfer` or `approve` will be locked waiting for validation. + +## Motivation + +The power of the blockchain is at the same time its weakness: giving the user full responsibility for their data. + +Many cases of NFT theft currently exist, and current NFT anti-theft schemes, such as transferring NFTs to cold wallets, make NFTs inconvenient to use. + +Having a validation step before every `transfer` and `approve` would give Smart Contract developers the opportunity to create secure NFT anti-theft schemes. + +An implementation example would be a system where a validator address is responsible for validating all Smart Contract transactions. + +This address would be connected to a dApp where the user could see the validation requests of his NFTs and accept the correct ones. + +Giving this address only the power to validate transactions would make a much more secure system where to steal an NFT the thief would have to have both the user's address and the validator address simultaneously. + +## Specification + +The keywords "MUST", "MUST NOT", "REQUIRED", "SHALL", "SHALL NOT", "SHOULD", "SHOULD NOT", "RECOMMENDED", "MAY" and "OPTIONAL" in this document are to be interpreted as described in RFC 2119. + +[ERC-721](./eip-721.md) compliant contracts MAY implement this EIP. + +All the operations that change the ownership of an NFT, like a `transferFrom`/`safeTransferFrom`, SHALL create a `TransferValidation` pending to be validated and emit a `ValidateTransfer`, and SHALL NOT transfer the ownership of an NFT. + +All the operations that enable an approval to manage an NFT, like an `approve`/`setApprovalForAll`, SHALL create an `ApprovalValidation` pending to be validated and emit a `ValidateApproval`, and SHALL NOT enable an approval. + +When the transfer is called by an approved account and not the owner, it MUST be executed directly without the need for validation. This is in order to adapt to all current marketplaces that require approve to directly move your NFTs. + +When validating a `TransferValidation` or `ApprovalValidation` the valid field MUST be set to true and MUST NOT be validated again. + +The operations that validate a `TransferValidation` SHALL change the ownership of the NFT or enable the approval. + +The operations that validate an `ApprovalValidation` SHALL enable the approval. + +### Contract Interface + +```solidity + interface IERC6997 { + + struct TransferValidation { + // The address of the owner. + address from; + // The address of the receiver. + address to; + // The token Id. + uint256 tokenId; + // Whether is a valid transfer. + bool valid; + } + + struct ApprovalValidation { + // The address of the owner. + address owner; + // The approved address. + address approve; + // The token Id. + uint256 tokenId; + // Wether is a total approvement. + bool approveAll; + // Whether is a valid approve. + bool valid; + } + + /** + * @dev Emitted when a new transfer validation has been requested. + */ + event ValidateTransfer(address indexed from, address to, uint256 indexed tokenId, uint256 indexed transferValidationId); + + /** + * @dev Emitted when a new approval validation has been requested. + */ + event ValidateApproval(address indexed owner, address approve, uint256 tokenId, bool indexed approveAll, uint256 indexed approvalValidationId); + + /** + * @dev Returns true if this contract is a validator ERC721. + */ + function isValidatorContract() external view returns (bool); + + /** + * @dev Returns the transfer validation struct using the transfer ID. + * + */ + function transferValidation(uint256 transferId) external view returns (TransferValidation memory); + + /** + * @dev Returns the approval validation struct using the approval ID. + * + */ + function approvalValidation(uint256 approvalId) external view returns (ApprovalValidation memory); + + /** + * @dev Return the total amount of transfer validations created. + * + */ + function totalTransferValidations() external view returns (uint256); + + /** + * @dev Return the total amount of transfer validations created. + * + */ + function totalApprovalValidations() external view returns (uint256); +} + ``` + +The `isValidatorContract()` function MUST be implemented as `public`. + +The `transferValidation(uint256 transferId)` function MAY be implemented as `public` or `external`. + +The `approvalValidation(uint256 approveId)` function MAY be implemented as `public` or `external`. + +The `totalTransferValidations()` function MAY be implemented as `pure` or `view`. + +The `totalApprovalValidations()` function MAY be implemented as `pure` or `view`. + +## Rationale + +### Universality + +The standard only defines the validation functions, but not how they should be used. It defines the validations as internal and lets the user decide how to manage them. + +An example could be to have an address validator connected to a dApp so that users could manage their validations. + +This validator could be used for all NFTs or only for some users. + +It could also be used as a wrapped Smart Contract for existing ERC-721, allowing 1/1 conversion with existing NFTs. + +### Extensibility + +This standard only defines the validation function, but does not define the system with which it has to be validated. A third-party protocol can define how it wants to call these functions as it wishes. + +## Backwards Compatibility + +This standard is an extension of [ERC-721](./eip-721.md), compatible with all the operations except `transferFrom`/`safeTransferFrom`/`approve`/`setApprovalForAll`. + +This operations will be overridden to create a validation petition instead of transfer ownership of an NFT or enable an approval. + +## Reference Implementation + +```solidity +// SPDX-License-Identifier: CC0-1.0 + +pragma solidity ^0.8.0; + +import "./IERC6997.sol"; +import "@openzeppelin/contracts/token/ERC721/ERC721.sol"; + +/** + * @dev Implementation of ERC6997 + */ +contract ERC6997 is IERC6997, ERC721 { + + // Mapping from transfer ID to transfer validation + mapping(uint256 => TransferValidation) private _transferValidations; + + // Mapping from approval ID to approval validation + mapping(uint256 => ApprovalValidation) private _approvalValidations; + + // Total number of transfer validations + uint256 private _totalTransferValidations; + + // Total number of approval validations + uint256 private _totalApprovalValidations; + + /** + * @dev Initializes the contract by setting a `name` and a `symbol` to the token collection. + */ + constructor(string memory name_, string memory symbol_) ERC721(name_, symbol_){ + } + + /** + * @dev Returns true if this contract is a validator ERC721. + */ + function isValidatorContract() public pure returns (bool) { + return true; + } + + /** + * @dev Returns the transfer validation struct using the transfer ID. + * + */ + function transferValidation(uint256 transferId) public view override returns (TransferValidation memory) { + require(transferId < _totalTransferValidations, "ERC6997: invalid transfer ID"); + TransferValidation memory v = _transferValidation(transferId); + + return v; + } + + /** + * @dev Returns the approval validation struct using the approval ID. + * + */ + function approvalValidation(uint256 approvalId) public view override returns (ApprovalValidation memory) { + require(approvalId < _totalApprovalValidations, "ERC6997: invalid approval ID"); + ApprovalValidation memory v = _approvalValidation(approvalId); + + return v; + } + + /** + * @dev Return the total amount of transfer validations created. + * + */ + function totalTransferValidations() public view override returns (uint256) { + return _totalTransferValidations; + } + + /** + * @dev Return the total amount of approval validations created. + * + */ + function totalApprovalValidations() public view override returns (uint256) { + return _totalApprovalValidations; + } + + /** + * @dev Returns the transfer validation of the `transferId`. Does NOT revert if transfer doesn't exist + */ + function _transferValidation(uint256 transferId) internal view virtual returns (TransferValidation memory) { + return _transferValidations[transferId]; + } + + /** + * @dev Returns the approval validation of the `approvalId`. Does NOT revert if transfer doesn't exist + */ + function _approvalValidation(uint256 approvalId) internal view virtual returns (ApprovalValidation memory) { + return _approvalValidations[approvalId]; + } + + /** + * @dev Validate the transfer using the transfer ID. + * + */ + function _validateTransfer(uint256 transferId) internal virtual { + TransferValidation memory v = transferValidation(transferId); + require(!v.valid, "ERC6997: the transfer is already validated"); + + address from = v.from; + address to = v.to; + uint256 tokenId = v.tokenId; + + super._transfer(from, to, tokenId); + + _transferValidations[transferId].valid = true; + } + + /** + * @dev Validate the approval using the approval ID. + * + */ + function _validateApproval(uint256 approvalId) internal virtual { + ApprovalValidation memory v = approvalValidation(approvalId); + require(!v.valid, "ERC6997: the approval is already validated"); + + if(!v.approveAll) { + require(v.owner == ownerOf(v.tokenId), "ERC6997: The token have a new owner"); + super._approve(v.approve, v.tokenId); + } + else { + super._setApprovalForAll(v.owner, v.approve, true); + } + + _approvalValidations[approvalId].valid = true; + } + + /** + * @dev Create a transfer petition of `tokenId` from `from` to `to`. + * + * Requirements: + * + * - `to` cannot be the zero address. + * - `tokenId` token must be owned by `from`. + * + * Emits a {TransferValidate} event. + */ + function _transfer( + address from, + address to, + uint256 tokenId + ) internal virtual override { + require(ERC721.ownerOf(tokenId) == from, "ERC6997: transfer from incorrect owner"); + require(to != address(0), "ERC6997: transfer to the zero address"); + + if(_msgSender() == from) { + TransferValidation memory v; + + v.from = from; + v.to = to; + v.tokenId = tokenId; + + _transferValidations[_totalTransferValidations] = v; + + emit ValidateTransfer(from, to, tokenId, _totalTransferValidations); + + _totalTransferValidations++; + } else { + super._transfer(from, to, tokenId); + } + } + + /** + * @dev Create an approval petition from `to` to operate on `tokenId` + * + * Emits an {ValidateApproval} event. + */ + function _approve(address to, uint256 tokenId) internal override virtual { + ApprovalValidation memory v; + + v.owner = ownerOf(tokenId); + v.approve = to; + v.tokenId = tokenId; + + _approvalValidations[_totalApprovalValidations] = v; + + emit ValidateApproval(v.owner, to, tokenId, false, _totalApprovalValidations); + + _totalApprovalValidations++; + } + + /** + * @dev If approved is true create an approval petition from `operator` to operate on + * all of `owner` tokens, if not remove `operator` from operate on all of `owner` tokens + * + * Emits an {ValidateApproval} event. + */ + function _setApprovalForAll( + address owner, + address operator, + bool approved + ) internal override virtual { + require(owner != operator, "ERC6997: approve to caller"); + + if(approved) { + ApprovalValidation memory v; + + v.owner = owner; + v.approve = operator; + v.approveAll = true; + + _approvalValidations[_totalApprovalValidations] = v; + + emit ValidateApproval(v.owner, operator, 0, true, _totalApprovalValidations); + + _totalApprovalValidations++; + } + else { + super._setApprovalForAll(owner, operator, approved); + } + } +} +``` + +## Security Considerations + +As is defined in the Specification the operations that change the ownership of an NFT or enable an approval to manage the NFT SHALL create a `TransferValidation` or an `ApprovalValidation` pending to be validated and SHALL NOT transfer the ownership of an NFT or enable an approval. + +With this premise in mind, the operations in charge of validating a `TransferValidation` or an `ApprovalValidation` must be protected with the maximum security required by the applied system. + +For example, a valid system would be one where there is a validator address in charge of validating the transactions. + +To give another example, a system where each user could choose his validator address would also be correct. + +In any case, the importance of security resides in the fact that no address can validate a `TransferValidation` or an `ApprovalValidation` without the permission of the chosen system. + +## Copyright + +Copyright and related rights waived via [CC0](../LICENSE.md). From 444313be872f5a11bfbd26aa27b752603672a62d Mon Sep 17 00:00:00 2001 From: Riley Date: Fri, 2 Jun 2023 00:10:34 -0500 Subject: [PATCH 49/97] Add EIP: Minimal Multi-Token Interface Merged by EIP-Bot. --- EIPS/eip-6909.md | 606 +++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 606 insertions(+) create mode 100644 EIPS/eip-6909.md diff --git a/EIPS/eip-6909.md b/EIPS/eip-6909.md new file mode 100644 index 00000000000000..b265e4b5b746cc --- /dev/null +++ b/EIPS/eip-6909.md @@ -0,0 +1,606 @@ +--- +eip: 6909 +title: Minimal Multi-Token Interface +description: A minimal specification for managing multiple tokens by their id in a single contract. +author: Joshua Trujillo (@jtriley) +discussions-to: https://ethereum-magicians.org/t/eip-6909-multi-token-standard/13891 +status: Draft +type: Standards Track +category: ERC +created: 2023-04-19 +requires: 165 +--- + +## Abstract + +The following standard specifies a multi-token contract as a simplified alternative to the [ERC-1155](./eip-1155.md) Multi-Token Standard. + +## Motivation + +The ERC-1155 standard includes unnecessary features such as requiring recipient accounts with code to implement callbacks returning specific values and batch-calls in the specification. In addition, the single operator permission scheme grants unlimited allowance on every token ID in the contract. Backwards compatibility is deliberately removed only where necessary. Additional features such as batch calls, increase and decrease allowance methods, and other user experience improvements are deliberately omitted in the specification to minimize the required external interface. + +According to ERC-1155, callbacks are required for each transfer and batch transfer to contract accounts. This requires potentially unnecessary external calls to the recipient when the recipient account is a contract account. While this behavior may be desirable in some cases, there is no option to opt-out of this behavior, as is the case for [ERC-721](./eip-721.md) having both `transferFrom` and `safeTransferFrom`. In addition to runtime performance of the token contract itself, it also impacts the runtime performance and codesize of recipient contract accounts, requiring multiple callback functions and return values to recieve the tokens. + +Batching transfers, while useful, are excluded from this standard to allow for opinionated batch transfer operations on different implementations. For example, a different ABI encoding may provide different benefits in different environments such as calldata size optimization for rollups with calldata storage commitments or runtime performance for environments with expensive gas fees. + +A hybrid allowance-operator permission scheme enables granular yet scalable controls on token approvals. Allowances enable an external account to transfer tokens of a single token ID on a user's behalf w by their ID while operators are granted full transfer permission for all token IDs for the user. + +## Specification + +The key words "MUST", "MUST NOT", "REQUIRED", "SHALL", "SHALL NOT", "SHOULD", "SHOULD NOT", "RECOMMENDED", "NOT RECOMMENDED", "MAY", and "OPTIONAL" in this document are to be interpreted as described in RFC 2119 and RFC 8174. + +### Definitions + +- infinite: The maximum value for a uint256 (`2 ** 256 - 1`). +- caller: The caller of the current context (`msg.sender`). +- spender: An account that transfers tokens on behalf of another account. +- operator: An account that has unlimited transfer permissions on all token ids for another account. +- mint: The creation of an amount of tokens. This MAY happen in a mint method or as a transfer from the zero address. +- burn: The removal an amount of tokens. This MAY happen in a burn method or as a transfer to the zero address. + +### Methods + +#### `totalSupply` + +The total `amount` of a token `id` that exists. + +MUST be equal to the sum of the `balanceOf` of all accounts of the token `id`. + +```yaml +- name: totalSupply + type: function + stateMutability: view + + inputs: + - name: id + type: uint256 + + outputs: + - name: amount + type: uint256 +``` + +#### `balanceOf` + +The total `amount` of a token `id` that an `owner` owns. + +```yaml +- name: balanceOf + type: function + stateMutability: view + + inputs: + - name: owner + type: address + - name: id + type: uint256 + + outputs: + - name: amount + type: uint256 +``` + +#### `allowance` + +The total `amount` of a token id that a spender is permitted to transfer on behalf of an owner. + +```yaml +- name: allowance + type: function + stateMutability: view + + inputs: + - name: owner + type: address + - name: spender + type: address + - name: id + type: uint256 + + outputs: + - name: amount + type: uint256 +``` + +#### `isOperator` + +Returns `true` if the `spender` is approved as an operator for an `owner`. + +```yaml +- name: isOperator + type: function + stateMutability: view + + inputs: + - name: owner + type: address + - name: spender + type: address + + outputs: + - name: status + type: bool +``` + +#### `transfer` + +Transfers an `amount` of a token `id` from the caller to the `receiver`. + +MUST revert when the caller's balance for the token `id` is insufficient. + +MUST log the `Transfer` event. + +```yaml +- name: transfer + type: function + stateMutability: nonpayable + + inputs: + - name: receiver + type: address + - name: id + type: uint256 + - name: amount + type: uint256 + + outputs: [] +``` + +#### `transferFrom` + +Transfers an `amount` of a token `id` from a `sender` to a `receiver` by the caller. + +MUST revert when the caller is not an operator for the `sender` and the caller's allowance for the token `id` for the `sender` is insufficient. + +MUST revert when the `sender`'s balance for the token id is insufficient. + +MUST log the `Transfer` event. + +MUST decrease the caller's `allowance` by the same `amount` of the `sender`'s balance decrease if the caller is not an operator for the `sender` and the caller's `allowance` is not infinite. + +SHOULD NOT decrease the caller's `allowance` for the token `id` for the `sender` if the `allowance` is infinite. + +SHOULD NOT decrease the caller's `allowance` for the token `id` for the `sender` if the caller is an operator. + +```yaml +- name: transferFrom + type: function + stateMutability: nonpayable + + inputs: + - name: sender + type: address + - name: receiver + type: address + - name: id + type: uint256 + - name: amount + type: uint256 + + outputs: [] +``` + +#### `approve` + +Approves an `amount` of a token `id` that a `spender` is permitted to transfer on behalf of the caller. + +MUST set the `allowance` of the `spender` of the token `id` for the caller to the `amount`. + +MUST log the `Approval` event. + +```yaml +- name: approve + type: function + stateMutability: nonpayable + + inputs: + - name: spender + type: address + - name: id + type: uint256 + - name: amount + type: uint256 + + outputs: [] +``` + +#### `setOperator` + +Grants or revokes unlimited transfer permissions for a `spender` for any token `id` on behalf of the caller. + +MUST set the operator status to the `approved` value. + +MUST log the `OperatorSet` event. + +```yaml +- name: setOperator + type: function + stateMutability: nonpayable + + inputs: + - name: spender + type: address + - name: approved + type: bool +``` + +### Events + +#### `Transfer` + +The `sender` has transferred an `amount` of a token `id` to a `receiver`. + +MUST be logged when an `amount` of a token `id` is transferred from one account to another. + +SHOULD be logged with the `sender` address as the zero address when an `amount` of a token `id` is minted. + +SHOULD be logged with the `receiver` address as the zero address when an `amount` of a token `id` is burned. + +```yaml +- name: Transfer + type: event + + inputs: + - name: sender + indexed: true + type: address + - name: receiver + indexed: true + type: address + - name: id + indexed: true + type: address + - name: amount + indexed: false + type: address +``` + +#### `OperatorSet` + +The `owner` has set the `approved` status to a `spender`. + +MUST be logged when the operator status is set. + +MAY be logged when the operator status is set to the same status it was before the current call. + +```yaml +- name: OperatorSet + type: event + + inputs: + - name: owner + indexed: true + type: address + - name: spender + indexed: true + type: address + - name: approved + indexed: false + type: bool +``` + +#### `Approval` + +The `owner` has approved a `spender` to transfer an `amount` of a token `id` to be transferred on the owner's behalf. + +MUST be logged when the `allowance` is set by an `owner`. + +```yaml +- name: Approval + type: event + + inputs: + - name: owner + indexed: true + type: address + - name: spender + indexed: true + type: address + - name: id + indexed: true + type: uint256 + - name: amount + indexed: false + type: uint256 +``` + +## Rationale + +### Granular Approvals + +While the "operator model" from the ERC-1155 standard allows an account to set another account as an operator, giving full permissions to transfer any amount of any token id on behalf of the owner, this may not always be the desired permission scheme. The "allowance model" from [ERC-20](./eip-20.md) allows an account to set an explicit amount of the token that another account can spend on the owner's behalf. This standard requires both be implemented, with the only modification being to the "allowance model" where the token id must be specified as well. This allows an account to grant specific approvals to specific token ids, infinite approvals to specific token ids, or infinite approvals to all token ids. If an account is set as an operator, the allowance SHOULD NOT be decreased when tokens are transferred on behalf of the owner. + +### Removal of Batching + +While batching operations is useful, its place should not be in the standard itself, but rather on a case-by-case basis. This allows for different tradeoffs to be made in terms of calldata layout, which may be especially useful for specific applications such as roll-ups that commit calldata to global storage. + +### Removal of Required Callbacks + +Callbacks MAY be used within a multi-token compliant contract, but it is not required. This allows for more gas efficient methods by reducing external calls and additional checks. + +### Removal of "Safe" Naming + +The `safeTransfer` and `safeTransferFrom` naming conventions are misleading, especially in the context of the ERC-1155 and ERC-721 standards, as they require external calls to receiver accounts with code, passing the execution flow to an arbitrary contract, provided the receiver contract returns a specific value. The combination of removing mandatory callbacks and removing the word "safe" from all method names improves the safety of the control flow by default. + +### Interface ID + +The interface ID is `0xb2e69f8a`. + +### Metadata Extension + +#### Methods + +##### name + +The `name` of the contract. + +```yaml +- name: name + type: function + stateMutability: view + + inputs: [] + + outputs: + - name: name + type: string +``` + +##### symbol + +The ticker `symbol` of the contract. + +```yaml +- name: symbol + type: function + stateMutability: view + + inputs: [] + + outputs: + - name: symbol + type: string +``` + +##### decimals + +The `amount` of decimals for a token `id`. + +```yaml +- name: decimals + type: function + stateMutability: view + + inputs: + - name: id + type: uint256 + + outputs: + - name: amount + type: uint8 +``` + +### Metadata URI Extension + +#### Methods + +##### tokenURI + +The `URI` for a token `id`. + +MAY revert if the token `id` does not exist. + +MUST replace occurrences of `{id}` in the returned URI string by the client. + +```yaml +- name: tokenURI + type: function + stateMutability: view + + inputs: + - name: id + type: uint256 + + outputs: + - name: uri + type: string +``` + +#### Metadata Structure + +The metadata specification closely follows that of the ERC-721 JSON schema. + +MUST replace occurrences of `{id}` in the returned URI string by the client. + +```json +{ + "title": "Asset Metadata", + "type": "object", + "properties": { + "name": { + "type": "string", + "description": "Identifies the token" + }, + "description": { + "type": "string", + "description": "Describes the token" + }, + "image": { + "type": "string", + "description": "A URI pointing to an image resource." + } + } +} +``` + +## Backwards Compatibility + +This is not backwards compatible with ERC-1155 as some methods are removed. However, wrappers can be implemented for the ERC-20, ERC-721, and ERC-1155 standards. + +## Reference Implementation + +```solidity +// SPDX-License-Identifier: CC0-1.0 +pragma solidity 0.8.19; + +/// @title ERC6909 Multi-Token Reference Implementation +/// @author jtriley.eth +contract ERC6909 { + /// @dev Thrown when owner balance for id is insufficient. + /// @param owner The address of the owner. + /// @param id The id of the token. + error InsufficientBalance(address owner, uint256 id); + + /// @dev Thrown when spender allowance for id is insufficient. + /// @param spender The address of the spender. + /// @param id The id of the token. + error InsufficientPermission(address spender, uint256 id); + + /// @notice The event emitted when a transfer occurs. + /// @param sender The address of the sender. + /// @param receiver The address of the receiver. + /// @param id The id of the token. + /// @param amount The amount of the token. + event Transfer(address indexed sender, address indexed receiver, uint256 indexed id, uint256 amount); + + /// @notice The event emitted when an operator is set. + /// @param owner The address of the owner. + /// @param spender The address of the spender. + /// @param approved The approval status. + event OperatorSet(address indexed owner, address indexed spender, bool approved); + + /// @notice The event emitted when an approval occurs. + /// @param owner The address of the owner. + /// @param spender The address of the spender. + /// @param id The id of the token. + /// @param amount The amount of the token. + event Approval(address indexed owner, address indexed spender, uint256 indexed id, uint256 amount); + + /// @notice The total supply of each id. + mapping(uint256 id => uint256 amount) public totalSupply; + + /// @notice Owner balance of an id. + mapping(address owner => mapping(uint256 id => uint256 amount)) public balanceOf; + + /// @notice Spender allowance of an id. + mapping(address owner => mapping(address spender => mapping(uint256 id => uint256 amount))) public allowance; + + /// @notice Checks if a spender is approved by an owner as an operator. + mapping(address owner => mapping(address spender => bool)) public isOperator; + + /// @notice Transfers an amount of an id from the caller to a receiver. + /// @param receiver The address of the receiver. + /// @param id The id of the token. + /// @param amount The amount of the token. + function transfer(address receiver, uint256 id, uint256 amount) public { + if (balanceOf[msg.sender][id] < amount) revert InsufficientBalance(msg.sender, id); + balanceOf[msg.sender][id] -= amount; + balanceOf[receiver][id] += amount; + emit Transfer(msg.sender, receiver, id, amount); + } + + /// @notice Transfers an amount of an id from a sender to a receiver. + /// @param sender The address of the sender. + /// @param receiver The address of the receiver. + /// @param id The id of the token. + /// @param amount The amount of the token. + function transferFrom(address sender, address receiver, uint256 id, uint256 amount) public { + if (sender != msg.sender && !isOperator[sender][msg.sender]) { + if (allowance[sender][msg.sender][id] < amount) { + revert InsufficientPermission(msg.sender, id); + } + allowance[sender][msg.sender][id] -= amount; + } + if (balanceOf[sender][id] < amount) revert InsufficientBalance(sender, id); + balanceOf[sender][id] -= amount; + balanceOf[receiver][id] += amount; + emit Transfer(sender, receiver, id, amount); + } + + /// @notice Approves an amount of an id to a spender. + /// @param spender The address of the spender. + /// @param id The id of the token. + /// @param amount The amount of the token. + function approve(address spender, uint256 id, uint256 amount) public { + allowance[msg.sender][spender][id] = amount; + emit Approval(msg.sender, spender, id, amount); + } + + /// @notice Sets or removes a spender as an operator for the caller. + /// @param spender The address of the spender. + /// @param approved The approval status. + function setOperator(address spender, bool approved) public { + isOperator[msg.sender][spender] = approved; + emit OperatorSet(msg.sender, spender, approved); + } + + /// @notice Checks if a contract implements an interface. + /// @param interfaceId The interface identifier, as specified in ERC-165. + /// @return supported True if the contract implements `interfaceId` and + function supportsInterface(bytes4 interfaceId) public pure returns (bool supported) { + return interfaceId == 0xb2e69f8a || interfaceId == 0x01ffc9a7; + } + + function _mint(address receiver, uint256 id, uint256 amount) internal { + // WARNING: important safety checks should preceed calls to this method. + balanceOf[receiver][id] += amount; + totalSupply[id] += amount; + emit Transfer(address(0), receiver, id, amount); + } + + function _burn(address sender, uint256 id, uint256 amount) internal { + // WARNING: important safety checks should preceed calls to this method. + balanceOf[sender][id] -= amount; + totalSupply[id] -= amount; + emit Transfer(sender, address(0), id, amount); + } +} +``` + +## Security Considerations + +### Approvals and Operators + +The specification includes two token transfer permission systems, the "allowance" and "operator" +models. There are two security considerations in regards to delegating permission to transfer. + +The first consideration is consistent with all delegated permission models. Any account with an allowance may transfer the full allowance for any reason at any time until the allowance is revoked. Any account with operator permissions may transfer any amount of any token id on behalf of the owner until the operator permission is revoked. + +The second consideration is unique to systems with both delegated permission models. In accordance with the `transferFrom` method, spenders with operator permission are not subject to allowance restrictions, spenders with infinite approvals SHOULD NOT have their allowance deducted on delegated transfers, but spenders with non-infinite approvals MUST have their balance deducted on delegated transfers. A spender with both operator permission and a non-infinite approval may introduce functional ambiguity. If the operator permission takes precedence, that is, the allowance is never deducted when a spender has operator permissions, there is no ambiguity. However, in the event the allowance takes precedence over the operator permissions, an additional branch may be necessary to ensure an allowance underflow does not occur. The following is an example of such an issue. + +```solidity +contract ERC6909OperatorPrecedence { + // -- snip -- + + function transferFrom(address sender, address receiver, uint256 id, uint256 amount) public { + // check if `isOperator` first + if (msg.sender != sender && !isOperator[sender][msg.sender]) { + require(allowance[sender][msg.sender][id] >= amount, "insufficient allowance"); + allowance[sender][msg.sender][id] -= amount; + } + + // -- snip -- + } +} + +contract ERC6909AllowancePrecedence { + // -- snip -- + + function transferFrom(address sender, address receiver, uint256 id, uint256 amount) public { + // check if allowance is sufficient first + if (msg.sender != sender && allowance[sender][msg.sender][id] < amount) { + require(isOperator[sender][msg.sender], "insufficient allowance"); + } + + // ERROR: when allowance is insufficient, this panics due to arithmetic underflow, regardless of + // whether the caller has operator permissions. + allowance[sender][msg.sender][id] -= amount; + + // -- snip + } +} +``` + +## Copyright + +Copyright and related rights waived via [CC0](../LICENSE.md). From 7aeca8e20ddac15e4d200e0374d265e611e100dc Mon Sep 17 00:00:00 2001 From: lightclient <14004106+lightclient@users.noreply.github.com> Date: Fri, 2 Jun 2023 17:47:20 +0200 Subject: [PATCH 50/97] Update EIP-4844: reduce size of `excess_data_gas` to 64 bit Merged by EIP-Bot. --- EIPS/eip-4844.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/EIPS/eip-4844.md b/EIPS/eip-4844.md index a28109feaa73f5..f43da5418eafbb 100644 --- a/EIPS/eip-4844.md +++ b/EIPS/eip-4844.md @@ -123,7 +123,7 @@ The signature values `y_parity`, `r`, and `s` are calculated by constructing a s ### Header extension -The current header encoding is extended with a new 64-bit unsigned integer field `data_gas_used` and a 256-bit unsigned integer field `excess_data_gas`. This is the running total of excess data gas consumed on chain since this EIP was activated. If the total amount of data gas is below the +The current header encoding is extended with a new 64-bit unsigned integer field `data_gas_used` and a 64-bit unsigned integer field `excess_data_gas`. This is the running total of excess data gas consumed on chain since this EIP was activated. If the total amount of data gas is below the target, `excess_data_gas` is capped at zero. The resulting RLP encoding of the header is therefore: From 3b42b46bc39f2d74a8ddb703c964fa5e1f90f8dd Mon Sep 17 00:00:00 2001 From: saitama2009 <107180872+saitama2009@users.noreply.github.com> Date: Sat, 3 Jun 2023 00:39:57 +0800 Subject: [PATCH 51/97] Add EIP: ERC-721 Holding Time Tracking Merged by EIP-Bot. --- EIPS/eip-6806.md | 132 +++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 132 insertions(+) create mode 100644 EIPS/eip-6806.md diff --git a/EIPS/eip-6806.md b/EIPS/eip-6806.md new file mode 100644 index 00000000000000..b37562b02c29a1 --- /dev/null +++ b/EIPS/eip-6806.md @@ -0,0 +1,132 @@ +--- +eip: 6806 +title: ERC-721 Holding Time Tracking +description: Add holding time information to ERC-721 tokens +author: Saitama (@saitama2009), Combo , Luigi +discussions-to: https://ethereum-magicians.org/t/draft-eip-erc721-holding-time-tracking/13605 +status: Draft +type: Standards Track +category: ERC +created: 2023-03-30 +requires: 721 +--- + +## Abstract + +This standard is an extension of [ERC-721](./eip-721.md). It adds an interface that tracks and describes the holding time of a Non-Fungible Token (NFT) by an account. + +## Motivation + +In some use cases, it is valuable to know the duration for which a NFT has been held by an account. This information can be useful for rewarding long-term holders, determining access to exclusive content, or even implementing specific business logic based on holding time. However, the current ERC-721 standard does not have a built-in mechanism to track NFT holding time. + +This proposal aims to address these limitations by extending the ERC-721 standard to include holding time tracking functionality. + +## Specification + +The key words “MUST”, “MUST NOT”, “REQUIRED”, “SHALL”, “SHALL NOT”, “SHOULD”, “SHOULD NOT”, “RECOMMENDED”, “MAY”, and “OPTIONAL” in this document are to be interpreted as described in RFC 2119. + +**Interface** + +The following interface extends the existing ERC-721 standard: + +```solidity +// SPDX-License-Identifier: CC0-1.0 +pragma solidity ^0.8.0 + +interface IERC6806 { + function getHoldingInfo( + uint256 tokenId + ) external view returns (address holder, uint256 holdingTime); +} +``` + +**Functions** + +### getHoldingInfo + +``` +function getHoldingInfo(uint256 tokenId) external view returns (address holder, uint256 holdingTime); +``` + +This function returns the current holder of the specified NFT and the length of time (in seconds) the NFT has been held by the current account. + +* `tokenId`: The unique identifier of the NFT. +* Returns: A tuple containing the current holder's address and the holding time (in seconds). + +## Rationale + +The addition of the `getHoldingInfo` function to an extension of the ERC-721 standard enables developers to implement NFT-based applications that require holding time information. This extension maintains compatibility with existing ERC-721 implementations while offering additional functionality for new use cases. + +The `getHoldingInfo` function provides a straightforward method for retrieving the holding time and holder address of an NFT. By using seconds as the unit of time for holding duration, it ensures precision and compatibility with other time-based functions in smart contracts. + +`getHoldingInfo` returns both `holder` and `holdingTime` so that some token owners (as decided by the implementation) can be ignored for the purposes of calculating holding time. For example, a contract may take ownership of an NFT as collateral for a loan. Such a loan contract could be ignored, so the real owner's holding time increases properly. + +## Backwards Compatibility + +This proposal is fully backwards compatible with the existing ERC-721 standard, as it extends the standard with new functions that do not affect the core functionality. + +## Reference Implementation + +```solidity +// SPDX-License-Identifier: CC0-1.0 +pragma solidity ^0.8.0; + +import "@openzeppelin/contracts/access/Ownable.sol"; +import "@openzeppelin/contracts/token/ERC721/ERC721.sol"; +import "./IERC6806.sol"; + +contract ERC6806 is ERC721, Ownable, IERC6806 { + mapping(uint256 => address) private _holder; + mapping(uint256 => uint256) private _holdStart; + mapping(address => bool) private _holdingTimeWhitelist; + + constructor( + string memory name_, + string memory symbol_ + ) ERC721(name_, symbol_) {} + + function _afterTokenTransfer( + address from, + address to, + uint256 firstotTokenId, + uint256 + ) internal override { + if (_holdingTimeWhitelist[from] || _holdingTimeWhitelist[to]) { + return; + } + + if (_holder[firstotTokenId] != to) { + _holder[firstotTokenId] = to; + _holdStart[firstotTokenId] = block.timestamp; + } + } + + function getHoldingInfo( + uint256 tokenId + ) public view returns (address holder, uint256 holdingTime) { + return (_holder[tokenId], block.timestamp - _holdStart[tokenId]); + } + + function setHoldingTimeWhitelistedAddress( + address account, + bool ignoreReset + ) public onlyOwner { + _holdingTimeWhitelist[account] = ignoreReset; + emit HoldingTimeWhitelistSet(account, ignoreReset); + } +} +``` + +## Security Considerations + +This EIP introduces additional state management for tracking holding times, which may have security implications. Implementers should be cautious of potential vulnerabilities related to holding time manipulation, especially during transfers. + +When implementing this EIP, developers should be mindful of potential attack vectors, such as reentrancy and front-running attacks, as well as general security best practices for smart contracts. Adequate testing and code review should be performed to ensure the safety and correctness of the implementation. + +Furthermore, developers should consider the gas costs associated with maintaining and updating holding time information. Optimizations may be necessary to minimize the impact on contract execution costs. + +It is also important to note that the accuracy of holding time information depends on the accuracy of the underlying blockchain's timestamp. While block timestamps are generally reliable, they can be manipulated by miners to some extent. As a result, holding time data should not be relied upon as a sole source of truth in situations where absolute precision is required. + +## Copyright + +Copyright and related rights waived via [CC0](../LICENSE.md). From 76a22a856e64060f07f11c7cdaa65e6b99375f47 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Ernesto=20Garc=C3=ADa?= Date: Fri, 2 Jun 2023 14:39:10 -0600 Subject: [PATCH 52/97] Update EIP-6093: Rename `ERC721InexistentToken` to `ERC721NonexistentToken` Merged by EIP-Bot. --- EIPS/eip-6093.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/EIPS/eip-6093.md b/EIPS/eip-6093.md index 86e2211d9bc7c7..25e87bfce54e53 100644 --- a/EIPS/eip-6093.md +++ b/EIPS/eip-6093.md @@ -101,7 +101,7 @@ Used in balance queries. - MUST not be used for transfers. - Use `ERC721IncorrectOwner` instead. -### `ERC721InexistentToken(uint256 tokenId)` +### `ERC721NonexistentToken(uint256 tokenId)` Indicates a `tokenId` whose `owner` is the zero address. @@ -353,7 +353,7 @@ interface ERC20Errors { /// https://eips.ethereum.org/EIPS/eip-6093 interface ERC721Errors { error ERC721InvalidOwner(address owner); - error ERC721InexistentToken(uint256 tokenId); + error ERC721NonexistentToken(uint256 tokenId); error ERC721IncorrectOwner(address sender, uint256 tokenId, address owner); error ERC721InvalidSender(address sender); error ERC721InvalidReceiver(address receiver); From 6153bfa51fce44579c6f6269a692634abefd711c Mon Sep 17 00:00:00 2001 From: Kyle Den Hartog Date: Mon, 5 Jun 2023 17:24:35 +0900 Subject: [PATCH 53/97] Update EIP-6963: Editorial changes Merged by EIP-Bot. --- EIPS/eip-6963.md | 308 ++++++++++++++++++++++++++--------------------- 1 file changed, 172 insertions(+), 136 deletions(-) diff --git a/EIPS/eip-6963.md b/EIPS/eip-6963.md index bbf84fe27d02f9..dc8aad7ad80859 100644 --- a/EIPS/eip-6963.md +++ b/EIPS/eip-6963.md @@ -33,9 +33,21 @@ This is achieved by introducing a set of window events to provide a two-way comm The key words “MUST”, “MUST NOT”, “REQUIRED”, “SHALL”, “SHALL NOT”, “SHOULD”, “SHOULD NOT”, “RECOMMENDED”, “MAY”, and “OPTIONAL” in this document are to be interpreted as described in RFC 2119. +### Definitions + +Wallet: A user agent that manages keys and facilitates transactions with Ethereum. + +Decentralized Application (DApp): A web page that relies upon one or many Web3 platform APIs which are exposed to the web page via the Wallet. + +Provider Discovery Library: A library or piece of software that assists a DApp to interact with the Wallet. + ### Provider Info -Each wallet provider will be announced with the following interface `EIP6963ProviderInfo` that will be used to display to the user: +Each wallet provider will be announced with the following interface `EIP6963ProviderInfo`. The values in the `EIP6963ProviderInfo` MUST be used as follows: + +- **`uuid`** - a globally unique of the wallet provider that MUST be (UUIDv4[^rfc4122] compliant) to uniquely distinguish different [EIP-1193](./eip-1193.md) provider sessions. The cryptographic uniqueness provided by UUIDv4[^rfc4122] guarantees that two independent `EIP6963ProviderInfo` objects can be separately identified. +- **`name`** - A human-readable local alias of the wallet provider to be displayed to the user on the DApp. (e.g. `DopeWalletExtension` or `AwesomeWallet`) +- **`icon`** - A URI[^rfc3986] pointing to an image. Icon images MUST be square with 96x96px minimum resolution ```typescript /** @@ -49,84 +61,28 @@ interface EIP6963ProviderInfo { } ``` -The values in the `EIP6963ProviderInfo` MUST be used as follows: +#### Images/Icons -- **`walletId`** - globally unique identifier of the wallet provider (eg. `io.dopewallet.extension` or `awesomewallet`) -- **`uuid`** - locally unique of the wallet provider (UUIDv4[^rfc4122] compliant) -- **`name`** - human-readable name of the wallet provider (e.g. `DopeWalletExtension` or `AwesomeWallet`) -- **`icon`** - A URI[^rfc3986] pointing to an image. Icon images MUST be square with 96x96px minimum resolution +// TODO for @kdenhartog: This section should be updated to require support of SVGs instead of arbitrary data URIs or URLs that point to images. -[^rfc4122]: - ```csl-json - { - "author": [ - { - "given": "Paul J.", - "family": "Leach" - }, - { - "given": "Rich", - "family": "Salz" - }, - { - "given": "Michael H.", - "family": "Mealling" - } - ], - "collection-title": "Request for Comments", - "DOI": "10.17487/RFC4122", - "type": "book", - "id": "rfc4122", - "citation-label": "rfc4122", - "issued": { - "date-parts": [ - [2005, 7] - ] - }, - "number-of-pages": "32", - "publisher": "RFC Editor", - "title": "A Universally Unique IDentifier (UUID) URN Namespace", - "URL": "https://www.rfc-editor.org/info/rfc4122" - } - ``` +A uri encoded image was chosen to enable flexibility for multiple protocols for fetching and rendering icons, for example: -[^rfc3986]: - ```csl-json - { - "author": [ - { - "given": "Tim", - "family": "Berners-Lee" - }, - { - "given": "Roy T.", - "family": "Fielding" - }, - { - "given": "Larry M", - "family": "Masinter" - } - ], - "collection-title": "Request for Comments", - "DOI": "10.17487/RFC3986", - "type": "book", - "id": "rfc3986", - "citation-label": "rfc3986", - "issued": { - "date-parts": [ - [2005, 1] - ] - }, - "number-of-pages": "61", - "publisher": "RFC Editor", - "title": "Uniform Resource Identifier (URI): Generic Syntax", - "URL": "https://www.rfc-editor.org/info/rfc3986" - } - ``` +```sh +# svg (data uri) +data:image/svg+xml, +# png (data uri) +data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAUAAAAFCAYAAACNbyblAAAAHElEQVQI12P4//8/w38GIAXDIBKE0DHxgljNBAAO9TXL0Y4OHwAAAABJRU5ErkJggg== +# png (ipfs uri) +ipfs://QmZo7gsostaUdrV1peFz4cX6Z2TgriFJJP4VahG5knVm29 +# webp (http uri) +https://ethereum.org/static/f541df14fca86543040c113725b5bd1a/99bcf/metamask.webp +``` + +Additionally the image must be squared with 96x96px minimum resolution. Image format is recommended to be lossless like PNG and WebP or alternatively vectorial like SVG. We strongly discourage lossy formats like JPG/JPEG. ### Provider Detail -The wallet provider will also announce their own [EIP-1193](./eip-1193.md) provider interface in parallel with the provider info defined above in the following interface `EIP6963ProviderDetail` +The `EIP6963ProviderDetail` is used as a composition interface to announce a wallet provider and and related metadata about the wallet provider. The `EIP6963ProviderDetail` MUST contain an `info` property of type `EIP6963ProviderInfo` and a `provider` property of type `EIP1193Provider` defined by [EIP-1193](./eip-1193.md). ```typescript interface EIP6963ProviderDetail { @@ -135,40 +91,41 @@ interface EIP6963ProviderDetail { } ``` -The `EIP1193Provider` interface is documented at [EIP-1193](./eip-1193.md) and can be used to override the `window.ethereum` object once the user has explicitly selected it. - ### Window Event -Different wallet providers might inject their scripts at different times, plus there is no guarantees that the Ethereum library in the web page will be loaded before all injected scripts are present in the page. +In order to prevent provider collisions, the DApp and the Wallet are expected to emit an event and instantiate an eventListener to discover the various Wallet's. This forms an Event concurrency loop. -To emit events both Ethereum libraries and Wallet providers must use `window.dispatchEvent` to emit events and `window.addEventListener` to observe events. There will be two event interfaces: +To emit events both DApps and Wallets MUST use the `window.dispatchEvent` function to emit events and MUST use the `window.addEventListener` function to observe events. There will be two Event interfaces used for the DApp and Wallet to discover each other. -```typescript -// Requesting an EVM provider -interface EIP6963RequestProviderEvent extends Event { - type: "eip6963:requestProvider"; -} +#### Wallet Events + +The `EIP6963AnnounceProviderEvent` interface MUST be a `CustomEvent` object with a `type` property containing a string value of `eip6963:announceProvider` and a `detail` property with an object as it's value of type `EIP6963ProviderDetail`. The `EIP6963ProviderDetail` object MUST be frozen by calling `Object.freeze()` on the value of the `detail` property. -// Annoucing an EVM provider +```typescript +// A Wallet announcing the EIP6963ProviderDetail object interface EIP6963AnnounceProviderEvent extends CustomEvent { type: "eip6963:announceProvider"; detail: EIP6963ProviderDetail; } ``` -Therefore both wallet providers and the Ethereum library must emit events when they initialize. +The Wallet must announce to the DApp this `CustomEvent` via a `window.dispatchEvent()` function call. In order for the Wallet to recognize that the DApp is Web3 enabled and can support interactions with the Web3 Platform APIs the Wallet MUST add an EventListener to catch an Event dispatched from the DApp. This EventListener MUST have a `type` property with the string `eip6963:requestProvider` and MUST use a handler that will re-dispatch a `CustomEvent` object of type `EIP6963AnnounceProviderEvent`. This re-announcement by the Wallet is useful for when a Wallet's initial Event announcement may have been delayed or fired before the DApp had initialized it's EventListener. This allows the various Wallet Providers to react to the DApp without the need to pollute the `window.ethereum` namespace which can produce non-deterministic wallet behavior such as different wallets connecting each time. ```typescript -// Ethereum library initializes -window.dispatchEvent(new Event("eip6963:requestProvider")); - -// Wallet provider initializes -window.dispatchEvent(new CustomEvent("eip6963:announceProvider", { detail })); -``` - -Additionally the Wallet providers will react to the event emitted by the Ethereum library. + function announceProvider() { + const info: EIP6963ProviderInfo = { + walletId: "org.example.wallet", + uuid: "350670db-19fa-4704-a166-e52e178b59d2", + name: "Example Wallet", + icon: "https://wallet.example.org/icon.png", + }; + window.dispatchEvent( + new CustomEvent("eip6963:announceProvider", { + detail: Object.freeze({ info, provider }), + }) + ); + } -```typescript window.addEventListener( "eip6963:requestProvider", (event: EIP6963RequestProviderEvent) => { @@ -176,60 +133,41 @@ window.addEventListener( } ); ``` +#### DApp Events -## Rationale - -### Interfaces - -Standardizing a provider info interface (`EIP6963ProviderInfo`) allows determining the necessary information to populate a wallet selection popup. This is particularly useful for Ethereum libraries such as Web3Modal, RainbowKit, Web3-Onboard, ConnectKit, etc. +The DApp MUST listen for the `CustomEvent` dispatched by the Wallet via a `window.dispatchEvent()` function call. In order for the DApp to discover the `EIP6963AnnounceProviderEvent` this EventListener MUST have a `type` property with the string `eip6963:requestProvider`. -Regarding the announced provider interface (`EIP6963ProviderDetail`) it was important to leave the [EIP-1193](./eip-1193.md) provider interface untouched for backwards-compatiblity therefore it's exposed in parallel. - -### Identifiers - -A locally unique identifier prevents from conflicts using the same globally unique identifier by using UUID v4.0 - -A globally unique identifier is used for machine-readable detection of the currently active wallet and it can take different formats, for example: - -```text -# lowercase name -awesomewallet +```typescript +// Requesting an EVM provider +interface EIP6963RequestProviderEvent extends Event { + type: "eip6963:requestProvider"; +} +``` -# legacy JS variable -isCoolWallet +In a DApp's implementation, it uses the `EIP6963RequestProviderEvent` interface. The `EIP6963RequestProviderEvent` interface is an Event object with a `type` property containing a string value of `eip6963:requestProvider`. -# reversed domain -io.dopewallet.app +```typescript + window.addEventListener("eip6963:announceProvider"); ``` -### Images/Icons +The DApp MAY also keep track of the various `EIP6963ProviderDetail` announced by the various wallets so that if the user wishes to utilize a different Wallet the DApp can immediately send transactions to the new Wallet. Otherwise, the DApp MAY re-initiate the wallet discovery flow via dispatching a new `EIP6963RequestProviderEvent` Event. -A uri encoded image was chosen to enable flexibility for multiple protocols for fetching and rendering icons, for example: +## Rationale -```sh -# svg (data uri) -data:image/svg+xml, -# png (data uri) -data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAUAAAAFCAYAAACNbyblAAAAHElEQVQI12P4//8/w38GIAXDIBKE0DHxgljNBAAO9TXL0Y4OHwAAAABJRU5ErkJggg== -# png (ipfs uri) -ipfs://QmZo7gsostaUdrV1peFz4cX6Z2TgriFJJP4VahG5knVm29 -# webp (http uri) -https://ethereum.org/static/f541df14fca86543040c113725b5bd1a/99bcf/metamask.webp -``` +Previous proposal introduced mechanisms that relied on a single window object that could be overridden by multiple parties. Therefore using an event-based approach we avoid the race conditions and potential attacks by making the communication available both ways in a way that doesn't have potential namespace collisions. -Additionally the image must be squared with 96x96px minimum resolution. Image format is recommended to be lossless like PNG and WebP or alternatively vectorial like SVG. We strongly discourage lossy formats like JPG/JPEG. +To follow the Javascript event name conventions, the names are written in present tense and are prefixed with the standard number (`eip6963`). -### Events +### Interfaces -Previous proposal introduced mechanisms that relied on a single window object that could be overriden by multiple parties. +Standardizing a provider info interface (`EIP6963ProviderInfo`) allows determining the necessary information to populate a wallet selection popup. This is particularly useful for DApps and Ethereum libraries they might depend on such as Web3Modal, RainbowKit, Web3-Onboard, ConnectKit, etc. -Therefore using an event-based approach we avoid these race conditions and potential attacks by making the communication available both ways. +Regarding the announced provider interface (`EIP6963ProviderDetail`) it was important to leave the [EIP-1193](./eip-1193.md) provider interface untouched for backwards compatibility therefore it's exposed in parallel. However, just as it is today there is no guarantee that this backwards compatible method will result in the user selected wallet being chosen. -To follow the Javascript event name conventions, the names are written in present tense and are prefixed with the standard number (`eip6963`). ## Backwards Compatibility -This EIP doesn't require supplanting `window.ethereum`, so it doesn't directly break existing applications. However, the recommended behavior of eventually supplanting `window.ethereum` would break existing applications that rely on it. +This EIP doesn't require supplanting `window.ethereum`, so it doesn't directly break existing applications that cannot update to this method of Wallet discovery. However, it is RECOMMENDED DApps implement this EIP and SHOULD disable `window.ethereum` usage to ensure discovery of multiple Wallet Providers. Similarly, Wallets SHOULD keep compatibility of `window.ethereum` to ensure backwards compatibility for DApps that have not implemented this EIP. ## Reference Implementation @@ -268,18 +206,17 @@ function onPageLoad() { } ``` -### Ethereum library +### DApp implementation -Here is a reference implementation for a Ethereum library to display and track multiple wallet providers that are injected by browser extensions. +Here is a reference implementation for a DApp to display and track multiple wallet providers that are injected by browser extensions. ```typescript -function onPageLoad() { - const providers: EIP6963ProviderDetail[] = []; +function onPageLoad(): EIP6963ProviderDetail[] => { window.addEventListener( "eip6963:announceProvider", (event: EIP6963AnnounceProviderEvent) => { - providers.push(event.detail); + providers.push(Object.freeze(event.detail)); } ); @@ -293,6 +230,105 @@ The security considerations of [EIP-1193](./eip-1193.md) apply to this EIP. The use of SVG images introduces a cross-site scripting risk as they can include JavaScript code. Applications and libraries must render SVG images using the `` tag to ensure no JS executions can happen. +// TODO for @kdenhartog: Add a privacy section about Wallet fingerprinting and how Wallets should not announce themselves until the DApp has dispatched the request provider Event and gathered consent from the user that they wish to announce themselves to the DApp. + ## Copyright Copyright and related rights waived via [CC0](../LICENSE.md). + + +[^rfc4122]: + ```csl-json + { + "author": [ + { + "given": "Paul J.", + "family": "Leach" + }, + { + "given": "Rich", + "family": "Salz" + }, + { + "given": "Michael H.", + "family": "Mealling" + } + ], + "collection-title": "Request for Comments", + "DOI": "10.17487/RFC4122", + "type": "book", + "id": "rfc4122", + "citation-label": "rfc4122", + "issued": { + "date-parts": [ + [2005, 7] + ] + }, + "number-of-pages": "32", + "publisher": "RFC Editor", + "title": "A Universally Unique IDentifier (UUID) URN Namespace", + "URL": "https://www.rfc-editor.org/info/rfc4122" + } + ``` + +[^rfc3986]: + ```csl-json + { + "author": [ + { + "given": "Tim", + "family": "Berners-Lee" + }, + { + "given": "Roy T.", + "family": "Fielding" + }, + { + "given": "Larry M", + "family": "Masinter" + } + ], + "collection-title": "Request for Comments", + "DOI": "10.17487/RFC3986", + "type": "book", + "id": "rfc3986", + "citation-label": "rfc3986", + "issued": { + "date-parts": [ + [2005, 1] + ] + }, + "number-of-pages": "61", + "publisher": "RFC Editor", + "title": "Uniform Resource Identifier (URI): Generic Syntax", + "URL": "https://www.rfc-editor.org/info/rfc3986" + } + ``` + + [^rfc2397]: + ```csl-json + { + "type": "book", + "id": "RFC2397", + "author": [ + { + "family": "Hoffman", + "given": "Paul" + } + ], + "collection-title": "Request for Comments", + "DOI": "10.17487/RFC2397", // TODO determine proper DOI number + "type": "book", + "id": "rfc2397", + "citation-label": "rfc2397", + "issued": { + "date-parts": [ + [1998, 08] + ] + }, + "number-of-pages": "5", + "publisher": "RFC Editor", + "title": "The 'data' URL scheme", + "URL": "https://www.rfc-editor.org/info/rfc3986" + } + ``` \ No newline at end of file From 86d46ffc72e0a116a2f0e1fc2dd0cacaeb8d0e25 Mon Sep 17 00:00:00 2001 From: Pedro Gomes Date: Mon, 5 Jun 2023 12:46:58 +0200 Subject: [PATCH 54/97] Update EIP-6963: [EIP-6963] remove walletId from spec Merged by EIP-Bot. --- EIPS/eip-6963.md | 5 +---- 1 file changed, 1 insertion(+), 4 deletions(-) diff --git a/EIPS/eip-6963.md b/EIPS/eip-6963.md index dc8aad7ad80859..4289664323fd5f 100644 --- a/EIPS/eip-6963.md +++ b/EIPS/eip-6963.md @@ -54,7 +54,6 @@ Each wallet provider will be announced with the following interface `EIP6963Prov * Represents the assets needed to display a wallet */ interface EIP6963ProviderInfo { - walletId: string; uuid: string; name: string; icon: string; @@ -114,7 +113,6 @@ The Wallet must announce to the DApp this `CustomEvent` via a `window.dispatchEv ```typescript function announceProvider() { const info: EIP6963ProviderInfo = { - walletId: "org.example.wallet", uuid: "350670db-19fa-4704-a166-e52e178b59d2", name: "Example Wallet", icon: "https://wallet.example.org/icon.png", @@ -183,7 +181,6 @@ function onPageLoad() { function announceProvider() { const info: EIP6963ProviderInfo = { - walletId: "org.example.wallet", uuid: "350670db-19fa-4704-a166-e52e178b59d2", name: "Example Wallet", icon: "https://wallet.example.org/icon.png", @@ -331,4 +328,4 @@ Copyright and related rights waived via [CC0](../LICENSE.md). "title": "The 'data' URL scheme", "URL": "https://www.rfc-editor.org/info/rfc3986" } - ``` \ No newline at end of file + ``` From 201ac9600000c3873c095bfde6cfc4425095488d Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Pawe=C5=82=20Bylica?= Date: Mon, 5 Jun 2023 13:38:46 +0200 Subject: [PATCH 55/97] Update EIP-3540: EOF1 contracts can only DELEGATECALL EOF1 contracts Merged by EIP-Bot. --- EIPS/eip-3540.md | 9 +++++++++ 1 file changed, 9 insertions(+) diff --git a/EIPS/eip-3540.md b/EIPS/eip-3540.md index 80439fd64f37f1..8dcb0a8c1c0102 100644 --- a/EIPS/eip-3540.md +++ b/EIPS/eip-3540.md @@ -162,6 +162,7 @@ For clarity, the *container* refers to the complete account code, while *code* r 4. `CODECOPY`/`CODESIZE`/`EXTCODECOPY`/`EXTCODESIZE`/`EXTCODEHASH` keeps operating on the entire *container*. 5. The input to `CREATE`/`CREATE2` is still the entire *container*. 6. The size limit for deployed code as specified in [EIP-170](./eip-170.md) and for initcode as specified in [EIP-3860](./eip-3860.md) is applied to the entire *container* size, not to the *code* size. This also means if initcode validation fails, it is still charged the EIP-3860 `initcode_cost`. +7. When an EOF1 contract performs a `DELEGATECALL` the target must be EOF1. If it is not EOF1, the `DELEGATECALL` execution finishes as a failed call by pushing `0` to the stack. Only initial gas cost of `DELEGATECALL` is consumed (similarly to the call depth check) and the target address still becomes warm. (*Remark:* Due to [EIP-4750](./eip-4750.md), `JUMP` and `JUMPI` are disabled and therefore are not discussed in relation to EOF.) @@ -250,6 +251,10 @@ It is possible in the future that this data will be accessible with data-specifi The value for `PC` is specified to start at 0 and to be within the active *code* section. We considered keeping `PC` to operate on the whole *container* and be consistent with `CODECOPY`/`EXTCODECOPY` but in the end decided otherwise. This also feels more natural and easier to implement in EVM: the new EOF EVM should only care about traversing *code* and accessing other parts of the *container* only on special occasions (e.g. in `CODECOPY` instruction). +### EOF1 contracts can only `DELEGATECALL` EOF1 contracts + +Currently contracts can selfdestruct in three different ways (directly through `SELFDESTRUCT`, indirectly through `CALLCODE` and indirectly through `DELEGATECALL`). [EIP-3670](./eip-3670.md) disables the first two possibilities, however the third possibility remains. Allowing EOF1 contracts to only `DELEGATECALL` other EOF1 contracts allows the following strong statement: EOF1 contract can never be destructed. Attacks based on `SELFDESTRUCT` completely disappear for EOF1 contracts. These include destructed library contracts (e.g. Parity Multisig). + ## Backwards Compatibility This is a breaking change given that any code starting with `0xEF` was not deployable before (and resulted in exceptional abort if executed), but now some subset of such codes can be deployed and executed successfully. @@ -291,6 +296,10 @@ All cases should be checked for creation transaction, `CREATE` and `CREATE2`. - `EXTCODECOPY` can copy from target's EOF header - `EXTCODECOPY` can copy entire target container - Results don't differ when executed inside legacy or EOF contract +- EOF1 `DELEGATECALL` + - `DELEGATECALL` to EOF1 code succeeds + - `DELEGATECALL` to EOF0 code fails + - `DELEGATECALL` to empty container fails ## Security Considerations From 131bc9059e8e8d674950ec1fc1c10e11ceb706d5 Mon Sep 17 00:00:00 2001 From: Alex Beregszaszi Date: Mon, 5 Jun 2023 19:34:23 +0200 Subject: [PATCH 56/97] Add EIP: Revamped CALL instructions Merged by EIP-Bot. --- EIPS/eip-7069.md | 153 +++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 153 insertions(+) create mode 100644 EIPS/eip-7069.md diff --git a/EIPS/eip-7069.md b/EIPS/eip-7069.md new file mode 100644 index 00000000000000..7cd6448a9a35cb --- /dev/null +++ b/EIPS/eip-7069.md @@ -0,0 +1,153 @@ +--- +eip: 7069 +title: Revamped CALL instructions +description: Introduce CALL2, DELEGATECALL2 and STATICCALL2 with simplified semantics +author: Alex Beregszaszi (@axic), Paweł Bylica (@chfast), Danno Ferrin (@shemnon), Andrei Maiboroda (@gumb0) +discussions-to: https://ethereum-magicians.org/t/eip-revamped-call-instructions/14432 +status: Draft +type: Standards Track +category: Core +created: 2023-05-05 +requires: 150, 211, 214, 2929 +--- + +## Abstract + +Introduce three new call instructions, `CALL2`, `DELEGATECALL2` and `STATICCALL2`, with simplified semantics. The existing call instructions remain unchanged. + +The new instructions do not allow specifying a gas limit, but rather rely on the "63/64th rule" ([EIP-150](./eip-150.md)) to limit gas. An important improvement is the rules around the "stipend" are simplified, and callers do not need to perform special calculation whether the value is sent or not. + +Furthermore, the obsolete functionality of specifying output buffer address is removed in favor of using `RETURNDATACOPY` instead. + +Lastly, instead of returning a boolean for execution status, an extensible list of status codes is returned: `0` for success, `1` for revert, `2` for failure. + +We expect most new contracts to rely on the new instructions (for simplicity and in order to save gas), and some specific contracts where gas limiting is required to keep using the old instructions (e.g. [ERC-4337](./eip-4337.md)). + +## Motivation + +Observability of gas has been a problem for very long. The system of gas has been (and likely must be) flexible in adapting to changes to both how Ethereum is used as well as changes in underlying hardware. + +Unfortunately, in many cases compromises or workarounds had to be made to avoid affecting call instructions negatively, mostly due to the complex semantics and expectations of them. + +This change aims to remove gas observability from the new instructions and opening the door for new classes of contracts that are not affected by repricings. Furthermore, once the EVM Object Format (EOF) is introduced, the legacy call instructions can be rejected within EOF contracts, making sure they are mostly unaffected by changes in gas fees. Because these operations are required for removing gas observability they will be required for EOF in lieu of the existing instructions. + +It is important to note that starting Solidity 0.4.21, the compiler already passes all remaining gas to calls (using `call(gas(), ...`), unless the developer uses the explicit override (`{gas: ...}`) in the language. This suggests most contracts don't rely on controlling gas. + +Besides the above, this change introduces a convenience feature of returning more detailed status codes: success (0), revert (1), failure (2). This moves from the boolean option to codes, which are extensible in the future. + +Lastly, the introduction of the `RETURNDATA*` instructions ([EIP-211](./eip-211.md)) has obsoleted the output parameters of calls, in a large number of cases rendering them unused. Using the output buffers have caused "bugs" in the past: in the case of [ERC-20](./eip-20.md), conflicting implementations caused a lot of trouble, where some would return something, while others would not. With relying on `RETURNDATA*` instructions this is implicitly clarified. + +## Specification + +| Name | Value | Comment | +|------|-------|---------| +| WARM_STORAGE_READ_COST | 100 | From [EIP-2929](./eip-2929.md) | +| COLD_ACCOUNT_ACCESS | 2600 | From [EIP-2929](./eip-2929.md) | +| ACCOUNT_CREATION_COST | 25000 | | +| MIN_RETAINED_GAS | 5000 | | +| MIN_CALLEE_GAS | 2300 | | + +We introduce three new instructions: + +- `CALL2` (`0xf8`) with arguments `(target_address, input_offset, input_size, value)` +- `DELEGATECALL2` (`0xf9`) with arguments `(target_address, input_offset, input_size)` +- `STATICCALL2` (`0xfb`) with arguments `(target_address, input_offset, input_size)` + +Execution semantics: + +1. Charge `WARM_STORAGE_READ_COST` (100) gas. +2. Pop required arguments from stack, fail with error on stack underflow. +4. If `value` is non-zero: + 3a. Fail with error if the current frame is in `static-mode`. + 3b. Fail with error if the balance of the current account is less than `value`. +4. Peform (and charge for) memory expansion using `[input_offset, input_size]`. +5. If `target_address` is not in the `warm_account_list`, charge `COLD_ACCOUNT_ACCESS - WARM_STORAGE_READ_COST` (2500) gas. +6. If `target_address` is not in the state and the call configuration would result in account creation, charge `ACCOUNT_CREATION_COST` (25000) gas. + - The only such case in this EIP is if `value` is non-zero. +7. Calculate the gas available to callee as caller's remaining gas reduced by `max(ceil(gas/64), MIN_RETAINED_GAS)` (`MIN_RETAINED_GAS` is 5000). +8. Fail with error if the gas available to callee at this point is less than `MIN_CALLEE_GAS` (2300). +9. Perform the call with the available gas and configuration. +10. Push a status code on the stack: + 11a. `0` if the call was successful. + 11b. `1` if the call has reverted. + 11c. `2` if the call has failed. +11. Gas not used by the callee is returned to the caller. + +Note: Unlike `CALL` there is no extra charge for value bearing calls. + + + + + + + +## Rationale + +### Removing gas selectability + +One major change from the original `CALL` series of instructions is that the caller has no control over the amount of gas passed in as part of the call. The number of cases where such a feature is essential are probably better served by direct protocol integration. + +Removing gas selectability also introduces a valuable property that future revisions to the gas schedule will benefit from: you can always overcome Out of Gas (OOG) errors by sending more gas as part of the transaction (subject to the block gas limit). Previously when raising storage costs ([EIP-1884](./eip-1884.md)) some contracts that sent only a limited amount of gas to their calls were broken by the new costing. + +Hence some contracts had a gas ceiling they were sending to their next call, permanently limiting the amount of gas they could spend. No amount of extra gas could fix the issue as the call would limit the amount sent. The notion of a stipend floor is retained in this spec. This floor can be changed independent of the smart contracts and still preserve the feature that OOG halts can be fixed by sending more gas as part of the transaction. + +### Stipend and 63/64th rule + +The purpose of the stipend is to have enough gas to emit logs (i.e. perform non-state-changing operations) when a "contract wallet" is called. The stipend is only added when the target has code and the call value is non-zero. + +The 63/64th rule has multiple purposes: + +a. to limit call depth, +b. to ensure the caller has gas left to make state changes after a callee returns. + +Additionally there is a call depth counter, and calls fail if the depth would exceed 1024. + +Before the 63/64th rule was introduced, it was required to calculate available gas semi-accurately on caller side. Solidity has a complicated ruleset where it tries to estimate how much it will cost on the caller side to perform the call itself, in order to set a reasonable gas value. + +We have changed the ruleset: + +1. Removed the call depth check. +2. Use the 63/64th rule, but + 2a. ensure that at least 5000 gas is retained prior to executing the callee, + 2b. ensure that at least 2300 gas is available to the callee. + +### Output buffers + +The functionality of specifying output buffer address is removed, because it is added complexity and in a large number of cases implementers prefer to use `RETURNDATACOPY` instead. Even if they rely on the output buffer (like in the case of Vyper), they would still check the length with `RETURNDATASIZE`. In Solidity one exception is the case when the expected return size is known (i.e. non-dynamic return values), in this case Solidity still uses the output buffer. + +### Status codes + +Current call instructions return a boolean value to signal success: 0 means failure, 1 means success. The Solidity compiler assumed this value is a boolean and thus uses the value as branch condition to status (`if iszero(status) { /* failure */ }`). This prevents us from introducing new status codes without breaking existing contracts. At the time of the design of [EIP-211](./eip-211.md) the idea of return a specific code for revert was discussed, but ultimately abandoned for the above reason. + +We change the value from boolean to a status code, where `0` signals success and thus it will be possible to introduce more non-success codes in the future, if desired. + +### Parameter order + +The order of parameters has been changed to move the `value` field to be the last. This allows the instructions to have identical encoding with the exception of the last parameter, and simplifies EVM and compiler implementations slightly. + +### Opcode encoding + +Instead of introducing three new opcodes we have discussed a version with an immediate configuration byte (flags). There are two main disadvantages to this: + +1. Some combination of flags may not be useful/be invalid, and this increases the testing/implementation surface. +2. The instruction could take variable number of stack items (i.e. `value` for `CALL2`) would be a brand new concept no other instruction has. + +It is also useful to have these as new opcodes instead of modifying the exiting CALL series inside of EOF. This creates an "escape hatch" in case gas observability needs to be restored to EOF contracts. This is done by adding the GAS and original CALL series opcodes to the valid EOF opcode list. + +### `CALLCODE` + +Since `CALLCODE` is deprecated, we do not introduce a counterpart here. + +## Backwards Compatibility + +No existing instructions are changed and so we do not think any backwards compatibility issues can occur. + +## Security Considerations + +It is expected that the attack surface will not grow. All of these operations can be modeled by existing operations with fixed gas (all available) and output range (zero length at zero memory). + +When implemented in EOF (where the GAS opcode and the original CALL operations are removed) existing out of gas attacks will be slightly more difficult, but not entirely prevented. Transactions can still pass in arbitrary gas values and clever contract construction can still result in specific gas values being passed to specific calls. It is expected the same surface will remain in EOF, but the ease of explotation will be reduced. + +## Copyright + +Copyright and related rights waived via [CC0](../LICENSE.md). From 46b9b698815abbfa628cd1097311deee77dd45c5 Mon Sep 17 00:00:00 2001 From: James Brown Date: Tue, 6 Jun 2023 01:10:39 +0300 Subject: [PATCH 57/97] Update EIP-5169: Move to Final Merged by EIP-Bot. --- EIPS/eip-5169.md | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/EIPS/eip-5169.md b/EIPS/eip-5169.md index 85a48184e274ef..03fb383158885d 100644 --- a/EIPS/eip-5169.md +++ b/EIPS/eip-5169.md @@ -4,8 +4,7 @@ title: Client Script URI for Token Contracts description: Add a scriptURI to point to an executable script associated with the functionality of the token. author: James (@JamesSmartCell), Weiwu (@weiwu-zhang) discussions-to: https://ethereum-magicians.org/t/eip-5169-client-script-uri-for-token-contracts/9674 -status: Last Call -last-call-deadline: 2023-05-12 +status: Final type: Standards Track category: ERC created: 2022-05-03 From 5188ecfec1f068050353e76c894a81148d546114 Mon Sep 17 00:00:00 2001 From: everdimension Date: Wed, 7 Jun 2023 04:16:02 +0100 Subject: [PATCH 58/97] Update EIP-6963: Update Window Events section Merged by EIP-Bot. --- EIPS/eip-6963.md | 77 +++++++++++++++++++++++++++--------------------- 1 file changed, 44 insertions(+), 33 deletions(-) diff --git a/EIPS/eip-6963.md b/EIPS/eip-6963.md index 4289664323fd5f..172064a522ac81 100644 --- a/EIPS/eip-6963.md +++ b/EIPS/eip-6963.md @@ -90,66 +90,77 @@ interface EIP6963ProviderDetail { } ``` -### Window Event +### Window Events -In order to prevent provider collisions, the DApp and the Wallet are expected to emit an event and instantiate an eventListener to discover the various Wallet's. This forms an Event concurrency loop. +In order to prevent provider collisions, the DApp and the Wallet are expected to emit an event and instantiate an eventListener to discover the various Wallets. This forms an Event concurrency loop. -To emit events both DApps and Wallets MUST use the `window.dispatchEvent` function to emit events and MUST use the `window.addEventListener` function to observe events. There will be two Event interfaces used for the DApp and Wallet to discover each other. +Since the DApp code and Wallet code aren't guaranteed to run in a particular order, the events are designed to handle such race conditions. -#### Wallet Events +To emit events both DApps and Wallets MUST use the `window.dispatchEvent` function to emit events and MUST use the `window.addEventListener` function to observe events. There are two Event interfaces used for the DApp and Wallet to discover each other. + +#### Announce and Request Events The `EIP6963AnnounceProviderEvent` interface MUST be a `CustomEvent` object with a `type` property containing a string value of `eip6963:announceProvider` and a `detail` property with an object as it's value of type `EIP6963ProviderDetail`. The `EIP6963ProviderDetail` object MUST be frozen by calling `Object.freeze()` on the value of the `detail` property. ```typescript -// A Wallet announcing the EIP6963ProviderDetail object +// Announce Event dispatched by a Wallet interface EIP6963AnnounceProviderEvent extends CustomEvent { type: "eip6963:announceProvider"; detail: EIP6963ProviderDetail; } ``` -The Wallet must announce to the DApp this `CustomEvent` via a `window.dispatchEvent()` function call. In order for the Wallet to recognize that the DApp is Web3 enabled and can support interactions with the Web3 Platform APIs the Wallet MUST add an EventListener to catch an Event dispatched from the DApp. This EventListener MUST have a `type` property with the string `eip6963:requestProvider` and MUST use a handler that will re-dispatch a `CustomEvent` object of type `EIP6963AnnounceProviderEvent`. This re-announcement by the Wallet is useful for when a Wallet's initial Event announcement may have been delayed or fired before the DApp had initialized it's EventListener. This allows the various Wallet Providers to react to the DApp without the need to pollute the `window.ethereum` namespace which can produce non-deterministic wallet behavior such as different wallets connecting each time. +The `EIP6963RequestProviderEvent` interface MUST be an `Event` object with a `type` property containing a string value of `eip6963:requestProvider`. ```typescript - function announceProvider() { - const info: EIP6963ProviderInfo = { - uuid: "350670db-19fa-4704-a166-e52e178b59d2", - name: "Example Wallet", - icon: "https://wallet.example.org/icon.png", - }; - window.dispatchEvent( - new CustomEvent("eip6963:announceProvider", { - detail: Object.freeze({ info, provider }), - }) - ); - } - -window.addEventListener( - "eip6963:requestProvider", - (event: EIP6963RequestProviderEvent) => { - announceProvider(); - } -); +// Request Event dispatched by a DApp +interface EIP6963RequestProviderEvent extends Event { + type: "eip6963:requestProvider"; +} ``` -#### DApp Events -The DApp MUST listen for the `CustomEvent` dispatched by the Wallet via a `window.dispatchEvent()` function call. In order for the DApp to discover the `EIP6963AnnounceProviderEvent` this EventListener MUST have a `type` property with the string `eip6963:requestProvider`. +The Wallet MUST announce to the DApp the `EIP6963AnnounceProviderEvent` via a `window.dispatchEvent()` function call. The Wallet MUST add an EventListener to catch an `EIP6963RequestProviderEvent` dispatched from the DApp. This EventListener MUST use a handler that will re-dispatch an `EIP6963AnnounceProviderEvent`. This re-announcement by the Wallet is useful for when a Wallet's initial Event announcement may have been delayed or fired before the DApp had initialized its EventListener. This allows the various Wallet Providers to react to the DApp without the need to pollute the `window.ethereum` namespace which can produce non-deterministic wallet behavior such as different wallets connecting each time. + +The Wallet listens dispatches the `"eip6963:announceProvider"` event and listens to the `"eip6963:requestProvider"` event: ```typescript -// Requesting an EVM provider -interface EIP6963RequestProviderEvent extends Event { - type: "eip6963:requestProvider"; -} +let info: EIP6963ProviderInfo; +let provider: EIP1193Provider; + +const announceEvent: EIP6963AnnounceProviderEvent = new CustomEvent( + "eip6963:announceProvider", + { detail: Object.freeze({ info, provider }) } +); + +// The Wallet dispatches an announce event which is heard by +// the DApp code that had run earlier +window.dispatchEvent(announceEvent); + +// The Wallet listens to the request events which may be +// dispatched later and re-dispatches the `EIP6963AnnounceProviderEvent` +window.addEventListener("eip6963:requestProvider", () => { + window.dispatchEvent(announceEvent); +}); ``` -In a DApp's implementation, it uses the `EIP6963RequestProviderEvent` interface. The `EIP6963RequestProviderEvent` interface is an Event object with a `type` property containing a string value of `eip6963:requestProvider`. +The DApp MUST listen for the `EIP6963AnnounceProviderEvent` dispatched by the Wallet via a `window.addEventListener()` method. The DApp MUST dispatch the `EIP6963RequestProviderEvent` via a `window.dispatchEvent()` function call. ```typescript - window.addEventListener("eip6963:announceProvider"); +// The DApp listens to announced providers +window.addEventListener( + "eip6963:announceProvider", + (event: EIP6963AnnounceProviderEvent) => {} +); + +// The DApp dispatches a request event which will be heard by +// Wallets' code that had run earlier +window.dispatchEvent(new Event("eip6963:requestProvider")); ``` The DApp MAY also keep track of the various `EIP6963ProviderDetail` announced by the various wallets so that if the user wishes to utilize a different Wallet the DApp can immediately send transactions to the new Wallet. Otherwise, the DApp MAY re-initiate the wallet discovery flow via dispatching a new `EIP6963RequestProviderEvent` Event. +The described orchestration of events guarantees that the DApp is able to discover the Wallet, regardless of which code executes first, the Wallet code or the DApp code. + ## Rationale Previous proposal introduced mechanisms that relied on a single window object that could be overridden by multiple parties. Therefore using an event-based approach we avoid the race conditions and potential attacks by making the communication available both ways in a way that doesn't have potential namespace collisions. From 39a11ce272dbec5c75af6e3518ccc68b3282b07c Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Toni=20Wahrst=C3=A4tter?= <51536394+nerolation@users.noreply.github.com> Date: Wed, 7 Jun 2023 08:49:41 +0200 Subject: [PATCH 59/97] Update EIP-5564: ERC-5564 - remove staking and add indexed caller Merged by EIP-Bot. --- EIPS/eip-5564.md | 65 ++++++++---------------------------------------- 1 file changed, 11 insertions(+), 54 deletions(-) diff --git a/EIPS/eip-5564.md b/EIPS/eip-5564.md index 9fc6da2ad8fee4..e2a2e03dac2168 100644 --- a/EIPS/eip-5564.md +++ b/EIPS/eip-5564.md @@ -101,12 +101,13 @@ This specification additionally defines a singleton `ERC5564Messenger` contract ```solidity /// @notice Interface for announcing when something is sent to a stealth address. -contract IERC5564Messenger is StakeManager{ +contract IERC5564Messenger { /// @dev Emitted when sending something to a stealth address. /// @dev See the `announce` method for documentation on the parameters. event Announcement ( uint256 indexed schemeId, address indexed stealthAddress, + address indexed caller, bytes ephemeralPubKey, bytes metadata ); @@ -141,57 +142,11 @@ contract IERC5564Messenger is StakeManager{ ) external { - emit Announcement(schemeId, stealthAddress, ephemeralPubKey, metadata); + emit Announcement(schemeId, stealthAddress, msg.sender, ephemeralPubKey, metadata); } } ``` -The `ERC5564Messenger` contract inherits the `StakeManager` contract allowing users to stake ETH that is used as an anti-DoS measure. More details in the [DoS Countermeasures](#dos-countermeasures) section. - -```solidity -/// @notice Interface for the Stake Manager contract. -contract StakeManager{ - - /// @dev Emitted when stake is deposited. - /// @param account The address of the staker who deposited the stake. - /// @param totalStaked The new total amount of staked tokens for the account. - event StakeDeposit ( - address indexed account, - uint256 totalStaked - ); - - /// @dev Emitted when stake is withdrawn. - /// @param account The address of the staker who withdrew the stake. - /// @param withdrawAddress The address to which the withdrawn amount was sent. - /// @param amount The amount of tokens withdrawn. - event StakeWithdrawal ( - address indexed account, - address withdrawAddress, - uint256 amount - ); - - /** - * @notice Returns the stake of the account. - * @param account The address of the staker to check the stake for. - * @return uint256 The amount of staked tokens for the account. - */ - function balanceOf(address account) external view returns (uint256); - - /** - * @notice Adds the specified amount to the account's stake. - * @dev The function is payable, so the amount is sent as value with the transaction. - * @param staker The address of the staker to add the stake for. - */ - function addStake(address staker) external payable; - - /** - * @notice Withdraws the stake for the caller and sends it to the specified address. - * @param withdrawAddress The address to send the withdrawn amount to. - */ - function withdrawStake(address payable withdrawAddress) external; -} -``` - ### Stealth meta-address format @@ -289,13 +244,13 @@ The view tags approach is introduced to reduce the parsing time by around 6x. Us ## Rationale -This EIP emerged from the need of having privacy-preserving ways to transfer ownership without disclosing any information about the recipients' identities. Token ownership can expose sensitive personal information. While individuals may wish to donate to a specific organization or country, they might prefer not to disclose a link between themselves and the recipient at the same time. Standardizing stealth address generation represents a significant step towards unlinkable interactions, since such privacy-enhancing solutions require standards to achieve widespread adoption. Consequently, it is crucial to concentrate on developing generalizable approaches for implementing related solutions. +This EIP emerged from the need for privacy-preserving ways to transfer ownership without disclosing any information about the recipients' identities. Token ownership can expose sensitive personal information. While individuals may wish to donate to a specific organization or country, they might prefer not to disclose a link between themselves and the recipient simultaneously. Standardizing stealth address generation represents a significant step towards unlinkable interactions, since such privacy-enhancing solutions require standards to achieve widespread adoption. Consequently, it is crucial to focus on developing generalizable approaches for implementing related solutions. The stealth address specification standardizes a protocol for generating and locating stealth addresses, facilitating the transfer of assets without requiring prior interaction with the recipient. This enables recipients to verify the receipt of a transfer without the need to interact with the blockchain and query account balances. Importantly, stealth addresses enable token transfer recipients to verify receipt while maintaining their privacy, as only the recipient can recognize themselves as the recipient of the transfer. The authors recognize the trade-off between on- and off-chain efficiency. Although incorporating a Monero-like view tags mechanism enables recipients to parse announcements more efficiently, it adds complexity to the announcement event. -The address of the recipient and the `viewTag` MUST be included in the announcement event, allowing users to quickly verify ownership without querying the chain for positive account balances. +The recipient's address and the `viewTag` MUST be included in the announcement event, allowing users to quickly verify ownership without querying the chain for positive account balances. ## Backwards Compatibility @@ -310,16 +265,18 @@ You can find an implementation of this standard in TBD. ### DoS Countermeasures There are potential denial of service (DoS) attack vectors that are not mitigated by network transaction fees. Stealth transfer senders cause an externality for recipients, as parsing announcement events consumes computational resources that are not compensated with gas. Therefore, spamming announcement events *can* be a detriment to the user experience, as it *can* lead to longer parsing times. -We consider the incentives to carry out such an attack to be low because **no monetary benefit can be obtained** and, in theory, nothing prevents parsing providers from ignoring the spamming when serving announcements to users. -However, sophisticated spamming (*sybil attacks*), which are not considered worth the associated costs, could make it difficult for parsing providers to develop filters for such announcement events. -Therefore, to counter spamming directly, a staking mechanism is introduced in the EIP that allows users to stake an unslashable amount of ETH. Staking allows parsing providers to better tackle potential spam through *sybil attacks*, enabling them to filter spam more effectively. +We consider the incentives to carry out such an attack to be low because **no monetary benefit can be obtained** +However, to tackle potential spam, parsing providers may adopt their own anti-DoS attack methods. These may include ignoring the spamming users when serving announcements to users or, less harsh, de-prioritizing them when ordering the announcements. The indexed `caller` keyword may help parsing providers to effectively filter known spammers. -Similarly to [ERC-4337](./eip-4337), parsing providers agree on a `MINIMUM_STAKE`, such that the minimum required stake is not enforced on-chain. Users *can* withdraw their stake at any time without any delay. Parsing providers can de-prioritize senders who have not staked a certain minimum amount or withdrew their stake immediately. +Furthermore, parsing providers have a few options to counter spam, such as introducing staking mechanisms or requiring senders to pay a `toll` before including their `Announcement`. Moreover, a Staking mechanism may allow users to stake an unslashable amount of ETH (similarly to [ERC-4337](./eip-4337)), to help mitigate potential spam through *sybil attacks* and enable parsing providers filtering spam more effectively. +Introducing a `toll`, paid by sending users, would simply put a cost on each stealth address transaction, making spamming economically unattractive. ### Recipients' transaction costs The funding of the stealth address wallet represents a known issue that might breach privacy. The wallet that funds the stealth address MUST NOT have any physical connection to the stealth address owner in order to fully leverage the privacy improvements. +Thus, the sender may attach a small amount of ETH to each stealth address transaction, thereby sponsoring subsequent transactions of the recipient. + ## Copyright Copyright and related rights waived via [CC0](../LICENSE.md). From 3ed24020f7350e116ed26bfb4ba8278eb7b6b656 Mon Sep 17 00:00:00 2001 From: g11tech Date: Wed, 7 Jun 2023 15:31:05 +0530 Subject: [PATCH 60/97] Update EIP-4844: Specify precompile input's z and y to be encoded as big endian Merged by EIP-Bot. --- EIPS/eip-4844.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/EIPS/eip-4844.md b/EIPS/eip-4844.md index f43da5418eafbb..f33aadd1017395 100644 --- a/EIPS/eip-4844.md +++ b/EIPS/eip-4844.md @@ -184,7 +184,7 @@ def point_evaluation_precompile(input: Bytes) -> Bytes: Verify p(z) = y given commitment that corresponds to the polynomial p(x) and a KZG proof. Also verify that the provided commitment matches the provided versioned_hash. """ - # The data is encoded as follows: versioned_hash | z | y | commitment | proof | + # The data is encoded as follows: versioned_hash | z | y | commitment | proof | with z and y being padded 32 byte big endian values assert len(input) == 192 versioned_hash = input[:32] z = input[32:64] @@ -195,7 +195,7 @@ def point_evaluation_precompile(input: Bytes) -> Bytes: # Verify commitment matches versioned_hash assert kzg_to_versioned_hash(commitment) == versioned_hash - # Verify KZG proof + # Verify KZG proof with z and y in big endian format assert verify_kzg_proof(commitment, z, y, proof) # Return FIELD_ELEMENTS_PER_BLOB and BLS_MODULUS as padded 32 byte big endian values From aaf7b9557156d70abb3d859629b05e2baa3202fe Mon Sep 17 00:00:00 2001 From: adam-alchemy <127769144+adam-alchemy@users.noreply.github.com> Date: Wed, 7 Jun 2023 13:03:39 -0700 Subject: [PATCH 61/97] Update EIP-6900: Spec changes regarding call mode and new hook types Merged by EIP-Bot. --- EIPS/eip-6900.md | 285 ++++++++---------- .../MSCA_Shared_Components_Diagram.svg | 0 .../eip-6900/MSCA_Two_Call_Paths_Diagram.svg | 16 + .../MSCA_Two_Call_Paths_Diagram.svg | 16 - 4 files changed, 150 insertions(+), 167 deletions(-) rename assets/{eip-modular-smart-contract-accounts-and-plugins => eip-6900}/MSCA_Shared_Components_Diagram.svg (100%) create mode 100644 assets/eip-6900/MSCA_Two_Call_Paths_Diagram.svg delete mode 100644 assets/eip-modular-smart-contract-accounts-and-plugins/MSCA_Two_Call_Paths_Diagram.svg diff --git a/EIPS/eip-6900.md b/EIPS/eip-6900.md index 3d6dfa2066498a..915608f05dcb47 100644 --- a/EIPS/eip-6900.md +++ b/EIPS/eip-6900.md @@ -1,7 +1,7 @@ --- eip: 6900 title: Modular Smart Contract Accounts and Plugins -description: Interfaces for composable account plugins optionally supporting upgradability and introspection +description: Interfaces for composable contract accounts optionally supporting upgradability and introspection author: Adam Egyed (@adamegyed), Fangting Liu (@trinity-0111) discussions-to: https://ethereum-magicians.org/t/eip-modular-smart-contract-accounts-and-plugins/13885 status: Draft @@ -13,9 +13,9 @@ requires: 4337 ## Abstract -This proposal standardizes smart contract accounts and account plugins, which are smart contract interfaces that allow for composable logic within smart contract accounts. This proposal is compliant with [ERC-4337](./eip-4337.md), and builds on the existing work from [ERC-2535](./eip-2535.md) when defining interfaces for updating and querying modular function implementations. +This proposal standardizes smart contract accounts and account plugins, which are smart contract interfaces that allow for composable logic within smart contract accounts. This proposal is compliant with [ERC-4337](./eip-4337.md), and takes inspiration from [ERC-2535](./eip-2535.md) when defining interfaces for updating and querying modular function implementations. -This modular approach splits account functionality into three categories, delegates them to external contracts, and defines an expected execution flow from accounts. +This modular approach splits account functionality into three categories, implements them in external contracts, and defines an expected execution flow from accounts. ## Motivation @@ -27,11 +27,13 @@ However, managing multiple wallet instances provides a worse user experience, fr We propose a standard that coordinates the implementation work between plugin developers and wallet developers. This standard defines a modular smart contract account capable of supporting all standard-conformant plugins. This allows users to have greater portability of their data, and for plugin developers to not have to choose specific wallet implementations to support. -![diagram showing relationship between accounts and plugins of each type](../assets/eip-modular-smart-contract-accounts-and-plugins/MSCA_Shared_Components_Diagram.svg) +![diagram showing relationship between accounts and plugins of each type](../assets/eip-6900/MSCA_Shared_Components_Diagram.svg) -We take inspiration from ERC-2535’s diamond pattern and adopt a similar composability by proposing three types of plugins. However, you are not required to implement the account with a multi-facet proxy pattern. These plugins contain execution logic. They also incorporate validation schemes and hooks. Validation schemes define the circumstances under which the smart contract account will approve actions taken on its behalf, while hooks allow for pre- and post-execution controls. Accounts adopting this ERC will support modular, upgradable execution and validation logic. +We take inspiration from ERC-2535’s diamond pattern for routing execution based on function selectors, and create a similarly composable account. However, the standard does not require the multi-facet proxy pattern. -Defining this as a standard for smart contract accounts will make plugins easier to develop securely and will allow for greater interoperability. +These plugins can contain execution logic, validation schemes, and hooks. Validation schemes define the circumstances under which the smart contract account will approve actions taken on its behalf, while hooks allow for pre- and post-execution controls. + +Accounts adopting this standard will support modular, upgradable execution and validation logic. Defining this as a standard for smart contract accounts will make plugins easier to develop securely and will allow for greater interoperability. Goals: @@ -50,44 +52,44 @@ The key words "MUST", "MUST NOT", "REQUIRED", "SHALL", "SHALL NOT", "SHOULD", "S - **Execution functions** execute any custom logic allowed by the account. - **Hooks** execute custom logic and checks before and/or after an execution function. - A **validation function** is a function that validates authentication and authorization of a caller to the account. There are two types of validation functions: - - **User Operation Validator** functions handle calls to `validateUserOp` and check the validity of an ERC-4337 user operation. The function may have any function name, but MUST take in the parameters `(UserOperation calldata, bytes32, uint256)`, representing the user operation, user operation hash, and required prefund. It MUST return `(uint256)`, representing packed validation data for `authorizer`, `validUntil`, and `validAfter`. - - **Runtime Validator** functions run before an execution function, and enforce checks. Common checks include enforcing only calls from `EntryPoint` or an owner. -- An **execution function** is a smart contract function that defines the execution of a function for a **modular account**. -- A **hook** is a smart contract function executed before or after an **execution function**, with the ability to modify state or cause the entire call to revert. There are two types of **hooks**. - - **preHook** functions run before an **execution function;**. They map optionally return data to be consumed the **postHook**. - - **postHook** functions run after an **execution function**. They can optionally take returned data from **preHook**. + - **User Operation Validator** functions handle calls to `validateUserOp` and check the validity of an ERC-4337 user operation. The function may have any function name, and MUST take in the parameters `(UserOperation calldata, bytes32, uint256)`, representing the user operation, user operation hash, and required prefund. It MUST return `(uint256)`, representing packed validation data for `authorizer`, `validUntil`, and `validAfter`. + - **Runtime Validator** functions run before an execution function when not called via a user operation, and enforce checks. Common checks include allowing execution only by an owner. +- An **execution function** is a smart contract function that defines the main execution step of a function for a **modular account**. +- The **standard execute functions** are two specific execution functions that are implemented natively by the modular account, and not on a plugin. These allow for open-ended execution. +- A **hook** is a smart contract function executed before or after another function, with the ability to modify state or cause the entire call to revert. There are four types of **hooks**. + - **Pre User Operation Validation Hook** functions run before user operation validators. These can enforce permissions on what actions a validator may perform via user operations. + - **Pre Runtime Validation Hook** functions run before runtime validators. These can enforce permissions on what actions a validator may perform via direct calls. + - **Pre Execution Hook** functions run before an **execution function**. They may optionally return data to be consumed the **postHook**. + - **Post Execution Hook** functions run after an **execution function**. They may optionally take returned data from **preHook**. - **Associated function** refers to either a validation function or a hook. - A **plugin** is a deployed smart contract that hosts any amount of the above three kinds of modular functions: execution functions, validation functions, or hooks. ### Overview -A smart contract account handles two kinds of calls: one from `Entrypoint` through ERC-4337, the other are direct calls from EOA and other smart contracts. The proposal supports both use cases. +A modular account handles two kinds of calls: either from the `Entrypoint` through ERC-4337, or through direct calls from externally owned accounts (EOAs) and other smart contracts. This standard supports both use cases. -A call to the smart contract account can be decomposed into 4 steps as shown in the diagram below. The validation step (Step 1) validates if the caller is allowed to call. The pre execution hook step (Step 2) can be used to do any pre execution checks or updates. It can also be used with the post execution hook step (Step 4) to perform certain verifications. The execution step (Step 3) performs a performs a call-defined task or collection of tasks. +A call to the smart contract account can be decomposed into 5 steps as shown in the diagram below. The validation steps (Steps 1 and 2) validate if the caller is allowed to call. The pre execution hook step (Step 2) can be used to do any pre execution checks or updates. It can also be used with the post execution hook step (Step 4) to perform additional actions or verification. The execution step (Step 4) performs a performs a defined task or collection of tasks. -![diagram showing execution flow within an account](../assets/eip-modular-smart-contract-accounts-and-plugins/MSCA_Two_Call_Paths_Diagram.svg) +![diagram showing execution flow within an account](../assets/eip-6900/MSCA_Two_Call_Paths_Diagram.svg) -Each step is modularized and can have different combinations and infinite functionalities. **The smart contract account SHOULD orchestrate the above 4 steps.** For example, a MSCA has a fallback functions that orchestrate the above 4 steps for the account. +Each step is modular, supporting different implementations for each execution function, and composable, supporting multiple steps through hooks. Combined, these allow for open-ended programmable accounts. ### Interfaces Modular Smart Contract Accounts MUST implement the `IAccount` interface from [ERC-4337](./eip-4337.md). -#### `IModularAccount.sol` +#### Common types -Modular Smart Contract Accounts MAY implement `IModularAccount` to support view functions without the need to add view functions selectors into storage through updatePlugins. +The following types are used by both of the following interfaces. Implementors MAY use the elementary value type instead of the type alias. ```solidity -interface IModularAccount { - /** - * view function calls to the account - * @param implAddress the address of the implmentation contract - * @param data params to pass to the view function - */ - function viewCall(address implAddress, bytes calldata data) external returns (bytes memory); -} +type FunctionReference is bytes24; + +type HookGroupId is uint32; ``` +Variables of the type `FunctionReference` MUST be interpreted as an address in the first 20 bytes and a function selector in the remaining 4 bytes. + #### `IPluginUpdate.sol` Plugin modification interface. Modular Smart Contract Accounts MAY implement this interface to support updates to plugins. @@ -100,103 +102,114 @@ interface IPluginUpdate { REMOVE } - enum AssociatedFunctionType { + enum ValidatorType { USER_OP_VALIDATOR, - RUNTIME_VALIDATOR, - PRE_HOOK, - POST_HOOK + RUNTIME_VALIDATOR } - struct PluginUpdate { - address executionPluginAddress; + enum HookType { + PRE_EXEC_HOOK, + POST_EXEC_HOOK, + PRE_USER_OP_VALIDATION_HOOK, + PRE_RUNTIME_VALIDATION_HOOK + } + + struct ExecutionUpdate { PluginAction action; - ExecutionUpdate[] executionUpdates; + address pluginAddress; + bytes4[] executionSelectors; + ValidatorUpdate[] validatorUpdates; } - struct GlobalPluginUpdate { + struct ValidatorUpdate { PluginAction action; - AssociatedFunction globalPlugin; + ValidatorType validatorType; + FunctionReference functionReference; } - struct ExecutionUpdate { - bytes4 executionSelector; - AssociatedFunction[] associatedFunctions; + struct HookGroupUpdate { + PluginAction action; + HookGroupId hookGroupId; + bytes4[] executionSelectors; } - struct AssociatedFunction { - AssociatedFunctionType functionType; - address implAddress; - bytes4 implSelector; + struct HookUpdate { + PluginAction action; + HookGroupId hookGroupId; + HookType hookType; + FunctionReference functionReference; } - event PluginsUpdated(PluginUpdate[] pluginUpdates, address init, bytes callData); - - event GlobalPluginsUpdated(AssociatedFunction[] globalPluginUpdates, address init, bytes callData); - - /** - * @notice Add/replace/remove any number of plugins and optionally execute a function - * @param pluginUpdates Contains the plugin addresses and function selectors. - * executionPluginAddress specifies the plugin containing the execution functions defined within - * pluginAction denotes what operation to perform - * executionUpdates denote which execution function and associated function to perform the opeartion on. - * @param init The address of the contract or facet to execute calldata - * @param callData A function call, including function selector and arguments - */ - function updatePlugins(PluginUpdate[] memory pluginUpdates, address init, bytes calldata callData) external; - - /** - * @notice Add/replace/remove any number of global plugins and optionally execute a function - * @param globalPluginUpdates Contains the plugin addresses and function selectors. - * @param init The address of the contract or facet to execute calldata - * @param callData A function call, including function selector and arguments - */ - function updateGlobalPlugins(GlobalPluginUpdate[] memory globalPluginUpdates, address init, bytes calldata callData) - external; + event ExecutionPluginUpdate(ExecutionUpdate[] executionUpdates); + + function updatePlugins( + ExecutionUpdate[] calldata executionUpdates, + HookUpdate[] calldata hookUpdates, + HookGroupUpdate[] calldata hookGroupUpdates, + address init, + bytes calldata callData + ) external; } ``` #### `IPluginLoupe.sol` -Plugin inspection interface. Modular Smart Contract Accounts MAY implement this interface to support visibility in plugin configuration on-chain. Note this will require extra storage. +Plugin inspection interface. Modular Smart Contract Accounts MAY implement this interface to support visibility in plugin configuration on-chain. ```solidity interface IPluginLoupe { - struct PluginInfo { + struct ExecutionPluginConfig { address executionPluginAddress; - FunctionConfig[] configs; - } - - struct FunctionConfig { - bytes4 executionSelector; + HookGroupId[] hookGroupIds; + HookGroup[] hookGroups; FunctionReference userOpValidator; FunctionReference runtimeValidator; - FunctionReference preHook; - FunctionReference postHook; } - struct FunctionReference { - address implAddress; - bytes4 implSelector; + struct HookGroup { + FunctionReference preUserOpValidation; + FunctionReference preRuntimeValidation; + FunctionReference preExec; + FunctionReference postExec; } - function getPlugins() external view returns (PluginInfo[] memory); + function getExecutionFunctionConfig(bytes4 executionSelector) + external + view + returns (ExecutionPluginConfig memory); - function getPlugin(address executionPluginAddress) external view returns (FunctionConfig[] memory functions); - - function getFunctionConfig(bytes4 executionSelector) external view returns (FunctionConfig memory); + function getStandardExecutionValidators() + external + view + returns (FunctionReference[] memory userOpValidators, FunctionReference[] memory runtimeValidators); } ``` -#### `IPlugin.sol` +#### `IStandardExecutor.sol` -Plugin interface. Plugins MUST implement the following interface. +Standard execution interface. Modular Smart Contract Accounts MUST implement this interface to support open-ended execution. ```solidity -interface IPlugin { - // Returns the starting storage slot owned by the plugin. - // Storage may extend past this slot, or to other locations - // when used through mappings or dynamically-sized arrays - function pluginStorageRoot() external view returns (bytes32 slot); +interface IStandardExecutor { + + enum ExecutionMode { + CALL, + DELEGATECALL, + STATICCALL + } + + struct Execution { + address dest; + uint256 value; + bytes func; + ExecutionMode mode; + } + + function execute(address dest, uint256 value, bytes calldata func, ExecutionMode mode, FunctionReference validator) + external + payable; + + function executeBatch(Execution[] calldata executions, FunctionReference validator) external payable; } ``` @@ -204,99 +217,69 @@ interface IPlugin { #### Calls to `updatePlugins` -The function `updatePlugins` takes in an array of updates to perform, and an optional initialization function. The function MUST perform the update operation sequentially, then, if the address provided in `init` is not `address(0)`, MUST execute `init` with the calldata `callData`. +The function `updatePlugins` takes in arrays of execution updates, hook updates, and hook group updates to perform. It also takes in an optional initialization function. The function MUST perform the update operation sequentially, then, if the address provided in `init` is not `address(0)`, MUST execute `init` with the calldata `callData` through a `delegatecall`. -> **⚠️ The ability to update a plugin is very powerful. The security of the updatePlugins determines the security of the account. It is critical for Account builders to make sure updatePlugins has the proper security consideration and access control in place.** +> **⚠️ The ability to update a plugin is very powerful. The security of the updatePlugins determines the security of the account. It is critical for modular account implementers to make sure updatePlugins has the proper security consideration and access control in place.** #### Calls to `validateUserOp` -When the function `validateUserOp` is called on an MSCA by the `EntryPoint`, it MUST find the user operation validator defined for the selector in `userOp.callData`, which is in the first four bytes. If there is no function defined for the selector, or if `userOp.callData.length < 4`, then execution MUST revert. Otherwise, the MSCA MUST execute the validator function with the user operation, its hash, and the required prefund as parameters. The returned validation data from the user operation validator MUST be returned by `validateUserOp`. +When the function `validateUserOp` is called on modular account by the `EntryPoint`, it MUST find the user operation validator defined for the selector in `userOp.callData`, which is in the first four bytes. If there is no function defined for the selector, or if `userOp.callData.length < 4`, then execution MUST revert. Otherwise, the MSCA MUST execute the validator function with the user operation and its hash as parameters using the `call` opcode. The returned validation data from the user operation validator MUST be returned by `validateUserOp`. + +If the execution selector has associated hook groups with pre user operation validation hooks, then those hooks MUST be run sequentially. If any revert or return false, the outer call MUST revert. + +If the call is to a standard execution function, then the modular account must verify that the provided `validator` in calldata has previously been associated with either of the standard execution functions. If it was previously added, the specified user operation validator MUST be run. #### Calls to execution functions -When a function other than `validateUserOp` is called on an MSCA, it MUST find the plugin configuration for the corresponding selector added via `updatePlugins`. If no corresponding plugin is found, the MSCA MUST revert. Otherwise, the MSCA MUST perform the following steps: +When a function other than a natively defined function is called on an MSCA, it MUST find the plugin configuration for the corresponding selector added via `updatePlugins`. If no corresponding plugin is found, the MSCA MUST revert. Otherwise, the MSCA MUST perform the following steps: -- If a `runtimeValidator` function is defined, execute the function with the execution function’s calldata as parameter. -- If there are global `preHook`s, execute each with the execution function’s calldata. -- If an associated `preHook` is defined, execute the associated function with the execution function’s calldata. If the `preHook` returns data, it MUST be preserved until the call to `postHook`. -- execute the execution function. -- If an associated `postHook` is defined, execute the associated function with the execution function’s calldata. If the `preHook` function returned data, the MSCA MUST pass that data in to `postHook`. -- If there are global `postHook`s, execute each with the execution function’s calldata. +- If the call is not from the `EntryPoint`, then find an associated `runtimeValidator` function. If one does not exist, execution MUST revert. The modular account MUST execute all pre runtime validation hooks, then the runtime validator function, with the `call` opcode. All of these functions MUST receive the caller, value, and execution function’s calldata as parameters. If any of these functions revert, or return a boolean false, execution MUST revert. +- If there are pre execution hooks defined in the associated hook groups of the execution function, execute those hooks with the caller, value, and execution function’s calldata as parameters. If any of thee hooks returns data, it MUST be preserved until the call to the post execution hook. The operation must be done with the `call` opcode. +- Run the execution function. +- If any associated post execution hooks are defined, run the functions. If a pre execution hook in the same hook group returned data to the account, that data MUST be passed as a parameter to the post execution hook. The operation must be done with the `call` opcode. -> **⚠️ If the execution function does not have a definition for either `runtimeValidator`, `preHook`, or `postHook`, the undefined functions will be skipped. The execution function will be executed and it may change account state.** -> -> **💡 If, during the execution of `runtimeValidator`, the caller can be established as the EntryPoint contract, it is guaranteed the associated user operation validator has returned a valid signature. Validation MAY be skipped.** +> **⚠️ If the execution function does not have a definition for either pre runtime validation hooks, pre execution hooks or post execution hooks, the undefined functions will be skipped. The execution function will be run and it may change account state.** #### Plugin update operations When `updatePlugins` is called with `PluginAction.ADD`, the following MUST occur: -- Each `executionSelector` must be added their parent `executionPluginAddress` as a valid implementation contract to forward calls to. -- Each `AssociatedFunction` must be added to their parent execution function in the role specified by `associatedFunctionType`. +- Each execution selector must be added as a valid execution function, with the contract specified in `pluginAddress` as implementation contract to call to. +- Each validator function reference must be added to their parent execution function in the role specified by `validatorType`. +- Each hook update must add the hook type specified by `hookType` to the group specified by `hookGroupId`. If that hook type is already defined, the update MUST revert. +- Each hook group update must add that hook group to the execution selectors specified by `executionSelectors`. Execution function selectors MUST be unique when added. -When `updatePlugins` is called with `PluginAction.REPLACE`, each `executionSelector` MUST override any previous execution definition for said function selector. Any associated function defined MUST override previously defined function selectors. Existing associated functions not specified in this operation MUST NOT be modified. - -When `updatePlugins` is called with `PluginAction.REMOVE`, both execution function definitions and associated function definitions MUST be removed. The contents of the `associatedFunctions` array MUST be ignored. +When `updatePlugins` is called with `PluginAction.REPLACE`, each each execution selector or function reference MUST override any previous definition for said function. Existing associated functions not specified in this operation MUST NOT be modified. -When adding a plugin function of any type, the MSCA MAY call `pluginStorageRoot()` on the plugin. If the returned `bytes32` value has ever been returned by a previously added plugin, the MSCA MAY revert and reject the operation. +When `updatePlugins` is called with `PluginAction.REMOVE`, execution function definitions and associated function definitions MUST be removed. -#### Plugins Storage Management - -Plugins MAY access the storage of other plugins. If a plugin does not have any plugin-specific storage, it MUST return `0` for the method `pluginStorageRoot()`. +#### Plugin Functions -Plugin contracts MUST NOT define or access storage structs growing from slot 0. +Execution functions may have any function signature, but must be unique for the account. When added to an MSCA via `updatePlugins`, the function selector of the execution function will be mapped from the modular account to the plugin. -Plugin storage management is managed by plugin implementations. Here is an example where storage management is done through statically linked Solidity libraries. +User Operation Validation functions may have any function name, and MUST take in the parameters `(UserOperation calldata, bytes32)`, representing the user operation and the user operation hash. The functions MUST return `(uint256)`, representing packed validation data for `authorizer`, `validUntil`, and `validAfter`. -`LibMyPlugin.sol` +Here is an example function signature of a conformant user operation validator function: ```solidity -library LibMyPlugin { - bytes32 constant MY_PLUGIN_POSITION = keccak256("plugin.standard.my.plugin"); - - struct MyPluginStorage { - // Any storage fields you need - } - - // Return my plugin storage struct for reading and writing - function getStorage() internal pure returns (MyPluginStorage storage storageStruct) { - bytes32 position = MY_PLUGIN_POSITION; - assembly { - storageStruct.slot := position - } - } -} +function validateSignature(UserOperation calldata userOp, bytes32 userOpHash) external returns (uint256 validationData); ``` -#### Plugin Functions - -Execution functions may have any function signature, but must be unique for the account. When added to an MSCA via `updatePlugins`, the function selector of the execution function will be mapped from the modular account to the plugin. - -User Operation Validation functions may have any function name, and MUST take in the parameters `(UserOperation calldata, bytes32)`, representing the user operation and the user operation hash. The functions MUST return `(uint256)`, representing packed validation data for `authorizer`, `validUntil`, and `validAfter`. - -> Here is an example function signature of a conformant user operation validator function: -> -> ```solidity -> function validateSignature(UserOperation calldata userOp, bytes32 userOpHash) external returns (uint256 validationData); -> ``` +Runtime Validation Functions may have any function name, and MUST take in the parameters `(address, uint256, bytes calldata)`. -Runtime Validation Functions may have any function name, and MUST take in the parameters `(bytes calldata)`. +Here is an example function signature of a conformant runtime validator function: -> Here is an example function signature of a conformant runtime validator function: -> -> ```solidity -> function validateOwnership(bytes calldata) external; -> ``` +```solidity +function validateOwnership(address caller, uint256 value, bytes calldata) external; +``` Hooks MAY have any function name. -Global hooks MUST be executed for every incoming call. -The global preHook function MUST take in the parameters `(bytes calldata data)`. -The global postHook function MUST take in the parameters `(bytes calldata data)`. -For sets of hooks that are used specifically with execution funtions, they MAY be paired and share information through returned value. -The preHook function MUST take in the parameters `(bytes calldata data)` and return `(bytes calldata preHookReturnedData)`. -The postHook function MUST take in the parameters `(bytes calldata data, bytes calldata preHookReturnedData)`. +The pre user operation validation hook functions MUST take in the parameters `(bytes calldata callData, bytes calldata paymasterAndData)` and return `(bool)`. +The pre runtime validation hook functions MUST take in the parameters `(bytes calldata)` and return `(bool)`. +The pre execution hook functions MUST take in the parameters `(address, uint256, bytes calldata)` and return `(bytes calldata)`. +The post execution hook functions MUST take in the parameters `(bytes calldata)`. ## Rationale diff --git a/assets/eip-modular-smart-contract-accounts-and-plugins/MSCA_Shared_Components_Diagram.svg b/assets/eip-6900/MSCA_Shared_Components_Diagram.svg similarity index 100% rename from assets/eip-modular-smart-contract-accounts-and-plugins/MSCA_Shared_Components_Diagram.svg rename to assets/eip-6900/MSCA_Shared_Components_Diagram.svg diff --git a/assets/eip-6900/MSCA_Two_Call_Paths_Diagram.svg b/assets/eip-6900/MSCA_Two_Call_Paths_Diagram.svg new file mode 100644 index 00000000000000..96d76a98747b0c --- /dev/null +++ b/assets/eip-6900/MSCA_Two_Call_Paths_Diagram.svg @@ -0,0 +1,16 @@ + + + + + + + SCAEntryPointEOA/SC callA.0B.1A.1A.2Step 1Step 2Step 3Step 4ACalls from Entrypoint (ERC-4337)BCalls from EOAs and other contractsB.2UserOpValidatorvalidateUserOpPre-UserOpValidate Hook(s)Execution FunctionPre-Execution Hook(s)Post-Execution Hook(s)A.3 B.3A.4 B.4fallback & standard executionfrom EntryPoint?RuntimeValidatorPre-RuntimeValidate Hook(s)noyesStep 5 \ No newline at end of file diff --git a/assets/eip-modular-smart-contract-accounts-and-plugins/MSCA_Two_Call_Paths_Diagram.svg b/assets/eip-modular-smart-contract-accounts-and-plugins/MSCA_Two_Call_Paths_Diagram.svg deleted file mode 100644 index 729ecb99bff628..00000000000000 --- a/assets/eip-modular-smart-contract-accounts-and-plugins/MSCA_Two_Call_Paths_Diagram.svg +++ /dev/null @@ -1,16 +0,0 @@ - - - - - - - SCAEntryPointEOA/SC callA.0B.1Execution FunctionA.1runtimeValidatorPre Execution Hook(s)Post Execution Hook(s)A.2Step 1Step 2Step 3Step 4ACalls from Entrypoint (ERC-4337)BCalls from EOAs and other contractsA.3 B.3A.4 B.4B.2userOpValidatorvalidateUserOp \ No newline at end of file From 8d64936ecd0717a3860f7e0d7ba3240e717bd10f Mon Sep 17 00:00:00 2001 From: Jan Turk Date: Wed, 7 Jun 2023 23:32:57 +0200 Subject: [PATCH 62/97] Update EIP-6381: Add bulk actions and presigned emotes Merged by EIP-Bot. --- EIPS/eip-6381.md | 205 +++++++++- .../eip-6381/contracts/EmotableRepository.sol | 271 +++++++++++++ assets/eip-6381/contracts/IERC6381.sol | 60 +++ assets/eip-6381/test/emotableRepository.ts | 360 +++++++++++++++++- 4 files changed, 891 insertions(+), 5 deletions(-) diff --git a/EIPS/eip-6381.md b/EIPS/eip-6381.md index 1fa3003cfd2067..4087da1a3ddcfa 100644 --- a/EIPS/eip-6381.md +++ b/EIPS/eip-6381.md @@ -49,7 +49,7 @@ The key words “MUST”, “MUST NOT”, “REQUIRED”, “SHALL”, “SHALL ```solidity /// @title ERC-6381 Emotable Extension for Non-Fungible Tokens /// @dev See https://eips.ethereum.org/EIPS/eip-6381 -/// @dev Note: the ERC-165 identifier for this interface is 0x08eb97a6. +/// @dev Note: the ERC-165 identifier for this interface is 0xd9fac55a. pragma solidity ^0.8.16; @@ -84,6 +84,19 @@ interface IERC6381 /*is IERC165*/ { bytes4 emoji ) external view returns (uint256); + /** + * @notice Used to get the number of emotes for a specific emoji on a set of tokens. + * @param collection An array of addresses of the collections containing the tokens being checked for emoji count + * @param tokenIds An array of IDs of the tokens to check for emoji count + * @param emojis An array of unicode identifiers of the emojis + * @return An array of numbers of emotes with the emoji on the tokens + */ + function bulkEmoteCountOf( + address[] memory collections, + uint256[] memory tokenIds, + bytes4[] memory emojis + ) external view returns (uint256[] memory); + /** * @notice Used to get the information on whether the specified address has used a specific emoji on a specific * token. @@ -101,11 +114,65 @@ interface IERC6381 /*is IERC165*/ { bytes4 emoji ) external view returns (bool); + /** + * @notice Used to get the information on whether the specified addresses have used specific emojis on specific + * tokens. + * @param collections An array of addresses of the collection smart contracts containing the tokens being checked + * for emoji reactions + * @param emoters An array of addresses of the accounts we are checking for reactions to tokens + * @param tokenIds An array of IDs of the tokens being checked for emoji reactions + * @param emojis An array of the ASCII emoji codes being checked for reactions + * @return An array of boolean values indicating whether the `emoter`s has used the `emoji`s on the tokens (`true`) + * or not (`false`) + */ + function haveEmotersUsedEmotes( + address[] memory emoters, + address[] memory collections, + uint256[] memory tokenIds, + bytes4[] memory emojis + ) external view returns (bool[] memory); + + /** + * @notice Used to get the message to be signed by the `emoter` in order for the reaction to be submitted by someone + * else. + * @param collection The address of the collection smart contract containing the token being emoted at + * @param tokenId ID of the token being emoted + * @param emoji Unicode identifier of the emoji + * @param state Boolean value signifying whether to emote (`true`) or undo (`false`) emote + * @param deadline UNIX timestamp of the deadline for the signature to be submitted + * @return The message to be signed by the `emoter` in order for the reaction to be submitted by someone else + */ + function prepareMessageToPresignEmote( + address collection, + uint256 tokenId, + bytes4 emoji, + bool state, + uint256 deadline + ) external view returns (bytes32); + + /** + * @notice Used to get multiple messages to be signed by the `emoter` in order for the reaction to be submitted by someone + * else. + * @param collections An array of addresses of the collection smart contracts containing the tokens being emoted at + * @param tokenIds An array of IDs of the tokens being emoted + * @param emojis An arrau of unicode identifiers of the emojis + * @param states An array of boolean values signifying whether to emote (`true`) or undo (`false`) emote + * @param deadlines An array of UNIX timestamps of the deadlines for the signatures to be submitted + * @return The array of messages to be signed by the `emoter` in order for the reaction to be submitted by someone else + */ + function prepareMessageToPresignEmote( + address collection, + uint256 tokenId, + bytes4 emoji, + bool state, + uint256 deadline + ) external view returns (bytes32); + /** * @notice Used to emote or undo an emote on a token. * @dev Does nothing if attempting to set a pre-existent state. * @dev MUST emit the `Emoted` event is the state of the emote is changed. - * @param collection Address of the collection containing the token being checked for emoji count + * @param collection Address of the collection containing the token being emoted at * @param tokenId ID of the token being emoted * @param emoji Unicode identifier of the emoji * @param state Boolean value signifying whether to emote (`true`) or undo (`false`) emote @@ -116,9 +183,125 @@ interface IERC6381 /*is IERC165*/ { bytes4 emoji, bool state ) external; + + /** + * @notice Used to emote or undo an emote on multiple tokens. + * @dev Does nothing if attempting to set a pre-existent state. + * @dev MUST emit the `Emoted` event is the state of the emote is changed. + * @dev MUST revert if the lengths of the `collections`, `tokenIds`, `emojis` and `states` arrays are not equal. + * @param collections An array of addresses of the collections containing the tokens being emoted at + * @param tokenIds An array of IDs of the tokens being emoted + * @param emojis An array of unicode identifiers of the emojis + * @param states An array of boolean values signifying whether to emote (`true`) or undo (`false`) emote + */ + function bulkEmote( + address[] memory collections, + uint256[] memory tokenIds, + bytes4[] memory emojis, + bool[] memory states + ) external; + + /** + * @notice Used to emote or undo an emote on someone else's behalf. + * @dev Does nothing if attempting to set a pre-existent state. + * @dev MUST emit the `Emoted` event is the state of the emote is changed. + * @dev MUST revert if the lengths of the `collections`, `tokenIds`, `emojis` and `states` arrays are not equal. + * @dev MUST revert if the `deadline` has passed. + * @dev MUST revert if the recovered address is the zero address. + * @param emoter The address that presigned the emote + * @param collection The address of the collection smart contract containing the token being emoted at + * @param tokenId IDs of the token being emoted + * @param emoji Unicode identifier of the emoji + * @param states Boolean value signifying whether to emote (`true`) or undo (`false`) emote + * @param deadline UNIX timestamp of the deadline for the signature to be submitted + * @param v `v` value of an ECDSA signature of the message obtained via `prepareMessageToPresignEmote` + * @param r `r` value of an ECDSA signature of the message obtained via `prepareMessageToPresignEmote` + * @param s `s` value of an ECDSA signature of the message obtained via `prepareMessageToPresignEmote` + */ + function presignedEmote( + address emoter, + address collection, + uint256 tokenId, + bytes4 emoji, + bool state, + uint256 deadline, + uint8 v, + bytes32 r, + bytes32 s + ) external; + + /** + * @notice Used to bulk emote or undo an emote on someone else's behalf. + * @dev Does nothing if attempting to set a pre-existent state. + * @dev MUST emit the `Emoted` event is the state of the emote is changed. + * @dev MUST revert if the lengths of the `collections`, `tokenIds`, `emojis` and `states` arrays are not equal. + * @dev MUST revert if the `deadline` has passed. + * @dev MUST revert if the recovered address is the zero address. + * @param emoters An array of addresses of the accounts that presigned the emotes + * @param collections An array of addresses of the collections containing the tokens being emoted at + * @param tokenIds An array of IDs of the tokens being emoted + * @param emojis An array of unicode identifiers of the emojis + * @param states An array of boolean values signifying whether to emote (`true`) or undo (`false`) emote + * @param deadline UNIX timestamp of the deadline for the signature to be submitted + * @param v An array of `v` values of an ECDSA signatures of the messages obtained via `prepareMessageToPresignEmote` + * @param r An array of `r` values of an ECDSA signatures of the messages obtained via `prepareMessageToPresignEmote` + * @param s An array of `s` values of an ECDSA signatures of the messages obtained via `prepareMessageToPresignEmote` + */ + function bulkPresignedEmote( + address[] memory emoters, + address[] memory collections, + uint256[] memory tokenIds, + bytes4[] memory emojis, + bool[] memory states, + uint256[] memory deadlines, + uint8[] memory v, + bytes32[] memory r, + bytes32[] memory s + ) external; } ``` +### Message format for presigned emotes + +The message to be signed by the `emoter` in order for the reaction to be submitted by someone else is formatted as follows: + +```solidity +keccak256( + abi.encode( + DOMAIN_SEPARATOR, + collection, + tokenId, + emoji, + state, + deadline + ) + ); +``` + +The values passed when generating the message to be signed are: + +- `DOMAIN_SEPARATOR` - The domain separator of the Emotable repository smart contract +- `collection` - Address of the collection containing the token being emoted at +- `tokenId` - ID of the token being emoted +- `emoji` - Unicode identifier of the emoji +- `state` - Boolean value signifying whether to emote (`true`) or undo (`false`) emote +- `deadline` - UNIX timestamp of the deadline for the signature to be submitted + +The `DOMAIN_SEPARATOR` is generated as follows: + +```solidity +keccak256( + abi.encode( + "ERC-6381: Public Non-Fungible Token Emote Repository", + "1", + block.chainid, + address(this) + ) + ); +``` + +Each chain, that the Emotable repository smart contract is deployed on, will have a different `DOMAIN_SEPARATOR` value due to chain IDs being different. + ### Pre-determined address of the Emotable repository The address of the Emotable repository smart contract is designed to resemble the function it serves. It starts with `0x311073` which is the abstract representation of `EMOTE`. The address is: @@ -138,6 +321,18 @@ The impressions could have been done using user-supplied strings or numeric valu 3. **Should the proposal establish an emotable extension or a common-good repository?**\ Initially we set out to create an emotable extension to be used with any ERC-721 compilant tokens. However, we realized that the proposal would be more useful if it was a common-good repository of emotable tokens. This way, the tokens that can be reacted to are not only the new ones but also the old ones that have been around since before the proposal.\ In line with this decision, we decided to calculate a deterministic address for the repository smart contract. This way, the repository can be used by any NFT collection without the need to search for the address on the given chain. +4. **Should we include only single-action operations, only multi-action operations, or both?**\ +We've considered including only single-action operations, where the user is only able to react with a single emoji to a single token, but we decided to include both single-action and multi-action operations. This way, the users can choose whether they want to emote or undo emote on a single token or on multiple tokens at once.\ +This decision was made for the long-term viability of the proposal. Based on the gas cost of the network and the number of tokens in the collection, the user can choose the most cost-effective way of emoting. +5. **Should we add the ability to emote on someone else's behalf?**\ +While we did not intend to add this as part of the proposal when drafting it, we realized that it would be a useful feature for it. This way, the users can emote on behalf of someone else, for example, if they are not able to do it themselves or if the emote is earned through an off-chain activity. +6. **How do we ensure that emoting on someone else's behalf is legitimate?**\ +We could add delegates to the proposal; when a user delegates their right to emote to someone else, the delegate can emote on their behalf. However, this would add a lot of complexity and additional logic to the proposal.\ +Using ECDSA signatures, we can ensure that the user has given their consent to emote on their behalf. This way, the user can sign a message with the parameters of the emote and the signature can be submitted by someone else. +7. **Should we add chain ID as a parameter when reacting to a token?**\ +During the course of discussion of the proposal, a suggestion arose that we could add chain ID as a parameter when reacting to a token. This would allow the users to emote on the token of one chain on another chain.\ +We decided against this as we feel that additional parameter would rarely be used and would add additional cost to the reaction transactions. If the collection smart contract wants to utilize on-chain emotes to tokens they contain, they require the reactions to be recorded on the same chain. Marketplaces and wallets integrating this proposal will rely on reactions to reside in the same chain as well, because if chain ID parameter was supported this would mean that they would need to query the repository smart contract on all of the chains the repository is deployed in order to get the reactions for a given token.\ +Additionally, if the collection creator wants users to record their reactions on a different chain, they can still direct the users to do just that. The repository does not validate the existence of the token being reacted to, which in theory means that you can react to non-existent token or to a token that does not exist yet. The likelihood of a different collection existing at the same address on another chain is significantly low, so the users can react using the collection's address on another chain and it is very unlikely that they will unintentionally react to another collection's token. ## Backwards Compatibility @@ -161,7 +356,11 @@ See [`EmotableRepository.sol`](../assets/eip-6381/contracts/EmotableRepository.s ## Security Considerations -The same security considerations as with [ERC-721](./eip-721.md) apply: hidden logic may be present in any of the functions, including burn, add asset, accept asset, and more. +The proposal does not envision handling any form of assets from the user, so the assets should not be at risk when interacting with an Emote repository. + +The ability to use ECDSA signatures to emote on someone else's behalf introduces the risk of a replay attack, which the format of the message to be signed guards against. The `DOMAIN_SEPARATOR` used in the message to be signed is unique to the repository smart contract of the chain it is deployed on. This means that the signature is invalid on any other chain and the Emote repositories deployed on them should revert the operation if a replay attack is attempted. + +Another thing to consider is the ability of presigned message reuse. Since the message includes the signature validity deadline, the message can be reused any number of times before the deadline is reached. The proposal only allows for a single reaction with a given emoji to a specific token to be active, so the presigned message can not be abused to increase the reaction count on the token. However, if the service using the repository relies on the ability to revoke the reaction after certain actions, a valid presigned message can be used to re-react to the token. We suggest that the services using the repository in cnjunction with presigned messages use deadlines that invalidate presigned messages after a reasonalby short period of time. Caution is advised when dealing with non-audited contracts. diff --git a/assets/eip-6381/contracts/EmotableRepository.sol b/assets/eip-6381/contracts/EmotableRepository.sol index d66c36b59b9490..445ae2454f4fad 100644 --- a/assets/eip-6381/contracts/EmotableRepository.sol +++ b/assets/eip-6381/contracts/EmotableRepository.sol @@ -5,7 +5,20 @@ pragma solidity ^0.8.16; import "./IERC6381.sol"; import "@openzeppelin/contracts/utils/introspection/ERC165.sol"; +error BulkParametersOfUnequalLength(); +error ExpiredPresignedEmote(); +error InvalidSignature(); + contract EmotableRepository is IERC6381 { + bytes32 public immutable DOMAIN_SEPARATOR = keccak256( + abi.encode( + "ERC-6381: Public Non-Fungible Token Emote Repository", + "1", + block.chainid, + address(this) + ) + ); + // Used to avoid double emoting and control undoing mapping(address => mapping(address => mapping(uint256 => mapping(bytes4 => uint256)))) private _emotesUsedByEmoter; // Cheaper than using a bool @@ -20,6 +33,28 @@ contract EmotableRepository is IERC6381 { return _emotesPerToken[collection][tokenId][emoji]; } + function bulkEmoteCountOf( + address[] memory collections, + uint256[] memory tokenIds, + bytes4[] memory emojis + ) public view returns (uint256[] memory) { + if( + collections.length != tokenIds.length || + collections.length != emojis.length + ){ + revert BulkParametersOfUnequalLength(); + } + + uint256[] memory counts = new uint256[](collections.length); + for (uint256 i; i < collections.length; ) { + counts[i] = _emotesPerToken[collections[i]][tokenIds[i]][emojis[i]]; + unchecked { + ++i; + } + } + return counts; + } + function hasEmoterUsedEmote( address emoter, address collection, @@ -29,6 +64,30 @@ contract EmotableRepository is IERC6381 { return _emotesUsedByEmoter[emoter][collection][tokenId][emoji] == 1; } + function haveEmotersUsedEmotes( + address[] memory emoters, + address[] memory collections, + uint256[] memory tokenIds, + bytes4[] memory emojis + ) public view returns (bool[] memory) { + if( + emoters.length != collections.length || + emoters.length != tokenIds.length || + emoters.length != emojis.length + ){ + revert BulkParametersOfUnequalLength(); + } + + bool[] memory states = new bool[](collections.length); + for (uint256 i; i < collections.length; ) { + states[i] = _emotesUsedByEmoter[emoters[i]][collections[i]][tokenIds[i]][emojis[i]] == 1; + unchecked { + ++i; + } + } + return states; + } + function emote( address collection, uint256 tokenId, @@ -51,6 +110,218 @@ contract EmotableRepository is IERC6381 { } } + function bulkEmote( + address[] memory collections, + uint256[] memory tokenIds, + bytes4[] memory emojis, + bool[] memory states + ) public { + if( + collections.length != tokenIds.length || + collections.length != emojis.length || + collections.length != states.length + ){ + revert BulkParametersOfUnequalLength(); + } + + bool currentVal; + for (uint256 i; i < collections.length; ) { + currentVal = _emotesUsedByEmoter[msg.sender][collections[i]][tokenIds[i]][ + emojis[i] + ] == 1; + if (currentVal != states[i]) { + if (states[i]) { + _emotesPerToken[collections[i]][tokenIds[i]][emojis[i]] += 1; + } else { + _emotesPerToken[collections[i]][tokenIds[i]][emojis[i]] -= 1; + } + _emotesUsedByEmoter[msg.sender][collections[i]][tokenIds[i]][emojis[i]] = states[i] + ? 1 + : 0; + emit Emoted(msg.sender, collections[i], tokenIds[i], emojis[i], states[i]); + } + unchecked { + ++i; + } + } + } + + function prepareMessageToPresignEmote( + address collection, + uint256 tokenId, + bytes4 emoji, + bool state, + uint256 deadline + ) public view returns (bytes32) { + return keccak256( + abi.encode( + DOMAIN_SEPARATOR, + collection, + tokenId, + emoji, + state, + deadline + ) + ); + } + + function bulkPrepareMessagesToPresignEmote( + address[] memory collections, + uint256[] memory tokenIds, + bytes4[] memory emojis, + bool[] memory states, + uint256[] memory deadlines + ) public view returns (bytes32[] memory) { + if( + collections.length != tokenIds.length || + collections.length != emojis.length || + collections.length != states.length || + collections.length != deadlines.length + ){ + revert BulkParametersOfUnequalLength(); + } + + bytes32[] memory messages = new bytes32[](collections.length); + for (uint256 i; i < collections.length; ) { + messages[i] = keccak256( + abi.encode( + DOMAIN_SEPARATOR, + collections[i], + tokenIds[i], + emojis[i], + states[i], + deadlines[i] + ) + ); + unchecked { + ++i; + } + } + + return messages; + } + + function presignedEmote( + address emoter, + address collection, + uint256 tokenId, + bytes4 emoji, + bool state, + uint256 deadline, + uint8 v, + bytes32 r, + bytes32 s + ) public { + if(block.timestamp > deadline){ + revert ExpiredPresignedEmote(); + } + bytes32 digest = keccak256( + abi.encodePacked( + "\x19Ethereum Signed Message:\n32", + keccak256( + abi.encode( + DOMAIN_SEPARATOR, + collection, + tokenId, + emoji, + state, + deadline + ) + ) + ) + ); + address signer = ecrecover(digest, v, r, s); + if(signer != emoter){ + revert InvalidSignature(); + } + + bool currentVal = _emotesUsedByEmoter[signer][collection][tokenId][ + emoji + ] == 1; + if (currentVal != state) { + if (state) { + _emotesPerToken[collection][tokenId][emoji] += 1; + } else { + _emotesPerToken[collection][tokenId][emoji] -= 1; + } + _emotesUsedByEmoter[signer][collection][tokenId][emoji] = state + ? 1 + : 0; + emit Emoted(signer, collection, tokenId, emoji, state); + } + } + + function bulkPresignedEmote( + address[] memory emoters, + address[] memory collections, + uint256[] memory tokenIds, + bytes4[] memory emojis, + bool[] memory states, + uint256[] memory deadlines, + uint8[] memory v, + bytes32[] memory r, + bytes32[] memory s + ) public { + if( + emoters.length != collections.length || + emoters.length != tokenIds.length || + emoters.length != emojis.length || + emoters.length != states.length || + emoters.length != deadlines.length || + emoters.length != v.length || + emoters.length != r.length || + emoters.length != s.length + ){ + revert BulkParametersOfUnequalLength(); + } + + bytes32 digest; + address signer; + bool currentVal; + for (uint256 i; i < collections.length; ) { + if (block.timestamp > deadlines[i]){ + revert ExpiredPresignedEmote(); + } + digest = keccak256( + abi.encodePacked( + "\x19Ethereum Signed Message:\n32", + keccak256( + abi.encode( + DOMAIN_SEPARATOR, + collections[i], + tokenIds[i], + emojis[i], + states[i], + deadlines[i] + ) + ) + ) + ); + signer = ecrecover(digest, v[i], r[i], s[i]); + if(signer != emoters[i]){ + revert InvalidSignature(); + } + + currentVal = _emotesUsedByEmoter[signer][collections[i]][tokenIds[i]][ + emojis[i] + ] == 1; + if (currentVal != states[i]) { + if (states[i]) { + _emotesPerToken[collections[i]][tokenIds[i]][emojis[i]] += 1; + } else { + _emotesPerToken[collections[i]][tokenIds[i]][emojis[i]] -= 1; + } + _emotesUsedByEmoter[signer][collections[i]][tokenIds[i]][emojis[i]] = states[i] + ? 1 + : 0; + emit Emoted(signer, collections[i], tokenIds[i], emojis[i], states[i]); + } + unchecked { + ++i; + } + } + } + function supportsInterface( bytes4 interfaceId ) public view virtual returns (bool) { diff --git a/assets/eip-6381/contracts/IERC6381.sol b/assets/eip-6381/contracts/IERC6381.sol index 0d31de0a6aaf05..a579c5825d9620 100644 --- a/assets/eip-6381/contracts/IERC6381.sol +++ b/assets/eip-6381/contracts/IERC6381.sol @@ -17,6 +17,12 @@ interface IERC6381 { bytes4 emoji ) external view returns (uint256); + function bulkEmoteCountOf( + address[] memory collections, + uint256[] memory tokenIds, + bytes4[] memory emojis + ) external view returns (uint256[] memory); + function hasEmoterUsedEmote( address emoter, address collection, @@ -24,10 +30,64 @@ interface IERC6381 { bytes4 emoji ) external view returns (bool); + function haveEmotersUsedEmotes( + address[] memory emoters, + address[] memory collections, + uint256[] memory tokenIds, + bytes4[] memory emojis + ) external view returns (bool[] memory); + + function prepareMessageToPresignEmote( + address collection, + uint256 tokenId, + bytes4 emoji, + bool state, + uint256 deadline + ) external view returns (bytes32); + + function bulkPrepareMessagesToPresignEmote( + address[] memory collections, + uint256[] memory tokenIds, + bytes4[] memory emojis, + bool[] memory states, + uint256[] memory deadlines + ) external view returns (bytes32[] memory); + function emote( address collection, uint256 tokenId, bytes4 emoji, bool state ) external; + + function bulkEmote( + address[] memory collections, + uint256[] memory tokenIds, + bytes4[] memory emojis, + bool[] memory states + ) external; + + function presignedEmote( + address emoter, + address collection, + uint256 tokenId, + bytes4 emoji, + bool state, + uint256 deadline, + uint8 v, + bytes32 r, + bytes32 s + ) external; + + function bulkPresignedEmote( + address[] memory emoters, + address[] memory collections, + uint256[] memory tokenIds, + bytes4[] memory emojis, + bool[] memory states, + uint256[] memory deadlines, + uint8[] memory v, + bytes32[] memory r, + bytes32[] memory s + ) external; } \ No newline at end of file diff --git a/assets/eip-6381/test/emotableRepository.ts b/assets/eip-6381/test/emotableRepository.ts index 11dd7d2e1be5ef..18345bf4032d6a 100644 --- a/assets/eip-6381/test/emotableRepository.ts +++ b/assets/eip-6381/test/emotableRepository.ts @@ -40,8 +40,8 @@ describe("RMRKEmotableRepositoryMock", async function () { repository = await loadFixture(emotableRepositoryFixture); }); - it("can support IEmotableRepository", async function () { - expect(await repository.supportsInterface("0x08eb97a6")).to.equal(true); + it("can support IERC6381", async function () { + expect(await repository.supportsInterface("0xd9fac55a")).to.equal(true); }); it("can support IERC165", async function () { @@ -132,5 +132,361 @@ describe("RMRKEmotableRepositoryMock", async function () { await repository.emoteCountOf(token.address, tokenId, emoji2) ).to.equal(bn(0)); }); + + it("can bulk emote", async function () { + expect( + await repository.bulkEmoteCountOf( + [token.address, token.address], + [tokenId, tokenId], + [emoji1, emoji2] + ) + ).to.eql([bn(0), bn(0)]); + + expect( + await repository.haveEmotersUsedEmotes( + [owner.address, owner.address], + [token.address, token.address], + [tokenId, tokenId], + [emoji1, emoji2] + ) + ).to.eql([false, false]); + + await expect( + repository.bulkEmote( + [token.address, token.address], + [tokenId, tokenId], + [emoji1, emoji2], + [true, true] + ) + ) + .to.emit(repository, "Emoted") + .withArgs( + owner.address, + token.address, + tokenId.toNumber(), + emoji1, + true + ) + .to.emit(repository, "Emoted") + .withArgs( + owner.address, + token.address, + tokenId.toNumber(), + emoji2, + true + ); + + expect( + await repository.bulkEmoteCountOf( + [token.address, token.address], + [tokenId, tokenId], + [emoji1, emoji2] + ) + ).to.eql([bn(1), bn(1)]); + + expect( + await repository.haveEmotersUsedEmotes( + [owner.address, owner.address], + [token.address, token.address], + [tokenId, tokenId], + [emoji1, emoji2] + ) + ).to.eql([true, true]); + }); + + it("can bulk undo emote", async function () { + await expect( + repository.bulkEmote( + [token.address, token.address], + [tokenId, tokenId], + [emoji1, emoji2], + [true, true] + ) + ) + .to.emit(repository, "Emoted") + .withArgs( + owner.address, + token.address, + tokenId.toNumber(), + emoji1, + true + ) + .to.emit(repository, "Emoted") + .withArgs( + owner.address, + token.address, + tokenId.toNumber(), + emoji2, + true + ); + + expect( + await repository.bulkEmoteCountOf( + [token.address, token.address], + [tokenId, tokenId], + [emoji1, emoji2] + ) + ).to.eql([bn(1), bn(1)]); + + expect( + await repository.haveEmotersUsedEmotes( + [owner.address, owner.address], + [token.address, token.address], + [tokenId, tokenId], + [emoji1, emoji2] + ) + ).to.eql([true, true]); + + await expect( + repository.bulkEmote( + [token.address, token.address], + [tokenId, tokenId], + [emoji1, emoji2], + [false, false] + ) + ) + .to.emit(repository, "Emoted") + .withArgs( + owner.address, + token.address, + tokenId.toNumber(), + emoji1, + false + ) + .to.emit(repository, "Emoted") + .withArgs( + owner.address, + token.address, + tokenId.toNumber(), + emoji2, + false + ); + + expect( + await repository.bulkEmoteCountOf( + [token.address, token.address], + [tokenId, tokenId], + [emoji1, emoji2] + ) + ).to.eql([bn(0), bn(0)]); + + expect( + await repository.haveEmotersUsedEmotes( + [owner.address, owner.address], + [token.address, token.address], + [tokenId, tokenId], + [emoji1, emoji2] + ) + ).to.eql([false, false]); + }); + + it("can bulk emote and unemote at the same time", async function () { + await repository.emote(token.address, tokenId, emoji2, true); + + expect( + await repository.bulkEmoteCountOf( + [token.address, token.address], + [tokenId, tokenId], + [emoji1, emoji2] + ) + ).to.eql([bn(0), bn(1)]); + + expect( + await repository.haveEmotersUsedEmotes( + [owner.address, owner.address], + [token.address, token.address], + [tokenId, tokenId], + [emoji1, emoji2] + ) + ).to.eql([false, true]); + + await expect( + repository.bulkEmote( + [token.address, token.address], + [tokenId, tokenId], + [emoji1, emoji2], + [true, false] + ) + ) + .to.emit(repository, "Emoted") + .withArgs( + owner.address, + token.address, + tokenId.toNumber(), + emoji1, + true + ) + .to.emit(repository, "Emoted") + .withArgs( + owner.address, + token.address, + tokenId.toNumber(), + emoji2, + false + ); + + expect( + await repository.bulkEmoteCountOf( + [token.address, token.address], + [tokenId, tokenId], + [emoji1, emoji2] + ) + ).to.eql([bn(1), bn(0)]); + + expect( + await repository.haveEmotersUsedEmotes( + [owner.address, owner.address], + [token.address, token.address], + [tokenId, tokenId], + [emoji1, emoji2] + ) + ).to.eql([true, false]); + }); + + it("can not bulk emote if passing arrays of different length", async function () { + await expect( + repository.bulkEmote( + [token.address, token.address], + [tokenId, tokenId], + [emoji1, emoji2], + [true] + ) + ).to.be.revertedWithCustomError( + repository, + "BulkParametersOfUnequalLength" + ); + + await expect( + repository.bulkEmote( + [token.address], + [tokenId, tokenId], + [emoji1, emoji2], + [true, true] + ) + ).to.be.revertedWithCustomError( + repository, + "BulkParametersOfUnequalLength" + ); + + await expect( + repository.bulkEmote( + [token.address, token.address], + [tokenId], + [emoji1, emoji2], + [true, true] + ) + ).to.be.revertedWithCustomError( + repository, + "BulkParametersOfUnequalLength" + ); + + await expect( + repository.bulkEmote( + [token.address, token.address], + [tokenId, tokenId], + [emoji1], + [true, true] + ) + ).to.be.revertedWithCustomError( + repository, + "BulkParametersOfUnequalLength" + ); + }); + + it("can use presigned emote to react to token", async function () { + const message = await repository.prepareMessageToPresignEmote( + token.address, + tokenId, + emoji1, + true, + bn(9999999999) + ); + + const signature = await owner.signMessage(ethers.utils.arrayify(message)); + + const r: string = signature.substring(0, 66); + const s: string = "0x" + signature.substring(66, 130); + const v: number = parseInt(signature.substring(130, 132), 16); + + await expect( + repository + .connect(addrs[0]) + .presignedEmote( + owner.address, + token.address, + tokenId, + emoji1, + true, + bn(9999999999), + v, + r, + s + ) + ) + .to.emit(repository, "Emoted") + .withArgs( + owner.address, + token.address, + tokenId.toNumber(), + emoji1, + true + ); + }); + + it("can use presigned emotes to bulk react to token", async function () { + const messages = await repository.bulkPrepareMessagesToPresignEmote( + [token.address, token.address], + [tokenId, tokenId], + [emoji1, emoji2], + [true, true], + [bn(9999999999), bn(9999999999)] + ); + + const signature1 = await owner.signMessage( + ethers.utils.arrayify(messages[0]) + ); + const signature2 = await owner.signMessage( + ethers.utils.arrayify(messages[1]) + ); + + const r1: string = signature1.substring(0, 66); + const s1: string = "0x" + signature1.substring(66, 130); + const v1: number = parseInt(signature1.substring(130, 132), 16); + const r2: string = signature2.substring(0, 66); + const s2: string = "0x" + signature2.substring(66, 130); + const v2: number = parseInt(signature2.substring(130, 132), 16); + + await expect( + repository + .connect(addrs[0]) + .bulkPresignedEmote( + [owner.address, owner.address], + [token.address, token.address], + [tokenId, tokenId], + [emoji1, emoji2], + [true, true], + [bn(9999999999), bn(9999999999)], + [v1, v2], + [r1, r2], + [s1, s2] + ) + ) + .to.emit(repository, "Emoted") + .withArgs( + owner.address, + token.address, + tokenId.toNumber(), + emoji1, + true + ) + .to.emit(repository, "Emoted") + .withArgs( + owner.address, + token.address, + tokenId.toNumber(), + emoji2, + true + ); + }); }); }); From 92be438575005350b9740bf8c0ec98de200fd908 Mon Sep 17 00:00:00 2001 From: Jan Turk Date: Wed, 7 Jun 2023 23:47:20 +0200 Subject: [PATCH 63/97] Update EIP-6381: Set new last call deadline Merged by EIP-Bot. --- EIPS/eip-6381.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/EIPS/eip-6381.md b/EIPS/eip-6381.md index 4087da1a3ddcfa..69b6f79e3f5a18 100644 --- a/EIPS/eip-6381.md +++ b/EIPS/eip-6381.md @@ -5,7 +5,7 @@ description: React to any Non-Fungible Tokens using Unicode emojis. author: Bruno Škvorc (@Swader), Steven Pineda (@steven2308), Stevan Bogosavljevic (@stevyhacker), Jan Turk (@ThunderDeliverer) discussions-to: https://ethereum-magicians.org/t/eip-6381-emotable-extension-for-non-fungible-tokens/12710 status: Last Call -last-call-deadline: 2023-05-02 +last-call-deadline: 2023-06-21 type: Standards Track category: ERC created: 2023-01-22 From 9510768bea94a4f16e538b085b09465601635f6d Mon Sep 17 00:00:00 2001 From: Pedro Gomes Date: Thu, 8 Jun 2023 12:08:08 +0200 Subject: [PATCH 64/97] Update EIP-6963: Update eip-6963.md Merged by EIP-Bot. --- EIPS/eip-6963.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/EIPS/eip-6963.md b/EIPS/eip-6963.md index 172064a522ac81..57aa5278b86353 100644 --- a/EIPS/eip-6963.md +++ b/EIPS/eip-6963.md @@ -2,7 +2,7 @@ eip: 6963 title: Multi Injected Provider Discovery description: Using window events to announce injected wallet providers -author: Pedro Gomes (@pedrouid), Kosala Hemachandra (@kvhnuke), Richard Moore (@ricmoo), Gregory Markou (@GregTheGreek), Kyle Den Hartog (@kdenhartog), Glitch (@glitch-txs), Jake Moxey (@jxom), Pierre Bertet (@bpierre), Darryl Yeo (@darrylyeo) +author: Pedro Gomes (@pedrouid), Kosala Hemachandra (@kvhnuke), Richard Moore (@ricmoo), Gregory Markou (@GregTheGreek), Kyle Den Hartog (@kdenhartog), Glitch (@glitch-txs), Jake Moxey (@jxom), Pierre Bertet (@bpierre), Darryl Yeo (@darrylyeo), Yaroslav Sergievsky (@everdimension) discussions-to: https://ethereum-magicians.org/t/eip-6963-multi-injected-provider-interface-aka-mipi/14076 status: Draft type: Standards Track From be27fce3a363685642daf1dbe8d294d69a31a063 Mon Sep 17 00:00:00 2001 From: corentinDallenogare <64168677+corentinDallenogare@users.noreply.github.com> Date: Thu, 8 Jun 2023 16:17:28 +0200 Subject: [PATCH 65/97] Update EIP-6551: Update eip-6551.md Merged by EIP-Bot. --- EIPS/eip-6551.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/EIPS/eip-6551.md b/EIPS/eip-6551.md index f9b3c74ccf9b90..9fcbe3a4a682d7 100644 --- a/EIPS/eip-6551.md +++ b/EIPS/eip-6551.md @@ -337,7 +337,7 @@ contract ERC6551Registry is IERC6551Registry { uint256 salt, bytes calldata initData ) external returns (address) { - bytes memory code = _creationCode(implementation, chainId, tokenContract, tokenId, salt) + bytes memory code = _creationCode(implementation, chainId, tokenContract, tokenId, salt); address _account = Create2.computeAddress( bytes32(salt), From 2511e0bc3eac7343ff306d246dee0f69d0862498 Mon Sep 17 00:00:00 2001 From: Ansgar Dietrichs Date: Thu, 8 Jun 2023 17:50:42 +0200 Subject: [PATCH 66/97] Update EIP-4844: Increase Blob Throughput Merged by EIP-Bot. --- EIPS/eip-4844.md | 16 ++++++++-------- 1 file changed, 8 insertions(+), 8 deletions(-) diff --git a/EIPS/eip-4844.md b/EIPS/eip-4844.md index f33aadd1017395..ff3348a4859fd8 100644 --- a/EIPS/eip-4844.md +++ b/EIPS/eip-4844.md @@ -31,7 +31,7 @@ However, data sharding will still take a considerable amount of time to finish i This EIP provides a stop-gap solution until that point by implementing the _transaction format_ that would be used in sharding, but not actually sharding those transactions. Instead, the data from this transaction format is simply part of the beacon chain and is fully downloaded by all consensus nodes (but can be deleted after only a relatively short delay). -Compared to full data sharding, this EIP has a reduced cap on the number of these transactions that can be included, corresponding to a target of ~0.25 MB per block and a limit of ~0.5 MB. +Compared to full data sharding, this EIP has a reduced cap on the number of these transactions that can be included, corresponding to a target of ~0.375 MB per block and a limit of ~0.75 MB. ## Specification @@ -45,10 +45,10 @@ Compared to full data sharding, this EIP has a reduced cap on the number of thes | `BLOB_COMMITMENT_VERSION_KZG` | `Bytes1(0x01)` | | `POINT_EVALUATION_PRECOMPILE_ADDRESS` | `Bytes20(0x14)` | | `POINT_EVALUATION_PRECOMPILE_GAS` | `50000` | -| `MAX_DATA_GAS_PER_BLOCK` | `2**19` | -| `TARGET_DATA_GAS_PER_BLOCK` | `2**18` | +| `MAX_DATA_GAS_PER_BLOCK` | `786432` | +| `TARGET_DATA_GAS_PER_BLOCK` | `393216` | | `MIN_DATA_GASPRICE` | `1` | -| `DATA_GASPRICE_UPDATE_FRACTION` | `2225652` | +| `DATA_GASPRICE_UPDATE_FRACTION` | `3338477` | | `MAX_VERSIONED_HASHES_LIST_SIZE` | `2**24` | | `MAX_CALLDATA_SIZE` | `2**24` | | `MAX_ACCESS_LIST_SIZE` | `2**24` | @@ -323,7 +323,7 @@ Instead, those transactions are only announced using `NewPooledTransactionHashes ### On the path to sharding This EIP introduces blob transactions in the same format in which they are expected to exist in the final sharding specification. -This provides a temporary but significant scaling relief for rollups by allowing them to initially scale to 0.25 MB per slot, +This provides a temporary but significant scaling relief for rollups by allowing them to initially scale to 0.375 MB per slot, with a separate fee market allowing fees to be very low while usage of this system is limited. The core goal of rollup scaling stopgaps is to provide temporary scaling relief, @@ -427,9 +427,9 @@ TBD ## Security Considerations -This EIP increases the storage requirements per Beacon block by a maximum of ~0.5 MB. -This is 4x larger than the theoretical maximum size of a block today (30M gas / 16 gas per calldata byte = 1.875M bytes), and so it will not greatly increase worst-case bandwidth. -Post-merge, block times are expected to be static rather than an unpredictable Poisson distribution, giving a guaranteed period of time for large blocks to propagate. +This EIP increases the bandwidth requirements per beacon block by a maximum of ~0.75 MB. +This is 40% larger than the theoretical maximum size of a block today (30M gas / 16 gas per calldata byte = 1.875M bytes), and so it will not greatly increase worst-case bandwidth. +Post-merge, block times are static rather than an unpredictable Poisson distribution, giving a guaranteed period of time for large blocks to propagate. The _sustained_ load of this EIP is much lower than alternatives that reduce calldata costs, even if the calldata is limited, because there is no existing software that stores the blobs indefinitely and there is no expectation that they need to be stored for as long as an execution payload. From 0c9832d55936dcb9d7b928ff5fa8d2ad76f4e3b0 Mon Sep 17 00:00:00 2001 From: Charles Cooper Date: Thu, 8 Jun 2023 10:05:31 -0700 Subject: [PATCH 67/97] Update EIP-5656: update eip-5656 MCOPY opcode per cancun allocation Merged by EIP-Bot. --- EIPS/eip-5656.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/EIPS/eip-5656.md b/EIPS/eip-5656.md index 3682a57c253779..be0b1a26a2db11 100644 --- a/EIPS/eip-5656.md +++ b/EIPS/eip-5656.md @@ -56,7 +56,7 @@ where it is identified as a significant overhead. ## Specification -The instruction `MCOPY` is introduced at `0xb7`. +The instruction `MCOPY` is introduced at `0x5E`. ### Input stack From 2a2a4c0158e2815b38dd840d3fe737cce0a2ea7f Mon Sep 17 00:00:00 2001 From: Ansgar Dietrichs Date: Thu, 8 Jun 2023 20:39:11 +0200 Subject: [PATCH 68/97] Update EIP-4844: Adjust Throughput Section Merged by EIP-Bot. --- EIPS/eip-4844.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/EIPS/eip-4844.md b/EIPS/eip-4844.md index ff3348a4859fd8..fc36199c0f1c50 100644 --- a/EIPS/eip-4844.md +++ b/EIPS/eip-4844.md @@ -400,7 +400,7 @@ The parameter `DATA_GASPRICE_UPDATE_FRACTION` controls the maximum rate of chang ### Throughput -The values for `TARGET_DATA_GAS_PER_BLOCK` and `MAX_DATA_GAS_PER_BLOCK` are chosen to correspond to a target of 2 blobs (0.25 MB) and maximum of 4 blobs (0.5 MB) per block. These small initial limits are intended to minimize the strain on the network created by this EIP and are expected to be increased in future upgrades as the network demonstrates reliability under larger blocks. +The values for `TARGET_DATA_GAS_PER_BLOCK` and `MAX_DATA_GAS_PER_BLOCK` are chosen to correspond to a target of 3 blobs (0.375 MB) and maximum of 6 blobs (0.75 MB) per block. These small initial limits are intended to minimize the strain on the network created by this EIP and are expected to be increased in future upgrades as the network demonstrates reliability under larger blocks. ## Backwards Compatibility From dbfcffeae28ff0eb3e7e00a2efd4824f58af2f13 Mon Sep 17 00:00:00 2001 From: OT <120460176+OT-kthd@users.noreply.github.com> Date: Thu, 8 Jun 2023 23:33:33 +0300 Subject: [PATCH 69/97] Add EIP: ERC-721 Utilities Information Extension Merged by EIP-Bot. --- EIPS/eip-6785.md | 210 +++++++++++++++++++++++++ assets/eip-6785/contracts/ERC6785.sol | 45 ++++++ assets/eip-6785/contracts/IERC6785.sol | 27 ++++ assets/eip-6785/test/ERC6785.test.js | 56 +++++++ 4 files changed, 338 insertions(+) create mode 100644 EIPS/eip-6785.md create mode 100644 assets/eip-6785/contracts/ERC6785.sol create mode 100644 assets/eip-6785/contracts/IERC6785.sol create mode 100644 assets/eip-6785/test/ERC6785.test.js diff --git a/EIPS/eip-6785.md b/EIPS/eip-6785.md new file mode 100644 index 00000000000000..b02f62f48c4ca0 --- /dev/null +++ b/EIPS/eip-6785.md @@ -0,0 +1,210 @@ +--- +eip: 6785 +title: ERC-721 Utilities Information Extension +description: Provide easy access to information about the `utility` of an NFT via functions and the NFT's metadata +author: Otniel Nicola (@OT-kthd), Bogdan Popa (@BogdanKTHD) +discussions-to: https://ethereum-magicians.org/t/eip-6785-erc-721-utilities-extension/13568 +status: Draft +type: Standards Track +category: ERC +created: 2023-03-27 +requires: 165, 721 +--- + +## Abstract + +This specification defines standard functions and an extension of the metadata schema that outlines what a +token's utility entails and how the utility may be used and/or accessed. +This specification is an optional extension of [ERC-721](./eip-721.md). + +## Motivation + +This specification aims to clarify what the utility associated with an NFT is and how to access this utility. +Relying on third-party platforms to obtain information regarding the utility of the NFT that one owns can lead to scams, +phishing or other forms of fraud. + +Currently, utilities that are offered with NFTs are not captured on-chain. We want the utility of an NFT to be part of +the metadata of an NFT. The metadata information would include: a) type of utility, b) description +of utility, c) frequency and duration of utility, and d) expiration of utility. This will provide transparency as to the +utility terms, and greater accountability on the creator to honor these utilities. + +As the instructions on how to access a given utility may change over time, there should be a historical record of these +changes for transparency. + +## Specification + +The keywords “MUST”, “MUST NOT”, “REQUIRED”, “SHALL”, “SHALL NOT”, “SHOULD”, “SHOULD NOT”, “RECOMMENDED”, “MAY”, and +“OPTIONAL” in this document are to be interpreted as described in RFC 2119. + +Every contract compliant with [ERC-6785](./eip-6785.md) MUST implement the interface defined as follows: + +### Contract Interface + +```solidity +// @title NFT Utility description +/// Note: the EIP-165 identifier for this interface is ed231d73 + +interface IERC6785 { + + // Logged when the utility description URL of an NFT is changed + /// @notice Emitted when the utilityURL of an NFT is changed + /// The empty string for `utilityUri` indicates that there is no utility associated + event UpdateUtility(uint256 indexed tokenId, string utilityUri); + + /// @notice set the new utilityUri - remember the date it was set on + /// @dev The empty string indicates there is no utility + /// Throws if `tokenId` is not valid NFT + /// @param utilityUri The new utility description of the NFT + /// 4a048176 + function setUtilityUri(uint256 tokenId, string utilityUri) external; + + /// @notice Get the utilityUri of an NFT + /// @dev The empty string for `utilityUri` indicates that there is no utility associated + /// @param tokenId The NFT to get the user address for + /// @return The utility uri for this NFT + /// 5e470cbc + function utilityUriOf(uint256 tokenId) external view returns (string memory); + + /// @notice Get the changes made to utilityUri + /// @param tokenId The NFT to get the user address for + /// @return The history of changes to `utilityUri` for this NFT + /// f96090b9 + function utilityHistoryOf(uint256 tokenId) external view returns (string[] memory); +} +``` + +All functions defined as view MAY be implemented as pure or view + +Function `setUtilityUri` MAY be implemented as public or external. Also, the ability to set the `utilityUri` SHOULD be +restricted to the one who's offering the utility, whether that's the NFT creator or someone else. + +The event `UpdateUtility` MUST be emitted when the `setUtilityUri` function is called or any other time that the utility +of the token is changed, like in batch updates. + +The method `utilityHistoryOf` MUST reflect all changes made to the `utilityUri` of a tokenId, whether that's done +through `setUtilityUri` or by any other means, such as bulk updates + +The `supportsInterface` method MUST return true when called with `ed231d73` + +The original metadata SHOULD conform to the “ERC-6785 Metadata with utilities JSON Schema” which is a compatible +extension of the “ERC-721 Metadata JSON Schema” defined in ERC-721. + +“ERC-6785 Metadata with utilities JSON Schema” : + +```json +{ + "title": "Asset Metadata", + "type": "object", + "properties": { + "name": { + "type": "string", + "description": "Identifies the asset to which this NFT represents" + }, + "description": { + "type": "string", + "description": "Describes the asset to which this NFT represents" + }, + "image": { + "type": "string", + "description": "A URI pointing to a resource with mime type image/* representing the asset to which this NFT represents. Consider making any images at a width between 320 and 1080 pixels and aspect ratio between 1.91:1 and 4:5 inclusive." + }, + "utilities": { + "type": "object", + "required": [ + "type", + "description", + "t&c" + ], + "properties": { + "type": { + "type": "string", + "description": "Describes what type of utility this is" + }, + "description": { + "type": "string", + "description": "A brief description of the utility" + }, + "properties": { + "type": "array", + "description": "An array of possible properties describing the utility, defined as key-value pairs", + "items": { + "type": "object" + } + }, + "expiry": { + "type": "number", + "description": "The period of time for the validity of the utility, since the minting of the NFT. Expressed in seconds" + }, + "t&c": { + "type": "string", + "description": "" + } + } + } + } +} +``` + +## Rationale + +Since the `utilityUri` could contain information that has to be restricted to some level and could be dependent on an +off-chain tool for displaying said information, the creator needs the ability to modify it in the event the off-chain +tool or platform becomes unavailable or inaccessible. + +For transparency purposes, having a `utilityHistoryOf` method will make it clear how the `utilityUri` has changed over +time. + +For example, if a creator sells an NFT that gives holders a right to a video call with the creator, the metadata for +this utility NFT would read as follows: + +```json +{ + "name": "...", + "description": "...", + "image": "...", + "utilities": { + "type": "Video call", + "description": "I will enter a private video call with whoever owns the NFT", + "properties": [ + { + "sessions": 2 + }, + { + "duration": 30 + }, + { + "time_unit": "minutes" + } + ], + "expiry": 1.577e+7, + "t&c": "https://...." + } +} +``` + +In order to get access to the details needed to enter the video call, the owner would access the URI returned by +the `getUtilityUri` method for the NFT that they own. Additionally, access to the details could be conditioned by the +authentication with the wallet that owns the NFT. + +The current status of the utility would also be included in the URI (eg: how many sessions are still available, etc.) + +## Backwards Compatibility + +This standard is compatible with current ERC-721 standard. There are no other standards that define similar methods for +NFTs and the method names are not used by other ERC-721 related standards. + +## Test Cases + +Test cases are available [here](../assets/eip-6785/test/ERC6785.test.js) + +## Reference Implementation + +The reference implementation can be found [here](../assets/eip-6785/contracts/ERC6785.sol). + +## Security Considerations + +There are no security considerations related directly to the implementation of this standard. + +## Copyright + +Copyright and related rights waived via [CC0-1.0](../LICENSE.md). diff --git a/assets/eip-6785/contracts/ERC6785.sol b/assets/eip-6785/contracts/ERC6785.sol new file mode 100644 index 00000000000000..7dfbc98e8750f6 --- /dev/null +++ b/assets/eip-6785/contracts/ERC6785.sol @@ -0,0 +1,45 @@ +// SPDX-License-Identifier: CC0-1.0 +pragma solidity ^0.8.0; + +import "@openzeppelin/contracts/utils/introspection/ERC165.sol"; +import "@openzeppelin/contracts/token/ERC721/ERC721.sol"; +import "@openzeppelin/contracts/access/Ownable.sol"; +import "./IERC6785.sol"; + +contract ERC6785 is ERC721, Ownable, IERC6785 { + + /* + * bytes4(keccak256('setUtilityUri(uint256,string)')) = 0x4a048176 + * bytes4(keccak256('utilityUriOf(uint256)')) = 0x5e470cbc + * bytes4(keccak256('utilityHistoryOf(uint256)')) = 0xf96090b9 + * + * => 0x4a048176 ^ 0x5e470cbc ^ 0xf96090b9 == 0xed231d73 + */ + bytes4 public constant _INTERFACE_ID_ERC6785 = 0xed231d73; + + mapping(uint => string[]) private utilities; + + constructor(string memory name_, string memory symbol_) ERC721(name_, symbol_) {} + + /** + * @dev See {IERC165-supportsInterface}. + */ + function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) { + return + interfaceId == type(IERC6785).interfaceId || super.supportsInterface(interfaceId); + } + + function setUtilityUri(uint256 tokenId, string calldata utilityUri) override external onlyOwner { + utilities[tokenId].push(utilityUri); + emit UpdateUtility(tokenId, utilityUri); + } + + function utilityUriOf(uint256 tokenId) override external view returns (string memory) { + uint last = utilities[tokenId].length - 1; + return utilities[tokenId][last]; + } + + function utilityHistoryOf(uint256 tokenId) override external view returns (string[] memory){ + return utilities[tokenId]; + } +} diff --git a/assets/eip-6785/contracts/IERC6785.sol b/assets/eip-6785/contracts/IERC6785.sol new file mode 100644 index 00000000000000..fc933dba28bfc2 --- /dev/null +++ b/assets/eip-6785/contracts/IERC6785.sol @@ -0,0 +1,27 @@ +// SPDX-License-Identifier: CC0-1.0 +pragma solidity ^0.8.0; + +interface IERC6785 { + + // Logged when the utility description URL of an NFT is changed + /// @notice Emitted when the utilityURL of an NFT is changed + /// The empty string for `utilityUri` indicates that there is no utility associated + event UpdateUtility(uint256 indexed tokenId, string utilityUri); + + /// @notice set the new utilityUri - remember the date it was set on + /// @dev The empty string indicates there is no utility + /// Throws if `tokenId` is not valid NFT + /// @param utilityUri The new utility description of the NFT + function setUtilityUri(uint256 tokenId, string calldata utilityUri) external; + + /// @notice Get the utilityUri of an NFT + /// @dev The empty string for `utilityUri` indicates that there is no utility associated + /// @param tokenId The NFT to get the user address for + /// @return The utility uri for this NFT + function utilityUriOf(uint256 tokenId) external view returns (string memory); + + /// @notice Get the changes made to utilityUri + /// @param tokenId The NFT to get the user address for + /// @return The history of changes to `utilityUri` for this NFT + function utilityHistoryOf(uint256 tokenId) external view returns(string[] memory); +} diff --git a/assets/eip-6785/test/ERC6785.test.js b/assets/eip-6785/test/ERC6785.test.js new file mode 100644 index 00000000000000..d585bfb4e9fc3c --- /dev/null +++ b/assets/eip-6785/test/ERC6785.test.js @@ -0,0 +1,56 @@ +const {deployContracts} = require("../scripts/deploy_contracts"); +const {expect} = require('chai'); + +describe('ERC6785', () => { + let erc6785; + const tokenId = 123; + const utilityUrl1 = 'https://utility.url'; + + beforeEach(async () => { + erc6785 = await deployContracts(); + }); + + it('should support ERC6785 interface', async () => { + await expect(await erc6785.supportsInterface( + await erc6785._INTERFACE_ID_ERC6785(), + )).to.be.true; + }); + + it('should allow setting first utility NFT', async () => { + await expect(erc6785.setUtilityUri( + tokenId, + utilityUrl1, + )).to.emit(erc6785, 'UpdateUtility').withArgs(tokenId, utilityUrl1); + }); + + it('should allow retrieving initial royalties amount for a NFT', + async () => { + await expect(erc6785.setUtilityUri( + tokenId, + utilityUrl1, + )).to.emit(erc6785, 'UpdateUtility').withArgs(tokenId, utilityUrl1); + + await expect(await erc6785.utilityUriOf( + tokenId, + )).to.equal(utilityUrl1); + }) + + it('should allow retrieving utility history for the NFT', async () => { + await expect(erc6785.setUtilityUri( + tokenId, + utilityUrl1, + )).to.emit(erc6785, 'UpdateUtility').withArgs(tokenId, utilityUrl1); + let utilityUrl2 = utilityUrl1 + '_2'; + await expect(erc6785.setUtilityUri( + tokenId, + utilityUrl2, + )).to.emit(erc6785, 'UpdateUtility').withArgs(tokenId, utilityUrl2); + + let history = await erc6785.utilityHistoryOf( + tokenId, + ); + await expect(history.length).to.equal(2); + await expect(history[0]).to.equal(utilityUrl1); + await expect(history[1]).to.equal(utilityUrl2); + }) +}); From 063d4d0eb93fb48f5fddd9362506015682f18953 Mon Sep 17 00:00:00 2001 From: Adam Boudj Date: Fri, 9 Jun 2023 00:57:29 +0400 Subject: [PATCH 70/97] Add EIP: Dual Layer Token Merged by EIP-Bot. --- EIPS/eip-6960.md | 325 ++++++++++++++++++ .../eip-6960-dual-layer-token-dlt.png | Bin 0 -> 29359 bytes 2 files changed, 325 insertions(+) create mode 100644 EIPS/eip-6960.md create mode 100644 assets/eip-6960/eip-6960-dual-layer-token-dlt.png diff --git a/EIPS/eip-6960.md b/EIPS/eip-6960.md new file mode 100644 index 00000000000000..7d1214061f4344 --- /dev/null +++ b/EIPS/eip-6960.md @@ -0,0 +1,325 @@ +--- +eip: 6960 +title: Dual Layer Token +description: Token with a two-level classification system using mainId and subId +author: Adam Boudjemaa (@aboudjem), Mohamad Hammoud (@mohamadhammoud), Nawar Hisso (@nawar-hisso), Khawla Hassan (@khawlahssn), Mohammad Zakeri Rad (@zakrad), Ashish Sood +discussions-to: https://ethereum-magicians.org/t/eip-6960-dual-layer-token/14070 +status: Draft +type: Standards Track +category: ERC +created: 2023-04-30 +--- + +## Abstract + +The dual-layer token combines the functionalities of [ERC-20](./eip-20.md), [ERC-721](./eip-721.md), and [ERC-1155](./eip-1155.md) while adding a classification layer that uses `mainId` as the main asset type identifier and `subId` as the unique attributes or variations of the main asset. +![Dual Layer Token](../assets/eip-6960/eip-6960-dual-layer-token-dlt.png) + +The proposed token aims to offer more granularity in token management, facilitating a well-organized token ecosystem and simplifying the process of tracking tokens within a contract. This standard is particularly useful for tokenizing and enabling the fractional ownership of Real World Assets (RWAs). It also allows for efficient and flexible management of both fungible and non-fungible assets. + +The following are examples of assets that the DLT standard can represent fractional ownership of: + +- Invoices +- Company stocks +- Digital collectibles +- Real estate + +## Motivation + +The [ERC-1155](./eip-1155.md) standard has experienced considerable adoption within the Ethereum ecosystem; however, its design exhibits constraints when handling tokens with multiple classifications, particularly in relation to Real World Assets (RWAs) and fractionalization of assets. + +This EIP strives to overcome this limitation by proposing a token standard incorporating a dual-layer classification system, allowing for enhanced organization and management of tokens, especially in situations where additional sub-categorization of token types is necessary. + +## Specification + +The key words "MUST", "MUST NOT", "REQUIRED", "SHALL", "SHALL NOT", "SHOULD", "SHOULD NOT", "RECOMMENDED", "NOT RECOMMENDED", "MAY", and "OPTIONAL" in this document are to be interpreted as described in RFC 2119 and RFC 8174. + +### DLT Interface + +```solidity +// SPDX-License-Identifier: CC0-1.0 +pragma solidity 0.8.17; + +/** + * @title DLT token standard interface + * @dev Interface for any contract that wants to implement the DLT standard + */ +interface IDLT { + + /** + * @dev MUST emit when `subId` token is transferred from `sender` to `recipient` + * @param sender is the address of the previous holder whose balance is decreased + * @param recipient is the address of the new holder whose balance is increased + * @param mainId is the main token type ID to be transferred + * @param subId is the token subtype ID to be transferred + * @param amount is the amount to be transferred of the token subtype + */ + event Transfer( + address indexed sender, + address indexed recipient, + uint256 indexed mainId, + uint256 subId, + uint256 amount + ); + + /** + * @dev MUST emit when `subIds` token array is transferred from `sender` to `recipient` + * @param sender is the address of the previous holder whose balance is decreased + * @param recipient is the address of the new holder whose balance is increased + * @param mainIds is the main token type ID array to be transferred + * @param subIds is the token subtype ID array to be transferred + * @param amounts is the amount array to be transferred of the token subtype + */ + event TransferBatch( + address indexed sender, + address indexed recipient, + uint256[] mainIds, + uint256[] subIds, + uint256[] amounts + ); + + /** + * @dev MUST emit when `owner` enables `operator` to manage the `subId` token + * @param owner is the address of the token owner + * @param operator is the authorized address to manage the allocated amount for an owner address + * @param mainId is the main token type ID to be approved + * @param subId is the token subtype ID to be approved + * @param amount is the amount to be approved of the token subtype + */ + event Approval( + address indexed owner, + address indexed operator, + uint256 mainId, + uint256 subId, + uint256 amount + ); + + /** + * @dev MUST emit when `owner` enables or disables (`approved`) `operator` to manage all of its assets + * @param owner is the address of the token owner + * @param operator is the authorized address to manage all tokens for an owner address + * @param approved true if the operator is approved, false to revoke approval + */ + event ApprovalForAll( + address indexed owner, + address indexed operator, + bool approved + ); + + /** + * @dev MUST emit when the URI is updated for a main token type ID. + * URIs are defined in RFC 3986. + * The URI MUST point to a JSON file that conforms to the "DLT Metadata URI JSON Schema". + * @param oldValue is the old URI value + * @param newValue is the new URI value + * @param mainId is the main token type ID + */ + event URI(string oldValue, string newValue, uint256 indexed mainId); + + /** + * @dev Approve or remove `operator` as an operator for the caller. + * Operators can call {transferFrom} or {safeTransferFrom} for any subId owned by the caller. + * The `operator` MUST NOT be the caller. + * MUST emit an {ApprovalForAll} event. + * @param operator is the authorized address to manage all tokens for an owner address + * @param approved true if the operator is approved, false to revoke approval + */ + function setApprovalForAll(address operator, bool approved) external; + + /** + * @dev Moves `amount` tokens from `sender` to `recipient` using the + * allowance mechanism. `amount` is then deducted from the caller's + * allowance. + * MUST revert if `sender` or `recipient` is the zero address. + * MUST revert if balance of holder for token `subId` is lower than the `amount` sent. + * MUST emit a {Transfer} event. + * @param sender is the address of the previous holder whose balance is decreased + * @param recipient is the address of the new holder whose balance is increased + * @param mainId is the main token type ID to be transferred + * @param subId is the token subtype ID to be transferred + * @param amount is the amount to be transferred of the token subtype + * @param data is additional data with no specified format + * @return True if the operation succeeded, false if operation failed + */ + function safeTransferFrom( + address sender, + address recipient, + uint256 mainId, + uint256 subId, + uint256 amount, + bytes calldata data + ) external returns (bool); + + /** + * @dev Sets `amount` as the allowance of `spender` over the caller's tokens. + * The `operator` MUST NOT be the caller. + * MUST revert if `operator` is the zero address. + * MUST emit an {Approval} event. + * @param operator is the authorized address to manage tokens for an owner address + * @param mainId is the main token type ID to be approved + * @param subId is the token subtype ID to be approved + * @param amount is the amount to be approved of the token subtype + * @return True if the operation succeeded, false if operation failed + */ + function approve( + address operator, + uint256 mainId, + uint256 subId, + uint256 amount + ) external returns (bool); + + /** + * @notice Get the token with a particular subId balance of an `account` + * @param account is the address of the token holder + * @param mainId is the main token type ID + * @param subId is the token subtype ID + * @return The amount of tokens owned by `account` in subId + */ + function subBalanceOf( + address account, + uint256 mainId, + uint256 subId + ) external view returns (uint256); + + /** + * @notice Get the tokens with a particular subIds balance of an `accounts` array + * @param accounts is the address array of the token holder + * @param mainIds is the main token type ID array + * @param subIds is the token subtype ID array + * @return The amount of tokens owned by `accounts` in subIds + */ + function balanceOfBatch( + address[] calldata accounts, + uint256[] calldata mainIds, + uint256[] calldata subIds + ) external view returns (uint256[] calldata); + + /** + * @notice Get the allowance allocated to an `operator` + * @dev This value changes when {approve} or {transferFrom} are called + * @param owner is the address of the token owner + * @param operator is the authorized address to manage assets for an owner address + * @param mainId is the main token type ID + * @param subId is the token subtype ID + * @return The remaining number of tokens that `operator` will be + * allowed to spend on behalf of `owner` through {transferFrom}. This is + * zero by default. + */ + function allowance( + address owner, + address operator, + uint256 mainId, + uint256 subId + ) external view returns (uint256); + + /** + * @notice Get the approval status of an `operator` to manage assets + * @param owner is the address of the token owner + * @param operator is the authorized address to manage assets for an owner address + * @return True if the `operator` is allowed to manage all of the assets of `owner`, false if approval is revoked + * See {setApprovalForAll} + */ + function isApprovedForAll( + address owner, + address operator + ) external view returns (bool); +} +``` + +### `DLTReceiver` Interface + +Smart contracts MUST implement all the functions in the `DLTReceiver` interface to accept transfers. + +```solidity +// SPDX-License-Identifier: CC0-1.0 +pragma solidity 0.8.17; + +/** + * @title DLT token receiver interface + * @dev Interface for any contract that wants to support safeTransfers + * from DLT asset contracts. + */ +interface IDLTReceiver { + /** + * @notice Handle the receipt of a single DLT token type. + * @dev Whenever an {DLT} `subId` token is transferred to this contract via {IDLT-safeTransferFrom} + * by `operator` from `sender`, this function is called. + * MUST return its Solidity selector to confirm the token transfer. + * MUST revert if any other value is returned or the interface is not implemented by the recipient. + * The selector can be obtained in Solidity with `IDLTReceiver.onDLTReceived.selector`. + * @param operator is the address which initiated the transfer + * @param from is the address which previously owned the token + * @param mainId is the main token type ID being transferred + * @param subId subId is the token subtype ID being transferred + * @param amount is the amount of tokens being transferred + * @param data is additional data with no specified format + * @return `IDLTReceiver.onDLTReceived.selector` + */ + function onDLTReceived( + address operator, + address from, + uint256 mainId, + uint256 subId, + uint256 amount, + bytes calldata data + ) external returns (bytes4); + + /** + * @notice Handle the receipts of a DLT token type array. + * @dev Whenever an {DLT} `subIds` token is transferred to this contract via {IDLT-safeTransferFrom} + * by `operator` from `sender`, this function is called. + * MUST return its Solidity selector to confirm the token transfers. + * MUST revert if any other value is returned or the interface is not implemented by the recipient. + * The selector can be obtained in Solidity with `IDLTReceiver.onDLTReceived.selector`. + * @param operator is the address which initiated the transfer + * @param from is the address which previously owned the token + * @param mainIds is the main token type ID being transferred + * @param subIds subId is the token subtype ID being transferred + * @param amounts is the amount of tokens being transferred + * @param data is additional data with no specified format + * @return `IDLTReceiver.onDLTReceived.selector` + */ + function onDLTBatchReceived( + address operator, + address from, + uint256[] calldata mainIds, + uint256[] calldata subIds, + uint256[] calldata amounts, + bytes calldata data + ) external returns (bytes4); +} +``` + +## Rationale + +The two-level classification system introduced in this EIP allows for a more organized token ecosystem, enabling users to manage and track tokens with greater granularity. It is particularly useful for projects that require token classifications beyond the capabilities of the current ERC-1155 standard. + +As assets can have various properties or variations, our smart contract design reflects this by assigning a mainId to each asset category and a unique subId to each derivative or sub-category. This approach expands the capabilities of ERC-1155 to support a broader range of assets with complex requirements. Additionally, it enables tracking of mainBalance for the main asset and subBalance for its sub-assets individual accounts. + +The contract can be extended to support the use of subIds in two ways: + +- Shared SubIds: where all mainIds share the same set of subIds. +- Mixed SubIds: where mainIds have unique sets of subIds. + +DLT provides a more versatile solution compared to other token standards such as ERC-20, ERC-721, and ERC-1155 by effectively managing both fungible and non-fungible assets within the same contract. + +The following are questions that we considered during the design process: + +- How to name the proposal? +The standard introduces a two-level classification to tokens where one main asset (layer 1) can be further sub-divided into several sub-assets (layer 2) hence we decided to name it as "Dual-layer" token to reflect the hierarchical structure of the token classification. +- Should we limit the classification to two levels? +The standard’s implementation maintains a mapping to track the total supply of each sub-asset. If we allow sub-assets to have their own children, it would be necessary to introduce additional methods to track each sub-asset, which would be impractical and increases the complexity of the contract. +- Should we extend the ERC-1155 standard? +As the ERC-1155 standard is not designed to support a layered classification and requires significant modifications to do so, we concluded that it would not be appropriate to extend it for the dual-layer token standard. Hence, a standalone implementation would be a more suitable approach. + +## Backwards Compatibility + +No backward compatibility issues found. + +## Security Considerations + +Needs discussion. + +## Copyright + +Copyright and related rights waived via [CC0](../LICENSE.md). diff --git a/assets/eip-6960/eip-6960-dual-layer-token-dlt.png b/assets/eip-6960/eip-6960-dual-layer-token-dlt.png new file mode 100644 index 0000000000000000000000000000000000000000..d4db3c29e9b2ecd8f92e23829faa3b0b0cacc944 GIT binary patch literal 29359 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 B?iv69 literal 0 HcmV?d00001 From 33f5b65493174906750995f0381ad88f6e25b508 Mon Sep 17 00:00:00 2001 From: Francesco Sullo Date: Thu, 8 Jun 2023 13:05:21 -0800 Subject: [PATCH 71/97] Add EIP: Efficient Default Lockable Tokens Merged by EIP-Bot. --- EIPS/eip-6982.md | 90 +++++++++++ assets/eip-6982/.gitignore | 68 ++++++++ assets/eip-6982/README.md | 11 ++ assets/eip-6982/contracts/ERC721Lockable.sol | 153 ++++++++++++++++++ assets/eip-6982/contracts/IERC6982.sol | 28 ++++ assets/eip-6982/contracts/IERC721Lockable.sol | 46 ++++++ .../contracts/mocks/ERC721LockableMock.sol | 20 +++ assets/eip-6982/contracts/mocks/MyLocker.sol | 16 ++ assets/eip-6982/hardhat.config.js | 24 +++ assets/eip-6982/package.json | 27 ++++ assets/eip-6982/test/Lockable.test.js | 42 +++++ assets/eip-6982/test/helpers.js | 67 ++++++++ 12 files changed, 592 insertions(+) create mode 100644 EIPS/eip-6982.md create mode 100644 assets/eip-6982/.gitignore create mode 100644 assets/eip-6982/README.md create mode 100644 assets/eip-6982/contracts/ERC721Lockable.sol create mode 100644 assets/eip-6982/contracts/IERC6982.sol create mode 100644 assets/eip-6982/contracts/IERC721Lockable.sol create mode 100644 assets/eip-6982/contracts/mocks/ERC721LockableMock.sol create mode 100644 assets/eip-6982/contracts/mocks/MyLocker.sol create mode 100644 assets/eip-6982/hardhat.config.js create mode 100644 assets/eip-6982/package.json create mode 100644 assets/eip-6982/test/Lockable.test.js create mode 100644 assets/eip-6982/test/helpers.js diff --git a/EIPS/eip-6982.md b/EIPS/eip-6982.md new file mode 100644 index 00000000000000..a307da5ad40342 --- /dev/null +++ b/EIPS/eip-6982.md @@ -0,0 +1,90 @@ +--- +eip: 6982 +title: Efficient Default Lockable Tokens +description: A gas-efficient approach to lockable ERC-721 tokens +author: Francesco Sullo (@sullof), Alexe Spataru (@urataps) +discussions-to: https://ethereum-magicians.org/t/erc721-default-lockable-proposal/13366 +status: Draft +type: Standards Track +category: ERC +created: 2023-05-02 +requires: 165, 721 +--- + +## Abstract + +This proposal introduces a lockable interface for [ERC-721](./eip-721.md) tokens that optimizes gas usage by eliminating unnecessary events. This interface forms the foundation for the creation and management of lockable [ERC-721](./eip-721.md) tokens. It provides a gas-efficient approach by emitting a `DefaultLocked(bool locked)` event upon deployment, setting the initial lock status for all tokens, while individual `Locked(uint256 indexed tokenId, bool locked)` events handle subsequent status changes for specific tokens. The interface also includes a view function `locked(uint256 tokenId)` to return the current lock status of a token. + +## Motivation + +Existing lockable token proposals often mandate the emission of an event each time a token is minted. This results in unnecessary gas consumption, especially in cases where tokens are permanently locked from inception to destruction (e.g., soulbounds or non-transferable badges). This proposal offers a more gas-efficient solution that only emits events upon contract deployment and status changes of individual tokens. + +## Specification + +The key words "MUST", "MUST NOT", "REQUIRED", "SHALL", "SHALL NOT", "SHOULD", "SHOULD NOT", "RECOMMENDED", "NOT RECOMMENDED", "MAY", and "OPTIONAL" in this document are to be interpreted as described in RFC 2119 and RFC 8174. + +The interface is defined as follows: + +```solidity +// ERC165 interfaceId 0x6b61a747 +interface IERC6982 { + // This event MUST be emitted upon deployment of the contract, establishing + // the default lock status for any tokens that will be minted in the future. + // If the default lock status changes for any reason, this event + // MUST be re-emitted to update the default status for all tokens. + // Note that emitting a new DefaultLocked event does not affect the lock + // status of any tokens for which a Locked event has previously been emitted. + event DefaultLocked(bool locked); + + // This event MUST be emitted whenever the lock status of a specific token + // changes, effectively overriding the default lock status for this token. + event Locked(uint256 indexed tokenId, bool locked); + + // This function returns the current default lock status for tokens. + // It reflects the value set by the latest DefaultLocked event. + function defaultLocked() external view returns (bool); + + // This function returns the lock status of a specific token. + // If no Locked event has been emitted for a given tokenId, it MUST return + // the value that defaultLocked() returns, which represents the default + // lock status. + // This function MUST revert if the token does not exist. + function locked(uint256 tokenId) external view returns (bool); +} +``` + +The [ERC-165](./eip-165.md) interfaceId is `0x6b61a747`. + +## Rationale + +This standard seeks to optimize gas consumption by minimizing the frequency of event emission. The DefaultLocked event is designed to establish the lock status for all tokens, thereby circumventing the need to emit an event each time a new token is minted. It's crucial to note that the DefaultLocked event can be emitted at any point in time, and is not restricted to only before the Locked events are emitted. + +Tokens may alter their behavior under certain circumstances (such as after a reveal), prompting the re-emission of the DefaultLocked event to reflect the new default status. The primary objective here is to economize on gas usage by avoiding the need to emit a Locked event for each token when the default status changes. + +The Locked event is utilized to document changes in the lock status of individual tokens. + +The defaultLocked function returns the prevailing default lock status of a token. This function is beneficial as it fosters interaction with other contracts and averts potential conflicts with [ERC-5192](./eip-5192), which is in its final stage. + +The locked function gives the current lock status of a particular token, further facilitating interaction with other contracts. If no changes have been made to a specific token ID, this function should return the value provided by the defaultLocked function. + +Bear in mind that a token being designated as "locked" doesn't necessarily imply that it is entirely non-transferable. There might be certain conditions under which a token can still be transferred despite its locked status. Primarily, the locked status relates to a token's transferability on marketplaces and external exchanges. + +To illustrate, let's consider the Cruna protocol. In this system, an NFT owner has the ability to activate what is termed an 'initiator'. This is essentially a secondary wallet with the unique privilege of initiating key transactions. Upon setting an initiator, the token's status is rendered 'locked'. However, this does not impede the token's transferability if the initiation for the transfer comes from the designated initiator. + +## Backwards Compatibility + +This standard is fully backwards compatible with existing [ERC-721](./eip-721.md) contracts. It can be easily integrated into existing contracts and will not cause any conflicts or disruptions. + +## Reference Implementation + +An example implementation is located in the [assets](../assets/eip-6982) directory. + +It solves a specific use case: token's owners losing the ownership when staking the asset in a pool. The implementation allow the pool to lock the asset, leaving the ownership to the owner. In the [README](../assets/eip-6982/README.md) you can find more details about how to compile and test the contracts. + +## Security Considerations + +This EIP does not introduce any known security considerations. However, as with any smart contract standard, it is crucial to employ rigorous security measures in the implementation of this interface. + +## Copyright + +Copyright and related rights waived via [CC0](../LICENSE.md). diff --git a/assets/eip-6982/.gitignore b/assets/eip-6982/.gitignore new file mode 100644 index 00000000000000..b102f6f5f59ebe --- /dev/null +++ b/assets/eip-6982/.gitignore @@ -0,0 +1,68 @@ +*.swp +*.swo + +# Logs +logs +*.log + +# Runtime data +pids +*.pid +*.seed +allFiredEvents +scTopics + +# Coverage directory used by tools like istanbul +coverage +coverage.json +coverageEnv + +# node-waf configuration +.lock-wscript + +# Dependency directory +node_modules + +# Debug log from npm +npm-debug.log + +# local env variables +.env +.env.* +env.* + +# truffle build directory +build/ + +# macOS +.DS_Store + +# truffle +.node-xmlhttprequest-* + +# IntelliJ IDE +.idea + +# docs artifacts +docs/modules/api + +# only used to package @openzeppelin/contracts +contracts/build/ +contracts/README.md + +# temporary artifact from solidity-coverage +.coverage_artifacts +.coverage_cache +.coverage_contracts + +# hardhat +cache +artifacts + +#local data +db +/etherscan +.openzeppelin +/test/fixtures/csv +/export +pnpm-lock.yaml diff --git a/assets/eip-6982/README.md b/assets/eip-6982/README.md new file mode 100644 index 00000000000000..abec2293f500db --- /dev/null +++ b/assets/eip-6982/README.md @@ -0,0 +1,11 @@ +# EIP 6982 implementation + +As a reference implementation of EIP-6982 we use the Nduja Labs ERC721Lockable contract. + +To run the tests, run the following commands: + +```shell +npm i -g pnpm +pnpm i +pnpm test +``` diff --git a/assets/eip-6982/contracts/ERC721Lockable.sol b/assets/eip-6982/contracts/ERC721Lockable.sol new file mode 100644 index 00000000000000..c6a02c47fab2df --- /dev/null +++ b/assets/eip-6982/contracts/ERC721Lockable.sol @@ -0,0 +1,153 @@ +// SPDX-License-Identifier: MIT +pragma solidity ^0.8.19; + +// Authors: Francesco Sullo + +import "@openzeppelin/contracts/token/ERC721/ERC721.sol"; +import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol"; +import "@openzeppelin/contracts/utils/Address.sol"; +import "@openzeppelin/contracts/access/Ownable.sol"; +import "./IERC721Lockable.sol"; +import "./IERC6982.sol"; + +// This is an example of lockable ERC721 using IERC6982 as basic interface + +contract ERC721Lockable is IERC6982, IERC721Lockable, Ownable, ERC721, ERC721Enumerable { + using Address for address; + + mapping(address => bool) private _locker; + mapping(uint256 => address) private _lockedBy; + + bool internal _defaultLocked; + + modifier onlyLocker() { + require(_locker[_msgSender()], "Not a locker"); + _; + } + + constructor( + string memory name, + string memory symbol, + bool defaultLocked_ + ) ERC721(name, symbol) { + updateDefaultLocked(defaultLocked_); + } + + function defaultLocked() external view override returns (bool) { + return _defaultLocked; + } + + function updateDefaultLocked(bool defaultLocked_) public onlyOwner { + _defaultLocked = defaultLocked_; + emit DefaultLocked(defaultLocked_); + } + + function _beforeTokenTransfer( + address from, + address to, + uint256 tokenId, + uint256 batchSize + ) internal override(ERC721, ERC721Enumerable) { + require( + // during minting + from == address(0) || + // later + !locked(tokenId), + "Token is locked" + ); + super._beforeTokenTransfer(from, to, tokenId, batchSize); + } + + function supportsInterface(bytes4 interfaceId) public view override(ERC721, ERC721Enumerable) returns (bool) { + return + interfaceId == type(IERC6982).interfaceId || + interfaceId == type(IERC721Lockable).interfaceId || + super.supportsInterface(interfaceId); + } + + function locked(uint256 tokenId) public view virtual override returns (bool) { + require(_exists(tokenId), "Token does not exist"); + return _lockedBy[tokenId] != address(0); + } + + function lockerOf(uint256 tokenId) public view virtual override returns (address) { + return _lockedBy[tokenId]; + } + + function isLocker(address locker) public view virtual override returns (bool) { + return _locker[locker]; + } + + function setLocker(address locker) external virtual override onlyOwner { + require(locker.isContract(), "Locker not a contract"); + _locker[locker] = true; + emit LockerSet(locker); + } + + function removeLocker(address locker) external virtual override onlyOwner { + require(_locker[locker], "Not an active locker"); + delete _locker[locker]; + emit LockerRemoved(locker); + } + + function hasLocks(address owner) public view virtual override returns (bool) { + uint256 balance = balanceOf(owner); + for (uint256 i = 0; i < balance; i++) { + uint256 id = tokenOfOwnerByIndex(owner, i); + if (locked(id)) { + return true; + } + } + return false; + } + + function lock(uint256 tokenId) external virtual override onlyLocker { + // locker must be approved to mark the token as locked + require(isLocker(_msgSender()), "Not an authorized locker"); + require(getApproved(tokenId) == _msgSender() || isApprovedForAll(ownerOf(tokenId), _msgSender()), "Locker not approved"); + _lockedBy[tokenId] = _msgSender(); + emit Locked(tokenId, true); + } + + function unlock(uint256 tokenId) external virtual override onlyLocker { + // will revert if token does not exist + require(_lockedBy[tokenId] == _msgSender(), "Wrong locker"); + delete _lockedBy[tokenId]; + emit Locked(tokenId, false); + } + + // emergency function in case a compromised locker is removed + function unlockIfRemovedLocker(uint256 tokenId) external virtual override { + require(locked(tokenId), "Not a locked tokenId"); + require(!_locker[_lockedBy[tokenId]], "Locker is still active"); + require(ownerOf(tokenId) == _msgSender(), "Not the asset owner"); + delete _lockedBy[tokenId]; + emit ForcefullyUnlocked(tokenId); + } + + // manage approval + + function approve(address to, uint256 tokenId) public virtual override(IERC721, ERC721) { + require(!locked(tokenId), "Locked asset"); + super.approve(to, tokenId); + } + + function getApproved(uint256 tokenId) public view virtual override(IERC721, ERC721) returns (address) { + if (locked(tokenId) && lockerOf(tokenId) != _msgSender()) { + return address(0); + } + return super.getApproved(tokenId); + } + + function setApprovalForAll(address operator, bool approved) public virtual override(IERC721, ERC721) { + require(!approved || !hasLocks(_msgSender()), "At least one asset is locked"); + super.setApprovalForAll(operator, approved); + } + + function isApprovedForAll(address owner, address operator) public view virtual override(IERC721, ERC721) returns (bool) { + if (hasLocks(owner)) { + return false; + } + return super.isApprovedForAll(owner, operator); + } +} diff --git a/assets/eip-6982/contracts/IERC6982.sol b/assets/eip-6982/contracts/IERC6982.sol new file mode 100644 index 00000000000000..06ac78132b978e --- /dev/null +++ b/assets/eip-6982/contracts/IERC6982.sol @@ -0,0 +1,28 @@ +// SPDX-License-Identifier: CC0-1.0 +pragma solidity ^0.8.9; + +// ERC165 interfaceId 0x6b61a747 +interface IERC6982 { + // This event MUST be emitted upon deployment of the contract, establishing + // the default lock status for any tokens that will be minted in the future. + // If the default lock status changes for any reason, this event + // MUST be re-emitted to update the default status for all tokens. + // Note that emitting a new DefaultLocked event does not affect the lock + // status of any tokens for which a Locked event has previously been emitted. + event DefaultLocked(bool locked); + + // This event MUST be emitted whenever the lock status of a specific token + // changes, effectively overriding the default lock status for this token. + event Locked(uint256 indexed tokenId, bool locked); + + // This function returns the current default lock status for tokens. + // It reflects the value set by the latest DefaultLocked event. + function defaultLocked() external view returns (bool); + + // This function returns the lock status of a specific token. + // If no Locked event has been emitted for a given tokenId, it MUST return + // the value that defaultLocked() returns, which represents the default + // lock status. + // This function MUST revert if the token does not exist. + function locked(uint256 tokenId) external view returns (bool); +} diff --git a/assets/eip-6982/contracts/IERC721Lockable.sol b/assets/eip-6982/contracts/IERC721Lockable.sol new file mode 100644 index 00000000000000..77b2ff89e092f6 --- /dev/null +++ b/assets/eip-6982/contracts/IERC721Lockable.sol @@ -0,0 +1,46 @@ +// SPDX-License-Identifier: MIT +pragma solidity ^0.8.19; + +// Author: +// Francesco Sullo + +interface IERC721Lockable { + event LockerSet(address locker); + event LockerRemoved(address locker); + event ForcefullyUnlocked(uint256 tokenId); + + // tells if a token is locked. Removed to extend IERC5192 + // function locked(uint256 tokenID) external view returns (bool); + + // tells the address of the contract which is locking a token + function lockerOf(uint256 tokenID) external view returns (address); + + // tells if a contract is a locker + function isLocker(address _locker) external view returns (bool); + + // set a locker, if the actor that is locking it is a contract, it + // should be approved + // It should emit a LockerSet event + function setLocker(address pool) external; + + // remove a locker + // It should emit a LockerRemoved event + function removeLocker(address pool) external; + + // tells if an NFT has any locks on it + // The function is called internally and externally + function hasLocks(address owner) external view returns (bool); + + // locks an NFT + // It should emit a Locked event + function lock(uint256 tokenID) external; + + // unlocks an NFT + // It should emit a Unlocked event + function unlock(uint256 tokenID) external; + + // unlock an NFT if the locker is removed + // This is an emergency function called by the token owner or a DAO + // It should emit a ForcefullyUnlocked event + function unlockIfRemovedLocker(uint256 tokenID) external; +} diff --git a/assets/eip-6982/contracts/mocks/ERC721LockableMock.sol b/assets/eip-6982/contracts/mocks/ERC721LockableMock.sol new file mode 100644 index 00000000000000..94b62167c20f4b --- /dev/null +++ b/assets/eip-6982/contracts/mocks/ERC721LockableMock.sol @@ -0,0 +1,20 @@ +// SPDX-License-Identifier: MIT +pragma solidity ^0.8.19; + +// Authors: Francesco Sullo + +import "../ERC721Lockable.sol"; + +contract ERC721LockableMock is ERC721Lockable { + + uint public latestTokenId; + + constructor(string memory name, string memory symbol) ERC721Lockable(name, symbol, false) {} + + function mint (address to, uint256 amount) public { + for (uint256 i = 0; i < amount; i++) { + // inefficient, but this is a mock :-) + _safeMint(to, ++latestTokenId); + } + } +} diff --git a/assets/eip-6982/contracts/mocks/MyLocker.sol b/assets/eip-6982/contracts/mocks/MyLocker.sol new file mode 100644 index 00000000000000..5ceff78ac7359c --- /dev/null +++ b/assets/eip-6982/contracts/mocks/MyLocker.sol @@ -0,0 +1,16 @@ +// SPDX-License-Identifier: MIT +pragma solidity ^0.8.19; + +// Authors: Francesco Sullo + +import "../IERC721Lockable.sol"; + +contract MyLocker { + function lock(address asset, uint256 id) public { + IERC721Lockable(asset).lock(id); + } + + function unlock(address asset, uint256 id) public { + IERC721Lockable(asset).unlock(id); + } +} diff --git a/assets/eip-6982/hardhat.config.js b/assets/eip-6982/hardhat.config.js new file mode 100644 index 00000000000000..0d430b5335f8c0 --- /dev/null +++ b/assets/eip-6982/hardhat.config.js @@ -0,0 +1,24 @@ +require("@nomiclabs/hardhat-waffle"); + +// You need to export an object to set up your config +// Go to https://hardhat.org/config/ to learn more + +/** + * @type import('hardhat/config').HardhatUserConfig + */ +module.exports = { + solidity: { + version: "0.8.19", + settings: { + optimizer: { + enabled: true, + runs: 200, + }, + }, + }, + networks: { + hardhat: { + blockGasLimit: 10000000, + } + }, +}; diff --git a/assets/eip-6982/package.json b/assets/eip-6982/package.json new file mode 100644 index 00000000000000..b7fd956dc41b0e --- /dev/null +++ b/assets/eip-6982/package.json @@ -0,0 +1,27 @@ +{ + "name": "erc6982-example", + "version": "0.1.0", + "scripts": { + "test": "npx hardhat test", + "compile": "npx hardhat compile" + }, + "author": { + "name": "Francesco Sullo", + "email": "francesco@sullo.co" + }, + "license": "MIT", + "devDependencies": { + "@nomiclabs/hardhat-ethers": "^2.2.3", + "@nomiclabs/hardhat-waffle": "^2.0.5", + "@openzeppelin/hardhat-upgrades": "^1.25.3", + "chai": "^4.3.7", + "ethereum-waffle": "^3.4.4", + "ethers": "^5.7.2", + "hardhat": "^2.14.0", + "typescript": "^4.9.5" + }, + "dependencies": { + "@openzeppelin/contracts": "^4.8.3", + "@openzeppelin/contracts-upgradeable": "^4.8.3" + } +} diff --git a/assets/eip-6982/test/Lockable.test.js b/assets/eip-6982/test/Lockable.test.js new file mode 100644 index 00000000000000..279f13839b93e1 --- /dev/null +++ b/assets/eip-6982/test/Lockable.test.js @@ -0,0 +1,42 @@ +const {expect} = require("chai"); +const { deployContractUpgradeable, deployContract} = require("./helpers"); + +describe("ERC721Lockable", function () { + let myToken; + let myLocker; + + let owner, holder, holder2; + + before(async function () { + [owner, holder, holder2] = await ethers.getSigners(); + }); + + beforeEach(async function () { + // myPool = await deployContract("MyPlayer"); + myToken = await deployContract("ERC721LockableMock", "My token", "NFT"); + myLocker = await deployContract("MyLocker") + }); + + it("should verify the flow", async function () { + + expect(await myToken.supportsInterface("0x2e4e0d27")).equal(true); + + await myToken.mint(holder.address, 5); + + await myToken.setLocker(myLocker.address); + expect(await myToken.isLocker(myLocker.address)).equal(true); + + await expect(myLocker.lock(myToken.address, 2)).revertedWith("Locker not approved"); + + await myToken.connect(holder).approve(myLocker.address, 2); + await myLocker.lock(myToken.address, 2); + + expect(await myToken.locked(2)).equal(true); + + await expect(myToken.connect(holder).transferFrom(holder.address, holder2.address, 2)).revertedWith("Token is locked"); + + await expect(myToken.connect(holder).transferFrom(holder.address, holder2.address, 3)).emit(myToken, "Transfer").withArgs(holder.address, holder2.address, 3); + + }); + +}); diff --git a/assets/eip-6982/test/helpers.js b/assets/eip-6982/test/helpers.js new file mode 100644 index 00000000000000..8aab232fdeec10 --- /dev/null +++ b/assets/eip-6982/test/helpers.js @@ -0,0 +1,67 @@ +const {assert} = require("chai"); + +const Helpers = { + initEthers(ethers) { + this.ethers = ethers; + }, + + async assertThrowsMessage(promise, message) { + try { + await promise; + console.log("It did not throw :-("); + assert.isTrue(false); + } catch (e) { + const shouldBeTrue = e.message.indexOf(message) > -1; + if (!shouldBeTrue) { + console.error("Expected:", message); + console.error("Returned:", e.message); + // console.log(e) + } + assert.isTrue(shouldBeTrue); + } + }, + + async deployContractBy(contractName, owner, ...args) { + const Contract = await this.ethers.getContractFactory(contractName); + const contract = await Contract.connect(owner).deploy(...args); + await contract.deployed(); + return contract; + }, + + async deployContract(contractName, ...args) { + const Contract = await this.ethers.getContractFactory(contractName); + const contract = await Contract.deploy(...args); + await contract.deployed(); + return contract; + }, + + async deployContractUpgradeable(contractName, args = []) { + const Contract = await this.ethers.getContractFactory(contractName); + const contract = await upgrades.deployProxy(Contract, args); + await contract.deployed(); + return contract; + }, + + async signPackedData( + hash, + // hardhat account #4, starting from #0 + privateKey = "0x47e179ec197488593b187f80a00eb0da91f1b9d0b13f8733639f19c30a34926a" + ) { + const signingKey = new this.ethers.utils.SigningKey(privateKey); + const signedDigest = signingKey.signDigest(hash); + return this.ethers.utils.joinSignature(signedDigest); + }, + + async getTimestamp() { + return (await this.ethers.provider.getBlock()).timestamp; + }, + + addr0: "0x0000000000000000000000000000000000000000", + + async increaseBlockTimestampBy(offset) { + await this.ethers.provider.send("evm_increaseTime", [offset]); + await this.ethers.provider.send("evm_mine"); + }, +}; + +module.exports = Helpers; From b6ec7a50271b95234154dceebc4452cca36efa27 Mon Sep 17 00:00:00 2001 From: Matt Galligan Date: Sat, 10 Jun 2023 06:58:24 -0500 Subject: [PATCH 72/97] Update EIP-6492: Fix typo in eip-6492.md Merged by EIP-Bot. --- EIPS/eip-6492.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/EIPS/eip-6492.md b/EIPS/eip-6492.md index a5593d7261022c..78d7f4f6fb6697 100644 --- a/EIPS/eip-6492.md +++ b/EIPS/eip-6492.md @@ -17,7 +17,7 @@ Contracts can sign verifyable messages via [ERC-1271](./eip-1271.md). However, if the contract is not deployed yet, [ERC-1271](./eip-1271.md) verification is impossible, as you can't call the `isValidSignature` function on said contract. -We propose a standard way for any contract or off-chain actor to verify whether a signature on behalf of a given counterfactual contract (that is not deployed yet) is valid. This standarad way extends [ERC-1271](./eip-1271.md). +We propose a standard way for any contract or off-chain actor to verify whether a signature on behalf of a given counterfactual contract (that is not deployed yet) is valid. This standard way extends [ERC-1271](./eip-1271.md). ## Motivation From e84d8f988308475ef71da68fd82f214aa82701bc Mon Sep 17 00:00:00 2001 From: Gavin John Date: Sun, 11 Jun 2023 10:12:50 -0500 Subject: [PATCH 73/97] Update EIP-2015: Use sam's wording Merged by EIP-Bot. --- EIPS/eip-2015.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/EIPS/eip-2015.md b/EIPS/eip-2015.md index 6dbb8ad88aea83..6b359a5e19525d 100644 --- a/EIPS/eip-2015.md +++ b/EIPS/eip-2015.md @@ -47,7 +47,7 @@ The `chainId` is the `0x`-prefixed [EIP-155](./eip-155.md)-compliant chain ID. T All keys other than the `chainId` are optional. All keys other than `chainId` are suggestions to the wallet. Wallets can choose to ignore or display other data to users. Wallets should prompt the user before switching or adding chains. Wallets should also store a default list of data for commonly-used chains, in order to avoid phishing attacks. Wallets MUST sanitize each RPC url before using it to send other requests, including ensuring that it responds correctly to the `net_version` and `eth_chainId` methods. -The `wallet_updateEthereumChain` method returns `true` if the chain was successfully added or switched to, and an error with code `4001` if the user rejected the request. +The `wallet_updateEthereumChain` method returns `true` if the active chain matches the requested chain, regardless of whether the chain was already active or was added to the wallet previously. If the user rejects the request, it must return an error with code `4001`. ## Rationale From f0cb96f152214cf06df41704d25702407e2c8a96 Mon Sep 17 00:00:00 2001 From: jxom Date: Mon, 12 Jun 2023 09:42:16 +1000 Subject: [PATCH 74/97] Update EIP-6963: Add walletId back into the design Merged by EIP-Bot. --- EIPS/eip-6963.md | 80 +++++++++++++++++++++++++++++++++++++++++++----- 1 file changed, 73 insertions(+), 7 deletions(-) diff --git a/EIPS/eip-6963.md b/EIPS/eip-6963.md index 57aa5278b86353..727a5e1c9596ac 100644 --- a/EIPS/eip-6963.md +++ b/EIPS/eip-6963.md @@ -2,7 +2,7 @@ eip: 6963 title: Multi Injected Provider Discovery description: Using window events to announce injected wallet providers -author: Pedro Gomes (@pedrouid), Kosala Hemachandra (@kvhnuke), Richard Moore (@ricmoo), Gregory Markou (@GregTheGreek), Kyle Den Hartog (@kdenhartog), Glitch (@glitch-txs), Jake Moxey (@jxom), Pierre Bertet (@bpierre), Darryl Yeo (@darrylyeo), Yaroslav Sergievsky (@everdimension) +author: Pedro Gomes (@pedrouid), Kosala Hemachandra (@kvhnuke), Richard Moore (@ricmoo), Gregory Markou (@GregTheGreek), Kyle Den Hartog (@kdenhartog), Glitch (@glitch-txs), Jake Moxey (@jxom), Pierre Bertet (@bpierre), Darryl Yeo (@darrylyeo), Yaroslav Sergievsky (@everdimension), Tom Meagher (@tmm) discussions-to: https://ethereum-magicians.org/t/eip-6963-multi-injected-provider-interface-aka-mipi/14076 status: Draft type: Standards Track @@ -39,15 +39,16 @@ Wallet: A user agent that manages keys and facilitates transactions with Ethereu Decentralized Application (DApp): A web page that relies upon one or many Web3 platform APIs which are exposed to the web page via the Wallet. -Provider Discovery Library: A library or piece of software that assists a DApp to interact with the Wallet. +Provider Discovery Library: A library or piece of software that assists a DApp to interact with the Wallet (e.g. wagmi, Web3Modal, RainbowKit, Web3-Onboard, ConnectKit, etc). ### Provider Info -Each wallet provider will be announced with the following interface `EIP6963ProviderInfo`. The values in the `EIP6963ProviderInfo` MUST be used as follows: +Each Wallet Provider will be announced with the following interface `EIP6963ProviderInfo`. The values in the `EIP6963ProviderInfo` MUST be used as follows: -- **`uuid`** - a globally unique of the wallet provider that MUST be (UUIDv4[^rfc4122] compliant) to uniquely distinguish different [EIP-1193](./eip-1193.md) provider sessions. The cryptographic uniqueness provided by UUIDv4[^rfc4122] guarantees that two independent `EIP6963ProviderInfo` objects can be separately identified. -- **`name`** - A human-readable local alias of the wallet provider to be displayed to the user on the DApp. (e.g. `DopeWalletExtension` or `AwesomeWallet`) -- **`icon`** - A URI[^rfc3986] pointing to an image. Icon images MUST be square with 96x96px minimum resolution +- **`uuid`** - a universally unique identifier of the Wallet Provider that MUST be UUIDv4[^rfc4122] compliant and thus MUST BE non-deterministic between sessions. +- **`walletId`** - a unique identifier for the Wallet Provider that MUST be unique to the Wallet Provider and MUST be deterministic between sessions. +- **`name`** - a human-readable local alias of the Wallet Provider to be displayed to the user on the DApp and MAY be non-deterministic between sessions. +- **`icon`** - a URI[^rfc3986] pointing to an image. Icon images MUST be square with 96x96px minimum resolution ```typescript /** @@ -55,11 +56,55 @@ Each wallet provider will be announced with the following interface `EIP6963Prov */ interface EIP6963ProviderInfo { uuid: string; + walletId: string; name: string; icon: string; } ``` +#### Universally Unique Identifiers (UUIDs) + +The UUID (`uuid`) is a **non-deterministic unique identifier** used to uniquely distinguish different [EIP-1193](./eip-1193.md) provider sessions. The cryptographic uniqueness provided by UUIDv4[^rfc4122] guarantees that two independent `EIP6963ProviderInfo` objects can be separately identified. + +#### Wallet IDs + +The Wallet ID (`walletId`) is a **deterministic unique identifier** used by the Provider Discovery Library to "find" or "target" Wallet Providers. + +A **deterministic** Wallet ID is particularly useful for a Provider Discovery Library to: + +- Rehydrate Wallet Providers that have been persisted in a previous session via browser local storage or a database. +- Group Wallets in the Provider Discovery Library or DApps UI (e.g. "Favorites", "Recent", etc). +- Handle Wallet Providers that may implement optional `wallet_` RPC methods (e.g. `wallet_addEthereumChain`, etc). +- Shim behaviour that may not be native of the Wallet Provider. + +Examples of Wallet IDs include: + +``` +metamask +coinbase +zerion +brave +taho +rainbow +``` + +#### Wallet Names + +A Wallet Name (`name`) is a human-readable display name of the Wallet Provider. + +The Wallet Name is primarily used to display the Wallet to the user in the DApp's UI. + +Examples of Wallet Names include: + +``` +MetaMask +Coinbase Wallet +Zerion +Brave Wallet +Taho +Rainbow +``` + #### Images/Icons // TODO for @kdenhartog: This section should be updated to require support of SVGs instead of arbitrary data URIs or URLs that point to images. @@ -169,10 +214,31 @@ To follow the Javascript event name conventions, the names are written in presen ### Interfaces -Standardizing a provider info interface (`EIP6963ProviderInfo`) allows determining the necessary information to populate a wallet selection popup. This is particularly useful for DApps and Ethereum libraries they might depend on such as Web3Modal, RainbowKit, Web3-Onboard, ConnectKit, etc. +Standardizing a provider info interface (`EIP6963ProviderInfo`) allows determining the necessary information to populate a wallet selection popup. This is particularly useful for DApps and Provider Discovery Libraries they might depend on. Regarding the announced provider interface (`EIP6963ProviderDetail`) it was important to leave the [EIP-1193](./eip-1193.md) provider interface untouched for backwards compatibility therefore it's exposed in parallel. However, just as it is today there is no guarantee that this backwards compatible method will result in the user selected wallet being chosen. +### Wallet IDs + +A Wallet ID (`walletId`) is included in the design to allow DApps & Provider Discovery Libraries to target or identify Wallet Providers. As the Wallet ID is the only deterministic identifier in the design, this means we can accurately achieve Wallet Provider identification between sessions compared to the UUID (`uuid`) or Wallet Name (`name`). + +Notable differences: + +- The difference between a Wallet ID (`walletId`) and a UUID (`uuid`) is that the Wallet ID is a **deterministic identifier** that **does not** change between sessions, whereas a UUID is a **non-deterministic identifier** that **does** change between sessions. +- The difference between a Wallet ID (`walletId`) and a Wallet Name (`name`) is that the Wallet ID is a **deterministic identifier** that **does not** change between sessions, whereas a Wallet Name is a **non-deterministic display name** that **may** change between sessions, such as when a Wallet undergoes a brand change/modification (e.g. "Tally" → "Taho", or "Rabby" → "Rabby Wallet"). + +Previously, we implicitly achieved Wallet IDs by extending `window.ethereum` to include a non-standard flag (ie. `isMetaMask`, `isBrave`, `isTrustWallet`, etc.) to identify Wallet Providers. This was problematic because it: + +1. is a non-standard +2. introduces contradicting/"impossible" states (e.g. `isMetaMask` and `isOpera` being both `true`) that lead to challenges when identifying the correct wallet. + +Having a stringified Wallet ID (`walletId`) instead of a boolean flag allows us to accurately identify Wallet Providers between sessions and avoid the aforementioned challenges. + +Furthermore, some use-cases of Wallet IDs for Provider Discovery Libraries include: + +- **Rehydrating Wallet Providers**: If the Provider Discovery Library has persisted the Wallet Provider in a previous session via browser local storage or a database, they can rely on the Wallet ID to accurately rehydrate the Wallet Provider. +- **Group Wallets**: If the Provider Discovery Library has a list of Wallet Providers they wish to group together (e.g. a "Recent", "Favourites", etc section) they can rely on the Wallet ID to accurately achieve this. +- **`wallet_` RPC Method Differences**: If the Wallet Provider implements optional `wallet_` RPC methods, the Provider Discovery Library can rely on the Wallet ID to accurately determine how to facilitate the `wallet_` RPC method. For example, a Wallet may not support chain switching, and thus may not support `wallet_switchEthereumChain`, this means the Provider Discovery Library could not show a "Switch Network" button for that Wallet Provider. ## Backwards Compatibility From 179dac5ecf47306c6a5a2005a47a6716235c084c Mon Sep 17 00:00:00 2001 From: jxom Date: Mon, 12 Jun 2023 09:57:30 +1000 Subject: [PATCH 75/97] Update EIP-6963: Revert "Update EIP-6963: Add walletId back into the design" Merged by EIP-Bot. --- EIPS/eip-6963.md | 80 +++++------------------------------------------- 1 file changed, 7 insertions(+), 73 deletions(-) diff --git a/EIPS/eip-6963.md b/EIPS/eip-6963.md index 727a5e1c9596ac..57aa5278b86353 100644 --- a/EIPS/eip-6963.md +++ b/EIPS/eip-6963.md @@ -2,7 +2,7 @@ eip: 6963 title: Multi Injected Provider Discovery description: Using window events to announce injected wallet providers -author: Pedro Gomes (@pedrouid), Kosala Hemachandra (@kvhnuke), Richard Moore (@ricmoo), Gregory Markou (@GregTheGreek), Kyle Den Hartog (@kdenhartog), Glitch (@glitch-txs), Jake Moxey (@jxom), Pierre Bertet (@bpierre), Darryl Yeo (@darrylyeo), Yaroslav Sergievsky (@everdimension), Tom Meagher (@tmm) +author: Pedro Gomes (@pedrouid), Kosala Hemachandra (@kvhnuke), Richard Moore (@ricmoo), Gregory Markou (@GregTheGreek), Kyle Den Hartog (@kdenhartog), Glitch (@glitch-txs), Jake Moxey (@jxom), Pierre Bertet (@bpierre), Darryl Yeo (@darrylyeo), Yaroslav Sergievsky (@everdimension) discussions-to: https://ethereum-magicians.org/t/eip-6963-multi-injected-provider-interface-aka-mipi/14076 status: Draft type: Standards Track @@ -39,16 +39,15 @@ Wallet: A user agent that manages keys and facilitates transactions with Ethereu Decentralized Application (DApp): A web page that relies upon one or many Web3 platform APIs which are exposed to the web page via the Wallet. -Provider Discovery Library: A library or piece of software that assists a DApp to interact with the Wallet (e.g. wagmi, Web3Modal, RainbowKit, Web3-Onboard, ConnectKit, etc). +Provider Discovery Library: A library or piece of software that assists a DApp to interact with the Wallet. ### Provider Info -Each Wallet Provider will be announced with the following interface `EIP6963ProviderInfo`. The values in the `EIP6963ProviderInfo` MUST be used as follows: +Each wallet provider will be announced with the following interface `EIP6963ProviderInfo`. The values in the `EIP6963ProviderInfo` MUST be used as follows: -- **`uuid`** - a universally unique identifier of the Wallet Provider that MUST be UUIDv4[^rfc4122] compliant and thus MUST BE non-deterministic between sessions. -- **`walletId`** - a unique identifier for the Wallet Provider that MUST be unique to the Wallet Provider and MUST be deterministic between sessions. -- **`name`** - a human-readable local alias of the Wallet Provider to be displayed to the user on the DApp and MAY be non-deterministic between sessions. -- **`icon`** - a URI[^rfc3986] pointing to an image. Icon images MUST be square with 96x96px minimum resolution +- **`uuid`** - a globally unique of the wallet provider that MUST be (UUIDv4[^rfc4122] compliant) to uniquely distinguish different [EIP-1193](./eip-1193.md) provider sessions. The cryptographic uniqueness provided by UUIDv4[^rfc4122] guarantees that two independent `EIP6963ProviderInfo` objects can be separately identified. +- **`name`** - A human-readable local alias of the wallet provider to be displayed to the user on the DApp. (e.g. `DopeWalletExtension` or `AwesomeWallet`) +- **`icon`** - A URI[^rfc3986] pointing to an image. Icon images MUST be square with 96x96px minimum resolution ```typescript /** @@ -56,55 +55,11 @@ Each Wallet Provider will be announced with the following interface `EIP6963Prov */ interface EIP6963ProviderInfo { uuid: string; - walletId: string; name: string; icon: string; } ``` -#### Universally Unique Identifiers (UUIDs) - -The UUID (`uuid`) is a **non-deterministic unique identifier** used to uniquely distinguish different [EIP-1193](./eip-1193.md) provider sessions. The cryptographic uniqueness provided by UUIDv4[^rfc4122] guarantees that two independent `EIP6963ProviderInfo` objects can be separately identified. - -#### Wallet IDs - -The Wallet ID (`walletId`) is a **deterministic unique identifier** used by the Provider Discovery Library to "find" or "target" Wallet Providers. - -A **deterministic** Wallet ID is particularly useful for a Provider Discovery Library to: - -- Rehydrate Wallet Providers that have been persisted in a previous session via browser local storage or a database. -- Group Wallets in the Provider Discovery Library or DApps UI (e.g. "Favorites", "Recent", etc). -- Handle Wallet Providers that may implement optional `wallet_` RPC methods (e.g. `wallet_addEthereumChain`, etc). -- Shim behaviour that may not be native of the Wallet Provider. - -Examples of Wallet IDs include: - -``` -metamask -coinbase -zerion -brave -taho -rainbow -``` - -#### Wallet Names - -A Wallet Name (`name`) is a human-readable display name of the Wallet Provider. - -The Wallet Name is primarily used to display the Wallet to the user in the DApp's UI. - -Examples of Wallet Names include: - -``` -MetaMask -Coinbase Wallet -Zerion -Brave Wallet -Taho -Rainbow -``` - #### Images/Icons // TODO for @kdenhartog: This section should be updated to require support of SVGs instead of arbitrary data URIs or URLs that point to images. @@ -214,31 +169,10 @@ To follow the Javascript event name conventions, the names are written in presen ### Interfaces -Standardizing a provider info interface (`EIP6963ProviderInfo`) allows determining the necessary information to populate a wallet selection popup. This is particularly useful for DApps and Provider Discovery Libraries they might depend on. +Standardizing a provider info interface (`EIP6963ProviderInfo`) allows determining the necessary information to populate a wallet selection popup. This is particularly useful for DApps and Ethereum libraries they might depend on such as Web3Modal, RainbowKit, Web3-Onboard, ConnectKit, etc. Regarding the announced provider interface (`EIP6963ProviderDetail`) it was important to leave the [EIP-1193](./eip-1193.md) provider interface untouched for backwards compatibility therefore it's exposed in parallel. However, just as it is today there is no guarantee that this backwards compatible method will result in the user selected wallet being chosen. -### Wallet IDs - -A Wallet ID (`walletId`) is included in the design to allow DApps & Provider Discovery Libraries to target or identify Wallet Providers. As the Wallet ID is the only deterministic identifier in the design, this means we can accurately achieve Wallet Provider identification between sessions compared to the UUID (`uuid`) or Wallet Name (`name`). - -Notable differences: - -- The difference between a Wallet ID (`walletId`) and a UUID (`uuid`) is that the Wallet ID is a **deterministic identifier** that **does not** change between sessions, whereas a UUID is a **non-deterministic identifier** that **does** change between sessions. -- The difference between a Wallet ID (`walletId`) and a Wallet Name (`name`) is that the Wallet ID is a **deterministic identifier** that **does not** change between sessions, whereas a Wallet Name is a **non-deterministic display name** that **may** change between sessions, such as when a Wallet undergoes a brand change/modification (e.g. "Tally" → "Taho", or "Rabby" → "Rabby Wallet"). - -Previously, we implicitly achieved Wallet IDs by extending `window.ethereum` to include a non-standard flag (ie. `isMetaMask`, `isBrave`, `isTrustWallet`, etc.) to identify Wallet Providers. This was problematic because it: - -1. is a non-standard -2. introduces contradicting/"impossible" states (e.g. `isMetaMask` and `isOpera` being both `true`) that lead to challenges when identifying the correct wallet. - -Having a stringified Wallet ID (`walletId`) instead of a boolean flag allows us to accurately identify Wallet Providers between sessions and avoid the aforementioned challenges. - -Furthermore, some use-cases of Wallet IDs for Provider Discovery Libraries include: - -- **Rehydrating Wallet Providers**: If the Provider Discovery Library has persisted the Wallet Provider in a previous session via browser local storage or a database, they can rely on the Wallet ID to accurately rehydrate the Wallet Provider. -- **Group Wallets**: If the Provider Discovery Library has a list of Wallet Providers they wish to group together (e.g. a "Recent", "Favourites", etc section) they can rely on the Wallet ID to accurately achieve this. -- **`wallet_` RPC Method Differences**: If the Wallet Provider implements optional `wallet_` RPC methods, the Provider Discovery Library can rely on the Wallet ID to accurately determine how to facilitate the `wallet_` RPC method. For example, a Wallet may not support chain switching, and thus may not support `wallet_switchEthereumChain`, this means the Provider Discovery Library could not show a "Switch Network" button for that Wallet Provider. ## Backwards Compatibility From e9a4295fe7661d2ab31183563087f9073272ccc1 Mon Sep 17 00:00:00 2001 From: g11tech Date: Mon, 12 Jun 2023 21:00:03 +0530 Subject: [PATCH 76/97] Update EIP-4844: clarify transaction payload body Merged by EIP-Bot. --- EIPS/eip-4844.md | 16 ++++++++-------- 1 file changed, 8 insertions(+), 8 deletions(-) diff --git a/EIPS/eip-4844.md b/EIPS/eip-4844.md index fc36199c0f1c50..f0eb6a364aaf5c 100644 --- a/EIPS/eip-4844.md +++ b/EIPS/eip-4844.md @@ -99,12 +99,12 @@ def fake_exponential(factor: int, numerator: int, denominator: int) -> int: return output // denominator ``` -### New transaction type +### Blob transaction -We introduce a new [EIP-2718](./eip-2718.md) transaction, "blob transaction", where the `TransactionType` is `BLOB_TX_TYPE` and the `TransactionPayload` is the following RLP value: +We introduce a new [EIP-2718](./eip-2718.md) transaction, "blob transaction", where the `TransactionType` is `BLOB_TX_TYPE` and the `TransactionPayload` is the RLP serialization of the following `TransactionPayloadBody`: ``` -rlp([chain_id, nonce, max_priority_fee_per_gas, max_fee_per_gas, gas_limit, to, value, data, access_list, max_fee_per_data_gas, blob_versioned_hashes, y_parity, r, s])`. +[chain_id, nonce, max_priority_fee_per_gas, max_fee_per_gas, gas_limit, to, value, data, access_list, max_fee_per_data_gas, blob_versioned_hashes, y_parity, r, s] ``` The fields `chain_id`, `nonce`, `max_priority_fee_per_gas`, `max_fee_per_gas`, `gas_limit`, `value`, `data`, and `access_list` follow the same semantics as [EIP-1559](./eip-1559.md). @@ -296,20 +296,20 @@ def validate_block(block: Block) -> None: Blob transactions have two network representations. During transaction gossip responses (`PooledTransactions`), the EIP-2718 `TransactionPayload` of the blob transaction is wrapped to become: ``` -rlp([tx_payload, blobs, commitments, proofs]) +rlp([tx_payload_body, blobs, commitments, proofs]) ``` Each of these elements are defined as follows: -- `tx_payload` - standard EIP-2718 blob transaction `TransactionPayload` +- `tx_payload_body` - is the `TransactionPayloadBody` of standard EIP-2718 [blob transaction](#blob-transaction) - `blobs` - list of `blob` bytes where each `blob` is its `BLSFieldElement` list flattened in `big endian` - `commitments` - list of `KZGCommitment` of the corresponding `blobs` - `proofs` - list of `KZGProof` of the corresponding `blobs` and `commitments` -The node MUST validate `tx_payload` and verify the wrapped data against it. To do so, ensure that: +The node MUST validate `tx_payload_body` and verify the wrapped data against it. To do so, ensure that: -- There are an equal number of `tx_payload.blob_versioned_hashes`, `blobs`, `commitments`, and `proofs`. -- The KZG `commitments` hash to the versioned hashes, i.e. `kzg_to_versioned_hash(commitments[i]) == tx_payload.blob_versioned_hashes[i]` +- There are an equal number of `tx_payload_body.blob_versioned_hashes`, `blobs`, `commitments`, and `proofs`. +- The KZG `commitments` hash to the versioned hashes, i.e. `kzg_to_versioned_hash(commitments[i]) == tx_payload_body.blob_versioned_hashes[i]` - The KZG `commitments` match the corresponding `blobs` and `proofs`. (Note: this can be optimized using `blob_kzg_proofs`, with a proof for a random evaluation at a point derived from the commitment and blob data for each blob) From b72f9ee4574aeeca38154c56d1c69f28be2e3abf Mon Sep 17 00:00:00 2001 From: adam-alchemy <127769144+adam-alchemy@users.noreply.github.com> Date: Mon, 12 Jun 2023 12:53:40 -0700 Subject: [PATCH 77/97] Update EIP-6900: Spec corrections Merged by EIP-Bot. --- EIPS/eip-6900.md | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/EIPS/eip-6900.md b/EIPS/eip-6900.md index 915608f05dcb47..37935900066700 100644 --- a/EIPS/eip-6900.md +++ b/EIPS/eip-6900.md @@ -52,7 +52,7 @@ The key words "MUST", "MUST NOT", "REQUIRED", "SHALL", "SHALL NOT", "SHOULD", "S - **Execution functions** execute any custom logic allowed by the account. - **Hooks** execute custom logic and checks before and/or after an execution function. - A **validation function** is a function that validates authentication and authorization of a caller to the account. There are two types of validation functions: - - **User Operation Validator** functions handle calls to `validateUserOp` and check the validity of an ERC-4337 user operation. The function may have any function name, and MUST take in the parameters `(UserOperation calldata, bytes32, uint256)`, representing the user operation, user operation hash, and required prefund. It MUST return `(uint256)`, representing packed validation data for `authorizer`, `validUntil`, and `validAfter`. + - **User Operation Validator** functions handle calls to `validateUserOp` and check the validity of an ERC-4337 user operation. The function may have any function name, and MUST take in the parameters `(UserOperation calldata, bytes32)`, representing the user operation and user operation hash. It MUST return `(uint256)`, representing packed validation data for `authorizer`, `validUntil`, and `validAfter`. - **Runtime Validator** functions run before an execution function when not called via a user operation, and enforce checks. Common checks include allowing execution only by an owner. - An **execution function** is a smart contract function that defines the main execution step of a function for a **modular account**. - The **standard execute functions** are two specific execution functions that are implemented natively by the modular account, and not on a plugin. These allow for open-ended execution. @@ -68,7 +68,7 @@ The key words "MUST", "MUST NOT", "REQUIRED", "SHALL", "SHALL NOT", "SHOULD", "S A modular account handles two kinds of calls: either from the `Entrypoint` through ERC-4337, or through direct calls from externally owned accounts (EOAs) and other smart contracts. This standard supports both use cases. -A call to the smart contract account can be decomposed into 5 steps as shown in the diagram below. The validation steps (Steps 1 and 2) validate if the caller is allowed to call. The pre execution hook step (Step 2) can be used to do any pre execution checks or updates. It can also be used with the post execution hook step (Step 4) to perform additional actions or verification. The execution step (Step 4) performs a performs a defined task or collection of tasks. +A call to the smart contract account can be decomposed into 5 steps as shown in the diagram below. The validation steps (Steps 1 and 2) validate if the caller is allowed to call. The pre execution hook step (Step 3) can be used to do any pre execution checks or updates. It can also be used with the post execution hook step (Step 5) to perform additional actions or verification. The execution step (Step 4) performs a defined task or collection of tasks. ![diagram showing execution flow within an account](../assets/eip-6900/MSCA_Two_Call_Paths_Diagram.svg) @@ -199,9 +199,9 @@ interface IStandardExecutor { } struct Execution { - address dest; + address target; uint256 value; - bytes func; + bytes data; ExecutionMode mode; } From 6c7a38dc2b341a64f576a611e8466e135c722821 Mon Sep 17 00:00:00 2001 From: Alex Stokes Date: Mon, 12 Jun 2023 16:54:51 -0600 Subject: [PATCH 78/97] Update EIP-4788: Update the precompile address for 4788 Merged by EIP-Bot. --- EIPS/eip-4788.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/EIPS/eip-4788.md b/EIPS/eip-4788.md index 74521bc1d2dba8..8225351237c9e9 100644 --- a/EIPS/eip-4788.md +++ b/EIPS/eip-4788.md @@ -28,7 +28,7 @@ restaking constructions, smart contract bridges, MEV mitigations and more. | constants | value | units |--- |--- |--- | `FORK_TIMESTAMP` | TBD | -| `HISTORY_STORAGE_ADDRESS` | `0xfffffffffffffffffffffffffffffffffffffffd` | +| `HISTORY_STORAGE_ADDRESS` | `Bytes20(0xB)` | | `G_beacon_root` | 2100 | gas ### Background From 83af6a36bfdb2487d6584558b2741108ca6b8267 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Ernesto=20Garc=C3=ADa?= Date: Tue, 13 Jun 2023 09:04:07 -0600 Subject: [PATCH 79/97] Update EIP-6093: Move to Last Call Merged by EIP-Bot. --- EIPS/eip-6093.md | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/EIPS/eip-6093.md b/EIPS/eip-6093.md index 25e87bfce54e53..b5fce6869f2de8 100644 --- a/EIPS/eip-6093.md +++ b/EIPS/eip-6093.md @@ -4,7 +4,8 @@ title: Custom errors for commonly-used tokens description: Lists custom errors for common token implementations author: Ernesto García (@ernestognw), Francisco Giordano (@frangio), Hadrien Croubois (@Amxx) discussions-to: https://ethereum-magicians.org/t/eip-6093-custom-errors-for-erc-tokens/12043 -status: Draft +status: Last Call +last-call-deadline: 2023-08-15 type: Standards Track category: ERC created: 2022-12-06 From d80d36651aba52a12c9a624d253ec7ae66e18cba Mon Sep 17 00:00:00 2001 From: Jessica Chang <117890123+JessicaChg@users.noreply.github.com> Date: Tue, 13 Jun 2023 23:05:15 +0800 Subject: [PATCH 80/97] Update EIP-6239: Move to Review Merged by EIP-Bot. --- EIPS/eip-6239.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/EIPS/eip-6239.md b/EIPS/eip-6239.md index ca08a672608b90..02dc13b63b44e7 100644 --- a/EIPS/eip-6239.md +++ b/EIPS/eip-6239.md @@ -4,7 +4,7 @@ title: Semantic Soulbound Tokens description: Adding RDF triples to ERC-5192 token metadata to capture social meaning author: Jessica Chang (@JessicaChg) discussions-to: https://ethereum-magicians.org/t/eip-6239-semantic-soulbound-tokens/12334 -status: Draft +status: Review type: Standards Track category: ERC created: 2022-12-30 From 6f84674498c47722ed7fe0bb3ff01ad345eeebf7 Mon Sep 17 00:00:00 2001 From: Eduard Fina <67655321+eduardfina@users.noreply.github.com> Date: Tue, 13 Jun 2023 17:42:37 +0200 Subject: [PATCH 81/97] Update EIP-6997: Move to Review Merged by EIP-Bot. --- EIPS/eip-6997.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/EIPS/eip-6997.md b/EIPS/eip-6997.md index 3cccd5a21f571e..3c66b382e70621 100644 --- a/EIPS/eip-6997.md +++ b/EIPS/eip-6997.md @@ -4,7 +4,7 @@ title: ERC-721 with transaction validation step. description: A new validation step for transfer and approve calls, achieving a security step in case of stolen wallet. author: Eduard López i Fina (@eduardfina) discussions-to: https://ethereum-magicians.org/t/erc721-with-a-validation-step/14071 -status: Draft +status: Review type: Standards Track category: ERC created: 2023-05-07 From d0f0942991069f556727c3920d3a49010c1b9ba0 Mon Sep 17 00:00:00 2001 From: Alex Stokes Date: Tue, 13 Jun 2023 14:11:07 -0600 Subject: [PATCH 82/97] Update EIP-4788: clarify header and validity sections Merged by EIP-Bot. --- EIPS/eip-4788.md | 7 +++---- 1 file changed, 3 insertions(+), 4 deletions(-) diff --git a/EIPS/eip-4788.md b/EIPS/eip-4788.md index 8225351237c9e9..72e787a6ca11d1 100644 --- a/EIPS/eip-4788.md +++ b/EIPS/eip-4788.md @@ -40,11 +40,10 @@ To bound the amount of storage this construction consumes, a ring buffer is used ### Block structure and validity -Beginning at the execution timestamp `FORK_TIMESTAMP`, execution clients **MUST**: +Beginning at the execution timestamp `FORK_TIMESTAMP`, execution clients **MUST** extend the header schema with an additional field: the `parent_beacon_block_root`. +This root consumes 32 bytes and is exactly the [hash tree root](https://github.com/ethereum/consensus-specs/blob/fa09d896484bbe240334fa21ffaa454bafe5842e/ssz/simple-serialize.md#merkleization) of the parent beacon block for the given execution block. -1. set 32 bytes of the execution block header after the last header field as of `FORK_TIMESTAMP` to the 32 byte [hash tree root](https://github.com/ethereum/consensus-specs/blob/fa09d896484bbe240334fa21ffaa454bafe5842e/ssz/simple-serialize.md#merkleization) of the parent beacon block. - -*NOTE*: this field is appended to the current block header structure with this EIP so that the size of the header grows after (and including) the `FORK_TIMESTAMP`. +Validity is guaranteed from the consensus layer, much like how withdrawals are handled. ### EVM changes From 63c540645b7e017162ed03b9386be9cbccfc140d Mon Sep 17 00:00:00 2001 From: Glitch <66949816+glitch-txs@users.noreply.github.com> Date: Tue, 13 Jun 2023 23:17:02 -0300 Subject: [PATCH 83/97] =?UTF-8?q?Update=20EIP-6963:=20Remove=20Object.free?= =?UTF-8?q?ze=20from=20Dapp=20implementation=20exampl=E2=80=A6?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Merged by EIP-Bot. --- EIPS/eip-6963.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/EIPS/eip-6963.md b/EIPS/eip-6963.md index 57aa5278b86353..eac9cc73c2ec67 100644 --- a/EIPS/eip-6963.md +++ b/EIPS/eip-6963.md @@ -198,7 +198,7 @@ function onPageLoad() { }; window.dispatchEvent( new CustomEvent("eip6963:announceProvider", { - detail: { info, provider }, + detail: Object.freeze({ info, provider }), }) ); } @@ -224,7 +224,7 @@ function onPageLoad(): EIP6963ProviderDetail[] => { window.addEventListener( "eip6963:announceProvider", (event: EIP6963AnnounceProviderEvent) => { - providers.push(Object.freeze(event.detail)); + providers.push(event.detail); } ); From a9e7891309150158946465cb8fab05ccaec81b9f Mon Sep 17 00:00:00 2001 From: delaaxe <1091900+delaaxe@users.noreply.github.com> Date: Wed, 14 Jun 2023 18:18:43 +0300 Subject: [PATCH 84/97] Update EIP-6900: More precise usage of words `account` and `wallet` Merged by EIP-Bot. --- EIPS/eip-6900.md | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/EIPS/eip-6900.md b/EIPS/eip-6900.md index 37935900066700..37dd66eef8fe08 100644 --- a/EIPS/eip-6900.md +++ b/EIPS/eip-6900.md @@ -19,13 +19,13 @@ This modular approach splits account functionality into three categories, implem ## Motivation -One of the goals that ERC-4337 accomplishes is abstracting the logic for execution and validation to each smart contract wallet. +One of the goals that ERC-4337 accomplishes is abstracting the logic for execution and validation to each smart contract account. -Many new features of wallets can be built by customizing the logic that goes into the validation and execution steps. Examples of such features include session keys, subscriptions, spending limits, and role-based access control. Currently, some of these features are implemented natively by specific smart contract accounts, and others are able to be implemented by plugin systems. Examples of proprietary plugin systems include Safe modules and ZeroDev plugins. +Many new features of accounts can be built by customizing the logic that goes into the validation and execution steps. Examples of such features include session keys, subscriptions, spending limits, and role-based access control. Currently, some of these features are implemented natively by specific smart contract accounts, and others are able to be implemented by plugin systems. Examples of proprietary plugin systems include Safe modules and ZeroDev plugins. -However, managing multiple wallet instances provides a worse user experience, fragmenting accounts across supported features and security configurations. Additionally, it requires plugin developers to choose which platforms to support, causing either platform lock-in or duplicated development effort. +However, managing multiple account instances provides a worse user experience, fragmenting accounts across supported features and security configurations. Additionally, it requires plugin developers to choose which platforms to support, causing either platform lock-in or duplicated development effort. -We propose a standard that coordinates the implementation work between plugin developers and wallet developers. This standard defines a modular smart contract account capable of supporting all standard-conformant plugins. This allows users to have greater portability of their data, and for plugin developers to not have to choose specific wallet implementations to support. +We propose a standard that coordinates the implementation work between plugin developers and wallet developers. This standard defines a modular smart contract account capable of supporting all standard-conformant plugins. This allows users to have greater portability of their data, and for plugin developers to not have to choose specific account implementations to support. ![diagram showing relationship between accounts and plugins of each type](../assets/eip-6900/MSCA_Shared_Components_Diagram.svg) From 0e8c2de9d1028c943411f16860ef670ab0f9d06d Mon Sep 17 00:00:00 2001 From: Sam Wilson <57262657+SamWilsn@users.noreply.github.com> Date: Sat, 17 Jun 2023 00:34:45 -0400 Subject: [PATCH 85/97] Update EIP-1: Add W3C as a permissible origin (#7111) * Add W3C as a permissible origin * Update eip-1.md --- EIPS/eip-1.md | 18 ++++++++++++++++++ 1 file changed, 18 insertions(+) diff --git a/EIPS/eip-1.md b/EIPS/eip-1.md index 2225d4fbd9b4ff..7ffd14b8636c71 100644 --- a/EIPS/eip-1.md +++ b/EIPS/eip-1.md @@ -252,6 +252,24 @@ Permitted Networking Specifications URLs must anchor to a specific commit, and s ^https://github.com/ethereum/devp2p/blob/[0-9a-f]{40}/.*$ ``` +### World Wide Web Consortium (W3C) + +Links to a W3C "Recommendation" status specification may be included using normal markdown syntax. For example, the following link would be allowed: + +```markdown +[Secure Contexts](https://www.w3.org/TR/2021/CRD-secure-contexts-20210918/) +``` + +Which renders as: + +[Secure Contexts](https://www.w3.org/TR/2021/CRD-secure-contexts-20210918/) + +Permitted W3C recommendation URLs MUST anchor to a specification in the technical reports namespace with a date, and so MUST match this regular expression: + +```regex +^https://www\.w3\.org/TR/[0-9][0-9][0-9][0-9]/.*$ +``` + ### Digital Object Identifier System Links qualified with a Digital Object Identifier (DOI) may be included using the following syntax: From 71dc97318013bf2ac572ab63fab530ac9ef419ca Mon Sep 17 00:00:00 2001 From: Sam Wilson <57262657+SamWilsn@users.noreply.github.com> Date: Sat, 17 Jun 2023 01:05:01 -0400 Subject: [PATCH 86/97] Add WHATWG as a permissible origin (#7117) --- EIPS/eip-1.md | 20 ++++++++++++++++++++ 1 file changed, 20 insertions(+) diff --git a/EIPS/eip-1.md b/EIPS/eip-1.md index 7ffd14b8636c71..5f31c5916dc506 100644 --- a/EIPS/eip-1.md +++ b/EIPS/eip-1.md @@ -270,6 +270,26 @@ Permitted W3C recommendation URLs MUST anchor to a specification in the technica ^https://www\.w3\.org/TR/[0-9][0-9][0-9][0-9]/.*$ ``` +### Web Hypertext Application Technology Working Group (WHATWG) + +Links to WHATWG specifications may be included using normal markdown syntax, such as: + +```markdown +[HTML](https://html.spec.whatwg.org/commit-snapshots/578def68a9735a1e36610a6789245ddfc13d24e0/) +``` + +Which renders as: + +[HTML](https://html.spec.whatwg.org/commit-snapshots/578def68a9735a1e36610a6789245ddfc13d24e0/) + +Permitted WHATWG specification URLs must anchor to a specification defined in the `spec` subdomain (idea specifications are not allowed) and to a commit snapshot, and so must match this regular expression: + +```regex +^https:\/\/[a-z]*\.spec\.whatwg\.org/commit-snapshots/[0-9a-f]{40}/$ +``` + +Although not recommended by WHATWG, EIPs must anchor to a particular commit so that future readers can refer to the exact version of the living standard that existed at the time the EIP was finalized. This gives readers sufficient information to maintain compatibility, if they so choose, with the version referenced by the EIP and the current living standard. + ### Digital Object Identifier System Links qualified with a Digital Object Identifier (DOI) may be included using the following syntax: From 929f2101f4069bd9cd516175d893f9ea63b8cc15 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Ernesto=20Garc=C3=ADa?= Date: Sat, 17 Jun 2023 13:46:02 -0600 Subject: [PATCH 87/97] Update EIP-6093: Improve specification clarity Merged by EIP-Bot. --- EIPS/eip-6093.md | 113 +++++++++++++++++++++++++++++++---------------- 1 file changed, 76 insertions(+), 37 deletions(-) diff --git a/EIPS/eip-6093.md b/EIPS/eip-6093.md index b5fce6869f2de8..e82cc65cfed59e 100644 --- a/EIPS/eip-6093.md +++ b/EIPS/eip-6093.md @@ -32,9 +32,9 @@ The key words "MUST", "MUST NOT", "REQUIRED", "SHALL", "SHALL NOT", "SHOULD", "S The following errors were designed according to the criteria described in [Rationale](#rationale). -This EIP defines standard errors that may be used by implementations in certain scenarios, but does not specify whether implementations should revert in those scenarios, which remains up to the implementers, unless a revert is mandated by the corresponding EIPs. +This EIP defines standard errors that may be used by implementations in certain scenarios but it does not specify whether implementations should revert in those scenarios, which remains up to the implementers unless a revert is mandated by the corresponding EIPs. -The names of the error arguments are defined in the [Parameter Glossary](#parameter-glossary), and MUST be used according to those definitions. +The names of the error arguments are defined in the [Parameter Glossary](#parameter-glossary) and MUST be used according to those definitions. ### [ERC-20](./eip-20.md) @@ -43,15 +43,18 @@ The names of the error arguments are defined in the [Parameter Glossary](#parame Indicates an error related to the current `balance` of a `sender`. Used in transfers. -- MUST be used when `balance` is less than `needed`. -- MUST NOT be used if `balance` is greater than or equal to `needed`. +Usage guidelines: + +- `balance` MUST be less than `needed`. #### `ERC20InvalidSender(address sender)` Indicates a failure with the token `sender`. Used in transfers. -- MUST be used for disallowed transfers from the zero address. +Usage guidelines: + +- RECOMMENDED for disallowed transfers from the zero address. - MUST NOT be used for approval operations. - MUST NOT be used for balance or allowance requirements. - Use `ERC20InsufficientBalance` or `ERC20InsufficientAllowance` instead. @@ -61,8 +64,10 @@ Used in transfers. Indicates a failure with the token `receiver`. Used in transfers. -- MUST be used for disallowed transfers to the zero address. -- MUST be used for disallowed transfers to non-compatible addresses (eg. contract addresses). +Usage guidelines: + +- RECOMMENDED for disallowed transfers to the zero address. +- RECOMMENDED for disallowed transfers to non-compatible addresses (eg. contract addresses). - MUST NOT be used for approval operations. #### `ERC20InsufficientAllowance(address spender, uint256 allowance, uint256 needed)` @@ -70,15 +75,18 @@ Used in transfers. Indicates a failure with the `spender`'s `allowance`. Used in transfers. -- MUST be used when `allowance` is less than `needed`. -- MUST NOT be used if `allowance` is greater than or equal to `needed`. +Usage guidelines: + +- `allowance` MUST be less than `needed`. #### `ERC20InvalidApprover(address approver)` Indicates a failure with the `approver` of a token to be approved. Used in approvals. -- MUST be used for disallowed approvals from the zero address. +Usage guidelines: + +- RECOMMENDED for disallowed approvals from the zero address. - MUST NOT be used for transfer operations. #### `ERC20InvalidSpender(address spender)` @@ -86,34 +94,42 @@ Used in approvals. Indicates a failure with the `spender` to be approved. Used in approvals. -- MUST be used for disallowed approvals to the zero address. -- MUST be used for disallowed approvals to the owner itself. +Usage guidelines: + +- RECOMMENDED for disallowed approvals to the zero address. +- RECOMMENDED for disallowed approvals to the owner itself. - MUST NOT be used for transfer operations. - Use `ERC20InsufficientAllowance` instead. ### [ERC-721](./eip-721.md) -### `ERC721InvalidOwner(address owner)` +#### `ERC721InvalidOwner(address owner)` Indicates that an address can't be an owner. Used in balance queries. -- MUST be used for addresses whose ownership is disallowed (eg. ERC-721 explicitly disallows `address(0)` to be an owner). -- MUST not be used for transfers. +Usage guidelines: + +- RECOMMENDED for addresses whose ownership is disallowed (eg. ERC-721 explicitly disallows `address(0)` to be an owner). +- MUST NOT be used for transfers. - Use `ERC721IncorrectOwner` instead. -### `ERC721NonexistentToken(uint256 tokenId)` +#### `ERC721NonexistentToken(uint256 tokenId)` Indicates a `tokenId` whose `owner` is the zero address. -- MUST be used when attempting to interact with a non-minted or burned token. +Usage guidelines: + +- The `tokenId` MUST BE a non-minted or burned token. #### `ERC721IncorrectOwner(address sender, uint256 tokenId, address owner)` Indicates an error related to the ownership over a particular token. Used in transfers. -- MUST be used when `sender` is not `owner`. +Usage guidelines: + +- `sender` MUST NOT be `owner`. - MUST NOT be used for approval operations. #### `ERC721InvalidSender(address sender)` @@ -121,7 +137,9 @@ Used in transfers. Indicates a failure with the token `sender`. Used in transfers. -- MUST be used for disallowed transfers from the zero address. +Usage guidelines: + +- RECOMMENDED for disallowed transfers from the zero address. - MUST NOT be used for approval operations. - MUST NOT be used for ownership or approval requirements. - Use `ERC721IncorrectOwner` or `ERC721InsufficientApproval` instead. @@ -131,8 +149,10 @@ Used in transfers. Indicates a failure with the token `receiver`. Used in transfers. -- MUST be used for disallowed transfers to the zero address. -- MUST be used for disallowed transfers to non-`ERC721TokenReceiver` contracts or those that reject a transfer. (eg. returning an invalid response in `onERC721Received`). +Usage guidelines: + +- RECOMMENDED for disallowed transfers to the zero address. +- RECOMMENDED for disallowed transfers to non-`ERC721TokenReceiver` contracts or those that reject a transfer. (eg. returning an invalid response in `onERC721Received`). - MUST NOT be used for approval operations. #### `ERC721InsufficientApproval(address operator, uint256 tokenId)` @@ -140,15 +160,19 @@ Used in transfers. Indicates a failure with the `operator`'s approval. Used in transfers. -- MUST be used when operator `isApprovedForAll(owner, operator)` is false. -- MUST be used when operator `getApproved(tokenId)` is not `operator`. +Usage guidelines: + +- `isApprovedForAll(owner, operator)` MUST be false for the `tokenId`'s owner and `operator`. +- `getApproved(tokenId)` MUST not be `operator`. #### `ERC721InvalidApprover(address approver)` Indicates a failure with the `owner` of a token to be approved. Used in approvals. -- MUST be used for disallowed approvals from the zero address. +Usage guidelines: + +- RECOMMENDED for disallowed approvals from the zero address. - MUST NOT be used for transfer operations. #### `ERC721InvalidOperator(address operator)` @@ -156,8 +180,10 @@ Used in approvals. Indicates a failure with the `operator` to be approved. Used in approvals. -- MUST be used for disallowed approvals to the zero address. -- MUST be used for disallowed approvals to the owner itself. +Usage guidelines: + +- RECOMMENDED for disallowed approvals to the zero address. +- The `operator` MUST NOT be the owner of the approved token. - MUST NOT be used for transfer operations. - Use `ERC721InsufficientApproval` instead. @@ -168,15 +194,18 @@ Used in approvals. Indicates an error related to the current `balance` of a `sender`. Used in transfers. -- MUST be used when `balance` is less than `needed` for a `tokenId`. -- MUST NOT be used if `balance` is greater than or equal to `needed` for a `tokenId`. +Usage guidelines: + +- `balance` MUST be less than `needed` for a `tokenId`. #### `ERC1155InvalidSender(address sender)` Indicates a failure with the token `sender`. Used in transfers. -- MUST be used for disallowed transfers from the zero address. +Usage guidelines: + +- RECOMMENDED for disallowed transfers from the zero address. - MUST NOT be used for approval operations. - MUST NOT be used for balance or allowance requirements. - Use `ERC1155InsufficientBalance` or `ERC1155InsufficientApprovalForAll` instead. @@ -186,8 +215,10 @@ Used in transfers. Indicates a failure with the token `receiver`. Used in transfers. -- MUST be used for disallowed transfers to the zero address. -- MUST be used for disallowed transfers to non-`ERC1155TokenReceiver` contracts or those that reject a transfer. (eg. returning an invalid response in `onERC1155Received`). +Usage guidelines: + +- RECOMMENDED for disallowed transfers to the zero address. +- RECOMMENDED for disallowed transfers to non-`ERC1155TokenReceiver` contracts or those that reject a transfer. (eg. returning an invalid response in `onERC1155Received`). - MUST NOT be used for approval operations. #### `ERC1155InsufficientApprovalForAll(address operator, address owner)` @@ -195,14 +226,18 @@ Used in transfers. Indicates a failure with the `operator`'s approval in a transfer. Used in transfers. -- MUST be used when operator `isApprovedForAll(owner, operator, tokenId)` is false. +Usage guidelines: + +- `isApprovedForAll(owner, operator)` MUST be false for the `tokenId`'s owner and `operator`. #### `ERC1155InvalidApprover(address approver)` Indicates a failure with the `approver` of a token to be approved. Used in approvals. -- MUST be used for disallowed approvals from the zero address. +Usage guidelines: + +- RECOMMENDED for disallowed approvals from the zero address. - MUST NOT be used for transfer operations. #### `ERC1155InvalidOperator(address operator)` @@ -210,7 +245,9 @@ Used in approvals. Indicates a failure with the `operator` to be approved. Used in approvals. -- MUST be used for disallowed approvals to the zero address. +Usage guidelines: + +- RECOMMENDED for disallowed approvals to the zero address. - MUST be used for disallowed approvals to the owner itself. - MUST NOT be used for transfer operations. - Use `ERC1155InsufficientApproval` instead. @@ -220,7 +257,9 @@ Used in approvals. Indicates an array length mismatch between `ids` and `values` in a `safeBatchTransferFrom` operation. Used in batch transfers. -- MUST be used only if `idsLength` is different from `valuesLength` +Usage guidelines: + +- `idsLength` MUST NOT be `valuesLength`. ### Parameter Glossary @@ -250,12 +289,12 @@ Considering this, the error names are designed following a basic grammatical str ### Actions and subjects -The main actions that can be performed within a token are: +An error is defined based on the following **actions** that can be performed on a token and its involved _subjects_: - **Transfer**: An operation in which a _sender_ moves to a _receiver_ any number of tokens (fungible _balance_ and/or non-fungible _token ids_). - **Approval**: An operation in which an _approver_ grants any form of _approval_ to an _operator_. -The subjects outlined above are expected to exhaustively represent _what_ can go wrong in a token transaction, deriving a specific error by adding an [error prefix](#error-prefixes). +These attempt to exhaustively represent what can go wrong in a token operation. Therefore, the errors can be constructed by specifying which _subject_ failed during an **action** execution, and prefixing with an [error prefix](#error-prefixes). Note that the action is never seen as the subject of an error. From 2f0b191a39d1436dc2f5b77c0b246b76f840efc4 Mon Sep 17 00:00:00 2001 From: Sam Wilson <57262657+SamWilsn@users.noreply.github.com> Date: Sat, 17 Jun 2023 19:43:18 -0400 Subject: [PATCH 88/97] Add IETF as a permissible origin (#7113) --- EIPS/eip-1.md | 18 ++++++++++++++++++ 1 file changed, 18 insertions(+) diff --git a/EIPS/eip-1.md b/EIPS/eip-1.md index 5f31c5916dc506..6962a93b5ced28 100644 --- a/EIPS/eip-1.md +++ b/EIPS/eip-1.md @@ -290,6 +290,24 @@ Permitted WHATWG specification URLs must anchor to a specification defined in th Although not recommended by WHATWG, EIPs must anchor to a particular commit so that future readers can refer to the exact version of the living standard that existed at the time the EIP was finalized. This gives readers sufficient information to maintain compatibility, if they so choose, with the version referenced by the EIP and the current living standard. +### Internet Engineering Task Force (IETF) + +Links to an IETF Request For Comment (RFC) specification may be included using normal markdown syntax, such as: + +```markdown +[RFC 8446](https://www.rfc-editor.org/rfc/rfc8446) +``` + +Which renders as: + +[RFC 8446](https://www.rfc-editor.org/rfc/rfc8446) + +Permitted IETF specification URLs MUST anchor to a specification with an assigned RFC number (meaning cannot reference internet drafts), and so MUST match this regular expression: + +```regex +^https:\/\/www.rfc-editor.org\/rfc\/.*$ +``` + ### Digital Object Identifier System Links qualified with a Digital Object Identifier (DOI) may be included using the following syntax: From a92f9abb195b2e8b00ccdb49c1d53fad4a9097a2 Mon Sep 17 00:00:00 2001 From: xinbenlv Date: Mon, 19 Jun 2023 11:29:23 -0400 Subject: [PATCH 89/97] Update EIP-1 to allow link to BIPs (#6907) Update eip-1.md Commit fixed regex Apply suggestions from code review Co-authored-by: Gavin John --- EIPS/eip-1.md | 18 ++++++++++++++++++ 1 file changed, 18 insertions(+) diff --git a/EIPS/eip-1.md b/EIPS/eip-1.md index 6962a93b5ced28..ebec1036d1bf5d 100644 --- a/EIPS/eip-1.md +++ b/EIPS/eip-1.md @@ -308,6 +308,24 @@ Permitted IETF specification URLs MUST anchor to a specification with an assigne ^https:\/\/www.rfc-editor.org\/rfc\/.*$ ``` +### Bitcoin Improvement Proposal + +Links to Bitcoin Improvement Proposals may be included using normal markdown syntax, such as: + +```markdown +[BIP 38](https://github.com/bitcoin/bips/blob/3db736243cd01389a4dfd98738204df1856dc5b9/bip-0038.mediawiki) +``` + +Which renders to: + +[BIP 38](https://github.com/bitcoin/bips/blob/3db736243cd01389a4dfd98738204df1856dc5b9/bip-0038.mediawiki) + +Permitted Bitcoin Improvement Proposal URLs must anchor to a specific commit, and so must match this regular expression: + +```regex +^(https://github.com/bitcoin/bips/blob/[0-9a-f]{40}/bip-[0-9]+\.mediawiki)$ +``` + ### Digital Object Identifier System Links qualified with a Digital Object Identifier (DOI) may be included using the following syntax: From ce0299d4d2f1a9ede2b69ceab4b01c1ec4401420 Mon Sep 17 00:00:00 2001 From: Bofu Chen Date: Mon, 19 Jun 2023 23:58:11 +0800 Subject: [PATCH 90/97] Add EIP: Interoperable Digital Media Indexing Merged by EIP-Bot. --- EIPS/eip-7053.md | 117 ++++++++++++++++++ ...ia-indexing-system-and-metadata-lookup.jpg | Bin 0 -> 81772 bytes 2 files changed, 117 insertions(+) create mode 100644 EIPS/eip-7053.md create mode 100644 assets/eip-7053/digital-media-indexing-system-and-metadata-lookup.jpg diff --git a/EIPS/eip-7053.md b/EIPS/eip-7053.md new file mode 100644 index 00000000000000..2daf5d5de54a43 --- /dev/null +++ b/EIPS/eip-7053.md @@ -0,0 +1,117 @@ +--- +eip: 7053 +title: Interoperable Digital Media Indexing +description: Interoperable Indexing of Digital Media on the EVM-compatible Blockchains. +author: Bofu Chen (@bafu), Tammy Yang (@tammyyang) +discussions-to: https://ethereum-magicians.org/t/eip-7053-interoperable-digital-media-indexing/14394 +status: Draft +type: Standards Track +category: ERC +created: 2023-05-22 +--- + +## Abstract + +This EIP proposes an interoperable indexing strategy designed to enhance the organization and retrieval of digital media information across multiple smart contracts and EVM-compatible blockchains. This system enhances the traceability and verification of cross-contract and cross-chain data, facilitating a more efficient discovery of storage locations and crucial information related to media assets. The major purpose is to foster an integrated digital media environment on the blockchain. + +## Motivation + +Given the significant role digital media files play on the Internet, it's crucial to have a robust and efficient method for indexing immutable information. Existing systems encounter challenges due to the absence of a universal, interoperable identifier for digital media content. This leads to fragmentation and complications in retrieving metadata, storage information, or the provenance of specific media assets. The issues become increasingly critical as the volume of digital media continues to expand. + +The motivation behind this EIP is to establish a standardized, decentralized, and interoperable approach to index digital media across EVM-compatible networks. By integrating Decentralized Content Identifiers (CIDs) and Commit events, this EIP puts forward a mechanism enabling unique identification and indexing of each digital media file. Moreover, this system suggests a way for users to access a complete history of data associated with digital media assets, from creation to the current status. This full view enhances transparency, thereby providing users with the necessary information for future interactions with digital media. + +This method creates a common interface that any digital media system can use to provide a standard way of indexing and searching their content. + +|| +|:--:| +| ![](../assets/eip-7053/digital-media-indexing-system-and-metadata-lookup.jpg) | +| Figure 1: Digital Media Indexing Relationships and Lookup | + +This EIP aims to create an interoperable indexing system to associate all data of the same digital content together (Figure 1). This will make it easier for users to find and trust digital media content, and it will also make it easier for systems to share and exchange information about this digital media content. + +## Specification + +The key words "MUST", "MUST NOT", "REQUIRED", "SHALL", "SHALL NOT", "SHOULD", "SHOULD NOT", "RECOMMENDED", "NOT RECOMMENDED", "MAY", and "OPTIONAL" in this document are to be interpreted as described in RFC 2119 and RFC 8174. + +### Content Identifier + +Content Identifier in this EIP is the the content address generated by passing the content of a digital media through a cryptographic hash function. Before the indexing process for digital media can begin, it is REQUIRED to generate unique Content Identifiers for each file. This identifier should the same as the Content Identifiers on the decentralized storage, ensuring each identifier provides access to the metadata, media information, and the content file itself. + +### Commit Function + +To index digital media, we shall call the commit function and generate Commit event: + +```solidity +/** + * @notice Emitted when a new commit is made. + * @param recorder The address of the account making the commit. + * @param assetCid The content identifier of the asset being committed. + * @param commitData The data associated with the commit. + */ +event Commit(address indexed recorder, string indexed assetCid, string commitData); + +/** + * @notice Registers a commit for an asset. + * Emits a Commit event and records the block number of the commit in the recordLogs mapping for the provided assetCid. + * @dev Emits a Commit event and logs the block number of the commit event. + * @param assetCid The content identifier of the asset being committed. + * @param commitData The data associated with the commit. + * @return The block number at which the commit was made. + */ +function commit(string memory assetCid, string memory commitData) public returns (uint256 blockNumber); +``` + +## Rationale + +The design decisions in this EIP prioritize the effectiveness and efficiency of the indexing method. To achieve this, Decentralized Content Identifiers (CIDs) are utilized to uniquely identify digital media content across all systems. This approach offers accurate and precise searching of media, along with the following benefits: + +1. Strengthened data integrity: CIDs serve as cryptographic hashes of the content, ensuring their uniqueness and preventing forgery. With the content in hand, obtaining the CID allows for searching relevant information associated with that content. + +2. Streamlined data portability: CIDs enable the seamless transfer of digital media content across different systems, eliminating the need for re-encoding or reconfiguration of protocols. This promotes a more interoperable and open indexing system. For example, in cases where Non-Fungible Tokens (NFTs) are created prior to Commit events, the digital media content can still be indexed by converting the file referenced by the tokenURI using the same mechanism. This conversion process ensures that the digital media content associated with NFT tokens can be indexed with a consistent identification approach. + +## Reference Implementation + +```solidity +// SPDX-License-Identifier: CC0-1.0 +pragma solidity ^0.8.4; + +import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol"; +import "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol"; + +contract CommitRegister is Initializable { + using ECDSA for bytes32; + + mapping(string => uint[]) public commitLogs; + + event Commit(address indexed recorder, string indexed assetCid, string commitData); + + function initialize() public initializer {} + + function commit(string memory assetCid, string memory commitData) public returns (uint256 blockNumber) { + emit Commit(msg.sender, assetCid, commitData); + commitLogs[assetCid].push(block.number); + return block.number; + } + + function getCommits(string memory assetCid) public view returns (uint[] memory) { + return commitLogs[assetCid]; + } +} +``` + +## Security Considerations + +When implementing this EIP, it's essential to address several security aspects to ensure the safety and integrity of the digital media index: + +1. Input Validation: Given that commit function accepts string parameters, it's important to validate these inputs to avoid potential injection attacks. Although such attacks are less common in smart contracts than traditional web development, caution should be exercised. + +2. Data Integrity: The commit function relies on CIDs, which are assumed to be correct and point to the right data. It's important to note that this EIP doesn't validate the content behind the CIDs and the commit data, which remains a responsibility of the users or implementing applications. + +3. Event Listening: Systems relying on listening to the Commit events for changes need to be aware of potential missed events or incorrect ordering, especially during periods of network congestion or reorganizations. + +Implementers should consider these security aspects in the context of their specific use case and deployment scenario. It is strongly recommended to perform a comprehensive security audit before deploying any implementation of this EIP to a live network. + + +## Copyright + +Copyright and related rights waived via [CC0](../LICENSE.md). diff --git a/assets/eip-7053/digital-media-indexing-system-and-metadata-lookup.jpg b/assets/eip-7053/digital-media-indexing-system-and-metadata-lookup.jpg new file mode 100644 index 0000000000000000000000000000000000000000..8afd23d2c4d9e58e43bccd964167981c7e24418b GIT binary patch literal 81772 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%0AZlri_jUYSyyXbeZTjm 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 DH&aPQ literal 0 HcmV?d00001 From 1fe0b2e1ee8c88ef1663dc16e8e4119b8d3f6ac3 Mon Sep 17 00:00:00 2001 From: Kevin Owocki Date: Mon, 19 Jun 2023 10:00:52 -0600 Subject: [PATCH 91/97] Add EIP: Contract Secured Revenue on an EVM based L2 Merged by EIP-Bot. --- EIPS/eip-6968.md | 94 ++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 94 insertions(+) create mode 100644 EIPS/eip-6968.md diff --git a/EIPS/eip-6968.md b/EIPS/eip-6968.md new file mode 100644 index 00000000000000..bdb1e0966732ae --- /dev/null +++ b/EIPS/eip-6968.md @@ -0,0 +1,94 @@ +--- +eip: 6968 +title: Contract Secured Revenue on an EVM based L2 +description: Contract Secured Revenue on an EVM based L2 +author: Zak Cole , Zak Cole (@zscole), Kevin Owocki , Lightclient +discussions-to: https://ethereum-magicians.org/t/eip-6968-generalized-csr-protocol/14178 +status: Draft +type: Standards Track +category: Core +created: 2023-05-01 +--- + +## Abstract + +Contract Secured Revenue (CSR) allows smart contract developers to claim a percentage of all transaction fees paid by users when interacting with their smart contracts. + +This EIP proposes the introduction of CSR on EVM-based L2s which would provide smart contract developers who deploy on L2s access to revenue streams and/or public goods. + +## Motivation + +Using protocol rewards of an L1 to fund smart contract development would be a big change to the way the current market works. This EIP *does not* advocate for any changes to the existing Ethereum L1. + +This EIP does advocate that L2s could begin to experiment with Contract Secured Revenue as a means of: + +1. creating a new revenue stream for smart contract developers +2. creating a new way of funding public goods +3. creating incentives for developers to deploy their dapps on your network + +## Specification + +### Parameters + +| Constant | Value | +|---|---| +| REVENUE_SHARE_QUOTIENT | 5 | + +### Fee Mechanism + +The current [EIP-1559](./eip-1559.md) fee behavior is modified so that `header.base_fee_per_gas * REVENUE_SHARE_QUOTIENT` per gas is reallocated proportionally, based on gas used, to each contract executed during the transaction. + +Implicitly, this means that no fees are redistributed to externally owned accounts (EOA). + +#### Gas Tracking + +In order to fairly distribute the fee revenue, a new transaction-wide gas tracker is defined. + +When executing a block, maintain a mapping `gas_used_by_address` of `address` to `uint64`. This will track the amount of gas used by each address. For every EVM instruction that does not instantiate a new execution frame (e.g. `CALL`, `CALLCODE`, `DELEGATECALL`, `STATICCALL`, `CREATE`, and `CREATE2`), add the cost of the instruction to the address' current sum in the mapping. + +For EVM instructions which do instantiate new frames, greater care must be taken to determine the cost of the instruction to the calling frame. For simplicity, this cost is defined to be the total cost of the operation minus the amount of gas passed to the child frame. The gas passed to the child frame is determined via [EIP-150](./eip-150.md). The computed cost is added to the address' current sum in the mapping. + +Additionally: + +- If the address does not exist in the mapping, it's total gas used is `0`. +- If the instructions throws an out-of-gas (OOG) error, all remaining gas allocated to execution frame is added to the current total gas used by the address. +- No other exceptional halt adds remaining gas to the counter for the address where the halt occurred. + +#### Setting Revenue Recipient + +Revenue recipients are tracked via a new transaction wide mapping `revenue_recipient` of `address` to `address`. The default value for every key is the key itself. For example, unless set otherwise, the key `0xdead...beef` maps to the value `0xdead...beef`. + +To set a different revenue recipient, a new instruction `SETREVENUERECIPIENT` is introduced with the opcode `0x49`. The operation takes `1` stack element as input and outputs `0` stack elements. + +The `20` least significant bytes of the input stack element is the address of the new revenue recipient for the instruction's caller. The `revenue_recipient` entry is updated to reflect this. + +The instruction costs `3` gas. + +#### Dispersing Revenue + +After a transaction completes, for every element (`addr`, `gas_used`) in `gas_used_by_address`, increase the balance of `revenue_recipient[addr]` by `gas_used * (header.base_fee_per_gas // REVENUE_SHARE_QUOTIENT)` + +## Rationale + +### Tracking Gas Proportionally + +A simpler mechanism would be to send the full transaction revenue to the `to` value of the transaction. This, however, does not accurately reward the composition of many different smart contracts and applications. Additionally, it is not compatible with smart contract wallets which, by definition, are often the first destination of a transaction. + +Maintaining a transaction wide tracker of gas uses makes it possible to distribute revenue to contracts which are genuinely the most utilized. + +### Ephemeral Revenue Recipient Mapping + +Constructing the revenue recipient mapping ephemerally during each transaction appears inefficient on the surface. This value is expected to be relatively static and even if it did need to change, the change could be facilitated by the recipient contract. + +Unfortunately such a change is much more invasive for the EVM. The recipient value would need to be stored somewhere. This would require a modification to the account structure in the state trie. Also, the recipient value would need to be set at some point. This would necessitate either a modification to the `CREATE*` opcodes or a new opcode, similar to `SETREVENUERECIPIENT`, that would be called by initcode to "initialize" the recipient value. + +## Security Considerations + +### Increased Max Block Size/Complexity + +Similar to EIP-1559, we must consider the effects this will have on block size. Depending on the method by which this is implemented, it could increase maximum block size in the event that a significant number of contracts opt-in to CSR. + + +## Copyright + +Copyright and related rights waived via [CC0](../LICENSE.md). From bc5433bee85fdc00124bf1e33c799938eedcd43f Mon Sep 17 00:00:00 2001 From: xhyumiracle Date: Tue, 20 Jun 2023 04:03:18 +0800 Subject: [PATCH 92/97] Add EIP: Zero-Knowledge AI-Generated Content Token Merged by EIP-Bot. --- EIPS/eip-7007.md | 164 + assets/eip-7007/.gitignore | 11 + assets/eip-7007/README.md | 55 + assets/eip-7007/contracts/ERC7007.sol | 79 + .../eip-7007/contracts/ERC7007Enumerable.sol | 54 + assets/eip-7007/contracts/IERC7007.sol | 48 + .../eip-7007/contracts/IERC7007Enumerable.sol | 20 + assets/eip-7007/contracts/IVerifier.sol | 9 + assets/eip-7007/contracts/MockVerifier.sol | 14 + assets/eip-7007/hardhat.config.js | 6 + assets/eip-7007/package-lock.json | 16534 ++++++++++++++++ assets/eip-7007/package.json | 17 + assets/eip-7007/test/test.js | 90 + 13 files changed, 17101 insertions(+) create mode 100644 EIPS/eip-7007.md create mode 100644 assets/eip-7007/.gitignore create mode 100644 assets/eip-7007/README.md create mode 100644 assets/eip-7007/contracts/ERC7007.sol create mode 100644 assets/eip-7007/contracts/ERC7007Enumerable.sol create mode 100644 assets/eip-7007/contracts/IERC7007.sol create mode 100644 assets/eip-7007/contracts/IERC7007Enumerable.sol create mode 100644 assets/eip-7007/contracts/IVerifier.sol create mode 100644 assets/eip-7007/contracts/MockVerifier.sol create mode 100644 assets/eip-7007/hardhat.config.js create mode 100644 assets/eip-7007/package-lock.json create mode 100644 assets/eip-7007/package.json create mode 100644 assets/eip-7007/test/test.js diff --git a/EIPS/eip-7007.md b/EIPS/eip-7007.md new file mode 100644 index 00000000000000..1f439f0085ceb9 --- /dev/null +++ b/EIPS/eip-7007.md @@ -0,0 +1,164 @@ +--- +eip: 7007 +title: Zero-Knowledge AI-Generated Content Token +description: An ERC-721 extension interface for zkML based AIGC-NFTs. +author: Cathie So (@socathie), Xiaohang Yu (@xhyumiracle), Huaizhe Xu (@HuaizheXu), Kartin +discussions-to: https://ethereum-magicians.org/t/eip-7007-zkml-aigc-nfts-an-erc-721-extension-interface-for-zkml-based-aigc-nfts/14216 +status: Draft +type: Standards Track +category: ERC +created: 2023-05-10 +requires: 165, 721 +--- + +## Abstract + +The Zero-Knowledge Machine Lerning (zkML) AI-Generated Content (AIGC) non-fungible token (NFT) standard is an extension of the [ERC-721](./eip-721.md) token standard for AIGC. It proposes a set of interfaces for basic interactions and enumerable interactions for AIGC-NFTs. The standard includes a new mint event and a JSON schema for AIGC-NFT metadata. Additionally, it incorporates zkML capabilities to enable verification of AIGC-NFT ownership. In this standard, the `tokenId` is indexed by the `prompt`. + +## Motivation + +The zkML AIGC-NFTs standard aims to extend the existing [ERC-721](./eip-721.md) token standard to accommodate the unique requirements of AI-Generated Content NFTs representing models in a collection. This standard provides interfaces to use zkML to verify whether or not the AIGC data for an NFT is generated from a certain ML model with certain input (prompt). The proposed interfaces allow for additional functionality related to minting, verifying, and enumerating AIGC-NFTs. Additionally, the metadata schema provides a structured format for storing information related to AIGC-NFTs, such as the prompt used to generate the content and the proof of ownership. + +With this standard, model owners can publish their trained model and its ZKP verifier to Ethereum. Any user can claim an input (prompt) and publish the inference task, any node that maintains the model and the proving circuit can perform the inference and proving, then submit the output of inference and the ZK proof for the inference trace into the verifier that is deployed by the model owner. The user that initiates the inference task will own the output for the inference of that model and input (prompt). + +## Specification + +The keywords "MUST", "MUST NOT", "REQUIRED", "SHALL", "SHALL NOT", "SHOULD", "SHOULD NOT", "RECOMMENDED", "NOT RECOMMENDED", "MAY", and "OPTIONAL" in this document are to be interpreted as described in RFC 2119 and RFC 8174. + +**Every compliant contract must implement the [ERC-7007](./eip-7007.md), [ERC-721](./eip-721.md), and [ERC-165](./eip-165.md) interfaces.** + +The zkML AIGC-NFTs standard includes the following interfaces: + +`IERC7007`: Defines a mint event and a mint function for minting AIGC-NFTs. It also includes a verify function to check the validity of a combination of prompt and proof using zkML techniques. + +```solidity +pragma solidity ^0.8.18; + +/** + * @dev Required interface of an ERC7007 compliant contract. + * Note: the ERC-165 identifier for this interface is 0x7e52e423. + */ +interface IERC7007 is IERC165, IERC721 { + /** + * @dev Emitted when `tokenId` token is minted. + */ + event Mint( + uint256 indexed tokenId, + bytes indexed prompt, + bytes indexed aigcData, + string uri, + bytes proof + ); + + /** + * @dev Mint token at `tokenId` given `prompt`, `aigcData`, `uri` and `proof`. + * + * Requirements: + * - `tokenId` must not exist.' + * - verify(`prompt`, `aigcData`, `proof`) must return true. + * + * Optional: + * - `proof` should not include `aigcData` to save gas. + */ + function mint( + bytes calldata prompt, + bytes calldata aigcData, + string calldata uri, + bytes calldata proof + ) external returns (uint256 tokenId); + + /** + * @dev Verify the `prompt`, `aigcData` and `proof`. + */ + function verify( + bytes calldata prompt, + bytes calldata aigcData, + bytes calldata proof + ) external view returns (bool success); +} +``` + +Optional Extension: Enumerable + +The **enumeration extension** is OPTIONAL for [ERC-7007](./eip-7007.md) smart contracts. This allows your contract to publish its full list of mapping between `tokenId` and `prompt` and make them discoverable. + +```solidity +pragma solidity ^0.8.18; + +/** + * @title ERC7007 Token Standard, optional enumeration extension + * Note: the ERC-165 identifier for this interface is 0xfa1a557a. + */ +interface IERC7007Enumerable is IERC7007 { + /** + * @dev Returns the token ID given `prompt`. + */ + function tokenId(bytes calldata prompt) external view returns (uint256); + + /** + * @dev Returns the prompt given `tokenId`. + */ + function prompt(uint256 tokenId) external view returns (string calldata); +} +``` + +ERC-7007 Metadata JSON Schema for reference + +```json +{ + "title": "AIGC Metadata", + "type": "object", + "properties": { + "name": { + "type": "string", + "description": "Identifies the asset to which this NFT represents" + }, + "description": { + "type": "string", + "description": "Describes the asset to which this NFT represents" + }, + "image": { + "type": "string", + "description": "A URI pointing to a resource with mime type image/* representing the asset to which this NFT represents. Consider making any images at a width between 320 and 1080 pixels and aspect ratio between 1.91:1 and 4:5 inclusive." + }, + + "prompt": { + "type": "string", + "description": "Identifies the prompt from which this AIGC NFT generated" + }, + "aigc_type": { + "type": "string", + "description": "image/video/audio..." + }, + "aigc_data": { + "type": "string", + "description": "A URI pointing to a resource with mime type image/* representing the asset to which this AIGC NFT represents." + } + } +} +``` + +## Rationale + +TBD + +## Backwards Compatibility + +This standard is backward compatible with the [ERC-721](./eip-721.md) as it extends the existing functionality with new interfaces. + +## Test Cases + +The reference implementation includes sample implementations of the [ERC-7007](./eip-7007.md) interfaces under `contracts/` and corresponding unit tests under `test/`. This repo can be used to test the functionality of the proposed interfaces and metadata schema. + +## Reference Implementation + +* [ERC-7007](../assets/eip-7007/contracts/ERC7007.sol) +* [ERC-7007 Enumerable Extension](../assets/eip-7007/contracts/ERC7007Enumerable.sol) + +## Security Considerations + +Needs discussion. + +## Copyright + +Copyright and related rights waived via [CC0](../LICENSE.md). diff --git a/assets/eip-7007/.gitignore b/assets/eip-7007/.gitignore new file mode 100644 index 00000000000000..00dad773492c83 --- /dev/null +++ b/assets/eip-7007/.gitignore @@ -0,0 +1,11 @@ +node_modules +.env +coverage +coverage.json +typechain +typechain-types + +# Hardhat files +cache +artifacts + diff --git a/assets/eip-7007/README.md b/assets/eip-7007/README.md new file mode 100644 index 00000000000000..cc8e3a0f2fb7c8 --- /dev/null +++ b/assets/eip-7007/README.md @@ -0,0 +1,55 @@ +# ERC-7007 Reference Implementation + +This is a WIP implementation of ERC-7007 based on the discussions in the [EIP-7007 issue thread](https://github.com/ethereum/EIPs/issues/7007). + +## Setup +Run `npm install` in the root directory. + +## Testing +Try running some of the following tasks: + +```shell +npx hardhat help +npx hardhat test +REPORT_GAS=true npx hardhat test +``` + +## Metadata Standard + +```json +{ + "title": "AIGC Metadata", + "type": "object", + "properties": { + "name": { + "type": "string", + "description": "Identifies the asset to which this NFT represents" + }, + "description": { + "type": "string", + "description": "Describes the asset to which this NFT represents" + }, + "image": { + "type": "string", + "description": "A URI pointing to a resource with mime type image/* representing the asset to which this NFT represents. Consider making any images at a width between 320 and 1080 pixels and aspect ratio between 1.91:1 and 4:5 inclusive." + }, + + "prompt": { + "type": "string", + "description": "Identifies the prompt from which this AIGC NFT generated" + }, + "seed": { + "type": "uint256", + "description": "Identifies the seed from which this AIGC NFT generated" + }, + "aigc_type": { + "type": "string", + "description": "image/video/audio..." + }, + "aigc_data": { + "type": "string", + "description": "A URI pointing to a resource with mime type image/* representing the asset to which this AIGC NFT represents. Consider making any images at a width between 320 and 1080 pixels and aspect ratio between 1.91:1 and 4:5 inclusive." + } + } +} +``` \ No newline at end of file diff --git a/assets/eip-7007/contracts/ERC7007.sol b/assets/eip-7007/contracts/ERC7007.sol new file mode 100644 index 00000000000000..5610225acc64b1 --- /dev/null +++ b/assets/eip-7007/contracts/ERC7007.sol @@ -0,0 +1,79 @@ +// SPDX-License-Identifier: UNLICENSED +pragma solidity ^0.8.18; + +import "@openzeppelin/contracts/utils/introspection/ERC165.sol"; +import "@openzeppelin/contracts/token/ERC721/extensions/ERC721URIStorage.sol"; +import "./IERC7007.sol"; +import "./IVerifier.sol"; + +/** + * @dev Implementation of the {IERC7007} interface. + */ +contract ERC7007 is ERC165, IERC7007, ERC721URIStorage { + address public immutable verifier; + + /** + * @dev Initializes the contract by setting a `name` and a `symbol` to the token collection. + */ + constructor( + string memory name_, + string memory symbol_, + address verifier_ + ) ERC721(name_, symbol_) { + verifier = verifier_; + } + + /** + * @dev See {IERC7007-mint}. + */ + function mint( + bytes calldata prompt, + bytes calldata aigcData, + string calldata uri, + bytes calldata proof + ) public virtual override returns (uint256 tokenId) { + require(verify(prompt, aigcData, proof), "ERC7007: invalid proof"); + tokenId = uint256(keccak256(prompt)); + _safeMint(msg.sender, tokenId); + string memory tokenUri = string( + abi.encodePacked( + "{", + uri, + ', "prompt": "', + string(prompt), + '", "aigc_data": "', + string(aigcData), + '"}' + ) + ); + _setTokenURI(tokenId, tokenUri); + emit Mint(tokenId, prompt, aigcData, uri, proof); + } + + /** + * @dev See {IERC7007-verify}. + */ + function verify( + bytes calldata prompt, + bytes calldata aigcData, + bytes calldata proof + ) public view virtual override returns (bool success) { + return + IVerifier(verifier).verifyProof( + proof, + abi.encodePacked(prompt, aigcData) + ); + } + + /** + * @dev See {IERC165-supportsInterface}. + */ + function supportsInterface( + bytes4 interfaceId + ) public view virtual override(ERC165, ERC721, IERC165) returns (bool) { + return + interfaceId == type(IERC721).interfaceId || + interfaceId == type(IERC721Metadata).interfaceId || + super.supportsInterface(interfaceId); + } +} diff --git a/assets/eip-7007/contracts/ERC7007Enumerable.sol b/assets/eip-7007/contracts/ERC7007Enumerable.sol new file mode 100644 index 00000000000000..d8baed3210bb53 --- /dev/null +++ b/assets/eip-7007/contracts/ERC7007Enumerable.sol @@ -0,0 +1,54 @@ +// SPDX-License-Identifier: UNLICENSED +pragma solidity ^0.8.18; + +import "./ERC7007.sol"; +import "./IERC7007Enumerable.sol"; + +/** + * @dev Implementation of the {IERC7007Enumerable} interface. + */ +abstract contract ERC7007Enumerable is ERC7007, IERC7007Enumerable { + /** + * @dev See {IERC7007Enumerable-tokenId}. + */ + mapping(uint256 => string) public prompt; + + + /** + * @dev See {IERC7007Enumerable-prompt}. + */ + mapping(bytes => uint256) public tokenId; + + /** + * @dev See {IERC165-supportsInterface}. + */ + function supportsInterface( + bytes4 interfaceId + ) public view virtual override(IERC165, ERC7007) returns (bool) { + return + interfaceId == type(IERC7007Enumerable).interfaceId || + super.supportsInterface(interfaceId); + } + + /** + * @dev See {IERC7007-mint}. + */ + function mint( + bytes calldata prompt_, + bytes calldata aigcData, + string calldata uri, + bytes calldata proof + ) public virtual override(ERC7007, IERC7007) returns (uint256 tokenId_) { + tokenId_ = ERC7007.mint(prompt_, aigcData, uri, proof); + prompt[tokenId_] = string(prompt_); + tokenId[prompt_] = tokenId_; + } +} + +contract MockERC7007Enumerable is ERC7007Enumerable { + constructor( + string memory name_, + string memory symbol_, + address verifier_ + ) ERC7007(name_, symbol_, verifier_) {} +} \ No newline at end of file diff --git a/assets/eip-7007/contracts/IERC7007.sol b/assets/eip-7007/contracts/IERC7007.sol new file mode 100644 index 00000000000000..359b6b626d6318 --- /dev/null +++ b/assets/eip-7007/contracts/IERC7007.sol @@ -0,0 +1,48 @@ +// SPDX-License-Identifier: UNLICENSED +pragma solidity ^0.8.18; + +import "@openzeppelin/contracts/utils/introspection/IERC165.sol"; +import "@openzeppelin/contracts/token/ERC721/IERC721.sol"; + +/** + * @dev Required interface of an ERC7007 compliant contract. + * Note: the ERC-165 identifier for this interface is 0x7e52e423. + */ +interface IERC7007 is IERC165, IERC721 { + /** + * @dev Emitted when `tokenId` token is minted. + */ + event Mint( + uint256 indexed tokenId, + bytes indexed prompt, + bytes indexed aigcData, + string uri, + bytes proof + ); + + /** + * @dev Mint token at `tokenId` given `prompt`, `aigcData`, `uri` and `proof`. + * + * Requirements: + * - `tokenId` must not exist.' + * - verify(`prompt`, `aigcData`, `proof`) must return true. + * + * Optional: + * - `proof` should not include `aigcData` to save gas. + */ + function mint( + bytes calldata prompt, + bytes calldata aigcData, + string calldata uri, + bytes calldata proof + ) external returns (uint256 tokenId); + + /** + * @dev Verify the `prompt`, `aigcData` and `proof`. + */ + function verify( + bytes calldata prompt, + bytes calldata aigcData, + bytes calldata proof + ) external view returns (bool success); +} diff --git a/assets/eip-7007/contracts/IERC7007Enumerable.sol b/assets/eip-7007/contracts/IERC7007Enumerable.sol new file mode 100644 index 00000000000000..6055402b80ef5d --- /dev/null +++ b/assets/eip-7007/contracts/IERC7007Enumerable.sol @@ -0,0 +1,20 @@ +// SPDX-License-Identifier: UNLICENSED +pragma solidity ^0.8.18; + +import "./IERC7007.sol"; + +/** + * @title ERC7007 Token Standard, optional enumeration extension + * Note: the ERC-165 identifier for this interface is 0xfa1a557a. + */ +interface IERC7007Enumerable is IERC7007 { + /** + * @dev Returns the token ID given `prompt`. + */ + function tokenId(bytes calldata prompt) external view returns (uint256); + + /** + * @dev Returns the prompt given `tokenId`. + */ + function prompt(uint256 tokenId) external view returns (string calldata); +} diff --git a/assets/eip-7007/contracts/IVerifier.sol b/assets/eip-7007/contracts/IVerifier.sol new file mode 100644 index 00000000000000..3d918c70ba0c3c --- /dev/null +++ b/assets/eip-7007/contracts/IVerifier.sol @@ -0,0 +1,9 @@ +// SPDX-License-Identifier: UNLICENSED +pragma solidity ^0.8.18; + +interface IVerifier { + function verifyProof( + bytes calldata proof, + bytes calldata public_inputs + ) external view returns (bool valid); +} diff --git a/assets/eip-7007/contracts/MockVerifier.sol b/assets/eip-7007/contracts/MockVerifier.sol new file mode 100644 index 00000000000000..4c1a7712729900 --- /dev/null +++ b/assets/eip-7007/contracts/MockVerifier.sol @@ -0,0 +1,14 @@ +// SPDX-License-Identifier: UNLICENSED +pragma solidity ^0.8.18; + +import "./IVerifier.sol"; + +contract MockVerifier is IVerifier { + function verifyProof( + bytes calldata proof, + bytes calldata public_inputs + ) external pure override returns (bool valid) { + return + public_inputs.length > 0 && keccak256(proof) == keccak256("valid"); + } +} diff --git a/assets/eip-7007/hardhat.config.js b/assets/eip-7007/hardhat.config.js new file mode 100644 index 00000000000000..d5dd5f4e8ddd41 --- /dev/null +++ b/assets/eip-7007/hardhat.config.js @@ -0,0 +1,6 @@ +require("@nomicfoundation/hardhat-toolbox"); + +/** @type import('hardhat/config').HardhatUserConfig */ +module.exports = { + solidity: "0.8.18", +}; diff --git a/assets/eip-7007/package-lock.json b/assets/eip-7007/package-lock.json new file mode 100644 index 00000000000000..db6776ab742300 --- /dev/null +++ b/assets/eip-7007/package-lock.json @@ -0,0 +1,16534 @@ +{ + "name": "erc7007", + "version": "1.0.0", + "lockfileVersion": 2, + "requires": true, + "packages": { + "": { + "name": "erc7007", + "version": "1.0.0", + "license": "ISC", + "devDependencies": { + "@nomicfoundation/hardhat-toolbox": "^2.0.2", + "@openzeppelin/contracts": "^4.8.3", + "hardhat": "^2.14.0" + } + }, + "node_modules/@chainsafe/as-sha256": { + "version": "0.3.1", + "resolved": "https://registry.npmjs.org/@chainsafe/as-sha256/-/as-sha256-0.3.1.tgz", + "integrity": "sha512-hldFFYuf49ed7DAakWVXSJODuq3pzJEguD8tQ7h+sGkM18vja+OFoJI9krnGmgzyuZC2ETX0NOIcCTy31v2Mtg==", + "dev": true + }, + "node_modules/@chainsafe/persistent-merkle-tree": { + "version": "0.4.2", + "resolved": "https://registry.npmjs.org/@chainsafe/persistent-merkle-tree/-/persistent-merkle-tree-0.4.2.tgz", + "integrity": "sha512-lLO3ihKPngXLTus/L7WHKaw9PnNJWizlOF1H9NNzHP6Xvh82vzg9F2bzkXhYIFshMZ2gTCEz8tq6STe7r5NDfQ==", + "dev": true, + "dependencies": { + "@chainsafe/as-sha256": "^0.3.1" + } + }, + "node_modules/@chainsafe/ssz": { + "version": "0.9.4", + "resolved": "https://registry.npmjs.org/@chainsafe/ssz/-/ssz-0.9.4.tgz", + "integrity": "sha512-77Qtg2N1ayqs4Bg/wvnWfg5Bta7iy7IRh8XqXh7oNMeP2HBbBwx8m6yTpA8p0EHItWPEBkgZd5S5/LSlp3GXuQ==", + "dev": true, + "dependencies": { + "@chainsafe/as-sha256": "^0.3.1", + "@chainsafe/persistent-merkle-tree": "^0.4.2", + "case": "^1.6.3" + } + }, + "node_modules/@cspotcode/source-map-support": { + "version": "0.8.1", + "resolved": "https://registry.npmjs.org/@cspotcode/source-map-support/-/source-map-support-0.8.1.tgz", + "integrity": "sha512-IchNf6dN4tHoMFIn/7OE8LWZ19Y6q/67Bmf6vnGREv8RSbBVb9LPJxEcnwrcwX6ixSvaiGoomAUvu4YSxXrVgw==", + "dev": true, + "peer": true, + "dependencies": { + "@jridgewell/trace-mapping": "0.3.9" + }, + "engines": { + "node": ">=12" + } + }, + "node_modules/@ethersproject/abi": { + "version": "5.7.0", + "resolved": "https://registry.npmjs.org/@ethersproject/abi/-/abi-5.7.0.tgz", + "integrity": "sha512-351ktp42TiRcYB3H1OP8yajPeAQstMW/yCFokj/AthP9bLHzQFPlOrxOcwYEDkUAICmOHljvN4K39OMTMUa9RA==", + "dev": true, + "funding": [ + { + "type": "individual", + "url": "https://gitcoin.co/grants/13/ethersjs-complete-simple-and-tiny-2" + }, + { + "type": "individual", + "url": "https://www.buymeacoffee.com/ricmoo" + } + ], + "dependencies": { + "@ethersproject/address": "^5.7.0", + "@ethersproject/bignumber": "^5.7.0", + "@ethersproject/bytes": "^5.7.0", + "@ethersproject/constants": "^5.7.0", + "@ethersproject/hash": "^5.7.0", + "@ethersproject/keccak256": "^5.7.0", + "@ethersproject/logger": "^5.7.0", + "@ethersproject/properties": "^5.7.0", + "@ethersproject/strings": "^5.7.0" + } + }, + "node_modules/@ethersproject/abstract-provider": { + "version": "5.7.0", + "resolved": "https://registry.npmjs.org/@ethersproject/abstract-provider/-/abstract-provider-5.7.0.tgz", + "integrity": "sha512-R41c9UkchKCpAqStMYUpdunjo3pkEvZC3FAwZn5S5MGbXoMQOHIdHItezTETxAO5bevtMApSyEhn9+CHcDsWBw==", + "dev": true, + "funding": [ + { + "type": "individual", + "url": "https://gitcoin.co/grants/13/ethersjs-complete-simple-and-tiny-2" + }, + { + "type": "individual", + "url": "https://www.buymeacoffee.com/ricmoo" + } + ], + "dependencies": { + "@ethersproject/bignumber": "^5.7.0", + "@ethersproject/bytes": "^5.7.0", + "@ethersproject/logger": "^5.7.0", + "@ethersproject/networks": "^5.7.0", + "@ethersproject/properties": "^5.7.0", + "@ethersproject/transactions": "^5.7.0", + "@ethersproject/web": "^5.7.0" + } + }, + "node_modules/@ethersproject/abstract-signer": { + "version": "5.7.0", + "resolved": "https://registry.npmjs.org/@ethersproject/abstract-signer/-/abstract-signer-5.7.0.tgz", + "integrity": "sha512-a16V8bq1/Cz+TGCkE2OPMTOUDLS3grCpdjoJCYNnVBbdYEMSgKrU0+B90s8b6H+ByYTBZN7a3g76jdIJi7UfKQ==", + "dev": true, + "funding": [ + { + "type": "individual", + "url": "https://gitcoin.co/grants/13/ethersjs-complete-simple-and-tiny-2" + }, + { + "type": "individual", + "url": "https://www.buymeacoffee.com/ricmoo" + } + ], + "dependencies": { + "@ethersproject/abstract-provider": "^5.7.0", + "@ethersproject/bignumber": "^5.7.0", + "@ethersproject/bytes": "^5.7.0", + "@ethersproject/logger": "^5.7.0", + "@ethersproject/properties": "^5.7.0" + } + }, + "node_modules/@ethersproject/address": { + "version": "5.7.0", + "resolved": "https://registry.npmjs.org/@ethersproject/address/-/address-5.7.0.tgz", + "integrity": "sha512-9wYhYt7aghVGo758POM5nqcOMaE168Q6aRLJZwUmiqSrAungkG74gSSeKEIR7ukixesdRZGPgVqme6vmxs1fkA==", + "dev": true, + "funding": [ + { + "type": "individual", + "url": "https://gitcoin.co/grants/13/ethersjs-complete-simple-and-tiny-2" + }, + { + "type": "individual", + "url": "https://www.buymeacoffee.com/ricmoo" + } + ], + "dependencies": { + "@ethersproject/bignumber": "^5.7.0", + "@ethersproject/bytes": "^5.7.0", + "@ethersproject/keccak256": "^5.7.0", + "@ethersproject/logger": "^5.7.0", + "@ethersproject/rlp": "^5.7.0" + } + }, + "node_modules/@ethersproject/base64": { + "version": "5.7.0", + "resolved": "https://registry.npmjs.org/@ethersproject/base64/-/base64-5.7.0.tgz", + "integrity": "sha512-Dr8tcHt2mEbsZr/mwTPIQAf3Ai0Bks/7gTw9dSqk1mQvhW3XvRlmDJr/4n+wg1JmCl16NZue17CDh8xb/vZ0sQ==", + "dev": true, + "funding": [ + { + "type": "individual", + "url": "https://gitcoin.co/grants/13/ethersjs-complete-simple-and-tiny-2" + }, + { + "type": "individual", + "url": "https://www.buymeacoffee.com/ricmoo" + } + ], + "dependencies": { + "@ethersproject/bytes": "^5.7.0" + } + }, + "node_modules/@ethersproject/basex": { + "version": "5.7.0", + "resolved": "https://registry.npmjs.org/@ethersproject/basex/-/basex-5.7.0.tgz", + "integrity": "sha512-ywlh43GwZLv2Voc2gQVTKBoVQ1mti3d8HK5aMxsfu/nRDnMmNqaSJ3r3n85HBByT8OpoY96SXM1FogC533T4zw==", + "dev": true, + "funding": [ + { + "type": "individual", + "url": "https://gitcoin.co/grants/13/ethersjs-complete-simple-and-tiny-2" + }, + { + "type": "individual", + "url": "https://www.buymeacoffee.com/ricmoo" + } + ], + "dependencies": { + "@ethersproject/bytes": "^5.7.0", + "@ethersproject/properties": "^5.7.0" + } + }, + "node_modules/@ethersproject/bignumber": { + "version": "5.7.0", + "resolved": "https://registry.npmjs.org/@ethersproject/bignumber/-/bignumber-5.7.0.tgz", + "integrity": "sha512-n1CAdIHRWjSucQO3MC1zPSVgV/6dy/fjL9pMrPP9peL+QxEg9wOsVqwD4+818B6LUEtaXzVHQiuivzRoxPxUGw==", + "dev": true, + "funding": [ + { + "type": "individual", + "url": "https://gitcoin.co/grants/13/ethersjs-complete-simple-and-tiny-2" + }, + { + "type": "individual", + "url": "https://www.buymeacoffee.com/ricmoo" + } + ], + "dependencies": { + "@ethersproject/bytes": "^5.7.0", + "@ethersproject/logger": "^5.7.0", + "bn.js": "^5.2.1" + } + }, + "node_modules/@ethersproject/bytes": { + "version": "5.7.0", + "resolved": "https://registry.npmjs.org/@ethersproject/bytes/-/bytes-5.7.0.tgz", + "integrity": "sha512-nsbxwgFXWh9NyYWo+U8atvmMsSdKJprTcICAkvbBffT75qDocbuggBU0SJiVK2MuTrp0q+xvLkTnGMPK1+uA9A==", + "dev": true, + "funding": [ + { + "type": "individual", + "url": "https://gitcoin.co/grants/13/ethersjs-complete-simple-and-tiny-2" + }, + { + "type": "individual", + "url": "https://www.buymeacoffee.com/ricmoo" + } + ], + "dependencies": { + "@ethersproject/logger": "^5.7.0" + } + }, + "node_modules/@ethersproject/constants": { + "version": "5.7.0", + "resolved": "https://registry.npmjs.org/@ethersproject/constants/-/constants-5.7.0.tgz", + "integrity": "sha512-DHI+y5dBNvkpYUMiRQyxRBYBefZkJfo70VUkUAsRjcPs47muV9evftfZ0PJVCXYbAiCgght0DtcF9srFQmIgWA==", + "dev": true, + "funding": [ + { + "type": "individual", + "url": "https://gitcoin.co/grants/13/ethersjs-complete-simple-and-tiny-2" + }, + { + "type": "individual", + "url": "https://www.buymeacoffee.com/ricmoo" + } + ], + "dependencies": { + "@ethersproject/bignumber": "^5.7.0" + } + }, + "node_modules/@ethersproject/contracts": { + "version": "5.7.0", + "resolved": "https://registry.npmjs.org/@ethersproject/contracts/-/contracts-5.7.0.tgz", + "integrity": "sha512-5GJbzEU3X+d33CdfPhcyS+z8MzsTrBGk/sc+G+59+tPa9yFkl6HQ9D6L0QMgNTA9q8dT0XKxxkyp883XsQvbbg==", + "dev": true, + "funding": [ + { + "type": "individual", + "url": "https://gitcoin.co/grants/13/ethersjs-complete-simple-and-tiny-2" + }, + { + "type": "individual", + "url": "https://www.buymeacoffee.com/ricmoo" + } + ], + "dependencies": { + "@ethersproject/abi": "^5.7.0", + "@ethersproject/abstract-provider": "^5.7.0", + "@ethersproject/abstract-signer": "^5.7.0", + "@ethersproject/address": "^5.7.0", + "@ethersproject/bignumber": "^5.7.0", + "@ethersproject/bytes": "^5.7.0", + "@ethersproject/constants": "^5.7.0", + "@ethersproject/logger": "^5.7.0", + "@ethersproject/properties": "^5.7.0", + "@ethersproject/transactions": "^5.7.0" + } + }, + "node_modules/@ethersproject/hash": { + "version": "5.7.0", + "resolved": "https://registry.npmjs.org/@ethersproject/hash/-/hash-5.7.0.tgz", + "integrity": "sha512-qX5WrQfnah1EFnO5zJv1v46a8HW0+E5xuBBDTwMFZLuVTx0tbU2kkx15NqdjxecrLGatQN9FGQKpb1FKdHCt+g==", + "dev": true, + "funding": [ + { + "type": "individual", + "url": "https://gitcoin.co/grants/13/ethersjs-complete-simple-and-tiny-2" + }, + { + "type": "individual", + "url": "https://www.buymeacoffee.com/ricmoo" + } + ], + "dependencies": { + "@ethersproject/abstract-signer": "^5.7.0", + "@ethersproject/address": "^5.7.0", + "@ethersproject/base64": "^5.7.0", + "@ethersproject/bignumber": "^5.7.0", + "@ethersproject/bytes": "^5.7.0", + "@ethersproject/keccak256": "^5.7.0", + "@ethersproject/logger": "^5.7.0", + "@ethersproject/properties": "^5.7.0", + "@ethersproject/strings": "^5.7.0" + } + }, + "node_modules/@ethersproject/hdnode": { + "version": "5.7.0", + "resolved": "https://registry.npmjs.org/@ethersproject/hdnode/-/hdnode-5.7.0.tgz", + "integrity": "sha512-OmyYo9EENBPPf4ERhR7oj6uAtUAhYGqOnIS+jE5pTXvdKBS99ikzq1E7Iv0ZQZ5V36Lqx1qZLeak0Ra16qpeOg==", + "dev": true, + "funding": [ + { + "type": "individual", + "url": "https://gitcoin.co/grants/13/ethersjs-complete-simple-and-tiny-2" + }, + { + "type": "individual", + "url": "https://www.buymeacoffee.com/ricmoo" + } + ], + "dependencies": { + "@ethersproject/abstract-signer": "^5.7.0", + "@ethersproject/basex": "^5.7.0", + "@ethersproject/bignumber": "^5.7.0", + "@ethersproject/bytes": "^5.7.0", + "@ethersproject/logger": "^5.7.0", + "@ethersproject/pbkdf2": "^5.7.0", + "@ethersproject/properties": "^5.7.0", + "@ethersproject/sha2": "^5.7.0", + "@ethersproject/signing-key": "^5.7.0", + "@ethersproject/strings": "^5.7.0", + "@ethersproject/transactions": "^5.7.0", + "@ethersproject/wordlists": "^5.7.0" + } + }, + "node_modules/@ethersproject/json-wallets": { + "version": "5.7.0", + "resolved": "https://registry.npmjs.org/@ethersproject/json-wallets/-/json-wallets-5.7.0.tgz", + "integrity": "sha512-8oee5Xgu6+RKgJTkvEMl2wDgSPSAQ9MB/3JYjFV9jlKvcYHUXZC+cQp0njgmxdHkYWn8s6/IqIZYm0YWCjO/0g==", + "dev": true, + "funding": [ + { + "type": "individual", + "url": "https://gitcoin.co/grants/13/ethersjs-complete-simple-and-tiny-2" + }, + { + "type": "individual", + "url": "https://www.buymeacoffee.com/ricmoo" + } + ], + "dependencies": { + "@ethersproject/abstract-signer": "^5.7.0", + "@ethersproject/address": "^5.7.0", + "@ethersproject/bytes": "^5.7.0", + "@ethersproject/hdnode": "^5.7.0", + "@ethersproject/keccak256": "^5.7.0", + "@ethersproject/logger": "^5.7.0", + "@ethersproject/pbkdf2": "^5.7.0", + "@ethersproject/properties": "^5.7.0", + "@ethersproject/random": "^5.7.0", + "@ethersproject/strings": "^5.7.0", + "@ethersproject/transactions": "^5.7.0", + "aes-js": "3.0.0", + "scrypt-js": "3.0.1" + } + }, + "node_modules/@ethersproject/keccak256": { + "version": "5.7.0", + "resolved": "https://registry.npmjs.org/@ethersproject/keccak256/-/keccak256-5.7.0.tgz", + "integrity": "sha512-2UcPboeL/iW+pSg6vZ6ydF8tCnv3Iu/8tUmLLzWWGzxWKFFqOBQFLo6uLUv6BDrLgCDfN28RJ/wtByx+jZ4KBg==", + "dev": true, + "funding": [ + { + "type": "individual", + "url": "https://gitcoin.co/grants/13/ethersjs-complete-simple-and-tiny-2" + }, + { + "type": "individual", + "url": "https://www.buymeacoffee.com/ricmoo" + } + ], + "dependencies": { + "@ethersproject/bytes": "^5.7.0", + "js-sha3": "0.8.0" + } + }, + "node_modules/@ethersproject/logger": { + "version": "5.7.0", + "resolved": "https://registry.npmjs.org/@ethersproject/logger/-/logger-5.7.0.tgz", + "integrity": "sha512-0odtFdXu/XHtjQXJYA3u9G0G8btm0ND5Cu8M7i5vhEcE8/HmF4Lbdqanwyv4uQTr2tx6b7fQRmgLrsnpQlmnig==", + "dev": true, + "funding": [ + { + "type": "individual", + "url": "https://gitcoin.co/grants/13/ethersjs-complete-simple-and-tiny-2" + }, + { + "type": "individual", + "url": "https://www.buymeacoffee.com/ricmoo" + } + ] + }, + "node_modules/@ethersproject/networks": { + "version": "5.7.1", + "resolved": "https://registry.npmjs.org/@ethersproject/networks/-/networks-5.7.1.tgz", + "integrity": "sha512-n/MufjFYv3yFcUyfhnXotyDlNdFb7onmkSy8aQERi2PjNcnWQ66xXxa3XlS8nCcA8aJKJjIIMNJTC7tu80GwpQ==", + "dev": true, + "funding": [ + { + "type": "individual", + "url": "https://gitcoin.co/grants/13/ethersjs-complete-simple-and-tiny-2" + }, + { + "type": "individual", + "url": "https://www.buymeacoffee.com/ricmoo" + } + ], + "dependencies": { + "@ethersproject/logger": "^5.7.0" + } + }, + "node_modules/@ethersproject/pbkdf2": { + "version": "5.7.0", + "resolved": "https://registry.npmjs.org/@ethersproject/pbkdf2/-/pbkdf2-5.7.0.tgz", + "integrity": "sha512-oR/dBRZR6GTyaofd86DehG72hY6NpAjhabkhxgr3X2FpJtJuodEl2auADWBZfhDHgVCbu3/H/Ocq2uC6dpNjjw==", + "dev": true, + "funding": [ + { + "type": "individual", + "url": "https://gitcoin.co/grants/13/ethersjs-complete-simple-and-tiny-2" + }, + { + "type": "individual", + "url": "https://www.buymeacoffee.com/ricmoo" + } + ], + "dependencies": { + "@ethersproject/bytes": "^5.7.0", + "@ethersproject/sha2": "^5.7.0" + } + }, + "node_modules/@ethersproject/properties": { + "version": "5.7.0", + "resolved": "https://registry.npmjs.org/@ethersproject/properties/-/properties-5.7.0.tgz", + "integrity": "sha512-J87jy8suntrAkIZtecpxEPxY//szqr1mlBaYlQ0r4RCaiD2hjheqF9s1LVE8vVuJCXisjIP+JgtK/Do54ej4Sw==", + "dev": true, + "funding": [ + { + "type": "individual", + "url": "https://gitcoin.co/grants/13/ethersjs-complete-simple-and-tiny-2" + }, + { + "type": "individual", + "url": "https://www.buymeacoffee.com/ricmoo" + } + ], + "dependencies": { + "@ethersproject/logger": "^5.7.0" + } + }, + "node_modules/@ethersproject/providers": { + "version": "5.7.2", + "resolved": "https://registry.npmjs.org/@ethersproject/providers/-/providers-5.7.2.tgz", + "integrity": "sha512-g34EWZ1WWAVgr4aptGlVBF8mhl3VWjv+8hoAnzStu8Ah22VHBsuGzP17eb6xDVRzw895G4W7vvx60lFFur/1Rg==", + "dev": true, + "funding": [ + { + "type": "individual", + "url": "https://gitcoin.co/grants/13/ethersjs-complete-simple-and-tiny-2" + }, + { + "type": "individual", + "url": "https://www.buymeacoffee.com/ricmoo" + } + ], + "dependencies": { + "@ethersproject/abstract-provider": "^5.7.0", + "@ethersproject/abstract-signer": "^5.7.0", + "@ethersproject/address": "^5.7.0", + "@ethersproject/base64": "^5.7.0", + "@ethersproject/basex": "^5.7.0", + "@ethersproject/bignumber": "^5.7.0", + "@ethersproject/bytes": "^5.7.0", + "@ethersproject/constants": "^5.7.0", + "@ethersproject/hash": "^5.7.0", + "@ethersproject/logger": "^5.7.0", + "@ethersproject/networks": "^5.7.0", + "@ethersproject/properties": "^5.7.0", + "@ethersproject/random": "^5.7.0", + "@ethersproject/rlp": "^5.7.0", + "@ethersproject/sha2": "^5.7.0", + "@ethersproject/strings": "^5.7.0", + "@ethersproject/transactions": "^5.7.0", + "@ethersproject/web": "^5.7.0", + "bech32": "1.1.4", + "ws": "7.4.6" + } + }, + "node_modules/@ethersproject/providers/node_modules/ws": { + "version": "7.4.6", + "resolved": "https://registry.npmjs.org/ws/-/ws-7.4.6.tgz", + "integrity": "sha512-YmhHDO4MzaDLB+M9ym/mDA5z0naX8j7SIlT8f8z+I0VtzsRbekxEutHSme7NPS2qE8StCYQNUnfWdXta/Yu85A==", + "dev": true, + "engines": { + "node": ">=8.3.0" + }, + "peerDependencies": { + "bufferutil": "^4.0.1", + "utf-8-validate": "^5.0.2" + }, + "peerDependenciesMeta": { + "bufferutil": { + "optional": true + }, + "utf-8-validate": { + "optional": true + } + } + }, + "node_modules/@ethersproject/random": { + "version": "5.7.0", + "resolved": "https://registry.npmjs.org/@ethersproject/random/-/random-5.7.0.tgz", + "integrity": "sha512-19WjScqRA8IIeWclFme75VMXSBvi4e6InrUNuaR4s5pTF2qNhcGdCUwdxUVGtDDqC00sDLCO93jPQoDUH4HVmQ==", + "dev": true, + "funding": [ + { + "type": "individual", + "url": "https://gitcoin.co/grants/13/ethersjs-complete-simple-and-tiny-2" + }, + { + "type": "individual", + "url": "https://www.buymeacoffee.com/ricmoo" + } + ], + "dependencies": { + "@ethersproject/bytes": "^5.7.0", + "@ethersproject/logger": "^5.7.0" + } + }, + "node_modules/@ethersproject/rlp": { + "version": "5.7.0", + "resolved": "https://registry.npmjs.org/@ethersproject/rlp/-/rlp-5.7.0.tgz", + "integrity": "sha512-rBxzX2vK8mVF7b0Tol44t5Tb8gomOHkj5guL+HhzQ1yBh/ydjGnpw6at+X6Iw0Kp3OzzzkcKp8N9r0W4kYSs9w==", + "dev": true, + "funding": [ + { + "type": "individual", + "url": "https://gitcoin.co/grants/13/ethersjs-complete-simple-and-tiny-2" + }, + { + "type": "individual", + "url": "https://www.buymeacoffee.com/ricmoo" + } + ], + "dependencies": { + "@ethersproject/bytes": "^5.7.0", + "@ethersproject/logger": "^5.7.0" + } + }, + "node_modules/@ethersproject/sha2": { + "version": "5.7.0", + "resolved": "https://registry.npmjs.org/@ethersproject/sha2/-/sha2-5.7.0.tgz", + "integrity": "sha512-gKlH42riwb3KYp0reLsFTokByAKoJdgFCwI+CCiX/k+Jm2mbNs6oOaCjYQSlI1+XBVejwH2KrmCbMAT/GnRDQw==", + "dev": true, + "funding": [ + { + "type": "individual", + "url": "https://gitcoin.co/grants/13/ethersjs-complete-simple-and-tiny-2" + }, + { + "type": "individual", + "url": "https://www.buymeacoffee.com/ricmoo" + } + ], + "dependencies": { + "@ethersproject/bytes": "^5.7.0", + "@ethersproject/logger": "^5.7.0", + "hash.js": "1.1.7" + } + }, + "node_modules/@ethersproject/signing-key": { + "version": "5.7.0", + "resolved": "https://registry.npmjs.org/@ethersproject/signing-key/-/signing-key-5.7.0.tgz", + "integrity": "sha512-MZdy2nL3wO0u7gkB4nA/pEf8lu1TlFswPNmy8AiYkfKTdO6eXBJyUdmHO/ehm/htHw9K/qF8ujnTyUAD+Ry54Q==", + "dev": true, + "funding": [ + { + "type": "individual", + "url": "https://gitcoin.co/grants/13/ethersjs-complete-simple-and-tiny-2" + }, + { + "type": "individual", + "url": "https://www.buymeacoffee.com/ricmoo" + } + ], + "dependencies": { + "@ethersproject/bytes": "^5.7.0", + "@ethersproject/logger": "^5.7.0", + "@ethersproject/properties": "^5.7.0", + "bn.js": "^5.2.1", + "elliptic": "6.5.4", + "hash.js": "1.1.7" + } + }, + "node_modules/@ethersproject/solidity": { + "version": "5.7.0", + "resolved": "https://registry.npmjs.org/@ethersproject/solidity/-/solidity-5.7.0.tgz", + "integrity": "sha512-HmabMd2Dt/raavyaGukF4XxizWKhKQ24DoLtdNbBmNKUOPqwjsKQSdV9GQtj9CBEea9DlzETlVER1gYeXXBGaA==", + "dev": true, + "funding": [ + { + "type": "individual", + "url": "https://gitcoin.co/grants/13/ethersjs-complete-simple-and-tiny-2" + }, + { + "type": "individual", + "url": "https://www.buymeacoffee.com/ricmoo" + } + ], + "dependencies": { + "@ethersproject/bignumber": "^5.7.0", + "@ethersproject/bytes": "^5.7.0", + "@ethersproject/keccak256": "^5.7.0", + "@ethersproject/logger": "^5.7.0", + "@ethersproject/sha2": "^5.7.0", + "@ethersproject/strings": "^5.7.0" + } + }, + "node_modules/@ethersproject/strings": { + "version": "5.7.0", + "resolved": "https://registry.npmjs.org/@ethersproject/strings/-/strings-5.7.0.tgz", + "integrity": "sha512-/9nu+lj0YswRNSH0NXYqrh8775XNyEdUQAuf3f+SmOrnVewcJ5SBNAjF7lpgehKi4abvNNXyf+HX86czCdJ8Mg==", + "dev": true, + "funding": [ + { + "type": "individual", + "url": "https://gitcoin.co/grants/13/ethersjs-complete-simple-and-tiny-2" + }, + { + "type": "individual", + "url": "https://www.buymeacoffee.com/ricmoo" + } + ], + "dependencies": { + "@ethersproject/bytes": "^5.7.0", + "@ethersproject/constants": "^5.7.0", + "@ethersproject/logger": "^5.7.0" + } + }, + "node_modules/@ethersproject/transactions": { + "version": "5.7.0", + "resolved": "https://registry.npmjs.org/@ethersproject/transactions/-/transactions-5.7.0.tgz", + "integrity": "sha512-kmcNicCp1lp8qanMTC3RIikGgoJ80ztTyvtsFvCYpSCfkjhD0jZ2LOrnbcuxuToLIUYYf+4XwD1rP+B/erDIhQ==", + "dev": true, + "funding": [ + { + "type": "individual", + "url": "https://gitcoin.co/grants/13/ethersjs-complete-simple-and-tiny-2" + }, + { + "type": "individual", + "url": "https://www.buymeacoffee.com/ricmoo" + } + ], + "dependencies": { + "@ethersproject/address": "^5.7.0", + "@ethersproject/bignumber": "^5.7.0", + "@ethersproject/bytes": "^5.7.0", + "@ethersproject/constants": "^5.7.0", + "@ethersproject/keccak256": "^5.7.0", + "@ethersproject/logger": "^5.7.0", + "@ethersproject/properties": "^5.7.0", + "@ethersproject/rlp": "^5.7.0", + "@ethersproject/signing-key": "^5.7.0" + } + }, + "node_modules/@ethersproject/units": { + "version": "5.7.0", + "resolved": "https://registry.npmjs.org/@ethersproject/units/-/units-5.7.0.tgz", + "integrity": "sha512-pD3xLMy3SJu9kG5xDGI7+xhTEmGXlEqXU4OfNapmfnxLVY4EMSSRp7j1k7eezutBPH7RBN/7QPnwR7hzNlEFeg==", + "dev": true, + "funding": [ + { + "type": "individual", + "url": "https://gitcoin.co/grants/13/ethersjs-complete-simple-and-tiny-2" + }, + { + "type": "individual", + "url": "https://www.buymeacoffee.com/ricmoo" + } + ], + "dependencies": { + "@ethersproject/bignumber": "^5.7.0", + "@ethersproject/constants": "^5.7.0", + "@ethersproject/logger": "^5.7.0" + } + }, + "node_modules/@ethersproject/wallet": { + "version": "5.7.0", + "resolved": "https://registry.npmjs.org/@ethersproject/wallet/-/wallet-5.7.0.tgz", + "integrity": "sha512-MhmXlJXEJFBFVKrDLB4ZdDzxcBxQ3rLyCkhNqVu3CDYvR97E+8r01UgrI+TI99Le+aYm/in/0vp86guJuM7FCA==", + "dev": true, + "funding": [ + { + "type": "individual", + "url": "https://gitcoin.co/grants/13/ethersjs-complete-simple-and-tiny-2" + }, + { + "type": "individual", + "url": "https://www.buymeacoffee.com/ricmoo" + } + ], + "dependencies": { + "@ethersproject/abstract-provider": "^5.7.0", + "@ethersproject/abstract-signer": "^5.7.0", + "@ethersproject/address": "^5.7.0", + "@ethersproject/bignumber": "^5.7.0", + "@ethersproject/bytes": "^5.7.0", + "@ethersproject/hash": "^5.7.0", + "@ethersproject/hdnode": "^5.7.0", + "@ethersproject/json-wallets": "^5.7.0", + "@ethersproject/keccak256": "^5.7.0", + "@ethersproject/logger": "^5.7.0", + "@ethersproject/properties": "^5.7.0", + "@ethersproject/random": "^5.7.0", + "@ethersproject/signing-key": "^5.7.0", + "@ethersproject/transactions": "^5.7.0", + "@ethersproject/wordlists": "^5.7.0" + } + }, + "node_modules/@ethersproject/web": { + "version": "5.7.1", + "resolved": "https://registry.npmjs.org/@ethersproject/web/-/web-5.7.1.tgz", + "integrity": "sha512-Gueu8lSvyjBWL4cYsWsjh6MtMwM0+H4HvqFPZfB6dV8ctbP9zFAO73VG1cMWae0FLPCtz0peKPpZY8/ugJJX2w==", + "dev": true, + "funding": [ + { + "type": "individual", + "url": "https://gitcoin.co/grants/13/ethersjs-complete-simple-and-tiny-2" + }, + { + "type": "individual", + "url": "https://www.buymeacoffee.com/ricmoo" + } + ], + "dependencies": { + "@ethersproject/base64": "^5.7.0", + "@ethersproject/bytes": "^5.7.0", + "@ethersproject/logger": "^5.7.0", + "@ethersproject/properties": "^5.7.0", + "@ethersproject/strings": "^5.7.0" + } + }, + "node_modules/@ethersproject/wordlists": { + "version": "5.7.0", + "resolved": "https://registry.npmjs.org/@ethersproject/wordlists/-/wordlists-5.7.0.tgz", + "integrity": "sha512-S2TFNJNfHWVHNE6cNDjbVlZ6MgE17MIxMbMg2zv3wn+3XSJGosL1m9ZVv3GXCf/2ymSsQ+hRI5IzoMJTG6aoVA==", + "dev": true, + "funding": [ + { + "type": "individual", + "url": "https://gitcoin.co/grants/13/ethersjs-complete-simple-and-tiny-2" + }, + { + "type": "individual", + "url": "https://www.buymeacoffee.com/ricmoo" + } + ], + "dependencies": { + "@ethersproject/bytes": "^5.7.0", + "@ethersproject/hash": "^5.7.0", + "@ethersproject/logger": "^5.7.0", + "@ethersproject/properties": "^5.7.0", + "@ethersproject/strings": "^5.7.0" + } + }, + "node_modules/@jridgewell/resolve-uri": { + "version": "3.1.1", + "resolved": "https://registry.npmjs.org/@jridgewell/resolve-uri/-/resolve-uri-3.1.1.tgz", + "integrity": "sha512-dSYZh7HhCDtCKm4QakX0xFpsRDqjjtZf/kjI/v3T3Nwt5r8/qz/M19F9ySyOqU94SXBmeG9ttTul+YnR4LOxFA==", + "dev": true, + "peer": true, + "engines": { + "node": ">=6.0.0" + } + }, + "node_modules/@jridgewell/sourcemap-codec": { + "version": "1.4.15", + "resolved": "https://registry.npmjs.org/@jridgewell/sourcemap-codec/-/sourcemap-codec-1.4.15.tgz", + "integrity": "sha512-eF2rxCRulEKXHTRiDrDy6erMYWqNw4LPdQ8UQA4huuxaQsVeRPFl2oM8oDGxMFhJUWZf9McpLtJasDDZb/Bpeg==", + "dev": true, + "peer": true + }, + "node_modules/@jridgewell/trace-mapping": { + "version": "0.3.9", + "resolved": "https://registry.npmjs.org/@jridgewell/trace-mapping/-/trace-mapping-0.3.9.tgz", + "integrity": "sha512-3Belt6tdc8bPgAtbcmdtNJlirVoTmEb5e2gC94PnkwEW9jI6CAHUeoG85tjWP5WquqfavoMtMwiG4P926ZKKuQ==", + "dev": true, + "peer": true, + "dependencies": { + "@jridgewell/resolve-uri": "^3.0.3", + "@jridgewell/sourcemap-codec": "^1.4.10" + } + }, + "node_modules/@metamask/eth-sig-util": { + "version": "4.0.1", + "resolved": "https://registry.npmjs.org/@metamask/eth-sig-util/-/eth-sig-util-4.0.1.tgz", + "integrity": "sha512-tghyZKLHZjcdlDqCA3gNZmLeR0XvOE9U1qoQO9ohyAZT6Pya+H9vkBPcsyXytmYLNgVoin7CKCmweo/R43V+tQ==", + "dev": true, + "dependencies": { + "ethereumjs-abi": "^0.6.8", + "ethereumjs-util": "^6.2.1", + "ethjs-util": "^0.1.6", + "tweetnacl": "^1.0.3", + "tweetnacl-util": "^0.15.1" + }, + "engines": { + "node": ">=12.0.0" + } + }, + "node_modules/@morgan-stanley/ts-mocking-bird": { + "version": "0.6.4", + "resolved": "https://registry.npmjs.org/@morgan-stanley/ts-mocking-bird/-/ts-mocking-bird-0.6.4.tgz", + "integrity": "sha512-57VJIflP8eR2xXa9cD1LUawh+Gh+BVQfVu0n6GALyg/AqV/Nz25kDRvws3i9kIe1PTrbsZZOYpsYp6bXPd6nVA==", + "dev": true, + "peer": true, + "dependencies": { + "lodash": "^4.17.16", + "uuid": "^7.0.3" + }, + "peerDependencies": { + "jasmine": "2.x || 3.x || 4.x", + "jest": "26.x || 27.x || 28.x", + "typescript": ">=4.2" + }, + "peerDependenciesMeta": { + "jasmine": { + "optional": true + }, + "jest": { + "optional": true + } + } + }, + "node_modules/@morgan-stanley/ts-mocking-bird/node_modules/uuid": { + "version": "7.0.3", + "resolved": "https://registry.npmjs.org/uuid/-/uuid-7.0.3.tgz", + "integrity": "sha512-DPSke0pXhTZgoF/d+WSt2QaKMCFSfx7QegxEWT+JOuHF5aWrKEn0G+ztjuJg/gG8/ItK+rbPCD/yNv8yyih6Cg==", + "dev": true, + "peer": true, + "bin": { + "uuid": "dist/bin/uuid" + } + }, + "node_modules/@noble/hashes": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/@noble/hashes/-/hashes-1.2.0.tgz", + "integrity": "sha512-FZfhjEDbT5GRswV3C6uvLPHMiVD6lQBmpoX5+eSiPaMTXte/IKqI5dykDxzZB/WBeK/CDuQRBWarPdi3FNY2zQ==", + "dev": true, + "funding": [ + { + "type": "individual", + "url": "https://paulmillr.com/funding/" + } + ] + }, + "node_modules/@noble/secp256k1": { + "version": "1.7.1", + "resolved": "https://registry.npmjs.org/@noble/secp256k1/-/secp256k1-1.7.1.tgz", + "integrity": "sha512-hOUk6AyBFmqVrv7k5WAw/LpszxVbj9gGN4JRkIX52fdFAj1UA61KXmZDvqVEm+pOyec3+fIeZB02LYa/pWOArw==", + "dev": true, + "funding": [ + { + "type": "individual", + "url": "https://paulmillr.com/funding/" + } + ] + }, + "node_modules/@nodelib/fs.scandir": { + "version": "2.1.5", + "resolved": "https://registry.npmjs.org/@nodelib/fs.scandir/-/fs.scandir-2.1.5.tgz", + "integrity": "sha512-vq24Bq3ym5HEQm2NKCr3yXDwjc7vTsEThRDnkp2DK9p1uqLR+DHurm/NOTo0KG7HYHU7eppKZj3MyqYuMBf62g==", + "dev": true, + "peer": true, + "dependencies": { + "@nodelib/fs.stat": "2.0.5", + "run-parallel": "^1.1.9" + }, + "engines": { + "node": ">= 8" + } + }, + "node_modules/@nodelib/fs.stat": { + "version": "2.0.5", + "resolved": "https://registry.npmjs.org/@nodelib/fs.stat/-/fs.stat-2.0.5.tgz", + "integrity": "sha512-RkhPPp2zrqDAQA/2jNhnztcPAlv64XdhIp7a7454A5ovI7Bukxgt7MX7udwAu3zg1DcpPU0rz3VV1SeaqvY4+A==", + "dev": true, + "peer": true, + "engines": { + "node": ">= 8" + } + }, + "node_modules/@nodelib/fs.walk": { + "version": "1.2.8", + "resolved": "https://registry.npmjs.org/@nodelib/fs.walk/-/fs.walk-1.2.8.tgz", + "integrity": "sha512-oGB+UxlgWcgQkgwo8GcEGwemoTFt3FIO9ababBmaGwXIoBKZ+GTy0pP185beGg7Llih/NSHSV2XAs1lnznocSg==", + "dev": true, + "peer": true, + "dependencies": { + "@nodelib/fs.scandir": "2.1.5", + "fastq": "^1.6.0" + }, + "engines": { + "node": ">= 8" + } + }, + "node_modules/@nomicfoundation/ethereumjs-block": { + "version": "5.0.1", + "resolved": "https://registry.npmjs.org/@nomicfoundation/ethereumjs-block/-/ethereumjs-block-5.0.1.tgz", + "integrity": "sha512-u1Yioemi6Ckj3xspygu/SfFvm8vZEO8/Yx5a1QLzi6nVU0jz3Pg2OmHKJ5w+D9Ogk1vhwRiqEBAqcb0GVhCyHw==", + "dev": true, + "dependencies": { + "@nomicfoundation/ethereumjs-common": "4.0.1", + "@nomicfoundation/ethereumjs-rlp": "5.0.1", + "@nomicfoundation/ethereumjs-trie": "6.0.1", + "@nomicfoundation/ethereumjs-tx": "5.0.1", + "@nomicfoundation/ethereumjs-util": "9.0.1", + "ethereum-cryptography": "0.1.3", + "ethers": "^5.7.1" + }, + "engines": { + "node": ">=14" + } + }, + "node_modules/@nomicfoundation/ethereumjs-block/node_modules/ethereum-cryptography": { + "version": "0.1.3", + "resolved": "https://registry.npmjs.org/ethereum-cryptography/-/ethereum-cryptography-0.1.3.tgz", + "integrity": "sha512-w8/4x1SGGzc+tO97TASLja6SLd3fRIK2tLVcV2Gx4IB21hE19atll5Cq9o3d0ZmAYC/8aw0ipieTSiekAea4SQ==", + "dev": true, + "dependencies": { + "@types/pbkdf2": "^3.0.0", + "@types/secp256k1": "^4.0.1", + "blakejs": "^1.1.0", + "browserify-aes": "^1.2.0", + "bs58check": "^2.1.2", + "create-hash": "^1.2.0", + "create-hmac": "^1.1.7", + "hash.js": "^1.1.7", + "keccak": "^3.0.0", + "pbkdf2": "^3.0.17", + "randombytes": "^2.1.0", + "safe-buffer": "^5.1.2", + "scrypt-js": "^3.0.0", + "secp256k1": "^4.0.1", + "setimmediate": "^1.0.5" + } + }, + "node_modules/@nomicfoundation/ethereumjs-blockchain": { + "version": "7.0.1", + "resolved": "https://registry.npmjs.org/@nomicfoundation/ethereumjs-blockchain/-/ethereumjs-blockchain-7.0.1.tgz", + "integrity": "sha512-NhzndlGg829XXbqJEYrF1VeZhAwSPgsK/OB7TVrdzft3y918hW5KNd7gIZ85sn6peDZOdjBsAXIpXZ38oBYE5A==", + "dev": true, + "dependencies": { + "@nomicfoundation/ethereumjs-block": "5.0.1", + "@nomicfoundation/ethereumjs-common": "4.0.1", + "@nomicfoundation/ethereumjs-ethash": "3.0.1", + "@nomicfoundation/ethereumjs-rlp": "5.0.1", + "@nomicfoundation/ethereumjs-trie": "6.0.1", + "@nomicfoundation/ethereumjs-tx": "5.0.1", + "@nomicfoundation/ethereumjs-util": "9.0.1", + "abstract-level": "^1.0.3", + "debug": "^4.3.3", + "ethereum-cryptography": "0.1.3", + "level": "^8.0.0", + "lru-cache": "^5.1.1", + "memory-level": "^1.0.0" + }, + "engines": { + "node": ">=14" + } + }, + "node_modules/@nomicfoundation/ethereumjs-blockchain/node_modules/ethereum-cryptography": { + "version": "0.1.3", + "resolved": "https://registry.npmjs.org/ethereum-cryptography/-/ethereum-cryptography-0.1.3.tgz", + "integrity": "sha512-w8/4x1SGGzc+tO97TASLja6SLd3fRIK2tLVcV2Gx4IB21hE19atll5Cq9o3d0ZmAYC/8aw0ipieTSiekAea4SQ==", + "dev": true, + "dependencies": { + "@types/pbkdf2": "^3.0.0", + "@types/secp256k1": "^4.0.1", + "blakejs": "^1.1.0", + "browserify-aes": "^1.2.0", + "bs58check": "^2.1.2", + "create-hash": "^1.2.0", + "create-hmac": "^1.1.7", + "hash.js": "^1.1.7", + "keccak": "^3.0.0", + "pbkdf2": "^3.0.17", + "randombytes": "^2.1.0", + "safe-buffer": "^5.1.2", + "scrypt-js": "^3.0.0", + "secp256k1": "^4.0.1", + "setimmediate": "^1.0.5" + } + }, + "node_modules/@nomicfoundation/ethereumjs-common": { + "version": "4.0.1", + "resolved": "https://registry.npmjs.org/@nomicfoundation/ethereumjs-common/-/ethereumjs-common-4.0.1.tgz", + "integrity": "sha512-OBErlkfp54GpeiE06brBW/TTbtbuBJV5YI5Nz/aB2evTDo+KawyEzPjBlSr84z/8MFfj8wS2wxzQX1o32cev5g==", + "dev": true, + "dependencies": { + "@nomicfoundation/ethereumjs-util": "9.0.1", + "crc-32": "^1.2.0" + } + }, + "node_modules/@nomicfoundation/ethereumjs-ethash": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/@nomicfoundation/ethereumjs-ethash/-/ethereumjs-ethash-3.0.1.tgz", + "integrity": "sha512-KDjGIB5igzWOp8Ik5I6QiRH5DH+XgILlplsHR7TEuWANZA759G6krQ6o8bvj+tRUz08YygMQu/sGd9mJ1DYT8w==", + "dev": true, + "dependencies": { + "@nomicfoundation/ethereumjs-block": "5.0.1", + "@nomicfoundation/ethereumjs-rlp": "5.0.1", + "@nomicfoundation/ethereumjs-util": "9.0.1", + "abstract-level": "^1.0.3", + "bigint-crypto-utils": "^3.0.23", + "ethereum-cryptography": "0.1.3" + }, + "engines": { + "node": ">=14" + } + }, + "node_modules/@nomicfoundation/ethereumjs-ethash/node_modules/ethereum-cryptography": { + "version": "0.1.3", + "resolved": "https://registry.npmjs.org/ethereum-cryptography/-/ethereum-cryptography-0.1.3.tgz", + "integrity": "sha512-w8/4x1SGGzc+tO97TASLja6SLd3fRIK2tLVcV2Gx4IB21hE19atll5Cq9o3d0ZmAYC/8aw0ipieTSiekAea4SQ==", + "dev": true, + "dependencies": { + "@types/pbkdf2": "^3.0.0", + "@types/secp256k1": "^4.0.1", + "blakejs": "^1.1.0", + "browserify-aes": "^1.2.0", + "bs58check": "^2.1.2", + "create-hash": "^1.2.0", + "create-hmac": "^1.1.7", + "hash.js": "^1.1.7", + "keccak": "^3.0.0", + "pbkdf2": "^3.0.17", + "randombytes": "^2.1.0", + "safe-buffer": "^5.1.2", + "scrypt-js": "^3.0.0", + "secp256k1": "^4.0.1", + "setimmediate": "^1.0.5" + } + }, + "node_modules/@nomicfoundation/ethereumjs-evm": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/@nomicfoundation/ethereumjs-evm/-/ethereumjs-evm-2.0.1.tgz", + "integrity": "sha512-oL8vJcnk0Bx/onl+TgQOQ1t/534GKFaEG17fZmwtPFeH8S5soiBYPCLUrvANOl4sCp9elYxIMzIiTtMtNNN8EQ==", + "dev": true, + "dependencies": { + "@ethersproject/providers": "^5.7.1", + "@nomicfoundation/ethereumjs-common": "4.0.1", + "@nomicfoundation/ethereumjs-tx": "5.0.1", + "@nomicfoundation/ethereumjs-util": "9.0.1", + "debug": "^4.3.3", + "ethereum-cryptography": "0.1.3", + "mcl-wasm": "^0.7.1", + "rustbn.js": "~0.2.0" + }, + "engines": { + "node": ">=14" + } + }, + "node_modules/@nomicfoundation/ethereumjs-evm/node_modules/ethereum-cryptography": { + "version": "0.1.3", + "resolved": "https://registry.npmjs.org/ethereum-cryptography/-/ethereum-cryptography-0.1.3.tgz", + "integrity": "sha512-w8/4x1SGGzc+tO97TASLja6SLd3fRIK2tLVcV2Gx4IB21hE19atll5Cq9o3d0ZmAYC/8aw0ipieTSiekAea4SQ==", + "dev": true, + "dependencies": { + "@types/pbkdf2": "^3.0.0", + "@types/secp256k1": "^4.0.1", + "blakejs": "^1.1.0", + "browserify-aes": "^1.2.0", + "bs58check": "^2.1.2", + "create-hash": "^1.2.0", + "create-hmac": "^1.1.7", + "hash.js": "^1.1.7", + "keccak": "^3.0.0", + "pbkdf2": "^3.0.17", + "randombytes": "^2.1.0", + "safe-buffer": "^5.1.2", + "scrypt-js": "^3.0.0", + "secp256k1": "^4.0.1", + "setimmediate": "^1.0.5" + } + }, + "node_modules/@nomicfoundation/ethereumjs-rlp": { + "version": "5.0.1", + "resolved": "https://registry.npmjs.org/@nomicfoundation/ethereumjs-rlp/-/ethereumjs-rlp-5.0.1.tgz", + "integrity": "sha512-xtxrMGa8kP4zF5ApBQBtjlSbN5E2HI8m8FYgVSYAnO6ssUoY5pVPGy2H8+xdf/bmMa22Ce8nWMH3aEW8CcqMeQ==", + "dev": true, + "bin": { + "rlp": "bin/rlp" + }, + "engines": { + "node": ">=14" + } + }, + "node_modules/@nomicfoundation/ethereumjs-statemanager": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/@nomicfoundation/ethereumjs-statemanager/-/ethereumjs-statemanager-2.0.1.tgz", + "integrity": "sha512-B5ApMOnlruVOR7gisBaYwFX+L/AP7i/2oAahatssjPIBVDF6wTX1K7Qpa39E/nzsH8iYuL3krkYeUFIdO3EMUQ==", + "dev": true, + "dependencies": { + "@nomicfoundation/ethereumjs-common": "4.0.1", + "@nomicfoundation/ethereumjs-rlp": "5.0.1", + "debug": "^4.3.3", + "ethereum-cryptography": "0.1.3", + "ethers": "^5.7.1", + "js-sdsl": "^4.1.4" + } + }, + "node_modules/@nomicfoundation/ethereumjs-statemanager/node_modules/ethereum-cryptography": { + "version": "0.1.3", + "resolved": "https://registry.npmjs.org/ethereum-cryptography/-/ethereum-cryptography-0.1.3.tgz", + "integrity": "sha512-w8/4x1SGGzc+tO97TASLja6SLd3fRIK2tLVcV2Gx4IB21hE19atll5Cq9o3d0ZmAYC/8aw0ipieTSiekAea4SQ==", + "dev": true, + "dependencies": { + "@types/pbkdf2": "^3.0.0", + "@types/secp256k1": "^4.0.1", + "blakejs": "^1.1.0", + "browserify-aes": "^1.2.0", + "bs58check": "^2.1.2", + "create-hash": "^1.2.0", + "create-hmac": "^1.1.7", + "hash.js": "^1.1.7", + "keccak": "^3.0.0", + "pbkdf2": "^3.0.17", + "randombytes": "^2.1.0", + "safe-buffer": "^5.1.2", + "scrypt-js": "^3.0.0", + "secp256k1": "^4.0.1", + "setimmediate": "^1.0.5" + } + }, + "node_modules/@nomicfoundation/ethereumjs-trie": { + "version": "6.0.1", + "resolved": "https://registry.npmjs.org/@nomicfoundation/ethereumjs-trie/-/ethereumjs-trie-6.0.1.tgz", + "integrity": "sha512-A64It/IMpDVODzCgxDgAAla8jNjNtsoQZIzZUfIV5AY6Coi4nvn7+VReBn5itlxMiL2yaTlQr9TRWp3CSI6VoA==", + "dev": true, + "dependencies": { + "@nomicfoundation/ethereumjs-rlp": "5.0.1", + "@nomicfoundation/ethereumjs-util": "9.0.1", + "@types/readable-stream": "^2.3.13", + "ethereum-cryptography": "0.1.3", + "readable-stream": "^3.6.0" + }, + "engines": { + "node": ">=14" + } + }, + "node_modules/@nomicfoundation/ethereumjs-trie/node_modules/ethereum-cryptography": { + "version": "0.1.3", + "resolved": "https://registry.npmjs.org/ethereum-cryptography/-/ethereum-cryptography-0.1.3.tgz", + "integrity": "sha512-w8/4x1SGGzc+tO97TASLja6SLd3fRIK2tLVcV2Gx4IB21hE19atll5Cq9o3d0ZmAYC/8aw0ipieTSiekAea4SQ==", + "dev": true, + "dependencies": { + "@types/pbkdf2": "^3.0.0", + "@types/secp256k1": "^4.0.1", + "blakejs": "^1.1.0", + "browserify-aes": "^1.2.0", + "bs58check": "^2.1.2", + "create-hash": "^1.2.0", + "create-hmac": "^1.1.7", + "hash.js": "^1.1.7", + "keccak": "^3.0.0", + "pbkdf2": "^3.0.17", + "randombytes": "^2.1.0", + "safe-buffer": "^5.1.2", + "scrypt-js": "^3.0.0", + "secp256k1": "^4.0.1", + "setimmediate": "^1.0.5" + } + }, + "node_modules/@nomicfoundation/ethereumjs-tx": { + "version": "5.0.1", + "resolved": "https://registry.npmjs.org/@nomicfoundation/ethereumjs-tx/-/ethereumjs-tx-5.0.1.tgz", + "integrity": "sha512-0HwxUF2u2hrsIM1fsasjXvlbDOq1ZHFV2dd1yGq8CA+MEYhaxZr8OTScpVkkxqMwBcc5y83FyPl0J9MZn3kY0w==", + "dev": true, + "dependencies": { + "@chainsafe/ssz": "^0.9.2", + "@ethersproject/providers": "^5.7.2", + "@nomicfoundation/ethereumjs-common": "4.0.1", + "@nomicfoundation/ethereumjs-rlp": "5.0.1", + "@nomicfoundation/ethereumjs-util": "9.0.1", + "ethereum-cryptography": "0.1.3" + }, + "engines": { + "node": ">=14" + } + }, + "node_modules/@nomicfoundation/ethereumjs-tx/node_modules/ethereum-cryptography": { + "version": "0.1.3", + "resolved": "https://registry.npmjs.org/ethereum-cryptography/-/ethereum-cryptography-0.1.3.tgz", + "integrity": "sha512-w8/4x1SGGzc+tO97TASLja6SLd3fRIK2tLVcV2Gx4IB21hE19atll5Cq9o3d0ZmAYC/8aw0ipieTSiekAea4SQ==", + "dev": true, + "dependencies": { + "@types/pbkdf2": "^3.0.0", + "@types/secp256k1": "^4.0.1", + "blakejs": "^1.1.0", + "browserify-aes": "^1.2.0", + "bs58check": "^2.1.2", + "create-hash": "^1.2.0", + "create-hmac": "^1.1.7", + "hash.js": "^1.1.7", + "keccak": "^3.0.0", + "pbkdf2": "^3.0.17", + "randombytes": "^2.1.0", + "safe-buffer": "^5.1.2", + "scrypt-js": "^3.0.0", + "secp256k1": "^4.0.1", + "setimmediate": "^1.0.5" + } + }, + "node_modules/@nomicfoundation/ethereumjs-util": { + "version": "9.0.1", + "resolved": "https://registry.npmjs.org/@nomicfoundation/ethereumjs-util/-/ethereumjs-util-9.0.1.tgz", + "integrity": "sha512-TwbhOWQ8QoSCFhV/DDfSmyfFIHjPjFBj957219+V3jTZYZ2rf9PmDtNOeZWAE3p3vlp8xb02XGpd0v6nTUPbsA==", + "dev": true, + "dependencies": { + "@chainsafe/ssz": "^0.10.0", + "@nomicfoundation/ethereumjs-rlp": "5.0.1", + "ethereum-cryptography": "0.1.3" + }, + "engines": { + "node": ">=14" + } + }, + "node_modules/@nomicfoundation/ethereumjs-util/node_modules/@chainsafe/persistent-merkle-tree": { + "version": "0.5.0", + "resolved": "https://registry.npmjs.org/@chainsafe/persistent-merkle-tree/-/persistent-merkle-tree-0.5.0.tgz", + "integrity": "sha512-l0V1b5clxA3iwQLXP40zYjyZYospQLZXzBVIhhr9kDg/1qHZfzzHw0jj4VPBijfYCArZDlPkRi1wZaV2POKeuw==", + "dev": true, + "dependencies": { + "@chainsafe/as-sha256": "^0.3.1" + } + }, + "node_modules/@nomicfoundation/ethereumjs-util/node_modules/@chainsafe/ssz": { + "version": "0.10.2", + "resolved": "https://registry.npmjs.org/@chainsafe/ssz/-/ssz-0.10.2.tgz", + "integrity": "sha512-/NL3Lh8K+0q7A3LsiFq09YXS9fPE+ead2rr7vM2QK8PLzrNsw3uqrif9bpRX5UxgeRjM+vYi+boCM3+GM4ovXg==", + "dev": true, + "dependencies": { + "@chainsafe/as-sha256": "^0.3.1", + "@chainsafe/persistent-merkle-tree": "^0.5.0" + } + }, + "node_modules/@nomicfoundation/ethereumjs-util/node_modules/ethereum-cryptography": { + "version": "0.1.3", + "resolved": "https://registry.npmjs.org/ethereum-cryptography/-/ethereum-cryptography-0.1.3.tgz", + "integrity": "sha512-w8/4x1SGGzc+tO97TASLja6SLd3fRIK2tLVcV2Gx4IB21hE19atll5Cq9o3d0ZmAYC/8aw0ipieTSiekAea4SQ==", + "dev": true, + "dependencies": { + "@types/pbkdf2": "^3.0.0", + "@types/secp256k1": "^4.0.1", + "blakejs": "^1.1.0", + "browserify-aes": "^1.2.0", + "bs58check": "^2.1.2", + "create-hash": "^1.2.0", + "create-hmac": "^1.1.7", + "hash.js": "^1.1.7", + "keccak": "^3.0.0", + "pbkdf2": "^3.0.17", + "randombytes": "^2.1.0", + "safe-buffer": "^5.1.2", + "scrypt-js": "^3.0.0", + "secp256k1": "^4.0.1", + "setimmediate": "^1.0.5" + } + }, + "node_modules/@nomicfoundation/ethereumjs-vm": { + "version": "7.0.1", + "resolved": "https://registry.npmjs.org/@nomicfoundation/ethereumjs-vm/-/ethereumjs-vm-7.0.1.tgz", + "integrity": "sha512-rArhyn0jPsS/D+ApFsz3yVJMQ29+pVzNZ0VJgkzAZ+7FqXSRtThl1C1prhmlVr3YNUlfpZ69Ak+RUT4g7VoOuQ==", + "dev": true, + "dependencies": { + "@nomicfoundation/ethereumjs-block": "5.0.1", + "@nomicfoundation/ethereumjs-blockchain": "7.0.1", + "@nomicfoundation/ethereumjs-common": "4.0.1", + "@nomicfoundation/ethereumjs-evm": "2.0.1", + "@nomicfoundation/ethereumjs-rlp": "5.0.1", + "@nomicfoundation/ethereumjs-statemanager": "2.0.1", + "@nomicfoundation/ethereumjs-trie": "6.0.1", + "@nomicfoundation/ethereumjs-tx": "5.0.1", + "@nomicfoundation/ethereumjs-util": "9.0.1", + "debug": "^4.3.3", + "ethereum-cryptography": "0.1.3", + "mcl-wasm": "^0.7.1", + "rustbn.js": "~0.2.0" + }, + "engines": { + "node": ">=14" + } + }, + "node_modules/@nomicfoundation/ethereumjs-vm/node_modules/ethereum-cryptography": { + "version": "0.1.3", + "resolved": "https://registry.npmjs.org/ethereum-cryptography/-/ethereum-cryptography-0.1.3.tgz", + "integrity": "sha512-w8/4x1SGGzc+tO97TASLja6SLd3fRIK2tLVcV2Gx4IB21hE19atll5Cq9o3d0ZmAYC/8aw0ipieTSiekAea4SQ==", + "dev": true, + "dependencies": { + "@types/pbkdf2": "^3.0.0", + "@types/secp256k1": "^4.0.1", + "blakejs": "^1.1.0", + "browserify-aes": "^1.2.0", + "bs58check": "^2.1.2", + "create-hash": "^1.2.0", + "create-hmac": "^1.1.7", + "hash.js": "^1.1.7", + "keccak": "^3.0.0", + "pbkdf2": "^3.0.17", + "randombytes": "^2.1.0", + "safe-buffer": "^5.1.2", + "scrypt-js": "^3.0.0", + "secp256k1": "^4.0.1", + "setimmediate": "^1.0.5" + } + }, + "node_modules/@nomicfoundation/hardhat-chai-matchers": { + "version": "1.0.6", + "resolved": "https://registry.npmjs.org/@nomicfoundation/hardhat-chai-matchers/-/hardhat-chai-matchers-1.0.6.tgz", + "integrity": "sha512-f5ZMNmabZeZegEfuxn/0kW+mm7+yV7VNDxLpMOMGXWFJ2l/Ct3QShujzDRF9cOkK9Ui/hbDeOWGZqyQALDXVCQ==", + "dev": true, + "peer": true, + "dependencies": { + "@ethersproject/abi": "^5.1.2", + "@types/chai-as-promised": "^7.1.3", + "chai-as-promised": "^7.1.1", + "deep-eql": "^4.0.1", + "ordinal": "^1.0.3" + }, + "peerDependencies": { + "@nomiclabs/hardhat-ethers": "^2.0.0", + "chai": "^4.2.0", + "ethers": "^5.0.0", + "hardhat": "^2.9.4" + } + }, + "node_modules/@nomicfoundation/hardhat-network-helpers": { + "version": "1.0.8", + "resolved": "https://registry.npmjs.org/@nomicfoundation/hardhat-network-helpers/-/hardhat-network-helpers-1.0.8.tgz", + "integrity": "sha512-MNqQbzUJZnCMIYvlniC3U+kcavz/PhhQSsY90tbEtUyMj/IQqsLwIRZa4ctjABh3Bz0KCh9OXUZ7Yk/d9hr45Q==", + "dev": true, + "peer": true, + "dependencies": { + "ethereumjs-util": "^7.1.4" + }, + "peerDependencies": { + "hardhat": "^2.9.5" + } + }, + "node_modules/@nomicfoundation/hardhat-network-helpers/node_modules/ethereum-cryptography": { + "version": "0.1.3", + "resolved": "https://registry.npmjs.org/ethereum-cryptography/-/ethereum-cryptography-0.1.3.tgz", + "integrity": "sha512-w8/4x1SGGzc+tO97TASLja6SLd3fRIK2tLVcV2Gx4IB21hE19atll5Cq9o3d0ZmAYC/8aw0ipieTSiekAea4SQ==", + "dev": true, + "peer": true, + "dependencies": { + "@types/pbkdf2": "^3.0.0", + "@types/secp256k1": "^4.0.1", + "blakejs": "^1.1.0", + "browserify-aes": "^1.2.0", + "bs58check": "^2.1.2", + "create-hash": "^1.2.0", + "create-hmac": "^1.1.7", + "hash.js": "^1.1.7", + "keccak": "^3.0.0", + "pbkdf2": "^3.0.17", + "randombytes": "^2.1.0", + "safe-buffer": "^5.1.2", + "scrypt-js": "^3.0.0", + "secp256k1": "^4.0.1", + "setimmediate": "^1.0.5" + } + }, + "node_modules/@nomicfoundation/hardhat-network-helpers/node_modules/ethereumjs-util": { + "version": "7.1.5", + "resolved": "https://registry.npmjs.org/ethereumjs-util/-/ethereumjs-util-7.1.5.tgz", + "integrity": "sha512-SDl5kKrQAudFBUe5OJM9Ac6WmMyYmXX/6sTmLZ3ffG2eY6ZIGBes3pEDxNN6V72WyOw4CPD5RomKdsa8DAAwLg==", + "dev": true, + "peer": true, + "dependencies": { + "@types/bn.js": "^5.1.0", + "bn.js": "^5.1.2", + "create-hash": "^1.1.2", + "ethereum-cryptography": "^0.1.3", + "rlp": "^2.2.4" + }, + "engines": { + "node": ">=10.0.0" + } + }, + "node_modules/@nomicfoundation/hardhat-toolbox": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/@nomicfoundation/hardhat-toolbox/-/hardhat-toolbox-2.0.2.tgz", + "integrity": "sha512-vnN1AzxbvpSx9pfdRHbUzTRIXpMLPXnUlkW855VaDk6N1pwRaQ2gNzEmFAABk4lWf11E00PKwFd/q27HuwYrYg==", + "dev": true, + "peerDependencies": { + "@ethersproject/abi": "^5.4.7", + "@ethersproject/providers": "^5.4.7", + "@nomicfoundation/hardhat-chai-matchers": "^1.0.0", + "@nomicfoundation/hardhat-network-helpers": "^1.0.0", + "@nomiclabs/hardhat-ethers": "^2.0.0", + "@nomiclabs/hardhat-etherscan": "^3.0.0", + "@typechain/ethers-v5": "^10.1.0", + "@typechain/hardhat": "^6.1.2", + "@types/chai": "^4.2.0", + "@types/mocha": ">=9.1.0", + "@types/node": ">=12.0.0", + "chai": "^4.2.0", + "ethers": "^5.4.7", + "hardhat": "^2.11.0", + "hardhat-gas-reporter": "^1.0.8", + "solidity-coverage": "^0.8.1", + "ts-node": ">=8.0.0", + "typechain": "^8.1.0", + "typescript": ">=4.5.0" + } + }, + "node_modules/@nomicfoundation/solidity-analyzer": { + "version": "0.1.1", + "resolved": "https://registry.npmjs.org/@nomicfoundation/solidity-analyzer/-/solidity-analyzer-0.1.1.tgz", + "integrity": "sha512-1LMtXj1puAxyFusBgUIy5pZk3073cNXYnXUpuNKFghHbIit/xZgbk0AokpUADbNm3gyD6bFWl3LRFh3dhVdREg==", + "dev": true, + "engines": { + "node": ">= 12" + }, + "optionalDependencies": { + "@nomicfoundation/solidity-analyzer-darwin-arm64": "0.1.1", + "@nomicfoundation/solidity-analyzer-darwin-x64": "0.1.1", + "@nomicfoundation/solidity-analyzer-freebsd-x64": "0.1.1", + "@nomicfoundation/solidity-analyzer-linux-arm64-gnu": "0.1.1", + "@nomicfoundation/solidity-analyzer-linux-arm64-musl": "0.1.1", + "@nomicfoundation/solidity-analyzer-linux-x64-gnu": "0.1.1", + "@nomicfoundation/solidity-analyzer-linux-x64-musl": "0.1.1", + "@nomicfoundation/solidity-analyzer-win32-arm64-msvc": "0.1.1", + "@nomicfoundation/solidity-analyzer-win32-ia32-msvc": "0.1.1", + "@nomicfoundation/solidity-analyzer-win32-x64-msvc": "0.1.1" + } + }, + "node_modules/@nomicfoundation/solidity-analyzer-darwin-arm64": { + "version": "0.1.1", + "resolved": "https://registry.npmjs.org/@nomicfoundation/solidity-analyzer-darwin-arm64/-/solidity-analyzer-darwin-arm64-0.1.1.tgz", + "integrity": "sha512-KcTodaQw8ivDZyF+D76FokN/HdpgGpfjc/gFCImdLUyqB6eSWVaZPazMbeAjmfhx3R0zm/NYVzxwAokFKgrc0w==", + "cpu": [ + "arm64" + ], + "dev": true, + "optional": true, + "os": [ + "darwin" + ], + "engines": { + "node": ">= 10" + } + }, + "node_modules/@nomicfoundation/solidity-analyzer-darwin-x64": { + "version": "0.1.1", + "resolved": "https://registry.npmjs.org/@nomicfoundation/solidity-analyzer-darwin-x64/-/solidity-analyzer-darwin-x64-0.1.1.tgz", + "integrity": "sha512-XhQG4BaJE6cIbjAVtzGOGbK3sn1BO9W29uhk9J8y8fZF1DYz0Doj8QDMfpMu+A6TjPDs61lbsmeYodIDnfveSA==", + "cpu": [ + "x64" + ], + "dev": true, + "optional": true, + "os": [ + "darwin" + ], + "engines": { + "node": ">= 10" + } + }, + "node_modules/@nomicfoundation/solidity-analyzer-freebsd-x64": { + "version": "0.1.1", + "resolved": "https://registry.npmjs.org/@nomicfoundation/solidity-analyzer-freebsd-x64/-/solidity-analyzer-freebsd-x64-0.1.1.tgz", + "integrity": "sha512-GHF1VKRdHW3G8CndkwdaeLkVBi5A9u2jwtlS7SLhBc8b5U/GcoL39Q+1CSO3hYqePNP+eV5YI7Zgm0ea6kMHoA==", + "cpu": [ + "x64" + ], + "dev": true, + "optional": true, + "os": [ + "freebsd" + ], + "engines": { + "node": ">= 10" + } + }, + "node_modules/@nomicfoundation/solidity-analyzer-linux-arm64-gnu": { + "version": "0.1.1", + "resolved": "https://registry.npmjs.org/@nomicfoundation/solidity-analyzer-linux-arm64-gnu/-/solidity-analyzer-linux-arm64-gnu-0.1.1.tgz", + "integrity": "sha512-g4Cv2fO37ZsUENQ2vwPnZc2zRenHyAxHcyBjKcjaSmmkKrFr64yvzeNO8S3GBFCo90rfochLs99wFVGT/0owpg==", + "cpu": [ + "arm64" + ], + "dev": true, + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">= 10" + } + }, + "node_modules/@nomicfoundation/solidity-analyzer-linux-arm64-musl": { + "version": "0.1.1", + "resolved": "https://registry.npmjs.org/@nomicfoundation/solidity-analyzer-linux-arm64-musl/-/solidity-analyzer-linux-arm64-musl-0.1.1.tgz", + "integrity": "sha512-WJ3CE5Oek25OGE3WwzK7oaopY8xMw9Lhb0mlYuJl/maZVo+WtP36XoQTb7bW/i8aAdHW5Z+BqrHMux23pvxG3w==", + "cpu": [ + "arm64" + ], + "dev": true, + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">= 10" + } + }, + "node_modules/@nomicfoundation/solidity-analyzer-linux-x64-gnu": { + "version": "0.1.1", + "resolved": "https://registry.npmjs.org/@nomicfoundation/solidity-analyzer-linux-x64-gnu/-/solidity-analyzer-linux-x64-gnu-0.1.1.tgz", + "integrity": "sha512-5WN7leSr5fkUBBjE4f3wKENUy9HQStu7HmWqbtknfXkkil+eNWiBV275IOlpXku7v3uLsXTOKpnnGHJYI2qsdA==", + "cpu": [ + "x64" + ], + "dev": true, + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">= 10" + } + }, + "node_modules/@nomicfoundation/solidity-analyzer-linux-x64-musl": { + "version": "0.1.1", + "resolved": "https://registry.npmjs.org/@nomicfoundation/solidity-analyzer-linux-x64-musl/-/solidity-analyzer-linux-x64-musl-0.1.1.tgz", + "integrity": "sha512-KdYMkJOq0SYPQMmErv/63CwGwMm5XHenEna9X9aB8mQmhDBrYrlAOSsIPgFCUSL0hjxE3xHP65/EPXR/InD2+w==", + "cpu": [ + "x64" + ], + "dev": true, + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">= 10" + } + }, + "node_modules/@nomicfoundation/solidity-analyzer-win32-arm64-msvc": { + "version": "0.1.1", + "resolved": "https://registry.npmjs.org/@nomicfoundation/solidity-analyzer-win32-arm64-msvc/-/solidity-analyzer-win32-arm64-msvc-0.1.1.tgz", + "integrity": "sha512-VFZASBfl4qiBYwW5xeY20exWhmv6ww9sWu/krWSesv3q5hA0o1JuzmPHR4LPN6SUZj5vcqci0O6JOL8BPw+APg==", + "cpu": [ + "arm64" + ], + "dev": true, + "optional": true, + "os": [ + "win32" + ], + "engines": { + "node": ">= 10" + } + }, + "node_modules/@nomicfoundation/solidity-analyzer-win32-ia32-msvc": { + "version": "0.1.1", + "resolved": "https://registry.npmjs.org/@nomicfoundation/solidity-analyzer-win32-ia32-msvc/-/solidity-analyzer-win32-ia32-msvc-0.1.1.tgz", + "integrity": "sha512-JnFkYuyCSA70j6Si6cS1A9Gh1aHTEb8kOTBApp/c7NRTFGNMH8eaInKlyuuiIbvYFhlXW4LicqyYuWNNq9hkpQ==", + "cpu": [ + "ia32" + ], + "dev": true, + "optional": true, + "os": [ + "win32" + ], + "engines": { + "node": ">= 10" + } + }, + "node_modules/@nomicfoundation/solidity-analyzer-win32-x64-msvc": { + "version": "0.1.1", + "resolved": "https://registry.npmjs.org/@nomicfoundation/solidity-analyzer-win32-x64-msvc/-/solidity-analyzer-win32-x64-msvc-0.1.1.tgz", + "integrity": "sha512-HrVJr6+WjIXGnw3Q9u6KQcbZCtk0caVWhCdFADySvRyUxJ8PnzlaP+MhwNE8oyT8OZ6ejHBRrrgjSqDCFXGirw==", + "cpu": [ + "x64" + ], + "dev": true, + "optional": true, + "os": [ + "win32" + ], + "engines": { + "node": ">= 10" + } + }, + "node_modules/@nomiclabs/hardhat-ethers": { + "version": "2.2.3", + "resolved": "https://registry.npmjs.org/@nomiclabs/hardhat-ethers/-/hardhat-ethers-2.2.3.tgz", + "integrity": "sha512-YhzPdzb612X591FOe68q+qXVXGG2ANZRvDo0RRUtimev85rCrAlv/TLMEZw5c+kq9AbzocLTVX/h2jVIFPL9Xg==", + "dev": true, + "peer": true, + "peerDependencies": { + "ethers": "^5.0.0", + "hardhat": "^2.0.0" + } + }, + "node_modules/@nomiclabs/hardhat-etherscan": { + "version": "3.1.7", + "resolved": "https://registry.npmjs.org/@nomiclabs/hardhat-etherscan/-/hardhat-etherscan-3.1.7.tgz", + "integrity": "sha512-tZ3TvSgpvsQ6B6OGmo1/Au6u8BrAkvs1mIC/eURA3xgIfznUZBhmpne8hv7BXUzw9xNL3fXdpOYgOQlVMTcoHQ==", + "dev": true, + "peer": true, + "dependencies": { + "@ethersproject/abi": "^5.1.2", + "@ethersproject/address": "^5.0.2", + "cbor": "^8.1.0", + "chalk": "^2.4.2", + "debug": "^4.1.1", + "fs-extra": "^7.0.1", + "lodash": "^4.17.11", + "semver": "^6.3.0", + "table": "^6.8.0", + "undici": "^5.14.0" + }, + "peerDependencies": { + "hardhat": "^2.0.4" + } + }, + "node_modules/@openzeppelin/contracts": { + "version": "4.8.3", + "resolved": "https://registry.npmjs.org/@openzeppelin/contracts/-/contracts-4.8.3.tgz", + "integrity": "sha512-bQHV8R9Me8IaJoJ2vPG4rXcL7seB7YVuskr4f+f5RyOStSZetwzkWtoqDMl5erkBJy0lDRUnIR2WIkPiC0GJlg==", + "dev": true + }, + "node_modules/@scure/base": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/@scure/base/-/base-1.1.1.tgz", + "integrity": "sha512-ZxOhsSyxYwLJj3pLZCefNitxsj093tb2vq90mp2txoYeBqbcjDjqFhyM8eUjq/uFm6zJ+mUuqxlS2FkuSY1MTA==", + "dev": true, + "funding": [ + { + "type": "individual", + "url": "https://paulmillr.com/funding/" + } + ] + }, + "node_modules/@scure/bip32": { + "version": "1.1.5", + "resolved": "https://registry.npmjs.org/@scure/bip32/-/bip32-1.1.5.tgz", + "integrity": "sha512-XyNh1rB0SkEqd3tXcXMi+Xe1fvg+kUIcoRIEujP1Jgv7DqW2r9lg3Ah0NkFaCs9sTkQAQA8kw7xiRXzENi9Rtw==", + "dev": true, + "funding": [ + { + "type": "individual", + "url": "https://paulmillr.com/funding/" + } + ], + "dependencies": { + "@noble/hashes": "~1.2.0", + "@noble/secp256k1": "~1.7.0", + "@scure/base": "~1.1.0" + } + }, + "node_modules/@scure/bip39": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/@scure/bip39/-/bip39-1.1.1.tgz", + "integrity": "sha512-t+wDck2rVkh65Hmv280fYdVdY25J9YeEUIgn2LG1WM6gxFkGzcksoDiUkWVpVp3Oex9xGC68JU2dSbUfwZ2jPg==", + "dev": true, + "funding": [ + { + "type": "individual", + "url": "https://paulmillr.com/funding/" + } + ], + "dependencies": { + "@noble/hashes": "~1.2.0", + "@scure/base": "~1.1.0" + } + }, + "node_modules/@sentry/core": { + "version": "5.30.0", + "resolved": "https://registry.npmjs.org/@sentry/core/-/core-5.30.0.tgz", + "integrity": "sha512-TmfrII8w1PQZSZgPpUESqjB+jC6MvZJZdLtE/0hZ+SrnKhW3x5WlYLvTXZpcWePYBku7rl2wn1RZu6uT0qCTeg==", + "dev": true, + "dependencies": { + "@sentry/hub": "5.30.0", + "@sentry/minimal": "5.30.0", + "@sentry/types": "5.30.0", + "@sentry/utils": "5.30.0", + "tslib": "^1.9.3" + }, + "engines": { + "node": ">=6" + } + }, + "node_modules/@sentry/hub": { + "version": "5.30.0", + "resolved": "https://registry.npmjs.org/@sentry/hub/-/hub-5.30.0.tgz", + "integrity": "sha512-2tYrGnzb1gKz2EkMDQcfLrDTvmGcQPuWxLnJKXJvYTQDGLlEvi2tWz1VIHjunmOvJrB5aIQLhm+dcMRwFZDCqQ==", + "dev": true, + "dependencies": { + "@sentry/types": "5.30.0", + "@sentry/utils": "5.30.0", + "tslib": "^1.9.3" + }, + "engines": { + "node": ">=6" + } + }, + "node_modules/@sentry/minimal": { + "version": "5.30.0", + "resolved": "https://registry.npmjs.org/@sentry/minimal/-/minimal-5.30.0.tgz", + "integrity": "sha512-BwWb/owZKtkDX+Sc4zCSTNcvZUq7YcH3uAVlmh/gtR9rmUvbzAA3ewLuB3myi4wWRAMEtny6+J/FN/x+2wn9Xw==", + "dev": true, + "dependencies": { + "@sentry/hub": "5.30.0", + "@sentry/types": "5.30.0", + "tslib": "^1.9.3" + }, + "engines": { + "node": ">=6" + } + }, + "node_modules/@sentry/node": { + "version": "5.30.0", + "resolved": "https://registry.npmjs.org/@sentry/node/-/node-5.30.0.tgz", + "integrity": "sha512-Br5oyVBF0fZo6ZS9bxbJZG4ApAjRqAnqFFurMVJJdunNb80brh7a5Qva2kjhm+U6r9NJAB5OmDyPkA1Qnt+QVg==", + "dev": true, + "dependencies": { + "@sentry/core": "5.30.0", + "@sentry/hub": "5.30.0", + "@sentry/tracing": "5.30.0", + "@sentry/types": "5.30.0", + "@sentry/utils": "5.30.0", + "cookie": "^0.4.1", + "https-proxy-agent": "^5.0.0", + "lru_map": "^0.3.3", + "tslib": "^1.9.3" + }, + "engines": { + "node": ">=6" + } + }, + "node_modules/@sentry/tracing": { + "version": "5.30.0", + "resolved": "https://registry.npmjs.org/@sentry/tracing/-/tracing-5.30.0.tgz", + "integrity": "sha512-dUFowCr0AIMwiLD7Fs314Mdzcug+gBVo/+NCMyDw8tFxJkwWAKl7Qa2OZxLQ0ZHjakcj1hNKfCQJ9rhyfOl4Aw==", + "dev": true, + "dependencies": { + "@sentry/hub": "5.30.0", + "@sentry/minimal": "5.30.0", + "@sentry/types": "5.30.0", + "@sentry/utils": "5.30.0", + "tslib": "^1.9.3" + }, + "engines": { + "node": ">=6" + } + }, + "node_modules/@sentry/types": { + "version": "5.30.0", + "resolved": "https://registry.npmjs.org/@sentry/types/-/types-5.30.0.tgz", + "integrity": "sha512-R8xOqlSTZ+htqrfteCWU5Nk0CDN5ApUTvrlvBuiH1DyP6czDZ4ktbZB0hAgBlVcK0U+qpD3ag3Tqqpa5Q67rPw==", + "dev": true, + "engines": { + "node": ">=6" + } + }, + "node_modules/@sentry/utils": { + "version": "5.30.0", + "resolved": "https://registry.npmjs.org/@sentry/utils/-/utils-5.30.0.tgz", + "integrity": "sha512-zaYmoH0NWWtvnJjC9/CBseXMtKHm/tm40sz3YfJRxeQjyzRqNQPgivpd9R/oDJCYj999mzdW382p/qi2ypjLww==", + "dev": true, + "dependencies": { + "@sentry/types": "5.30.0", + "tslib": "^1.9.3" + }, + "engines": { + "node": ">=6" + } + }, + "node_modules/@solidity-parser/parser": { + "version": "0.14.5", + "resolved": "https://registry.npmjs.org/@solidity-parser/parser/-/parser-0.14.5.tgz", + "integrity": "sha512-6dKnHZn7fg/iQATVEzqyUOyEidbn05q7YA2mQ9hC0MMXhhV3/JrsxmFSYZAcr7j1yUP700LLhTruvJ3MiQmjJg==", + "dev": true, + "peer": true, + "dependencies": { + "antlr4ts": "^0.5.0-alpha.4" + } + }, + "node_modules/@tsconfig/node10": { + "version": "1.0.9", + "resolved": "https://registry.npmjs.org/@tsconfig/node10/-/node10-1.0.9.tgz", + "integrity": "sha512-jNsYVVxU8v5g43Erja32laIDHXeoNvFEpX33OK4d6hljo3jDhCBDhx5dhCCTMWUojscpAagGiRkBKxpdl9fxqA==", + "dev": true, + "peer": true + }, + "node_modules/@tsconfig/node12": { + "version": "1.0.11", + "resolved": "https://registry.npmjs.org/@tsconfig/node12/-/node12-1.0.11.tgz", + "integrity": "sha512-cqefuRsh12pWyGsIoBKJA9luFu3mRxCA+ORZvA4ktLSzIuCUtWVxGIuXigEwO5/ywWFMZ2QEGKWvkZG1zDMTag==", + "dev": true, + "peer": true + }, + "node_modules/@tsconfig/node14": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/@tsconfig/node14/-/node14-1.0.3.tgz", + "integrity": "sha512-ysT8mhdixWK6Hw3i1V2AeRqZ5WfXg1G43mqoYlM2nc6388Fq5jcXyr5mRsqViLx/GJYdoL0bfXD8nmF+Zn/Iow==", + "dev": true, + "peer": true + }, + "node_modules/@tsconfig/node16": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/@tsconfig/node16/-/node16-1.0.3.tgz", + "integrity": "sha512-yOlFc+7UtL/89t2ZhjPvvB/DeAr3r+Dq58IgzsFkOAvVC6NMJXmCGjbptdXdR9qsX7pKcTL+s87FtYREi2dEEQ==", + "dev": true, + "peer": true + }, + "node_modules/@typechain/ethers-v5": { + "version": "10.2.0", + "resolved": "https://registry.npmjs.org/@typechain/ethers-v5/-/ethers-v5-10.2.0.tgz", + "integrity": "sha512-ikaq0N/w9fABM+G01OFmU3U3dNnyRwEahkdvi9mqy1a3XwKiPZaF/lu54OcNaEWnpvEYyhhS0N7buCtLQqC92w==", + "dev": true, + "peer": true, + "dependencies": { + "lodash": "^4.17.15", + "ts-essentials": "^7.0.1" + }, + "peerDependencies": { + "@ethersproject/abi": "^5.0.0", + "@ethersproject/bytes": "^5.0.0", + "@ethersproject/providers": "^5.0.0", + "ethers": "^5.1.3", + "typechain": "^8.1.1", + "typescript": ">=4.3.0" + } + }, + "node_modules/@typechain/hardhat": { + "version": "6.1.5", + "resolved": "https://registry.npmjs.org/@typechain/hardhat/-/hardhat-6.1.5.tgz", + "integrity": "sha512-lg7LW4qDZpxFMknp3Xool61Fg6Lays8F8TXdFGBG+MxyYcYU5795P1U2XdStuzGq9S2Dzdgh+1jGww9wvZ6r4Q==", + "dev": true, + "peer": true, + "dependencies": { + "fs-extra": "^9.1.0" + }, + "peerDependencies": { + "@ethersproject/abi": "^5.4.7", + "@ethersproject/providers": "^5.4.7", + "@typechain/ethers-v5": "^10.2.0", + "ethers": "^5.4.7", + "hardhat": "^2.9.9", + "typechain": "^8.1.1" + } + }, + "node_modules/@typechain/hardhat/node_modules/fs-extra": { + "version": "9.1.0", + "resolved": "https://registry.npmjs.org/fs-extra/-/fs-extra-9.1.0.tgz", + "integrity": "sha512-hcg3ZmepS30/7BSFqRvoo3DOMQu7IjqxO5nCDt+zM9XWjb33Wg7ziNT+Qvqbuc3+gWpzO02JubVyk2G4Zvo1OQ==", + "dev": true, + "peer": true, + "dependencies": { + "at-least-node": "^1.0.0", + "graceful-fs": "^4.2.0", + "jsonfile": "^6.0.1", + "universalify": "^2.0.0" + }, + "engines": { + "node": ">=10" + } + }, + "node_modules/@typechain/hardhat/node_modules/jsonfile": { + "version": "6.1.0", + "resolved": "https://registry.npmjs.org/jsonfile/-/jsonfile-6.1.0.tgz", + "integrity": "sha512-5dgndWOriYSm5cnYaJNhalLNDKOqFwyDB/rr1E9ZsGciGvKPs8R2xYGCacuf3z6K1YKDz182fd+fY3cn3pMqXQ==", + "dev": true, + "peer": true, + "dependencies": { + "universalify": "^2.0.0" + }, + "optionalDependencies": { + "graceful-fs": "^4.1.6" + } + }, + "node_modules/@typechain/hardhat/node_modules/universalify": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/universalify/-/universalify-2.0.0.tgz", + "integrity": "sha512-hAZsKq7Yy11Zu1DE0OzWjw7nnLZmJZYTDZZyEFHZdUhV8FkH5MCfoU1XMaxXovpyW5nq5scPqq0ZDP9Zyl04oQ==", + "dev": true, + "peer": true, + "engines": { + "node": ">= 10.0.0" + } + }, + "node_modules/@types/bn.js": { + "version": "5.1.1", + "resolved": "https://registry.npmjs.org/@types/bn.js/-/bn.js-5.1.1.tgz", + "integrity": "sha512-qNrYbZqMx0uJAfKnKclPh+dTwK33KfLHYqtyODwd5HnXOjnkhc4qgn3BrK6RWyGZm5+sIFE7Q7Vz6QQtJB7w7g==", + "dev": true, + "dependencies": { + "@types/node": "*" + } + }, + "node_modules/@types/chai": { + "version": "4.3.5", + "resolved": "https://registry.npmjs.org/@types/chai/-/chai-4.3.5.tgz", + "integrity": "sha512-mEo1sAde+UCE6b2hxn332f1g1E8WfYRu6p5SvTKr2ZKC1f7gFJXk4h5PyGP9Dt6gCaG8y8XhwnXWC6Iy2cmBng==", + "dev": true, + "peer": true + }, + "node_modules/@types/chai-as-promised": { + "version": "7.1.5", + "resolved": "https://registry.npmjs.org/@types/chai-as-promised/-/chai-as-promised-7.1.5.tgz", + "integrity": "sha512-jStwss93SITGBwt/niYrkf2C+/1KTeZCZl1LaeezTlqppAKeoQC7jxyqYuP72sxBGKCIbw7oHgbYssIRzT5FCQ==", + "dev": true, + "peer": true, + "dependencies": { + "@types/chai": "*" + } + }, + "node_modules/@types/concat-stream": { + "version": "1.6.1", + "resolved": "https://registry.npmjs.org/@types/concat-stream/-/concat-stream-1.6.1.tgz", + "integrity": "sha512-eHE4cQPoj6ngxBZMvVf6Hw7Mh4jMW4U9lpGmS5GBPB9RYxlFg+CHaVN7ErNY4W9XfLIEn20b4VDYaIrbq0q4uA==", + "dev": true, + "peer": true, + "dependencies": { + "@types/node": "*" + } + }, + "node_modules/@types/form-data": { + "version": "0.0.33", + "resolved": "https://registry.npmjs.org/@types/form-data/-/form-data-0.0.33.tgz", + "integrity": "sha512-8BSvG1kGm83cyJITQMZSulnl6QV8jqAGreJsc5tPu1Jq0vTSOiY/k24Wx82JRpWwZSqrala6sd5rWi6aNXvqcw==", + "dev": true, + "peer": true, + "dependencies": { + "@types/node": "*" + } + }, + "node_modules/@types/glob": { + "version": "7.2.0", + "resolved": "https://registry.npmjs.org/@types/glob/-/glob-7.2.0.tgz", + "integrity": "sha512-ZUxbzKl0IfJILTS6t7ip5fQQM/J3TJYubDm3nMbgubNNYS62eXeUpoLUC8/7fJNiFYHTrGPQn7hspDUzIHX3UA==", + "dev": true, + "peer": true, + "dependencies": { + "@types/minimatch": "*", + "@types/node": "*" + } + }, + "node_modules/@types/lru-cache": { + "version": "5.1.1", + "resolved": "https://registry.npmjs.org/@types/lru-cache/-/lru-cache-5.1.1.tgz", + "integrity": "sha512-ssE3Vlrys7sdIzs5LOxCzTVMsU7i9oa/IaW92wF32JFb3CVczqOkru2xspuKczHEbG3nvmPY7IFqVmGGHdNbYw==", + "dev": true + }, + "node_modules/@types/minimatch": { + "version": "5.1.2", + "resolved": "https://registry.npmjs.org/@types/minimatch/-/minimatch-5.1.2.tgz", + "integrity": "sha512-K0VQKziLUWkVKiRVrx4a40iPaxTUefQmjtkQofBkYRcoaaL/8rhwDWww9qWbrgicNOgnpIsMxyNIUM4+n6dUIA==", + "dev": true, + "peer": true + }, + "node_modules/@types/mocha": { + "version": "10.0.1", + "resolved": "https://registry.npmjs.org/@types/mocha/-/mocha-10.0.1.tgz", + "integrity": "sha512-/fvYntiO1GeICvqbQ3doGDIP97vWmvFt83GKguJ6prmQM2iXZfFcq6YE8KteFyRtX2/h5Hf91BYvPodJKFYv5Q==", + "dev": true, + "peer": true + }, + "node_modules/@types/node": { + "version": "18.16.3", + "resolved": "https://registry.npmjs.org/@types/node/-/node-18.16.3.tgz", + "integrity": "sha512-OPs5WnnT1xkCBiuQrZA4+YAV4HEJejmHneyraIaxsbev5yCEr6KMwINNFP9wQeFIw8FWcoTqF3vQsa5CDaI+8Q==", + "dev": true + }, + "node_modules/@types/pbkdf2": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/@types/pbkdf2/-/pbkdf2-3.1.0.tgz", + "integrity": "sha512-Cf63Rv7jCQ0LaL8tNXmEyqTHuIJxRdlS5vMh1mj5voN4+QFhVZnlZruezqpWYDiJ8UTzhP0VmeLXCmBk66YrMQ==", + "dev": true, + "dependencies": { + "@types/node": "*" + } + }, + "node_modules/@types/prettier": { + "version": "2.7.2", + "resolved": "https://registry.npmjs.org/@types/prettier/-/prettier-2.7.2.tgz", + "integrity": "sha512-KufADq8uQqo1pYKVIYzfKbJfBAc0sOeXqGbFaSpv8MRmC/zXgowNZmFcbngndGk922QDmOASEXUZCaY48gs4cg==", + "dev": true, + "peer": true + }, + "node_modules/@types/qs": { + "version": "6.9.7", + "resolved": "https://registry.npmjs.org/@types/qs/-/qs-6.9.7.tgz", + "integrity": "sha512-FGa1F62FT09qcrueBA6qYTrJPVDzah9a+493+o2PCXsesWHIn27G98TsSMs3WPNbZIEj4+VJf6saSFpvD+3Zsw==", + "dev": true, + "peer": true + }, + "node_modules/@types/readable-stream": { + "version": "2.3.15", + "resolved": "https://registry.npmjs.org/@types/readable-stream/-/readable-stream-2.3.15.tgz", + "integrity": "sha512-oM5JSKQCcICF1wvGgmecmHldZ48OZamtMxcGGVICOJA8o8cahXC1zEVAif8iwoc5j8etxFaRFnf095+CDsuoFQ==", + "dev": true, + "dependencies": { + "@types/node": "*", + "safe-buffer": "~5.1.1" + } + }, + "node_modules/@types/secp256k1": { + "version": "4.0.3", + "resolved": "https://registry.npmjs.org/@types/secp256k1/-/secp256k1-4.0.3.tgz", + "integrity": "sha512-Da66lEIFeIz9ltsdMZcpQvmrmmoqrfju8pm1BH8WbYjZSwUgCwXLb9C+9XYogwBITnbsSaMdVPb2ekf7TV+03w==", + "dev": true, + "dependencies": { + "@types/node": "*" + } + }, + "node_modules/abbrev": { + "version": "1.0.9", + "resolved": "https://registry.npmjs.org/abbrev/-/abbrev-1.0.9.tgz", + "integrity": "sha512-LEyx4aLEC3x6T0UguF6YILf+ntvmOaWsVfENmIW0E9H09vKlLDGelMjjSm0jkDHALj8A8quZ/HapKNigzwge+Q==", + "dev": true, + "peer": true + }, + "node_modules/abort-controller": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/abort-controller/-/abort-controller-3.0.0.tgz", + "integrity": "sha512-h8lQ8tacZYnR3vNQTgibj+tODHI5/+l06Au2Pcriv/Gmet0eaj4TwWH41sO9wnHDiQsEj19q0drzdWdeAHtweg==", + "dev": true, + "dependencies": { + "event-target-shim": "^5.0.0" + }, + "engines": { + "node": ">=6.5" + } + }, + "node_modules/abstract-level": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/abstract-level/-/abstract-level-1.0.3.tgz", + "integrity": "sha512-t6jv+xHy+VYwc4xqZMn2Pa9DjcdzvzZmQGRjTFc8spIbRGHgBrEKbPq+rYXc7CCo0lxgYvSgKVg9qZAhpVQSjA==", + "dev": true, + "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" + }, + "engines": { + "node": ">=12" + } + }, + "node_modules/acorn": { + "version": "8.8.2", + "resolved": "https://registry.npmjs.org/acorn/-/acorn-8.8.2.tgz", + "integrity": "sha512-xjIYgE8HBrkpd/sJqOGNspf8uHG+NOHGOw6a/Urj8taM2EXfdNAH2oFcPeIFfsv3+kz/mJrS5VuMqbNLjCa2vw==", + "dev": true, + "peer": true, + "bin": { + "acorn": "bin/acorn" + }, + "engines": { + "node": ">=0.4.0" + } + }, + "node_modules/acorn-walk": { + "version": "8.2.0", + "resolved": "https://registry.npmjs.org/acorn-walk/-/acorn-walk-8.2.0.tgz", + "integrity": "sha512-k+iyHEuPgSw6SbuDpGQM+06HQUa04DZ3o+F6CSzXMvvI5KMvnaEqXe+YVe555R9nn6GPt404fos4wcgpw12SDA==", + "dev": true, + "peer": true, + "engines": { + "node": ">=0.4.0" + } + }, + "node_modules/address": { + "version": "1.2.2", + "resolved": "https://registry.npmjs.org/address/-/address-1.2.2.tgz", + "integrity": "sha512-4B/qKCfeE/ODUaAUpSwfzazo5x29WD4r3vXiWsB7I2mSDAihwEqKO+g8GELZUQSSAo5e1XTYh3ZVfLyxBc12nA==", + "dev": true, + "peer": true, + "engines": { + "node": ">= 10.0.0" + } + }, + "node_modules/adm-zip": { + "version": "0.4.16", + "resolved": "https://registry.npmjs.org/adm-zip/-/adm-zip-0.4.16.tgz", + "integrity": "sha512-TFi4HBKSGfIKsK5YCkKaaFG2m4PEDyViZmEwof3MTIgzimHLto6muaHVpbrljdIvIrFZzEq/p4nafOeLcYegrg==", + "dev": true, + "engines": { + "node": ">=0.3.0" + } + }, + "node_modules/aes-js": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/aes-js/-/aes-js-3.0.0.tgz", + "integrity": "sha512-H7wUZRn8WpTq9jocdxQ2c8x2sKo9ZVmzfRE13GiNJXfp7NcKYEdvl3vspKjXox6RIG2VtaRe4JFvxG4rqp2Zuw==", + "dev": true + }, + "node_modules/agent-base": { + "version": "6.0.2", + "resolved": "https://registry.npmjs.org/agent-base/-/agent-base-6.0.2.tgz", + "integrity": "sha512-RZNwNclF7+MS/8bDg70amg32dyeZGZxiDuQmZxKLAlQjr3jGyLx+4Kkk58UO7D2QdgFIQCovuSuZESne6RG6XQ==", + "dev": true, + "dependencies": { + "debug": "4" + }, + "engines": { + "node": ">= 6.0.0" + } + }, + "node_modules/aggregate-error": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/aggregate-error/-/aggregate-error-3.1.0.tgz", + "integrity": "sha512-4I7Td01quW/RpocfNayFdFVk1qSuoh0E7JrbRJ16nH01HhKFQ88INq9Sd+nd72zqRySlr9BmDA8xlEJ6vJMrYA==", + "dev": true, + "dependencies": { + "clean-stack": "^2.0.0", + "indent-string": "^4.0.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/ajv": { + "version": "6.12.6", + "resolved": "https://registry.npmjs.org/ajv/-/ajv-6.12.6.tgz", + "integrity": "sha512-j3fVLgvTo527anyYyJOGTYJbG+vnnQYvE0m5mmkc1TK+nxAppkCLMIL0aZ4dblVCNoGShhm+kzE4ZUykBoMg4g==", + "dev": true, + "peer": true, + "dependencies": { + "fast-deep-equal": "^3.1.1", + "fast-json-stable-stringify": "^2.0.0", + "json-schema-traverse": "^0.4.1", + "uri-js": "^4.2.2" + }, + "funding": { + "type": "github", + "url": "https://github.com/sponsors/epoberezkin" + } + }, + "node_modules/amdefine": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/amdefine/-/amdefine-1.0.1.tgz", + "integrity": "sha512-S2Hw0TtNkMJhIabBwIojKL9YHO5T0n5eNqWJ7Lrlel/zDbftQpxpapi8tZs3X1HWa+u+QeydGmzzNU0m09+Rcg==", + "dev": true, + "optional": true, + "peer": true, + "engines": { + "node": ">=0.4.2" + } + }, + "node_modules/ansi-colors": { + "version": "4.1.3", + "resolved": "https://registry.npmjs.org/ansi-colors/-/ansi-colors-4.1.3.tgz", + "integrity": "sha512-/6w/C21Pm1A7aZitlI5Ni/2J6FFQN8i1Cvz3kHABAAbw93v/NlvKdVOqz7CCWz/3iv/JplRSEEZ83XION15ovw==", + "dev": true, + "engines": { + "node": ">=6" + } + }, + "node_modules/ansi-escapes": { + "version": "4.3.2", + "resolved": "https://registry.npmjs.org/ansi-escapes/-/ansi-escapes-4.3.2.tgz", + "integrity": "sha512-gKXj5ALrKWQLsYG9jlTRmR/xKluxHV+Z9QEwNIgCfM1/uwPMCuzVVnh5mwTd+OuBZcwSIMbqssNWRm1lE51QaQ==", + "dev": true, + "dependencies": { + "type-fest": "^0.21.3" + }, + "engines": { + "node": ">=8" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/ansi-regex": { + "version": "5.0.1", + "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-5.0.1.tgz", + "integrity": "sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ==", + "dev": true, + "engines": { + "node": ">=8" + } + }, + "node_modules/ansi-styles": { + "version": "3.2.1", + "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-3.2.1.tgz", + "integrity": "sha512-VT0ZI6kZRdTh8YyJw3SMbYm/u+NqfsAxEpWO0Pf9sq8/e94WxxOpPKx9FR1FlyCtOVDNOQ+8ntlqFxiRc+r5qA==", + "dev": true, + "dependencies": { + "color-convert": "^1.9.0" + }, + "engines": { + "node": ">=4" + } + }, + "node_modules/antlr4ts": { + "version": "0.5.0-alpha.4", + "resolved": "https://registry.npmjs.org/antlr4ts/-/antlr4ts-0.5.0-alpha.4.tgz", + "integrity": "sha512-WPQDt1B74OfPv/IMS2ekXAKkTZIHl88uMetg6q3OTqgFxZ/dxDXI0EWLyZid/1Pe6hTftyg5N7gel5wNAGxXyQ==", + "dev": true, + "peer": true + }, + "node_modules/anymatch": { + "version": "3.1.3", + "resolved": "https://registry.npmjs.org/anymatch/-/anymatch-3.1.3.tgz", + "integrity": "sha512-KMReFUr0B4t+D+OBkjR3KYqvocp2XaSzO55UcB6mgQMd3KbcE+mWTyvVV7D/zsdEbNnV6acZUutkiHQXvTr1Rw==", + "dev": true, + "dependencies": { + "normalize-path": "^3.0.0", + "picomatch": "^2.0.4" + }, + "engines": { + "node": ">= 8" + } + }, + "node_modules/arg": { + "version": "4.1.3", + "resolved": "https://registry.npmjs.org/arg/-/arg-4.1.3.tgz", + "integrity": "sha512-58S9QDqG0Xx27YwPSt9fJxivjYl432YCwfDMfZ+71RAqUrZef7LrKQZ3LHLOwCS4FLNBplP533Zx895SeOCHvA==", + "dev": true, + "peer": true + }, + "node_modules/argparse": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/argparse/-/argparse-2.0.1.tgz", + "integrity": "sha512-8+9WqebbFzpX9OR+Wa6O29asIogeRMzcGtAINdpMHHyAg10f05aSFVBbcEqGf/PXw1EjAZ+q2/bEBg3DvurK3Q==", + "dev": true + }, + "node_modules/array-back": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/array-back/-/array-back-3.1.0.tgz", + "integrity": "sha512-TkuxA4UCOvxuDK6NZYXCalszEzj+TLszyASooky+i742l9TqsOdYCMJJupxRic61hwquNtppB3hgcuq9SVSH1Q==", + "dev": true, + "peer": true, + "engines": { + "node": ">=6" + } + }, + "node_modules/array-buffer-byte-length": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/array-buffer-byte-length/-/array-buffer-byte-length-1.0.0.tgz", + "integrity": "sha512-LPuwb2P+NrQw3XhxGc36+XSvuBPopovXYTR9Ew++Du9Yb/bx5AzBfrIsBoj0EZUifjQU+sHL21sseZ3jerWO/A==", + "dev": true, + "peer": true, + "dependencies": { + "call-bind": "^1.0.2", + "is-array-buffer": "^3.0.1" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/array-union": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/array-union/-/array-union-2.1.0.tgz", + "integrity": "sha512-HGyxoOTYUyCM6stUe6EJgnd4EoewAI7zMdfqO+kGjnlZmBDz/cR5pf8r/cR4Wq60sL/p0IkcjUEEPwS3GFrIyw==", + "dev": true, + "peer": true, + "engines": { + "node": ">=8" + } + }, + "node_modules/array-uniq": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/array-uniq/-/array-uniq-1.0.3.tgz", + "integrity": "sha512-MNha4BWQ6JbwhFhj03YK552f7cb3AzoE8SzeljgChvL1dl3IcvggXVz1DilzySZkCja+CXuZbdW7yATchWn8/Q==", + "dev": true, + "peer": true, + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/array.prototype.reduce": { + "version": "1.0.5", + "resolved": "https://registry.npmjs.org/array.prototype.reduce/-/array.prototype.reduce-1.0.5.tgz", + "integrity": "sha512-kDdugMl7id9COE8R7MHF5jWk7Dqt/fs4Pv+JXoICnYwqpjjjbUurz6w5fT5IG6brLdJhv6/VoHB0H7oyIBXd+Q==", + "dev": true, + "peer": true, + "dependencies": { + "call-bind": "^1.0.2", + "define-properties": "^1.1.4", + "es-abstract": "^1.20.4", + "es-array-method-boxes-properly": "^1.0.0", + "is-string": "^1.0.7" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/asap": { + "version": "2.0.6", + "resolved": "https://registry.npmjs.org/asap/-/asap-2.0.6.tgz", + "integrity": "sha512-BSHWgDSAiKs50o2Re8ppvp3seVHXSRM44cdSsT9FfNEUUZLOGWVCsiWaRPWM1Znn+mqZ1OfVZ3z3DWEzSp7hRA==", + "dev": true, + "peer": true + }, + "node_modules/asn1": { + "version": "0.2.6", + "resolved": "https://registry.npmjs.org/asn1/-/asn1-0.2.6.tgz", + "integrity": "sha512-ix/FxPn0MDjeyJ7i/yoHGFt/EX6LyNbxSEhPPXODPL+KB0VPk86UYfL0lMdy+KCnv+fmvIzySwaK5COwqVbWTQ==", + "dev": true, + "peer": true, + "dependencies": { + "safer-buffer": "~2.1.0" + } + }, + "node_modules/assert-plus": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/assert-plus/-/assert-plus-1.0.0.tgz", + "integrity": "sha512-NfJ4UzBCcQGLDlQq7nHxH+tv3kyZ0hHQqF5BO6J7tNJeP5do1llPr8dZ8zHonfhAu0PHAdMkSo+8o0wxg9lZWw==", + "dev": true, + "peer": true, + "engines": { + "node": ">=0.8" + } + }, + "node_modules/assertion-error": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/assertion-error/-/assertion-error-1.1.0.tgz", + "integrity": "sha512-jgsaNduz+ndvGyFt3uSuWqvy4lCnIJiovtouQN5JZHOKCS2QuhEdbcQHFhVksz2N2U9hXJo8odG7ETyWlEeuDw==", + "dev": true, + "peer": true, + "engines": { + "node": "*" + } + }, + "node_modules/astral-regex": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/astral-regex/-/astral-regex-2.0.0.tgz", + "integrity": "sha512-Z7tMw1ytTXt5jqMcOP+OQteU1VuNK9Y02uuJtKQ1Sv69jXQKKg5cibLwGJow8yzZP+eAc18EmLGPal0bp36rvQ==", + "dev": true, + "peer": true, + "engines": { + "node": ">=8" + } + }, + "node_modules/async": { + "version": "1.5.2", + "resolved": "https://registry.npmjs.org/async/-/async-1.5.2.tgz", + "integrity": "sha512-nSVgobk4rv61R9PUSDtYt7mPVB2olxNR5RWJcAsH676/ef11bUZwvu7+RGYrYauVdDPcO519v68wRhXQtxsV9w==", + "dev": true, + "peer": true + }, + "node_modules/asynckit": { + "version": "0.4.0", + "resolved": "https://registry.npmjs.org/asynckit/-/asynckit-0.4.0.tgz", + "integrity": "sha512-Oei9OH4tRh0YqU3GxhX79dM/mwVgvbZJaSNaRk+bshkj0S5cfHcgYakreBjrHwatXKbz+IoIdYLxrKim2MjW0Q==", + "dev": true, + "peer": true + }, + "node_modules/at-least-node": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/at-least-node/-/at-least-node-1.0.0.tgz", + "integrity": "sha512-+q/t7Ekv1EDY2l6Gda6LLiX14rU9TV20Wa3ofeQmwPFZbOMo9DXrLbOjFaaclkXKWidIaopwAObQDqwWtGUjqg==", + "dev": true, + "peer": true, + "engines": { + "node": ">= 4.0.0" + } + }, + "node_modules/available-typed-arrays": { + "version": "1.0.5", + "resolved": "https://registry.npmjs.org/available-typed-arrays/-/available-typed-arrays-1.0.5.tgz", + "integrity": "sha512-DMD0KiN46eipeziST1LPP/STfDU0sufISXmjSgvVsoU2tqxctQeASejWcfNtxYKqETM1UxQ8sp2OrSBWpHY6sw==", + "dev": true, + "peer": true, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/aws-sign2": { + "version": "0.7.0", + "resolved": "https://registry.npmjs.org/aws-sign2/-/aws-sign2-0.7.0.tgz", + "integrity": "sha512-08kcGqnYf/YmjoRhfxyu+CLxBjUtHLXLXX/vUfx9l2LYzG3c1m61nrpyFUZI6zeS+Li/wWMMidD9KgrqtGq3mA==", + "dev": true, + "peer": true, + "engines": { + "node": "*" + } + }, + "node_modules/aws4": { + "version": "1.12.0", + "resolved": "https://registry.npmjs.org/aws4/-/aws4-1.12.0.tgz", + "integrity": "sha512-NmWvPnx0F1SfrQbYwOi7OeaNGokp9XhzNioJ/CSBs8Qa4vxug81mhJEAVZwxXuBmYB5KDRfMq/F3RR0BIU7sWg==", + "dev": true, + "peer": true + }, + "node_modules/balanced-match": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/balanced-match/-/balanced-match-1.0.2.tgz", + "integrity": "sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw==", + "dev": true + }, + "node_modules/base-x": { + "version": "3.0.9", + "resolved": "https://registry.npmjs.org/base-x/-/base-x-3.0.9.tgz", + "integrity": "sha512-H7JU6iBHTal1gp56aKoaa//YUxEaAOUiydvrV/pILqIHXTtqxSkATOnDA2u+jZ/61sD+L/412+7kzXRtWukhpQ==", + "dev": true, + "dependencies": { + "safe-buffer": "^5.0.1" + } + }, + "node_modules/base64-js": { + "version": "1.5.1", + "resolved": "https://registry.npmjs.org/base64-js/-/base64-js-1.5.1.tgz", + "integrity": "sha512-AKpaYlHn8t4SVbOHCy+b5+KKgvR4vrsD8vbvrbiQJps7fKDTkjkDry6ji0rUJjC0kzbNePLwzxq8iypo41qeWA==", + "dev": true, + "funding": [ + { + "type": "github", + "url": "https://github.com/sponsors/feross" + }, + { + "type": "patreon", + "url": "https://www.patreon.com/feross" + }, + { + "type": "consulting", + "url": "https://feross.org/support" + } + ] + }, + "node_modules/bcrypt-pbkdf": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/bcrypt-pbkdf/-/bcrypt-pbkdf-1.0.2.tgz", + "integrity": "sha512-qeFIXtP4MSoi6NLqO12WfqARWWuCKi2Rn/9hJLEmtB5yTNr9DqFWkJRCf2qShWzPeAMRnOgCrq0sg/KLv5ES9w==", + "dev": true, + "peer": true, + "dependencies": { + "tweetnacl": "^0.14.3" + } + }, + "node_modules/bcrypt-pbkdf/node_modules/tweetnacl": { + "version": "0.14.5", + "resolved": "https://registry.npmjs.org/tweetnacl/-/tweetnacl-0.14.5.tgz", + "integrity": "sha512-KXXFFdAbFXY4geFIwoyNK+f5Z1b7swfXABfL7HXCmoIWMKU3dmS26672A4EeQtDzLKy7SXmfBu51JolvEKwtGA==", + "dev": true, + "peer": true + }, + "node_modules/bech32": { + "version": "1.1.4", + "resolved": "https://registry.npmjs.org/bech32/-/bech32-1.1.4.tgz", + "integrity": "sha512-s0IrSOzLlbvX7yp4WBfPITzpAU8sqQcpsmwXDiKwrG4r491vwCO/XpejasRNl0piBMe/DvP4Tz0mIS/X1DPJBQ==", + "dev": true + }, + "node_modules/bigint-crypto-utils": { + "version": "3.2.2", + "resolved": "https://registry.npmjs.org/bigint-crypto-utils/-/bigint-crypto-utils-3.2.2.tgz", + "integrity": "sha512-U1RbE3aX9ayCUVcIPHuPDPKcK3SFOXf93J1UK/iHlJuQB7bhagPIX06/CLpLEsDThJ7KA4Dhrnzynl+d2weTiw==", + "dev": true, + "engines": { + "node": ">=14.0.0" + } + }, + "node_modules/binary-extensions": { + "version": "2.2.0", + "resolved": "https://registry.npmjs.org/binary-extensions/-/binary-extensions-2.2.0.tgz", + "integrity": "sha512-jDctJ/IVQbZoJykoeHbhXpOlNBqGNcwXJKJog42E5HDPUwQTSdjCHdihjj0DlnheQ7blbT6dHOafNAiS8ooQKA==", + "dev": true, + "engines": { + "node": ">=8" + } + }, + "node_modules/blakejs": { + "version": "1.2.1", + "resolved": "https://registry.npmjs.org/blakejs/-/blakejs-1.2.1.tgz", + "integrity": "sha512-QXUSXI3QVc/gJME0dBpXrag1kbzOqCjCX8/b54ntNyW6sjtoqxqRk3LTmXzaJoh71zMsDCjM+47jS7XiwN/+fQ==", + "dev": true + }, + "node_modules/bn.js": { + "version": "5.2.1", + "resolved": "https://registry.npmjs.org/bn.js/-/bn.js-5.2.1.tgz", + "integrity": "sha512-eXRvHzWyYPBuB4NBy0cmYQjGitUrtqwbvlzP3G6VFnNRbsZQIxQ10PbKKHt8gZ/HW/D/747aDl+QkDqg3KQLMQ==", + "dev": true + }, + "node_modules/brace-expansion": { + "version": "1.1.11", + "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.11.tgz", + "integrity": "sha512-iCuPHDFgrHX7H2vEI/5xpz07zSHB00TpugqhmYtVmMO6518mCuRMoOYFldEBl0g187ufozdaHgWKcYFb61qGiA==", + "dev": true, + "dependencies": { + "balanced-match": "^1.0.0", + "concat-map": "0.0.1" + } + }, + "node_modules/braces": { + "version": "3.0.2", + "resolved": "https://registry.npmjs.org/braces/-/braces-3.0.2.tgz", + "integrity": "sha512-b8um+L1RzM3WDSzvhm6gIz1yfTbBt6YTlcEKAvsmqCZZFw46z626lVj9j1yEPW33H5H+lBQpZMP1k8l+78Ha0A==", + "dev": true, + "dependencies": { + "fill-range": "^7.0.1" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/brorand": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/brorand/-/brorand-1.1.0.tgz", + "integrity": "sha512-cKV8tMCEpQs4hK/ik71d6LrPOnpkpGBR0wzxqr68g2m/LB2GxVYQroAjMJZRVM1Y4BCjCKc3vAamxSzOY2RP+w==", + "dev": true + }, + "node_modules/browser-level": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/browser-level/-/browser-level-1.0.1.tgz", + "integrity": "sha512-XECYKJ+Dbzw0lbydyQuJzwNXtOpbMSq737qxJN11sIRTErOMShvDpbzTlgju7orJKvx4epULolZAuJGLzCmWRQ==", + "dev": true, + "dependencies": { + "abstract-level": "^1.0.2", + "catering": "^2.1.1", + "module-error": "^1.0.2", + "run-parallel-limit": "^1.1.0" + } + }, + "node_modules/browser-stdout": { + "version": "1.3.1", + "resolved": "https://registry.npmjs.org/browser-stdout/-/browser-stdout-1.3.1.tgz", + "integrity": "sha512-qhAVI1+Av2X7qelOfAIYwXONood6XlZE/fXaBSmW/T5SzLAmCgzi+eiWE7fUvbHaeNBQH13UftjpXxsfLkMpgw==", + "dev": true + }, + "node_modules/browserify-aes": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/browserify-aes/-/browserify-aes-1.2.0.tgz", + "integrity": "sha512-+7CHXqGuspUn/Sl5aO7Ea0xWGAtETPXNSAjHo48JfLdPWcMng33Xe4znFvQweqc/uzk5zSOI3H52CYnjCfb5hA==", + "dev": true, + "dependencies": { + "buffer-xor": "^1.0.3", + "cipher-base": "^1.0.0", + "create-hash": "^1.1.0", + "evp_bytestokey": "^1.0.3", + "inherits": "^2.0.1", + "safe-buffer": "^5.0.1" + } + }, + "node_modules/bs58": { + "version": "4.0.1", + "resolved": "https://registry.npmjs.org/bs58/-/bs58-4.0.1.tgz", + "integrity": "sha512-Ok3Wdf5vOIlBrgCvTq96gBkJw+JUEzdBgyaza5HLtPm7yTHkjRy8+JzNyHF7BHa0bNWOQIp3m5YF0nnFcOIKLw==", + "dev": true, + "dependencies": { + "base-x": "^3.0.2" + } + }, + "node_modules/bs58check": { + "version": "2.1.2", + "resolved": "https://registry.npmjs.org/bs58check/-/bs58check-2.1.2.tgz", + "integrity": "sha512-0TS1jicxdU09dwJMNZtVAfzPi6Q6QeN0pM1Fkzrjn+XYHvzMKPU3pHVpva+769iNVSfIYWf7LJ6WR+BuuMf8cA==", + "dev": true, + "dependencies": { + "bs58": "^4.0.0", + "create-hash": "^1.1.0", + "safe-buffer": "^5.1.2" + } + }, + "node_modules/buffer": { + "version": "6.0.3", + "resolved": "https://registry.npmjs.org/buffer/-/buffer-6.0.3.tgz", + "integrity": "sha512-FTiCpNxtwiZZHEZbcbTIcZjERVICn9yq/pDFkTl95/AxzD1naBctN7YO68riM/gLSDY7sdrMby8hofADYuuqOA==", + "dev": true, + "funding": [ + { + "type": "github", + "url": "https://github.com/sponsors/feross" + }, + { + "type": "patreon", + "url": "https://www.patreon.com/feross" + }, + { + "type": "consulting", + "url": "https://feross.org/support" + } + ], + "dependencies": { + "base64-js": "^1.3.1", + "ieee754": "^1.2.1" + } + }, + "node_modules/buffer-from": { + "version": "1.1.2", + "resolved": "https://registry.npmjs.org/buffer-from/-/buffer-from-1.1.2.tgz", + "integrity": "sha512-E+XQCRwSbaaiChtv6k6Dwgc+bx+Bs6vuKJHHl5kox/BaKbhiXzqQOwK4cO22yElGp2OCmjwVhT3HmxgyPGnJfQ==", + "dev": true + }, + "node_modules/buffer-xor": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/buffer-xor/-/buffer-xor-1.0.3.tgz", + "integrity": "sha512-571s0T7nZWK6vB67HI5dyUF7wXiNcfaPPPTl6zYCNApANjIvYJTg7hlud/+cJpdAhS7dVzqMLmfhfHR3rAcOjQ==", + "dev": true + }, + "node_modules/busboy": { + "version": "1.6.0", + "resolved": "https://registry.npmjs.org/busboy/-/busboy-1.6.0.tgz", + "integrity": "sha512-8SFQbg/0hQ9xy3UNTB0YEnsNBbWfhf7RtnzpL7TkBiTBRfrQ9Fxcnz7VJsleJpyp6rVLvXiuORqjlHi5q+PYuA==", + "dev": true, + "dependencies": { + "streamsearch": "^1.1.0" + }, + "engines": { + "node": ">=10.16.0" + } + }, + "node_modules/bytes": { + "version": "3.1.2", + "resolved": "https://registry.npmjs.org/bytes/-/bytes-3.1.2.tgz", + "integrity": "sha512-/Nf7TyzTx6S3yRJObOAV7956r8cr2+Oj8AC5dt8wSP3BQAoeX58NoHyCU8P8zGkNXStjTSi6fzO6F0pBdcYbEg==", + "dev": true, + "engines": { + "node": ">= 0.8" + } + }, + "node_modules/call-bind": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/call-bind/-/call-bind-1.0.2.tgz", + "integrity": "sha512-7O+FbCihrB5WGbFYesctwmTKae6rOiIzmz1icreWJ+0aA7LJfuqhEso2T9ncpcFtzMQtzXf2QGGueWJGTYsqrA==", + "dev": true, + "dependencies": { + "function-bind": "^1.1.1", + "get-intrinsic": "^1.0.2" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/camelcase": { + "version": "6.3.0", + "resolved": "https://registry.npmjs.org/camelcase/-/camelcase-6.3.0.tgz", + "integrity": "sha512-Gmy6FhYlCY7uOElZUSbxo2UCDH8owEk996gkbrpsgGtrJLM3J7jGxl9Ic7Qwwj4ivOE5AWZWRMecDdF7hqGjFA==", + "dev": true, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/case": { + "version": "1.6.3", + "resolved": "https://registry.npmjs.org/case/-/case-1.6.3.tgz", + "integrity": "sha512-mzDSXIPaFwVDvZAHqZ9VlbyF4yyXRuX6IvB06WvPYkqJVO24kX1PPhv9bfpKNFZyxYFmmgo03HUiD8iklmJYRQ==", + "dev": true, + "engines": { + "node": ">= 0.8.0" + } + }, + "node_modules/caseless": { + "version": "0.12.0", + "resolved": "https://registry.npmjs.org/caseless/-/caseless-0.12.0.tgz", + "integrity": "sha512-4tYFyifaFfGacoiObjJegolkwSU4xQNGbVgUiNYVUxbQ2x2lUsFvY4hVgVzGiIe6WLOPqycWXA40l+PWsxthUw==", + "dev": true, + "peer": true + }, + "node_modules/catering": { + "version": "2.1.1", + "resolved": "https://registry.npmjs.org/catering/-/catering-2.1.1.tgz", + "integrity": "sha512-K7Qy8O9p76sL3/3m7/zLKbRkyOlSZAgzEaLhyj2mXS8PsCud2Eo4hAb8aLtZqHh0QGqLcb9dlJSu6lHRVENm1w==", + "dev": true, + "engines": { + "node": ">=6" + } + }, + "node_modules/cbor": { + "version": "8.1.0", + "resolved": "https://registry.npmjs.org/cbor/-/cbor-8.1.0.tgz", + "integrity": "sha512-DwGjNW9omn6EwP70aXsn7FQJx5kO12tX0bZkaTjzdVFM6/7nhA4t0EENocKGx6D2Bch9PE2KzCUf5SceBdeijg==", + "dev": true, + "peer": true, + "dependencies": { + "nofilter": "^3.1.0" + }, + "engines": { + "node": ">=12.19" + } + }, + "node_modules/chai": { + "version": "4.3.7", + "resolved": "https://registry.npmjs.org/chai/-/chai-4.3.7.tgz", + "integrity": "sha512-HLnAzZ2iupm25PlN0xFreAlBA5zaBSv3og0DdeGA4Ar6h6rJ3A0rolRUKJhSF2V10GZKDgWF/VmAEsNWjCRB+A==", + "dev": true, + "peer": true, + "dependencies": { + "assertion-error": "^1.1.0", + "check-error": "^1.0.2", + "deep-eql": "^4.1.2", + "get-func-name": "^2.0.0", + "loupe": "^2.3.1", + "pathval": "^1.1.1", + "type-detect": "^4.0.5" + }, + "engines": { + "node": ">=4" + } + }, + "node_modules/chai-as-promised": { + "version": "7.1.1", + "resolved": "https://registry.npmjs.org/chai-as-promised/-/chai-as-promised-7.1.1.tgz", + "integrity": "sha512-azL6xMoi+uxu6z4rhWQ1jbdUhOMhis2PvscD/xjLqNMkv3BPPp2JyyuTHOrf9BOosGpNQ11v6BKv/g57RXbiaA==", + "dev": true, + "peer": true, + "dependencies": { + "check-error": "^1.0.2" + }, + "peerDependencies": { + "chai": ">= 2.1.2 < 5" + } + }, + "node_modules/chalk": { + "version": "2.4.2", + "resolved": "https://registry.npmjs.org/chalk/-/chalk-2.4.2.tgz", + "integrity": "sha512-Mti+f9lpJNcwF4tWV8/OrTTtF1gZi+f8FqlyAdouralcFWFQWF2+NgCHShjkCb+IFBLq9buZwE1xckQU4peSuQ==", + "dev": true, + "dependencies": { + "ansi-styles": "^3.2.1", + "escape-string-regexp": "^1.0.5", + "supports-color": "^5.3.0" + }, + "engines": { + "node": ">=4" + } + }, + "node_modules/charenc": { + "version": "0.0.2", + "resolved": "https://registry.npmjs.org/charenc/-/charenc-0.0.2.tgz", + "integrity": "sha512-yrLQ/yVUFXkzg7EDQsPieE/53+0RlaWTs+wBrvW36cyilJ2SaDWfl4Yj7MtLTXleV9uEKefbAGUPv2/iWSooRA==", + "dev": true, + "peer": true, + "engines": { + "node": "*" + } + }, + "node_modules/check-error": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/check-error/-/check-error-1.0.2.tgz", + "integrity": "sha512-BrgHpW9NURQgzoNyjfq0Wu6VFO6D7IZEmJNdtgNqpzGG8RuNFHt2jQxWlAs4HMe119chBnv+34syEZtc6IhLtA==", + "dev": true, + "peer": true, + "engines": { + "node": "*" + } + }, + "node_modules/chokidar": { + "version": "3.5.3", + "resolved": "https://registry.npmjs.org/chokidar/-/chokidar-3.5.3.tgz", + "integrity": "sha512-Dr3sfKRP6oTcjf2JmUmFJfeVMvXBdegxB0iVQ5eb2V10uFJUCAS8OByZdVAyVb8xXNz3GjjTgj9kLWsZTqE6kw==", + "dev": true, + "funding": [ + { + "type": "individual", + "url": "https://paulmillr.com/funding/" + } + ], + "dependencies": { + "anymatch": "~3.1.2", + "braces": "~3.0.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" + }, + "engines": { + "node": ">= 8.10.0" + }, + "optionalDependencies": { + "fsevents": "~2.3.2" + } + }, + "node_modules/ci-info": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/ci-info/-/ci-info-2.0.0.tgz", + "integrity": "sha512-5tK7EtrZ0N+OLFMthtqOj4fI2Jeb88C4CAZPu25LDVUgXJ0A3Js4PMGqrn0JU1W0Mh1/Z8wZzYPxqUrXeBboCQ==", + "dev": true + }, + "node_modules/cipher-base": { + "version": "1.0.4", + "resolved": "https://registry.npmjs.org/cipher-base/-/cipher-base-1.0.4.tgz", + "integrity": "sha512-Kkht5ye6ZGmwv40uUDZztayT2ThLQGfnj/T71N/XzeZeo3nf8foyW7zGTsPYkEya3m5f3cAypH+qe7YOrM1U2Q==", + "dev": true, + "dependencies": { + "inherits": "^2.0.1", + "safe-buffer": "^5.0.1" + } + }, + "node_modules/classic-level": { + "version": "1.3.0", + "resolved": "https://registry.npmjs.org/classic-level/-/classic-level-1.3.0.tgz", + "integrity": "sha512-iwFAJQYtqRTRM0F6L8h4JCt00ZSGdOyqh7yVrhhjrOpFhmBjNlRUey64MCiyo6UmQHMJ+No3c81nujPv+n9yrg==", + "dev": true, + "hasInstallScript": true, + "dependencies": { + "abstract-level": "^1.0.2", + "catering": "^2.1.0", + "module-error": "^1.0.1", + "napi-macros": "^2.2.2", + "node-gyp-build": "^4.3.0" + }, + "engines": { + "node": ">=12" + } + }, + "node_modules/clean-stack": { + "version": "2.2.0", + "resolved": "https://registry.npmjs.org/clean-stack/-/clean-stack-2.2.0.tgz", + "integrity": "sha512-4diC9HaTE+KRAMWhDhrGOECgWZxoevMc5TlkObMqNSsVU62PYzXZ/SMTjzyGAFF1YusgxGcSWTEXBhp0CPwQ1A==", + "dev": true, + "engines": { + "node": ">=6" + } + }, + "node_modules/cli-table3": { + "version": "0.5.1", + "resolved": "https://registry.npmjs.org/cli-table3/-/cli-table3-0.5.1.tgz", + "integrity": "sha512-7Qg2Jrep1S/+Q3EceiZtQcDPWxhAvBw+ERf1162v4sikJrvojMHFqXt8QIVha8UlH9rgU0BeWPytZ9/TzYqlUw==", + "dev": true, + "peer": true, + "dependencies": { + "object-assign": "^4.1.0", + "string-width": "^2.1.1" + }, + "engines": { + "node": ">=6" + }, + "optionalDependencies": { + "colors": "^1.1.2" + } + }, + "node_modules/cli-table3/node_modules/ansi-regex": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-3.0.1.tgz", + "integrity": "sha512-+O9Jct8wf++lXxxFc4hc8LsjaSq0HFzzL7cVsw8pRDIPdjKD2mT4ytDZlLuSBZ4cLKZFXIrMGO7DbQCtMJJMKw==", + "dev": true, + "peer": true, + "engines": { + "node": ">=4" + } + }, + "node_modules/cli-table3/node_modules/is-fullwidth-code-point": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/is-fullwidth-code-point/-/is-fullwidth-code-point-2.0.0.tgz", + "integrity": "sha512-VHskAKYM8RfSFXwee5t5cbN5PZeq1Wrh6qd5bkyiXIf6UQcN6w/A0eXM9r6t8d+GYOh+o6ZhiEnb88LN/Y8m2w==", + "dev": true, + "peer": true, + "engines": { + "node": ">=4" + } + }, + "node_modules/cli-table3/node_modules/string-width": { + "version": "2.1.1", + "resolved": "https://registry.npmjs.org/string-width/-/string-width-2.1.1.tgz", + "integrity": "sha512-nOqH59deCq9SRHlxq1Aw85Jnt4w6KvLKqWVik6oA9ZklXLNIOlqg4F2yrT1MVaTjAqvVwdfeZ7w7aCvJD7ugkw==", + "dev": true, + "peer": true, + "dependencies": { + "is-fullwidth-code-point": "^2.0.0", + "strip-ansi": "^4.0.0" + }, + "engines": { + "node": ">=4" + } + }, + "node_modules/cli-table3/node_modules/strip-ansi": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-4.0.0.tgz", + "integrity": "sha512-4XaJ2zQdCzROZDivEVIDPkcQn8LMFSa8kj8Gxb/Lnwzv9A8VctNZ+lfivC/sV3ivW8ElJTERXZoPBRrZKkNKow==", + "dev": true, + "peer": true, + "dependencies": { + "ansi-regex": "^3.0.0" + }, + "engines": { + "node": ">=4" + } + }, + "node_modules/cliui": { + "version": "7.0.4", + "resolved": "https://registry.npmjs.org/cliui/-/cliui-7.0.4.tgz", + "integrity": "sha512-OcRE68cOsVMXp1Yvonl/fzkQOyjLSu/8bhPDfQt0e0/Eb283TKP20Fs2MqoPsr9SwA595rRCA+QMzYc9nBP+JQ==", + "dev": true, + "dependencies": { + "string-width": "^4.2.0", + "strip-ansi": "^6.0.0", + "wrap-ansi": "^7.0.0" + } + }, + "node_modules/color-convert": { + "version": "1.9.3", + "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-1.9.3.tgz", + "integrity": "sha512-QfAUtd+vFdAtFQcC8CCyYt1fYWxSqAiK2cSD6zDB8N3cpsEBAvRxp9zOGg6G/SHHJYAT88/az/IuDGALsNVbGg==", + "dev": true, + "dependencies": { + "color-name": "1.1.3" + } + }, + "node_modules/color-name": { + "version": "1.1.3", + "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.3.tgz", + "integrity": "sha512-72fSenhMw2HZMTVHeCA9KCmpEIbzWiQsjN+BHcBbS9vr1mtt+vJjPdksIBNUmKAW8TFUDPJK5SUU3QhE9NEXDw==", + "dev": true + }, + "node_modules/colors": { + "version": "1.4.0", + "resolved": "https://registry.npmjs.org/colors/-/colors-1.4.0.tgz", + "integrity": "sha512-a+UqTh4kgZg/SlGvfbzDHpgRu7AAQOmmqRHJnxhRZICKFUT91brVhNNt58CMWU9PsBbv3PDCZUHbVxuDiH2mtA==", + "dev": true, + "peer": true, + "engines": { + "node": ">=0.1.90" + } + }, + "node_modules/combined-stream": { + "version": "1.0.8", + "resolved": "https://registry.npmjs.org/combined-stream/-/combined-stream-1.0.8.tgz", + "integrity": "sha512-FQN4MRfuJeHf7cBbBMJFXhKSDq+2kAArBlmRBvcvFE5BB1HZKXtSFASDhdlz9zOYwxh8lDdnvmMOe/+5cdoEdg==", + "dev": true, + "peer": true, + "dependencies": { + "delayed-stream": "~1.0.0" + }, + "engines": { + "node": ">= 0.8" + } + }, + "node_modules/command-exists": { + "version": "1.2.9", + "resolved": "https://registry.npmjs.org/command-exists/-/command-exists-1.2.9.tgz", + "integrity": "sha512-LTQ/SGc+s0Xc0Fu5WaKnR0YiygZkm9eKFvyS+fRsU7/ZWFF8ykFM6Pc9aCVf1+xasOOZpO3BAVgVrKvsqKHV7w==", + "dev": true + }, + "node_modules/command-line-args": { + "version": "5.2.1", + "resolved": "https://registry.npmjs.org/command-line-args/-/command-line-args-5.2.1.tgz", + "integrity": "sha512-H4UfQhZyakIjC74I9d34fGYDwk3XpSr17QhEd0Q3I9Xq1CETHo4Hcuo87WyWHpAF1aSLjLRf5lD9ZGX2qStUvg==", + "dev": true, + "peer": true, + "dependencies": { + "array-back": "^3.1.0", + "find-replace": "^3.0.0", + "lodash.camelcase": "^4.3.0", + "typical": "^4.0.0" + }, + "engines": { + "node": ">=4.0.0" + } + }, + "node_modules/command-line-usage": { + "version": "6.1.3", + "resolved": "https://registry.npmjs.org/command-line-usage/-/command-line-usage-6.1.3.tgz", + "integrity": "sha512-sH5ZSPr+7UStsloltmDh7Ce5fb8XPlHyoPzTpyyMuYCtervL65+ubVZ6Q61cFtFl62UyJlc8/JwERRbAFPUqgw==", + "dev": true, + "peer": true, + "dependencies": { + "array-back": "^4.0.2", + "chalk": "^2.4.2", + "table-layout": "^1.0.2", + "typical": "^5.2.0" + }, + "engines": { + "node": ">=8.0.0" + } + }, + "node_modules/command-line-usage/node_modules/array-back": { + "version": "4.0.2", + "resolved": "https://registry.npmjs.org/array-back/-/array-back-4.0.2.tgz", + "integrity": "sha512-NbdMezxqf94cnNfWLL7V/im0Ub+Anbb0IoZhvzie8+4HJ4nMQuzHuy49FkGYCJK2yAloZ3meiB6AVMClbrI1vg==", + "dev": true, + "peer": true, + "engines": { + "node": ">=8" + } + }, + "node_modules/command-line-usage/node_modules/typical": { + "version": "5.2.0", + "resolved": "https://registry.npmjs.org/typical/-/typical-5.2.0.tgz", + "integrity": "sha512-dvdQgNDNJo+8B2uBQoqdb11eUCE1JQXhvjC/CZtgvZseVd5TYMXnq0+vuUemXbd/Se29cTaUuPX3YIc2xgbvIg==", + "dev": true, + "peer": true, + "engines": { + "node": ">=8" + } + }, + "node_modules/commander": { + "version": "3.0.2", + "resolved": "https://registry.npmjs.org/commander/-/commander-3.0.2.tgz", + "integrity": "sha512-Gar0ASD4BDyKC4hl4DwHqDrmvjoxWKZigVnAbn5H1owvm4CxCPdb0HQDehwNYMJpla5+M2tPmPARzhtYuwpHow==", + "dev": true + }, + "node_modules/concat-map": { + "version": "0.0.1", + "resolved": "https://registry.npmjs.org/concat-map/-/concat-map-0.0.1.tgz", + "integrity": "sha512-/Srv4dswyQNBfohGpz9o6Yb3Gz3SrUDqBH5rTuhGR7ahtlbYKnVxw2bCFMRljaA7EXHaXZ8wsHdodFvbkhKmqg==", + "dev": true + }, + "node_modules/concat-stream": { + "version": "1.6.2", + "resolved": "https://registry.npmjs.org/concat-stream/-/concat-stream-1.6.2.tgz", + "integrity": "sha512-27HBghJxjiZtIk3Ycvn/4kbJk/1uZuJFfuPEns6LaEvpvG1f0hTea8lilrouyo9mVc2GWdcEZ8OLoGmSADlrCw==", + "dev": true, + "engines": [ + "node >= 0.8" + ], + "peer": true, + "dependencies": { + "buffer-from": "^1.0.0", + "inherits": "^2.0.3", + "readable-stream": "^2.2.2", + "typedarray": "^0.0.6" + } + }, + "node_modules/concat-stream/node_modules/readable-stream": { + "version": "2.3.8", + "resolved": "https://registry.npmjs.org/readable-stream/-/readable-stream-2.3.8.tgz", + "integrity": "sha512-8p0AUk4XODgIewSi0l8Epjs+EVnWiK7NoDIEGU0HhE7+ZyY8D1IMY7odu5lRrFXGg71L15KG8QrPmum45RTtdA==", + "dev": true, + "peer": true, + "dependencies": { + "core-util-is": "~1.0.0", + "inherits": "~2.0.3", + "isarray": "~1.0.0", + "process-nextick-args": "~2.0.0", + "safe-buffer": "~5.1.1", + "string_decoder": "~1.1.1", + "util-deprecate": "~1.0.1" + } + }, + "node_modules/concat-stream/node_modules/string_decoder": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/string_decoder/-/string_decoder-1.1.1.tgz", + "integrity": "sha512-n/ShnvDi6FHbbVfviro+WojiFzv+s8MPMHBczVePfUpDJLwoLT0ht1l4YwBCbi8pJAveEEdnkHyPyTP/mzRfwg==", + "dev": true, + "peer": true, + "dependencies": { + "safe-buffer": "~5.1.0" + } + }, + "node_modules/cookie": { + "version": "0.4.2", + "resolved": "https://registry.npmjs.org/cookie/-/cookie-0.4.2.tgz", + "integrity": "sha512-aSWTXFzaKWkvHO1Ny/s+ePFpvKsPnjc551iI41v3ny/ow6tBG5Vd+FuqGNhh1LxOmVzOlGUriIlOaokOvhaStA==", + "dev": true, + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/core-util-is": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/core-util-is/-/core-util-is-1.0.2.tgz", + "integrity": "sha512-3lqz5YjWTYnW6dlDa5TLaTCcShfar1e40rmcJVwCBJC6mWlFuj0eCHIElmG1g5kyuJ/GD+8Wn4FFCcz4gJPfaQ==", + "dev": true, + "peer": true + }, + "node_modules/crc-32": { + "version": "1.2.2", + "resolved": "https://registry.npmjs.org/crc-32/-/crc-32-1.2.2.tgz", + "integrity": "sha512-ROmzCKrTnOwybPcJApAA6WBWij23HVfGVNKqqrZpuyZOHqK2CwHSvpGuyt/UNNvaIjEd8X5IFGp4Mh+Ie1IHJQ==", + "dev": true, + "bin": { + "crc32": "bin/crc32.njs" + }, + "engines": { + "node": ">=0.8" + } + }, + "node_modules/create-hash": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/create-hash/-/create-hash-1.2.0.tgz", + "integrity": "sha512-z00bCGNHDG8mHAkP7CtT1qVu+bFQUPjYq/4Iv3C3kWjTFV10zIjfSoeqXo9Asws8gwSHDGj/hl2u4OGIjapeCg==", + "dev": true, + "dependencies": { + "cipher-base": "^1.0.1", + "inherits": "^2.0.1", + "md5.js": "^1.3.4", + "ripemd160": "^2.0.1", + "sha.js": "^2.4.0" + } + }, + "node_modules/create-hmac": { + "version": "1.1.7", + "resolved": "https://registry.npmjs.org/create-hmac/-/create-hmac-1.1.7.tgz", + "integrity": "sha512-MJG9liiZ+ogc4TzUwuvbER1JRdgvUFSB5+VR/g5h82fGaIRWMWddtKBHi7/sVhfjQZ6SehlyhvQYrcYkaUIpLg==", + "dev": true, + "dependencies": { + "cipher-base": "^1.0.3", + "create-hash": "^1.1.0", + "inherits": "^2.0.1", + "ripemd160": "^2.0.0", + "safe-buffer": "^5.0.1", + "sha.js": "^2.4.8" + } + }, + "node_modules/create-require": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/create-require/-/create-require-1.1.1.tgz", + "integrity": "sha512-dcKFX3jn0MpIaXjisoRvexIJVEKzaq7z2rZKxf+MSr9TkdmHmsU4m2lcLojrj/FHl8mk5VxMmYA+ftRkP/3oKQ==", + "dev": true, + "peer": true + }, + "node_modules/crypt": { + "version": "0.0.2", + "resolved": "https://registry.npmjs.org/crypt/-/crypt-0.0.2.tgz", + "integrity": "sha512-mCxBlsHFYh9C+HVpiEacem8FEBnMXgU9gy4zmNC+SXAZNB/1idgp/aulFJ4FgCi7GPEVbfyng092GqL2k2rmow==", + "dev": true, + "peer": true, + "engines": { + "node": "*" + } + }, + "node_modules/dashdash": { + "version": "1.14.1", + "resolved": "https://registry.npmjs.org/dashdash/-/dashdash-1.14.1.tgz", + "integrity": "sha512-jRFi8UDGo6j+odZiEpjazZaWqEal3w/basFjQHQEwVtZJGDpxbH1MeYluwCS8Xq5wmLJooDlMgvVarmWfGM44g==", + "dev": true, + "peer": true, + "dependencies": { + "assert-plus": "^1.0.0" + }, + "engines": { + "node": ">=0.10" + } + }, + "node_modules/death": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/death/-/death-1.1.0.tgz", + "integrity": "sha512-vsV6S4KVHvTGxbEcij7hkWRv0It+sGGWVOM67dQde/o5Xjnr+KmLjxWJii2uEObIrt1CcM9w0Yaovx+iOlIL+w==", + "dev": true, + "peer": true + }, + "node_modules/debug": { + "version": "4.3.4", + "resolved": "https://registry.npmjs.org/debug/-/debug-4.3.4.tgz", + "integrity": "sha512-PRWFHuSU3eDtQJPvnNY7Jcket1j0t5OuOsFzPPzsekD52Zl8qUfFIPEiswXqIvHWGVHOgX+7G/vCNNhehwxfkQ==", + "dev": true, + "dependencies": { + "ms": "2.1.2" + }, + "engines": { + "node": ">=6.0" + }, + "peerDependenciesMeta": { + "supports-color": { + "optional": true + } + } + }, + "node_modules/decamelize": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/decamelize/-/decamelize-4.0.0.tgz", + "integrity": "sha512-9iE1PgSik9HeIIw2JO94IidnE3eBoQrFJ3w7sFuzSX4DpmZ3v5sZpUiV5Swcf6mQEF+Y0ru8Neo+p+nyh2J+hQ==", + "dev": true, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/deep-eql": { + "version": "4.1.3", + "resolved": "https://registry.npmjs.org/deep-eql/-/deep-eql-4.1.3.tgz", + "integrity": "sha512-WaEtAOpRA1MQ0eohqZjpGD8zdI0Ovsm8mmFhaDN8dvDZzyoUMcYDnf5Y6iu7HTXxf8JDS23qWa4a+hKCDyOPzw==", + "dev": true, + "peer": true, + "dependencies": { + "type-detect": "^4.0.0" + }, + "engines": { + "node": ">=6" + } + }, + "node_modules/deep-extend": { + "version": "0.6.0", + "resolved": "https://registry.npmjs.org/deep-extend/-/deep-extend-0.6.0.tgz", + "integrity": "sha512-LOHxIOaPYdHlJRtCQfDIVZtfw/ufM8+rVj649RIHzcm/vGwQRXFt6OPqIFWsm2XEMrNIEtWR64sY1LEKD2vAOA==", + "dev": true, + "peer": true, + "engines": { + "node": ">=4.0.0" + } + }, + "node_modules/deep-is": { + "version": "0.1.4", + "resolved": "https://registry.npmjs.org/deep-is/-/deep-is-0.1.4.tgz", + "integrity": "sha512-oIPzksmTg4/MriiaYGO+okXDT7ztn/w3Eptv/+gSIdMdKsJo0u4CfYNFJPy+4SKMuCqGw2wxnA+URMg3t8a/bQ==", + "dev": true, + "peer": true + }, + "node_modules/define-properties": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/define-properties/-/define-properties-1.2.0.tgz", + "integrity": "sha512-xvqAVKGfT1+UAvPwKTVw/njhdQ8ZhXK4lI0bCIuCMrp2up9nPnaDftrLtmpTazqd1o+UY4zgzU+avtMbDP+ldA==", + "dev": true, + "peer": true, + "dependencies": { + "has-property-descriptors": "^1.0.0", + "object-keys": "^1.1.1" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/delayed-stream": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/delayed-stream/-/delayed-stream-1.0.0.tgz", + "integrity": "sha512-ZySD7Nf91aLB0RxL4KGrKHBXl7Eds1DAmEdcoVawXnLD7SDhpNgtuII2aAkg7a7QS41jxPSZ17p4VdGnMHk3MQ==", + "dev": true, + "peer": true, + "engines": { + "node": ">=0.4.0" + } + }, + "node_modules/depd": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/depd/-/depd-2.0.0.tgz", + "integrity": "sha512-g7nH6P6dyDioJogAAGprGpCtVImJhpPk/roCzdb3fIh61/s/nPsfR6onyMwkCAR/OlC3yBC0lESvUoQEAssIrw==", + "dev": true, + "engines": { + "node": ">= 0.8" + } + }, + "node_modules/detect-port": { + "version": "1.5.1", + "resolved": "https://registry.npmjs.org/detect-port/-/detect-port-1.5.1.tgz", + "integrity": "sha512-aBzdj76lueB6uUst5iAs7+0H/oOjqI5D16XUWxlWMIMROhcM0rfsNVk93zTngq1dDNpoXRr++Sus7ETAExppAQ==", + "dev": true, + "peer": true, + "dependencies": { + "address": "^1.0.1", + "debug": "4" + }, + "bin": { + "detect": "bin/detect-port.js", + "detect-port": "bin/detect-port.js" + } + }, + "node_modules/diff": { + "version": "5.0.0", + "resolved": "https://registry.npmjs.org/diff/-/diff-5.0.0.tgz", + "integrity": "sha512-/VTCrvm5Z0JGty/BWHljh+BAiw3IK+2j87NGMu8Nwc/f48WoDAC395uomO9ZD117ZOBaHmkX1oyLvkVM/aIT3w==", + "dev": true, + "engines": { + "node": ">=0.3.1" + } + }, + "node_modules/difflib": { + "version": "0.2.4", + "resolved": "https://registry.npmjs.org/difflib/-/difflib-0.2.4.tgz", + "integrity": "sha512-9YVwmMb0wQHQNr5J9m6BSj6fk4pfGITGQOOs+D9Fl+INODWFOfvhIU1hNv6GgR1RBoC/9NJcwu77zShxV0kT7w==", + "dev": true, + "peer": true, + "dependencies": { + "heap": ">= 0.2.0" + }, + "engines": { + "node": "*" + } + }, + "node_modules/dir-glob": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/dir-glob/-/dir-glob-3.0.1.tgz", + "integrity": "sha512-WkrWp9GR4KXfKGYzOLmTuGVi1UWFfws377n9cc55/tb6DuqyF6pcQ5AbiHEshaDpY9v6oaSr2XCDidGmMwdzIA==", + "dev": true, + "peer": true, + "dependencies": { + "path-type": "^4.0.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/ecc-jsbn": { + "version": "0.1.2", + "resolved": "https://registry.npmjs.org/ecc-jsbn/-/ecc-jsbn-0.1.2.tgz", + "integrity": "sha512-eh9O+hwRHNbG4BLTjEl3nw044CkGm5X6LoaCf7LPp7UU8Qrt47JYNi6nPX8xjW97TKGKm1ouctg0QSpZe9qrnw==", + "dev": true, + "peer": true, + "dependencies": { + "jsbn": "~0.1.0", + "safer-buffer": "^2.1.0" + } + }, + "node_modules/elliptic": { + "version": "6.5.4", + "resolved": "https://registry.npmjs.org/elliptic/-/elliptic-6.5.4.tgz", + "integrity": "sha512-iLhC6ULemrljPZb+QutR5TQGB+pdW6KGD5RSegS+8sorOZT+rdQFbsQFJgvN3eRqNALqJer4oQ16YvJHlU8hzQ==", + "dev": true, + "dependencies": { + "bn.js": "^4.11.9", + "brorand": "^1.1.0", + "hash.js": "^1.0.0", + "hmac-drbg": "^1.0.1", + "inherits": "^2.0.4", + "minimalistic-assert": "^1.0.1", + "minimalistic-crypto-utils": "^1.0.1" + } + }, + "node_modules/elliptic/node_modules/bn.js": { + "version": "4.12.0", + "resolved": "https://registry.npmjs.org/bn.js/-/bn.js-4.12.0.tgz", + "integrity": "sha512-c98Bf3tPniI+scsdk237ku1Dc3ujXQTSgyiPUDEOe7tRkhrqridvh8klBv0HCEso1OLOYcHuCv/cS6DNxKH+ZA==", + "dev": true + }, + "node_modules/emoji-regex": { + "version": "8.0.0", + "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-8.0.0.tgz", + "integrity": "sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A==", + "dev": true + }, + "node_modules/enquirer": { + "version": "2.3.6", + "resolved": "https://registry.npmjs.org/enquirer/-/enquirer-2.3.6.tgz", + "integrity": "sha512-yjNnPr315/FjS4zIsUxYguYUPP2e1NK4d7E7ZOLiyYCcbFBiTMyID+2wvm2w6+pZ/odMA7cRkjhsPbltwBOrLg==", + "dev": true, + "dependencies": { + "ansi-colors": "^4.1.1" + }, + "engines": { + "node": ">=8.6" + } + }, + "node_modules/env-paths": { + "version": "2.2.1", + "resolved": "https://registry.npmjs.org/env-paths/-/env-paths-2.2.1.tgz", + "integrity": "sha512-+h1lkLKhZMTYjog1VEpJNG7NZJWcuc2DDk/qsqSTRRCOXiLjeQ1d1/udrUGhqMxUgAlwKNZ0cf2uqan5GLuS2A==", + "dev": true, + "engines": { + "node": ">=6" + } + }, + "node_modules/es-abstract": { + "version": "1.21.2", + "resolved": "https://registry.npmjs.org/es-abstract/-/es-abstract-1.21.2.tgz", + "integrity": "sha512-y/B5POM2iBnIxCiernH1G7rC9qQoM77lLIMQLuob0zhp8C56Po81+2Nj0WFKnd0pNReDTnkYryc+zhOzpEIROg==", + "dev": true, + "peer": true, + "dependencies": { + "array-buffer-byte-length": "^1.0.0", + "available-typed-arrays": "^1.0.5", + "call-bind": "^1.0.2", + "es-set-tostringtag": "^2.0.1", + "es-to-primitive": "^1.2.1", + "function.prototype.name": "^1.1.5", + "get-intrinsic": "^1.2.0", + "get-symbol-description": "^1.0.0", + "globalthis": "^1.0.3", + "gopd": "^1.0.1", + "has": "^1.0.3", + "has-property-descriptors": "^1.0.0", + "has-proto": "^1.0.1", + "has-symbols": "^1.0.3", + "internal-slot": "^1.0.5", + "is-array-buffer": "^3.0.2", + "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.10", + "is-weakref": "^1.0.2", + "object-inspect": "^1.12.3", + "object-keys": "^1.1.1", + "object.assign": "^4.1.4", + "regexp.prototype.flags": "^1.4.3", + "safe-regex-test": "^1.0.0", + "string.prototype.trim": "^1.2.7", + "string.prototype.trimend": "^1.0.6", + "string.prototype.trimstart": "^1.0.6", + "typed-array-length": "^1.0.4", + "unbox-primitive": "^1.0.2", + "which-typed-array": "^1.1.9" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/es-abstract/node_modules/object.assign": { + "version": "4.1.4", + "resolved": "https://registry.npmjs.org/object.assign/-/object.assign-4.1.4.tgz", + "integrity": "sha512-1mxKf0e58bvyjSCtKYY4sRe9itRk3PJpquJOjeIkz885CczcI4IvJJDLPS72oowuSh+pBxUFROpX+TU++hxhZQ==", + "dev": true, + "peer": true, + "dependencies": { + "call-bind": "^1.0.2", + "define-properties": "^1.1.4", + "has-symbols": "^1.0.3", + "object-keys": "^1.1.1" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/es-array-method-boxes-properly": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/es-array-method-boxes-properly/-/es-array-method-boxes-properly-1.0.0.tgz", + "integrity": "sha512-wd6JXUmyHmt8T5a2xreUwKcGPq6f1f+WwIJkijUqiGcJz1qqnZgP6XIK+QyIWU5lT7imeNxUll48bziG+TSYcA==", + "dev": true, + "peer": true + }, + "node_modules/es-set-tostringtag": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/es-set-tostringtag/-/es-set-tostringtag-2.0.1.tgz", + "integrity": "sha512-g3OMbtlwY3QewlqAiMLI47KywjWZoEytKr8pf6iTC8uJq5bIAH52Z9pnQ8pVL6whrCto53JZDuUIsifGeLorTg==", + "dev": true, + "peer": true, + "dependencies": { + "get-intrinsic": "^1.1.3", + "has": "^1.0.3", + "has-tostringtag": "^1.0.0" + }, + "engines": { + "node": ">= 0.4" + } + }, + "node_modules/es-to-primitive": { + "version": "1.2.1", + "resolved": "https://registry.npmjs.org/es-to-primitive/-/es-to-primitive-1.2.1.tgz", + "integrity": "sha512-QCOllgZJtaUo9miYBcLChTUaHNjJF3PYs1VidD7AwiEj1kYxKeQTctLAezAOH5ZKRH0g2IgPn6KwB4IT8iRpvA==", + "dev": true, + "peer": true, + "dependencies": { + "is-callable": "^1.1.4", + "is-date-object": "^1.0.1", + "is-symbol": "^1.0.2" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/escalade": { + "version": "3.1.1", + "resolved": "https://registry.npmjs.org/escalade/-/escalade-3.1.1.tgz", + "integrity": "sha512-k0er2gUkLf8O0zKJiAhmkTnJlTvINGv7ygDNPbeIsX/TJjGJZHuh9B2UxbsaEkmlEo9MfhrSzmhIlhRlI2GXnw==", + "dev": true, + "engines": { + "node": ">=6" + } + }, + "node_modules/escape-string-regexp": { + "version": "1.0.5", + "resolved": "https://registry.npmjs.org/escape-string-regexp/-/escape-string-regexp-1.0.5.tgz", + "integrity": "sha512-vbRorB5FUQWvla16U8R/qgaFIya2qGzwDrNmCZuYKrbdSUMG6I1ZCGQRefkRVhuOkIGVne7BQ35DSfo1qvJqFg==", + "dev": true, + "engines": { + "node": ">=0.8.0" + } + }, + "node_modules/escodegen": { + "version": "1.8.1", + "resolved": "https://registry.npmjs.org/escodegen/-/escodegen-1.8.1.tgz", + "integrity": "sha512-yhi5S+mNTOuRvyW4gWlg5W1byMaQGWWSYHXsuFZ7GBo7tpyOwi2EdzMP/QWxh9hwkD2m+wDVHJsxhRIj+v/b/A==", + "dev": true, + "peer": true, + "dependencies": { + "esprima": "^2.7.1", + "estraverse": "^1.9.1", + "esutils": "^2.0.2", + "optionator": "^0.8.1" + }, + "bin": { + "escodegen": "bin/escodegen.js", + "esgenerate": "bin/esgenerate.js" + }, + "engines": { + "node": ">=0.12.0" + }, + "optionalDependencies": { + "source-map": "~0.2.0" + } + }, + "node_modules/escodegen/node_modules/source-map": { + "version": "0.2.0", + "resolved": "https://registry.npmjs.org/source-map/-/source-map-0.2.0.tgz", + "integrity": "sha512-CBdZ2oa/BHhS4xj5DlhjWNHcan57/5YuvfdLf17iVmIpd9KRm+DFLmC6nBNj+6Ua7Kt3TmOjDpQT1aTYOQtoUA==", + "dev": true, + "optional": true, + "peer": true, + "dependencies": { + "amdefine": ">=0.0.4" + }, + "engines": { + "node": ">=0.8.0" + } + }, + "node_modules/esprima": { + "version": "2.7.3", + "resolved": "https://registry.npmjs.org/esprima/-/esprima-2.7.3.tgz", + "integrity": "sha512-OarPfz0lFCiW4/AV2Oy1Rp9qu0iusTKqykwTspGCZtPxmF81JR4MmIebvF1F9+UOKth2ZubLQ4XGGaU+hSn99A==", + "dev": true, + "peer": true, + "bin": { + "esparse": "bin/esparse.js", + "esvalidate": "bin/esvalidate.js" + }, + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/estraverse": { + "version": "1.9.3", + "resolved": "https://registry.npmjs.org/estraverse/-/estraverse-1.9.3.tgz", + "integrity": "sha512-25w1fMXQrGdoquWnScXZGckOv+Wes+JDnuN/+7ex3SauFRS72r2lFDec0EKPt2YD1wUJ/IrfEex+9yp4hfSOJA==", + "dev": true, + "peer": true, + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/esutils": { + "version": "2.0.3", + "resolved": "https://registry.npmjs.org/esutils/-/esutils-2.0.3.tgz", + "integrity": "sha512-kVscqXk4OCp68SZ0dkgEKVi6/8ij300KBWTJq32P/dYeWTSwK41WyTxalN1eRmA5Z9UU/LX9D7FWSmV9SAYx6g==", + "dev": true, + "peer": true, + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/eth-gas-reporter": { + "version": "0.2.25", + "resolved": "https://registry.npmjs.org/eth-gas-reporter/-/eth-gas-reporter-0.2.25.tgz", + "integrity": "sha512-1fRgyE4xUB8SoqLgN3eDfpDfwEfRxh2Sz1b7wzFbyQA+9TekMmvSjjoRu9SKcSVyK+vLkLIsVbJDsTWjw195OQ==", + "dev": true, + "peer": true, + "dependencies": { + "@ethersproject/abi": "^5.0.0-beta.146", + "@solidity-parser/parser": "^0.14.0", + "cli-table3": "^0.5.0", + "colors": "1.4.0", + "ethereum-cryptography": "^1.0.3", + "ethers": "^4.0.40", + "fs-readdir-recursive": "^1.1.0", + "lodash": "^4.17.14", + "markdown-table": "^1.1.3", + "mocha": "^7.1.1", + "req-cwd": "^2.0.0", + "request": "^2.88.0", + "request-promise-native": "^1.0.5", + "sha1": "^1.1.1", + "sync-request": "^6.0.0" + }, + "peerDependencies": { + "@codechecks/client": "^0.1.0" + }, + "peerDependenciesMeta": { + "@codechecks/client": { + "optional": true + } + } + }, + "node_modules/eth-gas-reporter/node_modules/ansi-colors": { + "version": "3.2.3", + "resolved": "https://registry.npmjs.org/ansi-colors/-/ansi-colors-3.2.3.tgz", + "integrity": "sha512-LEHHyuhlPY3TmuUYMh2oz89lTShfvgbmzaBcxve9t/9Wuy7Dwf4yoAKcND7KFT1HAQfqZ12qtc+DUrBMeKF9nw==", + "dev": true, + "peer": true, + "engines": { + "node": ">=6" + } + }, + "node_modules/eth-gas-reporter/node_modules/ansi-regex": { + "version": "4.1.1", + "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-4.1.1.tgz", + "integrity": "sha512-ILlv4k/3f6vfQ4OoP2AGvirOktlQ98ZEL1k9FaQjxa3L1abBgbuTDAdPOpvbGncC0BTVQrl+OM8xZGK6tWXt7g==", + "dev": true, + "peer": true, + "engines": { + "node": ">=6" + } + }, + "node_modules/eth-gas-reporter/node_modules/argparse": { + "version": "1.0.10", + "resolved": "https://registry.npmjs.org/argparse/-/argparse-1.0.10.tgz", + "integrity": "sha512-o5Roy6tNG4SL/FOkCAN6RzjiakZS25RLYFrcMttJqbdd8BWrnA+fGz57iN5Pb06pvBGvl5gQ0B48dJlslXvoTg==", + "dev": true, + "peer": true, + "dependencies": { + "sprintf-js": "~1.0.2" + } + }, + "node_modules/eth-gas-reporter/node_modules/bn.js": { + "version": "4.12.0", + "resolved": "https://registry.npmjs.org/bn.js/-/bn.js-4.12.0.tgz", + "integrity": "sha512-c98Bf3tPniI+scsdk237ku1Dc3ujXQTSgyiPUDEOe7tRkhrqridvh8klBv0HCEso1OLOYcHuCv/cS6DNxKH+ZA==", + "dev": true, + "peer": true + }, + "node_modules/eth-gas-reporter/node_modules/camelcase": { + "version": "5.3.1", + "resolved": "https://registry.npmjs.org/camelcase/-/camelcase-5.3.1.tgz", + "integrity": "sha512-L28STB170nwWS63UjtlEOE3dldQApaJXZkOI1uMFfzf3rRuPegHaHesyee+YxQ+W6SvRDQV6UrdOdRiR153wJg==", + "dev": true, + "peer": true, + "engines": { + "node": ">=6" + } + }, + "node_modules/eth-gas-reporter/node_modules/chokidar": { + "version": "3.3.0", + "resolved": "https://registry.npmjs.org/chokidar/-/chokidar-3.3.0.tgz", + "integrity": "sha512-dGmKLDdT3Gdl7fBUe8XK+gAtGmzy5Fn0XkkWQuYxGIgWVPPse2CxFA5mtrlD0TOHaHjEUqkWNyP1XdHoJES/4A==", + "dev": true, + "peer": true, + "dependencies": { + "anymatch": "~3.1.1", + "braces": "~3.0.2", + "glob-parent": "~5.1.0", + "is-binary-path": "~2.1.0", + "is-glob": "~4.0.1", + "normalize-path": "~3.0.0", + "readdirp": "~3.2.0" + }, + "engines": { + "node": ">= 8.10.0" + }, + "optionalDependencies": { + "fsevents": "~2.1.1" + } + }, + "node_modules/eth-gas-reporter/node_modules/cliui": { + "version": "5.0.0", + "resolved": "https://registry.npmjs.org/cliui/-/cliui-5.0.0.tgz", + "integrity": "sha512-PYeGSEmmHM6zvoef2w8TPzlrnNpXIjTipYK780YswmIP9vjxmd6Y2a3CB2Ks6/AU8NHjZugXvo8w3oWM2qnwXA==", + "dev": true, + "peer": true, + "dependencies": { + "string-width": "^3.1.0", + "strip-ansi": "^5.2.0", + "wrap-ansi": "^5.1.0" + } + }, + "node_modules/eth-gas-reporter/node_modules/debug": { + "version": "3.2.6", + "resolved": "https://registry.npmjs.org/debug/-/debug-3.2.6.tgz", + "integrity": "sha512-mel+jf7nrtEl5Pn1Qx46zARXKDpBbvzezse7p7LqINmdoIk8PYP5SySaxEmYv6TZ0JyEKA1hsCId6DIhgITtWQ==", + "deprecated": "Debug versions >=3.2.0 <3.2.7 || >=4 <4.3.1 have a low-severity ReDos regression when used in a Node.js environment. It is recommended you upgrade to 3.2.7 or 4.3.1. (https://github.com/visionmedia/debug/issues/797)", + "dev": true, + "peer": true, + "dependencies": { + "ms": "^2.1.1" + } + }, + "node_modules/eth-gas-reporter/node_modules/decamelize": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/decamelize/-/decamelize-1.2.0.tgz", + "integrity": "sha512-z2S+W9X73hAUUki+N+9Za2lBlun89zigOyGrsax+KUQ6wKW4ZoWpEYBkGhQjwAjjDCkWxhY0VKEhk8wzY7F5cA==", + "dev": true, + "peer": true, + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/eth-gas-reporter/node_modules/diff": { + "version": "3.5.0", + "resolved": "https://registry.npmjs.org/diff/-/diff-3.5.0.tgz", + "integrity": "sha512-A46qtFgd+g7pDZinpnwiRJtxbC1hpgf0uzP3iG89scHk0AUC7A1TGxf5OiiOUv/JMZR8GOt8hL900hV0bOy5xA==", + "dev": true, + "peer": true, + "engines": { + "node": ">=0.3.1" + } + }, + "node_modules/eth-gas-reporter/node_modules/emoji-regex": { + "version": "7.0.3", + "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-7.0.3.tgz", + "integrity": "sha512-CwBLREIQ7LvYFB0WyRvwhq5N5qPhc6PMjD6bYggFlI5YyDgl+0vxq5VHbMOFqLg7hfWzmu8T5Z1QofhmTIhItA==", + "dev": true, + "peer": true + }, + "node_modules/eth-gas-reporter/node_modules/esprima": { + "version": "4.0.1", + "resolved": "https://registry.npmjs.org/esprima/-/esprima-4.0.1.tgz", + "integrity": "sha512-eGuFFw7Upda+g4p+QHvnW0RyTX/SVeJBDM/gCtMARO0cLuT2HcEKnTPvhjV6aGeqrCB/sbNop0Kszm0jsaWU4A==", + "dev": true, + "peer": true, + "bin": { + "esparse": "bin/esparse.js", + "esvalidate": "bin/esvalidate.js" + }, + "engines": { + "node": ">=4" + } + }, + "node_modules/eth-gas-reporter/node_modules/ethers": { + "version": "4.0.49", + "resolved": "https://registry.npmjs.org/ethers/-/ethers-4.0.49.tgz", + "integrity": "sha512-kPltTvWiyu+OktYy1IStSO16i2e7cS9D9OxZ81q2UUaiNPVrm/RTcbxamCXF9VUSKzJIdJV68EAIhTEVBalRWg==", + "dev": true, + "peer": true, + "dependencies": { + "aes-js": "3.0.0", + "bn.js": "^4.11.9", + "elliptic": "6.5.4", + "hash.js": "1.1.3", + "js-sha3": "0.5.7", + "scrypt-js": "2.0.4", + "setimmediate": "1.0.4", + "uuid": "2.0.1", + "xmlhttprequest": "1.8.0" + } + }, + "node_modules/eth-gas-reporter/node_modules/find-up": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/find-up/-/find-up-3.0.0.tgz", + "integrity": "sha512-1yD6RmLI1XBfxugvORwlck6f75tYL+iR0jqwsOrOxMZyGYqUuDhJ0l4AXdO1iX/FTs9cBAMEk1gWSEx1kSbylg==", + "dev": true, + "peer": true, + "dependencies": { + "locate-path": "^3.0.0" + }, + "engines": { + "node": ">=6" + } + }, + "node_modules/eth-gas-reporter/node_modules/flat": { + "version": "4.1.1", + "resolved": "https://registry.npmjs.org/flat/-/flat-4.1.1.tgz", + "integrity": "sha512-FmTtBsHskrU6FJ2VxCnsDb84wu9zhmO3cUX2kGFb5tuwhfXxGciiT0oRY+cck35QmG+NmGh5eLz6lLCpWTqwpA==", + "dev": true, + "peer": true, + "dependencies": { + "is-buffer": "~2.0.3" + }, + "bin": { + "flat": "cli.js" + } + }, + "node_modules/eth-gas-reporter/node_modules/fsevents": { + "version": "2.1.3", + "resolved": "https://registry.npmjs.org/fsevents/-/fsevents-2.1.3.tgz", + "integrity": "sha512-Auw9a4AxqWpa9GUfj370BMPzzyncfBABW8Mab7BGWBYDj4Isgq+cDKtx0i6u9jcX9pQDnswsaaOTgTmA5pEjuQ==", + "deprecated": "\"Please update to latest v2.3 or v2.2\"", + "dev": true, + "hasInstallScript": true, + "optional": true, + "os": [ + "darwin" + ], + "peer": true, + "engines": { + "node": "^8.16.0 || ^10.6.0 || >=11.0.0" + } + }, + "node_modules/eth-gas-reporter/node_modules/glob": { + "version": "7.1.3", + "resolved": "https://registry.npmjs.org/glob/-/glob-7.1.3.tgz", + "integrity": "sha512-vcfuiIxogLV4DlGBHIUOwI0IbrJ8HWPc4MU7HzviGeNho/UJDfi6B5p3sHeWIQ0KGIU0Jpxi5ZHxemQfLkkAwQ==", + "dev": true, + "peer": true, + "dependencies": { + "fs.realpath": "^1.0.0", + "inflight": "^1.0.4", + "inherits": "2", + "minimatch": "^3.0.4", + "once": "^1.3.0", + "path-is-absolute": "^1.0.0" + }, + "engines": { + "node": "*" + } + }, + "node_modules/eth-gas-reporter/node_modules/hash.js": { + "version": "1.1.3", + "resolved": "https://registry.npmjs.org/hash.js/-/hash.js-1.1.3.tgz", + "integrity": "sha512-/UETyP0W22QILqS+6HowevwhEFJ3MBJnwTf75Qob9Wz9t0DPuisL8kW8YZMK62dHAKE1c1p+gY1TtOLY+USEHA==", + "dev": true, + "peer": true, + "dependencies": { + "inherits": "^2.0.3", + "minimalistic-assert": "^1.0.0" + } + }, + "node_modules/eth-gas-reporter/node_modules/is-fullwidth-code-point": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/is-fullwidth-code-point/-/is-fullwidth-code-point-2.0.0.tgz", + "integrity": "sha512-VHskAKYM8RfSFXwee5t5cbN5PZeq1Wrh6qd5bkyiXIf6UQcN6w/A0eXM9r6t8d+GYOh+o6ZhiEnb88LN/Y8m2w==", + "dev": true, + "peer": true, + "engines": { + "node": ">=4" + } + }, + "node_modules/eth-gas-reporter/node_modules/js-sha3": { + "version": "0.5.7", + "resolved": "https://registry.npmjs.org/js-sha3/-/js-sha3-0.5.7.tgz", + "integrity": "sha512-GII20kjaPX0zJ8wzkTbNDYMY7msuZcTWk8S5UOh6806Jq/wz1J8/bnr8uGU0DAUmYDjj2Mr4X1cW8v/GLYnR+g==", + "dev": true, + "peer": true + }, + "node_modules/eth-gas-reporter/node_modules/js-yaml": { + "version": "3.13.1", + "resolved": "https://registry.npmjs.org/js-yaml/-/js-yaml-3.13.1.tgz", + "integrity": "sha512-YfbcO7jXDdyj0DGxYVSlSeQNHbD7XPWvrVWeVUujrQEoZzWJIRrCPoyk6kL6IAjAG2IolMK4T0hNUe0HOUs5Jw==", + "dev": true, + "peer": true, + "dependencies": { + "argparse": "^1.0.7", + "esprima": "^4.0.0" + }, + "bin": { + "js-yaml": "bin/js-yaml.js" + } + }, + "node_modules/eth-gas-reporter/node_modules/locate-path": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/locate-path/-/locate-path-3.0.0.tgz", + "integrity": "sha512-7AO748wWnIhNqAuaty2ZWHkQHRSNfPVIsPIfwEOWO22AmaoVrWavlOcMR5nzTLNYvp36X220/maaRsrec1G65A==", + "dev": true, + "peer": true, + "dependencies": { + "p-locate": "^3.0.0", + "path-exists": "^3.0.0" + }, + "engines": { + "node": ">=6" + } + }, + "node_modules/eth-gas-reporter/node_modules/log-symbols": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/log-symbols/-/log-symbols-3.0.0.tgz", + "integrity": "sha512-dSkNGuI7iG3mfvDzUuYZyvk5dD9ocYCYzNU6CYDE6+Xqd+gwme6Z00NS3dUh8mq/73HaEtT7m6W+yUPtU6BZnQ==", + "dev": true, + "peer": true, + "dependencies": { + "chalk": "^2.4.2" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/eth-gas-reporter/node_modules/minimatch": { + "version": "3.0.4", + "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.0.4.tgz", + "integrity": "sha512-yJHVQEhyqPLUTgt9B83PXu6W3rx4MvvHvSUvToogpwoGDOUQ+yDrR0HRot+yOCdCO7u4hX3pWft6kWBBcqh0UA==", + "dev": true, + "peer": true, + "dependencies": { + "brace-expansion": "^1.1.7" + }, + "engines": { + "node": "*" + } + }, + "node_modules/eth-gas-reporter/node_modules/mkdirp": { + "version": "0.5.5", + "resolved": "https://registry.npmjs.org/mkdirp/-/mkdirp-0.5.5.tgz", + "integrity": "sha512-NKmAlESf6jMGym1++R0Ra7wvhV+wFW63FaSOFPwRahvea0gMUcGUhVeAg/0BC0wiv9ih5NYPB1Wn1UEI1/L+xQ==", + "dev": true, + "peer": true, + "dependencies": { + "minimist": "^1.2.5" + }, + "bin": { + "mkdirp": "bin/cmd.js" + } + }, + "node_modules/eth-gas-reporter/node_modules/mocha": { + "version": "7.2.0", + "resolved": "https://registry.npmjs.org/mocha/-/mocha-7.2.0.tgz", + "integrity": "sha512-O9CIypScywTVpNaRrCAgoUnJgozpIofjKUYmJhiCIJMiuYnLI6otcb1/kpW9/n/tJODHGZ7i8aLQoDVsMtOKQQ==", + "dev": true, + "peer": true, + "dependencies": { + "ansi-colors": "3.2.3", + "browser-stdout": "1.3.1", + "chokidar": "3.3.0", + "debug": "3.2.6", + "diff": "3.5.0", + "escape-string-regexp": "1.0.5", + "find-up": "3.0.0", + "glob": "7.1.3", + "growl": "1.10.5", + "he": "1.2.0", + "js-yaml": "3.13.1", + "log-symbols": "3.0.0", + "minimatch": "3.0.4", + "mkdirp": "0.5.5", + "ms": "2.1.1", + "node-environment-flags": "1.0.6", + "object.assign": "4.1.0", + "strip-json-comments": "2.0.1", + "supports-color": "6.0.0", + "which": "1.3.1", + "wide-align": "1.1.3", + "yargs": "13.3.2", + "yargs-parser": "13.1.2", + "yargs-unparser": "1.6.0" + }, + "bin": { + "_mocha": "bin/_mocha", + "mocha": "bin/mocha" + }, + "engines": { + "node": ">= 8.10.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/mochajs" + } + }, + "node_modules/eth-gas-reporter/node_modules/ms": { + "version": "2.1.1", + "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.1.tgz", + "integrity": "sha512-tgp+dl5cGk28utYktBsrFqA7HKgrhgPsg6Z/EfhWI4gl1Hwq8B/GmY/0oXZ6nF8hDVesS/FpnYaD/kOWhYQvyg==", + "dev": true, + "peer": true + }, + "node_modules/eth-gas-reporter/node_modules/p-limit": { + "version": "2.3.0", + "resolved": "https://registry.npmjs.org/p-limit/-/p-limit-2.3.0.tgz", + "integrity": "sha512-//88mFWSJx8lxCzwdAABTJL2MyWB12+eIY7MDL2SqLmAkeKU9qxRvWuSyTjm3FUmpBEMuFfckAIqEaVGUDxb6w==", + "dev": true, + "peer": true, + "dependencies": { + "p-try": "^2.0.0" + }, + "engines": { + "node": ">=6" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/eth-gas-reporter/node_modules/p-locate": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/p-locate/-/p-locate-3.0.0.tgz", + "integrity": "sha512-x+12w/To+4GFfgJhBEpiDcLozRJGegY+Ei7/z0tSLkMmxGZNybVMSfWj9aJn8Z5Fc7dBUNJOOVgPv2H7IwulSQ==", + "dev": true, + "peer": true, + "dependencies": { + "p-limit": "^2.0.0" + }, + "engines": { + "node": ">=6" + } + }, + "node_modules/eth-gas-reporter/node_modules/p-try": { + "version": "2.2.0", + "resolved": "https://registry.npmjs.org/p-try/-/p-try-2.2.0.tgz", + "integrity": "sha512-R4nPAVTAU0B9D35/Gk3uJf/7XYbQcyohSKdvAxIRSNghFl4e71hVoGnBNQz9cWaXxO2I10KTC+3jMdvvoKw6dQ==", + "dev": true, + "peer": true, + "engines": { + "node": ">=6" + } + }, + "node_modules/eth-gas-reporter/node_modules/readdirp": { + "version": "3.2.0", + "resolved": "https://registry.npmjs.org/readdirp/-/readdirp-3.2.0.tgz", + "integrity": "sha512-crk4Qu3pmXwgxdSgGhgA/eXiJAPQiX4GMOZZMXnqKxHX7TaoL+3gQVo/WeuAiogr07DpnfjIMpXXa+PAIvwPGQ==", + "dev": true, + "peer": true, + "dependencies": { + "picomatch": "^2.0.4" + }, + "engines": { + "node": ">= 8" + } + }, + "node_modules/eth-gas-reporter/node_modules/scrypt-js": { + "version": "2.0.4", + "resolved": "https://registry.npmjs.org/scrypt-js/-/scrypt-js-2.0.4.tgz", + "integrity": "sha512-4KsaGcPnuhtCZQCxFxN3GVYIhKFPTdLd8PLC552XwbMndtD0cjRFAhDuuydXQ0h08ZfPgzqe6EKHozpuH74iDw==", + "dev": true, + "peer": true + }, + "node_modules/eth-gas-reporter/node_modules/setimmediate": { + "version": "1.0.4", + "resolved": "https://registry.npmjs.org/setimmediate/-/setimmediate-1.0.4.tgz", + "integrity": "sha512-/TjEmXQVEzdod/FFskf3o7oOAsGhHf2j1dZqRFbDzq4F3mvvxflIIi4Hd3bLQE9y/CpwqfSQam5JakI/mi3Pog==", + "dev": true, + "peer": true + }, + "node_modules/eth-gas-reporter/node_modules/string-width": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/string-width/-/string-width-3.1.0.tgz", + "integrity": "sha512-vafcv6KjVZKSgz06oM/H6GDBrAtz8vdhQakGjFIvNrHA6y3HCF1CInLy+QLq8dTJPQ1b+KDUqDFctkdRW44e1w==", + "dev": true, + "peer": true, + "dependencies": { + "emoji-regex": "^7.0.1", + "is-fullwidth-code-point": "^2.0.0", + "strip-ansi": "^5.1.0" + }, + "engines": { + "node": ">=6" + } + }, + "node_modules/eth-gas-reporter/node_modules/strip-ansi": { + "version": "5.2.0", + "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-5.2.0.tgz", + "integrity": "sha512-DuRs1gKbBqsMKIZlrffwlug8MHkcnpjs5VPmL1PAh+mA30U0DTotfDZ0d2UUsXpPmPmMMJ6W773MaA3J+lbiWA==", + "dev": true, + "peer": true, + "dependencies": { + "ansi-regex": "^4.1.0" + }, + "engines": { + "node": ">=6" + } + }, + "node_modules/eth-gas-reporter/node_modules/strip-json-comments": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/strip-json-comments/-/strip-json-comments-2.0.1.tgz", + "integrity": "sha512-4gB8na07fecVVkOI6Rs4e7T6NOTki5EmL7TUduTs6bu3EdnSycntVJ4re8kgZA+wx9IueI2Y11bfbgwtzuE0KQ==", + "dev": true, + "peer": true, + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/eth-gas-reporter/node_modules/supports-color": { + "version": "6.0.0", + "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-6.0.0.tgz", + "integrity": "sha512-on9Kwidc1IUQo+bQdhi8+Tijpo0e1SS6RoGo2guUwn5vdaxw8RXOF9Vb2ws+ihWOmh4JnCJOvaziZWP1VABaLg==", + "dev": true, + "peer": true, + "dependencies": { + "has-flag": "^3.0.0" + }, + "engines": { + "node": ">=6" + } + }, + "node_modules/eth-gas-reporter/node_modules/uuid": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/uuid/-/uuid-2.0.1.tgz", + "integrity": "sha512-nWg9+Oa3qD2CQzHIP4qKUqwNfzKn8P0LtFhotaCTFchsV7ZfDhAybeip/HZVeMIpZi9JgY1E3nUlwaCmZT1sEg==", + "deprecated": "Please upgrade to version 7 or higher. Older versions may use Math.random() in certain circumstances, which is known to be problematic. See https://v8.dev/blog/math-random for details.", + "dev": true, + "peer": true + }, + "node_modules/eth-gas-reporter/node_modules/wrap-ansi": { + "version": "5.1.0", + "resolved": "https://registry.npmjs.org/wrap-ansi/-/wrap-ansi-5.1.0.tgz", + "integrity": "sha512-QC1/iN/2/RPVJ5jYK8BGttj5z83LmSKmvbvrXPNCLZSEb32KKVDJDl/MOt2N01qU2H/FkzEa9PKto1BqDjtd7Q==", + "dev": true, + "peer": true, + "dependencies": { + "ansi-styles": "^3.2.0", + "string-width": "^3.0.0", + "strip-ansi": "^5.0.0" + }, + "engines": { + "node": ">=6" + } + }, + "node_modules/eth-gas-reporter/node_modules/y18n": { + "version": "4.0.3", + "resolved": "https://registry.npmjs.org/y18n/-/y18n-4.0.3.tgz", + "integrity": "sha512-JKhqTOwSrqNA1NY5lSztJ1GrBiUodLMmIZuLiDaMRJ+itFd+ABVE8XBjOvIWL+rSqNDC74LCSFmlb/U4UZ4hJQ==", + "dev": true, + "peer": true + }, + "node_modules/eth-gas-reporter/node_modules/yargs": { + "version": "13.3.2", + "resolved": "https://registry.npmjs.org/yargs/-/yargs-13.3.2.tgz", + "integrity": "sha512-AX3Zw5iPruN5ie6xGRIDgqkT+ZhnRlZMLMHAs8tg7nRruy2Nb+i5o9bwghAogtM08q1dpr2LVoS8KSTMYpWXUw==", + "dev": true, + "peer": true, + "dependencies": { + "cliui": "^5.0.0", + "find-up": "^3.0.0", + "get-caller-file": "^2.0.1", + "require-directory": "^2.1.1", + "require-main-filename": "^2.0.0", + "set-blocking": "^2.0.0", + "string-width": "^3.0.0", + "which-module": "^2.0.0", + "y18n": "^4.0.0", + "yargs-parser": "^13.1.2" + } + }, + "node_modules/eth-gas-reporter/node_modules/yargs-parser": { + "version": "13.1.2", + "resolved": "https://registry.npmjs.org/yargs-parser/-/yargs-parser-13.1.2.tgz", + "integrity": "sha512-3lbsNRf/j+A4QuSZfDRA7HRSfWrzO0YjqTJd5kjAq37Zep1CEgaYmrH9Q3GwPiB9cHyd1Y1UwggGhJGoxipbzg==", + "dev": true, + "peer": true, + "dependencies": { + "camelcase": "^5.0.0", + "decamelize": "^1.2.0" + } + }, + "node_modules/eth-gas-reporter/node_modules/yargs-unparser": { + "version": "1.6.0", + "resolved": "https://registry.npmjs.org/yargs-unparser/-/yargs-unparser-1.6.0.tgz", + "integrity": "sha512-W9tKgmSn0DpSatfri0nx52Joq5hVXgeLiqR/5G0sZNDoLZFOr/xjBUDcShCOGNsBnEMNo1KAMBkTej1Hm62HTw==", + "dev": true, + "peer": true, + "dependencies": { + "flat": "^4.1.0", + "lodash": "^4.17.15", + "yargs": "^13.3.0" + }, + "engines": { + "node": ">=6" + } + }, + "node_modules/ethereum-bloom-filters": { + "version": "1.0.10", + "resolved": "https://registry.npmjs.org/ethereum-bloom-filters/-/ethereum-bloom-filters-1.0.10.tgz", + "integrity": "sha512-rxJ5OFN3RwjQxDcFP2Z5+Q9ho4eIdEmSc2ht0fCu8Se9nbXjZ7/031uXoUYJ87KHCOdVeiUuwSnoS7hmYAGVHA==", + "dev": true, + "peer": true, + "dependencies": { + "js-sha3": "^0.8.0" + } + }, + "node_modules/ethereum-cryptography": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/ethereum-cryptography/-/ethereum-cryptography-1.2.0.tgz", + "integrity": "sha512-6yFQC9b5ug6/17CQpCyE3k9eKBMdhyVjzUy1WkiuY/E4vj/SXDBbCw8QEIaXqf0Mf2SnY6RmpDcwlUmBSS0EJw==", + "dev": true, + "dependencies": { + "@noble/hashes": "1.2.0", + "@noble/secp256k1": "1.7.1", + "@scure/bip32": "1.1.5", + "@scure/bip39": "1.1.1" + } + }, + "node_modules/ethereumjs-abi": { + "version": "0.6.8", + "resolved": "https://registry.npmjs.org/ethereumjs-abi/-/ethereumjs-abi-0.6.8.tgz", + "integrity": "sha512-Tx0r/iXI6r+lRsdvkFDlut0N08jWMnKRZ6Gkq+Nmw75lZe4e6o3EkSnkaBP5NF6+m5PTGAr9JP43N3LyeoglsA==", + "dev": true, + "dependencies": { + "bn.js": "^4.11.8", + "ethereumjs-util": "^6.0.0" + } + }, + "node_modules/ethereumjs-abi/node_modules/bn.js": { + "version": "4.12.0", + "resolved": "https://registry.npmjs.org/bn.js/-/bn.js-4.12.0.tgz", + "integrity": "sha512-c98Bf3tPniI+scsdk237ku1Dc3ujXQTSgyiPUDEOe7tRkhrqridvh8klBv0HCEso1OLOYcHuCv/cS6DNxKH+ZA==", + "dev": true + }, + "node_modules/ethereumjs-util": { + "version": "6.2.1", + "resolved": "https://registry.npmjs.org/ethereumjs-util/-/ethereumjs-util-6.2.1.tgz", + "integrity": "sha512-W2Ktez4L01Vexijrm5EB6w7dg4n/TgpoYU4avuT5T3Vmnw/eCRtiBrJfQYS/DCSvDIOLn2k57GcHdeBcgVxAqw==", + "dev": true, + "dependencies": { + "@types/bn.js": "^4.11.3", + "bn.js": "^4.11.0", + "create-hash": "^1.1.2", + "elliptic": "^6.5.2", + "ethereum-cryptography": "^0.1.3", + "ethjs-util": "0.1.6", + "rlp": "^2.2.3" + } + }, + "node_modules/ethereumjs-util/node_modules/@types/bn.js": { + "version": "4.11.6", + "resolved": "https://registry.npmjs.org/@types/bn.js/-/bn.js-4.11.6.tgz", + "integrity": "sha512-pqr857jrp2kPuO9uRjZ3PwnJTjoQy+fcdxvBTvHm6dkmEL9q+hDD/2j/0ELOBPtPnS8LjCX0gI9nbl8lVkadpg==", + "dev": true, + "dependencies": { + "@types/node": "*" + } + }, + "node_modules/ethereumjs-util/node_modules/bn.js": { + "version": "4.12.0", + "resolved": "https://registry.npmjs.org/bn.js/-/bn.js-4.12.0.tgz", + "integrity": "sha512-c98Bf3tPniI+scsdk237ku1Dc3ujXQTSgyiPUDEOe7tRkhrqridvh8klBv0HCEso1OLOYcHuCv/cS6DNxKH+ZA==", + "dev": true + }, + "node_modules/ethereumjs-util/node_modules/ethereum-cryptography": { + "version": "0.1.3", + "resolved": "https://registry.npmjs.org/ethereum-cryptography/-/ethereum-cryptography-0.1.3.tgz", + "integrity": "sha512-w8/4x1SGGzc+tO97TASLja6SLd3fRIK2tLVcV2Gx4IB21hE19atll5Cq9o3d0ZmAYC/8aw0ipieTSiekAea4SQ==", + "dev": true, + "dependencies": { + "@types/pbkdf2": "^3.0.0", + "@types/secp256k1": "^4.0.1", + "blakejs": "^1.1.0", + "browserify-aes": "^1.2.0", + "bs58check": "^2.1.2", + "create-hash": "^1.2.0", + "create-hmac": "^1.1.7", + "hash.js": "^1.1.7", + "keccak": "^3.0.0", + "pbkdf2": "^3.0.17", + "randombytes": "^2.1.0", + "safe-buffer": "^5.1.2", + "scrypt-js": "^3.0.0", + "secp256k1": "^4.0.1", + "setimmediate": "^1.0.5" + } + }, + "node_modules/ethers": { + "version": "5.7.2", + "resolved": "https://registry.npmjs.org/ethers/-/ethers-5.7.2.tgz", + "integrity": "sha512-wswUsmWo1aOK8rR7DIKiWSw9DbLWe6x98Jrn8wcTflTVvaXhAMaB5zGAXy0GYQEQp9iO1iSHWVyARQm11zUtyg==", + "dev": true, + "funding": [ + { + "type": "individual", + "url": "https://gitcoin.co/grants/13/ethersjs-complete-simple-and-tiny-2" + }, + { + "type": "individual", + "url": "https://www.buymeacoffee.com/ricmoo" + } + ], + "dependencies": { + "@ethersproject/abi": "5.7.0", + "@ethersproject/abstract-provider": "5.7.0", + "@ethersproject/abstract-signer": "5.7.0", + "@ethersproject/address": "5.7.0", + "@ethersproject/base64": "5.7.0", + "@ethersproject/basex": "5.7.0", + "@ethersproject/bignumber": "5.7.0", + "@ethersproject/bytes": "5.7.0", + "@ethersproject/constants": "5.7.0", + "@ethersproject/contracts": "5.7.0", + "@ethersproject/hash": "5.7.0", + "@ethersproject/hdnode": "5.7.0", + "@ethersproject/json-wallets": "5.7.0", + "@ethersproject/keccak256": "5.7.0", + "@ethersproject/logger": "5.7.0", + "@ethersproject/networks": "5.7.1", + "@ethersproject/pbkdf2": "5.7.0", + "@ethersproject/properties": "5.7.0", + "@ethersproject/providers": "5.7.2", + "@ethersproject/random": "5.7.0", + "@ethersproject/rlp": "5.7.0", + "@ethersproject/sha2": "5.7.0", + "@ethersproject/signing-key": "5.7.0", + "@ethersproject/solidity": "5.7.0", + "@ethersproject/strings": "5.7.0", + "@ethersproject/transactions": "5.7.0", + "@ethersproject/units": "5.7.0", + "@ethersproject/wallet": "5.7.0", + "@ethersproject/web": "5.7.1", + "@ethersproject/wordlists": "5.7.0" + } + }, + "node_modules/ethjs-unit": { + "version": "0.1.6", + "resolved": "https://registry.npmjs.org/ethjs-unit/-/ethjs-unit-0.1.6.tgz", + "integrity": "sha512-/Sn9Y0oKl0uqQuvgFk/zQgR7aw1g36qX/jzSQ5lSwlO0GigPymk4eGQfeNTD03w1dPOqfz8V77Cy43jH56pagw==", + "dev": true, + "peer": true, + "dependencies": { + "bn.js": "4.11.6", + "number-to-bn": "1.7.0" + }, + "engines": { + "node": ">=6.5.0", + "npm": ">=3" + } + }, + "node_modules/ethjs-unit/node_modules/bn.js": { + "version": "4.11.6", + "resolved": "https://registry.npmjs.org/bn.js/-/bn.js-4.11.6.tgz", + "integrity": "sha512-XWwnNNFCuuSQ0m3r3C4LE3EiORltHd9M05pq6FOlVeiophzRbMo50Sbz1ehl8K3Z+jw9+vmgnXefY1hz8X+2wA==", + "dev": true, + "peer": true + }, + "node_modules/ethjs-util": { + "version": "0.1.6", + "resolved": "https://registry.npmjs.org/ethjs-util/-/ethjs-util-0.1.6.tgz", + "integrity": "sha512-CUnVOQq7gSpDHZVVrQW8ExxUETWrnrvXYvYz55wOU8Uj4VCgw56XC2B/fVqQN+f7gmrnRHSLVnFAwsCuNwji8w==", + "dev": true, + "dependencies": { + "is-hex-prefixed": "1.0.0", + "strip-hex-prefix": "1.0.0" + }, + "engines": { + "node": ">=6.5.0", + "npm": ">=3" + } + }, + "node_modules/event-target-shim": { + "version": "5.0.1", + "resolved": "https://registry.npmjs.org/event-target-shim/-/event-target-shim-5.0.1.tgz", + "integrity": "sha512-i/2XbnSz/uxRCU6+NdVJgKWDTM427+MqYbkQzD321DuCQJUqOuJKIA0IM2+W2xtYHdKOmZ4dR6fExsd4SXL+WQ==", + "dev": true, + "engines": { + "node": ">=6" + } + }, + "node_modules/evp_bytestokey": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/evp_bytestokey/-/evp_bytestokey-1.0.3.tgz", + "integrity": "sha512-/f2Go4TognH/KvCISP7OUsHn85hT9nUkxxA9BEWxFn+Oj9o8ZNLm/40hdlgSLyuOimsrTKLUMEorQexp/aPQeA==", + "dev": true, + "dependencies": { + "md5.js": "^1.3.4", + "safe-buffer": "^5.1.1" + } + }, + "node_modules/extend": { + "version": "3.0.2", + "resolved": "https://registry.npmjs.org/extend/-/extend-3.0.2.tgz", + "integrity": "sha512-fjquC59cD7CyW6urNXK0FBufkZcoiGG80wTuPujX590cB5Ttln20E2UB4S/WARVqhXffZl2LNgS+gQdPIIim/g==", + "dev": true, + "peer": true + }, + "node_modules/extsprintf": { + "version": "1.3.0", + "resolved": "https://registry.npmjs.org/extsprintf/-/extsprintf-1.3.0.tgz", + "integrity": "sha512-11Ndz7Nv+mvAC1j0ktTa7fAb0vLyGGX+rMHNBYQviQDGU0Hw7lhctJANqbPhu9nV9/izT/IntTgZ7Im/9LJs9g==", + "dev": true, + "engines": [ + "node >=0.6.0" + ], + "peer": true + }, + "node_modules/fast-deep-equal": { + "version": "3.1.3", + "resolved": "https://registry.npmjs.org/fast-deep-equal/-/fast-deep-equal-3.1.3.tgz", + "integrity": "sha512-f3qQ9oQy9j2AhBe/H9VC91wLmKBCCU/gDOnKNAYG5hswO7BLKj09Hc5HYNz9cGI++xlpDCIgDaitVs03ATR84Q==", + "dev": true, + "peer": true + }, + "node_modules/fast-glob": { + "version": "3.2.12", + "resolved": "https://registry.npmjs.org/fast-glob/-/fast-glob-3.2.12.tgz", + "integrity": "sha512-DVj4CQIYYow0BlaelwK1pHl5n5cRSJfM60UA0zK891sVInoPri2Ekj7+e1CT3/3qxXenpI+nBBmQAcJPJgaj4w==", + "dev": true, + "peer": true, + "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" + }, + "engines": { + "node": ">=8.6.0" + } + }, + "node_modules/fast-json-stable-stringify": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/fast-json-stable-stringify/-/fast-json-stable-stringify-2.1.0.tgz", + "integrity": "sha512-lhd/wF+Lk98HZoTCtlVraHtfh5XYijIjalXck7saUtuanSDyLMxnHhSXEDJqHxD7msR8D0uCmqlkwjCV8xvwHw==", + "dev": true, + "peer": true + }, + "node_modules/fast-levenshtein": { + "version": "2.0.6", + "resolved": "https://registry.npmjs.org/fast-levenshtein/-/fast-levenshtein-2.0.6.tgz", + "integrity": "sha512-DCXu6Ifhqcks7TZKY3Hxp3y6qphY5SJZmrWMDrKcERSOXWQdMhU9Ig/PYrzyw/ul9jOIyh0N4M0tbC5hodg8dw==", + "dev": true, + "peer": true + }, + "node_modules/fastq": { + "version": "1.15.0", + "resolved": "https://registry.npmjs.org/fastq/-/fastq-1.15.0.tgz", + "integrity": "sha512-wBrocU2LCXXa+lWBt8RoIRD89Fi8OdABODa/kEnyeyjS5aZO5/GNvI5sEINADqP/h8M29UHTHUb53sUu5Ihqdw==", + "dev": true, + "peer": true, + "dependencies": { + "reusify": "^1.0.4" + } + }, + "node_modules/fill-range": { + "version": "7.0.1", + "resolved": "https://registry.npmjs.org/fill-range/-/fill-range-7.0.1.tgz", + "integrity": "sha512-qOo9F+dMUmC2Lcb4BbVvnKJxTPjCm+RRpe4gDuGrzkL7mEVl/djYSu2OdQ2Pa302N4oqkSg9ir6jaLWJ2USVpQ==", + "dev": true, + "dependencies": { + "to-regex-range": "^5.0.1" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/find-replace": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/find-replace/-/find-replace-3.0.0.tgz", + "integrity": "sha512-6Tb2myMioCAgv5kfvP5/PkZZ/ntTpVK39fHY7WkWBgvbeE+VHd/tZuZ4mrC+bxh4cfOZeYKVPaJIZtZXV7GNCQ==", + "dev": true, + "peer": true, + "dependencies": { + "array-back": "^3.0.1" + }, + "engines": { + "node": ">=4.0.0" + } + }, + "node_modules/find-up": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/find-up/-/find-up-2.1.0.tgz", + "integrity": "sha512-NWzkk0jSJtTt08+FBFMvXoeZnOJD+jTtsRmBYbAIzJdX6l7dLgR7CTubCM5/eDdPUBvLCeVasP1brfVR/9/EZQ==", + "dev": true, + "dependencies": { + "locate-path": "^2.0.0" + }, + "engines": { + "node": ">=4" + } + }, + "node_modules/flat": { + "version": "5.0.2", + "resolved": "https://registry.npmjs.org/flat/-/flat-5.0.2.tgz", + "integrity": "sha512-b6suED+5/3rTpUBdG1gupIl8MPFCAMA0QXwmljLhvCUKcUvdE4gWky9zpuGCcXHOsz4J9wPGNWq6OKpmIzz3hQ==", + "dev": true, + "bin": { + "flat": "cli.js" + } + }, + "node_modules/follow-redirects": { + "version": "1.15.2", + "resolved": "https://registry.npmjs.org/follow-redirects/-/follow-redirects-1.15.2.tgz", + "integrity": "sha512-VQLG33o04KaQ8uYi2tVNbdrWp1QWxNNea+nmIB4EVM28v0hmP17z7aG1+wAkNzVq4KeXTq3221ye5qTJP91JwA==", + "dev": true, + "funding": [ + { + "type": "individual", + "url": "https://github.com/sponsors/RubenVerborgh" + } + ], + "engines": { + "node": ">=4.0" + }, + "peerDependenciesMeta": { + "debug": { + "optional": true + } + } + }, + "node_modules/for-each": { + "version": "0.3.3", + "resolved": "https://registry.npmjs.org/for-each/-/for-each-0.3.3.tgz", + "integrity": "sha512-jqYfLp7mo9vIyQf8ykW2v7A+2N4QjeCeI5+Dz9XraiO1ign81wjiH7Fb9vSOWvQfNtmSa4H2RoQTrrXivdUZmw==", + "dev": true, + "peer": true, + "dependencies": { + "is-callable": "^1.1.3" + } + }, + "node_modules/forever-agent": { + "version": "0.6.1", + "resolved": "https://registry.npmjs.org/forever-agent/-/forever-agent-0.6.1.tgz", + "integrity": "sha512-j0KLYPhm6zeac4lz3oJ3o65qvgQCcPubiyotZrXqEaG4hNagNYO8qdlUrX5vwqv9ohqeT/Z3j6+yW067yWWdUw==", + "dev": true, + "peer": true, + "engines": { + "node": "*" + } + }, + "node_modules/form-data": { + "version": "2.3.3", + "resolved": "https://registry.npmjs.org/form-data/-/form-data-2.3.3.tgz", + "integrity": "sha512-1lLKB2Mu3aGP1Q/2eCOx0fNbRMe7XdwktwOruhfqqd0rIJWwN4Dh+E3hrPSlDCXnSR7UtZ1N38rVXm+6+MEhJQ==", + "dev": true, + "peer": true, + "dependencies": { + "asynckit": "^0.4.0", + "combined-stream": "^1.0.6", + "mime-types": "^2.1.12" + }, + "engines": { + "node": ">= 0.12" + } + }, + "node_modules/fp-ts": { + "version": "1.19.3", + "resolved": "https://registry.npmjs.org/fp-ts/-/fp-ts-1.19.3.tgz", + "integrity": "sha512-H5KQDspykdHuztLTg+ajGN0Z2qUjcEf3Ybxc6hLt0k7/zPkn29XnKnxlBPyW2XIddWrGaJBzBl4VLYOtk39yZg==", + "dev": true + }, + "node_modules/fs-extra": { + "version": "7.0.1", + "resolved": "https://registry.npmjs.org/fs-extra/-/fs-extra-7.0.1.tgz", + "integrity": "sha512-YJDaCJZEnBmcbw13fvdAM9AwNOJwOzrE4pqMqBq5nFiEqXUqHwlK4B+3pUw6JNvfSPtX05xFHtYy/1ni01eGCw==", + "dev": true, + "dependencies": { + "graceful-fs": "^4.1.2", + "jsonfile": "^4.0.0", + "universalify": "^0.1.0" + }, + "engines": { + "node": ">=6 <7 || >=8" + } + }, + "node_modules/fs-readdir-recursive": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/fs-readdir-recursive/-/fs-readdir-recursive-1.1.0.tgz", + "integrity": "sha512-GNanXlVr2pf02+sPN40XN8HG+ePaNcvM0q5mZBd668Obwb0yD5GiUbZOFgwn8kGMY6I3mdyDJzieUy3PTYyTRA==", + "dev": true, + "peer": true + }, + "node_modules/fs.realpath": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/fs.realpath/-/fs.realpath-1.0.0.tgz", + "integrity": "sha512-OO0pH2lK6a0hZnAdau5ItzHPI6pUlvI7jMVnxUQRtw4owF2wk8lOSabtGDCTP4Ggrg2MbGnWO9X8K1t4+fGMDw==", + "dev": true + }, + "node_modules/fsevents": { + "version": "2.3.2", + "resolved": "https://registry.npmjs.org/fsevents/-/fsevents-2.3.2.tgz", + "integrity": "sha512-xiqMQR4xAeHTuB9uWm+fFRcIOgKBMiOBP+eXiyT7jsgVCq1bkVygt00oASowB7EdtpOHaaPgKt812P9ab+DDKA==", + "dev": true, + "hasInstallScript": true, + "optional": true, + "os": [ + "darwin" + ], + "engines": { + "node": "^8.16.0 || ^10.6.0 || >=11.0.0" + } + }, + "node_modules/function-bind": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/function-bind/-/function-bind-1.1.1.tgz", + "integrity": "sha512-yIovAzMX49sF8Yl58fSCWJ5svSLuaibPxXQJFLmBObTuCr0Mf1KiPopGM9NiFjiYBCbfaa2Fh6breQ6ANVTI0A==", + "dev": true + }, + "node_modules/function.prototype.name": { + "version": "1.1.5", + "resolved": "https://registry.npmjs.org/function.prototype.name/-/function.prototype.name-1.1.5.tgz", + "integrity": "sha512-uN7m/BzVKQnCUF/iW8jYea67v++2u7m5UgENbHRtdDVclOUP+FMPlCNdmk0h/ysGyo2tavMJEDqJAkJdRa1vMA==", + "dev": true, + "peer": true, + "dependencies": { + "call-bind": "^1.0.2", + "define-properties": "^1.1.3", + "es-abstract": "^1.19.0", + "functions-have-names": "^1.2.2" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/functional-red-black-tree": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/functional-red-black-tree/-/functional-red-black-tree-1.0.1.tgz", + "integrity": "sha512-dsKNQNdj6xA3T+QlADDA7mOSlX0qiMINjn0cgr+eGHGsbSHzTabcIogz2+p/iqP1Xs6EP/sS2SbqH+brGTbq0g==", + "dev": true + }, + "node_modules/functions-have-names": { + "version": "1.2.3", + "resolved": "https://registry.npmjs.org/functions-have-names/-/functions-have-names-1.2.3.tgz", + "integrity": "sha512-xckBUXyTIqT97tq2x2AMb+g163b5JFysYk0x4qxNFwbfQkmNZoiRHb6sPzI9/QV33WeuvVYBUIiD4NzNIyqaRQ==", + "dev": true, + "peer": true, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/get-caller-file": { + "version": "2.0.5", + "resolved": "https://registry.npmjs.org/get-caller-file/-/get-caller-file-2.0.5.tgz", + "integrity": "sha512-DyFP3BM/3YHTQOCUL/w0OZHR0lpKeGrxotcHWcqNEdnltqFwXVfhEBQ94eIo34AfQpo0rGki4cyIiftY06h2Fg==", + "dev": true, + "engines": { + "node": "6.* || 8.* || >= 10.*" + } + }, + "node_modules/get-func-name": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/get-func-name/-/get-func-name-2.0.0.tgz", + "integrity": "sha512-Hm0ixYtaSZ/V7C8FJrtZIuBBI+iSgL+1Aq82zSu8VQNB4S3Gk8e7Qs3VwBDJAhmRZcFqkl3tQu36g/Foh5I5ig==", + "dev": true, + "peer": true, + "engines": { + "node": "*" + } + }, + "node_modules/get-intrinsic": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/get-intrinsic/-/get-intrinsic-1.2.0.tgz", + "integrity": "sha512-L049y6nFOuom5wGyRc3/gdTLO94dySVKRACj1RmJZBQXlbTMhtNIgkWkUHq+jYmZvKf14EW1EoJnnjbmoHij0Q==", + "dev": true, + "dependencies": { + "function-bind": "^1.1.1", + "has": "^1.0.3", + "has-symbols": "^1.0.3" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/get-port": { + "version": "3.2.0", + "resolved": "https://registry.npmjs.org/get-port/-/get-port-3.2.0.tgz", + "integrity": "sha512-x5UJKlgeUiNT8nyo/AcnwLnZuZNcSjSw0kogRB+Whd1fjjFq4B1hySFxSFWWSn4mIBzg3sRNUDFYc4g5gjPoLg==", + "dev": true, + "peer": true, + "engines": { + "node": ">=4" + } + }, + "node_modules/get-symbol-description": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/get-symbol-description/-/get-symbol-description-1.0.0.tgz", + "integrity": "sha512-2EmdH1YvIQiZpltCNgkuiUnyukzxM/R6NDJX31Ke3BG1Nq5b0S2PhX59UKi9vZpPDQVdqn+1IcaAwnzTT5vCjw==", + "dev": true, + "peer": true, + "dependencies": { + "call-bind": "^1.0.2", + "get-intrinsic": "^1.1.1" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/getpass": { + "version": "0.1.7", + "resolved": "https://registry.npmjs.org/getpass/-/getpass-0.1.7.tgz", + "integrity": "sha512-0fzj9JxOLfJ+XGLhR8ze3unN0KZCgZwiSSDz168VERjK8Wl8kVSdcu2kspd4s4wtAa1y/qrVRiAA0WclVsu0ng==", + "dev": true, + "peer": true, + "dependencies": { + "assert-plus": "^1.0.0" + } + }, + "node_modules/ghost-testrpc": { + "version": "0.0.2", + "resolved": "https://registry.npmjs.org/ghost-testrpc/-/ghost-testrpc-0.0.2.tgz", + "integrity": "sha512-i08dAEgJ2g8z5buJIrCTduwPIhih3DP+hOCTyyryikfV8T0bNvHnGXO67i0DD1H4GBDETTclPy9njZbfluQYrQ==", + "dev": true, + "peer": true, + "dependencies": { + "chalk": "^2.4.2", + "node-emoji": "^1.10.0" + }, + "bin": { + "testrpc-sc": "index.js" + } + }, + "node_modules/glob": { + "version": "7.2.0", + "resolved": "https://registry.npmjs.org/glob/-/glob-7.2.0.tgz", + "integrity": "sha512-lmLf6gtyrPq8tTjSmrO94wBeQbFR3HbLHbuyD69wuyQkImp2hWqMGB47OX65FBkPffO641IP9jWa1z4ivqG26Q==", + "dev": true, + "dependencies": { + "fs.realpath": "^1.0.0", + "inflight": "^1.0.4", + "inherits": "2", + "minimatch": "^3.0.4", + "once": "^1.3.0", + "path-is-absolute": "^1.0.0" + }, + "engines": { + "node": "*" + }, + "funding": { + "url": "https://github.com/sponsors/isaacs" + } + }, + "node_modules/glob-parent": { + "version": "5.1.2", + "resolved": "https://registry.npmjs.org/glob-parent/-/glob-parent-5.1.2.tgz", + "integrity": "sha512-AOIgSQCepiJYwP3ARnGx+5VnTu2HBYdzbGP45eLw1vr3zB3vZLeyed1sC9hnbcOc9/SrMyM5RPQrkGz4aS9Zow==", + "dev": true, + "dependencies": { + "is-glob": "^4.0.1" + }, + "engines": { + "node": ">= 6" + } + }, + "node_modules/global-modules": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/global-modules/-/global-modules-2.0.0.tgz", + "integrity": "sha512-NGbfmJBp9x8IxyJSd1P+otYK8vonoJactOogrVfFRIAEY1ukil8RSKDz2Yo7wh1oihl51l/r6W4epkeKJHqL8A==", + "dev": true, + "peer": true, + "dependencies": { + "global-prefix": "^3.0.0" + }, + "engines": { + "node": ">=6" + } + }, + "node_modules/global-prefix": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/global-prefix/-/global-prefix-3.0.0.tgz", + "integrity": "sha512-awConJSVCHVGND6x3tmMaKcQvwXLhjdkmomy2W+Goaui8YPgYgXJZewhg3fWC+DlfqqQuWg8AwqjGTD2nAPVWg==", + "dev": true, + "peer": true, + "dependencies": { + "ini": "^1.3.5", + "kind-of": "^6.0.2", + "which": "^1.3.1" + }, + "engines": { + "node": ">=6" + } + }, + "node_modules/globalthis": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/globalthis/-/globalthis-1.0.3.tgz", + "integrity": "sha512-sFdI5LyBiNTHjRd7cGPWapiHWMOXKyuBNX/cWJ3NfzrZQVa8GI/8cofCl74AOVqq9W5kNmguTIzJ/1s2gyI9wA==", + "dev": true, + "peer": true, + "dependencies": { + "define-properties": "^1.1.3" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/globby": { + "version": "10.0.2", + "resolved": "https://registry.npmjs.org/globby/-/globby-10.0.2.tgz", + "integrity": "sha512-7dUi7RvCoT/xast/o/dLN53oqND4yk0nsHkhRgn9w65C4PofCLOoJ39iSOg+qVDdWQPIEj+eszMHQ+aLVwwQSg==", + "dev": true, + "peer": true, + "dependencies": { + "@types/glob": "^7.1.1", + "array-union": "^2.1.0", + "dir-glob": "^3.0.1", + "fast-glob": "^3.0.3", + "glob": "^7.1.3", + "ignore": "^5.1.1", + "merge2": "^1.2.3", + "slash": "^3.0.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/gopd": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/gopd/-/gopd-1.0.1.tgz", + "integrity": "sha512-d65bNlIadxvpb/A2abVdlqKqV563juRnZ1Wtk6s1sIR8uNsXR70xqIzVqxVf1eTqDunwT2MkczEeaezCKTZhwA==", + "dev": true, + "peer": true, + "dependencies": { + "get-intrinsic": "^1.1.3" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/graceful-fs": { + "version": "4.2.11", + "resolved": "https://registry.npmjs.org/graceful-fs/-/graceful-fs-4.2.11.tgz", + "integrity": "sha512-RbJ5/jmFcNNCcDV5o9eTnBLJ/HszWV0P73bc+Ff4nS/rJj+YaS6IGyiOL0VoBYX+l1Wrl3k63h/KrH+nhJ0XvQ==", + "dev": true + }, + "node_modules/growl": { + "version": "1.10.5", + "resolved": "https://registry.npmjs.org/growl/-/growl-1.10.5.tgz", + "integrity": "sha512-qBr4OuELkhPenW6goKVXiv47US3clb3/IbuWF9KNKEijAy9oeHxU9IgzjvJhHkUzhaj7rOUD7+YGWqUjLp5oSA==", + "dev": true, + "peer": true, + "engines": { + "node": ">=4.x" + } + }, + "node_modules/handlebars": { + "version": "4.7.7", + "resolved": "https://registry.npmjs.org/handlebars/-/handlebars-4.7.7.tgz", + "integrity": "sha512-aAcXm5OAfE/8IXkcZvCepKU3VzW1/39Fb5ZuqMtgI/hT8X2YgoMvBY5dLhq/cpOvw7Lk1nK/UF71aLG/ZnVYRA==", + "dev": true, + "peer": true, + "dependencies": { + "minimist": "^1.2.5", + "neo-async": "^2.6.0", + "source-map": "^0.6.1", + "wordwrap": "^1.0.0" + }, + "bin": { + "handlebars": "bin/handlebars" + }, + "engines": { + "node": ">=0.4.7" + }, + "optionalDependencies": { + "uglify-js": "^3.1.4" + } + }, + "node_modules/har-schema": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/har-schema/-/har-schema-2.0.0.tgz", + "integrity": "sha512-Oqluz6zhGX8cyRaTQlFMPw80bSJVG2x/cFb8ZPhUILGgHka9SsokCCOQgpveePerqidZOrT14ipqfJb7ILcW5Q==", + "dev": true, + "peer": true, + "engines": { + "node": ">=4" + } + }, + "node_modules/har-validator": { + "version": "5.1.5", + "resolved": "https://registry.npmjs.org/har-validator/-/har-validator-5.1.5.tgz", + "integrity": "sha512-nmT2T0lljbxdQZfspsno9hgrG3Uir6Ks5afism62poxqBM6sDnMEuPmzTq8XN0OEwqKLLdh1jQI3qyE66Nzb3w==", + "deprecated": "this library is no longer supported", + "dev": true, + "peer": true, + "dependencies": { + "ajv": "^6.12.3", + "har-schema": "^2.0.0" + }, + "engines": { + "node": ">=6" + } + }, + "node_modules/hardhat": { + "version": "2.14.0", + "resolved": "https://registry.npmjs.org/hardhat/-/hardhat-2.14.0.tgz", + "integrity": "sha512-73jsInY4zZahMSVFurSK+5TNCJTXMv+vemvGia0Ac34Mm19fYp6vEPVGF3sucbumszsYxiTT2TbS8Ii2dsDSoQ==", + "dev": true, + "dependencies": { + "@ethersproject/abi": "^5.1.2", + "@metamask/eth-sig-util": "^4.0.0", + "@nomicfoundation/ethereumjs-block": "5.0.1", + "@nomicfoundation/ethereumjs-blockchain": "7.0.1", + "@nomicfoundation/ethereumjs-common": "4.0.1", + "@nomicfoundation/ethereumjs-evm": "2.0.1", + "@nomicfoundation/ethereumjs-rlp": "5.0.1", + "@nomicfoundation/ethereumjs-statemanager": "2.0.1", + "@nomicfoundation/ethereumjs-trie": "6.0.1", + "@nomicfoundation/ethereumjs-tx": "5.0.1", + "@nomicfoundation/ethereumjs-util": "9.0.1", + "@nomicfoundation/ethereumjs-vm": "7.0.1", + "@nomicfoundation/solidity-analyzer": "^0.1.0", + "@sentry/node": "^5.18.1", + "@types/bn.js": "^5.1.0", + "@types/lru-cache": "^5.1.0", + "abort-controller": "^3.0.0", + "adm-zip": "^0.4.16", + "aggregate-error": "^3.0.0", + "ansi-escapes": "^4.3.0", + "chalk": "^2.4.2", + "chokidar": "^3.4.0", + "ci-info": "^2.0.0", + "debug": "^4.1.1", + "enquirer": "^2.3.0", + "env-paths": "^2.2.0", + "ethereum-cryptography": "^1.0.3", + "ethereumjs-abi": "^0.6.8", + "find-up": "^2.1.0", + "fp-ts": "1.19.3", + "fs-extra": "^7.0.1", + "glob": "7.2.0", + "immutable": "^4.0.0-rc.12", + "io-ts": "1.10.4", + "keccak": "^3.0.2", + "lodash": "^4.17.11", + "mnemonist": "^0.38.0", + "mocha": "^10.0.0", + "p-map": "^4.0.0", + "qs": "^6.7.0", + "raw-body": "^2.4.1", + "resolve": "1.17.0", + "semver": "^6.3.0", + "solc": "0.7.3", + "source-map-support": "^0.5.13", + "stacktrace-parser": "^0.1.10", + "tsort": "0.0.1", + "undici": "^5.14.0", + "uuid": "^8.3.2", + "ws": "^7.4.6" + }, + "bin": { + "hardhat": "internal/cli/bootstrap.js" + }, + "engines": { + "node": ">=14.0.0" + }, + "peerDependencies": { + "ts-node": "*", + "typescript": "*" + }, + "peerDependenciesMeta": { + "ts-node": { + "optional": true + }, + "typescript": { + "optional": true + } + } + }, + "node_modules/hardhat-gas-reporter": { + "version": "1.0.9", + "resolved": "https://registry.npmjs.org/hardhat-gas-reporter/-/hardhat-gas-reporter-1.0.9.tgz", + "integrity": "sha512-INN26G3EW43adGKBNzYWOlI3+rlLnasXTwW79YNnUhXPDa+yHESgt639dJEs37gCjhkbNKcRRJnomXEuMFBXJg==", + "dev": true, + "peer": true, + "dependencies": { + "array-uniq": "1.0.3", + "eth-gas-reporter": "^0.2.25", + "sha1": "^1.1.1" + }, + "peerDependencies": { + "hardhat": "^2.0.2" + } + }, + "node_modules/has": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/has/-/has-1.0.3.tgz", + "integrity": "sha512-f2dvO0VU6Oej7RkWJGrehjbzMAjFp5/VKPp5tTpWIV4JHHZK1/BxbFRtf/siA2SWTe09caDmVtYYzWEIbBS4zw==", + "dev": true, + "dependencies": { + "function-bind": "^1.1.1" + }, + "engines": { + "node": ">= 0.4.0" + } + }, + "node_modules/has-bigints": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/has-bigints/-/has-bigints-1.0.2.tgz", + "integrity": "sha512-tSvCKtBr9lkF0Ex0aQiP9N+OpV4zi2r/Nee5VkRDbaqv35RLYMzbwQfFSZZH0kR+Rd6302UJZ2p/bJCEoR3VoQ==", + "dev": true, + "peer": true, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/has-flag": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-3.0.0.tgz", + "integrity": "sha512-sKJf1+ceQBr4SMkvQnBDNDtf4TXpVhVGateu0t918bl30FnbE2m4vNLX+VWe/dpjlb+HugGYzW7uQXH98HPEYw==", + "dev": true, + "engines": { + "node": ">=4" + } + }, + "node_modules/has-property-descriptors": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/has-property-descriptors/-/has-property-descriptors-1.0.0.tgz", + "integrity": "sha512-62DVLZGoiEBDHQyqG4w9xCuZ7eJEwNmJRWw2VY84Oedb7WFcA27fiEVe8oUQx9hAUJ4ekurquucTGwsyO1XGdQ==", + "dev": true, + "peer": true, + "dependencies": { + "get-intrinsic": "^1.1.1" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/has-proto": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/has-proto/-/has-proto-1.0.1.tgz", + "integrity": "sha512-7qE+iP+O+bgF9clE5+UoBFzE65mlBiVj3tKCrlNQ0Ogwm0BjpT/gK4SlLYDMybDh5I3TCTKnPPa0oMG7JDYrhg==", + "dev": true, + "peer": true, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/has-symbols": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/has-symbols/-/has-symbols-1.0.3.tgz", + "integrity": "sha512-l3LCuF6MgDNwTDKkdYGEihYjt5pRPbEg46rtlmnSPlUbgmB8LOIrKJbYYFBSbnPaJexMKtiPO8hmeRjRz2Td+A==", + "dev": true, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/has-tostringtag": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/has-tostringtag/-/has-tostringtag-1.0.0.tgz", + "integrity": "sha512-kFjcSNhnlGV1kyoGk7OXKSawH5JOb/LzUc5w9B02hOTO0dfFRjbHQKvg1d6cf3HbeUmtU9VbbV3qzZ2Teh97WQ==", + "dev": true, + "peer": true, + "dependencies": { + "has-symbols": "^1.0.2" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/hash-base": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/hash-base/-/hash-base-3.1.0.tgz", + "integrity": "sha512-1nmYp/rhMDiE7AYkDw+lLwlAzz0AntGIe51F3RfFfEqyQ3feY2eI/NcwC6umIQVOASPMsWJLJScWKSSvzL9IVA==", + "dev": true, + "dependencies": { + "inherits": "^2.0.4", + "readable-stream": "^3.6.0", + "safe-buffer": "^5.2.0" + }, + "engines": { + "node": ">=4" + } + }, + "node_modules/hash-base/node_modules/safe-buffer": { + "version": "5.2.1", + "resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.2.1.tgz", + "integrity": "sha512-rp3So07KcdmmKbGvgaNxQSJr7bGVSVk5S9Eq1F+ppbRo70+YeaDxkw5Dd8NPN+GD6bjnYm2VuPuCXmpuYvmCXQ==", + "dev": true, + "funding": [ + { + "type": "github", + "url": "https://github.com/sponsors/feross" + }, + { + "type": "patreon", + "url": "https://www.patreon.com/feross" + }, + { + "type": "consulting", + "url": "https://feross.org/support" + } + ] + }, + "node_modules/hash.js": { + "version": "1.1.7", + "resolved": "https://registry.npmjs.org/hash.js/-/hash.js-1.1.7.tgz", + "integrity": "sha512-taOaskGt4z4SOANNseOviYDvjEJinIkRgmp7LbKP2YTTmVxWBl87s/uzK9r+44BclBSp2X7K1hqeNfz9JbBeXA==", + "dev": true, + "dependencies": { + "inherits": "^2.0.3", + "minimalistic-assert": "^1.0.1" + } + }, + "node_modules/he": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/he/-/he-1.2.0.tgz", + "integrity": "sha512-F/1DnUGPopORZi0ni+CvrCgHQ5FyEAHRLSApuYWMmrbSwoN2Mn/7k+Gl38gJnR7yyDZk6WLXwiGod1JOWNDKGw==", + "dev": true, + "bin": { + "he": "bin/he" + } + }, + "node_modules/heap": { + "version": "0.2.7", + "resolved": "https://registry.npmjs.org/heap/-/heap-0.2.7.tgz", + "integrity": "sha512-2bsegYkkHO+h/9MGbn6KWcE45cHZgPANo5LXF7EvWdT0yT2EguSVO1nDgU5c8+ZOPwp2vMNa7YFsJhVcDR9Sdg==", + "dev": true, + "peer": true + }, + "node_modules/hmac-drbg": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/hmac-drbg/-/hmac-drbg-1.0.1.tgz", + "integrity": "sha512-Tti3gMqLdZfhOQY1Mzf/AanLiqh1WTiJgEj26ZuYQ9fbkLomzGchCws4FyrSd4VkpBfiNhaE1On+lOz894jvXg==", + "dev": true, + "dependencies": { + "hash.js": "^1.0.3", + "minimalistic-assert": "^1.0.0", + "minimalistic-crypto-utils": "^1.0.1" + } + }, + "node_modules/http-basic": { + "version": "8.1.3", + "resolved": "https://registry.npmjs.org/http-basic/-/http-basic-8.1.3.tgz", + "integrity": "sha512-/EcDMwJZh3mABI2NhGfHOGOeOZITqfkEO4p/xK+l3NpyncIHUQBoMvCSF/b5GqvKtySC2srL/GGG3+EtlqlmCw==", + "dev": true, + "peer": true, + "dependencies": { + "caseless": "^0.12.0", + "concat-stream": "^1.6.2", + "http-response-object": "^3.0.1", + "parse-cache-control": "^1.0.1" + }, + "engines": { + "node": ">=6.0.0" + } + }, + "node_modules/http-errors": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/http-errors/-/http-errors-2.0.0.tgz", + "integrity": "sha512-FtwrG/euBzaEjYeRqOgly7G0qviiXoJWnvEH2Z1plBdXgbyjv34pHTSb9zoeHMyDy33+DWy5Wt9Wo+TURtOYSQ==", + "dev": true, + "dependencies": { + "depd": "2.0.0", + "inherits": "2.0.4", + "setprototypeof": "1.2.0", + "statuses": "2.0.1", + "toidentifier": "1.0.1" + }, + "engines": { + "node": ">= 0.8" + } + }, + "node_modules/http-response-object": { + "version": "3.0.2", + "resolved": "https://registry.npmjs.org/http-response-object/-/http-response-object-3.0.2.tgz", + "integrity": "sha512-bqX0XTF6fnXSQcEJ2Iuyr75yVakyjIDCqroJQ/aHfSdlM743Cwqoi2nDYMzLGWUcuTWGWy8AAvOKXTfiv6q9RA==", + "dev": true, + "peer": true, + "dependencies": { + "@types/node": "^10.0.3" + } + }, + "node_modules/http-response-object/node_modules/@types/node": { + "version": "10.17.60", + "resolved": "https://registry.npmjs.org/@types/node/-/node-10.17.60.tgz", + "integrity": "sha512-F0KIgDJfy2nA3zMLmWGKxcH2ZVEtCZXHHdOQs2gSaQ27+lNeEfGxzkIw90aXswATX7AZ33tahPbzy6KAfUreVw==", + "dev": true, + "peer": true + }, + "node_modules/http-signature": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/http-signature/-/http-signature-1.2.0.tgz", + "integrity": "sha512-CAbnr6Rz4CYQkLYUtSNXxQPUH2gK8f3iWexVlsnMeD+GjlsQ0Xsy1cOX+mN3dtxYomRy21CiOzU8Uhw6OwncEQ==", + "dev": true, + "peer": true, + "dependencies": { + "assert-plus": "^1.0.0", + "jsprim": "^1.2.2", + "sshpk": "^1.7.0" + }, + "engines": { + "node": ">=0.8", + "npm": ">=1.3.7" + } + }, + "node_modules/https-proxy-agent": { + "version": "5.0.1", + "resolved": "https://registry.npmjs.org/https-proxy-agent/-/https-proxy-agent-5.0.1.tgz", + "integrity": "sha512-dFcAjpTQFgoLMzC2VwU+C/CbS7uRL0lWmxDITmqm7C+7F0Odmj6s9l6alZc6AELXhrnggM2CeWSXHGOdX2YtwA==", + "dev": true, + "dependencies": { + "agent-base": "6", + "debug": "4" + }, + "engines": { + "node": ">= 6" + } + }, + "node_modules/iconv-lite": { + "version": "0.4.24", + "resolved": "https://registry.npmjs.org/iconv-lite/-/iconv-lite-0.4.24.tgz", + "integrity": "sha512-v3MXnZAcvnywkTUEZomIActle7RXXeedOR31wwl7VlyoXO4Qi9arvSenNQWne1TcRwhCL1HwLI21bEqdpj8/rA==", + "dev": true, + "dependencies": { + "safer-buffer": ">= 2.1.2 < 3" + }, + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/ieee754": { + "version": "1.2.1", + "resolved": "https://registry.npmjs.org/ieee754/-/ieee754-1.2.1.tgz", + "integrity": "sha512-dcyqhDvX1C46lXZcVqCpK+FtMRQVdIMN6/Df5js2zouUsqG7I6sFxitIC+7KYK29KdXOLHdu9zL4sFnoVQnqaA==", + "dev": true, + "funding": [ + { + "type": "github", + "url": "https://github.com/sponsors/feross" + }, + { + "type": "patreon", + "url": "https://www.patreon.com/feross" + }, + { + "type": "consulting", + "url": "https://feross.org/support" + } + ] + }, + "node_modules/ignore": { + "version": "5.2.4", + "resolved": "https://registry.npmjs.org/ignore/-/ignore-5.2.4.tgz", + "integrity": "sha512-MAb38BcSbH0eHNBxn7ql2NH/kX33OkB3lZ1BNdh7ENeRChHTYsTvWrMubiIAMNS2llXEEgZ1MUOBtXChP3kaFQ==", + "dev": true, + "peer": true, + "engines": { + "node": ">= 4" + } + }, + "node_modules/immutable": { + "version": "4.3.0", + "resolved": "https://registry.npmjs.org/immutable/-/immutable-4.3.0.tgz", + "integrity": "sha512-0AOCmOip+xgJwEVTQj1EfiDDOkPmuyllDuTuEX+DDXUgapLAsBIfkg3sxCYyCEA8mQqZrrxPUGjcOQ2JS3WLkg==", + "dev": true + }, + "node_modules/indent-string": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/indent-string/-/indent-string-4.0.0.tgz", + "integrity": "sha512-EdDDZu4A2OyIK7Lr/2zG+w5jmbuk1DVBnEwREQvBzspBJkCEbRa8GxU1lghYcaGJCnRWibjDXlq779X1/y5xwg==", + "dev": true, + "engines": { + "node": ">=8" + } + }, + "node_modules/inflight": { + "version": "1.0.6", + "resolved": "https://registry.npmjs.org/inflight/-/inflight-1.0.6.tgz", + "integrity": "sha512-k92I/b08q4wvFscXCLvqfsHCrjrF7yiXsQuIVvVE7N82W3+aqpzuUdBbfhWcy/FZR3/4IgflMgKLOsvPDrGCJA==", + "dev": true, + "dependencies": { + "once": "^1.3.0", + "wrappy": "1" + } + }, + "node_modules/inherits": { + "version": "2.0.4", + "resolved": "https://registry.npmjs.org/inherits/-/inherits-2.0.4.tgz", + "integrity": "sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ==", + "dev": true + }, + "node_modules/ini": { + "version": "1.3.8", + "resolved": "https://registry.npmjs.org/ini/-/ini-1.3.8.tgz", + "integrity": "sha512-JV/yugV2uzW5iMRSiZAyDtQd+nxtUnjeLt0acNdw98kKLrvuRVyB80tsREOE7yvGVgalhZ6RNXCmEHkUKBKxew==", + "dev": true, + "peer": true + }, + "node_modules/internal-slot": { + "version": "1.0.5", + "resolved": "https://registry.npmjs.org/internal-slot/-/internal-slot-1.0.5.tgz", + "integrity": "sha512-Y+R5hJrzs52QCG2laLn4udYVnxsfny9CpOhNhUvk/SSSVyF6T27FzRbF0sroPidSu3X8oEAkOn2K804mjpt6UQ==", + "dev": true, + "peer": true, + "dependencies": { + "get-intrinsic": "^1.2.0", + "has": "^1.0.3", + "side-channel": "^1.0.4" + }, + "engines": { + "node": ">= 0.4" + } + }, + "node_modules/interpret": { + "version": "1.4.0", + "resolved": "https://registry.npmjs.org/interpret/-/interpret-1.4.0.tgz", + "integrity": "sha512-agE4QfB2Lkp9uICn7BAqoscw4SZP9kTE2hxiFI3jBPmXJfdqiahTbUuKGsMoN2GtqL9AxhYioAcVvgsb1HvRbA==", + "dev": true, + "peer": true, + "engines": { + "node": ">= 0.10" + } + }, + "node_modules/io-ts": { + "version": "1.10.4", + "resolved": "https://registry.npmjs.org/io-ts/-/io-ts-1.10.4.tgz", + "integrity": "sha512-b23PteSnYXSONJ6JQXRAlvJhuw8KOtkqa87W4wDtvMrud/DTJd5X+NpOOI+O/zZwVq6v0VLAaJ+1EDViKEuN9g==", + "dev": true, + "dependencies": { + "fp-ts": "^1.0.0" + } + }, + "node_modules/is-array-buffer": { + "version": "3.0.2", + "resolved": "https://registry.npmjs.org/is-array-buffer/-/is-array-buffer-3.0.2.tgz", + "integrity": "sha512-y+FyyR/w8vfIRq4eQcM1EYgSTnmHXPqaF+IgzgraytCFq5Xh8lllDVmAZolPJiZttZLeFSINPYMaEJ7/vWUa1w==", + "dev": true, + "peer": true, + "dependencies": { + "call-bind": "^1.0.2", + "get-intrinsic": "^1.2.0", + "is-typed-array": "^1.1.10" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/is-bigint": { + "version": "1.0.4", + "resolved": "https://registry.npmjs.org/is-bigint/-/is-bigint-1.0.4.tgz", + "integrity": "sha512-zB9CruMamjym81i2JZ3UMn54PKGsQzsJeo6xvN3HJJ4CAsQNB6iRutp2To77OfCNuoxspsIhzaPoO1zyCEhFOg==", + "dev": true, + "peer": true, + "dependencies": { + "has-bigints": "^1.0.1" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/is-binary-path": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/is-binary-path/-/is-binary-path-2.1.0.tgz", + "integrity": "sha512-ZMERYes6pDydyuGidse7OsHxtbI7WVeUEozgR/g7rd0xUimYNlvZRE/K2MgZTjWy725IfelLeVcEM97mmtRGXw==", + "dev": true, + "dependencies": { + "binary-extensions": "^2.0.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/is-boolean-object": { + "version": "1.1.2", + "resolved": "https://registry.npmjs.org/is-boolean-object/-/is-boolean-object-1.1.2.tgz", + "integrity": "sha512-gDYaKHJmnj4aWxyj6YHyXVpdQawtVLHU5cb+eztPGczf6cjuTdwve5ZIEfgXqH4e57An1D1AKf8CZ3kYrQRqYA==", + "dev": true, + "peer": true, + "dependencies": { + "call-bind": "^1.0.2", + "has-tostringtag": "^1.0.0" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/is-buffer": { + "version": "2.0.5", + "resolved": "https://registry.npmjs.org/is-buffer/-/is-buffer-2.0.5.tgz", + "integrity": "sha512-i2R6zNFDwgEHJyQUtJEk0XFi1i0dPFn/oqjK3/vPCcDeJvW5NQ83V8QbicfF1SupOaB0h8ntgBC2YiE7dfyctQ==", + "dev": true, + "funding": [ + { + "type": "github", + "url": "https://github.com/sponsors/feross" + }, + { + "type": "patreon", + "url": "https://www.patreon.com/feross" + }, + { + "type": "consulting", + "url": "https://feross.org/support" + } + ], + "engines": { + "node": ">=4" + } + }, + "node_modules/is-callable": { + "version": "1.2.7", + "resolved": "https://registry.npmjs.org/is-callable/-/is-callable-1.2.7.tgz", + "integrity": "sha512-1BC0BVFhS/p0qtw6enp8e+8OD0UrK0oFLztSjNzhcKA3WDuJxxAPXzPuPtKkjEY9UUoEWlX/8fgKeu2S8i9JTA==", + "dev": true, + "peer": true, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/is-date-object": { + "version": "1.0.5", + "resolved": "https://registry.npmjs.org/is-date-object/-/is-date-object-1.0.5.tgz", + "integrity": "sha512-9YQaSxsAiSwcvS33MBk3wTCVnWK+HhF8VZR2jRxehM16QcVOdHqPn4VPHmRK4lSr38n9JriurInLcP90xsYNfQ==", + "dev": true, + "peer": true, + "dependencies": { + "has-tostringtag": "^1.0.0" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/is-extglob": { + "version": "2.1.1", + "resolved": "https://registry.npmjs.org/is-extglob/-/is-extglob-2.1.1.tgz", + "integrity": "sha512-SbKbANkN603Vi4jEZv49LeVJMn4yGwsbzZworEoyEiutsN3nJYdbO36zfhGJ6QEDpOZIFkDtnq5JRxmvl3jsoQ==", + "dev": true, + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/is-fullwidth-code-point": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/is-fullwidth-code-point/-/is-fullwidth-code-point-3.0.0.tgz", + "integrity": "sha512-zymm5+u+sCsSWyD9qNaejV3DFvhCKclKdizYaJUuHA83RLjb7nSuGnddCHGv0hk+KY7BMAlsWeK4Ueg6EV6XQg==", + "dev": true, + "engines": { + "node": ">=8" + } + }, + "node_modules/is-glob": { + "version": "4.0.3", + "resolved": "https://registry.npmjs.org/is-glob/-/is-glob-4.0.3.tgz", + "integrity": "sha512-xelSayHH36ZgE7ZWhli7pW34hNbNl8Ojv5KVmkJD4hBdD3th8Tfk9vYasLM+mXWOZhFkgZfxhLSnrwRr4elSSg==", + "dev": true, + "dependencies": { + "is-extglob": "^2.1.1" + }, + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/is-hex-prefixed": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/is-hex-prefixed/-/is-hex-prefixed-1.0.0.tgz", + "integrity": "sha512-WvtOiug1VFrE9v1Cydwm+FnXd3+w9GaeVUss5W4v/SLy3UW00vP+6iNF2SdnfiBoLy4bTqVdkftNGTUeOFVsbA==", + "dev": true, + "engines": { + "node": ">=6.5.0", + "npm": ">=3" + } + }, + "node_modules/is-negative-zero": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/is-negative-zero/-/is-negative-zero-2.0.2.tgz", + "integrity": "sha512-dqJvarLawXsFbNDeJW7zAz8ItJ9cd28YufuuFzh0G8pNHjJMnY08Dv7sYX2uF5UpQOwieAeOExEYAWWfu7ZZUA==", + "dev": true, + "peer": true, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/is-number": { + "version": "7.0.0", + "resolved": "https://registry.npmjs.org/is-number/-/is-number-7.0.0.tgz", + "integrity": "sha512-41Cifkg6e8TylSpdtTpeLVMqvSBEVzTttHvERD741+pnZ8ANv0004MRL43QKPDlK9cGvNp6NZWZUBlbGXYxxng==", + "dev": true, + "engines": { + "node": ">=0.12.0" + } + }, + "node_modules/is-number-object": { + "version": "1.0.7", + "resolved": "https://registry.npmjs.org/is-number-object/-/is-number-object-1.0.7.tgz", + "integrity": "sha512-k1U0IRzLMo7ZlYIfzRu23Oh6MiIFasgpb9X76eqfFZAqwH44UI4KTBvBYIZ1dSL9ZzChTB9ShHfLkR4pdW5krQ==", + "dev": true, + "peer": true, + "dependencies": { + "has-tostringtag": "^1.0.0" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/is-plain-obj": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/is-plain-obj/-/is-plain-obj-2.1.0.tgz", + "integrity": "sha512-YWnfyRwxL/+SsrWYfOpUtz5b3YD+nyfkHvjbcanzk8zgyO4ASD67uVMRt8k5bM4lLMDnXfriRhOpemw+NfT1eA==", + "dev": true, + "engines": { + "node": ">=8" + } + }, + "node_modules/is-regex": { + "version": "1.1.4", + "resolved": "https://registry.npmjs.org/is-regex/-/is-regex-1.1.4.tgz", + "integrity": "sha512-kvRdxDsxZjhzUX07ZnLydzS1TU/TJlTUHHY4YLL87e37oUA49DfkLqgy+VjFocowy29cKvcSiu+kIv728jTTVg==", + "dev": true, + "peer": true, + "dependencies": { + "call-bind": "^1.0.2", + "has-tostringtag": "^1.0.0" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/is-shared-array-buffer": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/is-shared-array-buffer/-/is-shared-array-buffer-1.0.2.tgz", + "integrity": "sha512-sqN2UDu1/0y6uvXyStCOzyhAjCSlHceFoMKJW8W9EU9cvic/QdsZ0kEU93HEy3IUEFZIiH/3w+AH/UQbPHNdhA==", + "dev": true, + "peer": true, + "dependencies": { + "call-bind": "^1.0.2" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/is-string": { + "version": "1.0.7", + "resolved": "https://registry.npmjs.org/is-string/-/is-string-1.0.7.tgz", + "integrity": "sha512-tE2UXzivje6ofPW7l23cjDOMa09gb7xlAqG6jG5ej6uPV32TlWP3NKPigtaGeHNu9fohccRYvIiZMfOOnOYUtg==", + "dev": true, + "peer": true, + "dependencies": { + "has-tostringtag": "^1.0.0" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/is-symbol": { + "version": "1.0.4", + "resolved": "https://registry.npmjs.org/is-symbol/-/is-symbol-1.0.4.tgz", + "integrity": "sha512-C/CPBqKWnvdcxqIARxyOh4v1UUEOCHpgDa0WYgpKDFMszcrPcffg5uhwSgPCLD2WWxmq6isisz87tzT01tuGhg==", + "dev": true, + "peer": true, + "dependencies": { + "has-symbols": "^1.0.2" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/is-typed-array": { + "version": "1.1.10", + "resolved": "https://registry.npmjs.org/is-typed-array/-/is-typed-array-1.1.10.tgz", + "integrity": "sha512-PJqgEHiWZvMpaFZ3uTc8kHPM4+4ADTlDniuQL7cU/UDA0Ql7F70yGfHph3cLNe+c9toaigv+DFzTJKhc2CtO6A==", + "dev": true, + "peer": true, + "dependencies": { + "available-typed-arrays": "^1.0.5", + "call-bind": "^1.0.2", + "for-each": "^0.3.3", + "gopd": "^1.0.1", + "has-tostringtag": "^1.0.0" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/is-typedarray": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/is-typedarray/-/is-typedarray-1.0.0.tgz", + "integrity": "sha512-cyA56iCMHAh5CdzjJIa4aohJyeO1YbwLi3Jc35MmRU6poroFjIGZzUzupGiRPOjgHg9TLu43xbpwXk523fMxKA==", + "dev": true, + "peer": true + }, + "node_modules/is-unicode-supported": { + "version": "0.1.0", + "resolved": "https://registry.npmjs.org/is-unicode-supported/-/is-unicode-supported-0.1.0.tgz", + "integrity": "sha512-knxG2q4UC3u8stRGyAVJCOdxFmv5DZiRcdlIaAQXAbSfJya+OhopNotLQrstBhququ4ZpuKbDc/8S6mgXgPFPw==", + "dev": true, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/is-weakref": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/is-weakref/-/is-weakref-1.0.2.tgz", + "integrity": "sha512-qctsuLZmIQ0+vSSMfoVvyFe2+GSEvnmZ2ezTup1SBse9+twCCeial6EEi3Nc2KFcf6+qz2FBPnjXsk8xhKSaPQ==", + "dev": true, + "peer": true, + "dependencies": { + "call-bind": "^1.0.2" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/isarray": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/isarray/-/isarray-1.0.0.tgz", + "integrity": "sha512-VLghIWNM6ELQzo7zwmcg0NmTVyWKYjvIeM83yjp0wRDTmUnrM678fQbcKBo6n2CJEF0szoG//ytg+TKla89ALQ==", + "dev": true, + "peer": true + }, + "node_modules/isexe": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/isexe/-/isexe-2.0.0.tgz", + "integrity": "sha512-RHxMLp9lnKHGHRng9QFhRCMbYAcVpn69smSGcq3f36xjgVVWThj4qqLbTLlq7Ssj8B+fIQ1EuCEGI2lKsyQeIw==", + "dev": true, + "peer": true + }, + "node_modules/isstream": { + "version": "0.1.2", + "resolved": "https://registry.npmjs.org/isstream/-/isstream-0.1.2.tgz", + "integrity": "sha512-Yljz7ffyPbrLpLngrMtZ7NduUgVvi6wG9RJ9IUcyCd59YQ911PBJphODUcbOVbqYfxe1wuYf/LJ8PauMRwsM/g==", + "dev": true, + "peer": true + }, + "node_modules/js-sdsl": { + "version": "4.4.0", + "resolved": "https://registry.npmjs.org/js-sdsl/-/js-sdsl-4.4.0.tgz", + "integrity": "sha512-FfVSdx6pJ41Oa+CF7RDaFmTnCaFhua+SNYQX74riGOpl96x+2jQCqEfQ2bnXu/5DPCqlRuiqyvTJM0Qjz26IVg==", + "dev": true, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/js-sdsl" + } + }, + "node_modules/js-sha3": { + "version": "0.8.0", + "resolved": "https://registry.npmjs.org/js-sha3/-/js-sha3-0.8.0.tgz", + "integrity": "sha512-gF1cRrHhIzNfToc802P800N8PpXS+evLLXfsVpowqmAFR9uwbi89WvXg2QspOmXL8QL86J4T1EpFu+yUkwJY3Q==", + "dev": true + }, + "node_modules/js-yaml": { + "version": "4.1.0", + "resolved": "https://registry.npmjs.org/js-yaml/-/js-yaml-4.1.0.tgz", + "integrity": "sha512-wpxZs9NoxZaJESJGIZTyDEaYpl0FKSA+FB9aJiyemKhMwkxQg63h4T1KJgUGHpTqPDNRcmmYLugrRjJlBtWvRA==", + "dev": true, + "dependencies": { + "argparse": "^2.0.1" + }, + "bin": { + "js-yaml": "bin/js-yaml.js" + } + }, + "node_modules/jsbn": { + "version": "0.1.1", + "resolved": "https://registry.npmjs.org/jsbn/-/jsbn-0.1.1.tgz", + "integrity": "sha512-UVU9dibq2JcFWxQPA6KCqj5O42VOmAY3zQUfEKxU0KpTGXwNoCjkX1e13eHNvw/xPynt6pU0rZ1htjWTNTSXsg==", + "dev": true, + "peer": true + }, + "node_modules/json-schema": { + "version": "0.4.0", + "resolved": "https://registry.npmjs.org/json-schema/-/json-schema-0.4.0.tgz", + "integrity": "sha512-es94M3nTIfsEPisRafak+HDLfHXnKBhV3vU5eqPcS3flIWqcxJWgXHXiey3YrpaNsanY5ei1VoYEbOzijuq9BA==", + "dev": true, + "peer": true + }, + "node_modules/json-schema-traverse": { + "version": "0.4.1", + "resolved": "https://registry.npmjs.org/json-schema-traverse/-/json-schema-traverse-0.4.1.tgz", + "integrity": "sha512-xbbCH5dCYU5T8LcEhhuh7HJ88HXuW3qsI3Y0zOZFKfZEHcpWiHU/Jxzk629Brsab/mMiHQti9wMP+845RPe3Vg==", + "dev": true, + "peer": true + }, + "node_modules/json-stringify-safe": { + "version": "5.0.1", + "resolved": "https://registry.npmjs.org/json-stringify-safe/-/json-stringify-safe-5.0.1.tgz", + "integrity": "sha512-ZClg6AaYvamvYEE82d3Iyd3vSSIjQ+odgjaTzRuO3s7toCdFKczob2i0zCh7JE8kWn17yvAWhUVxvqGwUalsRA==", + "dev": true, + "peer": true + }, + "node_modules/jsonfile": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/jsonfile/-/jsonfile-4.0.0.tgz", + "integrity": "sha512-m6F1R3z8jjlf2imQHS2Qez5sjKWQzbuuhuJ/FKYFRZvPE3PuHcSMVZzfsLhGVOkfd20obL5SWEBew5ShlquNxg==", + "dev": true, + "optionalDependencies": { + "graceful-fs": "^4.1.6" + } + }, + "node_modules/jsonschema": { + "version": "1.4.1", + "resolved": "https://registry.npmjs.org/jsonschema/-/jsonschema-1.4.1.tgz", + "integrity": "sha512-S6cATIPVv1z0IlxdN+zUk5EPjkGCdnhN4wVSBlvoUO1tOLJootbo9CquNJmbIh4yikWHiUedhRYrNPn1arpEmQ==", + "dev": true, + "peer": true, + "engines": { + "node": "*" + } + }, + "node_modules/jsprim": { + "version": "1.4.2", + "resolved": "https://registry.npmjs.org/jsprim/-/jsprim-1.4.2.tgz", + "integrity": "sha512-P2bSOMAc/ciLz6DzgjVlGJP9+BrJWu5UDGK70C2iweC5QBIeFf0ZXRvGjEj2uYgrY2MkAAhsSWHDWlFtEroZWw==", + "dev": true, + "peer": true, + "dependencies": { + "assert-plus": "1.0.0", + "extsprintf": "1.3.0", + "json-schema": "0.4.0", + "verror": "1.10.0" + }, + "engines": { + "node": ">=0.6.0" + } + }, + "node_modules/keccak": { + "version": "3.0.3", + "resolved": "https://registry.npmjs.org/keccak/-/keccak-3.0.3.tgz", + "integrity": "sha512-JZrLIAJWuZxKbCilMpNz5Vj7Vtb4scDG3dMXLOsbzBmQGyjwE61BbW7bJkfKKCShXiQZt3T6sBgALRtmd+nZaQ==", + "dev": true, + "hasInstallScript": true, + "dependencies": { + "node-addon-api": "^2.0.0", + "node-gyp-build": "^4.2.0", + "readable-stream": "^3.6.0" + }, + "engines": { + "node": ">=10.0.0" + } + }, + "node_modules/kind-of": { + "version": "6.0.3", + "resolved": "https://registry.npmjs.org/kind-of/-/kind-of-6.0.3.tgz", + "integrity": "sha512-dcS1ul+9tmeD95T+x28/ehLgd9mENa3LsvDTtzm3vyBEO7RPptvAD+t44WVXaUjTBRcrpFeFlC8WCruUR456hw==", + "dev": true, + "peer": true, + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/klaw": { + "version": "1.3.1", + "resolved": "https://registry.npmjs.org/klaw/-/klaw-1.3.1.tgz", + "integrity": "sha512-TED5xi9gGQjGpNnvRWknrwAB1eL5GciPfVFOt3Vk1OJCVDQbzuSfrF3hkUQKlsgKrG1F+0t5W0m+Fje1jIt8rw==", + "dev": true, + "optionalDependencies": { + "graceful-fs": "^4.1.9" + } + }, + "node_modules/level": { + "version": "8.0.0", + "resolved": "https://registry.npmjs.org/level/-/level-8.0.0.tgz", + "integrity": "sha512-ypf0jjAk2BWI33yzEaaotpq7fkOPALKAgDBxggO6Q9HGX2MRXn0wbP1Jn/tJv1gtL867+YOjOB49WaUF3UoJNQ==", + "dev": true, + "dependencies": { + "browser-level": "^1.0.1", + "classic-level": "^1.2.0" + }, + "engines": { + "node": ">=12" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/level" + } + }, + "node_modules/level-supports": { + "version": "4.0.1", + "resolved": "https://registry.npmjs.org/level-supports/-/level-supports-4.0.1.tgz", + "integrity": "sha512-PbXpve8rKeNcZ9C1mUicC9auIYFyGpkV9/i6g76tLgANwWhtG2v7I4xNBUlkn3lE2/dZF3Pi0ygYGtLc4RXXdA==", + "dev": true, + "engines": { + "node": ">=12" + } + }, + "node_modules/level-transcoder": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/level-transcoder/-/level-transcoder-1.0.1.tgz", + "integrity": "sha512-t7bFwFtsQeD8cl8NIoQ2iwxA0CL/9IFw7/9gAjOonH0PWTTiRfY7Hq+Ejbsxh86tXobDQ6IOiddjNYIfOBs06w==", + "dev": true, + "dependencies": { + "buffer": "^6.0.3", + "module-error": "^1.0.1" + }, + "engines": { + "node": ">=12" + } + }, + "node_modules/levn": { + "version": "0.3.0", + "resolved": "https://registry.npmjs.org/levn/-/levn-0.3.0.tgz", + "integrity": "sha512-0OO4y2iOHix2W6ujICbKIaEQXvFQHue65vUG3pb5EUomzPI90z9hsA1VsO/dbIIpC53J8gxM9Q4Oho0jrCM/yA==", + "dev": true, + "peer": true, + "dependencies": { + "prelude-ls": "~1.1.2", + "type-check": "~0.3.2" + }, + "engines": { + "node": ">= 0.8.0" + } + }, + "node_modules/locate-path": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/locate-path/-/locate-path-2.0.0.tgz", + "integrity": "sha512-NCI2kiDkyR7VeEKm27Kda/iQHyKJe1Bu0FlTbYp3CqJu+9IFe9bLyAjMxf5ZDDbEg+iMPzB5zYyUTSm8wVTKmA==", + "dev": true, + "dependencies": { + "p-locate": "^2.0.0", + "path-exists": "^3.0.0" + }, + "engines": { + "node": ">=4" + } + }, + "node_modules/lodash": { + "version": "4.17.21", + "resolved": "https://registry.npmjs.org/lodash/-/lodash-4.17.21.tgz", + "integrity": "sha512-v2kDEe57lecTulaDIuNTPy3Ry4gLGJ6Z1O3vE1krgXZNrsQ+LFTGHVxVjcXPs17LhbZVGedAJv8XZ1tvj5FvSg==", + "dev": true + }, + "node_modules/lodash.camelcase": { + "version": "4.3.0", + "resolved": "https://registry.npmjs.org/lodash.camelcase/-/lodash.camelcase-4.3.0.tgz", + "integrity": "sha512-TwuEnCnxbc3rAvhf/LbG7tJUDzhqXyFnv3dtzLOPgCG/hODL7WFnsbwktkD7yUV0RrreP/l1PALq/YSg6VvjlA==", + "dev": true, + "peer": true + }, + "node_modules/lodash.truncate": { + "version": "4.4.2", + "resolved": "https://registry.npmjs.org/lodash.truncate/-/lodash.truncate-4.4.2.tgz", + "integrity": "sha512-jttmRe7bRse52OsWIMDLaXxWqRAmtIUccAQ3garviCqJjafXOfNMO0yMfNpdD6zbGaTU0P5Nz7e7gAT6cKmJRw==", + "dev": true, + "peer": true + }, + "node_modules/log-symbols": { + "version": "4.1.0", + "resolved": "https://registry.npmjs.org/log-symbols/-/log-symbols-4.1.0.tgz", + "integrity": "sha512-8XPvpAA8uyhfteu8pIvQxpJZ7SYYdpUivZpGy6sFsBuKRY/7rQGavedeB8aK+Zkyq6upMFVL/9AW6vOYzfRyLg==", + "dev": true, + "dependencies": { + "chalk": "^4.1.0", + "is-unicode-supported": "^0.1.0" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/log-symbols/node_modules/ansi-styles": { + "version": "4.3.0", + "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-4.3.0.tgz", + "integrity": "sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==", + "dev": true, + "dependencies": { + "color-convert": "^2.0.1" + }, + "engines": { + "node": ">=8" + }, + "funding": { + "url": "https://github.com/chalk/ansi-styles?sponsor=1" + } + }, + "node_modules/log-symbols/node_modules/chalk": { + "version": "4.1.2", + "resolved": "https://registry.npmjs.org/chalk/-/chalk-4.1.2.tgz", + "integrity": "sha512-oKnbhFyRIXpUuez8iBMmyEa4nbj4IOQyuhc/wy9kY7/WVPcwIO9VA668Pu8RkO7+0G76SLROeyw9CpQ061i4mA==", + "dev": true, + "dependencies": { + "ansi-styles": "^4.1.0", + "supports-color": "^7.1.0" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/chalk/chalk?sponsor=1" + } + }, + "node_modules/log-symbols/node_modules/color-convert": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-2.0.1.tgz", + "integrity": "sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ==", + "dev": true, + "dependencies": { + "color-name": "~1.1.4" + }, + "engines": { + "node": ">=7.0.0" + } + }, + "node_modules/log-symbols/node_modules/color-name": { + "version": "1.1.4", + "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.4.tgz", + "integrity": "sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA==", + "dev": true + }, + "node_modules/log-symbols/node_modules/has-flag": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-4.0.0.tgz", + "integrity": "sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ==", + "dev": true, + "engines": { + "node": ">=8" + } + }, + "node_modules/log-symbols/node_modules/supports-color": { + "version": "7.2.0", + "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-7.2.0.tgz", + "integrity": "sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw==", + "dev": true, + "dependencies": { + "has-flag": "^4.0.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/loupe": { + "version": "2.3.6", + "resolved": "https://registry.npmjs.org/loupe/-/loupe-2.3.6.tgz", + "integrity": "sha512-RaPMZKiMy8/JruncMU5Bt6na1eftNoo++R4Y+N2FrxkDVTrGvcyzFTsaGif4QTeKESheMGegbhw6iUAq+5A8zA==", + "dev": true, + "peer": true, + "dependencies": { + "get-func-name": "^2.0.0" + } + }, + "node_modules/lru_map": { + "version": "0.3.3", + "resolved": "https://registry.npmjs.org/lru_map/-/lru_map-0.3.3.tgz", + "integrity": "sha512-Pn9cox5CsMYngeDbmChANltQl+5pi6XmTrraMSzhPmMBbmgcxmqWry0U3PGapCU1yB4/LqCcom7qhHZiF/jGfQ==", + "dev": true + }, + "node_modules/lru-cache": { + "version": "5.1.1", + "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-5.1.1.tgz", + "integrity": "sha512-KpNARQA3Iwv+jTA0utUVVbrh+Jlrr1Fv0e56GGzAFOXN7dk/FviaDW8LHmK52DlcH4WP2n6gI8vN1aesBFgo9w==", + "dev": true, + "dependencies": { + "yallist": "^3.0.2" + } + }, + "node_modules/make-error": { + "version": "1.3.6", + "resolved": "https://registry.npmjs.org/make-error/-/make-error-1.3.6.tgz", + "integrity": "sha512-s8UhlNe7vPKomQhC1qFelMokr/Sc3AgNbso3n74mVPA5LTZwkB9NlXf4XPamLxJE8h0gh73rM94xvwRT2CVInw==", + "dev": true, + "peer": true + }, + "node_modules/markdown-table": { + "version": "1.1.3", + "resolved": "https://registry.npmjs.org/markdown-table/-/markdown-table-1.1.3.tgz", + "integrity": "sha512-1RUZVgQlpJSPWYbFSpmudq5nHY1doEIv89gBtF0s4gW1GF2XorxcA/70M5vq7rLv0a6mhOUccRsqkwhwLCIQ2Q==", + "dev": true, + "peer": true + }, + "node_modules/mcl-wasm": { + "version": "0.7.9", + "resolved": "https://registry.npmjs.org/mcl-wasm/-/mcl-wasm-0.7.9.tgz", + "integrity": "sha512-iJIUcQWA88IJB/5L15GnJVnSQJmf/YaxxV6zRavv83HILHaJQb6y0iFyDMdDO0gN8X37tdxmAOrH/P8B6RB8sQ==", + "dev": true, + "engines": { + "node": ">=8.9.0" + } + }, + "node_modules/md5.js": { + "version": "1.3.5", + "resolved": "https://registry.npmjs.org/md5.js/-/md5.js-1.3.5.tgz", + "integrity": "sha512-xitP+WxNPcTTOgnTJcrhM0xvdPepipPSf3I8EIpGKeFLjt3PlJLIDG3u8EX53ZIubkb+5U2+3rELYpEhHhzdkg==", + "dev": true, + "dependencies": { + "hash-base": "^3.0.0", + "inherits": "^2.0.1", + "safe-buffer": "^5.1.2" + } + }, + "node_modules/memory-level": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/memory-level/-/memory-level-1.0.0.tgz", + "integrity": "sha512-UXzwewuWeHBz5krr7EvehKcmLFNoXxGcvuYhC41tRnkrTbJohtS7kVn9akmgirtRygg+f7Yjsfi8Uu5SGSQ4Og==", + "dev": true, + "dependencies": { + "abstract-level": "^1.0.0", + "functional-red-black-tree": "^1.0.1", + "module-error": "^1.0.1" + }, + "engines": { + "node": ">=12" + } + }, + "node_modules/memorystream": { + "version": "0.3.1", + "resolved": "https://registry.npmjs.org/memorystream/-/memorystream-0.3.1.tgz", + "integrity": "sha512-S3UwM3yj5mtUSEfP41UZmt/0SCoVYUcU1rkXv+BQ5Ig8ndL4sPoJNBUJERafdPb5jjHJGuMgytgKvKIf58XNBw==", + "dev": true, + "engines": { + "node": ">= 0.10.0" + } + }, + "node_modules/merge2": { + "version": "1.4.1", + "resolved": "https://registry.npmjs.org/merge2/-/merge2-1.4.1.tgz", + "integrity": "sha512-8q7VEgMJW4J8tcfVPy8g09NcQwZdbwFEqhe/WZkoIzjn/3TGDwtOCYtXGxA3O8tPzpczCCDgv+P2P5y00ZJOOg==", + "dev": true, + "peer": true, + "engines": { + "node": ">= 8" + } + }, + "node_modules/micromatch": { + "version": "4.0.5", + "resolved": "https://registry.npmjs.org/micromatch/-/micromatch-4.0.5.tgz", + "integrity": "sha512-DMy+ERcEW2q8Z2Po+WNXuw3c5YaUSFjAO5GsJqfEl7UjvtIuFKO6ZrKvcItdy98dwFI2N1tg3zNIdKaQT+aNdA==", + "dev": true, + "peer": true, + "dependencies": { + "braces": "^3.0.2", + "picomatch": "^2.3.1" + }, + "engines": { + "node": ">=8.6" + } + }, + "node_modules/mime-db": { + "version": "1.52.0", + "resolved": "https://registry.npmjs.org/mime-db/-/mime-db-1.52.0.tgz", + "integrity": "sha512-sPU4uV7dYlvtWJxwwxHD0PuihVNiE7TyAbQ5SWxDCB9mUYvOgroQOwYQQOKPJ8CIbE+1ETVlOoK1UC2nU3gYvg==", + "dev": true, + "peer": true, + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/mime-types": { + "version": "2.1.35", + "resolved": "https://registry.npmjs.org/mime-types/-/mime-types-2.1.35.tgz", + "integrity": "sha512-ZDY+bPm5zTTF+YpCrAU9nK0UgICYPT0QtT1NZWFv4s++TNkcgVaT0g6+4R2uI4MjQjzysHB1zxuWL50hzaeXiw==", + "dev": true, + "peer": true, + "dependencies": { + "mime-db": "1.52.0" + }, + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/minimalistic-assert": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/minimalistic-assert/-/minimalistic-assert-1.0.1.tgz", + "integrity": "sha512-UtJcAD4yEaGtjPezWuO9wC4nwUnVH/8/Im3yEHQP4b67cXlD/Qr9hdITCU1xDbSEXg2XKNaP8jsReV7vQd00/A==", + "dev": true + }, + "node_modules/minimalistic-crypto-utils": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/minimalistic-crypto-utils/-/minimalistic-crypto-utils-1.0.1.tgz", + "integrity": "sha512-JIYlbt6g8i5jKfJ3xz7rF0LXmv2TkDxBLUkiBeZ7bAx4GnnNMr8xFpGnOxn6GhTEHx3SjRrZEoU+j04prX1ktg==", + "dev": true + }, + "node_modules/minimatch": { + "version": "3.1.2", + "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.1.2.tgz", + "integrity": "sha512-J7p63hRiAjw1NDEww1W7i37+ByIrOWO5XQQAzZ3VOcL0PNybwpfmV/N05zFAzwQ9USyEcX6t3UO+K5aqBQOIHw==", + "dev": true, + "dependencies": { + "brace-expansion": "^1.1.7" + }, + "engines": { + "node": "*" + } + }, + "node_modules/minimist": { + "version": "1.2.8", + "resolved": "https://registry.npmjs.org/minimist/-/minimist-1.2.8.tgz", + "integrity": "sha512-2yyAR8qBkN3YuheJanUpWC5U3bb5osDywNB8RzDVlDwDHbocAJveqqj1u8+SVD7jkWT4yvsHCpWqqWqAxb0zCA==", + "dev": true, + "peer": true, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/mkdirp": { + "version": "0.5.6", + "resolved": "https://registry.npmjs.org/mkdirp/-/mkdirp-0.5.6.tgz", + "integrity": "sha512-FP+p8RB8OWpF3YZBCrP5gtADmtXApB5AMLn+vdyA+PyxCjrCs00mjyUozssO33cwDeT3wNGdLxJ5M//YqtHAJw==", + "dev": true, + "peer": true, + "dependencies": { + "minimist": "^1.2.6" + }, + "bin": { + "mkdirp": "bin/cmd.js" + } + }, + "node_modules/mnemonist": { + "version": "0.38.5", + "resolved": "https://registry.npmjs.org/mnemonist/-/mnemonist-0.38.5.tgz", + "integrity": "sha512-bZTFT5rrPKtPJxj8KSV0WkPyNxl72vQepqqVUAW2ARUpUSF2qXMB6jZj7hW5/k7C1rtpzqbD/IIbJwLXUjCHeg==", + "dev": true, + "dependencies": { + "obliterator": "^2.0.0" + } + }, + "node_modules/mocha": { + "version": "10.2.0", + "resolved": "https://registry.npmjs.org/mocha/-/mocha-10.2.0.tgz", + "integrity": "sha512-IDY7fl/BecMwFHzoqF2sg/SHHANeBoMMXFlS9r0OXKDssYE1M5O43wUY/9BVPeIvfH2zmEbBfseqN9gBQZzXkg==", + "dev": true, + "dependencies": { + "ansi-colors": "4.1.1", + "browser-stdout": "1.3.1", + "chokidar": "3.5.3", + "debug": "4.3.4", + "diff": "5.0.0", + "escape-string-regexp": "4.0.0", + "find-up": "5.0.0", + "glob": "7.2.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", + "workerpool": "6.2.1", + "yargs": "16.2.0", + "yargs-parser": "20.2.4", + "yargs-unparser": "2.0.0" + }, + "bin": { + "_mocha": "bin/_mocha", + "mocha": "bin/mocha.js" + }, + "engines": { + "node": ">= 14.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/mochajs" + } + }, + "node_modules/mocha/node_modules/ansi-colors": { + "version": "4.1.1", + "resolved": "https://registry.npmjs.org/ansi-colors/-/ansi-colors-4.1.1.tgz", + "integrity": "sha512-JoX0apGbHaUJBNl6yF+p6JAFYZ666/hhCGKN5t9QFjbJQKUU/g8MNbFDbvfrgKXvI1QpZplPOnwIo99lX/AAmA==", + "dev": true, + "engines": { + "node": ">=6" + } + }, + "node_modules/mocha/node_modules/brace-expansion": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-2.0.1.tgz", + "integrity": "sha512-XnAIvQ8eM+kC6aULx6wuQiwVsnzsi9d3WxzV3FpWTGA19F621kwdbsAcFKXgKUHZWsy+mY6iL1sHTxWEFCytDA==", + "dev": true, + "dependencies": { + "balanced-match": "^1.0.0" + } + }, + "node_modules/mocha/node_modules/escape-string-regexp": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/escape-string-regexp/-/escape-string-regexp-4.0.0.tgz", + "integrity": "sha512-TtpcNJ3XAzx3Gq8sWRzJaVajRs0uVxA2YAkdb1jm2YkPz4G6egUFAyA3n5vtEIZefPk5Wa4UXbKuS5fKkJWdgA==", + "dev": true, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/mocha/node_modules/find-up": { + "version": "5.0.0", + "resolved": "https://registry.npmjs.org/find-up/-/find-up-5.0.0.tgz", + "integrity": "sha512-78/PXT1wlLLDgTzDs7sjq9hzz0vXD+zn+7wypEe4fXQxCmdmqfGsEPQxmiCSQI3ajFV91bVSsvNtrJRiW6nGng==", + "dev": true, + "dependencies": { + "locate-path": "^6.0.0", + "path-exists": "^4.0.0" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/mocha/node_modules/has-flag": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-4.0.0.tgz", + "integrity": "sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ==", + "dev": true, + "engines": { + "node": ">=8" + } + }, + "node_modules/mocha/node_modules/locate-path": { + "version": "6.0.0", + "resolved": "https://registry.npmjs.org/locate-path/-/locate-path-6.0.0.tgz", + "integrity": "sha512-iPZK6eYjbxRu3uB4/WZ3EsEIMJFMqAoopl3R+zuq0UjcAm/MO6KCweDgPfP3elTztoKP3KtnVHxTn2NHBSDVUw==", + "dev": true, + "dependencies": { + "p-locate": "^5.0.0" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/mocha/node_modules/minimatch": { + "version": "5.0.1", + "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-5.0.1.tgz", + "integrity": "sha512-nLDxIFRyhDblz3qMuq+SoRZED4+miJ/G+tdDrjkkkRnjAsBexeGpgjLEQ0blJy7rHhR2b93rhQY4SvyWu9v03g==", + "dev": true, + "dependencies": { + "brace-expansion": "^2.0.1" + }, + "engines": { + "node": ">=10" + } + }, + "node_modules/mocha/node_modules/ms": { + "version": "2.1.3", + "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz", + "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==", + "dev": true + }, + "node_modules/mocha/node_modules/p-limit": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/p-limit/-/p-limit-3.1.0.tgz", + "integrity": "sha512-TYOanM3wGwNGsZN2cVTYPArw454xnXj5qmWF1bEoAc4+cU/ol7GVh7odevjp1FNHduHc3KZMcFduxU5Xc6uJRQ==", + "dev": true, + "dependencies": { + "yocto-queue": "^0.1.0" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/mocha/node_modules/p-locate": { + "version": "5.0.0", + "resolved": "https://registry.npmjs.org/p-locate/-/p-locate-5.0.0.tgz", + "integrity": "sha512-LaNjtRWUBY++zB5nE/NwcaoMylSPk+S+ZHNB1TzdbMJMny6dynpAGt7X/tl/QYq3TIeE6nxHppbo2LGymrG5Pw==", + "dev": true, + "dependencies": { + "p-limit": "^3.0.2" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/mocha/node_modules/path-exists": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/path-exists/-/path-exists-4.0.0.tgz", + "integrity": "sha512-ak9Qy5Q7jYb2Wwcey5Fpvg2KoAc/ZIhLSLOSBmRmygPsGwkVVt0fZa0qrtMz+m6tJTAHfZQ8FnmB4MG4LWy7/w==", + "dev": true, + "engines": { + "node": ">=8" + } + }, + "node_modules/mocha/node_modules/supports-color": { + "version": "8.1.1", + "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-8.1.1.tgz", + "integrity": "sha512-MpUEN2OodtUzxvKQl72cUF7RQ5EiHsGvSsVG0ia9c5RbWGL2CI4C7EpPS8UTBIplnlzZiNuV56w+FuNxy3ty2Q==", + "dev": true, + "dependencies": { + "has-flag": "^4.0.0" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/chalk/supports-color?sponsor=1" + } + }, + "node_modules/module-error": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/module-error/-/module-error-1.0.2.tgz", + "integrity": "sha512-0yuvsqSCv8LbaOKhnsQ/T5JhyFlCYLPXK3U2sgV10zoKQwzs/MyfuQUOZQ1V/6OCOJsK/TRgNVrPuPDqtdMFtA==", + "dev": true, + "engines": { + "node": ">=10" + } + }, + "node_modules/ms": { + "version": "2.1.2", + "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.2.tgz", + "integrity": "sha512-sGkPx+VjMtmA6MX27oA4FBFELFCZZ4S4XqeGOXCv68tT+jb3vk/RyaKWP0PTKyWtmLSM0b+adUTEvbs1PEaH2w==", + "dev": true + }, + "node_modules/nanoid": { + "version": "3.3.3", + "resolved": "https://registry.npmjs.org/nanoid/-/nanoid-3.3.3.tgz", + "integrity": "sha512-p1sjXuopFs0xg+fPASzQ28agW1oHD7xDsd9Xkf3T15H3c/cifrFHVwrh74PdoklAPi+i7MdRsE47vm2r6JoB+w==", + "dev": true, + "bin": { + "nanoid": "bin/nanoid.cjs" + }, + "engines": { + "node": "^10 || ^12 || ^13.7 || ^14 || >=15.0.1" + } + }, + "node_modules/napi-macros": { + "version": "2.2.2", + "resolved": "https://registry.npmjs.org/napi-macros/-/napi-macros-2.2.2.tgz", + "integrity": "sha512-hmEVtAGYzVQpCKdbQea4skABsdXW4RUh5t5mJ2zzqowJS2OyXZTU1KhDVFhx+NlWZ4ap9mqR9TcDO3LTTttd+g==", + "dev": true + }, + "node_modules/neo-async": { + "version": "2.6.2", + "resolved": "https://registry.npmjs.org/neo-async/-/neo-async-2.6.2.tgz", + "integrity": "sha512-Yd3UES5mWCSqR+qNT93S3UoYUkqAZ9lLg8a7g9rimsWmYGK8cVToA4/sF3RrshdyV3sAGMXVUmpMYOw+dLpOuw==", + "dev": true, + "peer": true + }, + "node_modules/node-addon-api": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/node-addon-api/-/node-addon-api-2.0.2.tgz", + "integrity": "sha512-Ntyt4AIXyaLIuMHF6IOoTakB3K+RWxwtsHNRxllEoA6vPwP9o4866g6YWDLUdnucilZhmkxiHwHr11gAENw+QA==", + "dev": true + }, + "node_modules/node-emoji": { + "version": "1.11.0", + "resolved": "https://registry.npmjs.org/node-emoji/-/node-emoji-1.11.0.tgz", + "integrity": "sha512-wo2DpQkQp7Sjm2A0cq+sN7EHKO6Sl0ctXeBdFZrL9T9+UywORbufTcTZxom8YqpLQt/FqNMUkOpkZrJVYSKD3A==", + "dev": true, + "peer": true, + "dependencies": { + "lodash": "^4.17.21" + } + }, + "node_modules/node-environment-flags": { + "version": "1.0.6", + "resolved": "https://registry.npmjs.org/node-environment-flags/-/node-environment-flags-1.0.6.tgz", + "integrity": "sha512-5Evy2epuL+6TM0lCQGpFIj6KwiEsGh1SrHUhTbNX+sLbBtjidPZFAnVK9y5yU1+h//RitLbRHTIMyxQPtxMdHw==", + "dev": true, + "peer": true, + "dependencies": { + "object.getownpropertydescriptors": "^2.0.3", + "semver": "^5.7.0" + } + }, + "node_modules/node-environment-flags/node_modules/semver": { + "version": "5.7.1", + "resolved": "https://registry.npmjs.org/semver/-/semver-5.7.1.tgz", + "integrity": "sha512-sauaDf/PZdVgrLTNYHRtpXa1iRiKcaebiKQ1BJdpQlWH2lCvexQdX55snPFyK7QzpudqbCI0qXFfOasHdyNDGQ==", + "dev": true, + "peer": true, + "bin": { + "semver": "bin/semver" + } + }, + "node_modules/node-gyp-build": { + "version": "4.6.0", + "resolved": "https://registry.npmjs.org/node-gyp-build/-/node-gyp-build-4.6.0.tgz", + "integrity": "sha512-NTZVKn9IylLwUzaKjkas1e4u2DLNcV4rdYagA4PWdPwW87Bi7z+BznyKSRwS/761tV/lzCGXplWsiaMjLqP2zQ==", + "dev": true, + "bin": { + "node-gyp-build": "bin.js", + "node-gyp-build-optional": "optional.js", + "node-gyp-build-test": "build-test.js" + } + }, + "node_modules/nofilter": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/nofilter/-/nofilter-3.1.0.tgz", + "integrity": "sha512-l2NNj07e9afPnhAhvgVrCD/oy2Ai1yfLpuo3EpiO1jFTsB4sFz6oIfAfSZyQzVpkZQ9xS8ZS5g1jCBgq4Hwo0g==", + "dev": true, + "peer": true, + "engines": { + "node": ">=12.19" + } + }, + "node_modules/nopt": { + "version": "3.0.6", + "resolved": "https://registry.npmjs.org/nopt/-/nopt-3.0.6.tgz", + "integrity": "sha512-4GUt3kSEYmk4ITxzB/b9vaIDfUVWN/Ml1Fwl11IlnIG2iaJ9O6WXZ9SrYM9NLI8OCBieN2Y8SWC2oJV0RQ7qYg==", + "dev": true, + "peer": true, + "dependencies": { + "abbrev": "1" + }, + "bin": { + "nopt": "bin/nopt.js" + } + }, + "node_modules/normalize-path": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/normalize-path/-/normalize-path-3.0.0.tgz", + "integrity": "sha512-6eZs5Ls3WtCisHWp9S2GUy8dqkpGi4BVSz3GaqiE6ezub0512ESztXUwUB6C6IKbQkY2Pnb/mD4WYojCRwcwLA==", + "dev": true, + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/number-to-bn": { + "version": "1.7.0", + "resolved": "https://registry.npmjs.org/number-to-bn/-/number-to-bn-1.7.0.tgz", + "integrity": "sha512-wsJ9gfSz1/s4ZsJN01lyonwuxA1tml6X1yBDnfpMglypcBRFZZkus26EdPSlqS5GJfYddVZa22p3VNb3z5m5Ig==", + "dev": true, + "peer": true, + "dependencies": { + "bn.js": "4.11.6", + "strip-hex-prefix": "1.0.0" + }, + "engines": { + "node": ">=6.5.0", + "npm": ">=3" + } + }, + "node_modules/number-to-bn/node_modules/bn.js": { + "version": "4.11.6", + "resolved": "https://registry.npmjs.org/bn.js/-/bn.js-4.11.6.tgz", + "integrity": "sha512-XWwnNNFCuuSQ0m3r3C4LE3EiORltHd9M05pq6FOlVeiophzRbMo50Sbz1ehl8K3Z+jw9+vmgnXefY1hz8X+2wA==", + "dev": true, + "peer": true + }, + "node_modules/oauth-sign": { + "version": "0.9.0", + "resolved": "https://registry.npmjs.org/oauth-sign/-/oauth-sign-0.9.0.tgz", + "integrity": "sha512-fexhUFFPTGV8ybAtSIGbV6gOkSv8UtRbDBnAyLQw4QPKkgNlsH2ByPGtMUqdWkos6YCRmAqViwgZrJc/mRDzZQ==", + "dev": true, + "peer": true, + "engines": { + "node": "*" + } + }, + "node_modules/object-assign": { + "version": "4.1.1", + "resolved": "https://registry.npmjs.org/object-assign/-/object-assign-4.1.1.tgz", + "integrity": "sha512-rJgTQnkUnH1sFw8yT6VSU3zD3sWmu6sZhIseY8VX+GRu3P6F7Fu+JNDoXfklElbLJSnc3FUQHVe4cU5hj+BcUg==", + "dev": true, + "peer": true, + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/object-inspect": { + "version": "1.12.3", + "resolved": "https://registry.npmjs.org/object-inspect/-/object-inspect-1.12.3.tgz", + "integrity": "sha512-geUvdk7c+eizMNUDkRpW1wJwgfOiOeHbxBR/hLXK1aT6zmVSO0jsQcs7fj6MGw89jC/cjGfLcNOrtMYtGqm81g==", + "dev": true, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/object-keys": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/object-keys/-/object-keys-1.1.1.tgz", + "integrity": "sha512-NuAESUOUMrlIXOfHKzD6bpPu3tYt3xvjNdRIQ+FeT0lNb4K8WR70CaDxhuNguS2XG+GjkyMwOzsN5ZktImfhLA==", + "dev": true, + "peer": true, + "engines": { + "node": ">= 0.4" + } + }, + "node_modules/object.assign": { + "version": "4.1.0", + "resolved": "https://registry.npmjs.org/object.assign/-/object.assign-4.1.0.tgz", + "integrity": "sha512-exHJeq6kBKj58mqGyTQ9DFvrZC/eR6OwxzoM9YRoGBqrXYonaFyGiFMuc9VZrXf7DarreEwMpurG3dd+CNyW5w==", + "dev": true, + "peer": true, + "dependencies": { + "define-properties": "^1.1.2", + "function-bind": "^1.1.1", + "has-symbols": "^1.0.0", + "object-keys": "^1.0.11" + }, + "engines": { + "node": ">= 0.4" + } + }, + "node_modules/object.getownpropertydescriptors": { + "version": "2.1.6", + "resolved": "https://registry.npmjs.org/object.getownpropertydescriptors/-/object.getownpropertydescriptors-2.1.6.tgz", + "integrity": "sha512-lq+61g26E/BgHv0ZTFgRvi7NMEPuAxLkFU7rukXjc/AlwH4Am5xXVnIXy3un1bg/JPbXHrixRkK1itUzzPiIjQ==", + "dev": true, + "peer": true, + "dependencies": { + "array.prototype.reduce": "^1.0.5", + "call-bind": "^1.0.2", + "define-properties": "^1.2.0", + "es-abstract": "^1.21.2", + "safe-array-concat": "^1.0.0" + }, + "engines": { + "node": ">= 0.8" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/obliterator": { + "version": "2.0.4", + "resolved": "https://registry.npmjs.org/obliterator/-/obliterator-2.0.4.tgz", + "integrity": "sha512-lgHwxlxV1qIg1Eap7LgIeoBWIMFibOjbrYPIPJZcI1mmGAI2m3lNYpK12Y+GBdPQ0U1hRwSord7GIaawz962qQ==", + "dev": true + }, + "node_modules/once": { + "version": "1.4.0", + "resolved": "https://registry.npmjs.org/once/-/once-1.4.0.tgz", + "integrity": "sha512-lNaJgI+2Q5URQBkccEKHTQOPaXdUxnZZElQTZY0MFUAuaEqe1E+Nyvgdz/aIyNi6Z9MzO5dv1H8n58/GELp3+w==", + "dev": true, + "dependencies": { + "wrappy": "1" + } + }, + "node_modules/optionator": { + "version": "0.8.3", + "resolved": "https://registry.npmjs.org/optionator/-/optionator-0.8.3.tgz", + "integrity": "sha512-+IW9pACdk3XWmmTXG8m3upGUJst5XRGzxMRjXzAuJ1XnIFNvfhjjIuYkDvysnPQ7qzqVzLt78BCruntqRhWQbA==", + "dev": true, + "peer": true, + "dependencies": { + "deep-is": "~0.1.3", + "fast-levenshtein": "~2.0.6", + "levn": "~0.3.0", + "prelude-ls": "~1.1.2", + "type-check": "~0.3.2", + "word-wrap": "~1.2.3" + }, + "engines": { + "node": ">= 0.8.0" + } + }, + "node_modules/ordinal": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/ordinal/-/ordinal-1.0.3.tgz", + "integrity": "sha512-cMddMgb2QElm8G7vdaa02jhUNbTSrhsgAGUz1OokD83uJTwSUn+nKoNoKVVaRa08yF6sgfO7Maou1+bgLd9rdQ==", + "dev": true, + "peer": true + }, + "node_modules/os-tmpdir": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/os-tmpdir/-/os-tmpdir-1.0.2.tgz", + "integrity": "sha512-D2FR03Vir7FIu45XBY20mTb+/ZSWB00sjU9jdQXt83gDrI4Ztz5Fs7/yy74g2N5SVQY4xY1qDr4rNddwYRVX0g==", + "dev": true, + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/p-limit": { + "version": "1.3.0", + "resolved": "https://registry.npmjs.org/p-limit/-/p-limit-1.3.0.tgz", + "integrity": "sha512-vvcXsLAJ9Dr5rQOPk7toZQZJApBl2K4J6dANSsEuh6QI41JYcsS/qhTGa9ErIUUgK3WNQoJYvylxvjqmiqEA9Q==", + "dev": true, + "dependencies": { + "p-try": "^1.0.0" + }, + "engines": { + "node": ">=4" + } + }, + "node_modules/p-locate": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/p-locate/-/p-locate-2.0.0.tgz", + "integrity": "sha512-nQja7m7gSKuewoVRen45CtVfODR3crN3goVQ0DDZ9N3yHxgpkuBhZqsaiotSQRrADUrne346peY7kT3TSACykg==", + "dev": true, + "dependencies": { + "p-limit": "^1.1.0" + }, + "engines": { + "node": ">=4" + } + }, + "node_modules/p-map": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/p-map/-/p-map-4.0.0.tgz", + "integrity": "sha512-/bjOqmgETBYB5BoEeGVea8dmvHb2m9GLy1E9W43yeyfP6QQCZGFNa+XRceJEuDB6zqr+gKpIAmlLebMpykw/MQ==", + "dev": true, + "dependencies": { + "aggregate-error": "^3.0.0" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/p-try": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/p-try/-/p-try-1.0.0.tgz", + "integrity": "sha512-U1etNYuMJoIz3ZXSrrySFjsXQTWOx2/jdi86L+2pRvph/qMKL6sbcCYdH23fqsbm8TH2Gn0OybpT4eSFlCVHww==", + "dev": true, + "engines": { + "node": ">=4" + } + }, + "node_modules/parse-cache-control": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/parse-cache-control/-/parse-cache-control-1.0.1.tgz", + "integrity": "sha512-60zvsJReQPX5/QP0Kzfd/VrpjScIQ7SHBW6bFCYfEP+fp0Eppr1SHhIO5nd1PjZtvclzSzES9D/p5nFJurwfWg==", + "dev": true, + "peer": true + }, + "node_modules/path-exists": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/path-exists/-/path-exists-3.0.0.tgz", + "integrity": "sha512-bpC7GYwiDYQ4wYLe+FA8lhRjhQCMcQGuSgGGqDkg/QerRWw9CmGRT0iSOVRSZJ29NMLZgIzqaljJ63oaL4NIJQ==", + "dev": true, + "engines": { + "node": ">=4" + } + }, + "node_modules/path-is-absolute": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/path-is-absolute/-/path-is-absolute-1.0.1.tgz", + "integrity": "sha512-AVbw3UJ2e9bq64vSaS9Am0fje1Pa8pbGqTTsmXfaIiMpnr5DlDhfJOuLj9Sf95ZPVDAUerDfEk88MPmPe7UCQg==", + "dev": true, + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/path-parse": { + "version": "1.0.7", + "resolved": "https://registry.npmjs.org/path-parse/-/path-parse-1.0.7.tgz", + "integrity": "sha512-LDJzPVEEEPR+y48z93A0Ed0yXb8pAByGWo/k5YYdYgpY2/2EsOsksJrq7lOHxryrVOn1ejG6oAp8ahvOIQD8sw==", + "dev": true + }, + "node_modules/path-type": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/path-type/-/path-type-4.0.0.tgz", + "integrity": "sha512-gDKb8aZMDeD/tZWs9P6+q0J9Mwkdl6xMV8TjnGP3qJVJ06bdMgkbBlLU8IdfOsIsFz2BW1rNVT3XuNEl8zPAvw==", + "dev": true, + "peer": true, + "engines": { + "node": ">=8" + } + }, + "node_modules/pathval": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/pathval/-/pathval-1.1.1.tgz", + "integrity": "sha512-Dp6zGqpTdETdR63lehJYPeIOqpiNBNtc7BpWSLrOje7UaIsE5aY92r/AunQA7rsXvet3lrJ3JnZX29UPTKXyKQ==", + "dev": true, + "peer": true, + "engines": { + "node": "*" + } + }, + "node_modules/pbkdf2": { + "version": "3.1.2", + "resolved": "https://registry.npmjs.org/pbkdf2/-/pbkdf2-3.1.2.tgz", + "integrity": "sha512-iuh7L6jA7JEGu2WxDwtQP1ddOpaJNC4KlDEFfdQajSGgGPNi4OyDc2R7QnbY2bR9QjBVGwgvTdNJZoE7RaxUMA==", + "dev": true, + "dependencies": { + "create-hash": "^1.1.2", + "create-hmac": "^1.1.4", + "ripemd160": "^2.0.1", + "safe-buffer": "^5.0.1", + "sha.js": "^2.4.8" + }, + "engines": { + "node": ">=0.12" + } + }, + "node_modules/performance-now": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/performance-now/-/performance-now-2.1.0.tgz", + "integrity": "sha512-7EAHlyLHI56VEIdK57uwHdHKIaAGbnXPiw0yWbarQZOKaKpvUIgW0jWRVLiatnM+XXlSwsanIBH/hzGMJulMow==", + "dev": true, + "peer": true + }, + "node_modules/picomatch": { + "version": "2.3.1", + "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-2.3.1.tgz", + "integrity": "sha512-JU3teHTNjmE2VCGFzuY8EXzCDVwEqB2a8fsIvwaStHhAWJEeVd1o1QD80CU6+ZdEXXSLbSsuLwJjkCBWqRQUVA==", + "dev": true, + "engines": { + "node": ">=8.6" + }, + "funding": { + "url": "https://github.com/sponsors/jonschlinkert" + } + }, + "node_modules/pify": { + "version": "4.0.1", + "resolved": "https://registry.npmjs.org/pify/-/pify-4.0.1.tgz", + "integrity": "sha512-uB80kBFb/tfd68bVleG9T5GGsGPjJrLAUpR5PZIrhBnIaRTQRjqdJSsIKkOP6OAIFbj7GOrcudc5pNjZ+geV2g==", + "dev": true, + "peer": true, + "engines": { + "node": ">=6" + } + }, + "node_modules/prelude-ls": { + "version": "1.1.2", + "resolved": "https://registry.npmjs.org/prelude-ls/-/prelude-ls-1.1.2.tgz", + "integrity": "sha512-ESF23V4SKG6lVSGZgYNpbsiaAkdab6ZgOxe52p7+Kid3W3u3bxR4Vfd/o21dmN7jSt0IwgZ4v5MUd26FEtXE9w==", + "dev": true, + "peer": true, + "engines": { + "node": ">= 0.8.0" + } + }, + "node_modules/prettier": { + "version": "2.8.8", + "resolved": "https://registry.npmjs.org/prettier/-/prettier-2.8.8.tgz", + "integrity": "sha512-tdN8qQGvNjw4CHbY+XXk0JgCXn9QiF21a55rBe5LJAU+kDyC4WQn4+awm2Xfk2lQMk5fKup9XgzTZtGkjBdP9Q==", + "dev": true, + "peer": true, + "bin": { + "prettier": "bin-prettier.js" + }, + "engines": { + "node": ">=10.13.0" + }, + "funding": { + "url": "https://github.com/prettier/prettier?sponsor=1" + } + }, + "node_modules/process-nextick-args": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/process-nextick-args/-/process-nextick-args-2.0.1.tgz", + "integrity": "sha512-3ouUOpQhtgrbOa17J7+uxOTpITYWaGP7/AhoR3+A+/1e9skrzelGi/dXzEYyvbxubEF6Wn2ypscTKiKJFFn1ag==", + "dev": true, + "peer": true + }, + "node_modules/promise": { + "version": "8.3.0", + "resolved": "https://registry.npmjs.org/promise/-/promise-8.3.0.tgz", + "integrity": "sha512-rZPNPKTOYVNEEKFaq1HqTgOwZD+4/YHS5ukLzQCypkj+OkYx7iv0mA91lJlpPPZ8vMau3IIGj5Qlwrx+8iiSmg==", + "dev": true, + "peer": true, + "dependencies": { + "asap": "~2.0.6" + } + }, + "node_modules/psl": { + "version": "1.9.0", + "resolved": "https://registry.npmjs.org/psl/-/psl-1.9.0.tgz", + "integrity": "sha512-E/ZsdU4HLs/68gYzgGTkMicWTLPdAftJLfJFlLUAAKZGkStNU72sZjT66SnMDVOfOWY/YAoiD7Jxa9iHvngcag==", + "dev": true, + "peer": true + }, + "node_modules/punycode": { + "version": "2.3.0", + "resolved": "https://registry.npmjs.org/punycode/-/punycode-2.3.0.tgz", + "integrity": "sha512-rRV+zQD8tVFys26lAGR9WUuS4iUAngJScM+ZRSKtvl5tKeZ2t5bvdNFdNHBW9FWR4guGHlgmsZ1G7BSm2wTbuA==", + "dev": true, + "peer": true, + "engines": { + "node": ">=6" + } + }, + "node_modules/qs": { + "version": "6.11.1", + "resolved": "https://registry.npmjs.org/qs/-/qs-6.11.1.tgz", + "integrity": "sha512-0wsrzgTz/kAVIeuxSjnpGC56rzYtr6JT/2BwEvMaPhFIoYa1aGO8LbzuU1R0uUYQkLpWBTOj0l/CLAJB64J6nQ==", + "dev": true, + "dependencies": { + "side-channel": "^1.0.4" + }, + "engines": { + "node": ">=0.6" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/queue-microtask": { + "version": "1.2.3", + "resolved": "https://registry.npmjs.org/queue-microtask/-/queue-microtask-1.2.3.tgz", + "integrity": "sha512-NuaNSa6flKT5JaSYQzJok04JzTL1CA6aGhv5rfLW3PgqA+M2ChpZQnAC8h8i4ZFkBS8X5RqkDBHA7r4hej3K9A==", + "dev": true, + "funding": [ + { + "type": "github", + "url": "https://github.com/sponsors/feross" + }, + { + "type": "patreon", + "url": "https://www.patreon.com/feross" + }, + { + "type": "consulting", + "url": "https://feross.org/support" + } + ] + }, + "node_modules/randombytes": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/randombytes/-/randombytes-2.1.0.tgz", + "integrity": "sha512-vYl3iOX+4CKUWuxGi9Ukhie6fsqXqS9FE2Zaic4tNFD2N2QQaXOMFbuKK4QmDHC0JO6B1Zp41J0LpT0oR68amQ==", + "dev": true, + "dependencies": { + "safe-buffer": "^5.1.0" + } + }, + "node_modules/raw-body": { + "version": "2.5.2", + "resolved": "https://registry.npmjs.org/raw-body/-/raw-body-2.5.2.tgz", + "integrity": "sha512-8zGqypfENjCIqGhgXToC8aB2r7YrBX+AQAfIPs/Mlk+BtPTztOvTS01NRW/3Eh60J+a48lt8qsCzirQ6loCVfA==", + "dev": true, + "dependencies": { + "bytes": "3.1.2", + "http-errors": "2.0.0", + "iconv-lite": "0.4.24", + "unpipe": "1.0.0" + }, + "engines": { + "node": ">= 0.8" + } + }, + "node_modules/readable-stream": { + "version": "3.6.2", + "resolved": "https://registry.npmjs.org/readable-stream/-/readable-stream-3.6.2.tgz", + "integrity": "sha512-9u/sniCrY3D5WdsERHzHE4G2YCXqoG5FTHUiCC4SIbr6XcLZBY05ya9EKjYek9O5xOAwjGq+1JdGBAS7Q9ScoA==", + "dev": true, + "dependencies": { + "inherits": "^2.0.3", + "string_decoder": "^1.1.1", + "util-deprecate": "^1.0.1" + }, + "engines": { + "node": ">= 6" + } + }, + "node_modules/readdirp": { + "version": "3.6.0", + "resolved": "https://registry.npmjs.org/readdirp/-/readdirp-3.6.0.tgz", + "integrity": "sha512-hOS089on8RduqdbhvQ5Z37A0ESjsqz6qnRcffsMU3495FuTdqSm+7bhJ29JvIOsBDEEnan5DPu9t3To9VRlMzA==", + "dev": true, + "dependencies": { + "picomatch": "^2.2.1" + }, + "engines": { + "node": ">=8.10.0" + } + }, + "node_modules/rechoir": { + "version": "0.6.2", + "resolved": "https://registry.npmjs.org/rechoir/-/rechoir-0.6.2.tgz", + "integrity": "sha512-HFM8rkZ+i3zrV+4LQjwQ0W+ez98pApMGM3HUrN04j3CqzPOzl9nmP15Y8YXNm8QHGv/eacOVEjqhmWpkRV0NAw==", + "dev": true, + "peer": true, + "dependencies": { + "resolve": "^1.1.6" + }, + "engines": { + "node": ">= 0.10" + } + }, + "node_modules/recursive-readdir": { + "version": "2.2.3", + "resolved": "https://registry.npmjs.org/recursive-readdir/-/recursive-readdir-2.2.3.tgz", + "integrity": "sha512-8HrF5ZsXk5FAH9dgsx3BlUer73nIhuj+9OrQwEbLTPOBzGkL1lsFCR01am+v+0m2Cmbs1nP12hLDl5FA7EszKA==", + "dev": true, + "peer": true, + "dependencies": { + "minimatch": "^3.0.5" + }, + "engines": { + "node": ">=6.0.0" + } + }, + "node_modules/reduce-flatten": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/reduce-flatten/-/reduce-flatten-2.0.0.tgz", + "integrity": "sha512-EJ4UNY/U1t2P/2k6oqotuX2Cc3T6nxJwsM0N0asT7dhrtH1ltUxDn4NalSYmPE2rCkVpcf/X6R0wDwcFpzhd4w==", + "dev": true, + "peer": true, + "engines": { + "node": ">=6" + } + }, + "node_modules/regexp.prototype.flags": { + "version": "1.5.0", + "resolved": "https://registry.npmjs.org/regexp.prototype.flags/-/regexp.prototype.flags-1.5.0.tgz", + "integrity": "sha512-0SutC3pNudRKgquxGoRGIz946MZVHqbNfPjBdxeOhBrdgDKlRoXmYLQN9xRbrR09ZXWeGAdPuif7egofn6v5LA==", + "dev": true, + "peer": true, + "dependencies": { + "call-bind": "^1.0.2", + "define-properties": "^1.2.0", + "functions-have-names": "^1.2.3" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/req-cwd": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/req-cwd/-/req-cwd-2.0.0.tgz", + "integrity": "sha512-ueoIoLo1OfB6b05COxAA9UpeoscNpYyM+BqYlA7H6LVF4hKGPXQQSSaD2YmvDVJMkk4UDpAHIeU1zG53IqjvlQ==", + "dev": true, + "peer": true, + "dependencies": { + "req-from": "^2.0.0" + }, + "engines": { + "node": ">=4" + } + }, + "node_modules/req-from": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/req-from/-/req-from-2.0.0.tgz", + "integrity": "sha512-LzTfEVDVQHBRfjOUMgNBA+V6DWsSnoeKzf42J7l0xa/B4jyPOuuF5MlNSmomLNGemWTnV2TIdjSSLnEn95fOQA==", + "dev": true, + "peer": true, + "dependencies": { + "resolve-from": "^3.0.0" + }, + "engines": { + "node": ">=4" + } + }, + "node_modules/request": { + "version": "2.88.2", + "resolved": "https://registry.npmjs.org/request/-/request-2.88.2.tgz", + "integrity": "sha512-MsvtOrfG9ZcrOwAW+Qi+F6HbD0CWXEh9ou77uOb7FM2WPhwT7smM833PzanhJLsgXjN89Ir6V2PczXNnMpwKhw==", + "deprecated": "request has been deprecated, see https://github.com/request/request/issues/3142", + "dev": true, + "peer": true, + "dependencies": { + "aws-sign2": "~0.7.0", + "aws4": "^1.8.0", + "caseless": "~0.12.0", + "combined-stream": "~1.0.6", + "extend": "~3.0.2", + "forever-agent": "~0.6.1", + "form-data": "~2.3.2", + "har-validator": "~5.1.3", + "http-signature": "~1.2.0", + "is-typedarray": "~1.0.0", + "isstream": "~0.1.2", + "json-stringify-safe": "~5.0.1", + "mime-types": "~2.1.19", + "oauth-sign": "~0.9.0", + "performance-now": "^2.1.0", + "qs": "~6.5.2", + "safe-buffer": "^5.1.2", + "tough-cookie": "~2.5.0", + "tunnel-agent": "^0.6.0", + "uuid": "^3.3.2" + }, + "engines": { + "node": ">= 6" + } + }, + "node_modules/request-promise-core": { + "version": "1.1.4", + "resolved": "https://registry.npmjs.org/request-promise-core/-/request-promise-core-1.1.4.tgz", + "integrity": "sha512-TTbAfBBRdWD7aNNOoVOBH4pN/KigV6LyapYNNlAPA8JwbovRti1E88m3sYAwsLi5ryhPKsE9APwnjFTgdUjTpw==", + "dev": true, + "peer": true, + "dependencies": { + "lodash": "^4.17.19" + }, + "engines": { + "node": ">=0.10.0" + }, + "peerDependencies": { + "request": "^2.34" + } + }, + "node_modules/request-promise-native": { + "version": "1.0.9", + "resolved": "https://registry.npmjs.org/request-promise-native/-/request-promise-native-1.0.9.tgz", + "integrity": "sha512-wcW+sIUiWnKgNY0dqCpOZkUbF/I+YPi+f09JZIDa39Ec+q82CpSYniDp+ISgTTbKmnpJWASeJBPZmoxH84wt3g==", + "deprecated": "request-promise-native has been deprecated because it extends the now deprecated request package, see https://github.com/request/request/issues/3142", + "dev": true, + "peer": true, + "dependencies": { + "request-promise-core": "1.1.4", + "stealthy-require": "^1.1.1", + "tough-cookie": "^2.3.3" + }, + "engines": { + "node": ">=0.12.0" + }, + "peerDependencies": { + "request": "^2.34" + } + }, + "node_modules/request/node_modules/qs": { + "version": "6.5.3", + "resolved": "https://registry.npmjs.org/qs/-/qs-6.5.3.tgz", + "integrity": "sha512-qxXIEh4pCGfHICj1mAJQ2/2XVZkjCDTcEgfoSQxc/fYivUZxTkk7L3bDBJSoNrEzXI17oUO5Dp07ktqE5KzczA==", + "dev": true, + "peer": true, + "engines": { + "node": ">=0.6" + } + }, + "node_modules/request/node_modules/uuid": { + "version": "3.4.0", + "resolved": "https://registry.npmjs.org/uuid/-/uuid-3.4.0.tgz", + "integrity": "sha512-HjSDRw6gZE5JMggctHBcjVak08+KEVhSIiDzFnT9S9aegmp85S/bReBVTb4QTFaRNptJ9kuYaNhnbNEOkbKb/A==", + "deprecated": "Please upgrade to version 7 or higher. Older versions may use Math.random() in certain circumstances, which is known to be problematic. See https://v8.dev/blog/math-random for details.", + "dev": true, + "peer": true, + "bin": { + "uuid": "bin/uuid" + } + }, + "node_modules/require-directory": { + "version": "2.1.1", + "resolved": "https://registry.npmjs.org/require-directory/-/require-directory-2.1.1.tgz", + "integrity": "sha512-fGxEI7+wsG9xrvdjsrlmL22OMTTiHRwAMroiEeMgq8gzoLC/PQr7RsRDSTLUg/bZAZtF+TVIkHc6/4RIKrui+Q==", + "dev": true, + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/require-from-string": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/require-from-string/-/require-from-string-2.0.2.tgz", + "integrity": "sha512-Xf0nWe6RseziFMu+Ap9biiUbmplq6S9/p+7w7YXP/JBHhrUDDUhwa+vANyubuqfZWTveU//DYVGsDG7RKL/vEw==", + "dev": true, + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/require-main-filename": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/require-main-filename/-/require-main-filename-2.0.0.tgz", + "integrity": "sha512-NKN5kMDylKuldxYLSUfrbo5Tuzh4hd+2E8NPPX02mZtn1VuREQToYe/ZdlJy+J3uCpfaiGF05e7B8W0iXbQHmg==", + "dev": true, + "peer": true + }, + "node_modules/resolve": { + "version": "1.17.0", + "resolved": "https://registry.npmjs.org/resolve/-/resolve-1.17.0.tgz", + "integrity": "sha512-ic+7JYiV8Vi2yzQGFWOkiZD5Z9z7O2Zhm9XMaTxdJExKasieFCr+yXZ/WmXsckHiKl12ar0y6XiXDx3m4RHn1w==", + "dev": true, + "dependencies": { + "path-parse": "^1.0.6" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/resolve-from": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/resolve-from/-/resolve-from-3.0.0.tgz", + "integrity": "sha512-GnlH6vxLymXJNMBo7XP1fJIzBFbdYt49CuTwmB/6N53t+kMPRMFKz783LlQ4tv28XoQfMWinAJX6WCGf2IlaIw==", + "dev": true, + "peer": true, + "engines": { + "node": ">=4" + } + }, + "node_modules/reusify": { + "version": "1.0.4", + "resolved": "https://registry.npmjs.org/reusify/-/reusify-1.0.4.tgz", + "integrity": "sha512-U9nH88a3fc/ekCF1l0/UP1IosiuIjyTh7hBvXVMHYgVcfGvt897Xguj2UOLDeI5BG2m7/uwyaLVT6fbtCwTyzw==", + "dev": true, + "peer": true, + "engines": { + "iojs": ">=1.0.0", + "node": ">=0.10.0" + } + }, + "node_modules/rimraf": { + "version": "2.7.1", + "resolved": "https://registry.npmjs.org/rimraf/-/rimraf-2.7.1.tgz", + "integrity": "sha512-uWjbaKIK3T1OSVptzX7Nl6PvQ3qAGtKEtVRjRuazjfL3Bx5eI409VZSqgND+4UNnmzLVdPj9FqFJNPqBZFve4w==", + "dev": true, + "dependencies": { + "glob": "^7.1.3" + }, + "bin": { + "rimraf": "bin.js" + } + }, + "node_modules/ripemd160": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/ripemd160/-/ripemd160-2.0.2.tgz", + "integrity": "sha512-ii4iagi25WusVoiC4B4lq7pbXfAp3D9v5CwfkY33vffw2+pkDjY1D8GaN7spsxvCSx8dkPqOZCEZyfxcmJG2IA==", + "dev": true, + "dependencies": { + "hash-base": "^3.0.0", + "inherits": "^2.0.1" + } + }, + "node_modules/rlp": { + "version": "2.2.7", + "resolved": "https://registry.npmjs.org/rlp/-/rlp-2.2.7.tgz", + "integrity": "sha512-d5gdPmgQ0Z+AklL2NVXr/IoSjNZFfTVvQWzL/AM2AOcSzYP2xjlb0AC8YyCLc41MSNf6P6QVtjgPdmVtzb+4lQ==", + "dev": true, + "dependencies": { + "bn.js": "^5.2.0" + }, + "bin": { + "rlp": "bin/rlp" + } + }, + "node_modules/run-parallel": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/run-parallel/-/run-parallel-1.2.0.tgz", + "integrity": "sha512-5l4VyZR86LZ/lDxZTR6jqL8AFE2S0IFLMP26AbjsLVADxHdhB/c0GUsH+y39UfCi3dzz8OlQuPmnaJOMoDHQBA==", + "dev": true, + "funding": [ + { + "type": "github", + "url": "https://github.com/sponsors/feross" + }, + { + "type": "patreon", + "url": "https://www.patreon.com/feross" + }, + { + "type": "consulting", + "url": "https://feross.org/support" + } + ], + "peer": true, + "dependencies": { + "queue-microtask": "^1.2.2" + } + }, + "node_modules/run-parallel-limit": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/run-parallel-limit/-/run-parallel-limit-1.1.0.tgz", + "integrity": "sha512-jJA7irRNM91jaKc3Hcl1npHsFLOXOoTkPCUL1JEa1R82O2miplXXRaGdjW/KM/98YQWDhJLiSs793CnXfblJUw==", + "dev": true, + "funding": [ + { + "type": "github", + "url": "https://github.com/sponsors/feross" + }, + { + "type": "patreon", + "url": "https://www.patreon.com/feross" + }, + { + "type": "consulting", + "url": "https://feross.org/support" + } + ], + "dependencies": { + "queue-microtask": "^1.2.2" + } + }, + "node_modules/rustbn.js": { + "version": "0.2.0", + "resolved": "https://registry.npmjs.org/rustbn.js/-/rustbn.js-0.2.0.tgz", + "integrity": "sha512-4VlvkRUuCJvr2J6Y0ImW7NvTCriMi7ErOAqWk1y69vAdoNIzCF3yPmgeNzx+RQTLEDFq5sHfscn1MwHxP9hNfA==", + "dev": true + }, + "node_modules/safe-array-concat": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/safe-array-concat/-/safe-array-concat-1.0.0.tgz", + "integrity": "sha512-9dVEFruWIsnie89yym+xWTAYASdpw3CJV7Li/6zBewGf9z2i1j31rP6jnY0pHEO4QZh6N0K11bFjWmdR8UGdPQ==", + "dev": true, + "peer": true, + "dependencies": { + "call-bind": "^1.0.2", + "get-intrinsic": "^1.2.0", + "has-symbols": "^1.0.3", + "isarray": "^2.0.5" + }, + "engines": { + "node": ">=0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/safe-array-concat/node_modules/isarray": { + "version": "2.0.5", + "resolved": "https://registry.npmjs.org/isarray/-/isarray-2.0.5.tgz", + "integrity": "sha512-xHjhDr3cNBK0BzdUJSPXZntQUx/mwMS5Rw4A7lPJ90XGAO6ISP/ePDNuo0vhqOZU+UD5JoodwCAAoZQd3FeAKw==", + "dev": true, + "peer": true + }, + "node_modules/safe-buffer": { + "version": "5.1.2", + "resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.1.2.tgz", + "integrity": "sha512-Gd2UZBJDkXlY7GbJxfsE8/nvKkUEU1G38c1siN6QP6a9PT9MmHB8GnpscSmMJSoF8LOIrt8ud/wPtojys4G6+g==", + "dev": true + }, + "node_modules/safe-regex-test": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/safe-regex-test/-/safe-regex-test-1.0.0.tgz", + "integrity": "sha512-JBUUzyOgEwXQY1NuPtvcj/qcBDbDmEvWufhlnXZIm75DEHp+afM1r1ujJpJsV/gSM4t59tpDyPi1sd6ZaPFfsA==", + "dev": true, + "peer": true, + "dependencies": { + "call-bind": "^1.0.2", + "get-intrinsic": "^1.1.3", + "is-regex": "^1.1.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/safer-buffer": { + "version": "2.1.2", + "resolved": "https://registry.npmjs.org/safer-buffer/-/safer-buffer-2.1.2.tgz", + "integrity": "sha512-YZo3K82SD7Riyi0E1EQPojLz7kpepnSQI9IyPbHHg1XXXevb5dJI7tpyN2ADxGcQbHG7vcyRHk0cbwqcQriUtg==", + "dev": true + }, + "node_modules/sc-istanbul": { + "version": "0.4.6", + "resolved": "https://registry.npmjs.org/sc-istanbul/-/sc-istanbul-0.4.6.tgz", + "integrity": "sha512-qJFF/8tW/zJsbyfh/iT/ZM5QNHE3CXxtLJbZsL+CzdJLBsPD7SedJZoUA4d8iAcN2IoMp/Dx80shOOd2x96X/g==", + "dev": true, + "peer": true, + "dependencies": { + "abbrev": "1.0.x", + "async": "1.x", + "escodegen": "1.8.x", + "esprima": "2.7.x", + "glob": "^5.0.15", + "handlebars": "^4.0.1", + "js-yaml": "3.x", + "mkdirp": "0.5.x", + "nopt": "3.x", + "once": "1.x", + "resolve": "1.1.x", + "supports-color": "^3.1.0", + "which": "^1.1.1", + "wordwrap": "^1.0.0" + }, + "bin": { + "istanbul": "lib/cli.js" + } + }, + "node_modules/sc-istanbul/node_modules/argparse": { + "version": "1.0.10", + "resolved": "https://registry.npmjs.org/argparse/-/argparse-1.0.10.tgz", + "integrity": "sha512-o5Roy6tNG4SL/FOkCAN6RzjiakZS25RLYFrcMttJqbdd8BWrnA+fGz57iN5Pb06pvBGvl5gQ0B48dJlslXvoTg==", + "dev": true, + "peer": true, + "dependencies": { + "sprintf-js": "~1.0.2" + } + }, + "node_modules/sc-istanbul/node_modules/glob": { + "version": "5.0.15", + "resolved": "https://registry.npmjs.org/glob/-/glob-5.0.15.tgz", + "integrity": "sha512-c9IPMazfRITpmAAKi22dK1VKxGDX9ehhqfABDriL/lzO92xcUKEJPQHrVA/2YHSNFB4iFlykVmWvwo48nr3OxA==", + "dev": true, + "peer": true, + "dependencies": { + "inflight": "^1.0.4", + "inherits": "2", + "minimatch": "2 || 3", + "once": "^1.3.0", + "path-is-absolute": "^1.0.0" + }, + "engines": { + "node": "*" + } + }, + "node_modules/sc-istanbul/node_modules/has-flag": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-1.0.0.tgz", + "integrity": "sha512-DyYHfIYwAJmjAjSSPKANxI8bFY9YtFrgkAfinBojQ8YJTOuOuav64tMUJv584SES4xl74PmuaevIyaLESHdTAA==", + "dev": true, + "peer": true, + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/sc-istanbul/node_modules/js-yaml": { + "version": "3.14.1", + "resolved": "https://registry.npmjs.org/js-yaml/-/js-yaml-3.14.1.tgz", + "integrity": "sha512-okMH7OXXJ7YrN9Ok3/SXrnu4iX9yOk+25nqX4imS2npuvTYDmo/QEZoqwZkYaIDk3jVvBOTOIEgEhaLOynBS9g==", + "dev": true, + "peer": true, + "dependencies": { + "argparse": "^1.0.7", + "esprima": "^4.0.0" + }, + "bin": { + "js-yaml": "bin/js-yaml.js" + } + }, + "node_modules/sc-istanbul/node_modules/js-yaml/node_modules/esprima": { + "version": "4.0.1", + "resolved": "https://registry.npmjs.org/esprima/-/esprima-4.0.1.tgz", + "integrity": "sha512-eGuFFw7Upda+g4p+QHvnW0RyTX/SVeJBDM/gCtMARO0cLuT2HcEKnTPvhjV6aGeqrCB/sbNop0Kszm0jsaWU4A==", + "dev": true, + "peer": true, + "bin": { + "esparse": "bin/esparse.js", + "esvalidate": "bin/esvalidate.js" + }, + "engines": { + "node": ">=4" + } + }, + "node_modules/sc-istanbul/node_modules/resolve": { + "version": "1.1.7", + "resolved": "https://registry.npmjs.org/resolve/-/resolve-1.1.7.tgz", + "integrity": "sha512-9znBF0vBcaSN3W2j7wKvdERPwqTxSpCq+if5C0WoTCyV9n24rua28jeuQ2pL/HOf+yUe/Mef+H/5p60K0Id3bg==", + "dev": true, + "peer": true + }, + "node_modules/sc-istanbul/node_modules/supports-color": { + "version": "3.2.3", + "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-3.2.3.tgz", + "integrity": "sha512-Jds2VIYDrlp5ui7t8abHN2bjAu4LV/q4N2KivFPpGH0lrka0BMq/33AmECUXlKPcHigkNaqfXRENFju+rlcy+A==", + "dev": true, + "peer": true, + "dependencies": { + "has-flag": "^1.0.0" + }, + "engines": { + "node": ">=0.8.0" + } + }, + "node_modules/scrypt-js": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/scrypt-js/-/scrypt-js-3.0.1.tgz", + "integrity": "sha512-cdwTTnqPu0Hyvf5in5asVdZocVDTNRmR7XEcJuIzMjJeSHybHl7vpB66AzwTaIg6CLSbtjcxc8fqcySfnTkccA==", + "dev": true + }, + "node_modules/secp256k1": { + "version": "4.0.3", + "resolved": "https://registry.npmjs.org/secp256k1/-/secp256k1-4.0.3.tgz", + "integrity": "sha512-NLZVf+ROMxwtEj3Xa562qgv2BK5e2WNmXPiOdVIPLgs6lyTzMvBq0aWTYMI5XCP9jZMVKOcqZLw/Wc4vDkuxhA==", + "dev": true, + "hasInstallScript": true, + "dependencies": { + "elliptic": "^6.5.4", + "node-addon-api": "^2.0.0", + "node-gyp-build": "^4.2.0" + }, + "engines": { + "node": ">=10.0.0" + } + }, + "node_modules/semver": { + "version": "6.3.0", + "resolved": "https://registry.npmjs.org/semver/-/semver-6.3.0.tgz", + "integrity": "sha512-b39TBaTSfV6yBrapU89p5fKekE2m/NwnDocOVruQFS1/veMgdzuPcnOM34M6CwxW8jH/lxEa5rBoDeUwu5HHTw==", + "dev": true, + "bin": { + "semver": "bin/semver.js" + } + }, + "node_modules/serialize-javascript": { + "version": "6.0.0", + "resolved": "https://registry.npmjs.org/serialize-javascript/-/serialize-javascript-6.0.0.tgz", + "integrity": "sha512-Qr3TosvguFt8ePWqsvRfrKyQXIiW+nGbYpy8XK24NQHE83caxWt+mIymTT19DGFbNWNLfEwsrkSmN64lVWB9ag==", + "dev": true, + "dependencies": { + "randombytes": "^2.1.0" + } + }, + "node_modules/set-blocking": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/set-blocking/-/set-blocking-2.0.0.tgz", + "integrity": "sha512-KiKBS8AnWGEyLzofFfmvKwpdPzqiy16LvQfK3yv/fVH7Bj13/wl3JSR1J+rfgRE9q7xUJK4qvgS8raSOeLUehw==", + "dev": true, + "peer": true + }, + "node_modules/setimmediate": { + "version": "1.0.5", + "resolved": "https://registry.npmjs.org/setimmediate/-/setimmediate-1.0.5.tgz", + "integrity": "sha512-MATJdZp8sLqDl/68LfQmbP8zKPLQNV6BIZoIgrscFDQ+RsvK/BxeDQOgyxKKoh0y/8h3BqVFnCqQ/gd+reiIXA==", + "dev": true + }, + "node_modules/setprototypeof": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/setprototypeof/-/setprototypeof-1.2.0.tgz", + "integrity": "sha512-E5LDX7Wrp85Kil5bhZv46j8jOeboKq5JMmYM3gVGdGH8xFpPWXUMsNrlODCrkoxMEeNi/XZIwuRvY4XNwYMJpw==", + "dev": true + }, + "node_modules/sha.js": { + "version": "2.4.11", + "resolved": "https://registry.npmjs.org/sha.js/-/sha.js-2.4.11.tgz", + "integrity": "sha512-QMEp5B7cftE7APOjk5Y6xgrbWu+WkLVQwk8JNjZ8nKRciZaByEW6MubieAiToS7+dwvrjGhH8jRXz3MVd0AYqQ==", + "dev": true, + "dependencies": { + "inherits": "^2.0.1", + "safe-buffer": "^5.0.1" + }, + "bin": { + "sha.js": "bin.js" + } + }, + "node_modules/sha1": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/sha1/-/sha1-1.1.1.tgz", + "integrity": "sha512-dZBS6OrMjtgVkopB1Gmo4RQCDKiZsqcpAQpkV/aaj+FCrCg8r4I4qMkDPQjBgLIxlmu9k4nUbWq6ohXahOneYA==", + "dev": true, + "peer": true, + "dependencies": { + "charenc": ">= 0.0.1", + "crypt": ">= 0.0.1" + }, + "engines": { + "node": "*" + } + }, + "node_modules/shelljs": { + "version": "0.8.5", + "resolved": "https://registry.npmjs.org/shelljs/-/shelljs-0.8.5.tgz", + "integrity": "sha512-TiwcRcrkhHvbrZbnRcFYMLl30Dfov3HKqzp5tO5b4pt6G/SezKcYhmDg15zXVBswHmctSAQKznqNW2LO5tTDow==", + "dev": true, + "peer": true, + "dependencies": { + "glob": "^7.0.0", + "interpret": "^1.0.0", + "rechoir": "^0.6.2" + }, + "bin": { + "shjs": "bin/shjs" + }, + "engines": { + "node": ">=4" + } + }, + "node_modules/side-channel": { + "version": "1.0.4", + "resolved": "https://registry.npmjs.org/side-channel/-/side-channel-1.0.4.tgz", + "integrity": "sha512-q5XPytqFEIKHkGdiMIrY10mvLRvnQh42/+GoBlFW3b2LXLE2xxJpZFdm94we0BaoV3RwJyGqg5wS7epxTv0Zvw==", + "dev": true, + "dependencies": { + "call-bind": "^1.0.0", + "get-intrinsic": "^1.0.2", + "object-inspect": "^1.9.0" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/slash": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/slash/-/slash-3.0.0.tgz", + "integrity": "sha512-g9Q1haeby36OSStwb4ntCGGGaKsaVSjQ68fBxoQcutl5fS1vuY18H3wSt3jFyFtrkx+Kz0V1G85A4MyAdDMi2Q==", + "dev": true, + "peer": true, + "engines": { + "node": ">=8" + } + }, + "node_modules/slice-ansi": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/slice-ansi/-/slice-ansi-4.0.0.tgz", + "integrity": "sha512-qMCMfhY040cVHT43K9BFygqYbUPFZKHOg7K73mtTWJRb8pyP3fzf4Ixd5SzdEJQ6MRUg/WBnOLxghZtKKurENQ==", + "dev": true, + "peer": true, + "dependencies": { + "ansi-styles": "^4.0.0", + "astral-regex": "^2.0.0", + "is-fullwidth-code-point": "^3.0.0" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/chalk/slice-ansi?sponsor=1" + } + }, + "node_modules/slice-ansi/node_modules/ansi-styles": { + "version": "4.3.0", + "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-4.3.0.tgz", + "integrity": "sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==", + "dev": true, + "peer": true, + "dependencies": { + "color-convert": "^2.0.1" + }, + "engines": { + "node": ">=8" + }, + "funding": { + "url": "https://github.com/chalk/ansi-styles?sponsor=1" + } + }, + "node_modules/slice-ansi/node_modules/color-convert": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-2.0.1.tgz", + "integrity": "sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ==", + "dev": true, + "peer": true, + "dependencies": { + "color-name": "~1.1.4" + }, + "engines": { + "node": ">=7.0.0" + } + }, + "node_modules/slice-ansi/node_modules/color-name": { + "version": "1.1.4", + "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.4.tgz", + "integrity": "sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA==", + "dev": true, + "peer": true + }, + "node_modules/solc": { + "version": "0.7.3", + "resolved": "https://registry.npmjs.org/solc/-/solc-0.7.3.tgz", + "integrity": "sha512-GAsWNAjGzIDg7VxzP6mPjdurby3IkGCjQcM8GFYZT6RyaoUZKmMU6Y7YwG+tFGhv7dwZ8rmR4iwFDrrD99JwqA==", + "dev": true, + "dependencies": { + "command-exists": "^1.2.8", + "commander": "3.0.2", + "follow-redirects": "^1.12.1", + "fs-extra": "^0.30.0", + "js-sha3": "0.8.0", + "memorystream": "^0.3.1", + "require-from-string": "^2.0.0", + "semver": "^5.5.0", + "tmp": "0.0.33" + }, + "bin": { + "solcjs": "solcjs" + }, + "engines": { + "node": ">=8.0.0" + } + }, + "node_modules/solc/node_modules/fs-extra": { + "version": "0.30.0", + "resolved": "https://registry.npmjs.org/fs-extra/-/fs-extra-0.30.0.tgz", + "integrity": "sha512-UvSPKyhMn6LEd/WpUaV9C9t3zATuqoqfWc3QdPhPLb58prN9tqYPlPWi8Krxi44loBoUzlobqZ3+8tGpxxSzwA==", + "dev": true, + "dependencies": { + "graceful-fs": "^4.1.2", + "jsonfile": "^2.1.0", + "klaw": "^1.0.0", + "path-is-absolute": "^1.0.0", + "rimraf": "^2.2.8" + } + }, + "node_modules/solc/node_modules/jsonfile": { + "version": "2.4.0", + "resolved": "https://registry.npmjs.org/jsonfile/-/jsonfile-2.4.0.tgz", + "integrity": "sha512-PKllAqbgLgxHaj8TElYymKCAgrASebJrWpTnEkOaTowt23VKXXN0sUeriJ+eh7y6ufb/CC5ap11pz71/cM0hUw==", + "dev": true, + "optionalDependencies": { + "graceful-fs": "^4.1.6" + } + }, + "node_modules/solc/node_modules/semver": { + "version": "5.7.1", + "resolved": "https://registry.npmjs.org/semver/-/semver-5.7.1.tgz", + "integrity": "sha512-sauaDf/PZdVgrLTNYHRtpXa1iRiKcaebiKQ1BJdpQlWH2lCvexQdX55snPFyK7QzpudqbCI0qXFfOasHdyNDGQ==", + "dev": true, + "bin": { + "semver": "bin/semver" + } + }, + "node_modules/solidity-coverage": { + "version": "0.8.2", + "resolved": "https://registry.npmjs.org/solidity-coverage/-/solidity-coverage-0.8.2.tgz", + "integrity": "sha512-cv2bWb7lOXPE9/SSleDO6czkFiMHgP4NXPj+iW9W7iEKLBk7Cj0AGBiNmGX3V1totl9wjPrT0gHmABZKZt65rQ==", + "dev": true, + "peer": true, + "dependencies": { + "@ethersproject/abi": "^5.0.9", + "@solidity-parser/parser": "^0.14.1", + "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", + "global-modules": "^2.0.0", + "globby": "^10.0.1", + "jsonschema": "^1.2.4", + "lodash": "^4.17.15", + "mocha": "7.1.2", + "node-emoji": "^1.10.0", + "pify": "^4.0.1", + "recursive-readdir": "^2.2.2", + "sc-istanbul": "^0.4.5", + "semver": "^7.3.4", + "shelljs": "^0.8.3", + "web3-utils": "^1.3.6" + }, + "bin": { + "solidity-coverage": "plugins/bin.js" + }, + "peerDependencies": { + "hardhat": "^2.11.0" + } + }, + "node_modules/solidity-coverage/node_modules/ansi-colors": { + "version": "3.2.3", + "resolved": "https://registry.npmjs.org/ansi-colors/-/ansi-colors-3.2.3.tgz", + "integrity": "sha512-LEHHyuhlPY3TmuUYMh2oz89lTShfvgbmzaBcxve9t/9Wuy7Dwf4yoAKcND7KFT1HAQfqZ12qtc+DUrBMeKF9nw==", + "dev": true, + "peer": true, + "engines": { + "node": ">=6" + } + }, + "node_modules/solidity-coverage/node_modules/ansi-regex": { + "version": "4.1.1", + "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-4.1.1.tgz", + "integrity": "sha512-ILlv4k/3f6vfQ4OoP2AGvirOktlQ98ZEL1k9FaQjxa3L1abBgbuTDAdPOpvbGncC0BTVQrl+OM8xZGK6tWXt7g==", + "dev": true, + "peer": true, + "engines": { + "node": ">=6" + } + }, + "node_modules/solidity-coverage/node_modules/argparse": { + "version": "1.0.10", + "resolved": "https://registry.npmjs.org/argparse/-/argparse-1.0.10.tgz", + "integrity": "sha512-o5Roy6tNG4SL/FOkCAN6RzjiakZS25RLYFrcMttJqbdd8BWrnA+fGz57iN5Pb06pvBGvl5gQ0B48dJlslXvoTg==", + "dev": true, + "peer": true, + "dependencies": { + "sprintf-js": "~1.0.2" + } + }, + "node_modules/solidity-coverage/node_modules/camelcase": { + "version": "5.3.1", + "resolved": "https://registry.npmjs.org/camelcase/-/camelcase-5.3.1.tgz", + "integrity": "sha512-L28STB170nwWS63UjtlEOE3dldQApaJXZkOI1uMFfzf3rRuPegHaHesyee+YxQ+W6SvRDQV6UrdOdRiR153wJg==", + "dev": true, + "peer": true, + "engines": { + "node": ">=6" + } + }, + "node_modules/solidity-coverage/node_modules/chokidar": { + "version": "3.3.0", + "resolved": "https://registry.npmjs.org/chokidar/-/chokidar-3.3.0.tgz", + "integrity": "sha512-dGmKLDdT3Gdl7fBUe8XK+gAtGmzy5Fn0XkkWQuYxGIgWVPPse2CxFA5mtrlD0TOHaHjEUqkWNyP1XdHoJES/4A==", + "dev": true, + "peer": true, + "dependencies": { + "anymatch": "~3.1.1", + "braces": "~3.0.2", + "glob-parent": "~5.1.0", + "is-binary-path": "~2.1.0", + "is-glob": "~4.0.1", + "normalize-path": "~3.0.0", + "readdirp": "~3.2.0" + }, + "engines": { + "node": ">= 8.10.0" + }, + "optionalDependencies": { + "fsevents": "~2.1.1" + } + }, + "node_modules/solidity-coverage/node_modules/cliui": { + "version": "5.0.0", + "resolved": "https://registry.npmjs.org/cliui/-/cliui-5.0.0.tgz", + "integrity": "sha512-PYeGSEmmHM6zvoef2w8TPzlrnNpXIjTipYK780YswmIP9vjxmd6Y2a3CB2Ks6/AU8NHjZugXvo8w3oWM2qnwXA==", + "dev": true, + "peer": true, + "dependencies": { + "string-width": "^3.1.0", + "strip-ansi": "^5.2.0", + "wrap-ansi": "^5.1.0" + } + }, + "node_modules/solidity-coverage/node_modules/debug": { + "version": "3.2.6", + "resolved": "https://registry.npmjs.org/debug/-/debug-3.2.6.tgz", + "integrity": "sha512-mel+jf7nrtEl5Pn1Qx46zARXKDpBbvzezse7p7LqINmdoIk8PYP5SySaxEmYv6TZ0JyEKA1hsCId6DIhgITtWQ==", + "deprecated": "Debug versions >=3.2.0 <3.2.7 || >=4 <4.3.1 have a low-severity ReDos regression when used in a Node.js environment. It is recommended you upgrade to 3.2.7 or 4.3.1. (https://github.com/visionmedia/debug/issues/797)", + "dev": true, + "peer": true, + "dependencies": { + "ms": "^2.1.1" + } + }, + "node_modules/solidity-coverage/node_modules/decamelize": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/decamelize/-/decamelize-1.2.0.tgz", + "integrity": "sha512-z2S+W9X73hAUUki+N+9Za2lBlun89zigOyGrsax+KUQ6wKW4ZoWpEYBkGhQjwAjjDCkWxhY0VKEhk8wzY7F5cA==", + "dev": true, + "peer": true, + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/solidity-coverage/node_modules/diff": { + "version": "3.5.0", + "resolved": "https://registry.npmjs.org/diff/-/diff-3.5.0.tgz", + "integrity": "sha512-A46qtFgd+g7pDZinpnwiRJtxbC1hpgf0uzP3iG89scHk0AUC7A1TGxf5OiiOUv/JMZR8GOt8hL900hV0bOy5xA==", + "dev": true, + "peer": true, + "engines": { + "node": ">=0.3.1" + } + }, + "node_modules/solidity-coverage/node_modules/emoji-regex": { + "version": "7.0.3", + "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-7.0.3.tgz", + "integrity": "sha512-CwBLREIQ7LvYFB0WyRvwhq5N5qPhc6PMjD6bYggFlI5YyDgl+0vxq5VHbMOFqLg7hfWzmu8T5Z1QofhmTIhItA==", + "dev": true, + "peer": true + }, + "node_modules/solidity-coverage/node_modules/esprima": { + "version": "4.0.1", + "resolved": "https://registry.npmjs.org/esprima/-/esprima-4.0.1.tgz", + "integrity": "sha512-eGuFFw7Upda+g4p+QHvnW0RyTX/SVeJBDM/gCtMARO0cLuT2HcEKnTPvhjV6aGeqrCB/sbNop0Kszm0jsaWU4A==", + "dev": true, + "peer": true, + "bin": { + "esparse": "bin/esparse.js", + "esvalidate": "bin/esvalidate.js" + }, + "engines": { + "node": ">=4" + } + }, + "node_modules/solidity-coverage/node_modules/find-up": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/find-up/-/find-up-3.0.0.tgz", + "integrity": "sha512-1yD6RmLI1XBfxugvORwlck6f75tYL+iR0jqwsOrOxMZyGYqUuDhJ0l4AXdO1iX/FTs9cBAMEk1gWSEx1kSbylg==", + "dev": true, + "peer": true, + "dependencies": { + "locate-path": "^3.0.0" + }, + "engines": { + "node": ">=6" + } + }, + "node_modules/solidity-coverage/node_modules/flat": { + "version": "4.1.1", + "resolved": "https://registry.npmjs.org/flat/-/flat-4.1.1.tgz", + "integrity": "sha512-FmTtBsHskrU6FJ2VxCnsDb84wu9zhmO3cUX2kGFb5tuwhfXxGciiT0oRY+cck35QmG+NmGh5eLz6lLCpWTqwpA==", + "dev": true, + "peer": true, + "dependencies": { + "is-buffer": "~2.0.3" + }, + "bin": { + "flat": "cli.js" + } + }, + "node_modules/solidity-coverage/node_modules/fs-extra": { + "version": "8.1.0", + "resolved": "https://registry.npmjs.org/fs-extra/-/fs-extra-8.1.0.tgz", + "integrity": "sha512-yhlQgA6mnOJUKOsRUFsgJdQCvkKhcz8tlZG5HBQfReYZy46OwLcY+Zia0mtdHsOo9y/hP+CxMN0TU9QxoOtG4g==", + "dev": true, + "peer": true, + "dependencies": { + "graceful-fs": "^4.2.0", + "jsonfile": "^4.0.0", + "universalify": "^0.1.0" + }, + "engines": { + "node": ">=6 <7 || >=8" + } + }, + "node_modules/solidity-coverage/node_modules/fsevents": { + "version": "2.1.3", + "resolved": "https://registry.npmjs.org/fsevents/-/fsevents-2.1.3.tgz", + "integrity": "sha512-Auw9a4AxqWpa9GUfj370BMPzzyncfBABW8Mab7BGWBYDj4Isgq+cDKtx0i6u9jcX9pQDnswsaaOTgTmA5pEjuQ==", + "deprecated": "\"Please update to latest v2.3 or v2.2\"", + "dev": true, + "hasInstallScript": true, + "optional": true, + "os": [ + "darwin" + ], + "peer": true, + "engines": { + "node": "^8.16.0 || ^10.6.0 || >=11.0.0" + } + }, + "node_modules/solidity-coverage/node_modules/glob": { + "version": "7.1.3", + "resolved": "https://registry.npmjs.org/glob/-/glob-7.1.3.tgz", + "integrity": "sha512-vcfuiIxogLV4DlGBHIUOwI0IbrJ8HWPc4MU7HzviGeNho/UJDfi6B5p3sHeWIQ0KGIU0Jpxi5ZHxemQfLkkAwQ==", + "dev": true, + "peer": true, + "dependencies": { + "fs.realpath": "^1.0.0", + "inflight": "^1.0.4", + "inherits": "2", + "minimatch": "^3.0.4", + "once": "^1.3.0", + "path-is-absolute": "^1.0.0" + }, + "engines": { + "node": "*" + } + }, + "node_modules/solidity-coverage/node_modules/is-fullwidth-code-point": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/is-fullwidth-code-point/-/is-fullwidth-code-point-2.0.0.tgz", + "integrity": "sha512-VHskAKYM8RfSFXwee5t5cbN5PZeq1Wrh6qd5bkyiXIf6UQcN6w/A0eXM9r6t8d+GYOh+o6ZhiEnb88LN/Y8m2w==", + "dev": true, + "peer": true, + "engines": { + "node": ">=4" + } + }, + "node_modules/solidity-coverage/node_modules/js-yaml": { + "version": "3.13.1", + "resolved": "https://registry.npmjs.org/js-yaml/-/js-yaml-3.13.1.tgz", + "integrity": "sha512-YfbcO7jXDdyj0DGxYVSlSeQNHbD7XPWvrVWeVUujrQEoZzWJIRrCPoyk6kL6IAjAG2IolMK4T0hNUe0HOUs5Jw==", + "dev": true, + "peer": true, + "dependencies": { + "argparse": "^1.0.7", + "esprima": "^4.0.0" + }, + "bin": { + "js-yaml": "bin/js-yaml.js" + } + }, + "node_modules/solidity-coverage/node_modules/locate-path": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/locate-path/-/locate-path-3.0.0.tgz", + "integrity": "sha512-7AO748wWnIhNqAuaty2ZWHkQHRSNfPVIsPIfwEOWO22AmaoVrWavlOcMR5nzTLNYvp36X220/maaRsrec1G65A==", + "dev": true, + "peer": true, + "dependencies": { + "p-locate": "^3.0.0", + "path-exists": "^3.0.0" + }, + "engines": { + "node": ">=6" + } + }, + "node_modules/solidity-coverage/node_modules/log-symbols": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/log-symbols/-/log-symbols-3.0.0.tgz", + "integrity": "sha512-dSkNGuI7iG3mfvDzUuYZyvk5dD9ocYCYzNU6CYDE6+Xqd+gwme6Z00NS3dUh8mq/73HaEtT7m6W+yUPtU6BZnQ==", + "dev": true, + "peer": true, + "dependencies": { + "chalk": "^2.4.2" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/solidity-coverage/node_modules/lru-cache": { + "version": "6.0.0", + "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-6.0.0.tgz", + "integrity": "sha512-Jo6dJ04CmSjuznwJSS3pUeWmd/H0ffTlkXXgwZi+eq1UCmqQwCh+eLsYOYCwY991i2Fah4h1BEMCx4qThGbsiA==", + "dev": true, + "peer": true, + "dependencies": { + "yallist": "^4.0.0" + }, + "engines": { + "node": ">=10" + } + }, + "node_modules/solidity-coverage/node_modules/minimatch": { + "version": "3.0.4", + "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.0.4.tgz", + "integrity": "sha512-yJHVQEhyqPLUTgt9B83PXu6W3rx4MvvHvSUvToogpwoGDOUQ+yDrR0HRot+yOCdCO7u4hX3pWft6kWBBcqh0UA==", + "dev": true, + "peer": true, + "dependencies": { + "brace-expansion": "^1.1.7" + }, + "engines": { + "node": "*" + } + }, + "node_modules/solidity-coverage/node_modules/mkdirp": { + "version": "0.5.5", + "resolved": "https://registry.npmjs.org/mkdirp/-/mkdirp-0.5.5.tgz", + "integrity": "sha512-NKmAlESf6jMGym1++R0Ra7wvhV+wFW63FaSOFPwRahvea0gMUcGUhVeAg/0BC0wiv9ih5NYPB1Wn1UEI1/L+xQ==", + "dev": true, + "peer": true, + "dependencies": { + "minimist": "^1.2.5" + }, + "bin": { + "mkdirp": "bin/cmd.js" + } + }, + "node_modules/solidity-coverage/node_modules/mocha": { + "version": "7.1.2", + "resolved": "https://registry.npmjs.org/mocha/-/mocha-7.1.2.tgz", + "integrity": "sha512-o96kdRKMKI3E8U0bjnfqW4QMk12MwZ4mhdBTf+B5a1q9+aq2HRnj+3ZdJu0B/ZhJeK78MgYuv6L8d/rA5AeBJA==", + "dev": true, + "peer": true, + "dependencies": { + "ansi-colors": "3.2.3", + "browser-stdout": "1.3.1", + "chokidar": "3.3.0", + "debug": "3.2.6", + "diff": "3.5.0", + "escape-string-regexp": "1.0.5", + "find-up": "3.0.0", + "glob": "7.1.3", + "growl": "1.10.5", + "he": "1.2.0", + "js-yaml": "3.13.1", + "log-symbols": "3.0.0", + "minimatch": "3.0.4", + "mkdirp": "0.5.5", + "ms": "2.1.1", + "node-environment-flags": "1.0.6", + "object.assign": "4.1.0", + "strip-json-comments": "2.0.1", + "supports-color": "6.0.0", + "which": "1.3.1", + "wide-align": "1.1.3", + "yargs": "13.3.2", + "yargs-parser": "13.1.2", + "yargs-unparser": "1.6.0" + }, + "bin": { + "_mocha": "bin/_mocha", + "mocha": "bin/mocha" + }, + "engines": { + "node": ">= 8.10.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/mochajs" + } + }, + "node_modules/solidity-coverage/node_modules/ms": { + "version": "2.1.1", + "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.1.tgz", + "integrity": "sha512-tgp+dl5cGk28utYktBsrFqA7HKgrhgPsg6Z/EfhWI4gl1Hwq8B/GmY/0oXZ6nF8hDVesS/FpnYaD/kOWhYQvyg==", + "dev": true, + "peer": true + }, + "node_modules/solidity-coverage/node_modules/p-limit": { + "version": "2.3.0", + "resolved": "https://registry.npmjs.org/p-limit/-/p-limit-2.3.0.tgz", + "integrity": "sha512-//88mFWSJx8lxCzwdAABTJL2MyWB12+eIY7MDL2SqLmAkeKU9qxRvWuSyTjm3FUmpBEMuFfckAIqEaVGUDxb6w==", + "dev": true, + "peer": true, + "dependencies": { + "p-try": "^2.0.0" + }, + "engines": { + "node": ">=6" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/solidity-coverage/node_modules/p-locate": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/p-locate/-/p-locate-3.0.0.tgz", + "integrity": "sha512-x+12w/To+4GFfgJhBEpiDcLozRJGegY+Ei7/z0tSLkMmxGZNybVMSfWj9aJn8Z5Fc7dBUNJOOVgPv2H7IwulSQ==", + "dev": true, + "peer": true, + "dependencies": { + "p-limit": "^2.0.0" + }, + "engines": { + "node": ">=6" + } + }, + "node_modules/solidity-coverage/node_modules/p-try": { + "version": "2.2.0", + "resolved": "https://registry.npmjs.org/p-try/-/p-try-2.2.0.tgz", + "integrity": "sha512-R4nPAVTAU0B9D35/Gk3uJf/7XYbQcyohSKdvAxIRSNghFl4e71hVoGnBNQz9cWaXxO2I10KTC+3jMdvvoKw6dQ==", + "dev": true, + "peer": true, + "engines": { + "node": ">=6" + } + }, + "node_modules/solidity-coverage/node_modules/readdirp": { + "version": "3.2.0", + "resolved": "https://registry.npmjs.org/readdirp/-/readdirp-3.2.0.tgz", + "integrity": "sha512-crk4Qu3pmXwgxdSgGhgA/eXiJAPQiX4GMOZZMXnqKxHX7TaoL+3gQVo/WeuAiogr07DpnfjIMpXXa+PAIvwPGQ==", + "dev": true, + "peer": true, + "dependencies": { + "picomatch": "^2.0.4" + }, + "engines": { + "node": ">= 8" + } + }, + "node_modules/solidity-coverage/node_modules/semver": { + "version": "7.5.0", + "resolved": "https://registry.npmjs.org/semver/-/semver-7.5.0.tgz", + "integrity": "sha512-+XC0AD/R7Q2mPSRuy2Id0+CGTZ98+8f+KvwirxOKIEyid+XSx6HbC63p+O4IndTHuX5Z+JxQ0TghCkO5Cg/2HA==", + "dev": true, + "peer": true, + "dependencies": { + "lru-cache": "^6.0.0" + }, + "bin": { + "semver": "bin/semver.js" + }, + "engines": { + "node": ">=10" + } + }, + "node_modules/solidity-coverage/node_modules/string-width": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/string-width/-/string-width-3.1.0.tgz", + "integrity": "sha512-vafcv6KjVZKSgz06oM/H6GDBrAtz8vdhQakGjFIvNrHA6y3HCF1CInLy+QLq8dTJPQ1b+KDUqDFctkdRW44e1w==", + "dev": true, + "peer": true, + "dependencies": { + "emoji-regex": "^7.0.1", + "is-fullwidth-code-point": "^2.0.0", + "strip-ansi": "^5.1.0" + }, + "engines": { + "node": ">=6" + } + }, + "node_modules/solidity-coverage/node_modules/strip-ansi": { + "version": "5.2.0", + "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-5.2.0.tgz", + "integrity": "sha512-DuRs1gKbBqsMKIZlrffwlug8MHkcnpjs5VPmL1PAh+mA30U0DTotfDZ0d2UUsXpPmPmMMJ6W773MaA3J+lbiWA==", + "dev": true, + "peer": true, + "dependencies": { + "ansi-regex": "^4.1.0" + }, + "engines": { + "node": ">=6" + } + }, + "node_modules/solidity-coverage/node_modules/strip-json-comments": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/strip-json-comments/-/strip-json-comments-2.0.1.tgz", + "integrity": "sha512-4gB8na07fecVVkOI6Rs4e7T6NOTki5EmL7TUduTs6bu3EdnSycntVJ4re8kgZA+wx9IueI2Y11bfbgwtzuE0KQ==", + "dev": true, + "peer": true, + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/solidity-coverage/node_modules/supports-color": { + "version": "6.0.0", + "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-6.0.0.tgz", + "integrity": "sha512-on9Kwidc1IUQo+bQdhi8+Tijpo0e1SS6RoGo2guUwn5vdaxw8RXOF9Vb2ws+ihWOmh4JnCJOvaziZWP1VABaLg==", + "dev": true, + "peer": true, + "dependencies": { + "has-flag": "^3.0.0" + }, + "engines": { + "node": ">=6" + } + }, + "node_modules/solidity-coverage/node_modules/wrap-ansi": { + "version": "5.1.0", + "resolved": "https://registry.npmjs.org/wrap-ansi/-/wrap-ansi-5.1.0.tgz", + "integrity": "sha512-QC1/iN/2/RPVJ5jYK8BGttj5z83LmSKmvbvrXPNCLZSEb32KKVDJDl/MOt2N01qU2H/FkzEa9PKto1BqDjtd7Q==", + "dev": true, + "peer": true, + "dependencies": { + "ansi-styles": "^3.2.0", + "string-width": "^3.0.0", + "strip-ansi": "^5.0.0" + }, + "engines": { + "node": ">=6" + } + }, + "node_modules/solidity-coverage/node_modules/y18n": { + "version": "4.0.3", + "resolved": "https://registry.npmjs.org/y18n/-/y18n-4.0.3.tgz", + "integrity": "sha512-JKhqTOwSrqNA1NY5lSztJ1GrBiUodLMmIZuLiDaMRJ+itFd+ABVE8XBjOvIWL+rSqNDC74LCSFmlb/U4UZ4hJQ==", + "dev": true, + "peer": true + }, + "node_modules/solidity-coverage/node_modules/yallist": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/yallist/-/yallist-4.0.0.tgz", + "integrity": "sha512-3wdGidZyq5PB084XLES5TpOSRA3wjXAlIWMhum2kRcv/41Sn2emQ0dycQW4uZXLejwKvg6EsvbdlVL+FYEct7A==", + "dev": true, + "peer": true + }, + "node_modules/solidity-coverage/node_modules/yargs": { + "version": "13.3.2", + "resolved": "https://registry.npmjs.org/yargs/-/yargs-13.3.2.tgz", + "integrity": "sha512-AX3Zw5iPruN5ie6xGRIDgqkT+ZhnRlZMLMHAs8tg7nRruy2Nb+i5o9bwghAogtM08q1dpr2LVoS8KSTMYpWXUw==", + "dev": true, + "peer": true, + "dependencies": { + "cliui": "^5.0.0", + "find-up": "^3.0.0", + "get-caller-file": "^2.0.1", + "require-directory": "^2.1.1", + "require-main-filename": "^2.0.0", + "set-blocking": "^2.0.0", + "string-width": "^3.0.0", + "which-module": "^2.0.0", + "y18n": "^4.0.0", + "yargs-parser": "^13.1.2" + } + }, + "node_modules/solidity-coverage/node_modules/yargs-parser": { + "version": "13.1.2", + "resolved": "https://registry.npmjs.org/yargs-parser/-/yargs-parser-13.1.2.tgz", + "integrity": "sha512-3lbsNRf/j+A4QuSZfDRA7HRSfWrzO0YjqTJd5kjAq37Zep1CEgaYmrH9Q3GwPiB9cHyd1Y1UwggGhJGoxipbzg==", + "dev": true, + "peer": true, + "dependencies": { + "camelcase": "^5.0.0", + "decamelize": "^1.2.0" + } + }, + "node_modules/solidity-coverage/node_modules/yargs-unparser": { + "version": "1.6.0", + "resolved": "https://registry.npmjs.org/yargs-unparser/-/yargs-unparser-1.6.0.tgz", + "integrity": "sha512-W9tKgmSn0DpSatfri0nx52Joq5hVXgeLiqR/5G0sZNDoLZFOr/xjBUDcShCOGNsBnEMNo1KAMBkTej1Hm62HTw==", + "dev": true, + "peer": true, + "dependencies": { + "flat": "^4.1.0", + "lodash": "^4.17.15", + "yargs": "^13.3.0" + }, + "engines": { + "node": ">=6" + } + }, + "node_modules/source-map": { + "version": "0.6.1", + "resolved": "https://registry.npmjs.org/source-map/-/source-map-0.6.1.tgz", + "integrity": "sha512-UjgapumWlbMhkBgzT7Ykc5YXUT46F0iKu8SGXq0bcwP5dz/h0Plj6enJqjz1Zbq2l5WaqYnrVbwWOWMyF3F47g==", + "dev": true, + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/source-map-support": { + "version": "0.5.21", + "resolved": "https://registry.npmjs.org/source-map-support/-/source-map-support-0.5.21.tgz", + "integrity": "sha512-uBHU3L3czsIyYXKX88fdrGovxdSCoTGDRZ6SYXtSRxLZUzHg5P/66Ht6uoUlHu9EZod+inXhKo3qQgwXUT/y1w==", + "dev": true, + "dependencies": { + "buffer-from": "^1.0.0", + "source-map": "^0.6.0" + } + }, + "node_modules/sprintf-js": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/sprintf-js/-/sprintf-js-1.0.3.tgz", + "integrity": "sha512-D9cPgkvLlV3t3IzL0D0YLvGA9Ahk4PcvVwUbN0dSGr1aP0Nrt4AEnTUbuGvquEC0mA64Gqt1fzirlRs5ibXx8g==", + "dev": true, + "peer": true + }, + "node_modules/sshpk": { + "version": "1.17.0", + "resolved": "https://registry.npmjs.org/sshpk/-/sshpk-1.17.0.tgz", + "integrity": "sha512-/9HIEs1ZXGhSPE8X6Ccm7Nam1z8KcoCqPdI7ecm1N33EzAetWahvQWVqLZtaZQ+IDKX4IyA2o0gBzqIMkAagHQ==", + "dev": true, + "peer": true, + "dependencies": { + "asn1": "~0.2.3", + "assert-plus": "^1.0.0", + "bcrypt-pbkdf": "^1.0.0", + "dashdash": "^1.12.0", + "ecc-jsbn": "~0.1.1", + "getpass": "^0.1.1", + "jsbn": "~0.1.0", + "safer-buffer": "^2.0.2", + "tweetnacl": "~0.14.0" + }, + "bin": { + "sshpk-conv": "bin/sshpk-conv", + "sshpk-sign": "bin/sshpk-sign", + "sshpk-verify": "bin/sshpk-verify" + }, + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/sshpk/node_modules/tweetnacl": { + "version": "0.14.5", + "resolved": "https://registry.npmjs.org/tweetnacl/-/tweetnacl-0.14.5.tgz", + "integrity": "sha512-KXXFFdAbFXY4geFIwoyNK+f5Z1b7swfXABfL7HXCmoIWMKU3dmS26672A4EeQtDzLKy7SXmfBu51JolvEKwtGA==", + "dev": true, + "peer": true + }, + "node_modules/stacktrace-parser": { + "version": "0.1.10", + "resolved": "https://registry.npmjs.org/stacktrace-parser/-/stacktrace-parser-0.1.10.tgz", + "integrity": "sha512-KJP1OCML99+8fhOHxwwzyWrlUuVX5GQ0ZpJTd1DFXhdkrvg1szxfHhawXUZ3g9TkXORQd4/WG68jMlQZ2p8wlg==", + "dev": true, + "dependencies": { + "type-fest": "^0.7.1" + }, + "engines": { + "node": ">=6" + } + }, + "node_modules/stacktrace-parser/node_modules/type-fest": { + "version": "0.7.1", + "resolved": "https://registry.npmjs.org/type-fest/-/type-fest-0.7.1.tgz", + "integrity": "sha512-Ne2YiiGN8bmrmJJEuTWTLJR32nh/JdL1+PSicowtNb0WFpn59GK8/lfD61bVtzguz7b3PBt74nxpv/Pw5po5Rg==", + "dev": true, + "engines": { + "node": ">=8" + } + }, + "node_modules/statuses": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/statuses/-/statuses-2.0.1.tgz", + "integrity": "sha512-RwNA9Z/7PrK06rYLIzFMlaF+l73iwpzsqRIFgbMLbTcLD6cOao82TaWefPXQvB2fOC4AjuYSEndS7N/mTCbkdQ==", + "dev": true, + "engines": { + "node": ">= 0.8" + } + }, + "node_modules/stealthy-require": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/stealthy-require/-/stealthy-require-1.1.1.tgz", + "integrity": "sha512-ZnWpYnYugiOVEY5GkcuJK1io5V8QmNYChG62gSit9pQVGErXtrKuPC55ITaVSukmMta5qpMU7vqLt2Lnni4f/g==", + "dev": true, + "peer": true, + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/streamsearch": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/streamsearch/-/streamsearch-1.1.0.tgz", + "integrity": "sha512-Mcc5wHehp9aXz1ax6bZUyY5afg9u2rv5cqQI3mRrYkGC8rW2hM02jWuwjtL++LS5qinSyhj2QfLyNsuc+VsExg==", + "dev": true, + "engines": { + "node": ">=10.0.0" + } + }, + "node_modules/string_decoder": { + "version": "1.3.0", + "resolved": "https://registry.npmjs.org/string_decoder/-/string_decoder-1.3.0.tgz", + "integrity": "sha512-hkRX8U1WjJFd8LsDJ2yQ/wWWxaopEsABU1XfkM8A+j0+85JAGppt16cr1Whg6KIbb4okU6Mql6BOj+uup/wKeA==", + "dev": true, + "dependencies": { + "safe-buffer": "~5.2.0" + } + }, + "node_modules/string_decoder/node_modules/safe-buffer": { + "version": "5.2.1", + "resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.2.1.tgz", + "integrity": "sha512-rp3So07KcdmmKbGvgaNxQSJr7bGVSVk5S9Eq1F+ppbRo70+YeaDxkw5Dd8NPN+GD6bjnYm2VuPuCXmpuYvmCXQ==", + "dev": true, + "funding": [ + { + "type": "github", + "url": "https://github.com/sponsors/feross" + }, + { + "type": "patreon", + "url": "https://www.patreon.com/feross" + }, + { + "type": "consulting", + "url": "https://feross.org/support" + } + ] + }, + "node_modules/string-format": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/string-format/-/string-format-2.0.0.tgz", + "integrity": "sha512-bbEs3scLeYNXLecRRuk6uJxdXUSj6le/8rNPHChIJTn2V79aXVTR1EH2OH5zLKKoz0V02fOUKZZcw01pLUShZA==", + "dev": true, + "peer": true + }, + "node_modules/string-width": { + "version": "4.2.3", + "resolved": "https://registry.npmjs.org/string-width/-/string-width-4.2.3.tgz", + "integrity": "sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g==", + "dev": true, + "dependencies": { + "emoji-regex": "^8.0.0", + "is-fullwidth-code-point": "^3.0.0", + "strip-ansi": "^6.0.1" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/string.prototype.trim": { + "version": "1.2.7", + "resolved": "https://registry.npmjs.org/string.prototype.trim/-/string.prototype.trim-1.2.7.tgz", + "integrity": "sha512-p6TmeT1T3411M8Cgg9wBTMRtY2q9+PNy9EV1i2lIXUN/btt763oIfxwN3RR8VU6wHX8j/1CFy0L+YuThm6bgOg==", + "dev": true, + "peer": true, + "dependencies": { + "call-bind": "^1.0.2", + "define-properties": "^1.1.4", + "es-abstract": "^1.20.4" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/string.prototype.trimend": { + "version": "1.0.6", + "resolved": "https://registry.npmjs.org/string.prototype.trimend/-/string.prototype.trimend-1.0.6.tgz", + "integrity": "sha512-JySq+4mrPf9EsDBEDYMOb/lM7XQLulwg5R/m1r0PXEFqrV0qHvl58sdTilSXtKOflCsK2E8jxf+GKC0T07RWwQ==", + "dev": true, + "peer": true, + "dependencies": { + "call-bind": "^1.0.2", + "define-properties": "^1.1.4", + "es-abstract": "^1.20.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/string.prototype.trimstart": { + "version": "1.0.6", + "resolved": "https://registry.npmjs.org/string.prototype.trimstart/-/string.prototype.trimstart-1.0.6.tgz", + "integrity": "sha512-omqjMDaY92pbn5HOX7f9IccLA+U1tA9GvtU4JrodiXFfYB7jPzzHpRzpglLAjtUV6bB557zwClJezTqnAiYnQA==", + "dev": true, + "peer": true, + "dependencies": { + "call-bind": "^1.0.2", + "define-properties": "^1.1.4", + "es-abstract": "^1.20.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/strip-ansi": { + "version": "6.0.1", + "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-6.0.1.tgz", + "integrity": "sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A==", + "dev": true, + "dependencies": { + "ansi-regex": "^5.0.1" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/strip-hex-prefix": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/strip-hex-prefix/-/strip-hex-prefix-1.0.0.tgz", + "integrity": "sha512-q8d4ue7JGEiVcypji1bALTos+0pWtyGlivAWyPuTkHzuTCJqrK9sWxYQZUq6Nq3cuyv3bm734IhHvHtGGURU6A==", + "dev": true, + "dependencies": { + "is-hex-prefixed": "1.0.0" + }, + "engines": { + "node": ">=6.5.0", + "npm": ">=3" + } + }, + "node_modules/strip-json-comments": { + "version": "3.1.1", + "resolved": "https://registry.npmjs.org/strip-json-comments/-/strip-json-comments-3.1.1.tgz", + "integrity": "sha512-6fPc+R4ihwqP6N/aIv2f1gMH8lOVtWQHoqC4yK6oSDVVocumAsfCqjkXnqiYMhmMwS/mEHLp7Vehlt3ql6lEig==", + "dev": true, + "engines": { + "node": ">=8" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/supports-color": { + "version": "5.5.0", + "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-5.5.0.tgz", + "integrity": "sha512-QjVjwdXIt408MIiAqCX4oUKsgU2EqAGzs2Ppkm4aQYbjm+ZEWEcW4SfFNTr4uMNZma0ey4f5lgLrkB0aX0QMow==", + "dev": true, + "dependencies": { + "has-flag": "^3.0.0" + }, + "engines": { + "node": ">=4" + } + }, + "node_modules/sync-request": { + "version": "6.1.0", + "resolved": "https://registry.npmjs.org/sync-request/-/sync-request-6.1.0.tgz", + "integrity": "sha512-8fjNkrNlNCrVc/av+Jn+xxqfCjYaBoHqCsDz6mt030UMxJGr+GSfCV1dQt2gRtlL63+VPidwDVLr7V2OcTSdRw==", + "dev": true, + "peer": true, + "dependencies": { + "http-response-object": "^3.0.1", + "sync-rpc": "^1.2.1", + "then-request": "^6.0.0" + }, + "engines": { + "node": ">=8.0.0" + } + }, + "node_modules/sync-rpc": { + "version": "1.3.6", + "resolved": "https://registry.npmjs.org/sync-rpc/-/sync-rpc-1.3.6.tgz", + "integrity": "sha512-J8jTXuZzRlvU7HemDgHi3pGnh/rkoqR/OZSjhTyyZrEkkYQbk7Z33AXp37mkPfPpfdOuj7Ex3H/TJM1z48uPQw==", + "dev": true, + "peer": true, + "dependencies": { + "get-port": "^3.1.0" + } + }, + "node_modules/table": { + "version": "6.8.1", + "resolved": "https://registry.npmjs.org/table/-/table-6.8.1.tgz", + "integrity": "sha512-Y4X9zqrCftUhMeH2EptSSERdVKt/nEdijTOacGD/97EKjhQ/Qs8RTlEGABSJNNN8lac9kheH+af7yAkEWlgneA==", + "dev": true, + "peer": true, + "dependencies": { + "ajv": "^8.0.1", + "lodash.truncate": "^4.4.2", + "slice-ansi": "^4.0.0", + "string-width": "^4.2.3", + "strip-ansi": "^6.0.1" + }, + "engines": { + "node": ">=10.0.0" + } + }, + "node_modules/table-layout": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/table-layout/-/table-layout-1.0.2.tgz", + "integrity": "sha512-qd/R7n5rQTRFi+Zf2sk5XVVd9UQl6ZkduPFC3S7WEGJAmetDTjY3qPN50eSKzwuzEyQKy5TN2TiZdkIjos2L6A==", + "dev": true, + "peer": true, + "dependencies": { + "array-back": "^4.0.1", + "deep-extend": "~0.6.0", + "typical": "^5.2.0", + "wordwrapjs": "^4.0.0" + }, + "engines": { + "node": ">=8.0.0" + } + }, + "node_modules/table-layout/node_modules/array-back": { + "version": "4.0.2", + "resolved": "https://registry.npmjs.org/array-back/-/array-back-4.0.2.tgz", + "integrity": "sha512-NbdMezxqf94cnNfWLL7V/im0Ub+Anbb0IoZhvzie8+4HJ4nMQuzHuy49FkGYCJK2yAloZ3meiB6AVMClbrI1vg==", + "dev": true, + "peer": true, + "engines": { + "node": ">=8" + } + }, + "node_modules/table-layout/node_modules/typical": { + "version": "5.2.0", + "resolved": "https://registry.npmjs.org/typical/-/typical-5.2.0.tgz", + "integrity": "sha512-dvdQgNDNJo+8B2uBQoqdb11eUCE1JQXhvjC/CZtgvZseVd5TYMXnq0+vuUemXbd/Se29cTaUuPX3YIc2xgbvIg==", + "dev": true, + "peer": true, + "engines": { + "node": ">=8" + } + }, + "node_modules/table/node_modules/ajv": { + "version": "8.12.0", + "resolved": "https://registry.npmjs.org/ajv/-/ajv-8.12.0.tgz", + "integrity": "sha512-sRu1kpcO9yLtYxBKvqfTeh9KzZEwO3STyX1HT+4CaDzC6HpTGYhIhPIzj9XuKU7KYDwnaeh5hcOwjy1QuJzBPA==", + "dev": true, + "peer": true, + "dependencies": { + "fast-deep-equal": "^3.1.1", + "json-schema-traverse": "^1.0.0", + "require-from-string": "^2.0.2", + "uri-js": "^4.2.2" + }, + "funding": { + "type": "github", + "url": "https://github.com/sponsors/epoberezkin" + } + }, + "node_modules/table/node_modules/json-schema-traverse": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/json-schema-traverse/-/json-schema-traverse-1.0.0.tgz", + "integrity": "sha512-NM8/P9n3XjXhIZn1lLhkFaACTOURQXjWhV4BA/RnOv8xvgqtqpAX9IO4mRQxSx1Rlo4tqzeqb0sOlruaOy3dug==", + "dev": true, + "peer": true + }, + "node_modules/then-request": { + "version": "6.0.2", + "resolved": "https://registry.npmjs.org/then-request/-/then-request-6.0.2.tgz", + "integrity": "sha512-3ZBiG7JvP3wbDzA9iNY5zJQcHL4jn/0BWtXIkagfz7QgOL/LqjCEOBQuJNZfu0XYnv5JhKh+cDxCPM4ILrqruA==", + "dev": true, + "peer": true, + "dependencies": { + "@types/concat-stream": "^1.6.0", + "@types/form-data": "0.0.33", + "@types/node": "^8.0.0", + "@types/qs": "^6.2.31", + "caseless": "~0.12.0", + "concat-stream": "^1.6.0", + "form-data": "^2.2.0", + "http-basic": "^8.1.1", + "http-response-object": "^3.0.1", + "promise": "^8.0.0", + "qs": "^6.4.0" + }, + "engines": { + "node": ">=6.0.0" + } + }, + "node_modules/then-request/node_modules/@types/node": { + "version": "8.10.66", + "resolved": "https://registry.npmjs.org/@types/node/-/node-8.10.66.tgz", + "integrity": "sha512-tktOkFUA4kXx2hhhrB8bIFb5TbwzS4uOhKEmwiD+NoiL0qtP2OQ9mFldbgD4dV1djrlBYP6eBuQZiWjuHUpqFw==", + "dev": true, + "peer": true + }, + "node_modules/tmp": { + "version": "0.0.33", + "resolved": "https://registry.npmjs.org/tmp/-/tmp-0.0.33.tgz", + "integrity": "sha512-jRCJlojKnZ3addtTOjdIqoRuPEKBvNXcGYqzO6zWZX8KfKEpnGY5jfggJQ3EjKuu8D4bJRr0y+cYJFmYbImXGw==", + "dev": true, + "dependencies": { + "os-tmpdir": "~1.0.2" + }, + "engines": { + "node": ">=0.6.0" + } + }, + "node_modules/to-regex-range": { + "version": "5.0.1", + "resolved": "https://registry.npmjs.org/to-regex-range/-/to-regex-range-5.0.1.tgz", + "integrity": "sha512-65P7iz6X5yEr1cwcgvQxbbIw7Uk3gOy5dIdtZ4rDveLqhrdJP+Li/Hx6tyK0NEb+2GCyneCMJiGqrADCSNk8sQ==", + "dev": true, + "dependencies": { + "is-number": "^7.0.0" + }, + "engines": { + "node": ">=8.0" + } + }, + "node_modules/toidentifier": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/toidentifier/-/toidentifier-1.0.1.tgz", + "integrity": "sha512-o5sSPKEkg/DIQNmH43V0/uerLrpzVedkUh8tGNvaeXpfpuwjKenlSox/2O/BTlZUtEe+JG7s5YhEz608PlAHRA==", + "dev": true, + "engines": { + "node": ">=0.6" + } + }, + "node_modules/tough-cookie": { + "version": "2.5.0", + "resolved": "https://registry.npmjs.org/tough-cookie/-/tough-cookie-2.5.0.tgz", + "integrity": "sha512-nlLsUzgm1kfLXSXfRZMc1KLAugd4hqJHDTvc2hDIwS3mZAfMEuMbc03SujMF+GEcpaX/qboeycw6iO8JwVv2+g==", + "dev": true, + "peer": true, + "dependencies": { + "psl": "^1.1.28", + "punycode": "^2.1.1" + }, + "engines": { + "node": ">=0.8" + } + }, + "node_modules/ts-command-line-args": { + "version": "2.5.0", + "resolved": "https://registry.npmjs.org/ts-command-line-args/-/ts-command-line-args-2.5.0.tgz", + "integrity": "sha512-Ff7Xt04WWCjj/cmPO9eWTJX3qpBZWuPWyQYG1vnxJao+alWWYjwJBc5aYz3h5p5dE08A6AnpkgiCtP/0KXXBYw==", + "dev": true, + "peer": true, + "dependencies": { + "@morgan-stanley/ts-mocking-bird": "^0.6.2", + "chalk": "^4.1.0", + "command-line-args": "^5.1.1", + "command-line-usage": "^6.1.0", + "string-format": "^2.0.0" + }, + "bin": { + "write-markdown": "dist/write-markdown.js" + } + }, + "node_modules/ts-command-line-args/node_modules/ansi-styles": { + "version": "4.3.0", + "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-4.3.0.tgz", + "integrity": "sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==", + "dev": true, + "peer": true, + "dependencies": { + "color-convert": "^2.0.1" + }, + "engines": { + "node": ">=8" + }, + "funding": { + "url": "https://github.com/chalk/ansi-styles?sponsor=1" + } + }, + "node_modules/ts-command-line-args/node_modules/chalk": { + "version": "4.1.2", + "resolved": "https://registry.npmjs.org/chalk/-/chalk-4.1.2.tgz", + "integrity": "sha512-oKnbhFyRIXpUuez8iBMmyEa4nbj4IOQyuhc/wy9kY7/WVPcwIO9VA668Pu8RkO7+0G76SLROeyw9CpQ061i4mA==", + "dev": true, + "peer": true, + "dependencies": { + "ansi-styles": "^4.1.0", + "supports-color": "^7.1.0" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/chalk/chalk?sponsor=1" + } + }, + "node_modules/ts-command-line-args/node_modules/color-convert": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-2.0.1.tgz", + "integrity": "sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ==", + "dev": true, + "peer": true, + "dependencies": { + "color-name": "~1.1.4" + }, + "engines": { + "node": ">=7.0.0" + } + }, + "node_modules/ts-command-line-args/node_modules/color-name": { + "version": "1.1.4", + "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.4.tgz", + "integrity": "sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA==", + "dev": true, + "peer": true + }, + "node_modules/ts-command-line-args/node_modules/has-flag": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-4.0.0.tgz", + "integrity": "sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ==", + "dev": true, + "peer": true, + "engines": { + "node": ">=8" + } + }, + "node_modules/ts-command-line-args/node_modules/supports-color": { + "version": "7.2.0", + "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-7.2.0.tgz", + "integrity": "sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw==", + "dev": true, + "peer": true, + "dependencies": { + "has-flag": "^4.0.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/ts-essentials": { + "version": "7.0.3", + "resolved": "https://registry.npmjs.org/ts-essentials/-/ts-essentials-7.0.3.tgz", + "integrity": "sha512-8+gr5+lqO3G84KdiTSMRLtuyJ+nTBVRKuCrK4lidMPdVeEp0uqC875uE5NMcaA7YYMN7XsNiFQuMvasF8HT/xQ==", + "dev": true, + "peer": true, + "peerDependencies": { + "typescript": ">=3.7.0" + } + }, + "node_modules/ts-node": { + "version": "10.9.1", + "resolved": "https://registry.npmjs.org/ts-node/-/ts-node-10.9.1.tgz", + "integrity": "sha512-NtVysVPkxxrwFGUUxGYhfux8k78pQB3JqYBXlLRZgdGUqTO5wU/UyHop5p70iEbGhB7q5KmiZiU0Y3KlJrScEw==", + "dev": true, + "peer": true, + "dependencies": { + "@cspotcode/source-map-support": "^0.8.0", + "@tsconfig/node10": "^1.0.7", + "@tsconfig/node12": "^1.0.7", + "@tsconfig/node14": "^1.0.0", + "@tsconfig/node16": "^1.0.2", + "acorn": "^8.4.1", + "acorn-walk": "^8.1.1", + "arg": "^4.1.0", + "create-require": "^1.1.0", + "diff": "^4.0.1", + "make-error": "^1.1.1", + "v8-compile-cache-lib": "^3.0.1", + "yn": "3.1.1" + }, + "bin": { + "ts-node": "dist/bin.js", + "ts-node-cwd": "dist/bin-cwd.js", + "ts-node-esm": "dist/bin-esm.js", + "ts-node-script": "dist/bin-script.js", + "ts-node-transpile-only": "dist/bin-transpile.js", + "ts-script": "dist/bin-script-deprecated.js" + }, + "peerDependencies": { + "@swc/core": ">=1.2.50", + "@swc/wasm": ">=1.2.50", + "@types/node": "*", + "typescript": ">=2.7" + }, + "peerDependenciesMeta": { + "@swc/core": { + "optional": true + }, + "@swc/wasm": { + "optional": true + } + } + }, + "node_modules/ts-node/node_modules/diff": { + "version": "4.0.2", + "resolved": "https://registry.npmjs.org/diff/-/diff-4.0.2.tgz", + "integrity": "sha512-58lmxKSA4BNyLz+HHMUzlOEpg09FV+ev6ZMe3vJihgdxzgcwZ8VoEEPmALCZG9LmqfVoNMMKpttIYTVG6uDY7A==", + "dev": true, + "peer": true, + "engines": { + "node": ">=0.3.1" + } + }, + "node_modules/tslib": { + "version": "1.14.1", + "resolved": "https://registry.npmjs.org/tslib/-/tslib-1.14.1.tgz", + "integrity": "sha512-Xni35NKzjgMrwevysHTCArtLDpPvye8zV/0E4EyYn43P7/7qvQwPh9BGkHewbMulVntbigmcT7rdX3BNo9wRJg==", + "dev": true + }, + "node_modules/tsort": { + "version": "0.0.1", + "resolved": "https://registry.npmjs.org/tsort/-/tsort-0.0.1.tgz", + "integrity": "sha512-Tyrf5mxF8Ofs1tNoxA13lFeZ2Zrbd6cKbuH3V+MQ5sb6DtBj5FjrXVsRWT8YvNAQTqNoz66dz1WsbigI22aEnw==", + "dev": true + }, + "node_modules/tunnel-agent": { + "version": "0.6.0", + "resolved": "https://registry.npmjs.org/tunnel-agent/-/tunnel-agent-0.6.0.tgz", + "integrity": "sha512-McnNiV1l8RYeY8tBgEpuodCC1mLUdbSN+CYBL7kJsJNInOP8UjDDEwdk6Mw60vdLLrr5NHKZhMAOSrR2NZuQ+w==", + "dev": true, + "peer": true, + "dependencies": { + "safe-buffer": "^5.0.1" + }, + "engines": { + "node": "*" + } + }, + "node_modules/tweetnacl": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/tweetnacl/-/tweetnacl-1.0.3.tgz", + "integrity": "sha512-6rt+RN7aOi1nGMyC4Xa5DdYiukl2UWCbcJft7YhxReBGQD7OAM8Pbxw6YMo4r2diNEA8FEmu32YOn9rhaiE5yw==", + "dev": true + }, + "node_modules/tweetnacl-util": { + "version": "0.15.1", + "resolved": "https://registry.npmjs.org/tweetnacl-util/-/tweetnacl-util-0.15.1.tgz", + "integrity": "sha512-RKJBIj8lySrShN4w6i/BonWp2Z/uxwC3h4y7xsRrpP59ZboCd0GpEVsOnMDYLMmKBpYhb5TgHzZXy7wTfYFBRw==", + "dev": true + }, + "node_modules/type-check": { + "version": "0.3.2", + "resolved": "https://registry.npmjs.org/type-check/-/type-check-0.3.2.tgz", + "integrity": "sha512-ZCmOJdvOWDBYJlzAoFkC+Q0+bUyEOS1ltgp1MGU03fqHG+dbi9tBFU2Rd9QKiDZFAYrhPh2JUf7rZRIuHRKtOg==", + "dev": true, + "peer": true, + "dependencies": { + "prelude-ls": "~1.1.2" + }, + "engines": { + "node": ">= 0.8.0" + } + }, + "node_modules/type-detect": { + "version": "4.0.8", + "resolved": "https://registry.npmjs.org/type-detect/-/type-detect-4.0.8.tgz", + "integrity": "sha512-0fr/mIH1dlO+x7TlcMy+bIDqKPsw/70tVyeHW787goQjhmqaZe10uwLujubK9q9Lg6Fiho1KUKDYz0Z7k7g5/g==", + "dev": true, + "peer": true, + "engines": { + "node": ">=4" + } + }, + "node_modules/type-fest": { + "version": "0.21.3", + "resolved": "https://registry.npmjs.org/type-fest/-/type-fest-0.21.3.tgz", + "integrity": "sha512-t0rzBq87m3fVcduHDUFhKmyyX+9eo6WQjZvf51Ea/M0Q7+T374Jp1aUiyUl0GKxp8M/OETVHSDvmkyPgvX+X2w==", + "dev": true, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/typechain": { + "version": "8.1.1", + "resolved": "https://registry.npmjs.org/typechain/-/typechain-8.1.1.tgz", + "integrity": "sha512-uF/sUvnXTOVF2FHKhQYnxHk4su4JjZR8vr4mA2mBaRwHTbwh0jIlqARz9XJr1tA0l7afJGvEa1dTSi4zt039LQ==", + "dev": true, + "peer": true, + "dependencies": { + "@types/prettier": "^2.1.1", + "debug": "^4.3.1", + "fs-extra": "^7.0.0", + "glob": "7.1.7", + "js-sha3": "^0.8.0", + "lodash": "^4.17.15", + "mkdirp": "^1.0.4", + "prettier": "^2.3.1", + "ts-command-line-args": "^2.2.0", + "ts-essentials": "^7.0.1" + }, + "bin": { + "typechain": "dist/cli/cli.js" + }, + "peerDependencies": { + "typescript": ">=4.3.0" + } + }, + "node_modules/typechain/node_modules/glob": { + "version": "7.1.7", + "resolved": "https://registry.npmjs.org/glob/-/glob-7.1.7.tgz", + "integrity": "sha512-OvD9ENzPLbegENnYP5UUfJIirTg4+XwMWGaQfQTY0JenxNvvIKP3U3/tAQSPIu/lHxXYSZmpXlUHeqAIdKzBLQ==", + "dev": true, + "peer": true, + "dependencies": { + "fs.realpath": "^1.0.0", + "inflight": "^1.0.4", + "inherits": "2", + "minimatch": "^3.0.4", + "once": "^1.3.0", + "path-is-absolute": "^1.0.0" + }, + "engines": { + "node": "*" + }, + "funding": { + "url": "https://github.com/sponsors/isaacs" + } + }, + "node_modules/typechain/node_modules/mkdirp": { + "version": "1.0.4", + "resolved": "https://registry.npmjs.org/mkdirp/-/mkdirp-1.0.4.tgz", + "integrity": "sha512-vVqVZQyf3WLx2Shd0qJ9xuvqgAyKPLAiqITEtqW0oIUjzo3PePDd6fW9iFz30ef7Ysp/oiWqbhszeGWW2T6Gzw==", + "dev": true, + "peer": true, + "bin": { + "mkdirp": "bin/cmd.js" + }, + "engines": { + "node": ">=10" + } + }, + "node_modules/typed-array-length": { + "version": "1.0.4", + "resolved": "https://registry.npmjs.org/typed-array-length/-/typed-array-length-1.0.4.tgz", + "integrity": "sha512-KjZypGq+I/H7HI5HlOoGHkWUUGq+Q0TPhQurLbyrVrvnKTBgzLhIJ7j6J/XTQOi0d1RjyZ0wdas8bKs2p0x3Ng==", + "dev": true, + "peer": true, + "dependencies": { + "call-bind": "^1.0.2", + "for-each": "^0.3.3", + "is-typed-array": "^1.1.9" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/typedarray": { + "version": "0.0.6", + "resolved": "https://registry.npmjs.org/typedarray/-/typedarray-0.0.6.tgz", + "integrity": "sha512-/aCDEGatGvZ2BIk+HmLf4ifCJFwvKFNb9/JeZPMulfgFracn9QFcAf5GO8B/mweUjSoblS5In0cWhqpfs/5PQA==", + "dev": true, + "peer": true + }, + "node_modules/typescript": { + "version": "5.0.4", + "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.0.4.tgz", + "integrity": "sha512-cW9T5W9xY37cc+jfEnaUvX91foxtHkza3Nw3wkoF4sSlKn0MONdkdEndig/qPBWXNkmplh3NzayQzCiHM4/hqw==", + "dev": true, + "peer": true, + "bin": { + "tsc": "bin/tsc", + "tsserver": "bin/tsserver" + }, + "engines": { + "node": ">=12.20" + } + }, + "node_modules/typical": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/typical/-/typical-4.0.0.tgz", + "integrity": "sha512-VAH4IvQ7BDFYglMd7BPRDfLgxZZX4O4TFcRDA6EN5X7erNJJq+McIEp8np9aVtxrCJ6qx4GTYVfOWNjcqwZgRw==", + "dev": true, + "peer": true, + "engines": { + "node": ">=8" + } + }, + "node_modules/uglify-js": { + "version": "3.17.4", + "resolved": "https://registry.npmjs.org/uglify-js/-/uglify-js-3.17.4.tgz", + "integrity": "sha512-T9q82TJI9e/C1TAxYvfb16xO120tMVFZrGA3f9/P4424DNu6ypK103y0GPFVa17yotwSyZW5iYXgjYHkGrJW/g==", + "dev": true, + "optional": true, + "peer": true, + "bin": { + "uglifyjs": "bin/uglifyjs" + }, + "engines": { + "node": ">=0.8.0" + } + }, + "node_modules/unbox-primitive": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/unbox-primitive/-/unbox-primitive-1.0.2.tgz", + "integrity": "sha512-61pPlCD9h51VoreyJ0BReideM3MDKMKnh6+V9L08331ipq6Q8OFXZYiqP6n/tbHx4s5I9uRhcye6BrbkizkBDw==", + "dev": true, + "peer": true, + "dependencies": { + "call-bind": "^1.0.2", + "has-bigints": "^1.0.2", + "has-symbols": "^1.0.3", + "which-boxed-primitive": "^1.0.2" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/undici": { + "version": "5.22.0", + "resolved": "https://registry.npmjs.org/undici/-/undici-5.22.0.tgz", + "integrity": "sha512-fR9RXCc+6Dxav4P9VV/sp5w3eFiSdOjJYsbtWfd4s5L5C4ogyuVpdKIVHeW0vV1MloM65/f7W45nR9ZxwVdyiA==", + "dev": true, + "dependencies": { + "busboy": "^1.6.0" + }, + "engines": { + "node": ">=14.0" + } + }, + "node_modules/universalify": { + "version": "0.1.2", + "resolved": "https://registry.npmjs.org/universalify/-/universalify-0.1.2.tgz", + "integrity": "sha512-rBJeI5CXAlmy1pV+617WB9J63U6XcazHHF2f2dbJix4XzpUF0RS3Zbj0FGIOCAva5P/d/GBOYaACQ1w+0azUkg==", + "dev": true, + "engines": { + "node": ">= 4.0.0" + } + }, + "node_modules/unpipe": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/unpipe/-/unpipe-1.0.0.tgz", + "integrity": "sha512-pjy2bYhSsufwWlKwPc+l3cN7+wuJlK6uz0YdJEOlQDbl6jo/YlPi4mb8agUkVC8BF7V8NuzeyPNqRksA3hztKQ==", + "dev": true, + "engines": { + "node": ">= 0.8" + } + }, + "node_modules/uri-js": { + "version": "4.4.1", + "resolved": "https://registry.npmjs.org/uri-js/-/uri-js-4.4.1.tgz", + "integrity": "sha512-7rKUyy33Q1yc98pQ1DAmLtwX109F7TIfWlW1Ydo8Wl1ii1SeHieeh0HHfPeL2fMXK6z0s8ecKs9frCuLJvndBg==", + "dev": true, + "peer": true, + "dependencies": { + "punycode": "^2.1.0" + } + }, + "node_modules/utf8": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/utf8/-/utf8-3.0.0.tgz", + "integrity": "sha512-E8VjFIQ/TyQgp+TZfS6l8yp/xWppSAHzidGiRrqe4bK4XP9pTRyKFgGJpO3SN7zdX4DeomTrwaseCHovfpFcqQ==", + "dev": true, + "peer": true + }, + "node_modules/util-deprecate": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/util-deprecate/-/util-deprecate-1.0.2.tgz", + "integrity": "sha512-EPD5q1uXyFxJpCrLnCc1nHnq3gOa6DZBocAIiI2TaSCA7VCJ1UJDMagCzIkXNsUYfD1daK//LTEQ8xiIbrHtcw==", + "dev": true + }, + "node_modules/uuid": { + "version": "8.3.2", + "resolved": "https://registry.npmjs.org/uuid/-/uuid-8.3.2.tgz", + "integrity": "sha512-+NYs2QeMWy+GWFOEm9xnn6HCDp0l7QBD7ml8zLUmJ+93Q5NF0NocErnwkTkXVFNiX3/fpC6afS8Dhb/gz7R7eg==", + "dev": true, + "bin": { + "uuid": "dist/bin/uuid" + } + }, + "node_modules/v8-compile-cache-lib": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/v8-compile-cache-lib/-/v8-compile-cache-lib-3.0.1.tgz", + "integrity": "sha512-wa7YjyUGfNZngI/vtK0UHAN+lgDCxBPCylVXGp0zu59Fz5aiGtNXaq3DhIov063MorB+VfufLh3JlF2KdTK3xg==", + "dev": true, + "peer": true + }, + "node_modules/verror": { + "version": "1.10.0", + "resolved": "https://registry.npmjs.org/verror/-/verror-1.10.0.tgz", + "integrity": "sha512-ZZKSmDAEFOijERBLkmYfJ+vmk3w+7hOLYDNkRCuRuMJGEmqYNCNLyBBFwWKVMhfwaEF3WOd0Zlw86U/WC/+nYw==", + "dev": true, + "engines": [ + "node >=0.6.0" + ], + "peer": true, + "dependencies": { + "assert-plus": "^1.0.0", + "core-util-is": "1.0.2", + "extsprintf": "^1.2.0" + } + }, + "node_modules/web3-utils": { + "version": "1.9.0", + "resolved": "https://registry.npmjs.org/web3-utils/-/web3-utils-1.9.0.tgz", + "integrity": "sha512-p++69rCNNfu2jM9n5+VD/g26l+qkEOQ1m6cfRQCbH8ZRrtquTmrirJMgTmyOoax5a5XRYOuws14aypCOs51pdQ==", + "dev": true, + "peer": true, + "dependencies": { + "bn.js": "^5.2.1", + "ethereum-bloom-filters": "^1.0.6", + "ethereumjs-util": "^7.1.0", + "ethjs-unit": "0.1.6", + "number-to-bn": "1.7.0", + "randombytes": "^2.1.0", + "utf8": "3.0.0" + }, + "engines": { + "node": ">=8.0.0" + } + }, + "node_modules/web3-utils/node_modules/ethereum-cryptography": { + "version": "0.1.3", + "resolved": "https://registry.npmjs.org/ethereum-cryptography/-/ethereum-cryptography-0.1.3.tgz", + "integrity": "sha512-w8/4x1SGGzc+tO97TASLja6SLd3fRIK2tLVcV2Gx4IB21hE19atll5Cq9o3d0ZmAYC/8aw0ipieTSiekAea4SQ==", + "dev": true, + "peer": true, + "dependencies": { + "@types/pbkdf2": "^3.0.0", + "@types/secp256k1": "^4.0.1", + "blakejs": "^1.1.0", + "browserify-aes": "^1.2.0", + "bs58check": "^2.1.2", + "create-hash": "^1.2.0", + "create-hmac": "^1.1.7", + "hash.js": "^1.1.7", + "keccak": "^3.0.0", + "pbkdf2": "^3.0.17", + "randombytes": "^2.1.0", + "safe-buffer": "^5.1.2", + "scrypt-js": "^3.0.0", + "secp256k1": "^4.0.1", + "setimmediate": "^1.0.5" + } + }, + "node_modules/web3-utils/node_modules/ethereumjs-util": { + "version": "7.1.5", + "resolved": "https://registry.npmjs.org/ethereumjs-util/-/ethereumjs-util-7.1.5.tgz", + "integrity": "sha512-SDl5kKrQAudFBUe5OJM9Ac6WmMyYmXX/6sTmLZ3ffG2eY6ZIGBes3pEDxNN6V72WyOw4CPD5RomKdsa8DAAwLg==", + "dev": true, + "peer": true, + "dependencies": { + "@types/bn.js": "^5.1.0", + "bn.js": "^5.1.2", + "create-hash": "^1.1.2", + "ethereum-cryptography": "^0.1.3", + "rlp": "^2.2.4" + }, + "engines": { + "node": ">=10.0.0" + } + }, + "node_modules/which": { + "version": "1.3.1", + "resolved": "https://registry.npmjs.org/which/-/which-1.3.1.tgz", + "integrity": "sha512-HxJdYWq1MTIQbJ3nw0cqssHoTNU267KlrDuGZ1WYlxDStUtKUhOaJmh112/TZmHxxUfuJqPXSOm7tDyas0OSIQ==", + "dev": true, + "peer": true, + "dependencies": { + "isexe": "^2.0.0" + }, + "bin": { + "which": "bin/which" + } + }, + "node_modules/which-boxed-primitive": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/which-boxed-primitive/-/which-boxed-primitive-1.0.2.tgz", + "integrity": "sha512-bwZdv0AKLpplFY2KZRX6TvyuN7ojjr7lwkg6ml0roIy9YeuSr7JS372qlNW18UQYzgYK9ziGcerWqZOmEn9VNg==", + "dev": true, + "peer": true, + "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" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/which-module": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/which-module/-/which-module-2.0.1.tgz", + "integrity": "sha512-iBdZ57RDvnOR9AGBhML2vFZf7h8vmBjhoaZqODJBFWHVtKkDmKuHai3cx5PgVMrX5YDNp27AofYbAwctSS+vhQ==", + "dev": true, + "peer": true + }, + "node_modules/which-typed-array": { + "version": "1.1.9", + "resolved": "https://registry.npmjs.org/which-typed-array/-/which-typed-array-1.1.9.tgz", + "integrity": "sha512-w9c4xkx6mPidwp7180ckYWfMmvxpjlZuIudNtDf4N/tTAUB8VJbX25qZoAsrtGuYNnGw3pa0AXgbGKRB8/EceA==", + "dev": true, + "peer": true, + "dependencies": { + "available-typed-arrays": "^1.0.5", + "call-bind": "^1.0.2", + "for-each": "^0.3.3", + "gopd": "^1.0.1", + "has-tostringtag": "^1.0.0", + "is-typed-array": "^1.1.10" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/wide-align": { + "version": "1.1.3", + "resolved": "https://registry.npmjs.org/wide-align/-/wide-align-1.1.3.tgz", + "integrity": "sha512-QGkOQc8XL6Bt5PwnsExKBPuMKBxnGxWWW3fU55Xt4feHozMUhdUMaBCk290qpm/wG5u/RSKzwdAC4i51YigihA==", + "dev": true, + "peer": true, + "dependencies": { + "string-width": "^1.0.2 || 2" + } + }, + "node_modules/wide-align/node_modules/ansi-regex": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-3.0.1.tgz", + "integrity": "sha512-+O9Jct8wf++lXxxFc4hc8LsjaSq0HFzzL7cVsw8pRDIPdjKD2mT4ytDZlLuSBZ4cLKZFXIrMGO7DbQCtMJJMKw==", + "dev": true, + "peer": true, + "engines": { + "node": ">=4" + } + }, + "node_modules/wide-align/node_modules/is-fullwidth-code-point": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/is-fullwidth-code-point/-/is-fullwidth-code-point-2.0.0.tgz", + "integrity": "sha512-VHskAKYM8RfSFXwee5t5cbN5PZeq1Wrh6qd5bkyiXIf6UQcN6w/A0eXM9r6t8d+GYOh+o6ZhiEnb88LN/Y8m2w==", + "dev": true, + "peer": true, + "engines": { + "node": ">=4" + } + }, + "node_modules/wide-align/node_modules/string-width": { + "version": "2.1.1", + "resolved": "https://registry.npmjs.org/string-width/-/string-width-2.1.1.tgz", + "integrity": "sha512-nOqH59deCq9SRHlxq1Aw85Jnt4w6KvLKqWVik6oA9ZklXLNIOlqg4F2yrT1MVaTjAqvVwdfeZ7w7aCvJD7ugkw==", + "dev": true, + "peer": true, + "dependencies": { + "is-fullwidth-code-point": "^2.0.0", + "strip-ansi": "^4.0.0" + }, + "engines": { + "node": ">=4" + } + }, + "node_modules/wide-align/node_modules/strip-ansi": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-4.0.0.tgz", + "integrity": "sha512-4XaJ2zQdCzROZDivEVIDPkcQn8LMFSa8kj8Gxb/Lnwzv9A8VctNZ+lfivC/sV3ivW8ElJTERXZoPBRrZKkNKow==", + "dev": true, + "peer": true, + "dependencies": { + "ansi-regex": "^3.0.0" + }, + "engines": { + "node": ">=4" + } + }, + "node_modules/word-wrap": { + "version": "1.2.3", + "resolved": "https://registry.npmjs.org/word-wrap/-/word-wrap-1.2.3.tgz", + "integrity": "sha512-Hz/mrNwitNRh/HUAtM/VT/5VH+ygD6DV7mYKZAtHOrbs8U7lvPS6xf7EJKMF0uW1KJCl0H701g3ZGus+muE5vQ==", + "dev": true, + "peer": true, + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/wordwrap": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/wordwrap/-/wordwrap-1.0.0.tgz", + "integrity": "sha512-gvVzJFlPycKc5dZN4yPkP8w7Dc37BtP1yczEneOb4uq34pXZcvrtRTmWV8W+Ume+XCxKgbjM+nevkyFPMybd4Q==", + "dev": true, + "peer": true + }, + "node_modules/wordwrapjs": { + "version": "4.0.1", + "resolved": "https://registry.npmjs.org/wordwrapjs/-/wordwrapjs-4.0.1.tgz", + "integrity": "sha512-kKlNACbvHrkpIw6oPeYDSmdCTu2hdMHoyXLTcUKala++lx5Y+wjJ/e474Jqv5abnVmwxw08DiTuHmw69lJGksA==", + "dev": true, + "peer": true, + "dependencies": { + "reduce-flatten": "^2.0.0", + "typical": "^5.2.0" + }, + "engines": { + "node": ">=8.0.0" + } + }, + "node_modules/wordwrapjs/node_modules/typical": { + "version": "5.2.0", + "resolved": "https://registry.npmjs.org/typical/-/typical-5.2.0.tgz", + "integrity": "sha512-dvdQgNDNJo+8B2uBQoqdb11eUCE1JQXhvjC/CZtgvZseVd5TYMXnq0+vuUemXbd/Se29cTaUuPX3YIc2xgbvIg==", + "dev": true, + "peer": true, + "engines": { + "node": ">=8" + } + }, + "node_modules/workerpool": { + "version": "6.2.1", + "resolved": "https://registry.npmjs.org/workerpool/-/workerpool-6.2.1.tgz", + "integrity": "sha512-ILEIE97kDZvF9Wb9f6h5aXK4swSlKGUcOEGiIYb2OOu/IrDU9iwj0fD//SsA6E5ibwJxpEvhullJY4Sl4GcpAw==", + "dev": true + }, + "node_modules/wrap-ansi": { + "version": "7.0.0", + "resolved": "https://registry.npmjs.org/wrap-ansi/-/wrap-ansi-7.0.0.tgz", + "integrity": "sha512-YVGIj2kamLSTxw6NsZjoBxfSwsn0ycdesmc4p+Q21c5zPuZ1pl+NfxVdxPtdHvmNVOQ6XSYG4AUtyt/Fi7D16Q==", + "dev": true, + "dependencies": { + "ansi-styles": "^4.0.0", + "string-width": "^4.1.0", + "strip-ansi": "^6.0.0" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/chalk/wrap-ansi?sponsor=1" + } + }, + "node_modules/wrap-ansi/node_modules/ansi-styles": { + "version": "4.3.0", + "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-4.3.0.tgz", + "integrity": "sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==", + "dev": true, + "dependencies": { + "color-convert": "^2.0.1" + }, + "engines": { + "node": ">=8" + }, + "funding": { + "url": "https://github.com/chalk/ansi-styles?sponsor=1" + } + }, + "node_modules/wrap-ansi/node_modules/color-convert": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-2.0.1.tgz", + "integrity": "sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ==", + "dev": true, + "dependencies": { + "color-name": "~1.1.4" + }, + "engines": { + "node": ">=7.0.0" + } + }, + "node_modules/wrap-ansi/node_modules/color-name": { + "version": "1.1.4", + "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.4.tgz", + "integrity": "sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA==", + "dev": true + }, + "node_modules/wrappy": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/wrappy/-/wrappy-1.0.2.tgz", + "integrity": "sha512-l4Sp/DRseor9wL6EvV2+TuQn63dMkPjZ/sp9XkghTEbV9KlPS1xUsZ3u7/IQO4wxtcFB4bgpQPRcR3QCvezPcQ==", + "dev": true + }, + "node_modules/ws": { + "version": "7.5.9", + "resolved": "https://registry.npmjs.org/ws/-/ws-7.5.9.tgz", + "integrity": "sha512-F+P9Jil7UiSKSkppIiD94dN07AwvFixvLIj1Og1Rl9GGMuNipJnV9JzjD6XuqmAeiswGvUmNLjr5cFuXwNS77Q==", + "dev": true, + "engines": { + "node": ">=8.3.0" + }, + "peerDependencies": { + "bufferutil": "^4.0.1", + "utf-8-validate": "^5.0.2" + }, + "peerDependenciesMeta": { + "bufferutil": { + "optional": true + }, + "utf-8-validate": { + "optional": true + } + } + }, + "node_modules/xmlhttprequest": { + "version": "1.8.0", + "resolved": "https://registry.npmjs.org/xmlhttprequest/-/xmlhttprequest-1.8.0.tgz", + "integrity": "sha512-58Im/U0mlVBLM38NdZjHyhuMtCqa61469k2YP/AaPbvCoV9aQGUpbJBj1QRm2ytRiVQBD/fsw7L2bJGDVQswBA==", + "dev": true, + "peer": true, + "engines": { + "node": ">=0.4.0" + } + }, + "node_modules/y18n": { + "version": "5.0.8", + "resolved": "https://registry.npmjs.org/y18n/-/y18n-5.0.8.tgz", + "integrity": "sha512-0pfFzegeDWJHJIAmTLRP2DwHjdF5s7jo9tuztdQxAhINCdvS+3nGINqPd00AphqJR/0LhANUS6/+7SCb98YOfA==", + "dev": true, + "engines": { + "node": ">=10" + } + }, + "node_modules/yallist": { + "version": "3.1.1", + "resolved": "https://registry.npmjs.org/yallist/-/yallist-3.1.1.tgz", + "integrity": "sha512-a4UGQaWPH59mOXUYnAG2ewncQS4i4F43Tv3JoAM+s2VDAmS9NsK8GpDMLrCHPksFT7h3K6TOoUNn2pb7RoXx4g==", + "dev": true + }, + "node_modules/yargs": { + "version": "16.2.0", + "resolved": "https://registry.npmjs.org/yargs/-/yargs-16.2.0.tgz", + "integrity": "sha512-D1mvvtDG0L5ft/jGWkLpG1+m0eQxOfaBvTNELraWj22wSVUMWxZUvYgJYcKh6jGGIkJFhH4IZPQhR4TKpc8mBw==", + "dev": true, + "dependencies": { + "cliui": "^7.0.2", + "escalade": "^3.1.1", + "get-caller-file": "^2.0.5", + "require-directory": "^2.1.1", + "string-width": "^4.2.0", + "y18n": "^5.0.5", + "yargs-parser": "^20.2.2" + }, + "engines": { + "node": ">=10" + } + }, + "node_modules/yargs-parser": { + "version": "20.2.4", + "resolved": "https://registry.npmjs.org/yargs-parser/-/yargs-parser-20.2.4.tgz", + "integrity": "sha512-WOkpgNhPTlE73h4VFAFsOnomJVaovO8VqLDzy5saChRBFQFBoMYirowyW+Q9HB4HFF4Z7VZTiG3iSzJJA29yRA==", + "dev": true, + "engines": { + "node": ">=10" + } + }, + "node_modules/yargs-unparser": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/yargs-unparser/-/yargs-unparser-2.0.0.tgz", + "integrity": "sha512-7pRTIA9Qc1caZ0bZ6RYRGbHJthJWuakf+WmHK0rVeLkNrrGhfoabBNdue6kdINI6r4if7ocq9aD/n7xwKOdzOA==", + "dev": true, + "dependencies": { + "camelcase": "^6.0.0", + "decamelize": "^4.0.0", + "flat": "^5.0.2", + "is-plain-obj": "^2.1.0" + }, + "engines": { + "node": ">=10" + } + }, + "node_modules/yn": { + "version": "3.1.1", + "resolved": "https://registry.npmjs.org/yn/-/yn-3.1.1.tgz", + "integrity": "sha512-Ux4ygGWsu2c7isFWe8Yu1YluJmqVhxqK2cLXNQA5AcC3QfbGNpM7fu0Y8b/z16pXLnFxZYvWhd3fhBY9DLmC6Q==", + "dev": true, + "peer": true, + "engines": { + "node": ">=6" + } + }, + "node_modules/yocto-queue": { + "version": "0.1.0", + "resolved": "https://registry.npmjs.org/yocto-queue/-/yocto-queue-0.1.0.tgz", + "integrity": "sha512-rVksvsnNCdJ/ohGc6xgPwyN8eheCxsiLM8mxuE/t/mOVqJewPuO1miLpTHQiRgTKCLexL4MeAFVagts7HmNZ2Q==", + "dev": true, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + } + }, + "dependencies": { + "@chainsafe/as-sha256": { + "version": "0.3.1", + "resolved": "https://registry.npmjs.org/@chainsafe/as-sha256/-/as-sha256-0.3.1.tgz", + "integrity": "sha512-hldFFYuf49ed7DAakWVXSJODuq3pzJEguD8tQ7h+sGkM18vja+OFoJI9krnGmgzyuZC2ETX0NOIcCTy31v2Mtg==", + "dev": true + }, + "@chainsafe/persistent-merkle-tree": { + "version": "0.4.2", + "resolved": "https://registry.npmjs.org/@chainsafe/persistent-merkle-tree/-/persistent-merkle-tree-0.4.2.tgz", + "integrity": "sha512-lLO3ihKPngXLTus/L7WHKaw9PnNJWizlOF1H9NNzHP6Xvh82vzg9F2bzkXhYIFshMZ2gTCEz8tq6STe7r5NDfQ==", + "dev": true, + "requires": { + "@chainsafe/as-sha256": "^0.3.1" + } + }, + "@chainsafe/ssz": { + "version": "0.9.4", + "resolved": "https://registry.npmjs.org/@chainsafe/ssz/-/ssz-0.9.4.tgz", + "integrity": "sha512-77Qtg2N1ayqs4Bg/wvnWfg5Bta7iy7IRh8XqXh7oNMeP2HBbBwx8m6yTpA8p0EHItWPEBkgZd5S5/LSlp3GXuQ==", + "dev": true, + "requires": { + "@chainsafe/as-sha256": "^0.3.1", + "@chainsafe/persistent-merkle-tree": "^0.4.2", + "case": "^1.6.3" + } + }, + "@cspotcode/source-map-support": { + "version": "0.8.1", + "resolved": "https://registry.npmjs.org/@cspotcode/source-map-support/-/source-map-support-0.8.1.tgz", + "integrity": "sha512-IchNf6dN4tHoMFIn/7OE8LWZ19Y6q/67Bmf6vnGREv8RSbBVb9LPJxEcnwrcwX6ixSvaiGoomAUvu4YSxXrVgw==", + "dev": true, + "peer": true, + "requires": { + "@jridgewell/trace-mapping": "0.3.9" + } + }, + "@ethersproject/abi": { + "version": "5.7.0", + "resolved": "https://registry.npmjs.org/@ethersproject/abi/-/abi-5.7.0.tgz", + "integrity": "sha512-351ktp42TiRcYB3H1OP8yajPeAQstMW/yCFokj/AthP9bLHzQFPlOrxOcwYEDkUAICmOHljvN4K39OMTMUa9RA==", + "dev": true, + "requires": { + "@ethersproject/address": "^5.7.0", + "@ethersproject/bignumber": "^5.7.0", + "@ethersproject/bytes": "^5.7.0", + "@ethersproject/constants": "^5.7.0", + "@ethersproject/hash": "^5.7.0", + "@ethersproject/keccak256": "^5.7.0", + "@ethersproject/logger": "^5.7.0", + "@ethersproject/properties": "^5.7.0", + "@ethersproject/strings": "^5.7.0" + } + }, + "@ethersproject/abstract-provider": { + "version": "5.7.0", + "resolved": "https://registry.npmjs.org/@ethersproject/abstract-provider/-/abstract-provider-5.7.0.tgz", + "integrity": "sha512-R41c9UkchKCpAqStMYUpdunjo3pkEvZC3FAwZn5S5MGbXoMQOHIdHItezTETxAO5bevtMApSyEhn9+CHcDsWBw==", + "dev": true, + "requires": { + "@ethersproject/bignumber": "^5.7.0", + "@ethersproject/bytes": "^5.7.0", + "@ethersproject/logger": "^5.7.0", + "@ethersproject/networks": "^5.7.0", + "@ethersproject/properties": "^5.7.0", + "@ethersproject/transactions": "^5.7.0", + "@ethersproject/web": "^5.7.0" + } + }, + "@ethersproject/abstract-signer": { + "version": "5.7.0", + "resolved": "https://registry.npmjs.org/@ethersproject/abstract-signer/-/abstract-signer-5.7.0.tgz", + "integrity": "sha512-a16V8bq1/Cz+TGCkE2OPMTOUDLS3grCpdjoJCYNnVBbdYEMSgKrU0+B90s8b6H+ByYTBZN7a3g76jdIJi7UfKQ==", + "dev": true, + "requires": { + "@ethersproject/abstract-provider": "^5.7.0", + "@ethersproject/bignumber": "^5.7.0", + "@ethersproject/bytes": "^5.7.0", + "@ethersproject/logger": "^5.7.0", + "@ethersproject/properties": "^5.7.0" + } + }, + "@ethersproject/address": { + "version": "5.7.0", + "resolved": "https://registry.npmjs.org/@ethersproject/address/-/address-5.7.0.tgz", + "integrity": "sha512-9wYhYt7aghVGo758POM5nqcOMaE168Q6aRLJZwUmiqSrAungkG74gSSeKEIR7ukixesdRZGPgVqme6vmxs1fkA==", + "dev": true, + "requires": { + "@ethersproject/bignumber": "^5.7.0", + "@ethersproject/bytes": "^5.7.0", + "@ethersproject/keccak256": "^5.7.0", + "@ethersproject/logger": "^5.7.0", + "@ethersproject/rlp": "^5.7.0" + } + }, + "@ethersproject/base64": { + "version": "5.7.0", + "resolved": "https://registry.npmjs.org/@ethersproject/base64/-/base64-5.7.0.tgz", + "integrity": "sha512-Dr8tcHt2mEbsZr/mwTPIQAf3Ai0Bks/7gTw9dSqk1mQvhW3XvRlmDJr/4n+wg1JmCl16NZue17CDh8xb/vZ0sQ==", + "dev": true, + "requires": { + "@ethersproject/bytes": "^5.7.0" + } + }, + "@ethersproject/basex": { + "version": "5.7.0", + "resolved": "https://registry.npmjs.org/@ethersproject/basex/-/basex-5.7.0.tgz", + "integrity": "sha512-ywlh43GwZLv2Voc2gQVTKBoVQ1mti3d8HK5aMxsfu/nRDnMmNqaSJ3r3n85HBByT8OpoY96SXM1FogC533T4zw==", + "dev": true, + "requires": { + "@ethersproject/bytes": "^5.7.0", + "@ethersproject/properties": "^5.7.0" + } + }, + "@ethersproject/bignumber": { + "version": "5.7.0", + "resolved": "https://registry.npmjs.org/@ethersproject/bignumber/-/bignumber-5.7.0.tgz", + "integrity": "sha512-n1CAdIHRWjSucQO3MC1zPSVgV/6dy/fjL9pMrPP9peL+QxEg9wOsVqwD4+818B6LUEtaXzVHQiuivzRoxPxUGw==", + "dev": true, + "requires": { + "@ethersproject/bytes": "^5.7.0", + "@ethersproject/logger": "^5.7.0", + "bn.js": "^5.2.1" + } + }, + "@ethersproject/bytes": { + "version": "5.7.0", + "resolved": "https://registry.npmjs.org/@ethersproject/bytes/-/bytes-5.7.0.tgz", + "integrity": "sha512-nsbxwgFXWh9NyYWo+U8atvmMsSdKJprTcICAkvbBffT75qDocbuggBU0SJiVK2MuTrp0q+xvLkTnGMPK1+uA9A==", + "dev": true, + "requires": { + "@ethersproject/logger": "^5.7.0" + } + }, + "@ethersproject/constants": { + "version": "5.7.0", + "resolved": "https://registry.npmjs.org/@ethersproject/constants/-/constants-5.7.0.tgz", + "integrity": "sha512-DHI+y5dBNvkpYUMiRQyxRBYBefZkJfo70VUkUAsRjcPs47muV9evftfZ0PJVCXYbAiCgght0DtcF9srFQmIgWA==", + "dev": true, + "requires": { + "@ethersproject/bignumber": "^5.7.0" + } + }, + "@ethersproject/contracts": { + "version": "5.7.0", + "resolved": "https://registry.npmjs.org/@ethersproject/contracts/-/contracts-5.7.0.tgz", + "integrity": "sha512-5GJbzEU3X+d33CdfPhcyS+z8MzsTrBGk/sc+G+59+tPa9yFkl6HQ9D6L0QMgNTA9q8dT0XKxxkyp883XsQvbbg==", + "dev": true, + "requires": { + "@ethersproject/abi": "^5.7.0", + "@ethersproject/abstract-provider": "^5.7.0", + "@ethersproject/abstract-signer": "^5.7.0", + "@ethersproject/address": "^5.7.0", + "@ethersproject/bignumber": "^5.7.0", + "@ethersproject/bytes": "^5.7.0", + "@ethersproject/constants": "^5.7.0", + "@ethersproject/logger": "^5.7.0", + "@ethersproject/properties": "^5.7.0", + "@ethersproject/transactions": "^5.7.0" + } + }, + "@ethersproject/hash": { + "version": "5.7.0", + "resolved": "https://registry.npmjs.org/@ethersproject/hash/-/hash-5.7.0.tgz", + "integrity": "sha512-qX5WrQfnah1EFnO5zJv1v46a8HW0+E5xuBBDTwMFZLuVTx0tbU2kkx15NqdjxecrLGatQN9FGQKpb1FKdHCt+g==", + "dev": true, + "requires": { + "@ethersproject/abstract-signer": "^5.7.0", + "@ethersproject/address": "^5.7.0", + "@ethersproject/base64": "^5.7.0", + "@ethersproject/bignumber": "^5.7.0", + "@ethersproject/bytes": "^5.7.0", + "@ethersproject/keccak256": "^5.7.0", + "@ethersproject/logger": "^5.7.0", + "@ethersproject/properties": "^5.7.0", + "@ethersproject/strings": "^5.7.0" + } + }, + "@ethersproject/hdnode": { + "version": "5.7.0", + "resolved": "https://registry.npmjs.org/@ethersproject/hdnode/-/hdnode-5.7.0.tgz", + "integrity": "sha512-OmyYo9EENBPPf4ERhR7oj6uAtUAhYGqOnIS+jE5pTXvdKBS99ikzq1E7Iv0ZQZ5V36Lqx1qZLeak0Ra16qpeOg==", + "dev": true, + "requires": { + "@ethersproject/abstract-signer": "^5.7.0", + "@ethersproject/basex": "^5.7.0", + "@ethersproject/bignumber": "^5.7.0", + "@ethersproject/bytes": "^5.7.0", + "@ethersproject/logger": "^5.7.0", + "@ethersproject/pbkdf2": "^5.7.0", + "@ethersproject/properties": "^5.7.0", + "@ethersproject/sha2": "^5.7.0", + "@ethersproject/signing-key": "^5.7.0", + "@ethersproject/strings": "^5.7.0", + "@ethersproject/transactions": "^5.7.0", + "@ethersproject/wordlists": "^5.7.0" + } + }, + "@ethersproject/json-wallets": { + "version": "5.7.0", + "resolved": "https://registry.npmjs.org/@ethersproject/json-wallets/-/json-wallets-5.7.0.tgz", + "integrity": "sha512-8oee5Xgu6+RKgJTkvEMl2wDgSPSAQ9MB/3JYjFV9jlKvcYHUXZC+cQp0njgmxdHkYWn8s6/IqIZYm0YWCjO/0g==", + "dev": true, + "requires": { + "@ethersproject/abstract-signer": "^5.7.0", + "@ethersproject/address": "^5.7.0", + "@ethersproject/bytes": "^5.7.0", + "@ethersproject/hdnode": "^5.7.0", + "@ethersproject/keccak256": "^5.7.0", + "@ethersproject/logger": "^5.7.0", + "@ethersproject/pbkdf2": "^5.7.0", + "@ethersproject/properties": "^5.7.0", + "@ethersproject/random": "^5.7.0", + "@ethersproject/strings": "^5.7.0", + "@ethersproject/transactions": "^5.7.0", + "aes-js": "3.0.0", + "scrypt-js": "3.0.1" + } + }, + "@ethersproject/keccak256": { + "version": "5.7.0", + "resolved": "https://registry.npmjs.org/@ethersproject/keccak256/-/keccak256-5.7.0.tgz", + "integrity": "sha512-2UcPboeL/iW+pSg6vZ6ydF8tCnv3Iu/8tUmLLzWWGzxWKFFqOBQFLo6uLUv6BDrLgCDfN28RJ/wtByx+jZ4KBg==", + "dev": true, + "requires": { + "@ethersproject/bytes": "^5.7.0", + "js-sha3": "0.8.0" + } + }, + "@ethersproject/logger": { + "version": "5.7.0", + "resolved": "https://registry.npmjs.org/@ethersproject/logger/-/logger-5.7.0.tgz", + "integrity": "sha512-0odtFdXu/XHtjQXJYA3u9G0G8btm0ND5Cu8M7i5vhEcE8/HmF4Lbdqanwyv4uQTr2tx6b7fQRmgLrsnpQlmnig==", + "dev": true + }, + "@ethersproject/networks": { + "version": "5.7.1", + "resolved": "https://registry.npmjs.org/@ethersproject/networks/-/networks-5.7.1.tgz", + "integrity": "sha512-n/MufjFYv3yFcUyfhnXotyDlNdFb7onmkSy8aQERi2PjNcnWQ66xXxa3XlS8nCcA8aJKJjIIMNJTC7tu80GwpQ==", + "dev": true, + "requires": { + "@ethersproject/logger": "^5.7.0" + } + }, + "@ethersproject/pbkdf2": { + "version": "5.7.0", + "resolved": "https://registry.npmjs.org/@ethersproject/pbkdf2/-/pbkdf2-5.7.0.tgz", + "integrity": "sha512-oR/dBRZR6GTyaofd86DehG72hY6NpAjhabkhxgr3X2FpJtJuodEl2auADWBZfhDHgVCbu3/H/Ocq2uC6dpNjjw==", + "dev": true, + "requires": { + "@ethersproject/bytes": "^5.7.0", + "@ethersproject/sha2": "^5.7.0" + } + }, + "@ethersproject/properties": { + "version": "5.7.0", + "resolved": "https://registry.npmjs.org/@ethersproject/properties/-/properties-5.7.0.tgz", + "integrity": "sha512-J87jy8suntrAkIZtecpxEPxY//szqr1mlBaYlQ0r4RCaiD2hjheqF9s1LVE8vVuJCXisjIP+JgtK/Do54ej4Sw==", + "dev": true, + "requires": { + "@ethersproject/logger": "^5.7.0" + } + }, + "@ethersproject/providers": { + "version": "5.7.2", + "resolved": "https://registry.npmjs.org/@ethersproject/providers/-/providers-5.7.2.tgz", + "integrity": "sha512-g34EWZ1WWAVgr4aptGlVBF8mhl3VWjv+8hoAnzStu8Ah22VHBsuGzP17eb6xDVRzw895G4W7vvx60lFFur/1Rg==", + "dev": true, + "requires": { + "@ethersproject/abstract-provider": "^5.7.0", + "@ethersproject/abstract-signer": "^5.7.0", + "@ethersproject/address": "^5.7.0", + "@ethersproject/base64": "^5.7.0", + "@ethersproject/basex": "^5.7.0", + "@ethersproject/bignumber": "^5.7.0", + "@ethersproject/bytes": "^5.7.0", + "@ethersproject/constants": "^5.7.0", + "@ethersproject/hash": "^5.7.0", + "@ethersproject/logger": "^5.7.0", + "@ethersproject/networks": "^5.7.0", + "@ethersproject/properties": "^5.7.0", + "@ethersproject/random": "^5.7.0", + "@ethersproject/rlp": "^5.7.0", + "@ethersproject/sha2": "^5.7.0", + "@ethersproject/strings": "^5.7.0", + "@ethersproject/transactions": "^5.7.0", + "@ethersproject/web": "^5.7.0", + "bech32": "1.1.4", + "ws": "7.4.6" + }, + "dependencies": { + "ws": { + "version": "7.4.6", + "resolved": "https://registry.npmjs.org/ws/-/ws-7.4.6.tgz", + "integrity": "sha512-YmhHDO4MzaDLB+M9ym/mDA5z0naX8j7SIlT8f8z+I0VtzsRbekxEutHSme7NPS2qE8StCYQNUnfWdXta/Yu85A==", + "dev": true, + "requires": {} + } + } + }, + "@ethersproject/random": { + "version": "5.7.0", + "resolved": "https://registry.npmjs.org/@ethersproject/random/-/random-5.7.0.tgz", + "integrity": "sha512-19WjScqRA8IIeWclFme75VMXSBvi4e6InrUNuaR4s5pTF2qNhcGdCUwdxUVGtDDqC00sDLCO93jPQoDUH4HVmQ==", + "dev": true, + "requires": { + "@ethersproject/bytes": "^5.7.0", + "@ethersproject/logger": "^5.7.0" + } + }, + "@ethersproject/rlp": { + "version": "5.7.0", + "resolved": "https://registry.npmjs.org/@ethersproject/rlp/-/rlp-5.7.0.tgz", + "integrity": "sha512-rBxzX2vK8mVF7b0Tol44t5Tb8gomOHkj5guL+HhzQ1yBh/ydjGnpw6at+X6Iw0Kp3OzzzkcKp8N9r0W4kYSs9w==", + "dev": true, + "requires": { + "@ethersproject/bytes": "^5.7.0", + "@ethersproject/logger": "^5.7.0" + } + }, + "@ethersproject/sha2": { + "version": "5.7.0", + "resolved": "https://registry.npmjs.org/@ethersproject/sha2/-/sha2-5.7.0.tgz", + "integrity": "sha512-gKlH42riwb3KYp0reLsFTokByAKoJdgFCwI+CCiX/k+Jm2mbNs6oOaCjYQSlI1+XBVejwH2KrmCbMAT/GnRDQw==", + "dev": true, + "requires": { + "@ethersproject/bytes": "^5.7.0", + "@ethersproject/logger": "^5.7.0", + "hash.js": "1.1.7" + } + }, + "@ethersproject/signing-key": { + "version": "5.7.0", + "resolved": "https://registry.npmjs.org/@ethersproject/signing-key/-/signing-key-5.7.0.tgz", + "integrity": "sha512-MZdy2nL3wO0u7gkB4nA/pEf8lu1TlFswPNmy8AiYkfKTdO6eXBJyUdmHO/ehm/htHw9K/qF8ujnTyUAD+Ry54Q==", + "dev": true, + "requires": { + "@ethersproject/bytes": "^5.7.0", + "@ethersproject/logger": "^5.7.0", + "@ethersproject/properties": "^5.7.0", + "bn.js": "^5.2.1", + "elliptic": "6.5.4", + "hash.js": "1.1.7" + } + }, + "@ethersproject/solidity": { + "version": "5.7.0", + "resolved": "https://registry.npmjs.org/@ethersproject/solidity/-/solidity-5.7.0.tgz", + "integrity": "sha512-HmabMd2Dt/raavyaGukF4XxizWKhKQ24DoLtdNbBmNKUOPqwjsKQSdV9GQtj9CBEea9DlzETlVER1gYeXXBGaA==", + "dev": true, + "requires": { + "@ethersproject/bignumber": "^5.7.0", + "@ethersproject/bytes": "^5.7.0", + "@ethersproject/keccak256": "^5.7.0", + "@ethersproject/logger": "^5.7.0", + "@ethersproject/sha2": "^5.7.0", + "@ethersproject/strings": "^5.7.0" + } + }, + "@ethersproject/strings": { + "version": "5.7.0", + "resolved": "https://registry.npmjs.org/@ethersproject/strings/-/strings-5.7.0.tgz", + "integrity": "sha512-/9nu+lj0YswRNSH0NXYqrh8775XNyEdUQAuf3f+SmOrnVewcJ5SBNAjF7lpgehKi4abvNNXyf+HX86czCdJ8Mg==", + "dev": true, + "requires": { + "@ethersproject/bytes": "^5.7.0", + "@ethersproject/constants": "^5.7.0", + "@ethersproject/logger": "^5.7.0" + } + }, + "@ethersproject/transactions": { + "version": "5.7.0", + "resolved": "https://registry.npmjs.org/@ethersproject/transactions/-/transactions-5.7.0.tgz", + "integrity": "sha512-kmcNicCp1lp8qanMTC3RIikGgoJ80ztTyvtsFvCYpSCfkjhD0jZ2LOrnbcuxuToLIUYYf+4XwD1rP+B/erDIhQ==", + "dev": true, + "requires": { + "@ethersproject/address": "^5.7.0", + "@ethersproject/bignumber": "^5.7.0", + "@ethersproject/bytes": "^5.7.0", + "@ethersproject/constants": "^5.7.0", + "@ethersproject/keccak256": "^5.7.0", + "@ethersproject/logger": "^5.7.0", + "@ethersproject/properties": "^5.7.0", + "@ethersproject/rlp": "^5.7.0", + "@ethersproject/signing-key": "^5.7.0" + } + }, + "@ethersproject/units": { + "version": "5.7.0", + "resolved": "https://registry.npmjs.org/@ethersproject/units/-/units-5.7.0.tgz", + "integrity": "sha512-pD3xLMy3SJu9kG5xDGI7+xhTEmGXlEqXU4OfNapmfnxLVY4EMSSRp7j1k7eezutBPH7RBN/7QPnwR7hzNlEFeg==", + "dev": true, + "requires": { + "@ethersproject/bignumber": "^5.7.0", + "@ethersproject/constants": "^5.7.0", + "@ethersproject/logger": "^5.7.0" + } + }, + "@ethersproject/wallet": { + "version": "5.7.0", + "resolved": "https://registry.npmjs.org/@ethersproject/wallet/-/wallet-5.7.0.tgz", + "integrity": "sha512-MhmXlJXEJFBFVKrDLB4ZdDzxcBxQ3rLyCkhNqVu3CDYvR97E+8r01UgrI+TI99Le+aYm/in/0vp86guJuM7FCA==", + "dev": true, + "requires": { + "@ethersproject/abstract-provider": "^5.7.0", + "@ethersproject/abstract-signer": "^5.7.0", + "@ethersproject/address": "^5.7.0", + "@ethersproject/bignumber": "^5.7.0", + "@ethersproject/bytes": "^5.7.0", + "@ethersproject/hash": "^5.7.0", + "@ethersproject/hdnode": "^5.7.0", + "@ethersproject/json-wallets": "^5.7.0", + "@ethersproject/keccak256": "^5.7.0", + "@ethersproject/logger": "^5.7.0", + "@ethersproject/properties": "^5.7.0", + "@ethersproject/random": "^5.7.0", + "@ethersproject/signing-key": "^5.7.0", + "@ethersproject/transactions": "^5.7.0", + "@ethersproject/wordlists": "^5.7.0" + } + }, + "@ethersproject/web": { + "version": "5.7.1", + "resolved": "https://registry.npmjs.org/@ethersproject/web/-/web-5.7.1.tgz", + "integrity": "sha512-Gueu8lSvyjBWL4cYsWsjh6MtMwM0+H4HvqFPZfB6dV8ctbP9zFAO73VG1cMWae0FLPCtz0peKPpZY8/ugJJX2w==", + "dev": true, + "requires": { + "@ethersproject/base64": "^5.7.0", + "@ethersproject/bytes": "^5.7.0", + "@ethersproject/logger": "^5.7.0", + "@ethersproject/properties": "^5.7.0", + "@ethersproject/strings": "^5.7.0" + } + }, + "@ethersproject/wordlists": { + "version": "5.7.0", + "resolved": "https://registry.npmjs.org/@ethersproject/wordlists/-/wordlists-5.7.0.tgz", + "integrity": "sha512-S2TFNJNfHWVHNE6cNDjbVlZ6MgE17MIxMbMg2zv3wn+3XSJGosL1m9ZVv3GXCf/2ymSsQ+hRI5IzoMJTG6aoVA==", + "dev": true, + "requires": { + "@ethersproject/bytes": "^5.7.0", + "@ethersproject/hash": "^5.7.0", + "@ethersproject/logger": "^5.7.0", + "@ethersproject/properties": "^5.7.0", + "@ethersproject/strings": "^5.7.0" + } + }, + "@jridgewell/resolve-uri": { + "version": "3.1.1", + "resolved": "https://registry.npmjs.org/@jridgewell/resolve-uri/-/resolve-uri-3.1.1.tgz", + "integrity": "sha512-dSYZh7HhCDtCKm4QakX0xFpsRDqjjtZf/kjI/v3T3Nwt5r8/qz/M19F9ySyOqU94SXBmeG9ttTul+YnR4LOxFA==", + "dev": true, + "peer": true + }, + "@jridgewell/sourcemap-codec": { + "version": "1.4.15", + "resolved": "https://registry.npmjs.org/@jridgewell/sourcemap-codec/-/sourcemap-codec-1.4.15.tgz", + "integrity": "sha512-eF2rxCRulEKXHTRiDrDy6erMYWqNw4LPdQ8UQA4huuxaQsVeRPFl2oM8oDGxMFhJUWZf9McpLtJasDDZb/Bpeg==", + "dev": true, + "peer": true + }, + "@jridgewell/trace-mapping": { + "version": "0.3.9", + "resolved": "https://registry.npmjs.org/@jridgewell/trace-mapping/-/trace-mapping-0.3.9.tgz", + "integrity": "sha512-3Belt6tdc8bPgAtbcmdtNJlirVoTmEb5e2gC94PnkwEW9jI6CAHUeoG85tjWP5WquqfavoMtMwiG4P926ZKKuQ==", + "dev": true, + "peer": true, + "requires": { + "@jridgewell/resolve-uri": "^3.0.3", + "@jridgewell/sourcemap-codec": "^1.4.10" + } + }, + "@metamask/eth-sig-util": { + "version": "4.0.1", + "resolved": "https://registry.npmjs.org/@metamask/eth-sig-util/-/eth-sig-util-4.0.1.tgz", + "integrity": "sha512-tghyZKLHZjcdlDqCA3gNZmLeR0XvOE9U1qoQO9ohyAZT6Pya+H9vkBPcsyXytmYLNgVoin7CKCmweo/R43V+tQ==", + "dev": true, + "requires": { + "ethereumjs-abi": "^0.6.8", + "ethereumjs-util": "^6.2.1", + "ethjs-util": "^0.1.6", + "tweetnacl": "^1.0.3", + "tweetnacl-util": "^0.15.1" + } + }, + "@morgan-stanley/ts-mocking-bird": { + "version": "0.6.4", + "resolved": "https://registry.npmjs.org/@morgan-stanley/ts-mocking-bird/-/ts-mocking-bird-0.6.4.tgz", + "integrity": "sha512-57VJIflP8eR2xXa9cD1LUawh+Gh+BVQfVu0n6GALyg/AqV/Nz25kDRvws3i9kIe1PTrbsZZOYpsYp6bXPd6nVA==", + "dev": true, + "peer": true, + "requires": { + "lodash": "^4.17.16", + "uuid": "^7.0.3" + }, + "dependencies": { + "uuid": { + "version": "7.0.3", + "resolved": "https://registry.npmjs.org/uuid/-/uuid-7.0.3.tgz", + "integrity": "sha512-DPSke0pXhTZgoF/d+WSt2QaKMCFSfx7QegxEWT+JOuHF5aWrKEn0G+ztjuJg/gG8/ItK+rbPCD/yNv8yyih6Cg==", + "dev": true, + "peer": true + } + } + }, + "@noble/hashes": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/@noble/hashes/-/hashes-1.2.0.tgz", + "integrity": "sha512-FZfhjEDbT5GRswV3C6uvLPHMiVD6lQBmpoX5+eSiPaMTXte/IKqI5dykDxzZB/WBeK/CDuQRBWarPdi3FNY2zQ==", + "dev": true + }, + "@noble/secp256k1": { + "version": "1.7.1", + "resolved": "https://registry.npmjs.org/@noble/secp256k1/-/secp256k1-1.7.1.tgz", + "integrity": "sha512-hOUk6AyBFmqVrv7k5WAw/LpszxVbj9gGN4JRkIX52fdFAj1UA61KXmZDvqVEm+pOyec3+fIeZB02LYa/pWOArw==", + "dev": true + }, + "@nodelib/fs.scandir": { + "version": "2.1.5", + "resolved": "https://registry.npmjs.org/@nodelib/fs.scandir/-/fs.scandir-2.1.5.tgz", + "integrity": "sha512-vq24Bq3ym5HEQm2NKCr3yXDwjc7vTsEThRDnkp2DK9p1uqLR+DHurm/NOTo0KG7HYHU7eppKZj3MyqYuMBf62g==", + "dev": true, + "peer": true, + "requires": { + "@nodelib/fs.stat": "2.0.5", + "run-parallel": "^1.1.9" + } + }, + "@nodelib/fs.stat": { + "version": "2.0.5", + "resolved": "https://registry.npmjs.org/@nodelib/fs.stat/-/fs.stat-2.0.5.tgz", + "integrity": "sha512-RkhPPp2zrqDAQA/2jNhnztcPAlv64XdhIp7a7454A5ovI7Bukxgt7MX7udwAu3zg1DcpPU0rz3VV1SeaqvY4+A==", + "dev": true, + "peer": true + }, + "@nodelib/fs.walk": { + "version": "1.2.8", + "resolved": "https://registry.npmjs.org/@nodelib/fs.walk/-/fs.walk-1.2.8.tgz", + "integrity": "sha512-oGB+UxlgWcgQkgwo8GcEGwemoTFt3FIO9ababBmaGwXIoBKZ+GTy0pP185beGg7Llih/NSHSV2XAs1lnznocSg==", + "dev": true, + "peer": true, + "requires": { + "@nodelib/fs.scandir": "2.1.5", + "fastq": "^1.6.0" + } + }, + "@nomicfoundation/ethereumjs-block": { + "version": "5.0.1", + "resolved": "https://registry.npmjs.org/@nomicfoundation/ethereumjs-block/-/ethereumjs-block-5.0.1.tgz", + "integrity": "sha512-u1Yioemi6Ckj3xspygu/SfFvm8vZEO8/Yx5a1QLzi6nVU0jz3Pg2OmHKJ5w+D9Ogk1vhwRiqEBAqcb0GVhCyHw==", + "dev": true, + "requires": { + "@nomicfoundation/ethereumjs-common": "4.0.1", + "@nomicfoundation/ethereumjs-rlp": "5.0.1", + "@nomicfoundation/ethereumjs-trie": "6.0.1", + "@nomicfoundation/ethereumjs-tx": "5.0.1", + "@nomicfoundation/ethereumjs-util": "9.0.1", + "ethereum-cryptography": "0.1.3", + "ethers": "^5.7.1" + }, + "dependencies": { + "ethereum-cryptography": { + "version": "0.1.3", + "resolved": "https://registry.npmjs.org/ethereum-cryptography/-/ethereum-cryptography-0.1.3.tgz", + "integrity": "sha512-w8/4x1SGGzc+tO97TASLja6SLd3fRIK2tLVcV2Gx4IB21hE19atll5Cq9o3d0ZmAYC/8aw0ipieTSiekAea4SQ==", + "dev": true, + "requires": { + "@types/pbkdf2": "^3.0.0", + "@types/secp256k1": "^4.0.1", + "blakejs": "^1.1.0", + "browserify-aes": "^1.2.0", + "bs58check": "^2.1.2", + "create-hash": "^1.2.0", + "create-hmac": "^1.1.7", + "hash.js": "^1.1.7", + "keccak": "^3.0.0", + "pbkdf2": "^3.0.17", + "randombytes": "^2.1.0", + "safe-buffer": "^5.1.2", + "scrypt-js": "^3.0.0", + "secp256k1": "^4.0.1", + "setimmediate": "^1.0.5" + } + } + } + }, + "@nomicfoundation/ethereumjs-blockchain": { + "version": "7.0.1", + "resolved": "https://registry.npmjs.org/@nomicfoundation/ethereumjs-blockchain/-/ethereumjs-blockchain-7.0.1.tgz", + "integrity": "sha512-NhzndlGg829XXbqJEYrF1VeZhAwSPgsK/OB7TVrdzft3y918hW5KNd7gIZ85sn6peDZOdjBsAXIpXZ38oBYE5A==", + "dev": true, + "requires": { + "@nomicfoundation/ethereumjs-block": "5.0.1", + "@nomicfoundation/ethereumjs-common": "4.0.1", + "@nomicfoundation/ethereumjs-ethash": "3.0.1", + "@nomicfoundation/ethereumjs-rlp": "5.0.1", + "@nomicfoundation/ethereumjs-trie": "6.0.1", + "@nomicfoundation/ethereumjs-tx": "5.0.1", + "@nomicfoundation/ethereumjs-util": "9.0.1", + "abstract-level": "^1.0.3", + "debug": "^4.3.3", + "ethereum-cryptography": "0.1.3", + "level": "^8.0.0", + "lru-cache": "^5.1.1", + "memory-level": "^1.0.0" + }, + "dependencies": { + "ethereum-cryptography": { + "version": "0.1.3", + "resolved": "https://registry.npmjs.org/ethereum-cryptography/-/ethereum-cryptography-0.1.3.tgz", + "integrity": "sha512-w8/4x1SGGzc+tO97TASLja6SLd3fRIK2tLVcV2Gx4IB21hE19atll5Cq9o3d0ZmAYC/8aw0ipieTSiekAea4SQ==", + "dev": true, + "requires": { + "@types/pbkdf2": "^3.0.0", + "@types/secp256k1": "^4.0.1", + "blakejs": "^1.1.0", + "browserify-aes": "^1.2.0", + "bs58check": "^2.1.2", + "create-hash": "^1.2.0", + "create-hmac": "^1.1.7", + "hash.js": "^1.1.7", + "keccak": "^3.0.0", + "pbkdf2": "^3.0.17", + "randombytes": "^2.1.0", + "safe-buffer": "^5.1.2", + "scrypt-js": "^3.0.0", + "secp256k1": "^4.0.1", + "setimmediate": "^1.0.5" + } + } + } + }, + "@nomicfoundation/ethereumjs-common": { + "version": "4.0.1", + "resolved": "https://registry.npmjs.org/@nomicfoundation/ethereumjs-common/-/ethereumjs-common-4.0.1.tgz", + "integrity": "sha512-OBErlkfp54GpeiE06brBW/TTbtbuBJV5YI5Nz/aB2evTDo+KawyEzPjBlSr84z/8MFfj8wS2wxzQX1o32cev5g==", + "dev": true, + "requires": { + "@nomicfoundation/ethereumjs-util": "9.0.1", + "crc-32": "^1.2.0" + } + }, + "@nomicfoundation/ethereumjs-ethash": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/@nomicfoundation/ethereumjs-ethash/-/ethereumjs-ethash-3.0.1.tgz", + "integrity": "sha512-KDjGIB5igzWOp8Ik5I6QiRH5DH+XgILlplsHR7TEuWANZA759G6krQ6o8bvj+tRUz08YygMQu/sGd9mJ1DYT8w==", + "dev": true, + "requires": { + "@nomicfoundation/ethereumjs-block": "5.0.1", + "@nomicfoundation/ethereumjs-rlp": "5.0.1", + "@nomicfoundation/ethereumjs-util": "9.0.1", + "abstract-level": "^1.0.3", + "bigint-crypto-utils": "^3.0.23", + "ethereum-cryptography": "0.1.3" + }, + "dependencies": { + "ethereum-cryptography": { + "version": "0.1.3", + "resolved": "https://registry.npmjs.org/ethereum-cryptography/-/ethereum-cryptography-0.1.3.tgz", + "integrity": "sha512-w8/4x1SGGzc+tO97TASLja6SLd3fRIK2tLVcV2Gx4IB21hE19atll5Cq9o3d0ZmAYC/8aw0ipieTSiekAea4SQ==", + "dev": true, + "requires": { + "@types/pbkdf2": "^3.0.0", + "@types/secp256k1": "^4.0.1", + "blakejs": "^1.1.0", + "browserify-aes": "^1.2.0", + "bs58check": "^2.1.2", + "create-hash": "^1.2.0", + "create-hmac": "^1.1.7", + "hash.js": "^1.1.7", + "keccak": "^3.0.0", + "pbkdf2": "^3.0.17", + "randombytes": "^2.1.0", + "safe-buffer": "^5.1.2", + "scrypt-js": "^3.0.0", + "secp256k1": "^4.0.1", + "setimmediate": "^1.0.5" + } + } + } + }, + "@nomicfoundation/ethereumjs-evm": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/@nomicfoundation/ethereumjs-evm/-/ethereumjs-evm-2.0.1.tgz", + "integrity": "sha512-oL8vJcnk0Bx/onl+TgQOQ1t/534GKFaEG17fZmwtPFeH8S5soiBYPCLUrvANOl4sCp9elYxIMzIiTtMtNNN8EQ==", + "dev": true, + "requires": { + "@ethersproject/providers": "^5.7.1", + "@nomicfoundation/ethereumjs-common": "4.0.1", + "@nomicfoundation/ethereumjs-tx": "5.0.1", + "@nomicfoundation/ethereumjs-util": "9.0.1", + "debug": "^4.3.3", + "ethereum-cryptography": "0.1.3", + "mcl-wasm": "^0.7.1", + "rustbn.js": "~0.2.0" + }, + "dependencies": { + "ethereum-cryptography": { + "version": "0.1.3", + "resolved": "https://registry.npmjs.org/ethereum-cryptography/-/ethereum-cryptography-0.1.3.tgz", + "integrity": "sha512-w8/4x1SGGzc+tO97TASLja6SLd3fRIK2tLVcV2Gx4IB21hE19atll5Cq9o3d0ZmAYC/8aw0ipieTSiekAea4SQ==", + "dev": true, + "requires": { + "@types/pbkdf2": "^3.0.0", + "@types/secp256k1": "^4.0.1", + "blakejs": "^1.1.0", + "browserify-aes": "^1.2.0", + "bs58check": "^2.1.2", + "create-hash": "^1.2.0", + "create-hmac": "^1.1.7", + "hash.js": "^1.1.7", + "keccak": "^3.0.0", + "pbkdf2": "^3.0.17", + "randombytes": "^2.1.0", + "safe-buffer": "^5.1.2", + "scrypt-js": "^3.0.0", + "secp256k1": "^4.0.1", + "setimmediate": "^1.0.5" + } + } + } + }, + "@nomicfoundation/ethereumjs-rlp": { + "version": "5.0.1", + "resolved": "https://registry.npmjs.org/@nomicfoundation/ethereumjs-rlp/-/ethereumjs-rlp-5.0.1.tgz", + "integrity": "sha512-xtxrMGa8kP4zF5ApBQBtjlSbN5E2HI8m8FYgVSYAnO6ssUoY5pVPGy2H8+xdf/bmMa22Ce8nWMH3aEW8CcqMeQ==", + "dev": true + }, + "@nomicfoundation/ethereumjs-statemanager": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/@nomicfoundation/ethereumjs-statemanager/-/ethereumjs-statemanager-2.0.1.tgz", + "integrity": "sha512-B5ApMOnlruVOR7gisBaYwFX+L/AP7i/2oAahatssjPIBVDF6wTX1K7Qpa39E/nzsH8iYuL3krkYeUFIdO3EMUQ==", + "dev": true, + "requires": { + "@nomicfoundation/ethereumjs-common": "4.0.1", + "@nomicfoundation/ethereumjs-rlp": "5.0.1", + "debug": "^4.3.3", + "ethereum-cryptography": "0.1.3", + "ethers": "^5.7.1", + "js-sdsl": "^4.1.4" + }, + "dependencies": { + "ethereum-cryptography": { + "version": "0.1.3", + "resolved": "https://registry.npmjs.org/ethereum-cryptography/-/ethereum-cryptography-0.1.3.tgz", + "integrity": "sha512-w8/4x1SGGzc+tO97TASLja6SLd3fRIK2tLVcV2Gx4IB21hE19atll5Cq9o3d0ZmAYC/8aw0ipieTSiekAea4SQ==", + "dev": true, + "requires": { + "@types/pbkdf2": "^3.0.0", + "@types/secp256k1": "^4.0.1", + "blakejs": "^1.1.0", + "browserify-aes": "^1.2.0", + "bs58check": "^2.1.2", + "create-hash": "^1.2.0", + "create-hmac": "^1.1.7", + "hash.js": "^1.1.7", + "keccak": "^3.0.0", + "pbkdf2": "^3.0.17", + "randombytes": "^2.1.0", + "safe-buffer": "^5.1.2", + "scrypt-js": "^3.0.0", + "secp256k1": "^4.0.1", + "setimmediate": "^1.0.5" + } + } + } + }, + "@nomicfoundation/ethereumjs-trie": { + "version": "6.0.1", + "resolved": "https://registry.npmjs.org/@nomicfoundation/ethereumjs-trie/-/ethereumjs-trie-6.0.1.tgz", + "integrity": "sha512-A64It/IMpDVODzCgxDgAAla8jNjNtsoQZIzZUfIV5AY6Coi4nvn7+VReBn5itlxMiL2yaTlQr9TRWp3CSI6VoA==", + "dev": true, + "requires": { + "@nomicfoundation/ethereumjs-rlp": "5.0.1", + "@nomicfoundation/ethereumjs-util": "9.0.1", + "@types/readable-stream": "^2.3.13", + "ethereum-cryptography": "0.1.3", + "readable-stream": "^3.6.0" + }, + "dependencies": { + "ethereum-cryptography": { + "version": "0.1.3", + "resolved": "https://registry.npmjs.org/ethereum-cryptography/-/ethereum-cryptography-0.1.3.tgz", + "integrity": "sha512-w8/4x1SGGzc+tO97TASLja6SLd3fRIK2tLVcV2Gx4IB21hE19atll5Cq9o3d0ZmAYC/8aw0ipieTSiekAea4SQ==", + "dev": true, + "requires": { + "@types/pbkdf2": "^3.0.0", + "@types/secp256k1": "^4.0.1", + "blakejs": "^1.1.0", + "browserify-aes": "^1.2.0", + "bs58check": "^2.1.2", + "create-hash": "^1.2.0", + "create-hmac": "^1.1.7", + "hash.js": "^1.1.7", + "keccak": "^3.0.0", + "pbkdf2": "^3.0.17", + "randombytes": "^2.1.0", + "safe-buffer": "^5.1.2", + "scrypt-js": "^3.0.0", + "secp256k1": "^4.0.1", + "setimmediate": "^1.0.5" + } + } + } + }, + "@nomicfoundation/ethereumjs-tx": { + "version": "5.0.1", + "resolved": "https://registry.npmjs.org/@nomicfoundation/ethereumjs-tx/-/ethereumjs-tx-5.0.1.tgz", + "integrity": "sha512-0HwxUF2u2hrsIM1fsasjXvlbDOq1ZHFV2dd1yGq8CA+MEYhaxZr8OTScpVkkxqMwBcc5y83FyPl0J9MZn3kY0w==", + "dev": true, + "requires": { + "@chainsafe/ssz": "^0.9.2", + "@ethersproject/providers": "^5.7.2", + "@nomicfoundation/ethereumjs-common": "4.0.1", + "@nomicfoundation/ethereumjs-rlp": "5.0.1", + "@nomicfoundation/ethereumjs-util": "9.0.1", + "ethereum-cryptography": "0.1.3" + }, + "dependencies": { + "ethereum-cryptography": { + "version": "0.1.3", + "resolved": "https://registry.npmjs.org/ethereum-cryptography/-/ethereum-cryptography-0.1.3.tgz", + "integrity": "sha512-w8/4x1SGGzc+tO97TASLja6SLd3fRIK2tLVcV2Gx4IB21hE19atll5Cq9o3d0ZmAYC/8aw0ipieTSiekAea4SQ==", + "dev": true, + "requires": { + "@types/pbkdf2": "^3.0.0", + "@types/secp256k1": "^4.0.1", + "blakejs": "^1.1.0", + "browserify-aes": "^1.2.0", + "bs58check": "^2.1.2", + "create-hash": "^1.2.0", + "create-hmac": "^1.1.7", + "hash.js": "^1.1.7", + "keccak": "^3.0.0", + "pbkdf2": "^3.0.17", + "randombytes": "^2.1.0", + "safe-buffer": "^5.1.2", + "scrypt-js": "^3.0.0", + "secp256k1": "^4.0.1", + "setimmediate": "^1.0.5" + } + } + } + }, + "@nomicfoundation/ethereumjs-util": { + "version": "9.0.1", + "resolved": "https://registry.npmjs.org/@nomicfoundation/ethereumjs-util/-/ethereumjs-util-9.0.1.tgz", + "integrity": "sha512-TwbhOWQ8QoSCFhV/DDfSmyfFIHjPjFBj957219+V3jTZYZ2rf9PmDtNOeZWAE3p3vlp8xb02XGpd0v6nTUPbsA==", + "dev": true, + "requires": { + "@chainsafe/ssz": "^0.10.0", + "@nomicfoundation/ethereumjs-rlp": "5.0.1", + "ethereum-cryptography": "0.1.3" + }, + "dependencies": { + "@chainsafe/persistent-merkle-tree": { + "version": "0.5.0", + "resolved": "https://registry.npmjs.org/@chainsafe/persistent-merkle-tree/-/persistent-merkle-tree-0.5.0.tgz", + "integrity": "sha512-l0V1b5clxA3iwQLXP40zYjyZYospQLZXzBVIhhr9kDg/1qHZfzzHw0jj4VPBijfYCArZDlPkRi1wZaV2POKeuw==", + "dev": true, + "requires": { + "@chainsafe/as-sha256": "^0.3.1" + } + }, + "@chainsafe/ssz": { + "version": "0.10.2", + "resolved": "https://registry.npmjs.org/@chainsafe/ssz/-/ssz-0.10.2.tgz", + "integrity": "sha512-/NL3Lh8K+0q7A3LsiFq09YXS9fPE+ead2rr7vM2QK8PLzrNsw3uqrif9bpRX5UxgeRjM+vYi+boCM3+GM4ovXg==", + "dev": true, + "requires": { + "@chainsafe/as-sha256": "^0.3.1", + "@chainsafe/persistent-merkle-tree": "^0.5.0" + } + }, + "ethereum-cryptography": { + "version": "0.1.3", + "resolved": "https://registry.npmjs.org/ethereum-cryptography/-/ethereum-cryptography-0.1.3.tgz", + "integrity": "sha512-w8/4x1SGGzc+tO97TASLja6SLd3fRIK2tLVcV2Gx4IB21hE19atll5Cq9o3d0ZmAYC/8aw0ipieTSiekAea4SQ==", + "dev": true, + "requires": { + "@types/pbkdf2": "^3.0.0", + "@types/secp256k1": "^4.0.1", + "blakejs": "^1.1.0", + "browserify-aes": "^1.2.0", + "bs58check": "^2.1.2", + "create-hash": "^1.2.0", + "create-hmac": "^1.1.7", + "hash.js": "^1.1.7", + "keccak": "^3.0.0", + "pbkdf2": "^3.0.17", + "randombytes": "^2.1.0", + "safe-buffer": "^5.1.2", + "scrypt-js": "^3.0.0", + "secp256k1": "^4.0.1", + "setimmediate": "^1.0.5" + } + } + } + }, + "@nomicfoundation/ethereumjs-vm": { + "version": "7.0.1", + "resolved": "https://registry.npmjs.org/@nomicfoundation/ethereumjs-vm/-/ethereumjs-vm-7.0.1.tgz", + "integrity": "sha512-rArhyn0jPsS/D+ApFsz3yVJMQ29+pVzNZ0VJgkzAZ+7FqXSRtThl1C1prhmlVr3YNUlfpZ69Ak+RUT4g7VoOuQ==", + "dev": true, + "requires": { + "@nomicfoundation/ethereumjs-block": "5.0.1", + "@nomicfoundation/ethereumjs-blockchain": "7.0.1", + "@nomicfoundation/ethereumjs-common": "4.0.1", + "@nomicfoundation/ethereumjs-evm": "2.0.1", + "@nomicfoundation/ethereumjs-rlp": "5.0.1", + "@nomicfoundation/ethereumjs-statemanager": "2.0.1", + "@nomicfoundation/ethereumjs-trie": "6.0.1", + "@nomicfoundation/ethereumjs-tx": "5.0.1", + "@nomicfoundation/ethereumjs-util": "9.0.1", + "debug": "^4.3.3", + "ethereum-cryptography": "0.1.3", + "mcl-wasm": "^0.7.1", + "rustbn.js": "~0.2.0" + }, + "dependencies": { + "ethereum-cryptography": { + "version": "0.1.3", + "resolved": "https://registry.npmjs.org/ethereum-cryptography/-/ethereum-cryptography-0.1.3.tgz", + "integrity": "sha512-w8/4x1SGGzc+tO97TASLja6SLd3fRIK2tLVcV2Gx4IB21hE19atll5Cq9o3d0ZmAYC/8aw0ipieTSiekAea4SQ==", + "dev": true, + "requires": { + "@types/pbkdf2": "^3.0.0", + "@types/secp256k1": "^4.0.1", + "blakejs": "^1.1.0", + "browserify-aes": "^1.2.0", + "bs58check": "^2.1.2", + "create-hash": "^1.2.0", + "create-hmac": "^1.1.7", + "hash.js": "^1.1.7", + "keccak": "^3.0.0", + "pbkdf2": "^3.0.17", + "randombytes": "^2.1.0", + "safe-buffer": "^5.1.2", + "scrypt-js": "^3.0.0", + "secp256k1": "^4.0.1", + "setimmediate": "^1.0.5" + } + } + } + }, + "@nomicfoundation/hardhat-chai-matchers": { + "version": "1.0.6", + "resolved": "https://registry.npmjs.org/@nomicfoundation/hardhat-chai-matchers/-/hardhat-chai-matchers-1.0.6.tgz", + "integrity": "sha512-f5ZMNmabZeZegEfuxn/0kW+mm7+yV7VNDxLpMOMGXWFJ2l/Ct3QShujzDRF9cOkK9Ui/hbDeOWGZqyQALDXVCQ==", + "dev": true, + "peer": true, + "requires": { + "@ethersproject/abi": "^5.1.2", + "@types/chai-as-promised": "^7.1.3", + "chai-as-promised": "^7.1.1", + "deep-eql": "^4.0.1", + "ordinal": "^1.0.3" + } + }, + "@nomicfoundation/hardhat-network-helpers": { + "version": "1.0.8", + "resolved": "https://registry.npmjs.org/@nomicfoundation/hardhat-network-helpers/-/hardhat-network-helpers-1.0.8.tgz", + "integrity": "sha512-MNqQbzUJZnCMIYvlniC3U+kcavz/PhhQSsY90tbEtUyMj/IQqsLwIRZa4ctjABh3Bz0KCh9OXUZ7Yk/d9hr45Q==", + "dev": true, + "peer": true, + "requires": { + "ethereumjs-util": "^7.1.4" + }, + "dependencies": { + "ethereum-cryptography": { + "version": "0.1.3", + "resolved": "https://registry.npmjs.org/ethereum-cryptography/-/ethereum-cryptography-0.1.3.tgz", + "integrity": "sha512-w8/4x1SGGzc+tO97TASLja6SLd3fRIK2tLVcV2Gx4IB21hE19atll5Cq9o3d0ZmAYC/8aw0ipieTSiekAea4SQ==", + "dev": true, + "peer": true, + "requires": { + "@types/pbkdf2": "^3.0.0", + "@types/secp256k1": "^4.0.1", + "blakejs": "^1.1.0", + "browserify-aes": "^1.2.0", + "bs58check": "^2.1.2", + "create-hash": "^1.2.0", + "create-hmac": "^1.1.7", + "hash.js": "^1.1.7", + "keccak": "^3.0.0", + "pbkdf2": "^3.0.17", + "randombytes": "^2.1.0", + "safe-buffer": "^5.1.2", + "scrypt-js": "^3.0.0", + "secp256k1": "^4.0.1", + "setimmediate": "^1.0.5" + } + }, + "ethereumjs-util": { + "version": "7.1.5", + "resolved": "https://registry.npmjs.org/ethereumjs-util/-/ethereumjs-util-7.1.5.tgz", + "integrity": "sha512-SDl5kKrQAudFBUe5OJM9Ac6WmMyYmXX/6sTmLZ3ffG2eY6ZIGBes3pEDxNN6V72WyOw4CPD5RomKdsa8DAAwLg==", + "dev": true, + "peer": true, + "requires": { + "@types/bn.js": "^5.1.0", + "bn.js": "^5.1.2", + "create-hash": "^1.1.2", + "ethereum-cryptography": "^0.1.3", + "rlp": "^2.2.4" + } + } + } + }, + "@nomicfoundation/hardhat-toolbox": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/@nomicfoundation/hardhat-toolbox/-/hardhat-toolbox-2.0.2.tgz", + "integrity": "sha512-vnN1AzxbvpSx9pfdRHbUzTRIXpMLPXnUlkW855VaDk6N1pwRaQ2gNzEmFAABk4lWf11E00PKwFd/q27HuwYrYg==", + "dev": true, + "requires": {} + }, + "@nomicfoundation/solidity-analyzer": { + "version": "0.1.1", + "resolved": "https://registry.npmjs.org/@nomicfoundation/solidity-analyzer/-/solidity-analyzer-0.1.1.tgz", + "integrity": "sha512-1LMtXj1puAxyFusBgUIy5pZk3073cNXYnXUpuNKFghHbIit/xZgbk0AokpUADbNm3gyD6bFWl3LRFh3dhVdREg==", + "dev": true, + "requires": { + "@nomicfoundation/solidity-analyzer-darwin-arm64": "0.1.1", + "@nomicfoundation/solidity-analyzer-darwin-x64": "0.1.1", + "@nomicfoundation/solidity-analyzer-freebsd-x64": "0.1.1", + "@nomicfoundation/solidity-analyzer-linux-arm64-gnu": "0.1.1", + "@nomicfoundation/solidity-analyzer-linux-arm64-musl": "0.1.1", + "@nomicfoundation/solidity-analyzer-linux-x64-gnu": "0.1.1", + "@nomicfoundation/solidity-analyzer-linux-x64-musl": "0.1.1", + "@nomicfoundation/solidity-analyzer-win32-arm64-msvc": "0.1.1", + "@nomicfoundation/solidity-analyzer-win32-ia32-msvc": "0.1.1", + "@nomicfoundation/solidity-analyzer-win32-x64-msvc": "0.1.1" + } + }, + "@nomicfoundation/solidity-analyzer-darwin-arm64": { + "version": "0.1.1", + "resolved": "https://registry.npmjs.org/@nomicfoundation/solidity-analyzer-darwin-arm64/-/solidity-analyzer-darwin-arm64-0.1.1.tgz", + "integrity": "sha512-KcTodaQw8ivDZyF+D76FokN/HdpgGpfjc/gFCImdLUyqB6eSWVaZPazMbeAjmfhx3R0zm/NYVzxwAokFKgrc0w==", + "dev": true, + "optional": true + }, + "@nomicfoundation/solidity-analyzer-darwin-x64": { + "version": "0.1.1", + "resolved": "https://registry.npmjs.org/@nomicfoundation/solidity-analyzer-darwin-x64/-/solidity-analyzer-darwin-x64-0.1.1.tgz", + "integrity": "sha512-XhQG4BaJE6cIbjAVtzGOGbK3sn1BO9W29uhk9J8y8fZF1DYz0Doj8QDMfpMu+A6TjPDs61lbsmeYodIDnfveSA==", + "dev": true, + "optional": true + }, + "@nomicfoundation/solidity-analyzer-freebsd-x64": { + "version": "0.1.1", + "resolved": "https://registry.npmjs.org/@nomicfoundation/solidity-analyzer-freebsd-x64/-/solidity-analyzer-freebsd-x64-0.1.1.tgz", + "integrity": "sha512-GHF1VKRdHW3G8CndkwdaeLkVBi5A9u2jwtlS7SLhBc8b5U/GcoL39Q+1CSO3hYqePNP+eV5YI7Zgm0ea6kMHoA==", + "dev": true, + "optional": true + }, + "@nomicfoundation/solidity-analyzer-linux-arm64-gnu": { + "version": "0.1.1", + "resolved": "https://registry.npmjs.org/@nomicfoundation/solidity-analyzer-linux-arm64-gnu/-/solidity-analyzer-linux-arm64-gnu-0.1.1.tgz", + "integrity": "sha512-g4Cv2fO37ZsUENQ2vwPnZc2zRenHyAxHcyBjKcjaSmmkKrFr64yvzeNO8S3GBFCo90rfochLs99wFVGT/0owpg==", + "dev": true, + "optional": true + }, + "@nomicfoundation/solidity-analyzer-linux-arm64-musl": { + "version": "0.1.1", + "resolved": "https://registry.npmjs.org/@nomicfoundation/solidity-analyzer-linux-arm64-musl/-/solidity-analyzer-linux-arm64-musl-0.1.1.tgz", + "integrity": "sha512-WJ3CE5Oek25OGE3WwzK7oaopY8xMw9Lhb0mlYuJl/maZVo+WtP36XoQTb7bW/i8aAdHW5Z+BqrHMux23pvxG3w==", + "dev": true, + "optional": true + }, + "@nomicfoundation/solidity-analyzer-linux-x64-gnu": { + "version": "0.1.1", + "resolved": "https://registry.npmjs.org/@nomicfoundation/solidity-analyzer-linux-x64-gnu/-/solidity-analyzer-linux-x64-gnu-0.1.1.tgz", + "integrity": "sha512-5WN7leSr5fkUBBjE4f3wKENUy9HQStu7HmWqbtknfXkkil+eNWiBV275IOlpXku7v3uLsXTOKpnnGHJYI2qsdA==", + "dev": true, + "optional": true + }, + "@nomicfoundation/solidity-analyzer-linux-x64-musl": { + "version": "0.1.1", + "resolved": "https://registry.npmjs.org/@nomicfoundation/solidity-analyzer-linux-x64-musl/-/solidity-analyzer-linux-x64-musl-0.1.1.tgz", + "integrity": "sha512-KdYMkJOq0SYPQMmErv/63CwGwMm5XHenEna9X9aB8mQmhDBrYrlAOSsIPgFCUSL0hjxE3xHP65/EPXR/InD2+w==", + "dev": true, + "optional": true + }, + "@nomicfoundation/solidity-analyzer-win32-arm64-msvc": { + "version": "0.1.1", + "resolved": "https://registry.npmjs.org/@nomicfoundation/solidity-analyzer-win32-arm64-msvc/-/solidity-analyzer-win32-arm64-msvc-0.1.1.tgz", + "integrity": "sha512-VFZASBfl4qiBYwW5xeY20exWhmv6ww9sWu/krWSesv3q5hA0o1JuzmPHR4LPN6SUZj5vcqci0O6JOL8BPw+APg==", + "dev": true, + "optional": true + }, + "@nomicfoundation/solidity-analyzer-win32-ia32-msvc": { + "version": "0.1.1", + "resolved": "https://registry.npmjs.org/@nomicfoundation/solidity-analyzer-win32-ia32-msvc/-/solidity-analyzer-win32-ia32-msvc-0.1.1.tgz", + "integrity": "sha512-JnFkYuyCSA70j6Si6cS1A9Gh1aHTEb8kOTBApp/c7NRTFGNMH8eaInKlyuuiIbvYFhlXW4LicqyYuWNNq9hkpQ==", + "dev": true, + "optional": true + }, + "@nomicfoundation/solidity-analyzer-win32-x64-msvc": { + "version": "0.1.1", + "resolved": "https://registry.npmjs.org/@nomicfoundation/solidity-analyzer-win32-x64-msvc/-/solidity-analyzer-win32-x64-msvc-0.1.1.tgz", + "integrity": "sha512-HrVJr6+WjIXGnw3Q9u6KQcbZCtk0caVWhCdFADySvRyUxJ8PnzlaP+MhwNE8oyT8OZ6ejHBRrrgjSqDCFXGirw==", + "dev": true, + "optional": true + }, + "@nomiclabs/hardhat-ethers": { + "version": "2.2.3", + "resolved": "https://registry.npmjs.org/@nomiclabs/hardhat-ethers/-/hardhat-ethers-2.2.3.tgz", + "integrity": "sha512-YhzPdzb612X591FOe68q+qXVXGG2ANZRvDo0RRUtimev85rCrAlv/TLMEZw5c+kq9AbzocLTVX/h2jVIFPL9Xg==", + "dev": true, + "peer": true, + "requires": {} + }, + "@nomiclabs/hardhat-etherscan": { + "version": "3.1.7", + "resolved": "https://registry.npmjs.org/@nomiclabs/hardhat-etherscan/-/hardhat-etherscan-3.1.7.tgz", + "integrity": "sha512-tZ3TvSgpvsQ6B6OGmo1/Au6u8BrAkvs1mIC/eURA3xgIfznUZBhmpne8hv7BXUzw9xNL3fXdpOYgOQlVMTcoHQ==", + "dev": true, + "peer": true, + "requires": { + "@ethersproject/abi": "^5.1.2", + "@ethersproject/address": "^5.0.2", + "cbor": "^8.1.0", + "chalk": "^2.4.2", + "debug": "^4.1.1", + "fs-extra": "^7.0.1", + "lodash": "^4.17.11", + "semver": "^6.3.0", + "table": "^6.8.0", + "undici": "^5.14.0" + } + }, + "@openzeppelin/contracts": { + "version": "4.8.3", + "resolved": "https://registry.npmjs.org/@openzeppelin/contracts/-/contracts-4.8.3.tgz", + "integrity": "sha512-bQHV8R9Me8IaJoJ2vPG4rXcL7seB7YVuskr4f+f5RyOStSZetwzkWtoqDMl5erkBJy0lDRUnIR2WIkPiC0GJlg==", + "dev": true + }, + "@scure/base": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/@scure/base/-/base-1.1.1.tgz", + "integrity": "sha512-ZxOhsSyxYwLJj3pLZCefNitxsj093tb2vq90mp2txoYeBqbcjDjqFhyM8eUjq/uFm6zJ+mUuqxlS2FkuSY1MTA==", + "dev": true + }, + "@scure/bip32": { + "version": "1.1.5", + "resolved": "https://registry.npmjs.org/@scure/bip32/-/bip32-1.1.5.tgz", + "integrity": "sha512-XyNh1rB0SkEqd3tXcXMi+Xe1fvg+kUIcoRIEujP1Jgv7DqW2r9lg3Ah0NkFaCs9sTkQAQA8kw7xiRXzENi9Rtw==", + "dev": true, + "requires": { + "@noble/hashes": "~1.2.0", + "@noble/secp256k1": "~1.7.0", + "@scure/base": "~1.1.0" + } + }, + "@scure/bip39": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/@scure/bip39/-/bip39-1.1.1.tgz", + "integrity": "sha512-t+wDck2rVkh65Hmv280fYdVdY25J9YeEUIgn2LG1WM6gxFkGzcksoDiUkWVpVp3Oex9xGC68JU2dSbUfwZ2jPg==", + "dev": true, + "requires": { + "@noble/hashes": "~1.2.0", + "@scure/base": "~1.1.0" + } + }, + "@sentry/core": { + "version": "5.30.0", + "resolved": "https://registry.npmjs.org/@sentry/core/-/core-5.30.0.tgz", + "integrity": "sha512-TmfrII8w1PQZSZgPpUESqjB+jC6MvZJZdLtE/0hZ+SrnKhW3x5WlYLvTXZpcWePYBku7rl2wn1RZu6uT0qCTeg==", + "dev": true, + "requires": { + "@sentry/hub": "5.30.0", + "@sentry/minimal": "5.30.0", + "@sentry/types": "5.30.0", + "@sentry/utils": "5.30.0", + "tslib": "^1.9.3" + } + }, + "@sentry/hub": { + "version": "5.30.0", + "resolved": "https://registry.npmjs.org/@sentry/hub/-/hub-5.30.0.tgz", + "integrity": "sha512-2tYrGnzb1gKz2EkMDQcfLrDTvmGcQPuWxLnJKXJvYTQDGLlEvi2tWz1VIHjunmOvJrB5aIQLhm+dcMRwFZDCqQ==", + "dev": true, + "requires": { + "@sentry/types": "5.30.0", + "@sentry/utils": "5.30.0", + "tslib": "^1.9.3" + } + }, + "@sentry/minimal": { + "version": "5.30.0", + "resolved": "https://registry.npmjs.org/@sentry/minimal/-/minimal-5.30.0.tgz", + "integrity": "sha512-BwWb/owZKtkDX+Sc4zCSTNcvZUq7YcH3uAVlmh/gtR9rmUvbzAA3ewLuB3myi4wWRAMEtny6+J/FN/x+2wn9Xw==", + "dev": true, + "requires": { + "@sentry/hub": "5.30.0", + "@sentry/types": "5.30.0", + "tslib": "^1.9.3" + } + }, + "@sentry/node": { + "version": "5.30.0", + "resolved": "https://registry.npmjs.org/@sentry/node/-/node-5.30.0.tgz", + "integrity": "sha512-Br5oyVBF0fZo6ZS9bxbJZG4ApAjRqAnqFFurMVJJdunNb80brh7a5Qva2kjhm+U6r9NJAB5OmDyPkA1Qnt+QVg==", + "dev": true, + "requires": { + "@sentry/core": "5.30.0", + "@sentry/hub": "5.30.0", + "@sentry/tracing": "5.30.0", + "@sentry/types": "5.30.0", + "@sentry/utils": "5.30.0", + "cookie": "^0.4.1", + "https-proxy-agent": "^5.0.0", + "lru_map": "^0.3.3", + "tslib": "^1.9.3" + } + }, + "@sentry/tracing": { + "version": "5.30.0", + "resolved": "https://registry.npmjs.org/@sentry/tracing/-/tracing-5.30.0.tgz", + "integrity": "sha512-dUFowCr0AIMwiLD7Fs314Mdzcug+gBVo/+NCMyDw8tFxJkwWAKl7Qa2OZxLQ0ZHjakcj1hNKfCQJ9rhyfOl4Aw==", + "dev": true, + "requires": { + "@sentry/hub": "5.30.0", + "@sentry/minimal": "5.30.0", + "@sentry/types": "5.30.0", + "@sentry/utils": "5.30.0", + "tslib": "^1.9.3" + } + }, + "@sentry/types": { + "version": "5.30.0", + "resolved": "https://registry.npmjs.org/@sentry/types/-/types-5.30.0.tgz", + "integrity": "sha512-R8xOqlSTZ+htqrfteCWU5Nk0CDN5ApUTvrlvBuiH1DyP6czDZ4ktbZB0hAgBlVcK0U+qpD3ag3Tqqpa5Q67rPw==", + "dev": true + }, + "@sentry/utils": { + "version": "5.30.0", + "resolved": "https://registry.npmjs.org/@sentry/utils/-/utils-5.30.0.tgz", + "integrity": "sha512-zaYmoH0NWWtvnJjC9/CBseXMtKHm/tm40sz3YfJRxeQjyzRqNQPgivpd9R/oDJCYj999mzdW382p/qi2ypjLww==", + "dev": true, + "requires": { + "@sentry/types": "5.30.0", + "tslib": "^1.9.3" + } + }, + "@solidity-parser/parser": { + "version": "0.14.5", + "resolved": "https://registry.npmjs.org/@solidity-parser/parser/-/parser-0.14.5.tgz", + "integrity": "sha512-6dKnHZn7fg/iQATVEzqyUOyEidbn05q7YA2mQ9hC0MMXhhV3/JrsxmFSYZAcr7j1yUP700LLhTruvJ3MiQmjJg==", + "dev": true, + "peer": true, + "requires": { + "antlr4ts": "^0.5.0-alpha.4" + } + }, + "@tsconfig/node10": { + "version": "1.0.9", + "resolved": "https://registry.npmjs.org/@tsconfig/node10/-/node10-1.0.9.tgz", + "integrity": "sha512-jNsYVVxU8v5g43Erja32laIDHXeoNvFEpX33OK4d6hljo3jDhCBDhx5dhCCTMWUojscpAagGiRkBKxpdl9fxqA==", + "dev": true, + "peer": true + }, + "@tsconfig/node12": { + "version": "1.0.11", + "resolved": "https://registry.npmjs.org/@tsconfig/node12/-/node12-1.0.11.tgz", + "integrity": "sha512-cqefuRsh12pWyGsIoBKJA9luFu3mRxCA+ORZvA4ktLSzIuCUtWVxGIuXigEwO5/ywWFMZ2QEGKWvkZG1zDMTag==", + "dev": true, + "peer": true + }, + "@tsconfig/node14": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/@tsconfig/node14/-/node14-1.0.3.tgz", + "integrity": "sha512-ysT8mhdixWK6Hw3i1V2AeRqZ5WfXg1G43mqoYlM2nc6388Fq5jcXyr5mRsqViLx/GJYdoL0bfXD8nmF+Zn/Iow==", + "dev": true, + "peer": true + }, + "@tsconfig/node16": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/@tsconfig/node16/-/node16-1.0.3.tgz", + "integrity": "sha512-yOlFc+7UtL/89t2ZhjPvvB/DeAr3r+Dq58IgzsFkOAvVC6NMJXmCGjbptdXdR9qsX7pKcTL+s87FtYREi2dEEQ==", + "dev": true, + "peer": true + }, + "@typechain/ethers-v5": { + "version": "10.2.0", + "resolved": "https://registry.npmjs.org/@typechain/ethers-v5/-/ethers-v5-10.2.0.tgz", + "integrity": "sha512-ikaq0N/w9fABM+G01OFmU3U3dNnyRwEahkdvi9mqy1a3XwKiPZaF/lu54OcNaEWnpvEYyhhS0N7buCtLQqC92w==", + "dev": true, + "peer": true, + "requires": { + "lodash": "^4.17.15", + "ts-essentials": "^7.0.1" + } + }, + "@typechain/hardhat": { + "version": "6.1.5", + "resolved": "https://registry.npmjs.org/@typechain/hardhat/-/hardhat-6.1.5.tgz", + "integrity": "sha512-lg7LW4qDZpxFMknp3Xool61Fg6Lays8F8TXdFGBG+MxyYcYU5795P1U2XdStuzGq9S2Dzdgh+1jGww9wvZ6r4Q==", + "dev": true, + "peer": true, + "requires": { + "fs-extra": "^9.1.0" + }, + "dependencies": { + "fs-extra": { + "version": "9.1.0", + "resolved": "https://registry.npmjs.org/fs-extra/-/fs-extra-9.1.0.tgz", + "integrity": "sha512-hcg3ZmepS30/7BSFqRvoo3DOMQu7IjqxO5nCDt+zM9XWjb33Wg7ziNT+Qvqbuc3+gWpzO02JubVyk2G4Zvo1OQ==", + "dev": true, + "peer": true, + "requires": { + "at-least-node": "^1.0.0", + "graceful-fs": "^4.2.0", + "jsonfile": "^6.0.1", + "universalify": "^2.0.0" + } + }, + "jsonfile": { + "version": "6.1.0", + "resolved": "https://registry.npmjs.org/jsonfile/-/jsonfile-6.1.0.tgz", + "integrity": "sha512-5dgndWOriYSm5cnYaJNhalLNDKOqFwyDB/rr1E9ZsGciGvKPs8R2xYGCacuf3z6K1YKDz182fd+fY3cn3pMqXQ==", + "dev": true, + "peer": true, + "requires": { + "graceful-fs": "^4.1.6", + "universalify": "^2.0.0" + } + }, + "universalify": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/universalify/-/universalify-2.0.0.tgz", + "integrity": "sha512-hAZsKq7Yy11Zu1DE0OzWjw7nnLZmJZYTDZZyEFHZdUhV8FkH5MCfoU1XMaxXovpyW5nq5scPqq0ZDP9Zyl04oQ==", + "dev": true, + "peer": true + } + } + }, + "@types/bn.js": { + "version": "5.1.1", + "resolved": "https://registry.npmjs.org/@types/bn.js/-/bn.js-5.1.1.tgz", + "integrity": "sha512-qNrYbZqMx0uJAfKnKclPh+dTwK33KfLHYqtyODwd5HnXOjnkhc4qgn3BrK6RWyGZm5+sIFE7Q7Vz6QQtJB7w7g==", + "dev": true, + "requires": { + "@types/node": "*" + } + }, + "@types/chai": { + "version": "4.3.5", + "resolved": "https://registry.npmjs.org/@types/chai/-/chai-4.3.5.tgz", + "integrity": "sha512-mEo1sAde+UCE6b2hxn332f1g1E8WfYRu6p5SvTKr2ZKC1f7gFJXk4h5PyGP9Dt6gCaG8y8XhwnXWC6Iy2cmBng==", + "dev": true, + "peer": true + }, + "@types/chai-as-promised": { + "version": "7.1.5", + "resolved": "https://registry.npmjs.org/@types/chai-as-promised/-/chai-as-promised-7.1.5.tgz", + "integrity": "sha512-jStwss93SITGBwt/niYrkf2C+/1KTeZCZl1LaeezTlqppAKeoQC7jxyqYuP72sxBGKCIbw7oHgbYssIRzT5FCQ==", + "dev": true, + "peer": true, + "requires": { + "@types/chai": "*" + } + }, + "@types/concat-stream": { + "version": "1.6.1", + "resolved": "https://registry.npmjs.org/@types/concat-stream/-/concat-stream-1.6.1.tgz", + "integrity": "sha512-eHE4cQPoj6ngxBZMvVf6Hw7Mh4jMW4U9lpGmS5GBPB9RYxlFg+CHaVN7ErNY4W9XfLIEn20b4VDYaIrbq0q4uA==", + "dev": true, + "peer": true, + "requires": { + "@types/node": "*" + } + }, + "@types/form-data": { + "version": "0.0.33", + "resolved": "https://registry.npmjs.org/@types/form-data/-/form-data-0.0.33.tgz", + "integrity": "sha512-8BSvG1kGm83cyJITQMZSulnl6QV8jqAGreJsc5tPu1Jq0vTSOiY/k24Wx82JRpWwZSqrala6sd5rWi6aNXvqcw==", + "dev": true, + "peer": true, + "requires": { + "@types/node": "*" + } + }, + "@types/glob": { + "version": "7.2.0", + "resolved": "https://registry.npmjs.org/@types/glob/-/glob-7.2.0.tgz", + "integrity": "sha512-ZUxbzKl0IfJILTS6t7ip5fQQM/J3TJYubDm3nMbgubNNYS62eXeUpoLUC8/7fJNiFYHTrGPQn7hspDUzIHX3UA==", + "dev": true, + "peer": true, + "requires": { + "@types/minimatch": "*", + "@types/node": "*" + } + }, + "@types/lru-cache": { + "version": "5.1.1", + "resolved": "https://registry.npmjs.org/@types/lru-cache/-/lru-cache-5.1.1.tgz", + "integrity": "sha512-ssE3Vlrys7sdIzs5LOxCzTVMsU7i9oa/IaW92wF32JFb3CVczqOkru2xspuKczHEbG3nvmPY7IFqVmGGHdNbYw==", + "dev": true + }, + "@types/minimatch": { + "version": "5.1.2", + "resolved": "https://registry.npmjs.org/@types/minimatch/-/minimatch-5.1.2.tgz", + "integrity": "sha512-K0VQKziLUWkVKiRVrx4a40iPaxTUefQmjtkQofBkYRcoaaL/8rhwDWww9qWbrgicNOgnpIsMxyNIUM4+n6dUIA==", + "dev": true, + "peer": true + }, + "@types/mocha": { + "version": "10.0.1", + "resolved": "https://registry.npmjs.org/@types/mocha/-/mocha-10.0.1.tgz", + "integrity": "sha512-/fvYntiO1GeICvqbQ3doGDIP97vWmvFt83GKguJ6prmQM2iXZfFcq6YE8KteFyRtX2/h5Hf91BYvPodJKFYv5Q==", + "dev": true, + "peer": true + }, + "@types/node": { + "version": "18.16.3", + "resolved": "https://registry.npmjs.org/@types/node/-/node-18.16.3.tgz", + "integrity": "sha512-OPs5WnnT1xkCBiuQrZA4+YAV4HEJejmHneyraIaxsbev5yCEr6KMwINNFP9wQeFIw8FWcoTqF3vQsa5CDaI+8Q==", + "dev": true + }, + "@types/pbkdf2": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/@types/pbkdf2/-/pbkdf2-3.1.0.tgz", + "integrity": "sha512-Cf63Rv7jCQ0LaL8tNXmEyqTHuIJxRdlS5vMh1mj5voN4+QFhVZnlZruezqpWYDiJ8UTzhP0VmeLXCmBk66YrMQ==", + "dev": true, + "requires": { + "@types/node": "*" + } + }, + "@types/prettier": { + "version": "2.7.2", + "resolved": "https://registry.npmjs.org/@types/prettier/-/prettier-2.7.2.tgz", + "integrity": "sha512-KufADq8uQqo1pYKVIYzfKbJfBAc0sOeXqGbFaSpv8MRmC/zXgowNZmFcbngndGk922QDmOASEXUZCaY48gs4cg==", + "dev": true, + "peer": true + }, + "@types/qs": { + "version": "6.9.7", + "resolved": "https://registry.npmjs.org/@types/qs/-/qs-6.9.7.tgz", + "integrity": "sha512-FGa1F62FT09qcrueBA6qYTrJPVDzah9a+493+o2PCXsesWHIn27G98TsSMs3WPNbZIEj4+VJf6saSFpvD+3Zsw==", + "dev": true, + "peer": true + }, + "@types/readable-stream": { + "version": "2.3.15", + "resolved": "https://registry.npmjs.org/@types/readable-stream/-/readable-stream-2.3.15.tgz", + "integrity": "sha512-oM5JSKQCcICF1wvGgmecmHldZ48OZamtMxcGGVICOJA8o8cahXC1zEVAif8iwoc5j8etxFaRFnf095+CDsuoFQ==", + "dev": true, + "requires": { + "@types/node": "*", + "safe-buffer": "~5.1.1" + } + }, + "@types/secp256k1": { + "version": "4.0.3", + "resolved": "https://registry.npmjs.org/@types/secp256k1/-/secp256k1-4.0.3.tgz", + "integrity": "sha512-Da66lEIFeIz9ltsdMZcpQvmrmmoqrfju8pm1BH8WbYjZSwUgCwXLb9C+9XYogwBITnbsSaMdVPb2ekf7TV+03w==", + "dev": true, + "requires": { + "@types/node": "*" + } + }, + "abbrev": { + "version": "1.0.9", + "resolved": "https://registry.npmjs.org/abbrev/-/abbrev-1.0.9.tgz", + "integrity": "sha512-LEyx4aLEC3x6T0UguF6YILf+ntvmOaWsVfENmIW0E9H09vKlLDGelMjjSm0jkDHALj8A8quZ/HapKNigzwge+Q==", + "dev": true, + "peer": true + }, + "abort-controller": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/abort-controller/-/abort-controller-3.0.0.tgz", + "integrity": "sha512-h8lQ8tacZYnR3vNQTgibj+tODHI5/+l06Au2Pcriv/Gmet0eaj4TwWH41sO9wnHDiQsEj19q0drzdWdeAHtweg==", + "dev": true, + "requires": { + "event-target-shim": "^5.0.0" + } + }, + "abstract-level": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/abstract-level/-/abstract-level-1.0.3.tgz", + "integrity": "sha512-t6jv+xHy+VYwc4xqZMn2Pa9DjcdzvzZmQGRjTFc8spIbRGHgBrEKbPq+rYXc7CCo0lxgYvSgKVg9qZAhpVQSjA==", + "dev": true, + "requires": { + "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" + } + }, + "acorn": { + "version": "8.8.2", + "resolved": "https://registry.npmjs.org/acorn/-/acorn-8.8.2.tgz", + "integrity": "sha512-xjIYgE8HBrkpd/sJqOGNspf8uHG+NOHGOw6a/Urj8taM2EXfdNAH2oFcPeIFfsv3+kz/mJrS5VuMqbNLjCa2vw==", + "dev": true, + "peer": true + }, + "acorn-walk": { + "version": "8.2.0", + "resolved": "https://registry.npmjs.org/acorn-walk/-/acorn-walk-8.2.0.tgz", + "integrity": "sha512-k+iyHEuPgSw6SbuDpGQM+06HQUa04DZ3o+F6CSzXMvvI5KMvnaEqXe+YVe555R9nn6GPt404fos4wcgpw12SDA==", + "dev": true, + "peer": true + }, + "address": { + "version": "1.2.2", + "resolved": "https://registry.npmjs.org/address/-/address-1.2.2.tgz", + "integrity": "sha512-4B/qKCfeE/ODUaAUpSwfzazo5x29WD4r3vXiWsB7I2mSDAihwEqKO+g8GELZUQSSAo5e1XTYh3ZVfLyxBc12nA==", + "dev": true, + "peer": true + }, + "adm-zip": { + "version": "0.4.16", + "resolved": "https://registry.npmjs.org/adm-zip/-/adm-zip-0.4.16.tgz", + "integrity": "sha512-TFi4HBKSGfIKsK5YCkKaaFG2m4PEDyViZmEwof3MTIgzimHLto6muaHVpbrljdIvIrFZzEq/p4nafOeLcYegrg==", + "dev": true + }, + "aes-js": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/aes-js/-/aes-js-3.0.0.tgz", + "integrity": "sha512-H7wUZRn8WpTq9jocdxQ2c8x2sKo9ZVmzfRE13GiNJXfp7NcKYEdvl3vspKjXox6RIG2VtaRe4JFvxG4rqp2Zuw==", + "dev": true + }, + "agent-base": { + "version": "6.0.2", + "resolved": "https://registry.npmjs.org/agent-base/-/agent-base-6.0.2.tgz", + "integrity": "sha512-RZNwNclF7+MS/8bDg70amg32dyeZGZxiDuQmZxKLAlQjr3jGyLx+4Kkk58UO7D2QdgFIQCovuSuZESne6RG6XQ==", + "dev": true, + "requires": { + "debug": "4" + } + }, + "aggregate-error": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/aggregate-error/-/aggregate-error-3.1.0.tgz", + "integrity": "sha512-4I7Td01quW/RpocfNayFdFVk1qSuoh0E7JrbRJ16nH01HhKFQ88INq9Sd+nd72zqRySlr9BmDA8xlEJ6vJMrYA==", + "dev": true, + "requires": { + "clean-stack": "^2.0.0", + "indent-string": "^4.0.0" + } + }, + "ajv": { + "version": "6.12.6", + "resolved": "https://registry.npmjs.org/ajv/-/ajv-6.12.6.tgz", + "integrity": "sha512-j3fVLgvTo527anyYyJOGTYJbG+vnnQYvE0m5mmkc1TK+nxAppkCLMIL0aZ4dblVCNoGShhm+kzE4ZUykBoMg4g==", + "dev": true, + "peer": true, + "requires": { + "fast-deep-equal": "^3.1.1", + "fast-json-stable-stringify": "^2.0.0", + "json-schema-traverse": "^0.4.1", + "uri-js": "^4.2.2" + } + }, + "amdefine": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/amdefine/-/amdefine-1.0.1.tgz", + "integrity": "sha512-S2Hw0TtNkMJhIabBwIojKL9YHO5T0n5eNqWJ7Lrlel/zDbftQpxpapi8tZs3X1HWa+u+QeydGmzzNU0m09+Rcg==", + "dev": true, + "optional": true, + "peer": true + }, + "ansi-colors": { + "version": "4.1.3", + "resolved": "https://registry.npmjs.org/ansi-colors/-/ansi-colors-4.1.3.tgz", + "integrity": "sha512-/6w/C21Pm1A7aZitlI5Ni/2J6FFQN8i1Cvz3kHABAAbw93v/NlvKdVOqz7CCWz/3iv/JplRSEEZ83XION15ovw==", + "dev": true + }, + "ansi-escapes": { + "version": "4.3.2", + "resolved": "https://registry.npmjs.org/ansi-escapes/-/ansi-escapes-4.3.2.tgz", + "integrity": "sha512-gKXj5ALrKWQLsYG9jlTRmR/xKluxHV+Z9QEwNIgCfM1/uwPMCuzVVnh5mwTd+OuBZcwSIMbqssNWRm1lE51QaQ==", + "dev": true, + "requires": { + "type-fest": "^0.21.3" + } + }, + "ansi-regex": { + "version": "5.0.1", + "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-5.0.1.tgz", + "integrity": "sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ==", + "dev": true + }, + "ansi-styles": { + "version": "3.2.1", + "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-3.2.1.tgz", + "integrity": "sha512-VT0ZI6kZRdTh8YyJw3SMbYm/u+NqfsAxEpWO0Pf9sq8/e94WxxOpPKx9FR1FlyCtOVDNOQ+8ntlqFxiRc+r5qA==", + "dev": true, + "requires": { + "color-convert": "^1.9.0" + } + }, + "antlr4ts": { + "version": "0.5.0-alpha.4", + "resolved": "https://registry.npmjs.org/antlr4ts/-/antlr4ts-0.5.0-alpha.4.tgz", + "integrity": "sha512-WPQDt1B74OfPv/IMS2ekXAKkTZIHl88uMetg6q3OTqgFxZ/dxDXI0EWLyZid/1Pe6hTftyg5N7gel5wNAGxXyQ==", + "dev": true, + "peer": true + }, + "anymatch": { + "version": "3.1.3", + "resolved": "https://registry.npmjs.org/anymatch/-/anymatch-3.1.3.tgz", + "integrity": "sha512-KMReFUr0B4t+D+OBkjR3KYqvocp2XaSzO55UcB6mgQMd3KbcE+mWTyvVV7D/zsdEbNnV6acZUutkiHQXvTr1Rw==", + "dev": true, + "requires": { + "normalize-path": "^3.0.0", + "picomatch": "^2.0.4" + } + }, + "arg": { + "version": "4.1.3", + "resolved": "https://registry.npmjs.org/arg/-/arg-4.1.3.tgz", + "integrity": "sha512-58S9QDqG0Xx27YwPSt9fJxivjYl432YCwfDMfZ+71RAqUrZef7LrKQZ3LHLOwCS4FLNBplP533Zx895SeOCHvA==", + "dev": true, + "peer": true + }, + "argparse": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/argparse/-/argparse-2.0.1.tgz", + "integrity": "sha512-8+9WqebbFzpX9OR+Wa6O29asIogeRMzcGtAINdpMHHyAg10f05aSFVBbcEqGf/PXw1EjAZ+q2/bEBg3DvurK3Q==", + "dev": true + }, + "array-back": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/array-back/-/array-back-3.1.0.tgz", + "integrity": "sha512-TkuxA4UCOvxuDK6NZYXCalszEzj+TLszyASooky+i742l9TqsOdYCMJJupxRic61hwquNtppB3hgcuq9SVSH1Q==", + "dev": true, + "peer": true + }, + "array-buffer-byte-length": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/array-buffer-byte-length/-/array-buffer-byte-length-1.0.0.tgz", + "integrity": "sha512-LPuwb2P+NrQw3XhxGc36+XSvuBPopovXYTR9Ew++Du9Yb/bx5AzBfrIsBoj0EZUifjQU+sHL21sseZ3jerWO/A==", + "dev": true, + "peer": true, + "requires": { + "call-bind": "^1.0.2", + "is-array-buffer": "^3.0.1" + } + }, + "array-union": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/array-union/-/array-union-2.1.0.tgz", + "integrity": "sha512-HGyxoOTYUyCM6stUe6EJgnd4EoewAI7zMdfqO+kGjnlZmBDz/cR5pf8r/cR4Wq60sL/p0IkcjUEEPwS3GFrIyw==", + "dev": true, + "peer": true + }, + "array-uniq": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/array-uniq/-/array-uniq-1.0.3.tgz", + "integrity": "sha512-MNha4BWQ6JbwhFhj03YK552f7cb3AzoE8SzeljgChvL1dl3IcvggXVz1DilzySZkCja+CXuZbdW7yATchWn8/Q==", + "dev": true, + "peer": true + }, + "array.prototype.reduce": { + "version": "1.0.5", + "resolved": "https://registry.npmjs.org/array.prototype.reduce/-/array.prototype.reduce-1.0.5.tgz", + "integrity": "sha512-kDdugMl7id9COE8R7MHF5jWk7Dqt/fs4Pv+JXoICnYwqpjjjbUurz6w5fT5IG6brLdJhv6/VoHB0H7oyIBXd+Q==", + "dev": true, + "peer": true, + "requires": { + "call-bind": "^1.0.2", + "define-properties": "^1.1.4", + "es-abstract": "^1.20.4", + "es-array-method-boxes-properly": "^1.0.0", + "is-string": "^1.0.7" + } + }, + "asap": { + "version": "2.0.6", + "resolved": "https://registry.npmjs.org/asap/-/asap-2.0.6.tgz", + "integrity": "sha512-BSHWgDSAiKs50o2Re8ppvp3seVHXSRM44cdSsT9FfNEUUZLOGWVCsiWaRPWM1Znn+mqZ1OfVZ3z3DWEzSp7hRA==", + "dev": true, + "peer": true + }, + "asn1": { + "version": "0.2.6", + "resolved": "https://registry.npmjs.org/asn1/-/asn1-0.2.6.tgz", + "integrity": "sha512-ix/FxPn0MDjeyJ7i/yoHGFt/EX6LyNbxSEhPPXODPL+KB0VPk86UYfL0lMdy+KCnv+fmvIzySwaK5COwqVbWTQ==", + "dev": true, + "peer": true, + "requires": { + "safer-buffer": "~2.1.0" + } + }, + "assert-plus": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/assert-plus/-/assert-plus-1.0.0.tgz", + "integrity": "sha512-NfJ4UzBCcQGLDlQq7nHxH+tv3kyZ0hHQqF5BO6J7tNJeP5do1llPr8dZ8zHonfhAu0PHAdMkSo+8o0wxg9lZWw==", + "dev": true, + "peer": true + }, + "assertion-error": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/assertion-error/-/assertion-error-1.1.0.tgz", + "integrity": "sha512-jgsaNduz+ndvGyFt3uSuWqvy4lCnIJiovtouQN5JZHOKCS2QuhEdbcQHFhVksz2N2U9hXJo8odG7ETyWlEeuDw==", + "dev": true, + "peer": true + }, + "astral-regex": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/astral-regex/-/astral-regex-2.0.0.tgz", + "integrity": "sha512-Z7tMw1ytTXt5jqMcOP+OQteU1VuNK9Y02uuJtKQ1Sv69jXQKKg5cibLwGJow8yzZP+eAc18EmLGPal0bp36rvQ==", + "dev": true, + "peer": true + }, + "async": { + "version": "1.5.2", + "resolved": "https://registry.npmjs.org/async/-/async-1.5.2.tgz", + "integrity": "sha512-nSVgobk4rv61R9PUSDtYt7mPVB2olxNR5RWJcAsH676/ef11bUZwvu7+RGYrYauVdDPcO519v68wRhXQtxsV9w==", + "dev": true, + "peer": true + }, + "asynckit": { + "version": "0.4.0", + "resolved": "https://registry.npmjs.org/asynckit/-/asynckit-0.4.0.tgz", + "integrity": "sha512-Oei9OH4tRh0YqU3GxhX79dM/mwVgvbZJaSNaRk+bshkj0S5cfHcgYakreBjrHwatXKbz+IoIdYLxrKim2MjW0Q==", + "dev": true, + "peer": true + }, + "at-least-node": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/at-least-node/-/at-least-node-1.0.0.tgz", + "integrity": "sha512-+q/t7Ekv1EDY2l6Gda6LLiX14rU9TV20Wa3ofeQmwPFZbOMo9DXrLbOjFaaclkXKWidIaopwAObQDqwWtGUjqg==", + "dev": true, + "peer": true + }, + "available-typed-arrays": { + "version": "1.0.5", + "resolved": "https://registry.npmjs.org/available-typed-arrays/-/available-typed-arrays-1.0.5.tgz", + "integrity": "sha512-DMD0KiN46eipeziST1LPP/STfDU0sufISXmjSgvVsoU2tqxctQeASejWcfNtxYKqETM1UxQ8sp2OrSBWpHY6sw==", + "dev": true, + "peer": true + }, + "aws-sign2": { + "version": "0.7.0", + "resolved": "https://registry.npmjs.org/aws-sign2/-/aws-sign2-0.7.0.tgz", + "integrity": "sha512-08kcGqnYf/YmjoRhfxyu+CLxBjUtHLXLXX/vUfx9l2LYzG3c1m61nrpyFUZI6zeS+Li/wWMMidD9KgrqtGq3mA==", + "dev": true, + "peer": true + }, + "aws4": { + "version": "1.12.0", + "resolved": "https://registry.npmjs.org/aws4/-/aws4-1.12.0.tgz", + "integrity": "sha512-NmWvPnx0F1SfrQbYwOi7OeaNGokp9XhzNioJ/CSBs8Qa4vxug81mhJEAVZwxXuBmYB5KDRfMq/F3RR0BIU7sWg==", + "dev": true, + "peer": true + }, + "balanced-match": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/balanced-match/-/balanced-match-1.0.2.tgz", + "integrity": "sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw==", + "dev": true + }, + "base-x": { + "version": "3.0.9", + "resolved": "https://registry.npmjs.org/base-x/-/base-x-3.0.9.tgz", + "integrity": "sha512-H7JU6iBHTal1gp56aKoaa//YUxEaAOUiydvrV/pILqIHXTtqxSkATOnDA2u+jZ/61sD+L/412+7kzXRtWukhpQ==", + "dev": true, + "requires": { + "safe-buffer": "^5.0.1" + } + }, + "base64-js": { + "version": "1.5.1", + "resolved": "https://registry.npmjs.org/base64-js/-/base64-js-1.5.1.tgz", + "integrity": "sha512-AKpaYlHn8t4SVbOHCy+b5+KKgvR4vrsD8vbvrbiQJps7fKDTkjkDry6ji0rUJjC0kzbNePLwzxq8iypo41qeWA==", + "dev": true + }, + "bcrypt-pbkdf": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/bcrypt-pbkdf/-/bcrypt-pbkdf-1.0.2.tgz", + "integrity": "sha512-qeFIXtP4MSoi6NLqO12WfqARWWuCKi2Rn/9hJLEmtB5yTNr9DqFWkJRCf2qShWzPeAMRnOgCrq0sg/KLv5ES9w==", + "dev": true, + "peer": true, + "requires": { + "tweetnacl": "^0.14.3" + }, + "dependencies": { + "tweetnacl": { + "version": "0.14.5", + "resolved": "https://registry.npmjs.org/tweetnacl/-/tweetnacl-0.14.5.tgz", + "integrity": "sha512-KXXFFdAbFXY4geFIwoyNK+f5Z1b7swfXABfL7HXCmoIWMKU3dmS26672A4EeQtDzLKy7SXmfBu51JolvEKwtGA==", + "dev": true, + "peer": true + } + } + }, + "bech32": { + "version": "1.1.4", + "resolved": "https://registry.npmjs.org/bech32/-/bech32-1.1.4.tgz", + "integrity": "sha512-s0IrSOzLlbvX7yp4WBfPITzpAU8sqQcpsmwXDiKwrG4r491vwCO/XpejasRNl0piBMe/DvP4Tz0mIS/X1DPJBQ==", + "dev": true + }, + "bigint-crypto-utils": { + "version": "3.2.2", + "resolved": "https://registry.npmjs.org/bigint-crypto-utils/-/bigint-crypto-utils-3.2.2.tgz", + "integrity": "sha512-U1RbE3aX9ayCUVcIPHuPDPKcK3SFOXf93J1UK/iHlJuQB7bhagPIX06/CLpLEsDThJ7KA4Dhrnzynl+d2weTiw==", + "dev": true + }, + "binary-extensions": { + "version": "2.2.0", + "resolved": "https://registry.npmjs.org/binary-extensions/-/binary-extensions-2.2.0.tgz", + "integrity": "sha512-jDctJ/IVQbZoJykoeHbhXpOlNBqGNcwXJKJog42E5HDPUwQTSdjCHdihjj0DlnheQ7blbT6dHOafNAiS8ooQKA==", + "dev": true + }, + "blakejs": { + "version": "1.2.1", + "resolved": "https://registry.npmjs.org/blakejs/-/blakejs-1.2.1.tgz", + "integrity": "sha512-QXUSXI3QVc/gJME0dBpXrag1kbzOqCjCX8/b54ntNyW6sjtoqxqRk3LTmXzaJoh71zMsDCjM+47jS7XiwN/+fQ==", + "dev": true + }, + "bn.js": { + "version": "5.2.1", + "resolved": "https://registry.npmjs.org/bn.js/-/bn.js-5.2.1.tgz", + "integrity": "sha512-eXRvHzWyYPBuB4NBy0cmYQjGitUrtqwbvlzP3G6VFnNRbsZQIxQ10PbKKHt8gZ/HW/D/747aDl+QkDqg3KQLMQ==", + "dev": true + }, + "brace-expansion": { + "version": "1.1.11", + "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.11.tgz", + "integrity": "sha512-iCuPHDFgrHX7H2vEI/5xpz07zSHB00TpugqhmYtVmMO6518mCuRMoOYFldEBl0g187ufozdaHgWKcYFb61qGiA==", + "dev": true, + "requires": { + "balanced-match": "^1.0.0", + "concat-map": "0.0.1" + } + }, + "braces": { + "version": "3.0.2", + "resolved": "https://registry.npmjs.org/braces/-/braces-3.0.2.tgz", + "integrity": "sha512-b8um+L1RzM3WDSzvhm6gIz1yfTbBt6YTlcEKAvsmqCZZFw46z626lVj9j1yEPW33H5H+lBQpZMP1k8l+78Ha0A==", + "dev": true, + "requires": { + "fill-range": "^7.0.1" + } + }, + "brorand": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/brorand/-/brorand-1.1.0.tgz", + "integrity": "sha512-cKV8tMCEpQs4hK/ik71d6LrPOnpkpGBR0wzxqr68g2m/LB2GxVYQroAjMJZRVM1Y4BCjCKc3vAamxSzOY2RP+w==", + "dev": true + }, + "browser-level": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/browser-level/-/browser-level-1.0.1.tgz", + "integrity": "sha512-XECYKJ+Dbzw0lbydyQuJzwNXtOpbMSq737qxJN11sIRTErOMShvDpbzTlgju7orJKvx4epULolZAuJGLzCmWRQ==", + "dev": true, + "requires": { + "abstract-level": "^1.0.2", + "catering": "^2.1.1", + "module-error": "^1.0.2", + "run-parallel-limit": "^1.1.0" + } + }, + "browser-stdout": { + "version": "1.3.1", + "resolved": "https://registry.npmjs.org/browser-stdout/-/browser-stdout-1.3.1.tgz", + "integrity": "sha512-qhAVI1+Av2X7qelOfAIYwXONood6XlZE/fXaBSmW/T5SzLAmCgzi+eiWE7fUvbHaeNBQH13UftjpXxsfLkMpgw==", + "dev": true + }, + "browserify-aes": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/browserify-aes/-/browserify-aes-1.2.0.tgz", + "integrity": "sha512-+7CHXqGuspUn/Sl5aO7Ea0xWGAtETPXNSAjHo48JfLdPWcMng33Xe4znFvQweqc/uzk5zSOI3H52CYnjCfb5hA==", + "dev": true, + "requires": { + "buffer-xor": "^1.0.3", + "cipher-base": "^1.0.0", + "create-hash": "^1.1.0", + "evp_bytestokey": "^1.0.3", + "inherits": "^2.0.1", + "safe-buffer": "^5.0.1" + } + }, + "bs58": { + "version": "4.0.1", + "resolved": "https://registry.npmjs.org/bs58/-/bs58-4.0.1.tgz", + "integrity": "sha512-Ok3Wdf5vOIlBrgCvTq96gBkJw+JUEzdBgyaza5HLtPm7yTHkjRy8+JzNyHF7BHa0bNWOQIp3m5YF0nnFcOIKLw==", + "dev": true, + "requires": { + "base-x": "^3.0.2" + } + }, + "bs58check": { + "version": "2.1.2", + "resolved": "https://registry.npmjs.org/bs58check/-/bs58check-2.1.2.tgz", + "integrity": "sha512-0TS1jicxdU09dwJMNZtVAfzPi6Q6QeN0pM1Fkzrjn+XYHvzMKPU3pHVpva+769iNVSfIYWf7LJ6WR+BuuMf8cA==", + "dev": true, + "requires": { + "bs58": "^4.0.0", + "create-hash": "^1.1.0", + "safe-buffer": "^5.1.2" + } + }, + "buffer": { + "version": "6.0.3", + "resolved": "https://registry.npmjs.org/buffer/-/buffer-6.0.3.tgz", + "integrity": "sha512-FTiCpNxtwiZZHEZbcbTIcZjERVICn9yq/pDFkTl95/AxzD1naBctN7YO68riM/gLSDY7sdrMby8hofADYuuqOA==", + "dev": true, + "requires": { + "base64-js": "^1.3.1", + "ieee754": "^1.2.1" + } + }, + "buffer-from": { + "version": "1.1.2", + "resolved": "https://registry.npmjs.org/buffer-from/-/buffer-from-1.1.2.tgz", + "integrity": "sha512-E+XQCRwSbaaiChtv6k6Dwgc+bx+Bs6vuKJHHl5kox/BaKbhiXzqQOwK4cO22yElGp2OCmjwVhT3HmxgyPGnJfQ==", + "dev": true + }, + "buffer-xor": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/buffer-xor/-/buffer-xor-1.0.3.tgz", + "integrity": "sha512-571s0T7nZWK6vB67HI5dyUF7wXiNcfaPPPTl6zYCNApANjIvYJTg7hlud/+cJpdAhS7dVzqMLmfhfHR3rAcOjQ==", + "dev": true + }, + "busboy": { + "version": "1.6.0", + "resolved": "https://registry.npmjs.org/busboy/-/busboy-1.6.0.tgz", + "integrity": "sha512-8SFQbg/0hQ9xy3UNTB0YEnsNBbWfhf7RtnzpL7TkBiTBRfrQ9Fxcnz7VJsleJpyp6rVLvXiuORqjlHi5q+PYuA==", + "dev": true, + "requires": { + "streamsearch": "^1.1.0" + } + }, + "bytes": { + "version": "3.1.2", + "resolved": "https://registry.npmjs.org/bytes/-/bytes-3.1.2.tgz", + "integrity": "sha512-/Nf7TyzTx6S3yRJObOAV7956r8cr2+Oj8AC5dt8wSP3BQAoeX58NoHyCU8P8zGkNXStjTSi6fzO6F0pBdcYbEg==", + "dev": true + }, + "call-bind": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/call-bind/-/call-bind-1.0.2.tgz", + "integrity": "sha512-7O+FbCihrB5WGbFYesctwmTKae6rOiIzmz1icreWJ+0aA7LJfuqhEso2T9ncpcFtzMQtzXf2QGGueWJGTYsqrA==", + "dev": true, + "requires": { + "function-bind": "^1.1.1", + "get-intrinsic": "^1.0.2" + } + }, + "camelcase": { + "version": "6.3.0", + "resolved": "https://registry.npmjs.org/camelcase/-/camelcase-6.3.0.tgz", + "integrity": "sha512-Gmy6FhYlCY7uOElZUSbxo2UCDH8owEk996gkbrpsgGtrJLM3J7jGxl9Ic7Qwwj4ivOE5AWZWRMecDdF7hqGjFA==", + "dev": true + }, + "case": { + "version": "1.6.3", + "resolved": "https://registry.npmjs.org/case/-/case-1.6.3.tgz", + "integrity": "sha512-mzDSXIPaFwVDvZAHqZ9VlbyF4yyXRuX6IvB06WvPYkqJVO24kX1PPhv9bfpKNFZyxYFmmgo03HUiD8iklmJYRQ==", + "dev": true + }, + "caseless": { + "version": "0.12.0", + "resolved": "https://registry.npmjs.org/caseless/-/caseless-0.12.0.tgz", + "integrity": "sha512-4tYFyifaFfGacoiObjJegolkwSU4xQNGbVgUiNYVUxbQ2x2lUsFvY4hVgVzGiIe6WLOPqycWXA40l+PWsxthUw==", + "dev": true, + "peer": true + }, + "catering": { + "version": "2.1.1", + "resolved": "https://registry.npmjs.org/catering/-/catering-2.1.1.tgz", + "integrity": "sha512-K7Qy8O9p76sL3/3m7/zLKbRkyOlSZAgzEaLhyj2mXS8PsCud2Eo4hAb8aLtZqHh0QGqLcb9dlJSu6lHRVENm1w==", + "dev": true + }, + "cbor": { + "version": "8.1.0", + "resolved": "https://registry.npmjs.org/cbor/-/cbor-8.1.0.tgz", + "integrity": "sha512-DwGjNW9omn6EwP70aXsn7FQJx5kO12tX0bZkaTjzdVFM6/7nhA4t0EENocKGx6D2Bch9PE2KzCUf5SceBdeijg==", + "dev": true, + "peer": true, + "requires": { + "nofilter": "^3.1.0" + } + }, + "chai": { + "version": "4.3.7", + "resolved": "https://registry.npmjs.org/chai/-/chai-4.3.7.tgz", + "integrity": "sha512-HLnAzZ2iupm25PlN0xFreAlBA5zaBSv3og0DdeGA4Ar6h6rJ3A0rolRUKJhSF2V10GZKDgWF/VmAEsNWjCRB+A==", + "dev": true, + "peer": true, + "requires": { + "assertion-error": "^1.1.0", + "check-error": "^1.0.2", + "deep-eql": "^4.1.2", + "get-func-name": "^2.0.0", + "loupe": "^2.3.1", + "pathval": "^1.1.1", + "type-detect": "^4.0.5" + } + }, + "chai-as-promised": { + "version": "7.1.1", + "resolved": "https://registry.npmjs.org/chai-as-promised/-/chai-as-promised-7.1.1.tgz", + "integrity": "sha512-azL6xMoi+uxu6z4rhWQ1jbdUhOMhis2PvscD/xjLqNMkv3BPPp2JyyuTHOrf9BOosGpNQ11v6BKv/g57RXbiaA==", + "dev": true, + "peer": true, + "requires": { + "check-error": "^1.0.2" + } + }, + "chalk": { + "version": "2.4.2", + "resolved": "https://registry.npmjs.org/chalk/-/chalk-2.4.2.tgz", + "integrity": "sha512-Mti+f9lpJNcwF4tWV8/OrTTtF1gZi+f8FqlyAdouralcFWFQWF2+NgCHShjkCb+IFBLq9buZwE1xckQU4peSuQ==", + "dev": true, + "requires": { + "ansi-styles": "^3.2.1", + "escape-string-regexp": "^1.0.5", + "supports-color": "^5.3.0" + } + }, + "charenc": { + "version": "0.0.2", + "resolved": "https://registry.npmjs.org/charenc/-/charenc-0.0.2.tgz", + "integrity": "sha512-yrLQ/yVUFXkzg7EDQsPieE/53+0RlaWTs+wBrvW36cyilJ2SaDWfl4Yj7MtLTXleV9uEKefbAGUPv2/iWSooRA==", + "dev": true, + "peer": true + }, + "check-error": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/check-error/-/check-error-1.0.2.tgz", + "integrity": "sha512-BrgHpW9NURQgzoNyjfq0Wu6VFO6D7IZEmJNdtgNqpzGG8RuNFHt2jQxWlAs4HMe119chBnv+34syEZtc6IhLtA==", + "dev": true, + "peer": true + }, + "chokidar": { + "version": "3.5.3", + "resolved": "https://registry.npmjs.org/chokidar/-/chokidar-3.5.3.tgz", + "integrity": "sha512-Dr3sfKRP6oTcjf2JmUmFJfeVMvXBdegxB0iVQ5eb2V10uFJUCAS8OByZdVAyVb8xXNz3GjjTgj9kLWsZTqE6kw==", + "dev": true, + "requires": { + "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" + } + }, + "ci-info": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/ci-info/-/ci-info-2.0.0.tgz", + "integrity": "sha512-5tK7EtrZ0N+OLFMthtqOj4fI2Jeb88C4CAZPu25LDVUgXJ0A3Js4PMGqrn0JU1W0Mh1/Z8wZzYPxqUrXeBboCQ==", + "dev": true + }, + "cipher-base": { + "version": "1.0.4", + "resolved": "https://registry.npmjs.org/cipher-base/-/cipher-base-1.0.4.tgz", + "integrity": "sha512-Kkht5ye6ZGmwv40uUDZztayT2ThLQGfnj/T71N/XzeZeo3nf8foyW7zGTsPYkEya3m5f3cAypH+qe7YOrM1U2Q==", + "dev": true, + "requires": { + "inherits": "^2.0.1", + "safe-buffer": "^5.0.1" + } + }, + "classic-level": { + "version": "1.3.0", + "resolved": "https://registry.npmjs.org/classic-level/-/classic-level-1.3.0.tgz", + "integrity": "sha512-iwFAJQYtqRTRM0F6L8h4JCt00ZSGdOyqh7yVrhhjrOpFhmBjNlRUey64MCiyo6UmQHMJ+No3c81nujPv+n9yrg==", + "dev": true, + "requires": { + "abstract-level": "^1.0.2", + "catering": "^2.1.0", + "module-error": "^1.0.1", + "napi-macros": "^2.2.2", + "node-gyp-build": "^4.3.0" + } + }, + "clean-stack": { + "version": "2.2.0", + "resolved": "https://registry.npmjs.org/clean-stack/-/clean-stack-2.2.0.tgz", + "integrity": "sha512-4diC9HaTE+KRAMWhDhrGOECgWZxoevMc5TlkObMqNSsVU62PYzXZ/SMTjzyGAFF1YusgxGcSWTEXBhp0CPwQ1A==", + "dev": true + }, + "cli-table3": { + "version": "0.5.1", + "resolved": "https://registry.npmjs.org/cli-table3/-/cli-table3-0.5.1.tgz", + "integrity": "sha512-7Qg2Jrep1S/+Q3EceiZtQcDPWxhAvBw+ERf1162v4sikJrvojMHFqXt8QIVha8UlH9rgU0BeWPytZ9/TzYqlUw==", + "dev": true, + "peer": true, + "requires": { + "colors": "^1.1.2", + "object-assign": "^4.1.0", + "string-width": "^2.1.1" + }, + "dependencies": { + "ansi-regex": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-3.0.1.tgz", + "integrity": "sha512-+O9Jct8wf++lXxxFc4hc8LsjaSq0HFzzL7cVsw8pRDIPdjKD2mT4ytDZlLuSBZ4cLKZFXIrMGO7DbQCtMJJMKw==", + "dev": true, + "peer": true + }, + "is-fullwidth-code-point": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/is-fullwidth-code-point/-/is-fullwidth-code-point-2.0.0.tgz", + "integrity": "sha512-VHskAKYM8RfSFXwee5t5cbN5PZeq1Wrh6qd5bkyiXIf6UQcN6w/A0eXM9r6t8d+GYOh+o6ZhiEnb88LN/Y8m2w==", + "dev": true, + "peer": true + }, + "string-width": { + "version": "2.1.1", + "resolved": "https://registry.npmjs.org/string-width/-/string-width-2.1.1.tgz", + "integrity": "sha512-nOqH59deCq9SRHlxq1Aw85Jnt4w6KvLKqWVik6oA9ZklXLNIOlqg4F2yrT1MVaTjAqvVwdfeZ7w7aCvJD7ugkw==", + "dev": true, + "peer": true, + "requires": { + "is-fullwidth-code-point": "^2.0.0", + "strip-ansi": "^4.0.0" + } + }, + "strip-ansi": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-4.0.0.tgz", + "integrity": "sha512-4XaJ2zQdCzROZDivEVIDPkcQn8LMFSa8kj8Gxb/Lnwzv9A8VctNZ+lfivC/sV3ivW8ElJTERXZoPBRrZKkNKow==", + "dev": true, + "peer": true, + "requires": { + "ansi-regex": "^3.0.0" + } + } + } + }, + "cliui": { + "version": "7.0.4", + "resolved": "https://registry.npmjs.org/cliui/-/cliui-7.0.4.tgz", + "integrity": "sha512-OcRE68cOsVMXp1Yvonl/fzkQOyjLSu/8bhPDfQt0e0/Eb283TKP20Fs2MqoPsr9SwA595rRCA+QMzYc9nBP+JQ==", + "dev": true, + "requires": { + "string-width": "^4.2.0", + "strip-ansi": "^6.0.0", + "wrap-ansi": "^7.0.0" + } + }, + "color-convert": { + "version": "1.9.3", + "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-1.9.3.tgz", + "integrity": "sha512-QfAUtd+vFdAtFQcC8CCyYt1fYWxSqAiK2cSD6zDB8N3cpsEBAvRxp9zOGg6G/SHHJYAT88/az/IuDGALsNVbGg==", + "dev": true, + "requires": { + "color-name": "1.1.3" + } + }, + "color-name": { + "version": "1.1.3", + "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.3.tgz", + "integrity": "sha512-72fSenhMw2HZMTVHeCA9KCmpEIbzWiQsjN+BHcBbS9vr1mtt+vJjPdksIBNUmKAW8TFUDPJK5SUU3QhE9NEXDw==", + "dev": true + }, + "colors": { + "version": "1.4.0", + "resolved": "https://registry.npmjs.org/colors/-/colors-1.4.0.tgz", + "integrity": "sha512-a+UqTh4kgZg/SlGvfbzDHpgRu7AAQOmmqRHJnxhRZICKFUT91brVhNNt58CMWU9PsBbv3PDCZUHbVxuDiH2mtA==", + "dev": true, + "peer": true + }, + "combined-stream": { + "version": "1.0.8", + "resolved": "https://registry.npmjs.org/combined-stream/-/combined-stream-1.0.8.tgz", + "integrity": "sha512-FQN4MRfuJeHf7cBbBMJFXhKSDq+2kAArBlmRBvcvFE5BB1HZKXtSFASDhdlz9zOYwxh8lDdnvmMOe/+5cdoEdg==", + "dev": true, + "peer": true, + "requires": { + "delayed-stream": "~1.0.0" + } + }, + "command-exists": { + "version": "1.2.9", + "resolved": "https://registry.npmjs.org/command-exists/-/command-exists-1.2.9.tgz", + "integrity": "sha512-LTQ/SGc+s0Xc0Fu5WaKnR0YiygZkm9eKFvyS+fRsU7/ZWFF8ykFM6Pc9aCVf1+xasOOZpO3BAVgVrKvsqKHV7w==", + "dev": true + }, + "command-line-args": { + "version": "5.2.1", + "resolved": "https://registry.npmjs.org/command-line-args/-/command-line-args-5.2.1.tgz", + "integrity": "sha512-H4UfQhZyakIjC74I9d34fGYDwk3XpSr17QhEd0Q3I9Xq1CETHo4Hcuo87WyWHpAF1aSLjLRf5lD9ZGX2qStUvg==", + "dev": true, + "peer": true, + "requires": { + "array-back": "^3.1.0", + "find-replace": "^3.0.0", + "lodash.camelcase": "^4.3.0", + "typical": "^4.0.0" + } + }, + "command-line-usage": { + "version": "6.1.3", + "resolved": "https://registry.npmjs.org/command-line-usage/-/command-line-usage-6.1.3.tgz", + "integrity": "sha512-sH5ZSPr+7UStsloltmDh7Ce5fb8XPlHyoPzTpyyMuYCtervL65+ubVZ6Q61cFtFl62UyJlc8/JwERRbAFPUqgw==", + "dev": true, + "peer": true, + "requires": { + "array-back": "^4.0.2", + "chalk": "^2.4.2", + "table-layout": "^1.0.2", + "typical": "^5.2.0" + }, + "dependencies": { + "array-back": { + "version": "4.0.2", + "resolved": "https://registry.npmjs.org/array-back/-/array-back-4.0.2.tgz", + "integrity": "sha512-NbdMezxqf94cnNfWLL7V/im0Ub+Anbb0IoZhvzie8+4HJ4nMQuzHuy49FkGYCJK2yAloZ3meiB6AVMClbrI1vg==", + "dev": true, + "peer": true + }, + "typical": { + "version": "5.2.0", + "resolved": "https://registry.npmjs.org/typical/-/typical-5.2.0.tgz", + "integrity": "sha512-dvdQgNDNJo+8B2uBQoqdb11eUCE1JQXhvjC/CZtgvZseVd5TYMXnq0+vuUemXbd/Se29cTaUuPX3YIc2xgbvIg==", + "dev": true, + "peer": true + } + } + }, + "commander": { + "version": "3.0.2", + "resolved": "https://registry.npmjs.org/commander/-/commander-3.0.2.tgz", + "integrity": "sha512-Gar0ASD4BDyKC4hl4DwHqDrmvjoxWKZigVnAbn5H1owvm4CxCPdb0HQDehwNYMJpla5+M2tPmPARzhtYuwpHow==", + "dev": true + }, + "concat-map": { + "version": "0.0.1", + "resolved": "https://registry.npmjs.org/concat-map/-/concat-map-0.0.1.tgz", + "integrity": "sha512-/Srv4dswyQNBfohGpz9o6Yb3Gz3SrUDqBH5rTuhGR7ahtlbYKnVxw2bCFMRljaA7EXHaXZ8wsHdodFvbkhKmqg==", + "dev": true + }, + "concat-stream": { + "version": "1.6.2", + "resolved": "https://registry.npmjs.org/concat-stream/-/concat-stream-1.6.2.tgz", + "integrity": "sha512-27HBghJxjiZtIk3Ycvn/4kbJk/1uZuJFfuPEns6LaEvpvG1f0hTea8lilrouyo9mVc2GWdcEZ8OLoGmSADlrCw==", + "dev": true, + "peer": true, + "requires": { + "buffer-from": "^1.0.0", + "inherits": "^2.0.3", + "readable-stream": "^2.2.2", + "typedarray": "^0.0.6" + }, + "dependencies": { + "readable-stream": { + "version": "2.3.8", + "resolved": "https://registry.npmjs.org/readable-stream/-/readable-stream-2.3.8.tgz", + "integrity": "sha512-8p0AUk4XODgIewSi0l8Epjs+EVnWiK7NoDIEGU0HhE7+ZyY8D1IMY7odu5lRrFXGg71L15KG8QrPmum45RTtdA==", + "dev": true, + "peer": true, + "requires": { + "core-util-is": "~1.0.0", + "inherits": "~2.0.3", + "isarray": "~1.0.0", + "process-nextick-args": "~2.0.0", + "safe-buffer": "~5.1.1", + "string_decoder": "~1.1.1", + "util-deprecate": "~1.0.1" + } + }, + "string_decoder": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/string_decoder/-/string_decoder-1.1.1.tgz", + "integrity": "sha512-n/ShnvDi6FHbbVfviro+WojiFzv+s8MPMHBczVePfUpDJLwoLT0ht1l4YwBCbi8pJAveEEdnkHyPyTP/mzRfwg==", + "dev": true, + "peer": true, + "requires": { + "safe-buffer": "~5.1.0" + } + } + } + }, + "cookie": { + "version": "0.4.2", + "resolved": "https://registry.npmjs.org/cookie/-/cookie-0.4.2.tgz", + "integrity": "sha512-aSWTXFzaKWkvHO1Ny/s+ePFpvKsPnjc551iI41v3ny/ow6tBG5Vd+FuqGNhh1LxOmVzOlGUriIlOaokOvhaStA==", + "dev": true + }, + "core-util-is": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/core-util-is/-/core-util-is-1.0.2.tgz", + "integrity": "sha512-3lqz5YjWTYnW6dlDa5TLaTCcShfar1e40rmcJVwCBJC6mWlFuj0eCHIElmG1g5kyuJ/GD+8Wn4FFCcz4gJPfaQ==", + "dev": true, + "peer": true + }, + "crc-32": { + "version": "1.2.2", + "resolved": "https://registry.npmjs.org/crc-32/-/crc-32-1.2.2.tgz", + "integrity": "sha512-ROmzCKrTnOwybPcJApAA6WBWij23HVfGVNKqqrZpuyZOHqK2CwHSvpGuyt/UNNvaIjEd8X5IFGp4Mh+Ie1IHJQ==", + "dev": true + }, + "create-hash": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/create-hash/-/create-hash-1.2.0.tgz", + "integrity": "sha512-z00bCGNHDG8mHAkP7CtT1qVu+bFQUPjYq/4Iv3C3kWjTFV10zIjfSoeqXo9Asws8gwSHDGj/hl2u4OGIjapeCg==", + "dev": true, + "requires": { + "cipher-base": "^1.0.1", + "inherits": "^2.0.1", + "md5.js": "^1.3.4", + "ripemd160": "^2.0.1", + "sha.js": "^2.4.0" + } + }, + "create-hmac": { + "version": "1.1.7", + "resolved": "https://registry.npmjs.org/create-hmac/-/create-hmac-1.1.7.tgz", + "integrity": "sha512-MJG9liiZ+ogc4TzUwuvbER1JRdgvUFSB5+VR/g5h82fGaIRWMWddtKBHi7/sVhfjQZ6SehlyhvQYrcYkaUIpLg==", + "dev": true, + "requires": { + "cipher-base": "^1.0.3", + "create-hash": "^1.1.0", + "inherits": "^2.0.1", + "ripemd160": "^2.0.0", + "safe-buffer": "^5.0.1", + "sha.js": "^2.4.8" + } + }, + "create-require": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/create-require/-/create-require-1.1.1.tgz", + "integrity": "sha512-dcKFX3jn0MpIaXjisoRvexIJVEKzaq7z2rZKxf+MSr9TkdmHmsU4m2lcLojrj/FHl8mk5VxMmYA+ftRkP/3oKQ==", + "dev": true, + "peer": true + }, + "crypt": { + "version": "0.0.2", + "resolved": "https://registry.npmjs.org/crypt/-/crypt-0.0.2.tgz", + "integrity": "sha512-mCxBlsHFYh9C+HVpiEacem8FEBnMXgU9gy4zmNC+SXAZNB/1idgp/aulFJ4FgCi7GPEVbfyng092GqL2k2rmow==", + "dev": true, + "peer": true + }, + "dashdash": { + "version": "1.14.1", + "resolved": "https://registry.npmjs.org/dashdash/-/dashdash-1.14.1.tgz", + "integrity": "sha512-jRFi8UDGo6j+odZiEpjazZaWqEal3w/basFjQHQEwVtZJGDpxbH1MeYluwCS8Xq5wmLJooDlMgvVarmWfGM44g==", + "dev": true, + "peer": true, + "requires": { + "assert-plus": "^1.0.0" + } + }, + "death": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/death/-/death-1.1.0.tgz", + "integrity": "sha512-vsV6S4KVHvTGxbEcij7hkWRv0It+sGGWVOM67dQde/o5Xjnr+KmLjxWJii2uEObIrt1CcM9w0Yaovx+iOlIL+w==", + "dev": true, + "peer": true + }, + "debug": { + "version": "4.3.4", + "resolved": "https://registry.npmjs.org/debug/-/debug-4.3.4.tgz", + "integrity": "sha512-PRWFHuSU3eDtQJPvnNY7Jcket1j0t5OuOsFzPPzsekD52Zl8qUfFIPEiswXqIvHWGVHOgX+7G/vCNNhehwxfkQ==", + "dev": true, + "requires": { + "ms": "2.1.2" + } + }, + "decamelize": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/decamelize/-/decamelize-4.0.0.tgz", + "integrity": "sha512-9iE1PgSik9HeIIw2JO94IidnE3eBoQrFJ3w7sFuzSX4DpmZ3v5sZpUiV5Swcf6mQEF+Y0ru8Neo+p+nyh2J+hQ==", + "dev": true + }, + "deep-eql": { + "version": "4.1.3", + "resolved": "https://registry.npmjs.org/deep-eql/-/deep-eql-4.1.3.tgz", + "integrity": "sha512-WaEtAOpRA1MQ0eohqZjpGD8zdI0Ovsm8mmFhaDN8dvDZzyoUMcYDnf5Y6iu7HTXxf8JDS23qWa4a+hKCDyOPzw==", + "dev": true, + "peer": true, + "requires": { + "type-detect": "^4.0.0" + } + }, + "deep-extend": { + "version": "0.6.0", + "resolved": "https://registry.npmjs.org/deep-extend/-/deep-extend-0.6.0.tgz", + "integrity": "sha512-LOHxIOaPYdHlJRtCQfDIVZtfw/ufM8+rVj649RIHzcm/vGwQRXFt6OPqIFWsm2XEMrNIEtWR64sY1LEKD2vAOA==", + "dev": true, + "peer": true + }, + "deep-is": { + "version": "0.1.4", + "resolved": "https://registry.npmjs.org/deep-is/-/deep-is-0.1.4.tgz", + "integrity": "sha512-oIPzksmTg4/MriiaYGO+okXDT7ztn/w3Eptv/+gSIdMdKsJo0u4CfYNFJPy+4SKMuCqGw2wxnA+URMg3t8a/bQ==", + "dev": true, + "peer": true + }, + "define-properties": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/define-properties/-/define-properties-1.2.0.tgz", + "integrity": "sha512-xvqAVKGfT1+UAvPwKTVw/njhdQ8ZhXK4lI0bCIuCMrp2up9nPnaDftrLtmpTazqd1o+UY4zgzU+avtMbDP+ldA==", + "dev": true, + "peer": true, + "requires": { + "has-property-descriptors": "^1.0.0", + "object-keys": "^1.1.1" + } + }, + "delayed-stream": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/delayed-stream/-/delayed-stream-1.0.0.tgz", + "integrity": "sha512-ZySD7Nf91aLB0RxL4KGrKHBXl7Eds1DAmEdcoVawXnLD7SDhpNgtuII2aAkg7a7QS41jxPSZ17p4VdGnMHk3MQ==", + "dev": true, + "peer": true + }, + "depd": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/depd/-/depd-2.0.0.tgz", + "integrity": "sha512-g7nH6P6dyDioJogAAGprGpCtVImJhpPk/roCzdb3fIh61/s/nPsfR6onyMwkCAR/OlC3yBC0lESvUoQEAssIrw==", + "dev": true + }, + "detect-port": { + "version": "1.5.1", + "resolved": "https://registry.npmjs.org/detect-port/-/detect-port-1.5.1.tgz", + "integrity": "sha512-aBzdj76lueB6uUst5iAs7+0H/oOjqI5D16XUWxlWMIMROhcM0rfsNVk93zTngq1dDNpoXRr++Sus7ETAExppAQ==", + "dev": true, + "peer": true, + "requires": { + "address": "^1.0.1", + "debug": "4" + } + }, + "diff": { + "version": "5.0.0", + "resolved": "https://registry.npmjs.org/diff/-/diff-5.0.0.tgz", + "integrity": "sha512-/VTCrvm5Z0JGty/BWHljh+BAiw3IK+2j87NGMu8Nwc/f48WoDAC395uomO9ZD117ZOBaHmkX1oyLvkVM/aIT3w==", + "dev": true + }, + "difflib": { + "version": "0.2.4", + "resolved": "https://registry.npmjs.org/difflib/-/difflib-0.2.4.tgz", + "integrity": "sha512-9YVwmMb0wQHQNr5J9m6BSj6fk4pfGITGQOOs+D9Fl+INODWFOfvhIU1hNv6GgR1RBoC/9NJcwu77zShxV0kT7w==", + "dev": true, + "peer": true, + "requires": { + "heap": ">= 0.2.0" + } + }, + "dir-glob": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/dir-glob/-/dir-glob-3.0.1.tgz", + "integrity": "sha512-WkrWp9GR4KXfKGYzOLmTuGVi1UWFfws377n9cc55/tb6DuqyF6pcQ5AbiHEshaDpY9v6oaSr2XCDidGmMwdzIA==", + "dev": true, + "peer": true, + "requires": { + "path-type": "^4.0.0" + } + }, + "ecc-jsbn": { + "version": "0.1.2", + "resolved": "https://registry.npmjs.org/ecc-jsbn/-/ecc-jsbn-0.1.2.tgz", + "integrity": "sha512-eh9O+hwRHNbG4BLTjEl3nw044CkGm5X6LoaCf7LPp7UU8Qrt47JYNi6nPX8xjW97TKGKm1ouctg0QSpZe9qrnw==", + "dev": true, + "peer": true, + "requires": { + "jsbn": "~0.1.0", + "safer-buffer": "^2.1.0" + } + }, + "elliptic": { + "version": "6.5.4", + "resolved": "https://registry.npmjs.org/elliptic/-/elliptic-6.5.4.tgz", + "integrity": "sha512-iLhC6ULemrljPZb+QutR5TQGB+pdW6KGD5RSegS+8sorOZT+rdQFbsQFJgvN3eRqNALqJer4oQ16YvJHlU8hzQ==", + "dev": true, + "requires": { + "bn.js": "^4.11.9", + "brorand": "^1.1.0", + "hash.js": "^1.0.0", + "hmac-drbg": "^1.0.1", + "inherits": "^2.0.4", + "minimalistic-assert": "^1.0.1", + "minimalistic-crypto-utils": "^1.0.1" + }, + "dependencies": { + "bn.js": { + "version": "4.12.0", + "resolved": "https://registry.npmjs.org/bn.js/-/bn.js-4.12.0.tgz", + "integrity": "sha512-c98Bf3tPniI+scsdk237ku1Dc3ujXQTSgyiPUDEOe7tRkhrqridvh8klBv0HCEso1OLOYcHuCv/cS6DNxKH+ZA==", + "dev": true + } + } + }, + "emoji-regex": { + "version": "8.0.0", + "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-8.0.0.tgz", + "integrity": "sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A==", + "dev": true + }, + "enquirer": { + "version": "2.3.6", + "resolved": "https://registry.npmjs.org/enquirer/-/enquirer-2.3.6.tgz", + "integrity": "sha512-yjNnPr315/FjS4zIsUxYguYUPP2e1NK4d7E7ZOLiyYCcbFBiTMyID+2wvm2w6+pZ/odMA7cRkjhsPbltwBOrLg==", + "dev": true, + "requires": { + "ansi-colors": "^4.1.1" + } + }, + "env-paths": { + "version": "2.2.1", + "resolved": "https://registry.npmjs.org/env-paths/-/env-paths-2.2.1.tgz", + "integrity": "sha512-+h1lkLKhZMTYjog1VEpJNG7NZJWcuc2DDk/qsqSTRRCOXiLjeQ1d1/udrUGhqMxUgAlwKNZ0cf2uqan5GLuS2A==", + "dev": true + }, + "es-abstract": { + "version": "1.21.2", + "resolved": "https://registry.npmjs.org/es-abstract/-/es-abstract-1.21.2.tgz", + "integrity": "sha512-y/B5POM2iBnIxCiernH1G7rC9qQoM77lLIMQLuob0zhp8C56Po81+2Nj0WFKnd0pNReDTnkYryc+zhOzpEIROg==", + "dev": true, + "peer": true, + "requires": { + "array-buffer-byte-length": "^1.0.0", + "available-typed-arrays": "^1.0.5", + "call-bind": "^1.0.2", + "es-set-tostringtag": "^2.0.1", + "es-to-primitive": "^1.2.1", + "function.prototype.name": "^1.1.5", + "get-intrinsic": "^1.2.0", + "get-symbol-description": "^1.0.0", + "globalthis": "^1.0.3", + "gopd": "^1.0.1", + "has": "^1.0.3", + "has-property-descriptors": "^1.0.0", + "has-proto": "^1.0.1", + "has-symbols": "^1.0.3", + "internal-slot": "^1.0.5", + "is-array-buffer": "^3.0.2", + "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.10", + "is-weakref": "^1.0.2", + "object-inspect": "^1.12.3", + "object-keys": "^1.1.1", + "object.assign": "^4.1.4", + "regexp.prototype.flags": "^1.4.3", + "safe-regex-test": "^1.0.0", + "string.prototype.trim": "^1.2.7", + "string.prototype.trimend": "^1.0.6", + "string.prototype.trimstart": "^1.0.6", + "typed-array-length": "^1.0.4", + "unbox-primitive": "^1.0.2", + "which-typed-array": "^1.1.9" + }, + "dependencies": { + "object.assign": { + "version": "4.1.4", + "resolved": "https://registry.npmjs.org/object.assign/-/object.assign-4.1.4.tgz", + "integrity": "sha512-1mxKf0e58bvyjSCtKYY4sRe9itRk3PJpquJOjeIkz885CczcI4IvJJDLPS72oowuSh+pBxUFROpX+TU++hxhZQ==", + "dev": true, + "peer": true, + "requires": { + "call-bind": "^1.0.2", + "define-properties": "^1.1.4", + "has-symbols": "^1.0.3", + "object-keys": "^1.1.1" + } + } + } + }, + "es-array-method-boxes-properly": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/es-array-method-boxes-properly/-/es-array-method-boxes-properly-1.0.0.tgz", + "integrity": "sha512-wd6JXUmyHmt8T5a2xreUwKcGPq6f1f+WwIJkijUqiGcJz1qqnZgP6XIK+QyIWU5lT7imeNxUll48bziG+TSYcA==", + "dev": true, + "peer": true + }, + "es-set-tostringtag": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/es-set-tostringtag/-/es-set-tostringtag-2.0.1.tgz", + "integrity": "sha512-g3OMbtlwY3QewlqAiMLI47KywjWZoEytKr8pf6iTC8uJq5bIAH52Z9pnQ8pVL6whrCto53JZDuUIsifGeLorTg==", + "dev": true, + "peer": true, + "requires": { + "get-intrinsic": "^1.1.3", + "has": "^1.0.3", + "has-tostringtag": "^1.0.0" + } + }, + "es-to-primitive": { + "version": "1.2.1", + "resolved": "https://registry.npmjs.org/es-to-primitive/-/es-to-primitive-1.2.1.tgz", + "integrity": "sha512-QCOllgZJtaUo9miYBcLChTUaHNjJF3PYs1VidD7AwiEj1kYxKeQTctLAezAOH5ZKRH0g2IgPn6KwB4IT8iRpvA==", + "dev": true, + "peer": true, + "requires": { + "is-callable": "^1.1.4", + "is-date-object": "^1.0.1", + "is-symbol": "^1.0.2" + } + }, + "escalade": { + "version": "3.1.1", + "resolved": "https://registry.npmjs.org/escalade/-/escalade-3.1.1.tgz", + "integrity": "sha512-k0er2gUkLf8O0zKJiAhmkTnJlTvINGv7ygDNPbeIsX/TJjGJZHuh9B2UxbsaEkmlEo9MfhrSzmhIlhRlI2GXnw==", + "dev": true + }, + "escape-string-regexp": { + "version": "1.0.5", + "resolved": "https://registry.npmjs.org/escape-string-regexp/-/escape-string-regexp-1.0.5.tgz", + "integrity": "sha512-vbRorB5FUQWvla16U8R/qgaFIya2qGzwDrNmCZuYKrbdSUMG6I1ZCGQRefkRVhuOkIGVne7BQ35DSfo1qvJqFg==", + "dev": true + }, + "escodegen": { + "version": "1.8.1", + "resolved": "https://registry.npmjs.org/escodegen/-/escodegen-1.8.1.tgz", + "integrity": "sha512-yhi5S+mNTOuRvyW4gWlg5W1byMaQGWWSYHXsuFZ7GBo7tpyOwi2EdzMP/QWxh9hwkD2m+wDVHJsxhRIj+v/b/A==", + "dev": true, + "peer": true, + "requires": { + "esprima": "^2.7.1", + "estraverse": "^1.9.1", + "esutils": "^2.0.2", + "optionator": "^0.8.1", + "source-map": "~0.2.0" + }, + "dependencies": { + "source-map": { + "version": "0.2.0", + "resolved": "https://registry.npmjs.org/source-map/-/source-map-0.2.0.tgz", + "integrity": "sha512-CBdZ2oa/BHhS4xj5DlhjWNHcan57/5YuvfdLf17iVmIpd9KRm+DFLmC6nBNj+6Ua7Kt3TmOjDpQT1aTYOQtoUA==", + "dev": true, + "optional": true, + "peer": true, + "requires": { + "amdefine": ">=0.0.4" + } + } + } + }, + "esprima": { + "version": "2.7.3", + "resolved": "https://registry.npmjs.org/esprima/-/esprima-2.7.3.tgz", + "integrity": "sha512-OarPfz0lFCiW4/AV2Oy1Rp9qu0iusTKqykwTspGCZtPxmF81JR4MmIebvF1F9+UOKth2ZubLQ4XGGaU+hSn99A==", + "dev": true, + "peer": true + }, + "estraverse": { + "version": "1.9.3", + "resolved": "https://registry.npmjs.org/estraverse/-/estraverse-1.9.3.tgz", + "integrity": "sha512-25w1fMXQrGdoquWnScXZGckOv+Wes+JDnuN/+7ex3SauFRS72r2lFDec0EKPt2YD1wUJ/IrfEex+9yp4hfSOJA==", + "dev": true, + "peer": true + }, + "esutils": { + "version": "2.0.3", + "resolved": "https://registry.npmjs.org/esutils/-/esutils-2.0.3.tgz", + "integrity": "sha512-kVscqXk4OCp68SZ0dkgEKVi6/8ij300KBWTJq32P/dYeWTSwK41WyTxalN1eRmA5Z9UU/LX9D7FWSmV9SAYx6g==", + "dev": true, + "peer": true + }, + "eth-gas-reporter": { + "version": "0.2.25", + "resolved": "https://registry.npmjs.org/eth-gas-reporter/-/eth-gas-reporter-0.2.25.tgz", + "integrity": "sha512-1fRgyE4xUB8SoqLgN3eDfpDfwEfRxh2Sz1b7wzFbyQA+9TekMmvSjjoRu9SKcSVyK+vLkLIsVbJDsTWjw195OQ==", + "dev": true, + "peer": true, + "requires": { + "@ethersproject/abi": "^5.0.0-beta.146", + "@solidity-parser/parser": "^0.14.0", + "cli-table3": "^0.5.0", + "colors": "1.4.0", + "ethereum-cryptography": "^1.0.3", + "ethers": "^4.0.40", + "fs-readdir-recursive": "^1.1.0", + "lodash": "^4.17.14", + "markdown-table": "^1.1.3", + "mocha": "^7.1.1", + "req-cwd": "^2.0.0", + "request": "^2.88.0", + "request-promise-native": "^1.0.5", + "sha1": "^1.1.1", + "sync-request": "^6.0.0" + }, + "dependencies": { + "ansi-colors": { + "version": "3.2.3", + "resolved": "https://registry.npmjs.org/ansi-colors/-/ansi-colors-3.2.3.tgz", + "integrity": "sha512-LEHHyuhlPY3TmuUYMh2oz89lTShfvgbmzaBcxve9t/9Wuy7Dwf4yoAKcND7KFT1HAQfqZ12qtc+DUrBMeKF9nw==", + "dev": true, + "peer": true + }, + "ansi-regex": { + "version": "4.1.1", + "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-4.1.1.tgz", + "integrity": "sha512-ILlv4k/3f6vfQ4OoP2AGvirOktlQ98ZEL1k9FaQjxa3L1abBgbuTDAdPOpvbGncC0BTVQrl+OM8xZGK6tWXt7g==", + "dev": true, + "peer": true + }, + "argparse": { + "version": "1.0.10", + "resolved": "https://registry.npmjs.org/argparse/-/argparse-1.0.10.tgz", + "integrity": "sha512-o5Roy6tNG4SL/FOkCAN6RzjiakZS25RLYFrcMttJqbdd8BWrnA+fGz57iN5Pb06pvBGvl5gQ0B48dJlslXvoTg==", + "dev": true, + "peer": true, + "requires": { + "sprintf-js": "~1.0.2" + } + }, + "bn.js": { + "version": "4.12.0", + "resolved": "https://registry.npmjs.org/bn.js/-/bn.js-4.12.0.tgz", + "integrity": "sha512-c98Bf3tPniI+scsdk237ku1Dc3ujXQTSgyiPUDEOe7tRkhrqridvh8klBv0HCEso1OLOYcHuCv/cS6DNxKH+ZA==", + "dev": true, + "peer": true + }, + "camelcase": { + "version": "5.3.1", + "resolved": "https://registry.npmjs.org/camelcase/-/camelcase-5.3.1.tgz", + "integrity": "sha512-L28STB170nwWS63UjtlEOE3dldQApaJXZkOI1uMFfzf3rRuPegHaHesyee+YxQ+W6SvRDQV6UrdOdRiR153wJg==", + "dev": true, + "peer": true + }, + "chokidar": { + "version": "3.3.0", + "resolved": "https://registry.npmjs.org/chokidar/-/chokidar-3.3.0.tgz", + "integrity": "sha512-dGmKLDdT3Gdl7fBUe8XK+gAtGmzy5Fn0XkkWQuYxGIgWVPPse2CxFA5mtrlD0TOHaHjEUqkWNyP1XdHoJES/4A==", + "dev": true, + "peer": true, + "requires": { + "anymatch": "~3.1.1", + "braces": "~3.0.2", + "fsevents": "~2.1.1", + "glob-parent": "~5.1.0", + "is-binary-path": "~2.1.0", + "is-glob": "~4.0.1", + "normalize-path": "~3.0.0", + "readdirp": "~3.2.0" + } + }, + "cliui": { + "version": "5.0.0", + "resolved": "https://registry.npmjs.org/cliui/-/cliui-5.0.0.tgz", + "integrity": "sha512-PYeGSEmmHM6zvoef2w8TPzlrnNpXIjTipYK780YswmIP9vjxmd6Y2a3CB2Ks6/AU8NHjZugXvo8w3oWM2qnwXA==", + "dev": true, + "peer": true, + "requires": { + "string-width": "^3.1.0", + "strip-ansi": "^5.2.0", + "wrap-ansi": "^5.1.0" + } + }, + "debug": { + "version": "3.2.6", + "resolved": "https://registry.npmjs.org/debug/-/debug-3.2.6.tgz", + "integrity": "sha512-mel+jf7nrtEl5Pn1Qx46zARXKDpBbvzezse7p7LqINmdoIk8PYP5SySaxEmYv6TZ0JyEKA1hsCId6DIhgITtWQ==", + "dev": true, + "peer": true, + "requires": { + "ms": "^2.1.1" + } + }, + "decamelize": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/decamelize/-/decamelize-1.2.0.tgz", + "integrity": "sha512-z2S+W9X73hAUUki+N+9Za2lBlun89zigOyGrsax+KUQ6wKW4ZoWpEYBkGhQjwAjjDCkWxhY0VKEhk8wzY7F5cA==", + "dev": true, + "peer": true + }, + "diff": { + "version": "3.5.0", + "resolved": "https://registry.npmjs.org/diff/-/diff-3.5.0.tgz", + "integrity": "sha512-A46qtFgd+g7pDZinpnwiRJtxbC1hpgf0uzP3iG89scHk0AUC7A1TGxf5OiiOUv/JMZR8GOt8hL900hV0bOy5xA==", + "dev": true, + "peer": true + }, + "emoji-regex": { + "version": "7.0.3", + "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-7.0.3.tgz", + "integrity": "sha512-CwBLREIQ7LvYFB0WyRvwhq5N5qPhc6PMjD6bYggFlI5YyDgl+0vxq5VHbMOFqLg7hfWzmu8T5Z1QofhmTIhItA==", + "dev": true, + "peer": true + }, + "esprima": { + "version": "4.0.1", + "resolved": "https://registry.npmjs.org/esprima/-/esprima-4.0.1.tgz", + "integrity": "sha512-eGuFFw7Upda+g4p+QHvnW0RyTX/SVeJBDM/gCtMARO0cLuT2HcEKnTPvhjV6aGeqrCB/sbNop0Kszm0jsaWU4A==", + "dev": true, + "peer": true + }, + "ethers": { + "version": "4.0.49", + "resolved": "https://registry.npmjs.org/ethers/-/ethers-4.0.49.tgz", + "integrity": "sha512-kPltTvWiyu+OktYy1IStSO16i2e7cS9D9OxZ81q2UUaiNPVrm/RTcbxamCXF9VUSKzJIdJV68EAIhTEVBalRWg==", + "dev": true, + "peer": true, + "requires": { + "aes-js": "3.0.0", + "bn.js": "^4.11.9", + "elliptic": "6.5.4", + "hash.js": "1.1.3", + "js-sha3": "0.5.7", + "scrypt-js": "2.0.4", + "setimmediate": "1.0.4", + "uuid": "2.0.1", + "xmlhttprequest": "1.8.0" + } + }, + "find-up": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/find-up/-/find-up-3.0.0.tgz", + "integrity": "sha512-1yD6RmLI1XBfxugvORwlck6f75tYL+iR0jqwsOrOxMZyGYqUuDhJ0l4AXdO1iX/FTs9cBAMEk1gWSEx1kSbylg==", + "dev": true, + "peer": true, + "requires": { + "locate-path": "^3.0.0" + } + }, + "flat": { + "version": "4.1.1", + "resolved": "https://registry.npmjs.org/flat/-/flat-4.1.1.tgz", + "integrity": "sha512-FmTtBsHskrU6FJ2VxCnsDb84wu9zhmO3cUX2kGFb5tuwhfXxGciiT0oRY+cck35QmG+NmGh5eLz6lLCpWTqwpA==", + "dev": true, + "peer": true, + "requires": { + "is-buffer": "~2.0.3" + } + }, + "fsevents": { + "version": "2.1.3", + "resolved": "https://registry.npmjs.org/fsevents/-/fsevents-2.1.3.tgz", + "integrity": "sha512-Auw9a4AxqWpa9GUfj370BMPzzyncfBABW8Mab7BGWBYDj4Isgq+cDKtx0i6u9jcX9pQDnswsaaOTgTmA5pEjuQ==", + "dev": true, + "optional": true, + "peer": true + }, + "glob": { + "version": "7.1.3", + "resolved": "https://registry.npmjs.org/glob/-/glob-7.1.3.tgz", + "integrity": "sha512-vcfuiIxogLV4DlGBHIUOwI0IbrJ8HWPc4MU7HzviGeNho/UJDfi6B5p3sHeWIQ0KGIU0Jpxi5ZHxemQfLkkAwQ==", + "dev": true, + "peer": true, + "requires": { + "fs.realpath": "^1.0.0", + "inflight": "^1.0.4", + "inherits": "2", + "minimatch": "^3.0.4", + "once": "^1.3.0", + "path-is-absolute": "^1.0.0" + } + }, + "hash.js": { + "version": "1.1.3", + "resolved": "https://registry.npmjs.org/hash.js/-/hash.js-1.1.3.tgz", + "integrity": "sha512-/UETyP0W22QILqS+6HowevwhEFJ3MBJnwTf75Qob9Wz9t0DPuisL8kW8YZMK62dHAKE1c1p+gY1TtOLY+USEHA==", + "dev": true, + "peer": true, + "requires": { + "inherits": "^2.0.3", + "minimalistic-assert": "^1.0.0" + } + }, + "is-fullwidth-code-point": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/is-fullwidth-code-point/-/is-fullwidth-code-point-2.0.0.tgz", + "integrity": "sha512-VHskAKYM8RfSFXwee5t5cbN5PZeq1Wrh6qd5bkyiXIf6UQcN6w/A0eXM9r6t8d+GYOh+o6ZhiEnb88LN/Y8m2w==", + "dev": true, + "peer": true + }, + "js-sha3": { + "version": "0.5.7", + "resolved": "https://registry.npmjs.org/js-sha3/-/js-sha3-0.5.7.tgz", + "integrity": "sha512-GII20kjaPX0zJ8wzkTbNDYMY7msuZcTWk8S5UOh6806Jq/wz1J8/bnr8uGU0DAUmYDjj2Mr4X1cW8v/GLYnR+g==", + "dev": true, + "peer": true + }, + "js-yaml": { + "version": "3.13.1", + "resolved": "https://registry.npmjs.org/js-yaml/-/js-yaml-3.13.1.tgz", + "integrity": "sha512-YfbcO7jXDdyj0DGxYVSlSeQNHbD7XPWvrVWeVUujrQEoZzWJIRrCPoyk6kL6IAjAG2IolMK4T0hNUe0HOUs5Jw==", + "dev": true, + "peer": true, + "requires": { + "argparse": "^1.0.7", + "esprima": "^4.0.0" + } + }, + "locate-path": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/locate-path/-/locate-path-3.0.0.tgz", + "integrity": "sha512-7AO748wWnIhNqAuaty2ZWHkQHRSNfPVIsPIfwEOWO22AmaoVrWavlOcMR5nzTLNYvp36X220/maaRsrec1G65A==", + "dev": true, + "peer": true, + "requires": { + "p-locate": "^3.0.0", + "path-exists": "^3.0.0" + } + }, + "log-symbols": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/log-symbols/-/log-symbols-3.0.0.tgz", + "integrity": "sha512-dSkNGuI7iG3mfvDzUuYZyvk5dD9ocYCYzNU6CYDE6+Xqd+gwme6Z00NS3dUh8mq/73HaEtT7m6W+yUPtU6BZnQ==", + "dev": true, + "peer": true, + "requires": { + "chalk": "^2.4.2" + } + }, + "minimatch": { + "version": "3.0.4", + "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.0.4.tgz", + "integrity": "sha512-yJHVQEhyqPLUTgt9B83PXu6W3rx4MvvHvSUvToogpwoGDOUQ+yDrR0HRot+yOCdCO7u4hX3pWft6kWBBcqh0UA==", + "dev": true, + "peer": true, + "requires": { + "brace-expansion": "^1.1.7" + } + }, + "mkdirp": { + "version": "0.5.5", + "resolved": "https://registry.npmjs.org/mkdirp/-/mkdirp-0.5.5.tgz", + "integrity": "sha512-NKmAlESf6jMGym1++R0Ra7wvhV+wFW63FaSOFPwRahvea0gMUcGUhVeAg/0BC0wiv9ih5NYPB1Wn1UEI1/L+xQ==", + "dev": true, + "peer": true, + "requires": { + "minimist": "^1.2.5" + } + }, + "mocha": { + "version": "7.2.0", + "resolved": "https://registry.npmjs.org/mocha/-/mocha-7.2.0.tgz", + "integrity": "sha512-O9CIypScywTVpNaRrCAgoUnJgozpIofjKUYmJhiCIJMiuYnLI6otcb1/kpW9/n/tJODHGZ7i8aLQoDVsMtOKQQ==", + "dev": true, + "peer": true, + "requires": { + "ansi-colors": "3.2.3", + "browser-stdout": "1.3.1", + "chokidar": "3.3.0", + "debug": "3.2.6", + "diff": "3.5.0", + "escape-string-regexp": "1.0.5", + "find-up": "3.0.0", + "glob": "7.1.3", + "growl": "1.10.5", + "he": "1.2.0", + "js-yaml": "3.13.1", + "log-symbols": "3.0.0", + "minimatch": "3.0.4", + "mkdirp": "0.5.5", + "ms": "2.1.1", + "node-environment-flags": "1.0.6", + "object.assign": "4.1.0", + "strip-json-comments": "2.0.1", + "supports-color": "6.0.0", + "which": "1.3.1", + "wide-align": "1.1.3", + "yargs": "13.3.2", + "yargs-parser": "13.1.2", + "yargs-unparser": "1.6.0" + } + }, + "ms": { + "version": "2.1.1", + "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.1.tgz", + "integrity": "sha512-tgp+dl5cGk28utYktBsrFqA7HKgrhgPsg6Z/EfhWI4gl1Hwq8B/GmY/0oXZ6nF8hDVesS/FpnYaD/kOWhYQvyg==", + "dev": true, + "peer": true + }, + "p-limit": { + "version": "2.3.0", + "resolved": "https://registry.npmjs.org/p-limit/-/p-limit-2.3.0.tgz", + "integrity": "sha512-//88mFWSJx8lxCzwdAABTJL2MyWB12+eIY7MDL2SqLmAkeKU9qxRvWuSyTjm3FUmpBEMuFfckAIqEaVGUDxb6w==", + "dev": true, + "peer": true, + "requires": { + "p-try": "^2.0.0" + } + }, + "p-locate": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/p-locate/-/p-locate-3.0.0.tgz", + "integrity": "sha512-x+12w/To+4GFfgJhBEpiDcLozRJGegY+Ei7/z0tSLkMmxGZNybVMSfWj9aJn8Z5Fc7dBUNJOOVgPv2H7IwulSQ==", + "dev": true, + "peer": true, + "requires": { + "p-limit": "^2.0.0" + } + }, + "p-try": { + "version": "2.2.0", + "resolved": "https://registry.npmjs.org/p-try/-/p-try-2.2.0.tgz", + "integrity": "sha512-R4nPAVTAU0B9D35/Gk3uJf/7XYbQcyohSKdvAxIRSNghFl4e71hVoGnBNQz9cWaXxO2I10KTC+3jMdvvoKw6dQ==", + "dev": true, + "peer": true + }, + "readdirp": { + "version": "3.2.0", + "resolved": "https://registry.npmjs.org/readdirp/-/readdirp-3.2.0.tgz", + "integrity": "sha512-crk4Qu3pmXwgxdSgGhgA/eXiJAPQiX4GMOZZMXnqKxHX7TaoL+3gQVo/WeuAiogr07DpnfjIMpXXa+PAIvwPGQ==", + "dev": true, + "peer": true, + "requires": { + "picomatch": "^2.0.4" + } + }, + "scrypt-js": { + "version": "2.0.4", + "resolved": "https://registry.npmjs.org/scrypt-js/-/scrypt-js-2.0.4.tgz", + "integrity": "sha512-4KsaGcPnuhtCZQCxFxN3GVYIhKFPTdLd8PLC552XwbMndtD0cjRFAhDuuydXQ0h08ZfPgzqe6EKHozpuH74iDw==", + "dev": true, + "peer": true + }, + "setimmediate": { + "version": "1.0.4", + "resolved": "https://registry.npmjs.org/setimmediate/-/setimmediate-1.0.4.tgz", + "integrity": "sha512-/TjEmXQVEzdod/FFskf3o7oOAsGhHf2j1dZqRFbDzq4F3mvvxflIIi4Hd3bLQE9y/CpwqfSQam5JakI/mi3Pog==", + "dev": true, + "peer": true + }, + "string-width": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/string-width/-/string-width-3.1.0.tgz", + "integrity": "sha512-vafcv6KjVZKSgz06oM/H6GDBrAtz8vdhQakGjFIvNrHA6y3HCF1CInLy+QLq8dTJPQ1b+KDUqDFctkdRW44e1w==", + "dev": true, + "peer": true, + "requires": { + "emoji-regex": "^7.0.1", + "is-fullwidth-code-point": "^2.0.0", + "strip-ansi": "^5.1.0" + } + }, + "strip-ansi": { + "version": "5.2.0", + "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-5.2.0.tgz", + "integrity": "sha512-DuRs1gKbBqsMKIZlrffwlug8MHkcnpjs5VPmL1PAh+mA30U0DTotfDZ0d2UUsXpPmPmMMJ6W773MaA3J+lbiWA==", + "dev": true, + "peer": true, + "requires": { + "ansi-regex": "^4.1.0" + } + }, + "strip-json-comments": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/strip-json-comments/-/strip-json-comments-2.0.1.tgz", + "integrity": "sha512-4gB8na07fecVVkOI6Rs4e7T6NOTki5EmL7TUduTs6bu3EdnSycntVJ4re8kgZA+wx9IueI2Y11bfbgwtzuE0KQ==", + "dev": true, + "peer": true + }, + "supports-color": { + "version": "6.0.0", + "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-6.0.0.tgz", + "integrity": "sha512-on9Kwidc1IUQo+bQdhi8+Tijpo0e1SS6RoGo2guUwn5vdaxw8RXOF9Vb2ws+ihWOmh4JnCJOvaziZWP1VABaLg==", + "dev": true, + "peer": true, + "requires": { + "has-flag": "^3.0.0" + } + }, + "uuid": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/uuid/-/uuid-2.0.1.tgz", + "integrity": "sha512-nWg9+Oa3qD2CQzHIP4qKUqwNfzKn8P0LtFhotaCTFchsV7ZfDhAybeip/HZVeMIpZi9JgY1E3nUlwaCmZT1sEg==", + "dev": true, + "peer": true + }, + "wrap-ansi": { + "version": "5.1.0", + "resolved": "https://registry.npmjs.org/wrap-ansi/-/wrap-ansi-5.1.0.tgz", + "integrity": "sha512-QC1/iN/2/RPVJ5jYK8BGttj5z83LmSKmvbvrXPNCLZSEb32KKVDJDl/MOt2N01qU2H/FkzEa9PKto1BqDjtd7Q==", + "dev": true, + "peer": true, + "requires": { + "ansi-styles": "^3.2.0", + "string-width": "^3.0.0", + "strip-ansi": "^5.0.0" + } + }, + "y18n": { + "version": "4.0.3", + "resolved": "https://registry.npmjs.org/y18n/-/y18n-4.0.3.tgz", + "integrity": "sha512-JKhqTOwSrqNA1NY5lSztJ1GrBiUodLMmIZuLiDaMRJ+itFd+ABVE8XBjOvIWL+rSqNDC74LCSFmlb/U4UZ4hJQ==", + "dev": true, + "peer": true + }, + "yargs": { + "version": "13.3.2", + "resolved": "https://registry.npmjs.org/yargs/-/yargs-13.3.2.tgz", + "integrity": "sha512-AX3Zw5iPruN5ie6xGRIDgqkT+ZhnRlZMLMHAs8tg7nRruy2Nb+i5o9bwghAogtM08q1dpr2LVoS8KSTMYpWXUw==", + "dev": true, + "peer": true, + "requires": { + "cliui": "^5.0.0", + "find-up": "^3.0.0", + "get-caller-file": "^2.0.1", + "require-directory": "^2.1.1", + "require-main-filename": "^2.0.0", + "set-blocking": "^2.0.0", + "string-width": "^3.0.0", + "which-module": "^2.0.0", + "y18n": "^4.0.0", + "yargs-parser": "^13.1.2" + } + }, + "yargs-parser": { + "version": "13.1.2", + "resolved": "https://registry.npmjs.org/yargs-parser/-/yargs-parser-13.1.2.tgz", + "integrity": "sha512-3lbsNRf/j+A4QuSZfDRA7HRSfWrzO0YjqTJd5kjAq37Zep1CEgaYmrH9Q3GwPiB9cHyd1Y1UwggGhJGoxipbzg==", + "dev": true, + "peer": true, + "requires": { + "camelcase": "^5.0.0", + "decamelize": "^1.2.0" + } + }, + "yargs-unparser": { + "version": "1.6.0", + "resolved": "https://registry.npmjs.org/yargs-unparser/-/yargs-unparser-1.6.0.tgz", + "integrity": "sha512-W9tKgmSn0DpSatfri0nx52Joq5hVXgeLiqR/5G0sZNDoLZFOr/xjBUDcShCOGNsBnEMNo1KAMBkTej1Hm62HTw==", + "dev": true, + "peer": true, + "requires": { + "flat": "^4.1.0", + "lodash": "^4.17.15", + "yargs": "^13.3.0" + } + } + } + }, + "ethereum-bloom-filters": { + "version": "1.0.10", + "resolved": "https://registry.npmjs.org/ethereum-bloom-filters/-/ethereum-bloom-filters-1.0.10.tgz", + "integrity": "sha512-rxJ5OFN3RwjQxDcFP2Z5+Q9ho4eIdEmSc2ht0fCu8Se9nbXjZ7/031uXoUYJ87KHCOdVeiUuwSnoS7hmYAGVHA==", + "dev": true, + "peer": true, + "requires": { + "js-sha3": "^0.8.0" + } + }, + "ethereum-cryptography": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/ethereum-cryptography/-/ethereum-cryptography-1.2.0.tgz", + "integrity": "sha512-6yFQC9b5ug6/17CQpCyE3k9eKBMdhyVjzUy1WkiuY/E4vj/SXDBbCw8QEIaXqf0Mf2SnY6RmpDcwlUmBSS0EJw==", + "dev": true, + "requires": { + "@noble/hashes": "1.2.0", + "@noble/secp256k1": "1.7.1", + "@scure/bip32": "1.1.5", + "@scure/bip39": "1.1.1" + } + }, + "ethereumjs-abi": { + "version": "0.6.8", + "resolved": "https://registry.npmjs.org/ethereumjs-abi/-/ethereumjs-abi-0.6.8.tgz", + "integrity": "sha512-Tx0r/iXI6r+lRsdvkFDlut0N08jWMnKRZ6Gkq+Nmw75lZe4e6o3EkSnkaBP5NF6+m5PTGAr9JP43N3LyeoglsA==", + "dev": true, + "requires": { + "bn.js": "^4.11.8", + "ethereumjs-util": "^6.0.0" + }, + "dependencies": { + "bn.js": { + "version": "4.12.0", + "resolved": "https://registry.npmjs.org/bn.js/-/bn.js-4.12.0.tgz", + "integrity": "sha512-c98Bf3tPniI+scsdk237ku1Dc3ujXQTSgyiPUDEOe7tRkhrqridvh8klBv0HCEso1OLOYcHuCv/cS6DNxKH+ZA==", + "dev": true + } + } + }, + "ethereumjs-util": { + "version": "6.2.1", + "resolved": "https://registry.npmjs.org/ethereumjs-util/-/ethereumjs-util-6.2.1.tgz", + "integrity": "sha512-W2Ktez4L01Vexijrm5EB6w7dg4n/TgpoYU4avuT5T3Vmnw/eCRtiBrJfQYS/DCSvDIOLn2k57GcHdeBcgVxAqw==", + "dev": true, + "requires": { + "@types/bn.js": "^4.11.3", + "bn.js": "^4.11.0", + "create-hash": "^1.1.2", + "elliptic": "^6.5.2", + "ethereum-cryptography": "^0.1.3", + "ethjs-util": "0.1.6", + "rlp": "^2.2.3" + }, + "dependencies": { + "@types/bn.js": { + "version": "4.11.6", + "resolved": "https://registry.npmjs.org/@types/bn.js/-/bn.js-4.11.6.tgz", + "integrity": "sha512-pqr857jrp2kPuO9uRjZ3PwnJTjoQy+fcdxvBTvHm6dkmEL9q+hDD/2j/0ELOBPtPnS8LjCX0gI9nbl8lVkadpg==", + "dev": true, + "requires": { + "@types/node": "*" + } + }, + "bn.js": { + "version": "4.12.0", + "resolved": "https://registry.npmjs.org/bn.js/-/bn.js-4.12.0.tgz", + "integrity": "sha512-c98Bf3tPniI+scsdk237ku1Dc3ujXQTSgyiPUDEOe7tRkhrqridvh8klBv0HCEso1OLOYcHuCv/cS6DNxKH+ZA==", + "dev": true + }, + "ethereum-cryptography": { + "version": "0.1.3", + "resolved": "https://registry.npmjs.org/ethereum-cryptography/-/ethereum-cryptography-0.1.3.tgz", + "integrity": "sha512-w8/4x1SGGzc+tO97TASLja6SLd3fRIK2tLVcV2Gx4IB21hE19atll5Cq9o3d0ZmAYC/8aw0ipieTSiekAea4SQ==", + "dev": true, + "requires": { + "@types/pbkdf2": "^3.0.0", + "@types/secp256k1": "^4.0.1", + "blakejs": "^1.1.0", + "browserify-aes": "^1.2.0", + "bs58check": "^2.1.2", + "create-hash": "^1.2.0", + "create-hmac": "^1.1.7", + "hash.js": "^1.1.7", + "keccak": "^3.0.0", + "pbkdf2": "^3.0.17", + "randombytes": "^2.1.0", + "safe-buffer": "^5.1.2", + "scrypt-js": "^3.0.0", + "secp256k1": "^4.0.1", + "setimmediate": "^1.0.5" + } + } + } + }, + "ethers": { + "version": "5.7.2", + "resolved": "https://registry.npmjs.org/ethers/-/ethers-5.7.2.tgz", + "integrity": "sha512-wswUsmWo1aOK8rR7DIKiWSw9DbLWe6x98Jrn8wcTflTVvaXhAMaB5zGAXy0GYQEQp9iO1iSHWVyARQm11zUtyg==", + "dev": true, + "requires": { + "@ethersproject/abi": "5.7.0", + "@ethersproject/abstract-provider": "5.7.0", + "@ethersproject/abstract-signer": "5.7.0", + "@ethersproject/address": "5.7.0", + "@ethersproject/base64": "5.7.0", + "@ethersproject/basex": "5.7.0", + "@ethersproject/bignumber": "5.7.0", + "@ethersproject/bytes": "5.7.0", + "@ethersproject/constants": "5.7.0", + "@ethersproject/contracts": "5.7.0", + "@ethersproject/hash": "5.7.0", + "@ethersproject/hdnode": "5.7.0", + "@ethersproject/json-wallets": "5.7.0", + "@ethersproject/keccak256": "5.7.0", + "@ethersproject/logger": "5.7.0", + "@ethersproject/networks": "5.7.1", + "@ethersproject/pbkdf2": "5.7.0", + "@ethersproject/properties": "5.7.0", + "@ethersproject/providers": "5.7.2", + "@ethersproject/random": "5.7.0", + "@ethersproject/rlp": "5.7.0", + "@ethersproject/sha2": "5.7.0", + "@ethersproject/signing-key": "5.7.0", + "@ethersproject/solidity": "5.7.0", + "@ethersproject/strings": "5.7.0", + "@ethersproject/transactions": "5.7.0", + "@ethersproject/units": "5.7.0", + "@ethersproject/wallet": "5.7.0", + "@ethersproject/web": "5.7.1", + "@ethersproject/wordlists": "5.7.0" + } + }, + "ethjs-unit": { + "version": "0.1.6", + "resolved": "https://registry.npmjs.org/ethjs-unit/-/ethjs-unit-0.1.6.tgz", + "integrity": "sha512-/Sn9Y0oKl0uqQuvgFk/zQgR7aw1g36qX/jzSQ5lSwlO0GigPymk4eGQfeNTD03w1dPOqfz8V77Cy43jH56pagw==", + "dev": true, + "peer": true, + "requires": { + "bn.js": "4.11.6", + "number-to-bn": "1.7.0" + }, + "dependencies": { + "bn.js": { + "version": "4.11.6", + "resolved": "https://registry.npmjs.org/bn.js/-/bn.js-4.11.6.tgz", + "integrity": "sha512-XWwnNNFCuuSQ0m3r3C4LE3EiORltHd9M05pq6FOlVeiophzRbMo50Sbz1ehl8K3Z+jw9+vmgnXefY1hz8X+2wA==", + "dev": true, + "peer": true + } + } + }, + "ethjs-util": { + "version": "0.1.6", + "resolved": "https://registry.npmjs.org/ethjs-util/-/ethjs-util-0.1.6.tgz", + "integrity": "sha512-CUnVOQq7gSpDHZVVrQW8ExxUETWrnrvXYvYz55wOU8Uj4VCgw56XC2B/fVqQN+f7gmrnRHSLVnFAwsCuNwji8w==", + "dev": true, + "requires": { + "is-hex-prefixed": "1.0.0", + "strip-hex-prefix": "1.0.0" + } + }, + "event-target-shim": { + "version": "5.0.1", + "resolved": "https://registry.npmjs.org/event-target-shim/-/event-target-shim-5.0.1.tgz", + "integrity": "sha512-i/2XbnSz/uxRCU6+NdVJgKWDTM427+MqYbkQzD321DuCQJUqOuJKIA0IM2+W2xtYHdKOmZ4dR6fExsd4SXL+WQ==", + "dev": true + }, + "evp_bytestokey": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/evp_bytestokey/-/evp_bytestokey-1.0.3.tgz", + "integrity": "sha512-/f2Go4TognH/KvCISP7OUsHn85hT9nUkxxA9BEWxFn+Oj9o8ZNLm/40hdlgSLyuOimsrTKLUMEorQexp/aPQeA==", + "dev": true, + "requires": { + "md5.js": "^1.3.4", + "safe-buffer": "^5.1.1" + } + }, + "extend": { + "version": "3.0.2", + "resolved": "https://registry.npmjs.org/extend/-/extend-3.0.2.tgz", + "integrity": "sha512-fjquC59cD7CyW6urNXK0FBufkZcoiGG80wTuPujX590cB5Ttln20E2UB4S/WARVqhXffZl2LNgS+gQdPIIim/g==", + "dev": true, + "peer": true + }, + "extsprintf": { + "version": "1.3.0", + "resolved": "https://registry.npmjs.org/extsprintf/-/extsprintf-1.3.0.tgz", + "integrity": "sha512-11Ndz7Nv+mvAC1j0ktTa7fAb0vLyGGX+rMHNBYQviQDGU0Hw7lhctJANqbPhu9nV9/izT/IntTgZ7Im/9LJs9g==", + "dev": true, + "peer": true + }, + "fast-deep-equal": { + "version": "3.1.3", + "resolved": "https://registry.npmjs.org/fast-deep-equal/-/fast-deep-equal-3.1.3.tgz", + "integrity": "sha512-f3qQ9oQy9j2AhBe/H9VC91wLmKBCCU/gDOnKNAYG5hswO7BLKj09Hc5HYNz9cGI++xlpDCIgDaitVs03ATR84Q==", + "dev": true, + "peer": true + }, + "fast-glob": { + "version": "3.2.12", + "resolved": "https://registry.npmjs.org/fast-glob/-/fast-glob-3.2.12.tgz", + "integrity": "sha512-DVj4CQIYYow0BlaelwK1pHl5n5cRSJfM60UA0zK891sVInoPri2Ekj7+e1CT3/3qxXenpI+nBBmQAcJPJgaj4w==", + "dev": true, + "peer": true, + "requires": { + "@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" + } + }, + "fast-json-stable-stringify": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/fast-json-stable-stringify/-/fast-json-stable-stringify-2.1.0.tgz", + "integrity": "sha512-lhd/wF+Lk98HZoTCtlVraHtfh5XYijIjalXck7saUtuanSDyLMxnHhSXEDJqHxD7msR8D0uCmqlkwjCV8xvwHw==", + "dev": true, + "peer": true + }, + "fast-levenshtein": { + "version": "2.0.6", + "resolved": "https://registry.npmjs.org/fast-levenshtein/-/fast-levenshtein-2.0.6.tgz", + "integrity": "sha512-DCXu6Ifhqcks7TZKY3Hxp3y6qphY5SJZmrWMDrKcERSOXWQdMhU9Ig/PYrzyw/ul9jOIyh0N4M0tbC5hodg8dw==", + "dev": true, + "peer": true + }, + "fastq": { + "version": "1.15.0", + "resolved": "https://registry.npmjs.org/fastq/-/fastq-1.15.0.tgz", + "integrity": "sha512-wBrocU2LCXXa+lWBt8RoIRD89Fi8OdABODa/kEnyeyjS5aZO5/GNvI5sEINADqP/h8M29UHTHUb53sUu5Ihqdw==", + "dev": true, + "peer": true, + "requires": { + "reusify": "^1.0.4" + } + }, + "fill-range": { + "version": "7.0.1", + "resolved": "https://registry.npmjs.org/fill-range/-/fill-range-7.0.1.tgz", + "integrity": "sha512-qOo9F+dMUmC2Lcb4BbVvnKJxTPjCm+RRpe4gDuGrzkL7mEVl/djYSu2OdQ2Pa302N4oqkSg9ir6jaLWJ2USVpQ==", + "dev": true, + "requires": { + "to-regex-range": "^5.0.1" + } + }, + "find-replace": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/find-replace/-/find-replace-3.0.0.tgz", + "integrity": "sha512-6Tb2myMioCAgv5kfvP5/PkZZ/ntTpVK39fHY7WkWBgvbeE+VHd/tZuZ4mrC+bxh4cfOZeYKVPaJIZtZXV7GNCQ==", + "dev": true, + "peer": true, + "requires": { + "array-back": "^3.0.1" + } + }, + "find-up": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/find-up/-/find-up-2.1.0.tgz", + "integrity": "sha512-NWzkk0jSJtTt08+FBFMvXoeZnOJD+jTtsRmBYbAIzJdX6l7dLgR7CTubCM5/eDdPUBvLCeVasP1brfVR/9/EZQ==", + "dev": true, + "requires": { + "locate-path": "^2.0.0" + } + }, + "flat": { + "version": "5.0.2", + "resolved": "https://registry.npmjs.org/flat/-/flat-5.0.2.tgz", + "integrity": "sha512-b6suED+5/3rTpUBdG1gupIl8MPFCAMA0QXwmljLhvCUKcUvdE4gWky9zpuGCcXHOsz4J9wPGNWq6OKpmIzz3hQ==", + "dev": true + }, + "follow-redirects": { + "version": "1.15.2", + "resolved": "https://registry.npmjs.org/follow-redirects/-/follow-redirects-1.15.2.tgz", + "integrity": "sha512-VQLG33o04KaQ8uYi2tVNbdrWp1QWxNNea+nmIB4EVM28v0hmP17z7aG1+wAkNzVq4KeXTq3221ye5qTJP91JwA==", + "dev": true + }, + "for-each": { + "version": "0.3.3", + "resolved": "https://registry.npmjs.org/for-each/-/for-each-0.3.3.tgz", + "integrity": "sha512-jqYfLp7mo9vIyQf8ykW2v7A+2N4QjeCeI5+Dz9XraiO1ign81wjiH7Fb9vSOWvQfNtmSa4H2RoQTrrXivdUZmw==", + "dev": true, + "peer": true, + "requires": { + "is-callable": "^1.1.3" + } + }, + "forever-agent": { + "version": "0.6.1", + "resolved": "https://registry.npmjs.org/forever-agent/-/forever-agent-0.6.1.tgz", + "integrity": "sha512-j0KLYPhm6zeac4lz3oJ3o65qvgQCcPubiyotZrXqEaG4hNagNYO8qdlUrX5vwqv9ohqeT/Z3j6+yW067yWWdUw==", + "dev": true, + "peer": true + }, + "form-data": { + "version": "2.3.3", + "resolved": "https://registry.npmjs.org/form-data/-/form-data-2.3.3.tgz", + "integrity": "sha512-1lLKB2Mu3aGP1Q/2eCOx0fNbRMe7XdwktwOruhfqqd0rIJWwN4Dh+E3hrPSlDCXnSR7UtZ1N38rVXm+6+MEhJQ==", + "dev": true, + "peer": true, + "requires": { + "asynckit": "^0.4.0", + "combined-stream": "^1.0.6", + "mime-types": "^2.1.12" + } + }, + "fp-ts": { + "version": "1.19.3", + "resolved": "https://registry.npmjs.org/fp-ts/-/fp-ts-1.19.3.tgz", + "integrity": "sha512-H5KQDspykdHuztLTg+ajGN0Z2qUjcEf3Ybxc6hLt0k7/zPkn29XnKnxlBPyW2XIddWrGaJBzBl4VLYOtk39yZg==", + "dev": true + }, + "fs-extra": { + "version": "7.0.1", + "resolved": "https://registry.npmjs.org/fs-extra/-/fs-extra-7.0.1.tgz", + "integrity": "sha512-YJDaCJZEnBmcbw13fvdAM9AwNOJwOzrE4pqMqBq5nFiEqXUqHwlK4B+3pUw6JNvfSPtX05xFHtYy/1ni01eGCw==", + "dev": true, + "requires": { + "graceful-fs": "^4.1.2", + "jsonfile": "^4.0.0", + "universalify": "^0.1.0" + } + }, + "fs-readdir-recursive": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/fs-readdir-recursive/-/fs-readdir-recursive-1.1.0.tgz", + "integrity": "sha512-GNanXlVr2pf02+sPN40XN8HG+ePaNcvM0q5mZBd668Obwb0yD5GiUbZOFgwn8kGMY6I3mdyDJzieUy3PTYyTRA==", + "dev": true, + "peer": true + }, + "fs.realpath": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/fs.realpath/-/fs.realpath-1.0.0.tgz", + "integrity": "sha512-OO0pH2lK6a0hZnAdau5ItzHPI6pUlvI7jMVnxUQRtw4owF2wk8lOSabtGDCTP4Ggrg2MbGnWO9X8K1t4+fGMDw==", + "dev": true + }, + "fsevents": { + "version": "2.3.2", + "resolved": "https://registry.npmjs.org/fsevents/-/fsevents-2.3.2.tgz", + "integrity": "sha512-xiqMQR4xAeHTuB9uWm+fFRcIOgKBMiOBP+eXiyT7jsgVCq1bkVygt00oASowB7EdtpOHaaPgKt812P9ab+DDKA==", + "dev": true, + "optional": true + }, + "function-bind": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/function-bind/-/function-bind-1.1.1.tgz", + "integrity": "sha512-yIovAzMX49sF8Yl58fSCWJ5svSLuaibPxXQJFLmBObTuCr0Mf1KiPopGM9NiFjiYBCbfaa2Fh6breQ6ANVTI0A==", + "dev": true + }, + "function.prototype.name": { + "version": "1.1.5", + "resolved": "https://registry.npmjs.org/function.prototype.name/-/function.prototype.name-1.1.5.tgz", + "integrity": "sha512-uN7m/BzVKQnCUF/iW8jYea67v++2u7m5UgENbHRtdDVclOUP+FMPlCNdmk0h/ysGyo2tavMJEDqJAkJdRa1vMA==", + "dev": true, + "peer": true, + "requires": { + "call-bind": "^1.0.2", + "define-properties": "^1.1.3", + "es-abstract": "^1.19.0", + "functions-have-names": "^1.2.2" + } + }, + "functional-red-black-tree": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/functional-red-black-tree/-/functional-red-black-tree-1.0.1.tgz", + "integrity": "sha512-dsKNQNdj6xA3T+QlADDA7mOSlX0qiMINjn0cgr+eGHGsbSHzTabcIogz2+p/iqP1Xs6EP/sS2SbqH+brGTbq0g==", + "dev": true + }, + "functions-have-names": { + "version": "1.2.3", + "resolved": "https://registry.npmjs.org/functions-have-names/-/functions-have-names-1.2.3.tgz", + "integrity": "sha512-xckBUXyTIqT97tq2x2AMb+g163b5JFysYk0x4qxNFwbfQkmNZoiRHb6sPzI9/QV33WeuvVYBUIiD4NzNIyqaRQ==", + "dev": true, + "peer": true + }, + "get-caller-file": { + "version": "2.0.5", + "resolved": "https://registry.npmjs.org/get-caller-file/-/get-caller-file-2.0.5.tgz", + "integrity": "sha512-DyFP3BM/3YHTQOCUL/w0OZHR0lpKeGrxotcHWcqNEdnltqFwXVfhEBQ94eIo34AfQpo0rGki4cyIiftY06h2Fg==", + "dev": true + }, + "get-func-name": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/get-func-name/-/get-func-name-2.0.0.tgz", + "integrity": "sha512-Hm0ixYtaSZ/V7C8FJrtZIuBBI+iSgL+1Aq82zSu8VQNB4S3Gk8e7Qs3VwBDJAhmRZcFqkl3tQu36g/Foh5I5ig==", + "dev": true, + "peer": true + }, + "get-intrinsic": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/get-intrinsic/-/get-intrinsic-1.2.0.tgz", + "integrity": "sha512-L049y6nFOuom5wGyRc3/gdTLO94dySVKRACj1RmJZBQXlbTMhtNIgkWkUHq+jYmZvKf14EW1EoJnnjbmoHij0Q==", + "dev": true, + "requires": { + "function-bind": "^1.1.1", + "has": "^1.0.3", + "has-symbols": "^1.0.3" + } + }, + "get-port": { + "version": "3.2.0", + "resolved": "https://registry.npmjs.org/get-port/-/get-port-3.2.0.tgz", + "integrity": "sha512-x5UJKlgeUiNT8nyo/AcnwLnZuZNcSjSw0kogRB+Whd1fjjFq4B1hySFxSFWWSn4mIBzg3sRNUDFYc4g5gjPoLg==", + "dev": true, + "peer": true + }, + "get-symbol-description": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/get-symbol-description/-/get-symbol-description-1.0.0.tgz", + "integrity": "sha512-2EmdH1YvIQiZpltCNgkuiUnyukzxM/R6NDJX31Ke3BG1Nq5b0S2PhX59UKi9vZpPDQVdqn+1IcaAwnzTT5vCjw==", + "dev": true, + "peer": true, + "requires": { + "call-bind": "^1.0.2", + "get-intrinsic": "^1.1.1" + } + }, + "getpass": { + "version": "0.1.7", + "resolved": "https://registry.npmjs.org/getpass/-/getpass-0.1.7.tgz", + "integrity": "sha512-0fzj9JxOLfJ+XGLhR8ze3unN0KZCgZwiSSDz168VERjK8Wl8kVSdcu2kspd4s4wtAa1y/qrVRiAA0WclVsu0ng==", + "dev": true, + "peer": true, + "requires": { + "assert-plus": "^1.0.0" + } + }, + "ghost-testrpc": { + "version": "0.0.2", + "resolved": "https://registry.npmjs.org/ghost-testrpc/-/ghost-testrpc-0.0.2.tgz", + "integrity": "sha512-i08dAEgJ2g8z5buJIrCTduwPIhih3DP+hOCTyyryikfV8T0bNvHnGXO67i0DD1H4GBDETTclPy9njZbfluQYrQ==", + "dev": true, + "peer": true, + "requires": { + "chalk": "^2.4.2", + "node-emoji": "^1.10.0" + } + }, + "glob": { + "version": "7.2.0", + "resolved": "https://registry.npmjs.org/glob/-/glob-7.2.0.tgz", + "integrity": "sha512-lmLf6gtyrPq8tTjSmrO94wBeQbFR3HbLHbuyD69wuyQkImp2hWqMGB47OX65FBkPffO641IP9jWa1z4ivqG26Q==", + "dev": true, + "requires": { + "fs.realpath": "^1.0.0", + "inflight": "^1.0.4", + "inherits": "2", + "minimatch": "^3.0.4", + "once": "^1.3.0", + "path-is-absolute": "^1.0.0" + } + }, + "glob-parent": { + "version": "5.1.2", + "resolved": "https://registry.npmjs.org/glob-parent/-/glob-parent-5.1.2.tgz", + "integrity": "sha512-AOIgSQCepiJYwP3ARnGx+5VnTu2HBYdzbGP45eLw1vr3zB3vZLeyed1sC9hnbcOc9/SrMyM5RPQrkGz4aS9Zow==", + "dev": true, + "requires": { + "is-glob": "^4.0.1" + } + }, + "global-modules": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/global-modules/-/global-modules-2.0.0.tgz", + "integrity": "sha512-NGbfmJBp9x8IxyJSd1P+otYK8vonoJactOogrVfFRIAEY1ukil8RSKDz2Yo7wh1oihl51l/r6W4epkeKJHqL8A==", + "dev": true, + "peer": true, + "requires": { + "global-prefix": "^3.0.0" + } + }, + "global-prefix": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/global-prefix/-/global-prefix-3.0.0.tgz", + "integrity": "sha512-awConJSVCHVGND6x3tmMaKcQvwXLhjdkmomy2W+Goaui8YPgYgXJZewhg3fWC+DlfqqQuWg8AwqjGTD2nAPVWg==", + "dev": true, + "peer": true, + "requires": { + "ini": "^1.3.5", + "kind-of": "^6.0.2", + "which": "^1.3.1" + } + }, + "globalthis": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/globalthis/-/globalthis-1.0.3.tgz", + "integrity": "sha512-sFdI5LyBiNTHjRd7cGPWapiHWMOXKyuBNX/cWJ3NfzrZQVa8GI/8cofCl74AOVqq9W5kNmguTIzJ/1s2gyI9wA==", + "dev": true, + "peer": true, + "requires": { + "define-properties": "^1.1.3" + } + }, + "globby": { + "version": "10.0.2", + "resolved": "https://registry.npmjs.org/globby/-/globby-10.0.2.tgz", + "integrity": "sha512-7dUi7RvCoT/xast/o/dLN53oqND4yk0nsHkhRgn9w65C4PofCLOoJ39iSOg+qVDdWQPIEj+eszMHQ+aLVwwQSg==", + "dev": true, + "peer": true, + "requires": { + "@types/glob": "^7.1.1", + "array-union": "^2.1.0", + "dir-glob": "^3.0.1", + "fast-glob": "^3.0.3", + "glob": "^7.1.3", + "ignore": "^5.1.1", + "merge2": "^1.2.3", + "slash": "^3.0.0" + } + }, + "gopd": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/gopd/-/gopd-1.0.1.tgz", + "integrity": "sha512-d65bNlIadxvpb/A2abVdlqKqV563juRnZ1Wtk6s1sIR8uNsXR70xqIzVqxVf1eTqDunwT2MkczEeaezCKTZhwA==", + "dev": true, + "peer": true, + "requires": { + "get-intrinsic": "^1.1.3" + } + }, + "graceful-fs": { + "version": "4.2.11", + "resolved": "https://registry.npmjs.org/graceful-fs/-/graceful-fs-4.2.11.tgz", + "integrity": "sha512-RbJ5/jmFcNNCcDV5o9eTnBLJ/HszWV0P73bc+Ff4nS/rJj+YaS6IGyiOL0VoBYX+l1Wrl3k63h/KrH+nhJ0XvQ==", + "dev": true + }, + "growl": { + "version": "1.10.5", + "resolved": "https://registry.npmjs.org/growl/-/growl-1.10.5.tgz", + "integrity": "sha512-qBr4OuELkhPenW6goKVXiv47US3clb3/IbuWF9KNKEijAy9oeHxU9IgzjvJhHkUzhaj7rOUD7+YGWqUjLp5oSA==", + "dev": true, + "peer": true + }, + "handlebars": { + "version": "4.7.7", + "resolved": "https://registry.npmjs.org/handlebars/-/handlebars-4.7.7.tgz", + "integrity": "sha512-aAcXm5OAfE/8IXkcZvCepKU3VzW1/39Fb5ZuqMtgI/hT8X2YgoMvBY5dLhq/cpOvw7Lk1nK/UF71aLG/ZnVYRA==", + "dev": true, + "peer": true, + "requires": { + "minimist": "^1.2.5", + "neo-async": "^2.6.0", + "source-map": "^0.6.1", + "uglify-js": "^3.1.4", + "wordwrap": "^1.0.0" + } + }, + "har-schema": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/har-schema/-/har-schema-2.0.0.tgz", + "integrity": "sha512-Oqluz6zhGX8cyRaTQlFMPw80bSJVG2x/cFb8ZPhUILGgHka9SsokCCOQgpveePerqidZOrT14ipqfJb7ILcW5Q==", + "dev": true, + "peer": true + }, + "har-validator": { + "version": "5.1.5", + "resolved": "https://registry.npmjs.org/har-validator/-/har-validator-5.1.5.tgz", + "integrity": "sha512-nmT2T0lljbxdQZfspsno9hgrG3Uir6Ks5afism62poxqBM6sDnMEuPmzTq8XN0OEwqKLLdh1jQI3qyE66Nzb3w==", + "dev": true, + "peer": true, + "requires": { + "ajv": "^6.12.3", + "har-schema": "^2.0.0" + } + }, + "hardhat": { + "version": "2.14.0", + "resolved": "https://registry.npmjs.org/hardhat/-/hardhat-2.14.0.tgz", + "integrity": "sha512-73jsInY4zZahMSVFurSK+5TNCJTXMv+vemvGia0Ac34Mm19fYp6vEPVGF3sucbumszsYxiTT2TbS8Ii2dsDSoQ==", + "dev": true, + "requires": { + "@ethersproject/abi": "^5.1.2", + "@metamask/eth-sig-util": "^4.0.0", + "@nomicfoundation/ethereumjs-block": "5.0.1", + "@nomicfoundation/ethereumjs-blockchain": "7.0.1", + "@nomicfoundation/ethereumjs-common": "4.0.1", + "@nomicfoundation/ethereumjs-evm": "2.0.1", + "@nomicfoundation/ethereumjs-rlp": "5.0.1", + "@nomicfoundation/ethereumjs-statemanager": "2.0.1", + "@nomicfoundation/ethereumjs-trie": "6.0.1", + "@nomicfoundation/ethereumjs-tx": "5.0.1", + "@nomicfoundation/ethereumjs-util": "9.0.1", + "@nomicfoundation/ethereumjs-vm": "7.0.1", + "@nomicfoundation/solidity-analyzer": "^0.1.0", + "@sentry/node": "^5.18.1", + "@types/bn.js": "^5.1.0", + "@types/lru-cache": "^5.1.0", + "abort-controller": "^3.0.0", + "adm-zip": "^0.4.16", + "aggregate-error": "^3.0.0", + "ansi-escapes": "^4.3.0", + "chalk": "^2.4.2", + "chokidar": "^3.4.0", + "ci-info": "^2.0.0", + "debug": "^4.1.1", + "enquirer": "^2.3.0", + "env-paths": "^2.2.0", + "ethereum-cryptography": "^1.0.3", + "ethereumjs-abi": "^0.6.8", + "find-up": "^2.1.0", + "fp-ts": "1.19.3", + "fs-extra": "^7.0.1", + "glob": "7.2.0", + "immutable": "^4.0.0-rc.12", + "io-ts": "1.10.4", + "keccak": "^3.0.2", + "lodash": "^4.17.11", + "mnemonist": "^0.38.0", + "mocha": "^10.0.0", + "p-map": "^4.0.0", + "qs": "^6.7.0", + "raw-body": "^2.4.1", + "resolve": "1.17.0", + "semver": "^6.3.0", + "solc": "0.7.3", + "source-map-support": "^0.5.13", + "stacktrace-parser": "^0.1.10", + "tsort": "0.0.1", + "undici": "^5.14.0", + "uuid": "^8.3.2", + "ws": "^7.4.6" + } + }, + "hardhat-gas-reporter": { + "version": "1.0.9", + "resolved": "https://registry.npmjs.org/hardhat-gas-reporter/-/hardhat-gas-reporter-1.0.9.tgz", + "integrity": "sha512-INN26G3EW43adGKBNzYWOlI3+rlLnasXTwW79YNnUhXPDa+yHESgt639dJEs37gCjhkbNKcRRJnomXEuMFBXJg==", + "dev": true, + "peer": true, + "requires": { + "array-uniq": "1.0.3", + "eth-gas-reporter": "^0.2.25", + "sha1": "^1.1.1" + } + }, + "has": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/has/-/has-1.0.3.tgz", + "integrity": "sha512-f2dvO0VU6Oej7RkWJGrehjbzMAjFp5/VKPp5tTpWIV4JHHZK1/BxbFRtf/siA2SWTe09caDmVtYYzWEIbBS4zw==", + "dev": true, + "requires": { + "function-bind": "^1.1.1" + } + }, + "has-bigints": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/has-bigints/-/has-bigints-1.0.2.tgz", + "integrity": "sha512-tSvCKtBr9lkF0Ex0aQiP9N+OpV4zi2r/Nee5VkRDbaqv35RLYMzbwQfFSZZH0kR+Rd6302UJZ2p/bJCEoR3VoQ==", + "dev": true, + "peer": true + }, + "has-flag": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-3.0.0.tgz", + "integrity": "sha512-sKJf1+ceQBr4SMkvQnBDNDtf4TXpVhVGateu0t918bl30FnbE2m4vNLX+VWe/dpjlb+HugGYzW7uQXH98HPEYw==", + "dev": true + }, + "has-property-descriptors": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/has-property-descriptors/-/has-property-descriptors-1.0.0.tgz", + "integrity": "sha512-62DVLZGoiEBDHQyqG4w9xCuZ7eJEwNmJRWw2VY84Oedb7WFcA27fiEVe8oUQx9hAUJ4ekurquucTGwsyO1XGdQ==", + "dev": true, + "peer": true, + "requires": { + "get-intrinsic": "^1.1.1" + } + }, + "has-proto": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/has-proto/-/has-proto-1.0.1.tgz", + "integrity": "sha512-7qE+iP+O+bgF9clE5+UoBFzE65mlBiVj3tKCrlNQ0Ogwm0BjpT/gK4SlLYDMybDh5I3TCTKnPPa0oMG7JDYrhg==", + "dev": true, + "peer": true + }, + "has-symbols": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/has-symbols/-/has-symbols-1.0.3.tgz", + "integrity": "sha512-l3LCuF6MgDNwTDKkdYGEihYjt5pRPbEg46rtlmnSPlUbgmB8LOIrKJbYYFBSbnPaJexMKtiPO8hmeRjRz2Td+A==", + "dev": true + }, + "has-tostringtag": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/has-tostringtag/-/has-tostringtag-1.0.0.tgz", + "integrity": "sha512-kFjcSNhnlGV1kyoGk7OXKSawH5JOb/LzUc5w9B02hOTO0dfFRjbHQKvg1d6cf3HbeUmtU9VbbV3qzZ2Teh97WQ==", + "dev": true, + "peer": true, + "requires": { + "has-symbols": "^1.0.2" + } + }, + "hash-base": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/hash-base/-/hash-base-3.1.0.tgz", + "integrity": "sha512-1nmYp/rhMDiE7AYkDw+lLwlAzz0AntGIe51F3RfFfEqyQ3feY2eI/NcwC6umIQVOASPMsWJLJScWKSSvzL9IVA==", + "dev": true, + "requires": { + "inherits": "^2.0.4", + "readable-stream": "^3.6.0", + "safe-buffer": "^5.2.0" + }, + "dependencies": { + "safe-buffer": { + "version": "5.2.1", + "resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.2.1.tgz", + "integrity": "sha512-rp3So07KcdmmKbGvgaNxQSJr7bGVSVk5S9Eq1F+ppbRo70+YeaDxkw5Dd8NPN+GD6bjnYm2VuPuCXmpuYvmCXQ==", + "dev": true + } + } + }, + "hash.js": { + "version": "1.1.7", + "resolved": "https://registry.npmjs.org/hash.js/-/hash.js-1.1.7.tgz", + "integrity": "sha512-taOaskGt4z4SOANNseOviYDvjEJinIkRgmp7LbKP2YTTmVxWBl87s/uzK9r+44BclBSp2X7K1hqeNfz9JbBeXA==", + "dev": true, + "requires": { + "inherits": "^2.0.3", + "minimalistic-assert": "^1.0.1" + } + }, + "he": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/he/-/he-1.2.0.tgz", + "integrity": "sha512-F/1DnUGPopORZi0ni+CvrCgHQ5FyEAHRLSApuYWMmrbSwoN2Mn/7k+Gl38gJnR7yyDZk6WLXwiGod1JOWNDKGw==", + "dev": true + }, + "heap": { + "version": "0.2.7", + "resolved": "https://registry.npmjs.org/heap/-/heap-0.2.7.tgz", + "integrity": "sha512-2bsegYkkHO+h/9MGbn6KWcE45cHZgPANo5LXF7EvWdT0yT2EguSVO1nDgU5c8+ZOPwp2vMNa7YFsJhVcDR9Sdg==", + "dev": true, + "peer": true + }, + "hmac-drbg": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/hmac-drbg/-/hmac-drbg-1.0.1.tgz", + "integrity": "sha512-Tti3gMqLdZfhOQY1Mzf/AanLiqh1WTiJgEj26ZuYQ9fbkLomzGchCws4FyrSd4VkpBfiNhaE1On+lOz894jvXg==", + "dev": true, + "requires": { + "hash.js": "^1.0.3", + "minimalistic-assert": "^1.0.0", + "minimalistic-crypto-utils": "^1.0.1" + } + }, + "http-basic": { + "version": "8.1.3", + "resolved": "https://registry.npmjs.org/http-basic/-/http-basic-8.1.3.tgz", + "integrity": "sha512-/EcDMwJZh3mABI2NhGfHOGOeOZITqfkEO4p/xK+l3NpyncIHUQBoMvCSF/b5GqvKtySC2srL/GGG3+EtlqlmCw==", + "dev": true, + "peer": true, + "requires": { + "caseless": "^0.12.0", + "concat-stream": "^1.6.2", + "http-response-object": "^3.0.1", + "parse-cache-control": "^1.0.1" + } + }, + "http-errors": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/http-errors/-/http-errors-2.0.0.tgz", + "integrity": "sha512-FtwrG/euBzaEjYeRqOgly7G0qviiXoJWnvEH2Z1plBdXgbyjv34pHTSb9zoeHMyDy33+DWy5Wt9Wo+TURtOYSQ==", + "dev": true, + "requires": { + "depd": "2.0.0", + "inherits": "2.0.4", + "setprototypeof": "1.2.0", + "statuses": "2.0.1", + "toidentifier": "1.0.1" + } + }, + "http-response-object": { + "version": "3.0.2", + "resolved": "https://registry.npmjs.org/http-response-object/-/http-response-object-3.0.2.tgz", + "integrity": "sha512-bqX0XTF6fnXSQcEJ2Iuyr75yVakyjIDCqroJQ/aHfSdlM743Cwqoi2nDYMzLGWUcuTWGWy8AAvOKXTfiv6q9RA==", + "dev": true, + "peer": true, + "requires": { + "@types/node": "^10.0.3" + }, + "dependencies": { + "@types/node": { + "version": "10.17.60", + "resolved": "https://registry.npmjs.org/@types/node/-/node-10.17.60.tgz", + "integrity": "sha512-F0KIgDJfy2nA3zMLmWGKxcH2ZVEtCZXHHdOQs2gSaQ27+lNeEfGxzkIw90aXswATX7AZ33tahPbzy6KAfUreVw==", + "dev": true, + "peer": true + } + } + }, + "http-signature": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/http-signature/-/http-signature-1.2.0.tgz", + "integrity": "sha512-CAbnr6Rz4CYQkLYUtSNXxQPUH2gK8f3iWexVlsnMeD+GjlsQ0Xsy1cOX+mN3dtxYomRy21CiOzU8Uhw6OwncEQ==", + "dev": true, + "peer": true, + "requires": { + "assert-plus": "^1.0.0", + "jsprim": "^1.2.2", + "sshpk": "^1.7.0" + } + }, + "https-proxy-agent": { + "version": "5.0.1", + "resolved": "https://registry.npmjs.org/https-proxy-agent/-/https-proxy-agent-5.0.1.tgz", + "integrity": "sha512-dFcAjpTQFgoLMzC2VwU+C/CbS7uRL0lWmxDITmqm7C+7F0Odmj6s9l6alZc6AELXhrnggM2CeWSXHGOdX2YtwA==", + "dev": true, + "requires": { + "agent-base": "6", + "debug": "4" + } + }, + "iconv-lite": { + "version": "0.4.24", + "resolved": "https://registry.npmjs.org/iconv-lite/-/iconv-lite-0.4.24.tgz", + "integrity": "sha512-v3MXnZAcvnywkTUEZomIActle7RXXeedOR31wwl7VlyoXO4Qi9arvSenNQWne1TcRwhCL1HwLI21bEqdpj8/rA==", + "dev": true, + "requires": { + "safer-buffer": ">= 2.1.2 < 3" + } + }, + "ieee754": { + "version": "1.2.1", + "resolved": "https://registry.npmjs.org/ieee754/-/ieee754-1.2.1.tgz", + "integrity": "sha512-dcyqhDvX1C46lXZcVqCpK+FtMRQVdIMN6/Df5js2zouUsqG7I6sFxitIC+7KYK29KdXOLHdu9zL4sFnoVQnqaA==", + "dev": true + }, + "ignore": { + "version": "5.2.4", + "resolved": "https://registry.npmjs.org/ignore/-/ignore-5.2.4.tgz", + "integrity": "sha512-MAb38BcSbH0eHNBxn7ql2NH/kX33OkB3lZ1BNdh7ENeRChHTYsTvWrMubiIAMNS2llXEEgZ1MUOBtXChP3kaFQ==", + "dev": true, + "peer": true + }, + "immutable": { + "version": "4.3.0", + "resolved": "https://registry.npmjs.org/immutable/-/immutable-4.3.0.tgz", + "integrity": "sha512-0AOCmOip+xgJwEVTQj1EfiDDOkPmuyllDuTuEX+DDXUgapLAsBIfkg3sxCYyCEA8mQqZrrxPUGjcOQ2JS3WLkg==", + "dev": true + }, + "indent-string": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/indent-string/-/indent-string-4.0.0.tgz", + "integrity": "sha512-EdDDZu4A2OyIK7Lr/2zG+w5jmbuk1DVBnEwREQvBzspBJkCEbRa8GxU1lghYcaGJCnRWibjDXlq779X1/y5xwg==", + "dev": true + }, + "inflight": { + "version": "1.0.6", + "resolved": "https://registry.npmjs.org/inflight/-/inflight-1.0.6.tgz", + "integrity": "sha512-k92I/b08q4wvFscXCLvqfsHCrjrF7yiXsQuIVvVE7N82W3+aqpzuUdBbfhWcy/FZR3/4IgflMgKLOsvPDrGCJA==", + "dev": true, + "requires": { + "once": "^1.3.0", + "wrappy": "1" + } + }, + "inherits": { + "version": "2.0.4", + "resolved": "https://registry.npmjs.org/inherits/-/inherits-2.0.4.tgz", + "integrity": "sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ==", + "dev": true + }, + "ini": { + "version": "1.3.8", + "resolved": "https://registry.npmjs.org/ini/-/ini-1.3.8.tgz", + "integrity": "sha512-JV/yugV2uzW5iMRSiZAyDtQd+nxtUnjeLt0acNdw98kKLrvuRVyB80tsREOE7yvGVgalhZ6RNXCmEHkUKBKxew==", + "dev": true, + "peer": true + }, + "internal-slot": { + "version": "1.0.5", + "resolved": "https://registry.npmjs.org/internal-slot/-/internal-slot-1.0.5.tgz", + "integrity": "sha512-Y+R5hJrzs52QCG2laLn4udYVnxsfny9CpOhNhUvk/SSSVyF6T27FzRbF0sroPidSu3X8oEAkOn2K804mjpt6UQ==", + "dev": true, + "peer": true, + "requires": { + "get-intrinsic": "^1.2.0", + "has": "^1.0.3", + "side-channel": "^1.0.4" + } + }, + "interpret": { + "version": "1.4.0", + "resolved": "https://registry.npmjs.org/interpret/-/interpret-1.4.0.tgz", + "integrity": "sha512-agE4QfB2Lkp9uICn7BAqoscw4SZP9kTE2hxiFI3jBPmXJfdqiahTbUuKGsMoN2GtqL9AxhYioAcVvgsb1HvRbA==", + "dev": true, + "peer": true + }, + "io-ts": { + "version": "1.10.4", + "resolved": "https://registry.npmjs.org/io-ts/-/io-ts-1.10.4.tgz", + "integrity": "sha512-b23PteSnYXSONJ6JQXRAlvJhuw8KOtkqa87W4wDtvMrud/DTJd5X+NpOOI+O/zZwVq6v0VLAaJ+1EDViKEuN9g==", + "dev": true, + "requires": { + "fp-ts": "^1.0.0" + } + }, + "is-array-buffer": { + "version": "3.0.2", + "resolved": "https://registry.npmjs.org/is-array-buffer/-/is-array-buffer-3.0.2.tgz", + "integrity": "sha512-y+FyyR/w8vfIRq4eQcM1EYgSTnmHXPqaF+IgzgraytCFq5Xh8lllDVmAZolPJiZttZLeFSINPYMaEJ7/vWUa1w==", + "dev": true, + "peer": true, + "requires": { + "call-bind": "^1.0.2", + "get-intrinsic": "^1.2.0", + "is-typed-array": "^1.1.10" + } + }, + "is-bigint": { + "version": "1.0.4", + "resolved": "https://registry.npmjs.org/is-bigint/-/is-bigint-1.0.4.tgz", + "integrity": "sha512-zB9CruMamjym81i2JZ3UMn54PKGsQzsJeo6xvN3HJJ4CAsQNB6iRutp2To77OfCNuoxspsIhzaPoO1zyCEhFOg==", + "dev": true, + "peer": true, + "requires": { + "has-bigints": "^1.0.1" + } + }, + "is-binary-path": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/is-binary-path/-/is-binary-path-2.1.0.tgz", + "integrity": "sha512-ZMERYes6pDydyuGidse7OsHxtbI7WVeUEozgR/g7rd0xUimYNlvZRE/K2MgZTjWy725IfelLeVcEM97mmtRGXw==", + "dev": true, + "requires": { + "binary-extensions": "^2.0.0" + } + }, + "is-boolean-object": { + "version": "1.1.2", + "resolved": "https://registry.npmjs.org/is-boolean-object/-/is-boolean-object-1.1.2.tgz", + "integrity": "sha512-gDYaKHJmnj4aWxyj6YHyXVpdQawtVLHU5cb+eztPGczf6cjuTdwve5ZIEfgXqH4e57An1D1AKf8CZ3kYrQRqYA==", + "dev": true, + "peer": true, + "requires": { + "call-bind": "^1.0.2", + "has-tostringtag": "^1.0.0" + } + }, + "is-buffer": { + "version": "2.0.5", + "resolved": "https://registry.npmjs.org/is-buffer/-/is-buffer-2.0.5.tgz", + "integrity": "sha512-i2R6zNFDwgEHJyQUtJEk0XFi1i0dPFn/oqjK3/vPCcDeJvW5NQ83V8QbicfF1SupOaB0h8ntgBC2YiE7dfyctQ==", + "dev": true + }, + "is-callable": { + "version": "1.2.7", + "resolved": "https://registry.npmjs.org/is-callable/-/is-callable-1.2.7.tgz", + "integrity": "sha512-1BC0BVFhS/p0qtw6enp8e+8OD0UrK0oFLztSjNzhcKA3WDuJxxAPXzPuPtKkjEY9UUoEWlX/8fgKeu2S8i9JTA==", + "dev": true, + "peer": true + }, + "is-date-object": { + "version": "1.0.5", + "resolved": "https://registry.npmjs.org/is-date-object/-/is-date-object-1.0.5.tgz", + "integrity": "sha512-9YQaSxsAiSwcvS33MBk3wTCVnWK+HhF8VZR2jRxehM16QcVOdHqPn4VPHmRK4lSr38n9JriurInLcP90xsYNfQ==", + "dev": true, + "peer": true, + "requires": { + "has-tostringtag": "^1.0.0" + } + }, + "is-extglob": { + "version": "2.1.1", + "resolved": "https://registry.npmjs.org/is-extglob/-/is-extglob-2.1.1.tgz", + "integrity": "sha512-SbKbANkN603Vi4jEZv49LeVJMn4yGwsbzZworEoyEiutsN3nJYdbO36zfhGJ6QEDpOZIFkDtnq5JRxmvl3jsoQ==", + "dev": true + }, + "is-fullwidth-code-point": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/is-fullwidth-code-point/-/is-fullwidth-code-point-3.0.0.tgz", + "integrity": "sha512-zymm5+u+sCsSWyD9qNaejV3DFvhCKclKdizYaJUuHA83RLjb7nSuGnddCHGv0hk+KY7BMAlsWeK4Ueg6EV6XQg==", + "dev": true + }, + "is-glob": { + "version": "4.0.3", + "resolved": "https://registry.npmjs.org/is-glob/-/is-glob-4.0.3.tgz", + "integrity": "sha512-xelSayHH36ZgE7ZWhli7pW34hNbNl8Ojv5KVmkJD4hBdD3th8Tfk9vYasLM+mXWOZhFkgZfxhLSnrwRr4elSSg==", + "dev": true, + "requires": { + "is-extglob": "^2.1.1" + } + }, + "is-hex-prefixed": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/is-hex-prefixed/-/is-hex-prefixed-1.0.0.tgz", + "integrity": "sha512-WvtOiug1VFrE9v1Cydwm+FnXd3+w9GaeVUss5W4v/SLy3UW00vP+6iNF2SdnfiBoLy4bTqVdkftNGTUeOFVsbA==", + "dev": true + }, + "is-negative-zero": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/is-negative-zero/-/is-negative-zero-2.0.2.tgz", + "integrity": "sha512-dqJvarLawXsFbNDeJW7zAz8ItJ9cd28YufuuFzh0G8pNHjJMnY08Dv7sYX2uF5UpQOwieAeOExEYAWWfu7ZZUA==", + "dev": true, + "peer": true + }, + "is-number": { + "version": "7.0.0", + "resolved": "https://registry.npmjs.org/is-number/-/is-number-7.0.0.tgz", + "integrity": "sha512-41Cifkg6e8TylSpdtTpeLVMqvSBEVzTttHvERD741+pnZ8ANv0004MRL43QKPDlK9cGvNp6NZWZUBlbGXYxxng==", + "dev": true + }, + "is-number-object": { + "version": "1.0.7", + "resolved": "https://registry.npmjs.org/is-number-object/-/is-number-object-1.0.7.tgz", + "integrity": "sha512-k1U0IRzLMo7ZlYIfzRu23Oh6MiIFasgpb9X76eqfFZAqwH44UI4KTBvBYIZ1dSL9ZzChTB9ShHfLkR4pdW5krQ==", + "dev": true, + "peer": true, + "requires": { + "has-tostringtag": "^1.0.0" + } + }, + "is-plain-obj": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/is-plain-obj/-/is-plain-obj-2.1.0.tgz", + "integrity": "sha512-YWnfyRwxL/+SsrWYfOpUtz5b3YD+nyfkHvjbcanzk8zgyO4ASD67uVMRt8k5bM4lLMDnXfriRhOpemw+NfT1eA==", + "dev": true + }, + "is-regex": { + "version": "1.1.4", + "resolved": "https://registry.npmjs.org/is-regex/-/is-regex-1.1.4.tgz", + "integrity": "sha512-kvRdxDsxZjhzUX07ZnLydzS1TU/TJlTUHHY4YLL87e37oUA49DfkLqgy+VjFocowy29cKvcSiu+kIv728jTTVg==", + "dev": true, + "peer": true, + "requires": { + "call-bind": "^1.0.2", + "has-tostringtag": "^1.0.0" + } + }, + "is-shared-array-buffer": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/is-shared-array-buffer/-/is-shared-array-buffer-1.0.2.tgz", + "integrity": "sha512-sqN2UDu1/0y6uvXyStCOzyhAjCSlHceFoMKJW8W9EU9cvic/QdsZ0kEU93HEy3IUEFZIiH/3w+AH/UQbPHNdhA==", + "dev": true, + "peer": true, + "requires": { + "call-bind": "^1.0.2" + } + }, + "is-string": { + "version": "1.0.7", + "resolved": "https://registry.npmjs.org/is-string/-/is-string-1.0.7.tgz", + "integrity": "sha512-tE2UXzivje6ofPW7l23cjDOMa09gb7xlAqG6jG5ej6uPV32TlWP3NKPigtaGeHNu9fohccRYvIiZMfOOnOYUtg==", + "dev": true, + "peer": true, + "requires": { + "has-tostringtag": "^1.0.0" + } + }, + "is-symbol": { + "version": "1.0.4", + "resolved": "https://registry.npmjs.org/is-symbol/-/is-symbol-1.0.4.tgz", + "integrity": "sha512-C/CPBqKWnvdcxqIARxyOh4v1UUEOCHpgDa0WYgpKDFMszcrPcffg5uhwSgPCLD2WWxmq6isisz87tzT01tuGhg==", + "dev": true, + "peer": true, + "requires": { + "has-symbols": "^1.0.2" + } + }, + "is-typed-array": { + "version": "1.1.10", + "resolved": "https://registry.npmjs.org/is-typed-array/-/is-typed-array-1.1.10.tgz", + "integrity": "sha512-PJqgEHiWZvMpaFZ3uTc8kHPM4+4ADTlDniuQL7cU/UDA0Ql7F70yGfHph3cLNe+c9toaigv+DFzTJKhc2CtO6A==", + "dev": true, + "peer": true, + "requires": { + "available-typed-arrays": "^1.0.5", + "call-bind": "^1.0.2", + "for-each": "^0.3.3", + "gopd": "^1.0.1", + "has-tostringtag": "^1.0.0" + } + }, + "is-typedarray": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/is-typedarray/-/is-typedarray-1.0.0.tgz", + "integrity": "sha512-cyA56iCMHAh5CdzjJIa4aohJyeO1YbwLi3Jc35MmRU6poroFjIGZzUzupGiRPOjgHg9TLu43xbpwXk523fMxKA==", + "dev": true, + "peer": true + }, + "is-unicode-supported": { + "version": "0.1.0", + "resolved": "https://registry.npmjs.org/is-unicode-supported/-/is-unicode-supported-0.1.0.tgz", + "integrity": "sha512-knxG2q4UC3u8stRGyAVJCOdxFmv5DZiRcdlIaAQXAbSfJya+OhopNotLQrstBhququ4ZpuKbDc/8S6mgXgPFPw==", + "dev": true + }, + "is-weakref": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/is-weakref/-/is-weakref-1.0.2.tgz", + "integrity": "sha512-qctsuLZmIQ0+vSSMfoVvyFe2+GSEvnmZ2ezTup1SBse9+twCCeial6EEi3Nc2KFcf6+qz2FBPnjXsk8xhKSaPQ==", + "dev": true, + "peer": true, + "requires": { + "call-bind": "^1.0.2" + } + }, + "isarray": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/isarray/-/isarray-1.0.0.tgz", + "integrity": "sha512-VLghIWNM6ELQzo7zwmcg0NmTVyWKYjvIeM83yjp0wRDTmUnrM678fQbcKBo6n2CJEF0szoG//ytg+TKla89ALQ==", + "dev": true, + "peer": true + }, + "isexe": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/isexe/-/isexe-2.0.0.tgz", + "integrity": "sha512-RHxMLp9lnKHGHRng9QFhRCMbYAcVpn69smSGcq3f36xjgVVWThj4qqLbTLlq7Ssj8B+fIQ1EuCEGI2lKsyQeIw==", + "dev": true, + "peer": true + }, + "isstream": { + "version": "0.1.2", + "resolved": "https://registry.npmjs.org/isstream/-/isstream-0.1.2.tgz", + "integrity": "sha512-Yljz7ffyPbrLpLngrMtZ7NduUgVvi6wG9RJ9IUcyCd59YQ911PBJphODUcbOVbqYfxe1wuYf/LJ8PauMRwsM/g==", + "dev": true, + "peer": true + }, + "js-sdsl": { + "version": "4.4.0", + "resolved": "https://registry.npmjs.org/js-sdsl/-/js-sdsl-4.4.0.tgz", + "integrity": "sha512-FfVSdx6pJ41Oa+CF7RDaFmTnCaFhua+SNYQX74riGOpl96x+2jQCqEfQ2bnXu/5DPCqlRuiqyvTJM0Qjz26IVg==", + "dev": true + }, + "js-sha3": { + "version": "0.8.0", + "resolved": "https://registry.npmjs.org/js-sha3/-/js-sha3-0.8.0.tgz", + "integrity": "sha512-gF1cRrHhIzNfToc802P800N8PpXS+evLLXfsVpowqmAFR9uwbi89WvXg2QspOmXL8QL86J4T1EpFu+yUkwJY3Q==", + "dev": true + }, + "js-yaml": { + "version": "4.1.0", + "resolved": "https://registry.npmjs.org/js-yaml/-/js-yaml-4.1.0.tgz", + "integrity": "sha512-wpxZs9NoxZaJESJGIZTyDEaYpl0FKSA+FB9aJiyemKhMwkxQg63h4T1KJgUGHpTqPDNRcmmYLugrRjJlBtWvRA==", + "dev": true, + "requires": { + "argparse": "^2.0.1" + } + }, + "jsbn": { + "version": "0.1.1", + "resolved": "https://registry.npmjs.org/jsbn/-/jsbn-0.1.1.tgz", + "integrity": "sha512-UVU9dibq2JcFWxQPA6KCqj5O42VOmAY3zQUfEKxU0KpTGXwNoCjkX1e13eHNvw/xPynt6pU0rZ1htjWTNTSXsg==", + "dev": true, + "peer": true + }, + "json-schema": { + "version": "0.4.0", + "resolved": "https://registry.npmjs.org/json-schema/-/json-schema-0.4.0.tgz", + "integrity": "sha512-es94M3nTIfsEPisRafak+HDLfHXnKBhV3vU5eqPcS3flIWqcxJWgXHXiey3YrpaNsanY5ei1VoYEbOzijuq9BA==", + "dev": true, + "peer": true + }, + "json-schema-traverse": { + "version": "0.4.1", + "resolved": "https://registry.npmjs.org/json-schema-traverse/-/json-schema-traverse-0.4.1.tgz", + "integrity": "sha512-xbbCH5dCYU5T8LcEhhuh7HJ88HXuW3qsI3Y0zOZFKfZEHcpWiHU/Jxzk629Brsab/mMiHQti9wMP+845RPe3Vg==", + "dev": true, + "peer": true + }, + "json-stringify-safe": { + "version": "5.0.1", + "resolved": "https://registry.npmjs.org/json-stringify-safe/-/json-stringify-safe-5.0.1.tgz", + "integrity": "sha512-ZClg6AaYvamvYEE82d3Iyd3vSSIjQ+odgjaTzRuO3s7toCdFKczob2i0zCh7JE8kWn17yvAWhUVxvqGwUalsRA==", + "dev": true, + "peer": true + }, + "jsonfile": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/jsonfile/-/jsonfile-4.0.0.tgz", + "integrity": "sha512-m6F1R3z8jjlf2imQHS2Qez5sjKWQzbuuhuJ/FKYFRZvPE3PuHcSMVZzfsLhGVOkfd20obL5SWEBew5ShlquNxg==", + "dev": true, + "requires": { + "graceful-fs": "^4.1.6" + } + }, + "jsonschema": { + "version": "1.4.1", + "resolved": "https://registry.npmjs.org/jsonschema/-/jsonschema-1.4.1.tgz", + "integrity": "sha512-S6cATIPVv1z0IlxdN+zUk5EPjkGCdnhN4wVSBlvoUO1tOLJootbo9CquNJmbIh4yikWHiUedhRYrNPn1arpEmQ==", + "dev": true, + "peer": true + }, + "jsprim": { + "version": "1.4.2", + "resolved": "https://registry.npmjs.org/jsprim/-/jsprim-1.4.2.tgz", + "integrity": "sha512-P2bSOMAc/ciLz6DzgjVlGJP9+BrJWu5UDGK70C2iweC5QBIeFf0ZXRvGjEj2uYgrY2MkAAhsSWHDWlFtEroZWw==", + "dev": true, + "peer": true, + "requires": { + "assert-plus": "1.0.0", + "extsprintf": "1.3.0", + "json-schema": "0.4.0", + "verror": "1.10.0" + } + }, + "keccak": { + "version": "3.0.3", + "resolved": "https://registry.npmjs.org/keccak/-/keccak-3.0.3.tgz", + "integrity": "sha512-JZrLIAJWuZxKbCilMpNz5Vj7Vtb4scDG3dMXLOsbzBmQGyjwE61BbW7bJkfKKCShXiQZt3T6sBgALRtmd+nZaQ==", + "dev": true, + "requires": { + "node-addon-api": "^2.0.0", + "node-gyp-build": "^4.2.0", + "readable-stream": "^3.6.0" + } + }, + "kind-of": { + "version": "6.0.3", + "resolved": "https://registry.npmjs.org/kind-of/-/kind-of-6.0.3.tgz", + "integrity": "sha512-dcS1ul+9tmeD95T+x28/ehLgd9mENa3LsvDTtzm3vyBEO7RPptvAD+t44WVXaUjTBRcrpFeFlC8WCruUR456hw==", + "dev": true, + "peer": true + }, + "klaw": { + "version": "1.3.1", + "resolved": "https://registry.npmjs.org/klaw/-/klaw-1.3.1.tgz", + "integrity": "sha512-TED5xi9gGQjGpNnvRWknrwAB1eL5GciPfVFOt3Vk1OJCVDQbzuSfrF3hkUQKlsgKrG1F+0t5W0m+Fje1jIt8rw==", + "dev": true, + "requires": { + "graceful-fs": "^4.1.9" + } + }, + "level": { + "version": "8.0.0", + "resolved": "https://registry.npmjs.org/level/-/level-8.0.0.tgz", + "integrity": "sha512-ypf0jjAk2BWI33yzEaaotpq7fkOPALKAgDBxggO6Q9HGX2MRXn0wbP1Jn/tJv1gtL867+YOjOB49WaUF3UoJNQ==", + "dev": true, + "requires": { + "browser-level": "^1.0.1", + "classic-level": "^1.2.0" + } + }, + "level-supports": { + "version": "4.0.1", + "resolved": "https://registry.npmjs.org/level-supports/-/level-supports-4.0.1.tgz", + "integrity": "sha512-PbXpve8rKeNcZ9C1mUicC9auIYFyGpkV9/i6g76tLgANwWhtG2v7I4xNBUlkn3lE2/dZF3Pi0ygYGtLc4RXXdA==", + "dev": true + }, + "level-transcoder": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/level-transcoder/-/level-transcoder-1.0.1.tgz", + "integrity": "sha512-t7bFwFtsQeD8cl8NIoQ2iwxA0CL/9IFw7/9gAjOonH0PWTTiRfY7Hq+Ejbsxh86tXobDQ6IOiddjNYIfOBs06w==", + "dev": true, + "requires": { + "buffer": "^6.0.3", + "module-error": "^1.0.1" + } + }, + "levn": { + "version": "0.3.0", + "resolved": "https://registry.npmjs.org/levn/-/levn-0.3.0.tgz", + "integrity": "sha512-0OO4y2iOHix2W6ujICbKIaEQXvFQHue65vUG3pb5EUomzPI90z9hsA1VsO/dbIIpC53J8gxM9Q4Oho0jrCM/yA==", + "dev": true, + "peer": true, + "requires": { + "prelude-ls": "~1.1.2", + "type-check": "~0.3.2" + } + }, + "locate-path": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/locate-path/-/locate-path-2.0.0.tgz", + "integrity": "sha512-NCI2kiDkyR7VeEKm27Kda/iQHyKJe1Bu0FlTbYp3CqJu+9IFe9bLyAjMxf5ZDDbEg+iMPzB5zYyUTSm8wVTKmA==", + "dev": true, + "requires": { + "p-locate": "^2.0.0", + "path-exists": "^3.0.0" + } + }, + "lodash": { + "version": "4.17.21", + "resolved": "https://registry.npmjs.org/lodash/-/lodash-4.17.21.tgz", + "integrity": "sha512-v2kDEe57lecTulaDIuNTPy3Ry4gLGJ6Z1O3vE1krgXZNrsQ+LFTGHVxVjcXPs17LhbZVGedAJv8XZ1tvj5FvSg==", + "dev": true + }, + "lodash.camelcase": { + "version": "4.3.0", + "resolved": "https://registry.npmjs.org/lodash.camelcase/-/lodash.camelcase-4.3.0.tgz", + "integrity": "sha512-TwuEnCnxbc3rAvhf/LbG7tJUDzhqXyFnv3dtzLOPgCG/hODL7WFnsbwktkD7yUV0RrreP/l1PALq/YSg6VvjlA==", + "dev": true, + "peer": true + }, + "lodash.truncate": { + "version": "4.4.2", + "resolved": "https://registry.npmjs.org/lodash.truncate/-/lodash.truncate-4.4.2.tgz", + "integrity": "sha512-jttmRe7bRse52OsWIMDLaXxWqRAmtIUccAQ3garviCqJjafXOfNMO0yMfNpdD6zbGaTU0P5Nz7e7gAT6cKmJRw==", + "dev": true, + "peer": true + }, + "log-symbols": { + "version": "4.1.0", + "resolved": "https://registry.npmjs.org/log-symbols/-/log-symbols-4.1.0.tgz", + "integrity": "sha512-8XPvpAA8uyhfteu8pIvQxpJZ7SYYdpUivZpGy6sFsBuKRY/7rQGavedeB8aK+Zkyq6upMFVL/9AW6vOYzfRyLg==", + "dev": true, + "requires": { + "chalk": "^4.1.0", + "is-unicode-supported": "^0.1.0" + }, + "dependencies": { + "ansi-styles": { + "version": "4.3.0", + "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-4.3.0.tgz", + "integrity": "sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==", + "dev": true, + "requires": { + "color-convert": "^2.0.1" + } + }, + "chalk": { + "version": "4.1.2", + "resolved": "https://registry.npmjs.org/chalk/-/chalk-4.1.2.tgz", + "integrity": "sha512-oKnbhFyRIXpUuez8iBMmyEa4nbj4IOQyuhc/wy9kY7/WVPcwIO9VA668Pu8RkO7+0G76SLROeyw9CpQ061i4mA==", + "dev": true, + "requires": { + "ansi-styles": "^4.1.0", + "supports-color": "^7.1.0" + } + }, + "color-convert": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-2.0.1.tgz", + "integrity": "sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ==", + "dev": true, + "requires": { + "color-name": "~1.1.4" + } + }, + "color-name": { + "version": "1.1.4", + "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.4.tgz", + "integrity": "sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA==", + "dev": true + }, + "has-flag": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-4.0.0.tgz", + "integrity": "sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ==", + "dev": true + }, + "supports-color": { + "version": "7.2.0", + "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-7.2.0.tgz", + "integrity": "sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw==", + "dev": true, + "requires": { + "has-flag": "^4.0.0" + } + } + } + }, + "loupe": { + "version": "2.3.6", + "resolved": "https://registry.npmjs.org/loupe/-/loupe-2.3.6.tgz", + "integrity": "sha512-RaPMZKiMy8/JruncMU5Bt6na1eftNoo++R4Y+N2FrxkDVTrGvcyzFTsaGif4QTeKESheMGegbhw6iUAq+5A8zA==", + "dev": true, + "peer": true, + "requires": { + "get-func-name": "^2.0.0" + } + }, + "lru_map": { + "version": "0.3.3", + "resolved": "https://registry.npmjs.org/lru_map/-/lru_map-0.3.3.tgz", + "integrity": "sha512-Pn9cox5CsMYngeDbmChANltQl+5pi6XmTrraMSzhPmMBbmgcxmqWry0U3PGapCU1yB4/LqCcom7qhHZiF/jGfQ==", + "dev": true + }, + "lru-cache": { + "version": "5.1.1", + "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-5.1.1.tgz", + "integrity": "sha512-KpNARQA3Iwv+jTA0utUVVbrh+Jlrr1Fv0e56GGzAFOXN7dk/FviaDW8LHmK52DlcH4WP2n6gI8vN1aesBFgo9w==", + "dev": true, + "requires": { + "yallist": "^3.0.2" + } + }, + "make-error": { + "version": "1.3.6", + "resolved": "https://registry.npmjs.org/make-error/-/make-error-1.3.6.tgz", + "integrity": "sha512-s8UhlNe7vPKomQhC1qFelMokr/Sc3AgNbso3n74mVPA5LTZwkB9NlXf4XPamLxJE8h0gh73rM94xvwRT2CVInw==", + "dev": true, + "peer": true + }, + "markdown-table": { + "version": "1.1.3", + "resolved": "https://registry.npmjs.org/markdown-table/-/markdown-table-1.1.3.tgz", + "integrity": "sha512-1RUZVgQlpJSPWYbFSpmudq5nHY1doEIv89gBtF0s4gW1GF2XorxcA/70M5vq7rLv0a6mhOUccRsqkwhwLCIQ2Q==", + "dev": true, + "peer": true + }, + "mcl-wasm": { + "version": "0.7.9", + "resolved": "https://registry.npmjs.org/mcl-wasm/-/mcl-wasm-0.7.9.tgz", + "integrity": "sha512-iJIUcQWA88IJB/5L15GnJVnSQJmf/YaxxV6zRavv83HILHaJQb6y0iFyDMdDO0gN8X37tdxmAOrH/P8B6RB8sQ==", + "dev": true + }, + "md5.js": { + "version": "1.3.5", + "resolved": "https://registry.npmjs.org/md5.js/-/md5.js-1.3.5.tgz", + "integrity": "sha512-xitP+WxNPcTTOgnTJcrhM0xvdPepipPSf3I8EIpGKeFLjt3PlJLIDG3u8EX53ZIubkb+5U2+3rELYpEhHhzdkg==", + "dev": true, + "requires": { + "hash-base": "^3.0.0", + "inherits": "^2.0.1", + "safe-buffer": "^5.1.2" + } + }, + "memory-level": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/memory-level/-/memory-level-1.0.0.tgz", + "integrity": "sha512-UXzwewuWeHBz5krr7EvehKcmLFNoXxGcvuYhC41tRnkrTbJohtS7kVn9akmgirtRygg+f7Yjsfi8Uu5SGSQ4Og==", + "dev": true, + "requires": { + "abstract-level": "^1.0.0", + "functional-red-black-tree": "^1.0.1", + "module-error": "^1.0.1" + } + }, + "memorystream": { + "version": "0.3.1", + "resolved": "https://registry.npmjs.org/memorystream/-/memorystream-0.3.1.tgz", + "integrity": "sha512-S3UwM3yj5mtUSEfP41UZmt/0SCoVYUcU1rkXv+BQ5Ig8ndL4sPoJNBUJERafdPb5jjHJGuMgytgKvKIf58XNBw==", + "dev": true + }, + "merge2": { + "version": "1.4.1", + "resolved": "https://registry.npmjs.org/merge2/-/merge2-1.4.1.tgz", + "integrity": "sha512-8q7VEgMJW4J8tcfVPy8g09NcQwZdbwFEqhe/WZkoIzjn/3TGDwtOCYtXGxA3O8tPzpczCCDgv+P2P5y00ZJOOg==", + "dev": true, + "peer": true + }, + "micromatch": { + "version": "4.0.5", + "resolved": "https://registry.npmjs.org/micromatch/-/micromatch-4.0.5.tgz", + "integrity": "sha512-DMy+ERcEW2q8Z2Po+WNXuw3c5YaUSFjAO5GsJqfEl7UjvtIuFKO6ZrKvcItdy98dwFI2N1tg3zNIdKaQT+aNdA==", + "dev": true, + "peer": true, + "requires": { + "braces": "^3.0.2", + "picomatch": "^2.3.1" + } + }, + "mime-db": { + "version": "1.52.0", + "resolved": "https://registry.npmjs.org/mime-db/-/mime-db-1.52.0.tgz", + "integrity": "sha512-sPU4uV7dYlvtWJxwwxHD0PuihVNiE7TyAbQ5SWxDCB9mUYvOgroQOwYQQOKPJ8CIbE+1ETVlOoK1UC2nU3gYvg==", + "dev": true, + "peer": true + }, + "mime-types": { + "version": "2.1.35", + "resolved": "https://registry.npmjs.org/mime-types/-/mime-types-2.1.35.tgz", + "integrity": "sha512-ZDY+bPm5zTTF+YpCrAU9nK0UgICYPT0QtT1NZWFv4s++TNkcgVaT0g6+4R2uI4MjQjzysHB1zxuWL50hzaeXiw==", + "dev": true, + "peer": true, + "requires": { + "mime-db": "1.52.0" + } + }, + "minimalistic-assert": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/minimalistic-assert/-/minimalistic-assert-1.0.1.tgz", + "integrity": "sha512-UtJcAD4yEaGtjPezWuO9wC4nwUnVH/8/Im3yEHQP4b67cXlD/Qr9hdITCU1xDbSEXg2XKNaP8jsReV7vQd00/A==", + "dev": true + }, + "minimalistic-crypto-utils": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/minimalistic-crypto-utils/-/minimalistic-crypto-utils-1.0.1.tgz", + "integrity": "sha512-JIYlbt6g8i5jKfJ3xz7rF0LXmv2TkDxBLUkiBeZ7bAx4GnnNMr8xFpGnOxn6GhTEHx3SjRrZEoU+j04prX1ktg==", + "dev": true + }, + "minimatch": { + "version": "3.1.2", + "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.1.2.tgz", + "integrity": "sha512-J7p63hRiAjw1NDEww1W7i37+ByIrOWO5XQQAzZ3VOcL0PNybwpfmV/N05zFAzwQ9USyEcX6t3UO+K5aqBQOIHw==", + "dev": true, + "requires": { + "brace-expansion": "^1.1.7" + } + }, + "minimist": { + "version": "1.2.8", + "resolved": "https://registry.npmjs.org/minimist/-/minimist-1.2.8.tgz", + "integrity": "sha512-2yyAR8qBkN3YuheJanUpWC5U3bb5osDywNB8RzDVlDwDHbocAJveqqj1u8+SVD7jkWT4yvsHCpWqqWqAxb0zCA==", + "dev": true, + "peer": true + }, + "mkdirp": { + "version": "0.5.6", + "resolved": "https://registry.npmjs.org/mkdirp/-/mkdirp-0.5.6.tgz", + "integrity": "sha512-FP+p8RB8OWpF3YZBCrP5gtADmtXApB5AMLn+vdyA+PyxCjrCs00mjyUozssO33cwDeT3wNGdLxJ5M//YqtHAJw==", + "dev": true, + "peer": true, + "requires": { + "minimist": "^1.2.6" + } + }, + "mnemonist": { + "version": "0.38.5", + "resolved": "https://registry.npmjs.org/mnemonist/-/mnemonist-0.38.5.tgz", + "integrity": "sha512-bZTFT5rrPKtPJxj8KSV0WkPyNxl72vQepqqVUAW2ARUpUSF2qXMB6jZj7hW5/k7C1rtpzqbD/IIbJwLXUjCHeg==", + "dev": true, + "requires": { + "obliterator": "^2.0.0" + } + }, + "mocha": { + "version": "10.2.0", + "resolved": "https://registry.npmjs.org/mocha/-/mocha-10.2.0.tgz", + "integrity": "sha512-IDY7fl/BecMwFHzoqF2sg/SHHANeBoMMXFlS9r0OXKDssYE1M5O43wUY/9BVPeIvfH2zmEbBfseqN9gBQZzXkg==", + "dev": true, + "requires": { + "ansi-colors": "4.1.1", + "browser-stdout": "1.3.1", + "chokidar": "3.5.3", + "debug": "4.3.4", + "diff": "5.0.0", + "escape-string-regexp": "4.0.0", + "find-up": "5.0.0", + "glob": "7.2.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", + "workerpool": "6.2.1", + "yargs": "16.2.0", + "yargs-parser": "20.2.4", + "yargs-unparser": "2.0.0" + }, + "dependencies": { + "ansi-colors": { + "version": "4.1.1", + "resolved": "https://registry.npmjs.org/ansi-colors/-/ansi-colors-4.1.1.tgz", + "integrity": "sha512-JoX0apGbHaUJBNl6yF+p6JAFYZ666/hhCGKN5t9QFjbJQKUU/g8MNbFDbvfrgKXvI1QpZplPOnwIo99lX/AAmA==", + "dev": true + }, + "brace-expansion": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-2.0.1.tgz", + "integrity": "sha512-XnAIvQ8eM+kC6aULx6wuQiwVsnzsi9d3WxzV3FpWTGA19F621kwdbsAcFKXgKUHZWsy+mY6iL1sHTxWEFCytDA==", + "dev": true, + "requires": { + "balanced-match": "^1.0.0" + } + }, + "escape-string-regexp": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/escape-string-regexp/-/escape-string-regexp-4.0.0.tgz", + "integrity": "sha512-TtpcNJ3XAzx3Gq8sWRzJaVajRs0uVxA2YAkdb1jm2YkPz4G6egUFAyA3n5vtEIZefPk5Wa4UXbKuS5fKkJWdgA==", + "dev": true + }, + "find-up": { + "version": "5.0.0", + "resolved": "https://registry.npmjs.org/find-up/-/find-up-5.0.0.tgz", + "integrity": "sha512-78/PXT1wlLLDgTzDs7sjq9hzz0vXD+zn+7wypEe4fXQxCmdmqfGsEPQxmiCSQI3ajFV91bVSsvNtrJRiW6nGng==", + "dev": true, + "requires": { + "locate-path": "^6.0.0", + "path-exists": "^4.0.0" + } + }, + "has-flag": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-4.0.0.tgz", + "integrity": "sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ==", + "dev": true + }, + "locate-path": { + "version": "6.0.0", + "resolved": "https://registry.npmjs.org/locate-path/-/locate-path-6.0.0.tgz", + "integrity": "sha512-iPZK6eYjbxRu3uB4/WZ3EsEIMJFMqAoopl3R+zuq0UjcAm/MO6KCweDgPfP3elTztoKP3KtnVHxTn2NHBSDVUw==", + "dev": true, + "requires": { + "p-locate": "^5.0.0" + } + }, + "minimatch": { + "version": "5.0.1", + "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-5.0.1.tgz", + "integrity": "sha512-nLDxIFRyhDblz3qMuq+SoRZED4+miJ/G+tdDrjkkkRnjAsBexeGpgjLEQ0blJy7rHhR2b93rhQY4SvyWu9v03g==", + "dev": true, + "requires": { + "brace-expansion": "^2.0.1" + } + }, + "ms": { + "version": "2.1.3", + "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz", + "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==", + "dev": true + }, + "p-limit": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/p-limit/-/p-limit-3.1.0.tgz", + "integrity": "sha512-TYOanM3wGwNGsZN2cVTYPArw454xnXj5qmWF1bEoAc4+cU/ol7GVh7odevjp1FNHduHc3KZMcFduxU5Xc6uJRQ==", + "dev": true, + "requires": { + "yocto-queue": "^0.1.0" + } + }, + "p-locate": { + "version": "5.0.0", + "resolved": "https://registry.npmjs.org/p-locate/-/p-locate-5.0.0.tgz", + "integrity": "sha512-LaNjtRWUBY++zB5nE/NwcaoMylSPk+S+ZHNB1TzdbMJMny6dynpAGt7X/tl/QYq3TIeE6nxHppbo2LGymrG5Pw==", + "dev": true, + "requires": { + "p-limit": "^3.0.2" + } + }, + "path-exists": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/path-exists/-/path-exists-4.0.0.tgz", + "integrity": "sha512-ak9Qy5Q7jYb2Wwcey5Fpvg2KoAc/ZIhLSLOSBmRmygPsGwkVVt0fZa0qrtMz+m6tJTAHfZQ8FnmB4MG4LWy7/w==", + "dev": true + }, + "supports-color": { + "version": "8.1.1", + "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-8.1.1.tgz", + "integrity": "sha512-MpUEN2OodtUzxvKQl72cUF7RQ5EiHsGvSsVG0ia9c5RbWGL2CI4C7EpPS8UTBIplnlzZiNuV56w+FuNxy3ty2Q==", + "dev": true, + "requires": { + "has-flag": "^4.0.0" + } + } + } + }, + "module-error": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/module-error/-/module-error-1.0.2.tgz", + "integrity": "sha512-0yuvsqSCv8LbaOKhnsQ/T5JhyFlCYLPXK3U2sgV10zoKQwzs/MyfuQUOZQ1V/6OCOJsK/TRgNVrPuPDqtdMFtA==", + "dev": true + }, + "ms": { + "version": "2.1.2", + "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.2.tgz", + "integrity": "sha512-sGkPx+VjMtmA6MX27oA4FBFELFCZZ4S4XqeGOXCv68tT+jb3vk/RyaKWP0PTKyWtmLSM0b+adUTEvbs1PEaH2w==", + "dev": true + }, + "nanoid": { + "version": "3.3.3", + "resolved": "https://registry.npmjs.org/nanoid/-/nanoid-3.3.3.tgz", + "integrity": "sha512-p1sjXuopFs0xg+fPASzQ28agW1oHD7xDsd9Xkf3T15H3c/cifrFHVwrh74PdoklAPi+i7MdRsE47vm2r6JoB+w==", + "dev": true + }, + "napi-macros": { + "version": "2.2.2", + "resolved": "https://registry.npmjs.org/napi-macros/-/napi-macros-2.2.2.tgz", + "integrity": "sha512-hmEVtAGYzVQpCKdbQea4skABsdXW4RUh5t5mJ2zzqowJS2OyXZTU1KhDVFhx+NlWZ4ap9mqR9TcDO3LTTttd+g==", + "dev": true + }, + "neo-async": { + "version": "2.6.2", + "resolved": "https://registry.npmjs.org/neo-async/-/neo-async-2.6.2.tgz", + "integrity": "sha512-Yd3UES5mWCSqR+qNT93S3UoYUkqAZ9lLg8a7g9rimsWmYGK8cVToA4/sF3RrshdyV3sAGMXVUmpMYOw+dLpOuw==", + "dev": true, + "peer": true + }, + "node-addon-api": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/node-addon-api/-/node-addon-api-2.0.2.tgz", + "integrity": "sha512-Ntyt4AIXyaLIuMHF6IOoTakB3K+RWxwtsHNRxllEoA6vPwP9o4866g6YWDLUdnucilZhmkxiHwHr11gAENw+QA==", + "dev": true + }, + "node-emoji": { + "version": "1.11.0", + "resolved": "https://registry.npmjs.org/node-emoji/-/node-emoji-1.11.0.tgz", + "integrity": "sha512-wo2DpQkQp7Sjm2A0cq+sN7EHKO6Sl0ctXeBdFZrL9T9+UywORbufTcTZxom8YqpLQt/FqNMUkOpkZrJVYSKD3A==", + "dev": true, + "peer": true, + "requires": { + "lodash": "^4.17.21" + } + }, + "node-environment-flags": { + "version": "1.0.6", + "resolved": "https://registry.npmjs.org/node-environment-flags/-/node-environment-flags-1.0.6.tgz", + "integrity": "sha512-5Evy2epuL+6TM0lCQGpFIj6KwiEsGh1SrHUhTbNX+sLbBtjidPZFAnVK9y5yU1+h//RitLbRHTIMyxQPtxMdHw==", + "dev": true, + "peer": true, + "requires": { + "object.getownpropertydescriptors": "^2.0.3", + "semver": "^5.7.0" + }, + "dependencies": { + "semver": { + "version": "5.7.1", + "resolved": "https://registry.npmjs.org/semver/-/semver-5.7.1.tgz", + "integrity": "sha512-sauaDf/PZdVgrLTNYHRtpXa1iRiKcaebiKQ1BJdpQlWH2lCvexQdX55snPFyK7QzpudqbCI0qXFfOasHdyNDGQ==", + "dev": true, + "peer": true + } + } + }, + "node-gyp-build": { + "version": "4.6.0", + "resolved": "https://registry.npmjs.org/node-gyp-build/-/node-gyp-build-4.6.0.tgz", + "integrity": "sha512-NTZVKn9IylLwUzaKjkas1e4u2DLNcV4rdYagA4PWdPwW87Bi7z+BznyKSRwS/761tV/lzCGXplWsiaMjLqP2zQ==", + "dev": true + }, + "nofilter": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/nofilter/-/nofilter-3.1.0.tgz", + "integrity": "sha512-l2NNj07e9afPnhAhvgVrCD/oy2Ai1yfLpuo3EpiO1jFTsB4sFz6oIfAfSZyQzVpkZQ9xS8ZS5g1jCBgq4Hwo0g==", + "dev": true, + "peer": true + }, + "nopt": { + "version": "3.0.6", + "resolved": "https://registry.npmjs.org/nopt/-/nopt-3.0.6.tgz", + "integrity": "sha512-4GUt3kSEYmk4ITxzB/b9vaIDfUVWN/Ml1Fwl11IlnIG2iaJ9O6WXZ9SrYM9NLI8OCBieN2Y8SWC2oJV0RQ7qYg==", + "dev": true, + "peer": true, + "requires": { + "abbrev": "1" + } + }, + "normalize-path": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/normalize-path/-/normalize-path-3.0.0.tgz", + "integrity": "sha512-6eZs5Ls3WtCisHWp9S2GUy8dqkpGi4BVSz3GaqiE6ezub0512ESztXUwUB6C6IKbQkY2Pnb/mD4WYojCRwcwLA==", + "dev": true + }, + "number-to-bn": { + "version": "1.7.0", + "resolved": "https://registry.npmjs.org/number-to-bn/-/number-to-bn-1.7.0.tgz", + "integrity": "sha512-wsJ9gfSz1/s4ZsJN01lyonwuxA1tml6X1yBDnfpMglypcBRFZZkus26EdPSlqS5GJfYddVZa22p3VNb3z5m5Ig==", + "dev": true, + "peer": true, + "requires": { + "bn.js": "4.11.6", + "strip-hex-prefix": "1.0.0" + }, + "dependencies": { + "bn.js": { + "version": "4.11.6", + "resolved": "https://registry.npmjs.org/bn.js/-/bn.js-4.11.6.tgz", + "integrity": "sha512-XWwnNNFCuuSQ0m3r3C4LE3EiORltHd9M05pq6FOlVeiophzRbMo50Sbz1ehl8K3Z+jw9+vmgnXefY1hz8X+2wA==", + "dev": true, + "peer": true + } + } + }, + "oauth-sign": { + "version": "0.9.0", + "resolved": "https://registry.npmjs.org/oauth-sign/-/oauth-sign-0.9.0.tgz", + "integrity": "sha512-fexhUFFPTGV8ybAtSIGbV6gOkSv8UtRbDBnAyLQw4QPKkgNlsH2ByPGtMUqdWkos6YCRmAqViwgZrJc/mRDzZQ==", + "dev": true, + "peer": true + }, + "object-assign": { + "version": "4.1.1", + "resolved": "https://registry.npmjs.org/object-assign/-/object-assign-4.1.1.tgz", + "integrity": "sha512-rJgTQnkUnH1sFw8yT6VSU3zD3sWmu6sZhIseY8VX+GRu3P6F7Fu+JNDoXfklElbLJSnc3FUQHVe4cU5hj+BcUg==", + "dev": true, + "peer": true + }, + "object-inspect": { + "version": "1.12.3", + "resolved": "https://registry.npmjs.org/object-inspect/-/object-inspect-1.12.3.tgz", + "integrity": "sha512-geUvdk7c+eizMNUDkRpW1wJwgfOiOeHbxBR/hLXK1aT6zmVSO0jsQcs7fj6MGw89jC/cjGfLcNOrtMYtGqm81g==", + "dev": true + }, + "object-keys": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/object-keys/-/object-keys-1.1.1.tgz", + "integrity": "sha512-NuAESUOUMrlIXOfHKzD6bpPu3tYt3xvjNdRIQ+FeT0lNb4K8WR70CaDxhuNguS2XG+GjkyMwOzsN5ZktImfhLA==", + "dev": true, + "peer": true + }, + "object.assign": { + "version": "4.1.0", + "resolved": "https://registry.npmjs.org/object.assign/-/object.assign-4.1.0.tgz", + "integrity": "sha512-exHJeq6kBKj58mqGyTQ9DFvrZC/eR6OwxzoM9YRoGBqrXYonaFyGiFMuc9VZrXf7DarreEwMpurG3dd+CNyW5w==", + "dev": true, + "peer": true, + "requires": { + "define-properties": "^1.1.2", + "function-bind": "^1.1.1", + "has-symbols": "^1.0.0", + "object-keys": "^1.0.11" + } + }, + "object.getownpropertydescriptors": { + "version": "2.1.6", + "resolved": "https://registry.npmjs.org/object.getownpropertydescriptors/-/object.getownpropertydescriptors-2.1.6.tgz", + "integrity": "sha512-lq+61g26E/BgHv0ZTFgRvi7NMEPuAxLkFU7rukXjc/AlwH4Am5xXVnIXy3un1bg/JPbXHrixRkK1itUzzPiIjQ==", + "dev": true, + "peer": true, + "requires": { + "array.prototype.reduce": "^1.0.5", + "call-bind": "^1.0.2", + "define-properties": "^1.2.0", + "es-abstract": "^1.21.2", + "safe-array-concat": "^1.0.0" + } + }, + "obliterator": { + "version": "2.0.4", + "resolved": "https://registry.npmjs.org/obliterator/-/obliterator-2.0.4.tgz", + "integrity": "sha512-lgHwxlxV1qIg1Eap7LgIeoBWIMFibOjbrYPIPJZcI1mmGAI2m3lNYpK12Y+GBdPQ0U1hRwSord7GIaawz962qQ==", + "dev": true + }, + "once": { + "version": "1.4.0", + "resolved": "https://registry.npmjs.org/once/-/once-1.4.0.tgz", + "integrity": "sha512-lNaJgI+2Q5URQBkccEKHTQOPaXdUxnZZElQTZY0MFUAuaEqe1E+Nyvgdz/aIyNi6Z9MzO5dv1H8n58/GELp3+w==", + "dev": true, + "requires": { + "wrappy": "1" + } + }, + "optionator": { + "version": "0.8.3", + "resolved": "https://registry.npmjs.org/optionator/-/optionator-0.8.3.tgz", + "integrity": "sha512-+IW9pACdk3XWmmTXG8m3upGUJst5XRGzxMRjXzAuJ1XnIFNvfhjjIuYkDvysnPQ7qzqVzLt78BCruntqRhWQbA==", + "dev": true, + "peer": true, + "requires": { + "deep-is": "~0.1.3", + "fast-levenshtein": "~2.0.6", + "levn": "~0.3.0", + "prelude-ls": "~1.1.2", + "type-check": "~0.3.2", + "word-wrap": "~1.2.3" + } + }, + "ordinal": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/ordinal/-/ordinal-1.0.3.tgz", + "integrity": "sha512-cMddMgb2QElm8G7vdaa02jhUNbTSrhsgAGUz1OokD83uJTwSUn+nKoNoKVVaRa08yF6sgfO7Maou1+bgLd9rdQ==", + "dev": true, + "peer": true + }, + "os-tmpdir": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/os-tmpdir/-/os-tmpdir-1.0.2.tgz", + "integrity": "sha512-D2FR03Vir7FIu45XBY20mTb+/ZSWB00sjU9jdQXt83gDrI4Ztz5Fs7/yy74g2N5SVQY4xY1qDr4rNddwYRVX0g==", + "dev": true + }, + "p-limit": { + "version": "1.3.0", + "resolved": "https://registry.npmjs.org/p-limit/-/p-limit-1.3.0.tgz", + "integrity": "sha512-vvcXsLAJ9Dr5rQOPk7toZQZJApBl2K4J6dANSsEuh6QI41JYcsS/qhTGa9ErIUUgK3WNQoJYvylxvjqmiqEA9Q==", + "dev": true, + "requires": { + "p-try": "^1.0.0" + } + }, + "p-locate": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/p-locate/-/p-locate-2.0.0.tgz", + "integrity": "sha512-nQja7m7gSKuewoVRen45CtVfODR3crN3goVQ0DDZ9N3yHxgpkuBhZqsaiotSQRrADUrne346peY7kT3TSACykg==", + "dev": true, + "requires": { + "p-limit": "^1.1.0" + } + }, + "p-map": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/p-map/-/p-map-4.0.0.tgz", + "integrity": "sha512-/bjOqmgETBYB5BoEeGVea8dmvHb2m9GLy1E9W43yeyfP6QQCZGFNa+XRceJEuDB6zqr+gKpIAmlLebMpykw/MQ==", + "dev": true, + "requires": { + "aggregate-error": "^3.0.0" + } + }, + "p-try": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/p-try/-/p-try-1.0.0.tgz", + "integrity": "sha512-U1etNYuMJoIz3ZXSrrySFjsXQTWOx2/jdi86L+2pRvph/qMKL6sbcCYdH23fqsbm8TH2Gn0OybpT4eSFlCVHww==", + "dev": true + }, + "parse-cache-control": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/parse-cache-control/-/parse-cache-control-1.0.1.tgz", + "integrity": "sha512-60zvsJReQPX5/QP0Kzfd/VrpjScIQ7SHBW6bFCYfEP+fp0Eppr1SHhIO5nd1PjZtvclzSzES9D/p5nFJurwfWg==", + "dev": true, + "peer": true + }, + "path-exists": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/path-exists/-/path-exists-3.0.0.tgz", + "integrity": "sha512-bpC7GYwiDYQ4wYLe+FA8lhRjhQCMcQGuSgGGqDkg/QerRWw9CmGRT0iSOVRSZJ29NMLZgIzqaljJ63oaL4NIJQ==", + "dev": true + }, + "path-is-absolute": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/path-is-absolute/-/path-is-absolute-1.0.1.tgz", + "integrity": "sha512-AVbw3UJ2e9bq64vSaS9Am0fje1Pa8pbGqTTsmXfaIiMpnr5DlDhfJOuLj9Sf95ZPVDAUerDfEk88MPmPe7UCQg==", + "dev": true + }, + "path-parse": { + "version": "1.0.7", + "resolved": "https://registry.npmjs.org/path-parse/-/path-parse-1.0.7.tgz", + "integrity": "sha512-LDJzPVEEEPR+y48z93A0Ed0yXb8pAByGWo/k5YYdYgpY2/2EsOsksJrq7lOHxryrVOn1ejG6oAp8ahvOIQD8sw==", + "dev": true + }, + "path-type": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/path-type/-/path-type-4.0.0.tgz", + "integrity": "sha512-gDKb8aZMDeD/tZWs9P6+q0J9Mwkdl6xMV8TjnGP3qJVJ06bdMgkbBlLU8IdfOsIsFz2BW1rNVT3XuNEl8zPAvw==", + "dev": true, + "peer": true + }, + "pathval": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/pathval/-/pathval-1.1.1.tgz", + "integrity": "sha512-Dp6zGqpTdETdR63lehJYPeIOqpiNBNtc7BpWSLrOje7UaIsE5aY92r/AunQA7rsXvet3lrJ3JnZX29UPTKXyKQ==", + "dev": true, + "peer": true + }, + "pbkdf2": { + "version": "3.1.2", + "resolved": "https://registry.npmjs.org/pbkdf2/-/pbkdf2-3.1.2.tgz", + "integrity": "sha512-iuh7L6jA7JEGu2WxDwtQP1ddOpaJNC4KlDEFfdQajSGgGPNi4OyDc2R7QnbY2bR9QjBVGwgvTdNJZoE7RaxUMA==", + "dev": true, + "requires": { + "create-hash": "^1.1.2", + "create-hmac": "^1.1.4", + "ripemd160": "^2.0.1", + "safe-buffer": "^5.0.1", + "sha.js": "^2.4.8" + } + }, + "performance-now": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/performance-now/-/performance-now-2.1.0.tgz", + "integrity": "sha512-7EAHlyLHI56VEIdK57uwHdHKIaAGbnXPiw0yWbarQZOKaKpvUIgW0jWRVLiatnM+XXlSwsanIBH/hzGMJulMow==", + "dev": true, + "peer": true + }, + "picomatch": { + "version": "2.3.1", + "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-2.3.1.tgz", + "integrity": "sha512-JU3teHTNjmE2VCGFzuY8EXzCDVwEqB2a8fsIvwaStHhAWJEeVd1o1QD80CU6+ZdEXXSLbSsuLwJjkCBWqRQUVA==", + "dev": true + }, + "pify": { + "version": "4.0.1", + "resolved": "https://registry.npmjs.org/pify/-/pify-4.0.1.tgz", + "integrity": "sha512-uB80kBFb/tfd68bVleG9T5GGsGPjJrLAUpR5PZIrhBnIaRTQRjqdJSsIKkOP6OAIFbj7GOrcudc5pNjZ+geV2g==", + "dev": true, + "peer": true + }, + "prelude-ls": { + "version": "1.1.2", + "resolved": "https://registry.npmjs.org/prelude-ls/-/prelude-ls-1.1.2.tgz", + "integrity": "sha512-ESF23V4SKG6lVSGZgYNpbsiaAkdab6ZgOxe52p7+Kid3W3u3bxR4Vfd/o21dmN7jSt0IwgZ4v5MUd26FEtXE9w==", + "dev": true, + "peer": true + }, + "prettier": { + "version": "2.8.8", + "resolved": "https://registry.npmjs.org/prettier/-/prettier-2.8.8.tgz", + "integrity": "sha512-tdN8qQGvNjw4CHbY+XXk0JgCXn9QiF21a55rBe5LJAU+kDyC4WQn4+awm2Xfk2lQMk5fKup9XgzTZtGkjBdP9Q==", + "dev": true, + "peer": true + }, + "process-nextick-args": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/process-nextick-args/-/process-nextick-args-2.0.1.tgz", + "integrity": "sha512-3ouUOpQhtgrbOa17J7+uxOTpITYWaGP7/AhoR3+A+/1e9skrzelGi/dXzEYyvbxubEF6Wn2ypscTKiKJFFn1ag==", + "dev": true, + "peer": true + }, + "promise": { + "version": "8.3.0", + "resolved": "https://registry.npmjs.org/promise/-/promise-8.3.0.tgz", + "integrity": "sha512-rZPNPKTOYVNEEKFaq1HqTgOwZD+4/YHS5ukLzQCypkj+OkYx7iv0mA91lJlpPPZ8vMau3IIGj5Qlwrx+8iiSmg==", + "dev": true, + "peer": true, + "requires": { + "asap": "~2.0.6" + } + }, + "psl": { + "version": "1.9.0", + "resolved": "https://registry.npmjs.org/psl/-/psl-1.9.0.tgz", + "integrity": "sha512-E/ZsdU4HLs/68gYzgGTkMicWTLPdAftJLfJFlLUAAKZGkStNU72sZjT66SnMDVOfOWY/YAoiD7Jxa9iHvngcag==", + "dev": true, + "peer": true + }, + "punycode": { + "version": "2.3.0", + "resolved": "https://registry.npmjs.org/punycode/-/punycode-2.3.0.tgz", + "integrity": "sha512-rRV+zQD8tVFys26lAGR9WUuS4iUAngJScM+ZRSKtvl5tKeZ2t5bvdNFdNHBW9FWR4guGHlgmsZ1G7BSm2wTbuA==", + "dev": true, + "peer": true + }, + "qs": { + "version": "6.11.1", + "resolved": "https://registry.npmjs.org/qs/-/qs-6.11.1.tgz", + "integrity": "sha512-0wsrzgTz/kAVIeuxSjnpGC56rzYtr6JT/2BwEvMaPhFIoYa1aGO8LbzuU1R0uUYQkLpWBTOj0l/CLAJB64J6nQ==", + "dev": true, + "requires": { + "side-channel": "^1.0.4" + } + }, + "queue-microtask": { + "version": "1.2.3", + "resolved": "https://registry.npmjs.org/queue-microtask/-/queue-microtask-1.2.3.tgz", + "integrity": "sha512-NuaNSa6flKT5JaSYQzJok04JzTL1CA6aGhv5rfLW3PgqA+M2ChpZQnAC8h8i4ZFkBS8X5RqkDBHA7r4hej3K9A==", + "dev": true + }, + "randombytes": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/randombytes/-/randombytes-2.1.0.tgz", + "integrity": "sha512-vYl3iOX+4CKUWuxGi9Ukhie6fsqXqS9FE2Zaic4tNFD2N2QQaXOMFbuKK4QmDHC0JO6B1Zp41J0LpT0oR68amQ==", + "dev": true, + "requires": { + "safe-buffer": "^5.1.0" + } + }, + "raw-body": { + "version": "2.5.2", + "resolved": "https://registry.npmjs.org/raw-body/-/raw-body-2.5.2.tgz", + "integrity": "sha512-8zGqypfENjCIqGhgXToC8aB2r7YrBX+AQAfIPs/Mlk+BtPTztOvTS01NRW/3Eh60J+a48lt8qsCzirQ6loCVfA==", + "dev": true, + "requires": { + "bytes": "3.1.2", + "http-errors": "2.0.0", + "iconv-lite": "0.4.24", + "unpipe": "1.0.0" + } + }, + "readable-stream": { + "version": "3.6.2", + "resolved": "https://registry.npmjs.org/readable-stream/-/readable-stream-3.6.2.tgz", + "integrity": "sha512-9u/sniCrY3D5WdsERHzHE4G2YCXqoG5FTHUiCC4SIbr6XcLZBY05ya9EKjYek9O5xOAwjGq+1JdGBAS7Q9ScoA==", + "dev": true, + "requires": { + "inherits": "^2.0.3", + "string_decoder": "^1.1.1", + "util-deprecate": "^1.0.1" + } + }, + "readdirp": { + "version": "3.6.0", + "resolved": "https://registry.npmjs.org/readdirp/-/readdirp-3.6.0.tgz", + "integrity": "sha512-hOS089on8RduqdbhvQ5Z37A0ESjsqz6qnRcffsMU3495FuTdqSm+7bhJ29JvIOsBDEEnan5DPu9t3To9VRlMzA==", + "dev": true, + "requires": { + "picomatch": "^2.2.1" + } + }, + "rechoir": { + "version": "0.6.2", + "resolved": "https://registry.npmjs.org/rechoir/-/rechoir-0.6.2.tgz", + "integrity": "sha512-HFM8rkZ+i3zrV+4LQjwQ0W+ez98pApMGM3HUrN04j3CqzPOzl9nmP15Y8YXNm8QHGv/eacOVEjqhmWpkRV0NAw==", + "dev": true, + "peer": true, + "requires": { + "resolve": "^1.1.6" + } + }, + "recursive-readdir": { + "version": "2.2.3", + "resolved": "https://registry.npmjs.org/recursive-readdir/-/recursive-readdir-2.2.3.tgz", + "integrity": "sha512-8HrF5ZsXk5FAH9dgsx3BlUer73nIhuj+9OrQwEbLTPOBzGkL1lsFCR01am+v+0m2Cmbs1nP12hLDl5FA7EszKA==", + "dev": true, + "peer": true, + "requires": { + "minimatch": "^3.0.5" + } + }, + "reduce-flatten": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/reduce-flatten/-/reduce-flatten-2.0.0.tgz", + "integrity": "sha512-EJ4UNY/U1t2P/2k6oqotuX2Cc3T6nxJwsM0N0asT7dhrtH1ltUxDn4NalSYmPE2rCkVpcf/X6R0wDwcFpzhd4w==", + "dev": true, + "peer": true + }, + "regexp.prototype.flags": { + "version": "1.5.0", + "resolved": "https://registry.npmjs.org/regexp.prototype.flags/-/regexp.prototype.flags-1.5.0.tgz", + "integrity": "sha512-0SutC3pNudRKgquxGoRGIz946MZVHqbNfPjBdxeOhBrdgDKlRoXmYLQN9xRbrR09ZXWeGAdPuif7egofn6v5LA==", + "dev": true, + "peer": true, + "requires": { + "call-bind": "^1.0.2", + "define-properties": "^1.2.0", + "functions-have-names": "^1.2.3" + } + }, + "req-cwd": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/req-cwd/-/req-cwd-2.0.0.tgz", + "integrity": "sha512-ueoIoLo1OfB6b05COxAA9UpeoscNpYyM+BqYlA7H6LVF4hKGPXQQSSaD2YmvDVJMkk4UDpAHIeU1zG53IqjvlQ==", + "dev": true, + "peer": true, + "requires": { + "req-from": "^2.0.0" + } + }, + "req-from": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/req-from/-/req-from-2.0.0.tgz", + "integrity": "sha512-LzTfEVDVQHBRfjOUMgNBA+V6DWsSnoeKzf42J7l0xa/B4jyPOuuF5MlNSmomLNGemWTnV2TIdjSSLnEn95fOQA==", + "dev": true, + "peer": true, + "requires": { + "resolve-from": "^3.0.0" + } + }, + "request": { + "version": "2.88.2", + "resolved": "https://registry.npmjs.org/request/-/request-2.88.2.tgz", + "integrity": "sha512-MsvtOrfG9ZcrOwAW+Qi+F6HbD0CWXEh9ou77uOb7FM2WPhwT7smM833PzanhJLsgXjN89Ir6V2PczXNnMpwKhw==", + "dev": true, + "peer": true, + "requires": { + "aws-sign2": "~0.7.0", + "aws4": "^1.8.0", + "caseless": "~0.12.0", + "combined-stream": "~1.0.6", + "extend": "~3.0.2", + "forever-agent": "~0.6.1", + "form-data": "~2.3.2", + "har-validator": "~5.1.3", + "http-signature": "~1.2.0", + "is-typedarray": "~1.0.0", + "isstream": "~0.1.2", + "json-stringify-safe": "~5.0.1", + "mime-types": "~2.1.19", + "oauth-sign": "~0.9.0", + "performance-now": "^2.1.0", + "qs": "~6.5.2", + "safe-buffer": "^5.1.2", + "tough-cookie": "~2.5.0", + "tunnel-agent": "^0.6.0", + "uuid": "^3.3.2" + }, + "dependencies": { + "qs": { + "version": "6.5.3", + "resolved": "https://registry.npmjs.org/qs/-/qs-6.5.3.tgz", + "integrity": "sha512-qxXIEh4pCGfHICj1mAJQ2/2XVZkjCDTcEgfoSQxc/fYivUZxTkk7L3bDBJSoNrEzXI17oUO5Dp07ktqE5KzczA==", + "dev": true, + "peer": true + }, + "uuid": { + "version": "3.4.0", + "resolved": "https://registry.npmjs.org/uuid/-/uuid-3.4.0.tgz", + "integrity": "sha512-HjSDRw6gZE5JMggctHBcjVak08+KEVhSIiDzFnT9S9aegmp85S/bReBVTb4QTFaRNptJ9kuYaNhnbNEOkbKb/A==", + "dev": true, + "peer": true + } + } + }, + "request-promise-core": { + "version": "1.1.4", + "resolved": "https://registry.npmjs.org/request-promise-core/-/request-promise-core-1.1.4.tgz", + "integrity": "sha512-TTbAfBBRdWD7aNNOoVOBH4pN/KigV6LyapYNNlAPA8JwbovRti1E88m3sYAwsLi5ryhPKsE9APwnjFTgdUjTpw==", + "dev": true, + "peer": true, + "requires": { + "lodash": "^4.17.19" + } + }, + "request-promise-native": { + "version": "1.0.9", + "resolved": "https://registry.npmjs.org/request-promise-native/-/request-promise-native-1.0.9.tgz", + "integrity": "sha512-wcW+sIUiWnKgNY0dqCpOZkUbF/I+YPi+f09JZIDa39Ec+q82CpSYniDp+ISgTTbKmnpJWASeJBPZmoxH84wt3g==", + "dev": true, + "peer": true, + "requires": { + "request-promise-core": "1.1.4", + "stealthy-require": "^1.1.1", + "tough-cookie": "^2.3.3" + } + }, + "require-directory": { + "version": "2.1.1", + "resolved": "https://registry.npmjs.org/require-directory/-/require-directory-2.1.1.tgz", + "integrity": "sha512-fGxEI7+wsG9xrvdjsrlmL22OMTTiHRwAMroiEeMgq8gzoLC/PQr7RsRDSTLUg/bZAZtF+TVIkHc6/4RIKrui+Q==", + "dev": true + }, + "require-from-string": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/require-from-string/-/require-from-string-2.0.2.tgz", + "integrity": "sha512-Xf0nWe6RseziFMu+Ap9biiUbmplq6S9/p+7w7YXP/JBHhrUDDUhwa+vANyubuqfZWTveU//DYVGsDG7RKL/vEw==", + "dev": true + }, + "require-main-filename": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/require-main-filename/-/require-main-filename-2.0.0.tgz", + "integrity": "sha512-NKN5kMDylKuldxYLSUfrbo5Tuzh4hd+2E8NPPX02mZtn1VuREQToYe/ZdlJy+J3uCpfaiGF05e7B8W0iXbQHmg==", + "dev": true, + "peer": true + }, + "resolve": { + "version": "1.17.0", + "resolved": "https://registry.npmjs.org/resolve/-/resolve-1.17.0.tgz", + "integrity": "sha512-ic+7JYiV8Vi2yzQGFWOkiZD5Z9z7O2Zhm9XMaTxdJExKasieFCr+yXZ/WmXsckHiKl12ar0y6XiXDx3m4RHn1w==", + "dev": true, + "requires": { + "path-parse": "^1.0.6" + } + }, + "resolve-from": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/resolve-from/-/resolve-from-3.0.0.tgz", + "integrity": "sha512-GnlH6vxLymXJNMBo7XP1fJIzBFbdYt49CuTwmB/6N53t+kMPRMFKz783LlQ4tv28XoQfMWinAJX6WCGf2IlaIw==", + "dev": true, + "peer": true + }, + "reusify": { + "version": "1.0.4", + "resolved": "https://registry.npmjs.org/reusify/-/reusify-1.0.4.tgz", + "integrity": "sha512-U9nH88a3fc/ekCF1l0/UP1IosiuIjyTh7hBvXVMHYgVcfGvt897Xguj2UOLDeI5BG2m7/uwyaLVT6fbtCwTyzw==", + "dev": true, + "peer": true + }, + "rimraf": { + "version": "2.7.1", + "resolved": "https://registry.npmjs.org/rimraf/-/rimraf-2.7.1.tgz", + "integrity": "sha512-uWjbaKIK3T1OSVptzX7Nl6PvQ3qAGtKEtVRjRuazjfL3Bx5eI409VZSqgND+4UNnmzLVdPj9FqFJNPqBZFve4w==", + "dev": true, + "requires": { + "glob": "^7.1.3" + } + }, + "ripemd160": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/ripemd160/-/ripemd160-2.0.2.tgz", + "integrity": "sha512-ii4iagi25WusVoiC4B4lq7pbXfAp3D9v5CwfkY33vffw2+pkDjY1D8GaN7spsxvCSx8dkPqOZCEZyfxcmJG2IA==", + "dev": true, + "requires": { + "hash-base": "^3.0.0", + "inherits": "^2.0.1" + } + }, + "rlp": { + "version": "2.2.7", + "resolved": "https://registry.npmjs.org/rlp/-/rlp-2.2.7.tgz", + "integrity": "sha512-d5gdPmgQ0Z+AklL2NVXr/IoSjNZFfTVvQWzL/AM2AOcSzYP2xjlb0AC8YyCLc41MSNf6P6QVtjgPdmVtzb+4lQ==", + "dev": true, + "requires": { + "bn.js": "^5.2.0" + } + }, + "run-parallel": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/run-parallel/-/run-parallel-1.2.0.tgz", + "integrity": "sha512-5l4VyZR86LZ/lDxZTR6jqL8AFE2S0IFLMP26AbjsLVADxHdhB/c0GUsH+y39UfCi3dzz8OlQuPmnaJOMoDHQBA==", + "dev": true, + "peer": true, + "requires": { + "queue-microtask": "^1.2.2" + } + }, + "run-parallel-limit": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/run-parallel-limit/-/run-parallel-limit-1.1.0.tgz", + "integrity": "sha512-jJA7irRNM91jaKc3Hcl1npHsFLOXOoTkPCUL1JEa1R82O2miplXXRaGdjW/KM/98YQWDhJLiSs793CnXfblJUw==", + "dev": true, + "requires": { + "queue-microtask": "^1.2.2" + } + }, + "rustbn.js": { + "version": "0.2.0", + "resolved": "https://registry.npmjs.org/rustbn.js/-/rustbn.js-0.2.0.tgz", + "integrity": "sha512-4VlvkRUuCJvr2J6Y0ImW7NvTCriMi7ErOAqWk1y69vAdoNIzCF3yPmgeNzx+RQTLEDFq5sHfscn1MwHxP9hNfA==", + "dev": true + }, + "safe-array-concat": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/safe-array-concat/-/safe-array-concat-1.0.0.tgz", + "integrity": "sha512-9dVEFruWIsnie89yym+xWTAYASdpw3CJV7Li/6zBewGf9z2i1j31rP6jnY0pHEO4QZh6N0K11bFjWmdR8UGdPQ==", + "dev": true, + "peer": true, + "requires": { + "call-bind": "^1.0.2", + "get-intrinsic": "^1.2.0", + "has-symbols": "^1.0.3", + "isarray": "^2.0.5" + }, + "dependencies": { + "isarray": { + "version": "2.0.5", + "resolved": "https://registry.npmjs.org/isarray/-/isarray-2.0.5.tgz", + "integrity": "sha512-xHjhDr3cNBK0BzdUJSPXZntQUx/mwMS5Rw4A7lPJ90XGAO6ISP/ePDNuo0vhqOZU+UD5JoodwCAAoZQd3FeAKw==", + "dev": true, + "peer": true + } + } + }, + "safe-buffer": { + "version": "5.1.2", + "resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.1.2.tgz", + "integrity": "sha512-Gd2UZBJDkXlY7GbJxfsE8/nvKkUEU1G38c1siN6QP6a9PT9MmHB8GnpscSmMJSoF8LOIrt8ud/wPtojys4G6+g==", + "dev": true + }, + "safe-regex-test": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/safe-regex-test/-/safe-regex-test-1.0.0.tgz", + "integrity": "sha512-JBUUzyOgEwXQY1NuPtvcj/qcBDbDmEvWufhlnXZIm75DEHp+afM1r1ujJpJsV/gSM4t59tpDyPi1sd6ZaPFfsA==", + "dev": true, + "peer": true, + "requires": { + "call-bind": "^1.0.2", + "get-intrinsic": "^1.1.3", + "is-regex": "^1.1.4" + } + }, + "safer-buffer": { + "version": "2.1.2", + "resolved": "https://registry.npmjs.org/safer-buffer/-/safer-buffer-2.1.2.tgz", + "integrity": "sha512-YZo3K82SD7Riyi0E1EQPojLz7kpepnSQI9IyPbHHg1XXXevb5dJI7tpyN2ADxGcQbHG7vcyRHk0cbwqcQriUtg==", + "dev": true + }, + "sc-istanbul": { + "version": "0.4.6", + "resolved": "https://registry.npmjs.org/sc-istanbul/-/sc-istanbul-0.4.6.tgz", + "integrity": "sha512-qJFF/8tW/zJsbyfh/iT/ZM5QNHE3CXxtLJbZsL+CzdJLBsPD7SedJZoUA4d8iAcN2IoMp/Dx80shOOd2x96X/g==", + "dev": true, + "peer": true, + "requires": { + "abbrev": "1.0.x", + "async": "1.x", + "escodegen": "1.8.x", + "esprima": "2.7.x", + "glob": "^5.0.15", + "handlebars": "^4.0.1", + "js-yaml": "3.x", + "mkdirp": "0.5.x", + "nopt": "3.x", + "once": "1.x", + "resolve": "1.1.x", + "supports-color": "^3.1.0", + "which": "^1.1.1", + "wordwrap": "^1.0.0" + }, + "dependencies": { + "argparse": { + "version": "1.0.10", + "resolved": "https://registry.npmjs.org/argparse/-/argparse-1.0.10.tgz", + "integrity": "sha512-o5Roy6tNG4SL/FOkCAN6RzjiakZS25RLYFrcMttJqbdd8BWrnA+fGz57iN5Pb06pvBGvl5gQ0B48dJlslXvoTg==", + "dev": true, + "peer": true, + "requires": { + "sprintf-js": "~1.0.2" + } + }, + "glob": { + "version": "5.0.15", + "resolved": "https://registry.npmjs.org/glob/-/glob-5.0.15.tgz", + "integrity": "sha512-c9IPMazfRITpmAAKi22dK1VKxGDX9ehhqfABDriL/lzO92xcUKEJPQHrVA/2YHSNFB4iFlykVmWvwo48nr3OxA==", + "dev": true, + "peer": true, + "requires": { + "inflight": "^1.0.4", + "inherits": "2", + "minimatch": "2 || 3", + "once": "^1.3.0", + "path-is-absolute": "^1.0.0" + } + }, + "has-flag": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-1.0.0.tgz", + "integrity": "sha512-DyYHfIYwAJmjAjSSPKANxI8bFY9YtFrgkAfinBojQ8YJTOuOuav64tMUJv584SES4xl74PmuaevIyaLESHdTAA==", + "dev": true, + "peer": true + }, + "js-yaml": { + "version": "3.14.1", + "resolved": "https://registry.npmjs.org/js-yaml/-/js-yaml-3.14.1.tgz", + "integrity": "sha512-okMH7OXXJ7YrN9Ok3/SXrnu4iX9yOk+25nqX4imS2npuvTYDmo/QEZoqwZkYaIDk3jVvBOTOIEgEhaLOynBS9g==", + "dev": true, + "peer": true, + "requires": { + "argparse": "^1.0.7", + "esprima": "^4.0.0" + }, + "dependencies": { + "esprima": { + "version": "4.0.1", + "resolved": "https://registry.npmjs.org/esprima/-/esprima-4.0.1.tgz", + "integrity": "sha512-eGuFFw7Upda+g4p+QHvnW0RyTX/SVeJBDM/gCtMARO0cLuT2HcEKnTPvhjV6aGeqrCB/sbNop0Kszm0jsaWU4A==", + "dev": true, + "peer": true + } + } + }, + "resolve": { + "version": "1.1.7", + "resolved": "https://registry.npmjs.org/resolve/-/resolve-1.1.7.tgz", + "integrity": "sha512-9znBF0vBcaSN3W2j7wKvdERPwqTxSpCq+if5C0WoTCyV9n24rua28jeuQ2pL/HOf+yUe/Mef+H/5p60K0Id3bg==", + "dev": true, + "peer": true + }, + "supports-color": { + "version": "3.2.3", + "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-3.2.3.tgz", + "integrity": "sha512-Jds2VIYDrlp5ui7t8abHN2bjAu4LV/q4N2KivFPpGH0lrka0BMq/33AmECUXlKPcHigkNaqfXRENFju+rlcy+A==", + "dev": true, + "peer": true, + "requires": { + "has-flag": "^1.0.0" + } + } + } + }, + "scrypt-js": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/scrypt-js/-/scrypt-js-3.0.1.tgz", + "integrity": "sha512-cdwTTnqPu0Hyvf5in5asVdZocVDTNRmR7XEcJuIzMjJeSHybHl7vpB66AzwTaIg6CLSbtjcxc8fqcySfnTkccA==", + "dev": true + }, + "secp256k1": { + "version": "4.0.3", + "resolved": "https://registry.npmjs.org/secp256k1/-/secp256k1-4.0.3.tgz", + "integrity": "sha512-NLZVf+ROMxwtEj3Xa562qgv2BK5e2WNmXPiOdVIPLgs6lyTzMvBq0aWTYMI5XCP9jZMVKOcqZLw/Wc4vDkuxhA==", + "dev": true, + "requires": { + "elliptic": "^6.5.4", + "node-addon-api": "^2.0.0", + "node-gyp-build": "^4.2.0" + } + }, + "semver": { + "version": "6.3.0", + "resolved": "https://registry.npmjs.org/semver/-/semver-6.3.0.tgz", + "integrity": "sha512-b39TBaTSfV6yBrapU89p5fKekE2m/NwnDocOVruQFS1/veMgdzuPcnOM34M6CwxW8jH/lxEa5rBoDeUwu5HHTw==", + "dev": true + }, + "serialize-javascript": { + "version": "6.0.0", + "resolved": "https://registry.npmjs.org/serialize-javascript/-/serialize-javascript-6.0.0.tgz", + "integrity": "sha512-Qr3TosvguFt8ePWqsvRfrKyQXIiW+nGbYpy8XK24NQHE83caxWt+mIymTT19DGFbNWNLfEwsrkSmN64lVWB9ag==", + "dev": true, + "requires": { + "randombytes": "^2.1.0" + } + }, + "set-blocking": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/set-blocking/-/set-blocking-2.0.0.tgz", + "integrity": "sha512-KiKBS8AnWGEyLzofFfmvKwpdPzqiy16LvQfK3yv/fVH7Bj13/wl3JSR1J+rfgRE9q7xUJK4qvgS8raSOeLUehw==", + "dev": true, + "peer": true + }, + "setimmediate": { + "version": "1.0.5", + "resolved": "https://registry.npmjs.org/setimmediate/-/setimmediate-1.0.5.tgz", + "integrity": "sha512-MATJdZp8sLqDl/68LfQmbP8zKPLQNV6BIZoIgrscFDQ+RsvK/BxeDQOgyxKKoh0y/8h3BqVFnCqQ/gd+reiIXA==", + "dev": true + }, + "setprototypeof": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/setprototypeof/-/setprototypeof-1.2.0.tgz", + "integrity": "sha512-E5LDX7Wrp85Kil5bhZv46j8jOeboKq5JMmYM3gVGdGH8xFpPWXUMsNrlODCrkoxMEeNi/XZIwuRvY4XNwYMJpw==", + "dev": true + }, + "sha.js": { + "version": "2.4.11", + "resolved": "https://registry.npmjs.org/sha.js/-/sha.js-2.4.11.tgz", + "integrity": "sha512-QMEp5B7cftE7APOjk5Y6xgrbWu+WkLVQwk8JNjZ8nKRciZaByEW6MubieAiToS7+dwvrjGhH8jRXz3MVd0AYqQ==", + "dev": true, + "requires": { + "inherits": "^2.0.1", + "safe-buffer": "^5.0.1" + } + }, + "sha1": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/sha1/-/sha1-1.1.1.tgz", + "integrity": "sha512-dZBS6OrMjtgVkopB1Gmo4RQCDKiZsqcpAQpkV/aaj+FCrCg8r4I4qMkDPQjBgLIxlmu9k4nUbWq6ohXahOneYA==", + "dev": true, + "peer": true, + "requires": { + "charenc": ">= 0.0.1", + "crypt": ">= 0.0.1" + } + }, + "shelljs": { + "version": "0.8.5", + "resolved": "https://registry.npmjs.org/shelljs/-/shelljs-0.8.5.tgz", + "integrity": "sha512-TiwcRcrkhHvbrZbnRcFYMLl30Dfov3HKqzp5tO5b4pt6G/SezKcYhmDg15zXVBswHmctSAQKznqNW2LO5tTDow==", + "dev": true, + "peer": true, + "requires": { + "glob": "^7.0.0", + "interpret": "^1.0.0", + "rechoir": "^0.6.2" + } + }, + "side-channel": { + "version": "1.0.4", + "resolved": "https://registry.npmjs.org/side-channel/-/side-channel-1.0.4.tgz", + "integrity": "sha512-q5XPytqFEIKHkGdiMIrY10mvLRvnQh42/+GoBlFW3b2LXLE2xxJpZFdm94we0BaoV3RwJyGqg5wS7epxTv0Zvw==", + "dev": true, + "requires": { + "call-bind": "^1.0.0", + "get-intrinsic": "^1.0.2", + "object-inspect": "^1.9.0" + } + }, + "slash": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/slash/-/slash-3.0.0.tgz", + "integrity": "sha512-g9Q1haeby36OSStwb4ntCGGGaKsaVSjQ68fBxoQcutl5fS1vuY18H3wSt3jFyFtrkx+Kz0V1G85A4MyAdDMi2Q==", + "dev": true, + "peer": true + }, + "slice-ansi": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/slice-ansi/-/slice-ansi-4.0.0.tgz", + "integrity": "sha512-qMCMfhY040cVHT43K9BFygqYbUPFZKHOg7K73mtTWJRb8pyP3fzf4Ixd5SzdEJQ6MRUg/WBnOLxghZtKKurENQ==", + "dev": true, + "peer": true, + "requires": { + "ansi-styles": "^4.0.0", + "astral-regex": "^2.0.0", + "is-fullwidth-code-point": "^3.0.0" + }, + "dependencies": { + "ansi-styles": { + "version": "4.3.0", + "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-4.3.0.tgz", + "integrity": "sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==", + "dev": true, + "peer": true, + "requires": { + "color-convert": "^2.0.1" + } + }, + "color-convert": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-2.0.1.tgz", + "integrity": "sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ==", + "dev": true, + "peer": true, + "requires": { + "color-name": "~1.1.4" + } + }, + "color-name": { + "version": "1.1.4", + "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.4.tgz", + "integrity": "sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA==", + "dev": true, + "peer": true + } + } + }, + "solc": { + "version": "0.7.3", + "resolved": "https://registry.npmjs.org/solc/-/solc-0.7.3.tgz", + "integrity": "sha512-GAsWNAjGzIDg7VxzP6mPjdurby3IkGCjQcM8GFYZT6RyaoUZKmMU6Y7YwG+tFGhv7dwZ8rmR4iwFDrrD99JwqA==", + "dev": true, + "requires": { + "command-exists": "^1.2.8", + "commander": "3.0.2", + "follow-redirects": "^1.12.1", + "fs-extra": "^0.30.0", + "js-sha3": "0.8.0", + "memorystream": "^0.3.1", + "require-from-string": "^2.0.0", + "semver": "^5.5.0", + "tmp": "0.0.33" + }, + "dependencies": { + "fs-extra": { + "version": "0.30.0", + "resolved": "https://registry.npmjs.org/fs-extra/-/fs-extra-0.30.0.tgz", + "integrity": "sha512-UvSPKyhMn6LEd/WpUaV9C9t3zATuqoqfWc3QdPhPLb58prN9tqYPlPWi8Krxi44loBoUzlobqZ3+8tGpxxSzwA==", + "dev": true, + "requires": { + "graceful-fs": "^4.1.2", + "jsonfile": "^2.1.0", + "klaw": "^1.0.0", + "path-is-absolute": "^1.0.0", + "rimraf": "^2.2.8" + } + }, + "jsonfile": { + "version": "2.4.0", + "resolved": "https://registry.npmjs.org/jsonfile/-/jsonfile-2.4.0.tgz", + "integrity": "sha512-PKllAqbgLgxHaj8TElYymKCAgrASebJrWpTnEkOaTowt23VKXXN0sUeriJ+eh7y6ufb/CC5ap11pz71/cM0hUw==", + "dev": true, + "requires": { + "graceful-fs": "^4.1.6" + } + }, + "semver": { + "version": "5.7.1", + "resolved": "https://registry.npmjs.org/semver/-/semver-5.7.1.tgz", + "integrity": "sha512-sauaDf/PZdVgrLTNYHRtpXa1iRiKcaebiKQ1BJdpQlWH2lCvexQdX55snPFyK7QzpudqbCI0qXFfOasHdyNDGQ==", + "dev": true + } + } + }, + "solidity-coverage": { + "version": "0.8.2", + "resolved": "https://registry.npmjs.org/solidity-coverage/-/solidity-coverage-0.8.2.tgz", + "integrity": "sha512-cv2bWb7lOXPE9/SSleDO6czkFiMHgP4NXPj+iW9W7iEKLBk7Cj0AGBiNmGX3V1totl9wjPrT0gHmABZKZt65rQ==", + "dev": true, + "peer": true, + "requires": { + "@ethersproject/abi": "^5.0.9", + "@solidity-parser/parser": "^0.14.1", + "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", + "global-modules": "^2.0.0", + "globby": "^10.0.1", + "jsonschema": "^1.2.4", + "lodash": "^4.17.15", + "mocha": "7.1.2", + "node-emoji": "^1.10.0", + "pify": "^4.0.1", + "recursive-readdir": "^2.2.2", + "sc-istanbul": "^0.4.5", + "semver": "^7.3.4", + "shelljs": "^0.8.3", + "web3-utils": "^1.3.6" + }, + "dependencies": { + "ansi-colors": { + "version": "3.2.3", + "resolved": "https://registry.npmjs.org/ansi-colors/-/ansi-colors-3.2.3.tgz", + "integrity": "sha512-LEHHyuhlPY3TmuUYMh2oz89lTShfvgbmzaBcxve9t/9Wuy7Dwf4yoAKcND7KFT1HAQfqZ12qtc+DUrBMeKF9nw==", + "dev": true, + "peer": true + }, + "ansi-regex": { + "version": "4.1.1", + "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-4.1.1.tgz", + "integrity": "sha512-ILlv4k/3f6vfQ4OoP2AGvirOktlQ98ZEL1k9FaQjxa3L1abBgbuTDAdPOpvbGncC0BTVQrl+OM8xZGK6tWXt7g==", + "dev": true, + "peer": true + }, + "argparse": { + "version": "1.0.10", + "resolved": "https://registry.npmjs.org/argparse/-/argparse-1.0.10.tgz", + "integrity": "sha512-o5Roy6tNG4SL/FOkCAN6RzjiakZS25RLYFrcMttJqbdd8BWrnA+fGz57iN5Pb06pvBGvl5gQ0B48dJlslXvoTg==", + "dev": true, + "peer": true, + "requires": { + "sprintf-js": "~1.0.2" + } + }, + "camelcase": { + "version": "5.3.1", + "resolved": "https://registry.npmjs.org/camelcase/-/camelcase-5.3.1.tgz", + "integrity": "sha512-L28STB170nwWS63UjtlEOE3dldQApaJXZkOI1uMFfzf3rRuPegHaHesyee+YxQ+W6SvRDQV6UrdOdRiR153wJg==", + "dev": true, + "peer": true + }, + "chokidar": { + "version": "3.3.0", + "resolved": "https://registry.npmjs.org/chokidar/-/chokidar-3.3.0.tgz", + "integrity": "sha512-dGmKLDdT3Gdl7fBUe8XK+gAtGmzy5Fn0XkkWQuYxGIgWVPPse2CxFA5mtrlD0TOHaHjEUqkWNyP1XdHoJES/4A==", + "dev": true, + "peer": true, + "requires": { + "anymatch": "~3.1.1", + "braces": "~3.0.2", + "fsevents": "~2.1.1", + "glob-parent": "~5.1.0", + "is-binary-path": "~2.1.0", + "is-glob": "~4.0.1", + "normalize-path": "~3.0.0", + "readdirp": "~3.2.0" + } + }, + "cliui": { + "version": "5.0.0", + "resolved": "https://registry.npmjs.org/cliui/-/cliui-5.0.0.tgz", + "integrity": "sha512-PYeGSEmmHM6zvoef2w8TPzlrnNpXIjTipYK780YswmIP9vjxmd6Y2a3CB2Ks6/AU8NHjZugXvo8w3oWM2qnwXA==", + "dev": true, + "peer": true, + "requires": { + "string-width": "^3.1.0", + "strip-ansi": "^5.2.0", + "wrap-ansi": "^5.1.0" + } + }, + "debug": { + "version": "3.2.6", + "resolved": "https://registry.npmjs.org/debug/-/debug-3.2.6.tgz", + "integrity": "sha512-mel+jf7nrtEl5Pn1Qx46zARXKDpBbvzezse7p7LqINmdoIk8PYP5SySaxEmYv6TZ0JyEKA1hsCId6DIhgITtWQ==", + "dev": true, + "peer": true, + "requires": { + "ms": "^2.1.1" + } + }, + "decamelize": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/decamelize/-/decamelize-1.2.0.tgz", + "integrity": "sha512-z2S+W9X73hAUUki+N+9Za2lBlun89zigOyGrsax+KUQ6wKW4ZoWpEYBkGhQjwAjjDCkWxhY0VKEhk8wzY7F5cA==", + "dev": true, + "peer": true + }, + "diff": { + "version": "3.5.0", + "resolved": "https://registry.npmjs.org/diff/-/diff-3.5.0.tgz", + "integrity": "sha512-A46qtFgd+g7pDZinpnwiRJtxbC1hpgf0uzP3iG89scHk0AUC7A1TGxf5OiiOUv/JMZR8GOt8hL900hV0bOy5xA==", + "dev": true, + "peer": true + }, + "emoji-regex": { + "version": "7.0.3", + "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-7.0.3.tgz", + "integrity": "sha512-CwBLREIQ7LvYFB0WyRvwhq5N5qPhc6PMjD6bYggFlI5YyDgl+0vxq5VHbMOFqLg7hfWzmu8T5Z1QofhmTIhItA==", + "dev": true, + "peer": true + }, + "esprima": { + "version": "4.0.1", + "resolved": "https://registry.npmjs.org/esprima/-/esprima-4.0.1.tgz", + "integrity": "sha512-eGuFFw7Upda+g4p+QHvnW0RyTX/SVeJBDM/gCtMARO0cLuT2HcEKnTPvhjV6aGeqrCB/sbNop0Kszm0jsaWU4A==", + "dev": true, + "peer": true + }, + "find-up": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/find-up/-/find-up-3.0.0.tgz", + "integrity": "sha512-1yD6RmLI1XBfxugvORwlck6f75tYL+iR0jqwsOrOxMZyGYqUuDhJ0l4AXdO1iX/FTs9cBAMEk1gWSEx1kSbylg==", + "dev": true, + "peer": true, + "requires": { + "locate-path": "^3.0.0" + } + }, + "flat": { + "version": "4.1.1", + "resolved": "https://registry.npmjs.org/flat/-/flat-4.1.1.tgz", + "integrity": "sha512-FmTtBsHskrU6FJ2VxCnsDb84wu9zhmO3cUX2kGFb5tuwhfXxGciiT0oRY+cck35QmG+NmGh5eLz6lLCpWTqwpA==", + "dev": true, + "peer": true, + "requires": { + "is-buffer": "~2.0.3" + } + }, + "fs-extra": { + "version": "8.1.0", + "resolved": "https://registry.npmjs.org/fs-extra/-/fs-extra-8.1.0.tgz", + "integrity": "sha512-yhlQgA6mnOJUKOsRUFsgJdQCvkKhcz8tlZG5HBQfReYZy46OwLcY+Zia0mtdHsOo9y/hP+CxMN0TU9QxoOtG4g==", + "dev": true, + "peer": true, + "requires": { + "graceful-fs": "^4.2.0", + "jsonfile": "^4.0.0", + "universalify": "^0.1.0" + } + }, + "fsevents": { + "version": "2.1.3", + "resolved": "https://registry.npmjs.org/fsevents/-/fsevents-2.1.3.tgz", + "integrity": "sha512-Auw9a4AxqWpa9GUfj370BMPzzyncfBABW8Mab7BGWBYDj4Isgq+cDKtx0i6u9jcX9pQDnswsaaOTgTmA5pEjuQ==", + "dev": true, + "optional": true, + "peer": true + }, + "glob": { + "version": "7.1.3", + "resolved": "https://registry.npmjs.org/glob/-/glob-7.1.3.tgz", + "integrity": "sha512-vcfuiIxogLV4DlGBHIUOwI0IbrJ8HWPc4MU7HzviGeNho/UJDfi6B5p3sHeWIQ0KGIU0Jpxi5ZHxemQfLkkAwQ==", + "dev": true, + "peer": true, + "requires": { + "fs.realpath": "^1.0.0", + "inflight": "^1.0.4", + "inherits": "2", + "minimatch": "^3.0.4", + "once": "^1.3.0", + "path-is-absolute": "^1.0.0" + } + }, + "is-fullwidth-code-point": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/is-fullwidth-code-point/-/is-fullwidth-code-point-2.0.0.tgz", + "integrity": "sha512-VHskAKYM8RfSFXwee5t5cbN5PZeq1Wrh6qd5bkyiXIf6UQcN6w/A0eXM9r6t8d+GYOh+o6ZhiEnb88LN/Y8m2w==", + "dev": true, + "peer": true + }, + "js-yaml": { + "version": "3.13.1", + "resolved": "https://registry.npmjs.org/js-yaml/-/js-yaml-3.13.1.tgz", + "integrity": "sha512-YfbcO7jXDdyj0DGxYVSlSeQNHbD7XPWvrVWeVUujrQEoZzWJIRrCPoyk6kL6IAjAG2IolMK4T0hNUe0HOUs5Jw==", + "dev": true, + "peer": true, + "requires": { + "argparse": "^1.0.7", + "esprima": "^4.0.0" + } + }, + "locate-path": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/locate-path/-/locate-path-3.0.0.tgz", + "integrity": "sha512-7AO748wWnIhNqAuaty2ZWHkQHRSNfPVIsPIfwEOWO22AmaoVrWavlOcMR5nzTLNYvp36X220/maaRsrec1G65A==", + "dev": true, + "peer": true, + "requires": { + "p-locate": "^3.0.0", + "path-exists": "^3.0.0" + } + }, + "log-symbols": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/log-symbols/-/log-symbols-3.0.0.tgz", + "integrity": "sha512-dSkNGuI7iG3mfvDzUuYZyvk5dD9ocYCYzNU6CYDE6+Xqd+gwme6Z00NS3dUh8mq/73HaEtT7m6W+yUPtU6BZnQ==", + "dev": true, + "peer": true, + "requires": { + "chalk": "^2.4.2" + } + }, + "lru-cache": { + "version": "6.0.0", + "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-6.0.0.tgz", + "integrity": "sha512-Jo6dJ04CmSjuznwJSS3pUeWmd/H0ffTlkXXgwZi+eq1UCmqQwCh+eLsYOYCwY991i2Fah4h1BEMCx4qThGbsiA==", + "dev": true, + "peer": true, + "requires": { + "yallist": "^4.0.0" + } + }, + "minimatch": { + "version": "3.0.4", + "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.0.4.tgz", + "integrity": "sha512-yJHVQEhyqPLUTgt9B83PXu6W3rx4MvvHvSUvToogpwoGDOUQ+yDrR0HRot+yOCdCO7u4hX3pWft6kWBBcqh0UA==", + "dev": true, + "peer": true, + "requires": { + "brace-expansion": "^1.1.7" + } + }, + "mkdirp": { + "version": "0.5.5", + "resolved": "https://registry.npmjs.org/mkdirp/-/mkdirp-0.5.5.tgz", + "integrity": "sha512-NKmAlESf6jMGym1++R0Ra7wvhV+wFW63FaSOFPwRahvea0gMUcGUhVeAg/0BC0wiv9ih5NYPB1Wn1UEI1/L+xQ==", + "dev": true, + "peer": true, + "requires": { + "minimist": "^1.2.5" + } + }, + "mocha": { + "version": "7.1.2", + "resolved": "https://registry.npmjs.org/mocha/-/mocha-7.1.2.tgz", + "integrity": "sha512-o96kdRKMKI3E8U0bjnfqW4QMk12MwZ4mhdBTf+B5a1q9+aq2HRnj+3ZdJu0B/ZhJeK78MgYuv6L8d/rA5AeBJA==", + "dev": true, + "peer": true, + "requires": { + "ansi-colors": "3.2.3", + "browser-stdout": "1.3.1", + "chokidar": "3.3.0", + "debug": "3.2.6", + "diff": "3.5.0", + "escape-string-regexp": "1.0.5", + "find-up": "3.0.0", + "glob": "7.1.3", + "growl": "1.10.5", + "he": "1.2.0", + "js-yaml": "3.13.1", + "log-symbols": "3.0.0", + "minimatch": "3.0.4", + "mkdirp": "0.5.5", + "ms": "2.1.1", + "node-environment-flags": "1.0.6", + "object.assign": "4.1.0", + "strip-json-comments": "2.0.1", + "supports-color": "6.0.0", + "which": "1.3.1", + "wide-align": "1.1.3", + "yargs": "13.3.2", + "yargs-parser": "13.1.2", + "yargs-unparser": "1.6.0" + } + }, + "ms": { + "version": "2.1.1", + "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.1.tgz", + "integrity": "sha512-tgp+dl5cGk28utYktBsrFqA7HKgrhgPsg6Z/EfhWI4gl1Hwq8B/GmY/0oXZ6nF8hDVesS/FpnYaD/kOWhYQvyg==", + "dev": true, + "peer": true + }, + "p-limit": { + "version": "2.3.0", + "resolved": "https://registry.npmjs.org/p-limit/-/p-limit-2.3.0.tgz", + "integrity": "sha512-//88mFWSJx8lxCzwdAABTJL2MyWB12+eIY7MDL2SqLmAkeKU9qxRvWuSyTjm3FUmpBEMuFfckAIqEaVGUDxb6w==", + "dev": true, + "peer": true, + "requires": { + "p-try": "^2.0.0" + } + }, + "p-locate": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/p-locate/-/p-locate-3.0.0.tgz", + "integrity": "sha512-x+12w/To+4GFfgJhBEpiDcLozRJGegY+Ei7/z0tSLkMmxGZNybVMSfWj9aJn8Z5Fc7dBUNJOOVgPv2H7IwulSQ==", + "dev": true, + "peer": true, + "requires": { + "p-limit": "^2.0.0" + } + }, + "p-try": { + "version": "2.2.0", + "resolved": "https://registry.npmjs.org/p-try/-/p-try-2.2.0.tgz", + "integrity": "sha512-R4nPAVTAU0B9D35/Gk3uJf/7XYbQcyohSKdvAxIRSNghFl4e71hVoGnBNQz9cWaXxO2I10KTC+3jMdvvoKw6dQ==", + "dev": true, + "peer": true + }, + "readdirp": { + "version": "3.2.0", + "resolved": "https://registry.npmjs.org/readdirp/-/readdirp-3.2.0.tgz", + "integrity": "sha512-crk4Qu3pmXwgxdSgGhgA/eXiJAPQiX4GMOZZMXnqKxHX7TaoL+3gQVo/WeuAiogr07DpnfjIMpXXa+PAIvwPGQ==", + "dev": true, + "peer": true, + "requires": { + "picomatch": "^2.0.4" + } + }, + "semver": { + "version": "7.5.0", + "resolved": "https://registry.npmjs.org/semver/-/semver-7.5.0.tgz", + "integrity": "sha512-+XC0AD/R7Q2mPSRuy2Id0+CGTZ98+8f+KvwirxOKIEyid+XSx6HbC63p+O4IndTHuX5Z+JxQ0TghCkO5Cg/2HA==", + "dev": true, + "peer": true, + "requires": { + "lru-cache": "^6.0.0" + } + }, + "string-width": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/string-width/-/string-width-3.1.0.tgz", + "integrity": "sha512-vafcv6KjVZKSgz06oM/H6GDBrAtz8vdhQakGjFIvNrHA6y3HCF1CInLy+QLq8dTJPQ1b+KDUqDFctkdRW44e1w==", + "dev": true, + "peer": true, + "requires": { + "emoji-regex": "^7.0.1", + "is-fullwidth-code-point": "^2.0.0", + "strip-ansi": "^5.1.0" + } + }, + "strip-ansi": { + "version": "5.2.0", + "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-5.2.0.tgz", + "integrity": "sha512-DuRs1gKbBqsMKIZlrffwlug8MHkcnpjs5VPmL1PAh+mA30U0DTotfDZ0d2UUsXpPmPmMMJ6W773MaA3J+lbiWA==", + "dev": true, + "peer": true, + "requires": { + "ansi-regex": "^4.1.0" + } + }, + "strip-json-comments": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/strip-json-comments/-/strip-json-comments-2.0.1.tgz", + "integrity": "sha512-4gB8na07fecVVkOI6Rs4e7T6NOTki5EmL7TUduTs6bu3EdnSycntVJ4re8kgZA+wx9IueI2Y11bfbgwtzuE0KQ==", + "dev": true, + "peer": true + }, + "supports-color": { + "version": "6.0.0", + "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-6.0.0.tgz", + "integrity": "sha512-on9Kwidc1IUQo+bQdhi8+Tijpo0e1SS6RoGo2guUwn5vdaxw8RXOF9Vb2ws+ihWOmh4JnCJOvaziZWP1VABaLg==", + "dev": true, + "peer": true, + "requires": { + "has-flag": "^3.0.0" + } + }, + "wrap-ansi": { + "version": "5.1.0", + "resolved": "https://registry.npmjs.org/wrap-ansi/-/wrap-ansi-5.1.0.tgz", + "integrity": "sha512-QC1/iN/2/RPVJ5jYK8BGttj5z83LmSKmvbvrXPNCLZSEb32KKVDJDl/MOt2N01qU2H/FkzEa9PKto1BqDjtd7Q==", + "dev": true, + "peer": true, + "requires": { + "ansi-styles": "^3.2.0", + "string-width": "^3.0.0", + "strip-ansi": "^5.0.0" + } + }, + "y18n": { + "version": "4.0.3", + "resolved": "https://registry.npmjs.org/y18n/-/y18n-4.0.3.tgz", + "integrity": "sha512-JKhqTOwSrqNA1NY5lSztJ1GrBiUodLMmIZuLiDaMRJ+itFd+ABVE8XBjOvIWL+rSqNDC74LCSFmlb/U4UZ4hJQ==", + "dev": true, + "peer": true + }, + "yallist": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/yallist/-/yallist-4.0.0.tgz", + "integrity": "sha512-3wdGidZyq5PB084XLES5TpOSRA3wjXAlIWMhum2kRcv/41Sn2emQ0dycQW4uZXLejwKvg6EsvbdlVL+FYEct7A==", + "dev": true, + "peer": true + }, + "yargs": { + "version": "13.3.2", + "resolved": "https://registry.npmjs.org/yargs/-/yargs-13.3.2.tgz", + "integrity": "sha512-AX3Zw5iPruN5ie6xGRIDgqkT+ZhnRlZMLMHAs8tg7nRruy2Nb+i5o9bwghAogtM08q1dpr2LVoS8KSTMYpWXUw==", + "dev": true, + "peer": true, + "requires": { + "cliui": "^5.0.0", + "find-up": "^3.0.0", + "get-caller-file": "^2.0.1", + "require-directory": "^2.1.1", + "require-main-filename": "^2.0.0", + "set-blocking": "^2.0.0", + "string-width": "^3.0.0", + "which-module": "^2.0.0", + "y18n": "^4.0.0", + "yargs-parser": "^13.1.2" + } + }, + "yargs-parser": { + "version": "13.1.2", + "resolved": "https://registry.npmjs.org/yargs-parser/-/yargs-parser-13.1.2.tgz", + "integrity": "sha512-3lbsNRf/j+A4QuSZfDRA7HRSfWrzO0YjqTJd5kjAq37Zep1CEgaYmrH9Q3GwPiB9cHyd1Y1UwggGhJGoxipbzg==", + "dev": true, + "peer": true, + "requires": { + "camelcase": "^5.0.0", + "decamelize": "^1.2.0" + } + }, + "yargs-unparser": { + "version": "1.6.0", + "resolved": "https://registry.npmjs.org/yargs-unparser/-/yargs-unparser-1.6.0.tgz", + "integrity": "sha512-W9tKgmSn0DpSatfri0nx52Joq5hVXgeLiqR/5G0sZNDoLZFOr/xjBUDcShCOGNsBnEMNo1KAMBkTej1Hm62HTw==", + "dev": true, + "peer": true, + "requires": { + "flat": "^4.1.0", + "lodash": "^4.17.15", + "yargs": "^13.3.0" + } + } + } + }, + "source-map": { + "version": "0.6.1", + "resolved": "https://registry.npmjs.org/source-map/-/source-map-0.6.1.tgz", + "integrity": "sha512-UjgapumWlbMhkBgzT7Ykc5YXUT46F0iKu8SGXq0bcwP5dz/h0Plj6enJqjz1Zbq2l5WaqYnrVbwWOWMyF3F47g==", + "dev": true + }, + "source-map-support": { + "version": "0.5.21", + "resolved": "https://registry.npmjs.org/source-map-support/-/source-map-support-0.5.21.tgz", + "integrity": "sha512-uBHU3L3czsIyYXKX88fdrGovxdSCoTGDRZ6SYXtSRxLZUzHg5P/66Ht6uoUlHu9EZod+inXhKo3qQgwXUT/y1w==", + "dev": true, + "requires": { + "buffer-from": "^1.0.0", + "source-map": "^0.6.0" + } + }, + "sprintf-js": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/sprintf-js/-/sprintf-js-1.0.3.tgz", + "integrity": "sha512-D9cPgkvLlV3t3IzL0D0YLvGA9Ahk4PcvVwUbN0dSGr1aP0Nrt4AEnTUbuGvquEC0mA64Gqt1fzirlRs5ibXx8g==", + "dev": true, + "peer": true + }, + "sshpk": { + "version": "1.17.0", + "resolved": "https://registry.npmjs.org/sshpk/-/sshpk-1.17.0.tgz", + "integrity": "sha512-/9HIEs1ZXGhSPE8X6Ccm7Nam1z8KcoCqPdI7ecm1N33EzAetWahvQWVqLZtaZQ+IDKX4IyA2o0gBzqIMkAagHQ==", + "dev": true, + "peer": true, + "requires": { + "asn1": "~0.2.3", + "assert-plus": "^1.0.0", + "bcrypt-pbkdf": "^1.0.0", + "dashdash": "^1.12.0", + "ecc-jsbn": "~0.1.1", + "getpass": "^0.1.1", + "jsbn": "~0.1.0", + "safer-buffer": "^2.0.2", + "tweetnacl": "~0.14.0" + }, + "dependencies": { + "tweetnacl": { + "version": "0.14.5", + "resolved": "https://registry.npmjs.org/tweetnacl/-/tweetnacl-0.14.5.tgz", + "integrity": "sha512-KXXFFdAbFXY4geFIwoyNK+f5Z1b7swfXABfL7HXCmoIWMKU3dmS26672A4EeQtDzLKy7SXmfBu51JolvEKwtGA==", + "dev": true, + "peer": true + } + } + }, + "stacktrace-parser": { + "version": "0.1.10", + "resolved": "https://registry.npmjs.org/stacktrace-parser/-/stacktrace-parser-0.1.10.tgz", + "integrity": "sha512-KJP1OCML99+8fhOHxwwzyWrlUuVX5GQ0ZpJTd1DFXhdkrvg1szxfHhawXUZ3g9TkXORQd4/WG68jMlQZ2p8wlg==", + "dev": true, + "requires": { + "type-fest": "^0.7.1" + }, + "dependencies": { + "type-fest": { + "version": "0.7.1", + "resolved": "https://registry.npmjs.org/type-fest/-/type-fest-0.7.1.tgz", + "integrity": "sha512-Ne2YiiGN8bmrmJJEuTWTLJR32nh/JdL1+PSicowtNb0WFpn59GK8/lfD61bVtzguz7b3PBt74nxpv/Pw5po5Rg==", + "dev": true + } + } + }, + "statuses": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/statuses/-/statuses-2.0.1.tgz", + "integrity": "sha512-RwNA9Z/7PrK06rYLIzFMlaF+l73iwpzsqRIFgbMLbTcLD6cOao82TaWefPXQvB2fOC4AjuYSEndS7N/mTCbkdQ==", + "dev": true + }, + "stealthy-require": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/stealthy-require/-/stealthy-require-1.1.1.tgz", + "integrity": "sha512-ZnWpYnYugiOVEY5GkcuJK1io5V8QmNYChG62gSit9pQVGErXtrKuPC55ITaVSukmMta5qpMU7vqLt2Lnni4f/g==", + "dev": true, + "peer": true + }, + "streamsearch": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/streamsearch/-/streamsearch-1.1.0.tgz", + "integrity": "sha512-Mcc5wHehp9aXz1ax6bZUyY5afg9u2rv5cqQI3mRrYkGC8rW2hM02jWuwjtL++LS5qinSyhj2QfLyNsuc+VsExg==", + "dev": true + }, + "string_decoder": { + "version": "1.3.0", + "resolved": "https://registry.npmjs.org/string_decoder/-/string_decoder-1.3.0.tgz", + "integrity": "sha512-hkRX8U1WjJFd8LsDJ2yQ/wWWxaopEsABU1XfkM8A+j0+85JAGppt16cr1Whg6KIbb4okU6Mql6BOj+uup/wKeA==", + "dev": true, + "requires": { + "safe-buffer": "~5.2.0" + }, + "dependencies": { + "safe-buffer": { + "version": "5.2.1", + "resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.2.1.tgz", + "integrity": "sha512-rp3So07KcdmmKbGvgaNxQSJr7bGVSVk5S9Eq1F+ppbRo70+YeaDxkw5Dd8NPN+GD6bjnYm2VuPuCXmpuYvmCXQ==", + "dev": true + } + } + }, + "string-format": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/string-format/-/string-format-2.0.0.tgz", + "integrity": "sha512-bbEs3scLeYNXLecRRuk6uJxdXUSj6le/8rNPHChIJTn2V79aXVTR1EH2OH5zLKKoz0V02fOUKZZcw01pLUShZA==", + "dev": true, + "peer": true + }, + "string-width": { + "version": "4.2.3", + "resolved": "https://registry.npmjs.org/string-width/-/string-width-4.2.3.tgz", + "integrity": "sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g==", + "dev": true, + "requires": { + "emoji-regex": "^8.0.0", + "is-fullwidth-code-point": "^3.0.0", + "strip-ansi": "^6.0.1" + } + }, + "string.prototype.trim": { + "version": "1.2.7", + "resolved": "https://registry.npmjs.org/string.prototype.trim/-/string.prototype.trim-1.2.7.tgz", + "integrity": "sha512-p6TmeT1T3411M8Cgg9wBTMRtY2q9+PNy9EV1i2lIXUN/btt763oIfxwN3RR8VU6wHX8j/1CFy0L+YuThm6bgOg==", + "dev": true, + "peer": true, + "requires": { + "call-bind": "^1.0.2", + "define-properties": "^1.1.4", + "es-abstract": "^1.20.4" + } + }, + "string.prototype.trimend": { + "version": "1.0.6", + "resolved": "https://registry.npmjs.org/string.prototype.trimend/-/string.prototype.trimend-1.0.6.tgz", + "integrity": "sha512-JySq+4mrPf9EsDBEDYMOb/lM7XQLulwg5R/m1r0PXEFqrV0qHvl58sdTilSXtKOflCsK2E8jxf+GKC0T07RWwQ==", + "dev": true, + "peer": true, + "requires": { + "call-bind": "^1.0.2", + "define-properties": "^1.1.4", + "es-abstract": "^1.20.4" + } + }, + "string.prototype.trimstart": { + "version": "1.0.6", + "resolved": "https://registry.npmjs.org/string.prototype.trimstart/-/string.prototype.trimstart-1.0.6.tgz", + "integrity": "sha512-omqjMDaY92pbn5HOX7f9IccLA+U1tA9GvtU4JrodiXFfYB7jPzzHpRzpglLAjtUV6bB557zwClJezTqnAiYnQA==", + "dev": true, + "peer": true, + "requires": { + "call-bind": "^1.0.2", + "define-properties": "^1.1.4", + "es-abstract": "^1.20.4" + } + }, + "strip-ansi": { + "version": "6.0.1", + "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-6.0.1.tgz", + "integrity": "sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A==", + "dev": true, + "requires": { + "ansi-regex": "^5.0.1" + } + }, + "strip-hex-prefix": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/strip-hex-prefix/-/strip-hex-prefix-1.0.0.tgz", + "integrity": "sha512-q8d4ue7JGEiVcypji1bALTos+0pWtyGlivAWyPuTkHzuTCJqrK9sWxYQZUq6Nq3cuyv3bm734IhHvHtGGURU6A==", + "dev": true, + "requires": { + "is-hex-prefixed": "1.0.0" + } + }, + "strip-json-comments": { + "version": "3.1.1", + "resolved": "https://registry.npmjs.org/strip-json-comments/-/strip-json-comments-3.1.1.tgz", + "integrity": "sha512-6fPc+R4ihwqP6N/aIv2f1gMH8lOVtWQHoqC4yK6oSDVVocumAsfCqjkXnqiYMhmMwS/mEHLp7Vehlt3ql6lEig==", + "dev": true + }, + "supports-color": { + "version": "5.5.0", + "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-5.5.0.tgz", + "integrity": "sha512-QjVjwdXIt408MIiAqCX4oUKsgU2EqAGzs2Ppkm4aQYbjm+ZEWEcW4SfFNTr4uMNZma0ey4f5lgLrkB0aX0QMow==", + "dev": true, + "requires": { + "has-flag": "^3.0.0" + } + }, + "sync-request": { + "version": "6.1.0", + "resolved": "https://registry.npmjs.org/sync-request/-/sync-request-6.1.0.tgz", + "integrity": "sha512-8fjNkrNlNCrVc/av+Jn+xxqfCjYaBoHqCsDz6mt030UMxJGr+GSfCV1dQt2gRtlL63+VPidwDVLr7V2OcTSdRw==", + "dev": true, + "peer": true, + "requires": { + "http-response-object": "^3.0.1", + "sync-rpc": "^1.2.1", + "then-request": "^6.0.0" + } + }, + "sync-rpc": { + "version": "1.3.6", + "resolved": "https://registry.npmjs.org/sync-rpc/-/sync-rpc-1.3.6.tgz", + "integrity": "sha512-J8jTXuZzRlvU7HemDgHi3pGnh/rkoqR/OZSjhTyyZrEkkYQbk7Z33AXp37mkPfPpfdOuj7Ex3H/TJM1z48uPQw==", + "dev": true, + "peer": true, + "requires": { + "get-port": "^3.1.0" + } + }, + "table": { + "version": "6.8.1", + "resolved": "https://registry.npmjs.org/table/-/table-6.8.1.tgz", + "integrity": "sha512-Y4X9zqrCftUhMeH2EptSSERdVKt/nEdijTOacGD/97EKjhQ/Qs8RTlEGABSJNNN8lac9kheH+af7yAkEWlgneA==", + "dev": true, + "peer": true, + "requires": { + "ajv": "^8.0.1", + "lodash.truncate": "^4.4.2", + "slice-ansi": "^4.0.0", + "string-width": "^4.2.3", + "strip-ansi": "^6.0.1" + }, + "dependencies": { + "ajv": { + "version": "8.12.0", + "resolved": "https://registry.npmjs.org/ajv/-/ajv-8.12.0.tgz", + "integrity": "sha512-sRu1kpcO9yLtYxBKvqfTeh9KzZEwO3STyX1HT+4CaDzC6HpTGYhIhPIzj9XuKU7KYDwnaeh5hcOwjy1QuJzBPA==", + "dev": true, + "peer": true, + "requires": { + "fast-deep-equal": "^3.1.1", + "json-schema-traverse": "^1.0.0", + "require-from-string": "^2.0.2", + "uri-js": "^4.2.2" + } + }, + "json-schema-traverse": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/json-schema-traverse/-/json-schema-traverse-1.0.0.tgz", + "integrity": "sha512-NM8/P9n3XjXhIZn1lLhkFaACTOURQXjWhV4BA/RnOv8xvgqtqpAX9IO4mRQxSx1Rlo4tqzeqb0sOlruaOy3dug==", + "dev": true, + "peer": true + } + } + }, + "table-layout": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/table-layout/-/table-layout-1.0.2.tgz", + "integrity": "sha512-qd/R7n5rQTRFi+Zf2sk5XVVd9UQl6ZkduPFC3S7WEGJAmetDTjY3qPN50eSKzwuzEyQKy5TN2TiZdkIjos2L6A==", + "dev": true, + "peer": true, + "requires": { + "array-back": "^4.0.1", + "deep-extend": "~0.6.0", + "typical": "^5.2.0", + "wordwrapjs": "^4.0.0" + }, + "dependencies": { + "array-back": { + "version": "4.0.2", + "resolved": "https://registry.npmjs.org/array-back/-/array-back-4.0.2.tgz", + "integrity": "sha512-NbdMezxqf94cnNfWLL7V/im0Ub+Anbb0IoZhvzie8+4HJ4nMQuzHuy49FkGYCJK2yAloZ3meiB6AVMClbrI1vg==", + "dev": true, + "peer": true + }, + "typical": { + "version": "5.2.0", + "resolved": "https://registry.npmjs.org/typical/-/typical-5.2.0.tgz", + "integrity": "sha512-dvdQgNDNJo+8B2uBQoqdb11eUCE1JQXhvjC/CZtgvZseVd5TYMXnq0+vuUemXbd/Se29cTaUuPX3YIc2xgbvIg==", + "dev": true, + "peer": true + } + } + }, + "then-request": { + "version": "6.0.2", + "resolved": "https://registry.npmjs.org/then-request/-/then-request-6.0.2.tgz", + "integrity": "sha512-3ZBiG7JvP3wbDzA9iNY5zJQcHL4jn/0BWtXIkagfz7QgOL/LqjCEOBQuJNZfu0XYnv5JhKh+cDxCPM4ILrqruA==", + "dev": true, + "peer": true, + "requires": { + "@types/concat-stream": "^1.6.0", + "@types/form-data": "0.0.33", + "@types/node": "^8.0.0", + "@types/qs": "^6.2.31", + "caseless": "~0.12.0", + "concat-stream": "^1.6.0", + "form-data": "^2.2.0", + "http-basic": "^8.1.1", + "http-response-object": "^3.0.1", + "promise": "^8.0.0", + "qs": "^6.4.0" + }, + "dependencies": { + "@types/node": { + "version": "8.10.66", + "resolved": "https://registry.npmjs.org/@types/node/-/node-8.10.66.tgz", + "integrity": "sha512-tktOkFUA4kXx2hhhrB8bIFb5TbwzS4uOhKEmwiD+NoiL0qtP2OQ9mFldbgD4dV1djrlBYP6eBuQZiWjuHUpqFw==", + "dev": true, + "peer": true + } + } + }, + "tmp": { + "version": "0.0.33", + "resolved": "https://registry.npmjs.org/tmp/-/tmp-0.0.33.tgz", + "integrity": "sha512-jRCJlojKnZ3addtTOjdIqoRuPEKBvNXcGYqzO6zWZX8KfKEpnGY5jfggJQ3EjKuu8D4bJRr0y+cYJFmYbImXGw==", + "dev": true, + "requires": { + "os-tmpdir": "~1.0.2" + } + }, + "to-regex-range": { + "version": "5.0.1", + "resolved": "https://registry.npmjs.org/to-regex-range/-/to-regex-range-5.0.1.tgz", + "integrity": "sha512-65P7iz6X5yEr1cwcgvQxbbIw7Uk3gOy5dIdtZ4rDveLqhrdJP+Li/Hx6tyK0NEb+2GCyneCMJiGqrADCSNk8sQ==", + "dev": true, + "requires": { + "is-number": "^7.0.0" + } + }, + "toidentifier": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/toidentifier/-/toidentifier-1.0.1.tgz", + "integrity": "sha512-o5sSPKEkg/DIQNmH43V0/uerLrpzVedkUh8tGNvaeXpfpuwjKenlSox/2O/BTlZUtEe+JG7s5YhEz608PlAHRA==", + "dev": true + }, + "tough-cookie": { + "version": "2.5.0", + "resolved": "https://registry.npmjs.org/tough-cookie/-/tough-cookie-2.5.0.tgz", + "integrity": "sha512-nlLsUzgm1kfLXSXfRZMc1KLAugd4hqJHDTvc2hDIwS3mZAfMEuMbc03SujMF+GEcpaX/qboeycw6iO8JwVv2+g==", + "dev": true, + "peer": true, + "requires": { + "psl": "^1.1.28", + "punycode": "^2.1.1" + } + }, + "ts-command-line-args": { + "version": "2.5.0", + "resolved": "https://registry.npmjs.org/ts-command-line-args/-/ts-command-line-args-2.5.0.tgz", + "integrity": "sha512-Ff7Xt04WWCjj/cmPO9eWTJX3qpBZWuPWyQYG1vnxJao+alWWYjwJBc5aYz3h5p5dE08A6AnpkgiCtP/0KXXBYw==", + "dev": true, + "peer": true, + "requires": { + "@morgan-stanley/ts-mocking-bird": "^0.6.2", + "chalk": "^4.1.0", + "command-line-args": "^5.1.1", + "command-line-usage": "^6.1.0", + "string-format": "^2.0.0" + }, + "dependencies": { + "ansi-styles": { + "version": "4.3.0", + "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-4.3.0.tgz", + "integrity": "sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==", + "dev": true, + "peer": true, + "requires": { + "color-convert": "^2.0.1" + } + }, + "chalk": { + "version": "4.1.2", + "resolved": "https://registry.npmjs.org/chalk/-/chalk-4.1.2.tgz", + "integrity": "sha512-oKnbhFyRIXpUuez8iBMmyEa4nbj4IOQyuhc/wy9kY7/WVPcwIO9VA668Pu8RkO7+0G76SLROeyw9CpQ061i4mA==", + "dev": true, + "peer": true, + "requires": { + "ansi-styles": "^4.1.0", + "supports-color": "^7.1.0" + } + }, + "color-convert": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-2.0.1.tgz", + "integrity": "sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ==", + "dev": true, + "peer": true, + "requires": { + "color-name": "~1.1.4" + } + }, + "color-name": { + "version": "1.1.4", + "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.4.tgz", + "integrity": "sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA==", + "dev": true, + "peer": true + }, + "has-flag": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-4.0.0.tgz", + "integrity": "sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ==", + "dev": true, + "peer": true + }, + "supports-color": { + "version": "7.2.0", + "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-7.2.0.tgz", + "integrity": "sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw==", + "dev": true, + "peer": true, + "requires": { + "has-flag": "^4.0.0" + } + } + } + }, + "ts-essentials": { + "version": "7.0.3", + "resolved": "https://registry.npmjs.org/ts-essentials/-/ts-essentials-7.0.3.tgz", + "integrity": "sha512-8+gr5+lqO3G84KdiTSMRLtuyJ+nTBVRKuCrK4lidMPdVeEp0uqC875uE5NMcaA7YYMN7XsNiFQuMvasF8HT/xQ==", + "dev": true, + "peer": true, + "requires": {} + }, + "ts-node": { + "version": "10.9.1", + "resolved": "https://registry.npmjs.org/ts-node/-/ts-node-10.9.1.tgz", + "integrity": "sha512-NtVysVPkxxrwFGUUxGYhfux8k78pQB3JqYBXlLRZgdGUqTO5wU/UyHop5p70iEbGhB7q5KmiZiU0Y3KlJrScEw==", + "dev": true, + "peer": true, + "requires": { + "@cspotcode/source-map-support": "^0.8.0", + "@tsconfig/node10": "^1.0.7", + "@tsconfig/node12": "^1.0.7", + "@tsconfig/node14": "^1.0.0", + "@tsconfig/node16": "^1.0.2", + "acorn": "^8.4.1", + "acorn-walk": "^8.1.1", + "arg": "^4.1.0", + "create-require": "^1.1.0", + "diff": "^4.0.1", + "make-error": "^1.1.1", + "v8-compile-cache-lib": "^3.0.1", + "yn": "3.1.1" + }, + "dependencies": { + "diff": { + "version": "4.0.2", + "resolved": "https://registry.npmjs.org/diff/-/diff-4.0.2.tgz", + "integrity": "sha512-58lmxKSA4BNyLz+HHMUzlOEpg09FV+ev6ZMe3vJihgdxzgcwZ8VoEEPmALCZG9LmqfVoNMMKpttIYTVG6uDY7A==", + "dev": true, + "peer": true + } + } + }, + "tslib": { + "version": "1.14.1", + "resolved": "https://registry.npmjs.org/tslib/-/tslib-1.14.1.tgz", + "integrity": "sha512-Xni35NKzjgMrwevysHTCArtLDpPvye8zV/0E4EyYn43P7/7qvQwPh9BGkHewbMulVntbigmcT7rdX3BNo9wRJg==", + "dev": true + }, + "tsort": { + "version": "0.0.1", + "resolved": "https://registry.npmjs.org/tsort/-/tsort-0.0.1.tgz", + "integrity": "sha512-Tyrf5mxF8Ofs1tNoxA13lFeZ2Zrbd6cKbuH3V+MQ5sb6DtBj5FjrXVsRWT8YvNAQTqNoz66dz1WsbigI22aEnw==", + "dev": true + }, + "tunnel-agent": { + "version": "0.6.0", + "resolved": "https://registry.npmjs.org/tunnel-agent/-/tunnel-agent-0.6.0.tgz", + "integrity": "sha512-McnNiV1l8RYeY8tBgEpuodCC1mLUdbSN+CYBL7kJsJNInOP8UjDDEwdk6Mw60vdLLrr5NHKZhMAOSrR2NZuQ+w==", + "dev": true, + "peer": true, + "requires": { + "safe-buffer": "^5.0.1" + } + }, + "tweetnacl": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/tweetnacl/-/tweetnacl-1.0.3.tgz", + "integrity": "sha512-6rt+RN7aOi1nGMyC4Xa5DdYiukl2UWCbcJft7YhxReBGQD7OAM8Pbxw6YMo4r2diNEA8FEmu32YOn9rhaiE5yw==", + "dev": true + }, + "tweetnacl-util": { + "version": "0.15.1", + "resolved": "https://registry.npmjs.org/tweetnacl-util/-/tweetnacl-util-0.15.1.tgz", + "integrity": "sha512-RKJBIj8lySrShN4w6i/BonWp2Z/uxwC3h4y7xsRrpP59ZboCd0GpEVsOnMDYLMmKBpYhb5TgHzZXy7wTfYFBRw==", + "dev": true + }, + "type-check": { + "version": "0.3.2", + "resolved": "https://registry.npmjs.org/type-check/-/type-check-0.3.2.tgz", + "integrity": "sha512-ZCmOJdvOWDBYJlzAoFkC+Q0+bUyEOS1ltgp1MGU03fqHG+dbi9tBFU2Rd9QKiDZFAYrhPh2JUf7rZRIuHRKtOg==", + "dev": true, + "peer": true, + "requires": { + "prelude-ls": "~1.1.2" + } + }, + "type-detect": { + "version": "4.0.8", + "resolved": "https://registry.npmjs.org/type-detect/-/type-detect-4.0.8.tgz", + "integrity": "sha512-0fr/mIH1dlO+x7TlcMy+bIDqKPsw/70tVyeHW787goQjhmqaZe10uwLujubK9q9Lg6Fiho1KUKDYz0Z7k7g5/g==", + "dev": true, + "peer": true + }, + "type-fest": { + "version": "0.21.3", + "resolved": "https://registry.npmjs.org/type-fest/-/type-fest-0.21.3.tgz", + "integrity": "sha512-t0rzBq87m3fVcduHDUFhKmyyX+9eo6WQjZvf51Ea/M0Q7+T374Jp1aUiyUl0GKxp8M/OETVHSDvmkyPgvX+X2w==", + "dev": true + }, + "typechain": { + "version": "8.1.1", + "resolved": "https://registry.npmjs.org/typechain/-/typechain-8.1.1.tgz", + "integrity": "sha512-uF/sUvnXTOVF2FHKhQYnxHk4su4JjZR8vr4mA2mBaRwHTbwh0jIlqARz9XJr1tA0l7afJGvEa1dTSi4zt039LQ==", + "dev": true, + "peer": true, + "requires": { + "@types/prettier": "^2.1.1", + "debug": "^4.3.1", + "fs-extra": "^7.0.0", + "glob": "7.1.7", + "js-sha3": "^0.8.0", + "lodash": "^4.17.15", + "mkdirp": "^1.0.4", + "prettier": "^2.3.1", + "ts-command-line-args": "^2.2.0", + "ts-essentials": "^7.0.1" + }, + "dependencies": { + "glob": { + "version": "7.1.7", + "resolved": "https://registry.npmjs.org/glob/-/glob-7.1.7.tgz", + "integrity": "sha512-OvD9ENzPLbegENnYP5UUfJIirTg4+XwMWGaQfQTY0JenxNvvIKP3U3/tAQSPIu/lHxXYSZmpXlUHeqAIdKzBLQ==", + "dev": true, + "peer": true, + "requires": { + "fs.realpath": "^1.0.0", + "inflight": "^1.0.4", + "inherits": "2", + "minimatch": "^3.0.4", + "once": "^1.3.0", + "path-is-absolute": "^1.0.0" + } + }, + "mkdirp": { + "version": "1.0.4", + "resolved": "https://registry.npmjs.org/mkdirp/-/mkdirp-1.0.4.tgz", + "integrity": "sha512-vVqVZQyf3WLx2Shd0qJ9xuvqgAyKPLAiqITEtqW0oIUjzo3PePDd6fW9iFz30ef7Ysp/oiWqbhszeGWW2T6Gzw==", + "dev": true, + "peer": true + } + } + }, + "typed-array-length": { + "version": "1.0.4", + "resolved": "https://registry.npmjs.org/typed-array-length/-/typed-array-length-1.0.4.tgz", + "integrity": "sha512-KjZypGq+I/H7HI5HlOoGHkWUUGq+Q0TPhQurLbyrVrvnKTBgzLhIJ7j6J/XTQOi0d1RjyZ0wdas8bKs2p0x3Ng==", + "dev": true, + "peer": true, + "requires": { + "call-bind": "^1.0.2", + "for-each": "^0.3.3", + "is-typed-array": "^1.1.9" + } + }, + "typedarray": { + "version": "0.0.6", + "resolved": "https://registry.npmjs.org/typedarray/-/typedarray-0.0.6.tgz", + "integrity": "sha512-/aCDEGatGvZ2BIk+HmLf4ifCJFwvKFNb9/JeZPMulfgFracn9QFcAf5GO8B/mweUjSoblS5In0cWhqpfs/5PQA==", + "dev": true, + "peer": true + }, + "typescript": { + "version": "5.0.4", + "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.0.4.tgz", + "integrity": "sha512-cW9T5W9xY37cc+jfEnaUvX91foxtHkza3Nw3wkoF4sSlKn0MONdkdEndig/qPBWXNkmplh3NzayQzCiHM4/hqw==", + "dev": true, + "peer": true + }, + "typical": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/typical/-/typical-4.0.0.tgz", + "integrity": "sha512-VAH4IvQ7BDFYglMd7BPRDfLgxZZX4O4TFcRDA6EN5X7erNJJq+McIEp8np9aVtxrCJ6qx4GTYVfOWNjcqwZgRw==", + "dev": true, + "peer": true + }, + "uglify-js": { + "version": "3.17.4", + "resolved": "https://registry.npmjs.org/uglify-js/-/uglify-js-3.17.4.tgz", + "integrity": "sha512-T9q82TJI9e/C1TAxYvfb16xO120tMVFZrGA3f9/P4424DNu6ypK103y0GPFVa17yotwSyZW5iYXgjYHkGrJW/g==", + "dev": true, + "optional": true, + "peer": true + }, + "unbox-primitive": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/unbox-primitive/-/unbox-primitive-1.0.2.tgz", + "integrity": "sha512-61pPlCD9h51VoreyJ0BReideM3MDKMKnh6+V9L08331ipq6Q8OFXZYiqP6n/tbHx4s5I9uRhcye6BrbkizkBDw==", + "dev": true, + "peer": true, + "requires": { + "call-bind": "^1.0.2", + "has-bigints": "^1.0.2", + "has-symbols": "^1.0.3", + "which-boxed-primitive": "^1.0.2" + } + }, + "undici": { + "version": "5.22.0", + "resolved": "https://registry.npmjs.org/undici/-/undici-5.22.0.tgz", + "integrity": "sha512-fR9RXCc+6Dxav4P9VV/sp5w3eFiSdOjJYsbtWfd4s5L5C4ogyuVpdKIVHeW0vV1MloM65/f7W45nR9ZxwVdyiA==", + "dev": true, + "requires": { + "busboy": "^1.6.0" + } + }, + "universalify": { + "version": "0.1.2", + "resolved": "https://registry.npmjs.org/universalify/-/universalify-0.1.2.tgz", + "integrity": "sha512-rBJeI5CXAlmy1pV+617WB9J63U6XcazHHF2f2dbJix4XzpUF0RS3Zbj0FGIOCAva5P/d/GBOYaACQ1w+0azUkg==", + "dev": true + }, + "unpipe": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/unpipe/-/unpipe-1.0.0.tgz", + "integrity": "sha512-pjy2bYhSsufwWlKwPc+l3cN7+wuJlK6uz0YdJEOlQDbl6jo/YlPi4mb8agUkVC8BF7V8NuzeyPNqRksA3hztKQ==", + "dev": true + }, + "uri-js": { + "version": "4.4.1", + "resolved": "https://registry.npmjs.org/uri-js/-/uri-js-4.4.1.tgz", + "integrity": "sha512-7rKUyy33Q1yc98pQ1DAmLtwX109F7TIfWlW1Ydo8Wl1ii1SeHieeh0HHfPeL2fMXK6z0s8ecKs9frCuLJvndBg==", + "dev": true, + "peer": true, + "requires": { + "punycode": "^2.1.0" + } + }, + "utf8": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/utf8/-/utf8-3.0.0.tgz", + "integrity": "sha512-E8VjFIQ/TyQgp+TZfS6l8yp/xWppSAHzidGiRrqe4bK4XP9pTRyKFgGJpO3SN7zdX4DeomTrwaseCHovfpFcqQ==", + "dev": true, + "peer": true + }, + "util-deprecate": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/util-deprecate/-/util-deprecate-1.0.2.tgz", + "integrity": "sha512-EPD5q1uXyFxJpCrLnCc1nHnq3gOa6DZBocAIiI2TaSCA7VCJ1UJDMagCzIkXNsUYfD1daK//LTEQ8xiIbrHtcw==", + "dev": true + }, + "uuid": { + "version": "8.3.2", + "resolved": "https://registry.npmjs.org/uuid/-/uuid-8.3.2.tgz", + "integrity": "sha512-+NYs2QeMWy+GWFOEm9xnn6HCDp0l7QBD7ml8zLUmJ+93Q5NF0NocErnwkTkXVFNiX3/fpC6afS8Dhb/gz7R7eg==", + "dev": true + }, + "v8-compile-cache-lib": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/v8-compile-cache-lib/-/v8-compile-cache-lib-3.0.1.tgz", + "integrity": "sha512-wa7YjyUGfNZngI/vtK0UHAN+lgDCxBPCylVXGp0zu59Fz5aiGtNXaq3DhIov063MorB+VfufLh3JlF2KdTK3xg==", + "dev": true, + "peer": true + }, + "verror": { + "version": "1.10.0", + "resolved": "https://registry.npmjs.org/verror/-/verror-1.10.0.tgz", + "integrity": "sha512-ZZKSmDAEFOijERBLkmYfJ+vmk3w+7hOLYDNkRCuRuMJGEmqYNCNLyBBFwWKVMhfwaEF3WOd0Zlw86U/WC/+nYw==", + "dev": true, + "peer": true, + "requires": { + "assert-plus": "^1.0.0", + "core-util-is": "1.0.2", + "extsprintf": "^1.2.0" + } + }, + "web3-utils": { + "version": "1.9.0", + "resolved": "https://registry.npmjs.org/web3-utils/-/web3-utils-1.9.0.tgz", + "integrity": "sha512-p++69rCNNfu2jM9n5+VD/g26l+qkEOQ1m6cfRQCbH8ZRrtquTmrirJMgTmyOoax5a5XRYOuws14aypCOs51pdQ==", + "dev": true, + "peer": true, + "requires": { + "bn.js": "^5.2.1", + "ethereum-bloom-filters": "^1.0.6", + "ethereumjs-util": "^7.1.0", + "ethjs-unit": "0.1.6", + "number-to-bn": "1.7.0", + "randombytes": "^2.1.0", + "utf8": "3.0.0" + }, + "dependencies": { + "ethereum-cryptography": { + "version": "0.1.3", + "resolved": "https://registry.npmjs.org/ethereum-cryptography/-/ethereum-cryptography-0.1.3.tgz", + "integrity": "sha512-w8/4x1SGGzc+tO97TASLja6SLd3fRIK2tLVcV2Gx4IB21hE19atll5Cq9o3d0ZmAYC/8aw0ipieTSiekAea4SQ==", + "dev": true, + "peer": true, + "requires": { + "@types/pbkdf2": "^3.0.0", + "@types/secp256k1": "^4.0.1", + "blakejs": "^1.1.0", + "browserify-aes": "^1.2.0", + "bs58check": "^2.1.2", + "create-hash": "^1.2.0", + "create-hmac": "^1.1.7", + "hash.js": "^1.1.7", + "keccak": "^3.0.0", + "pbkdf2": "^3.0.17", + "randombytes": "^2.1.0", + "safe-buffer": "^5.1.2", + "scrypt-js": "^3.0.0", + "secp256k1": "^4.0.1", + "setimmediate": "^1.0.5" + } + }, + "ethereumjs-util": { + "version": "7.1.5", + "resolved": "https://registry.npmjs.org/ethereumjs-util/-/ethereumjs-util-7.1.5.tgz", + "integrity": "sha512-SDl5kKrQAudFBUe5OJM9Ac6WmMyYmXX/6sTmLZ3ffG2eY6ZIGBes3pEDxNN6V72WyOw4CPD5RomKdsa8DAAwLg==", + "dev": true, + "peer": true, + "requires": { + "@types/bn.js": "^5.1.0", + "bn.js": "^5.1.2", + "create-hash": "^1.1.2", + "ethereum-cryptography": "^0.1.3", + "rlp": "^2.2.4" + } + } + } + }, + "which": { + "version": "1.3.1", + "resolved": "https://registry.npmjs.org/which/-/which-1.3.1.tgz", + "integrity": "sha512-HxJdYWq1MTIQbJ3nw0cqssHoTNU267KlrDuGZ1WYlxDStUtKUhOaJmh112/TZmHxxUfuJqPXSOm7tDyas0OSIQ==", + "dev": true, + "peer": true, + "requires": { + "isexe": "^2.0.0" + } + }, + "which-boxed-primitive": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/which-boxed-primitive/-/which-boxed-primitive-1.0.2.tgz", + "integrity": "sha512-bwZdv0AKLpplFY2KZRX6TvyuN7ojjr7lwkg6ml0roIy9YeuSr7JS372qlNW18UQYzgYK9ziGcerWqZOmEn9VNg==", + "dev": true, + "peer": true, + "requires": { + "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" + } + }, + "which-module": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/which-module/-/which-module-2.0.1.tgz", + "integrity": "sha512-iBdZ57RDvnOR9AGBhML2vFZf7h8vmBjhoaZqODJBFWHVtKkDmKuHai3cx5PgVMrX5YDNp27AofYbAwctSS+vhQ==", + "dev": true, + "peer": true + }, + "which-typed-array": { + "version": "1.1.9", + "resolved": "https://registry.npmjs.org/which-typed-array/-/which-typed-array-1.1.9.tgz", + "integrity": "sha512-w9c4xkx6mPidwp7180ckYWfMmvxpjlZuIudNtDf4N/tTAUB8VJbX25qZoAsrtGuYNnGw3pa0AXgbGKRB8/EceA==", + "dev": true, + "peer": true, + "requires": { + "available-typed-arrays": "^1.0.5", + "call-bind": "^1.0.2", + "for-each": "^0.3.3", + "gopd": "^1.0.1", + "has-tostringtag": "^1.0.0", + "is-typed-array": "^1.1.10" + } + }, + "wide-align": { + "version": "1.1.3", + "resolved": "https://registry.npmjs.org/wide-align/-/wide-align-1.1.3.tgz", + "integrity": "sha512-QGkOQc8XL6Bt5PwnsExKBPuMKBxnGxWWW3fU55Xt4feHozMUhdUMaBCk290qpm/wG5u/RSKzwdAC4i51YigihA==", + "dev": true, + "peer": true, + "requires": { + "string-width": "^1.0.2 || 2" + }, + "dependencies": { + "ansi-regex": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-3.0.1.tgz", + "integrity": "sha512-+O9Jct8wf++lXxxFc4hc8LsjaSq0HFzzL7cVsw8pRDIPdjKD2mT4ytDZlLuSBZ4cLKZFXIrMGO7DbQCtMJJMKw==", + "dev": true, + "peer": true + }, + "is-fullwidth-code-point": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/is-fullwidth-code-point/-/is-fullwidth-code-point-2.0.0.tgz", + "integrity": "sha512-VHskAKYM8RfSFXwee5t5cbN5PZeq1Wrh6qd5bkyiXIf6UQcN6w/A0eXM9r6t8d+GYOh+o6ZhiEnb88LN/Y8m2w==", + "dev": true, + "peer": true + }, + "string-width": { + "version": "2.1.1", + "resolved": "https://registry.npmjs.org/string-width/-/string-width-2.1.1.tgz", + "integrity": "sha512-nOqH59deCq9SRHlxq1Aw85Jnt4w6KvLKqWVik6oA9ZklXLNIOlqg4F2yrT1MVaTjAqvVwdfeZ7w7aCvJD7ugkw==", + "dev": true, + "peer": true, + "requires": { + "is-fullwidth-code-point": "^2.0.0", + "strip-ansi": "^4.0.0" + } + }, + "strip-ansi": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-4.0.0.tgz", + "integrity": "sha512-4XaJ2zQdCzROZDivEVIDPkcQn8LMFSa8kj8Gxb/Lnwzv9A8VctNZ+lfivC/sV3ivW8ElJTERXZoPBRrZKkNKow==", + "dev": true, + "peer": true, + "requires": { + "ansi-regex": "^3.0.0" + } + } + } + }, + "word-wrap": { + "version": "1.2.3", + "resolved": "https://registry.npmjs.org/word-wrap/-/word-wrap-1.2.3.tgz", + "integrity": "sha512-Hz/mrNwitNRh/HUAtM/VT/5VH+ygD6DV7mYKZAtHOrbs8U7lvPS6xf7EJKMF0uW1KJCl0H701g3ZGus+muE5vQ==", + "dev": true, + "peer": true + }, + "wordwrap": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/wordwrap/-/wordwrap-1.0.0.tgz", + "integrity": "sha512-gvVzJFlPycKc5dZN4yPkP8w7Dc37BtP1yczEneOb4uq34pXZcvrtRTmWV8W+Ume+XCxKgbjM+nevkyFPMybd4Q==", + "dev": true, + "peer": true + }, + "wordwrapjs": { + "version": "4.0.1", + "resolved": "https://registry.npmjs.org/wordwrapjs/-/wordwrapjs-4.0.1.tgz", + "integrity": "sha512-kKlNACbvHrkpIw6oPeYDSmdCTu2hdMHoyXLTcUKala++lx5Y+wjJ/e474Jqv5abnVmwxw08DiTuHmw69lJGksA==", + "dev": true, + "peer": true, + "requires": { + "reduce-flatten": "^2.0.0", + "typical": "^5.2.0" + }, + "dependencies": { + "typical": { + "version": "5.2.0", + "resolved": "https://registry.npmjs.org/typical/-/typical-5.2.0.tgz", + "integrity": "sha512-dvdQgNDNJo+8B2uBQoqdb11eUCE1JQXhvjC/CZtgvZseVd5TYMXnq0+vuUemXbd/Se29cTaUuPX3YIc2xgbvIg==", + "dev": true, + "peer": true + } + } + }, + "workerpool": { + "version": "6.2.1", + "resolved": "https://registry.npmjs.org/workerpool/-/workerpool-6.2.1.tgz", + "integrity": "sha512-ILEIE97kDZvF9Wb9f6h5aXK4swSlKGUcOEGiIYb2OOu/IrDU9iwj0fD//SsA6E5ibwJxpEvhullJY4Sl4GcpAw==", + "dev": true + }, + "wrap-ansi": { + "version": "7.0.0", + "resolved": "https://registry.npmjs.org/wrap-ansi/-/wrap-ansi-7.0.0.tgz", + "integrity": "sha512-YVGIj2kamLSTxw6NsZjoBxfSwsn0ycdesmc4p+Q21c5zPuZ1pl+NfxVdxPtdHvmNVOQ6XSYG4AUtyt/Fi7D16Q==", + "dev": true, + "requires": { + "ansi-styles": "^4.0.0", + "string-width": "^4.1.0", + "strip-ansi": "^6.0.0" + }, + "dependencies": { + "ansi-styles": { + "version": "4.3.0", + "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-4.3.0.tgz", + "integrity": "sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==", + "dev": true, + "requires": { + "color-convert": "^2.0.1" + } + }, + "color-convert": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-2.0.1.tgz", + "integrity": "sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ==", + "dev": true, + "requires": { + "color-name": "~1.1.4" + } + }, + "color-name": { + "version": "1.1.4", + "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.4.tgz", + "integrity": "sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA==", + "dev": true + } + } + }, + "wrappy": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/wrappy/-/wrappy-1.0.2.tgz", + "integrity": "sha512-l4Sp/DRseor9wL6EvV2+TuQn63dMkPjZ/sp9XkghTEbV9KlPS1xUsZ3u7/IQO4wxtcFB4bgpQPRcR3QCvezPcQ==", + "dev": true + }, + "ws": { + "version": "7.5.9", + "resolved": "https://registry.npmjs.org/ws/-/ws-7.5.9.tgz", + "integrity": "sha512-F+P9Jil7UiSKSkppIiD94dN07AwvFixvLIj1Og1Rl9GGMuNipJnV9JzjD6XuqmAeiswGvUmNLjr5cFuXwNS77Q==", + "dev": true, + "requires": {} + }, + "xmlhttprequest": { + "version": "1.8.0", + "resolved": "https://registry.npmjs.org/xmlhttprequest/-/xmlhttprequest-1.8.0.tgz", + "integrity": "sha512-58Im/U0mlVBLM38NdZjHyhuMtCqa61469k2YP/AaPbvCoV9aQGUpbJBj1QRm2ytRiVQBD/fsw7L2bJGDVQswBA==", + "dev": true, + "peer": true + }, + "y18n": { + "version": "5.0.8", + "resolved": "https://registry.npmjs.org/y18n/-/y18n-5.0.8.tgz", + "integrity": "sha512-0pfFzegeDWJHJIAmTLRP2DwHjdF5s7jo9tuztdQxAhINCdvS+3nGINqPd00AphqJR/0LhANUS6/+7SCb98YOfA==", + "dev": true + }, + "yallist": { + "version": "3.1.1", + "resolved": "https://registry.npmjs.org/yallist/-/yallist-3.1.1.tgz", + "integrity": "sha512-a4UGQaWPH59mOXUYnAG2ewncQS4i4F43Tv3JoAM+s2VDAmS9NsK8GpDMLrCHPksFT7h3K6TOoUNn2pb7RoXx4g==", + "dev": true + }, + "yargs": { + "version": "16.2.0", + "resolved": "https://registry.npmjs.org/yargs/-/yargs-16.2.0.tgz", + "integrity": "sha512-D1mvvtDG0L5ft/jGWkLpG1+m0eQxOfaBvTNELraWj22wSVUMWxZUvYgJYcKh6jGGIkJFhH4IZPQhR4TKpc8mBw==", + "dev": true, + "requires": { + "cliui": "^7.0.2", + "escalade": "^3.1.1", + "get-caller-file": "^2.0.5", + "require-directory": "^2.1.1", + "string-width": "^4.2.0", + "y18n": "^5.0.5", + "yargs-parser": "^20.2.2" + } + }, + "yargs-parser": { + "version": "20.2.4", + "resolved": "https://registry.npmjs.org/yargs-parser/-/yargs-parser-20.2.4.tgz", + "integrity": "sha512-WOkpgNhPTlE73h4VFAFsOnomJVaovO8VqLDzy5saChRBFQFBoMYirowyW+Q9HB4HFF4Z7VZTiG3iSzJJA29yRA==", + "dev": true + }, + "yargs-unparser": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/yargs-unparser/-/yargs-unparser-2.0.0.tgz", + "integrity": "sha512-7pRTIA9Qc1caZ0bZ6RYRGbHJthJWuakf+WmHK0rVeLkNrrGhfoabBNdue6kdINI6r4if7ocq9aD/n7xwKOdzOA==", + "dev": true, + "requires": { + "camelcase": "^6.0.0", + "decamelize": "^4.0.0", + "flat": "^5.0.2", + "is-plain-obj": "^2.1.0" + } + }, + "yn": { + "version": "3.1.1", + "resolved": "https://registry.npmjs.org/yn/-/yn-3.1.1.tgz", + "integrity": "sha512-Ux4ygGWsu2c7isFWe8Yu1YluJmqVhxqK2cLXNQA5AcC3QfbGNpM7fu0Y8b/z16pXLnFxZYvWhd3fhBY9DLmC6Q==", + "dev": true, + "peer": true + }, + "yocto-queue": { + "version": "0.1.0", + "resolved": "https://registry.npmjs.org/yocto-queue/-/yocto-queue-0.1.0.tgz", + "integrity": "sha512-rVksvsnNCdJ/ohGc6xgPwyN8eheCxsiLM8mxuE/t/mOVqJewPuO1miLpTHQiRgTKCLexL4MeAFVagts7HmNZ2Q==", + "dev": true + } + } +} diff --git a/assets/eip-7007/package.json b/assets/eip-7007/package.json new file mode 100644 index 00000000000000..0c5b28f233e4fd --- /dev/null +++ b/assets/eip-7007/package.json @@ -0,0 +1,17 @@ +{ + "name": "erc7007", + "version": "1.0.0", + "description": "", + "main": "index.js", + "scripts": { + "test": "echo \"Error: no test specified\" && exit 1" + }, + "keywords": [], + "author": "", + "license": "ISC", + "devDependencies": { + "@nomicfoundation/hardhat-toolbox": "^2.0.2", + "@openzeppelin/contracts": "^4.8.3", + "hardhat": "^2.14.0" + } +} diff --git a/assets/eip-7007/test/test.js b/assets/eip-7007/test/test.js new file mode 100644 index 00000000000000..31777ecb3ec2f6 --- /dev/null +++ b/assets/eip-7007/test/test.js @@ -0,0 +1,90 @@ +const { + time, + loadFixture, +} = require("@nomicfoundation/hardhat-network-helpers"); +const { anyValue } = require("@nomicfoundation/hardhat-chai-matchers/withArgs"); +const { expect } = require("chai"); +const { BigNumber } = require("ethers"); + +async function deployVerifierFixture() { + const Verifier = await ethers.getContractFactory("MockVerifier"); + const verifier = await Verifier.deploy(); + await verifier.deployed(); + return verifier; +} +const prompt = ethers.utils.toUtf8Bytes("test"); +const aigcData = ethers.utils.toUtf8Bytes("test"); +const uri = '"name": "test", "description": "test", "image": "test", "aigc_type": "test"'; +const validProof = ethers.utils.toUtf8Bytes("valid"); +const invalidProof = ethers.utils.toUtf8Bytes("invalid"); +const tokenId = BigNumber.from("70622639689279718371527342103894932928233838121221666359043189029713682937432"); + +describe("ERC7007.sol", function () { + + async function deployERC7007Fixture() { + const verifier = await deployVerifierFixture(); + + const ERC7007 = await ethers.getContractFactory("ERC7007"); + const erc7007 = await ERC7007.deploy("testing", "TEST", verifier.address); + await erc7007.deployed(); + return erc7007; + } + + describe("mint", function () { + it("should mint a token", async function () { + const erc7007 = await deployERC7007Fixture(); + const [owner] = await ethers.getSigners(); + await erc7007.mint(prompt, aigcData, uri, validProof); + expect(await erc7007.balanceOf(owner.address)).to.equal(1); + }); + + it("should not mint a token with invalid proof", async function () { + const erc7007 = await deployERC7007Fixture(); + await expect(erc7007.mint(prompt, aigcData, uri, invalidProof)).to.be.revertedWith("ERC7007: invalid proof"); + }); + + it("should not mint a token with same data twice", async function () { + const erc7007 = await deployERC7007Fixture(); + await erc7007.mint(prompt, aigcData, uri, validProof); + await expect(erc7007.mint(prompt, aigcData, uri, validProof)).to.be.revertedWith("ERC721: token already minted"); + }); + + it("should emit a Mint event", async function () { + const erc7007 = await deployERC7007Fixture(); + await expect(erc7007.mint(prompt, aigcData, uri, validProof)) + .to.emit(erc7007, "Mint") + }); + }); + + describe("metadata", function () { + it("should return token metadata", async function () { + const erc7007 = await deployERC7007Fixture(); + await erc7007.mint(prompt, aigcData, uri, validProof); + expect(await erc7007.tokenURI(tokenId)).to.equal('{"name": "test", "description": "test", "image": "test", "aigc_type": "test", "prompt": "test", "aigc_data": "test"}'); + }); + }); +}); + +describe("ERC7007Enumerable.sol", function () { + + async function deployERC7007EnumerableFixture() { + const verifier = await deployVerifierFixture(); + + const ERC7007Enumerable = await ethers.getContractFactory("MockERC7007Enumerable"); + const erc7007Enumerable = await ERC7007Enumerable.deploy("testing", "TEST", verifier.address); + await erc7007Enumerable.deployed(); + await erc7007Enumerable.mint(prompt, aigcData, uri, validProof); + return erc7007Enumerable; + } + + it("should return token id by prompt", async function () { + const erc7007Enumerable = await deployERC7007EnumerableFixture(); + expect(await erc7007Enumerable.tokenId(prompt)).to.equal(tokenId); + }); + + it("should return token prompt by id", async function () { + const erc7007Enumerable = await deployERC7007EnumerableFixture(); + expect(await erc7007Enumerable.prompt(tokenId)).to.equal("test"); + }); + +}); \ No newline at end of file From 4d6b331ce0ab1b6c6bc499bcaaf2ac0227992f8a Mon Sep 17 00:00:00 2001 From: Michael Sproul Date: Tue, 20 Jun 2023 19:03:09 +1000 Subject: [PATCH 93/97] Update EIP-3076: Conform EIP-3076 to linting policy Merged by EIP-Bot. --- EIPS/eip-3076.md | 19 +++++++------------ 1 file changed, 7 insertions(+), 12 deletions(-) diff --git a/EIPS/eip-3076.md b/EIPS/eip-3076.md index 9023b9d95f0f6a..a0a9f5d320bfca 100644 --- a/EIPS/eip-3076.md +++ b/EIPS/eip-3076.md @@ -3,17 +3,17 @@ eip: 3076 title: Slashing Protection Interchange Format description: A JSON interchange format for proof of stake validators to migrate slashing protection data between clients. author: Michael Sproul (@michaelsproul), Sacha Saint-Leger (@sachayves), Danny Ryan (@djrtwo) -discussions-to: https://ethereum-magicians.org/t/eip-3076-validator-client-interchange-format-slashing-protection/ +discussions-to: https://ethereum-magicians.org/t/eip-3076-validator-client-interchange-format-slashing-protection/4883 status: Last Call +last-call-deadline: 2021-11-03 type: Standards Track category: Interface created: 2020-10-27 -last-call-deadline: 2021-11-03 --- ## Abstract -A standard format for transferring a key's signing history allows validators to easily switch between clients without the risk of signing conflicting messages. While a [common keystore format](https://eips.ethereum.org/EIPS/eip-2335) provides part of the solution, it does not contain any information about a key's signing history. For a validator moving their keys from client A to client B, this could lead to scenarios in which client B inadvertently signs a message that conflicts with an earlier message signed with client A. The interchange format described here provides a solution to this problem. +A standard format for transferring a key's signing history allows validators to easily switch between clients without the risk of signing conflicting messages. While a common keystore format provides part of the solution, it does not contain any information about a key's signing history. For a validator moving their keys from client A to client B, this could lead to scenarios in which client B inadvertently signs a message that conflicts with an earlier message signed with client A. The interchange format described here provides a solution to this problem. ## Motivation @@ -168,11 +168,11 @@ A valid interchange file is one that adheres to the following JSON schema, and i After importing an interchange file with data field `data`, a signer must respect the following conditions: -1. Refuse to sign any block that is slashable with respect to the blocks contained in `data.signed_blocks`. For details of what constitutes a slashable block, see [process_proposer_slashing][pps]. If the `signing_root` is absent from a block, a signer must assume that any new block with the same `slot` is slashable with respect to the imported block. +1. Refuse to sign any block that is slashable with respect to the blocks contained in `data.signed_blocks`. For details of what constitutes a slashable block, see `process_proposer_slashing` (from `consensus-specs`). If the `signing_root` is absent from a block, a signer must assume that any new block with the same `slot` is slashable with respect to the imported block. 2. Refuse to sign any block with `slot <= min(b.slot for b in data.signed_blocks if b.pubkey == proposer_pubkey)`, except if it is a repeat signing as determined by the `signing_root`. -3. Refuse to sign any attestation that is slashable with respect to the attestations contained in `data.signed_attestations`. For details of what constitutes a slashable attestation, see [is_slashable_attestation_data][isad]. +3. Refuse to sign any attestation that is slashable with respect to the attestations contained in `data.signed_attestations`. For details of what constitutes a slashable attestation, see `is_slashable_attestation_data`. 4. Refuse to sign any attestation with source epoch less than the minimum source epoch present in that signer's attestations (as seen in `data.signed_attestations`). In pseudocode: ```python3 source.epoch < @@ -196,14 +196,9 @@ target_epoch <= - A signed block or attestation's `signing_root` refers to the message data (hash tree root) that gets signed with a BLS signature. It allows validators to re-sign and re-broadcast blocks or attestations if asked. -- The `signed_blocks` `signing_root`s are calculated using [`compute_signing_root(block, domain)`][csr]: where `block` is the block (of type `BeaconBlock` or `BeaconBlockHeader`) that was signed, and `domain` is equal to [`compute_domain(DOMAIN_BEACON_PROPOSER, fork, metadata.genesis_validators_root)`][cd]. - -- The `signed_attestations` `signing_root`s are calculated using [`compute_signing_root(attestation, domain)`][csr]: where `attestation` is the attestation (of type `AttestationData`) that was signed, and `domain` is equal to [`compute_domain(DOMAIN_BEACON_ATTESTER, fork, metadata.genesis_validators_root)`][cd]. +- The `signed_blocks` `signing_root`s are calculated using `compute_signing_root(block, domain)`: where `block` is the block (of type `BeaconBlock` or `BeaconBlockHeader`) that was signed, and `domain` is equal to `compute_domain(DOMAIN_BEACON_PROPOSER, fork, metadata.genesis_validators_root)`. -[pps]: https://github.com/ethereum/eth2.0-specs/blob/v1.0.0/specs/phase0/beacon-chain.md#proposer-slashings -[isad]: https://github.com/ethereum/eth2.0-specs/blob/v1.0.0/specs/phase0/beacon-chain.md#is_slashable_attestation_data -[csr]: https://github.com/ethereum/eth2.0-specs/blob/v1.0.0/specs/phase0/beacon-chain.md#compute_signing_root -[cd]: https://github.com/ethereum/eth2.0-specs/blob/v1.0.0/specs/phase0/beacon-chain.md#compute_domain +- The `signed_attestations` `signing_root`s are calculated using `compute_signing_root(attestation, domain)`: where `attestation` is the attestation (of type `AttestationData`) that was signed, and `domain` is equal to `compute_domain(DOMAIN_BEACON_ATTESTER, fork, metadata.genesis_validators_root)`. ## Rationale From 082834fed2556b1eb83729d35c2ecb3c7926f243 Mon Sep 17 00:00:00 2001 From: Manu NALEPA Date: Tue, 20 Jun 2023 14:25:18 +0200 Subject: [PATCH 94/97] Update EIP-3076: Update EIP-3076 - Condition 5 to be consistent with Condition 2, tests and with some current client implementations Merged by EIP-Bot. --- EIPS/eip-3076.md | 17 +++++++++-------- 1 file changed, 9 insertions(+), 8 deletions(-) diff --git a/EIPS/eip-3076.md b/EIPS/eip-3076.md index a0a9f5d320bfca..5040150f07b45a 100644 --- a/EIPS/eip-3076.md +++ b/EIPS/eip-3076.md @@ -21,7 +21,7 @@ The proof of stake (PoS) protocol penalises validators for voting in ways that c For a validator following the protocol correctly, there is, in principle, no risk of being slashed. However, changing clients (from client A to client B, say) can result in a slashing risk if client B is unaware of the blocks and attestations that were signed with client A. -This can can occur if client A and client B do not agree on what the present time is. For example, say client A's time is accidentally set to a day in the future (225 epochs), and a validator switches from client A to client B without giving B a record of the blocks and attestations signed with A. The validator in question now runs the risk of attesting to two different blocks in the same epoch (a slashable offence) for the next 225 epochs (since they've already voted on these epochs with client A, and now stand to vote on them again with client B). Such time-skew bugs have been observed in the wild. +This can occur if client A and client B do not agree on what the present time is. For example, say client A's time is accidentally set to a day in the future (225 epochs), and a validator switches from client A to client B without giving B a record of the blocks and attestations signed with A. The validator in question now runs the risk of attesting to two different blocks in the same epoch (a slashable offence) for the next 225 epochs (since they've already voted on these epochs with client A, and now stand to vote on them again with client B). Such time-skew bugs have been observed in the wild. Another situation in which slashing protection is critical is in the case of re-orgs. During a re-org it is possible for a validator to be assigned new attestation duties for an epoch in which it has already signed an attestation. In this case it is essential that the record of the previous attestation is available, even if the validator just moved from one client to another in the space of a single epoch. @@ -174,6 +174,7 @@ After importing an interchange file with data field `data`, a signer must respec 3. Refuse to sign any attestation that is slashable with respect to the attestations contained in `data.signed_attestations`. For details of what constitutes a slashable attestation, see `is_slashable_attestation_data`. 4. Refuse to sign any attestation with source epoch less than the minimum source epoch present in that signer's attestations (as seen in `data.signed_attestations`). In pseudocode: + ```python3 source.epoch < min(att.source_epoch @@ -181,7 +182,7 @@ source.epoch < if att.pubkey == attester_pubkey) ``` -5. Refuse to sign any attestation with target epoch less than or equal to the minimum target epoch present in that signer's attestations (as seen in `data.signed_attestations`). In pseudocode: +5. Refuse to sign any attestation with target epoch less than or equal to the minimum target epoch present in that signer's attestations (as seen in `data.signed_attestations`), except if it is a repeat signing as determined by the `signing_root`. In pseudocode: ```python3 target_epoch <= @@ -238,20 +239,20 @@ In order to minimise risk and complexity, the format has been designed to map cl For implementers who use a complete record of signed messages to implement their slashing protection database, we make the following recommendations: -* You MUST ensure that, in addition to importing all of the messages from an interchange, all the [conditions](#conditions) are enforced. In particular, conditions (2), (4) and (5) may not have been enforced by your implementation before adopting the interchange format. Our recommendation is to enforce these rules at all times, to keep the implementation clean and minimise the attack surface. For example: your slashing protection mechanism should not sign a block with a slot number less than, or equal to, the minimum slot number of a previously signed block, _irrespective_ of whether that minimum-slot block was imported from an interchange file, or inserted as part of your database's regular operation. -* If your database records the signing roots of messages in addition to their slot/epochs, you should ensure that imported messages without signing roots are assigned a suitable dummy signing root internally. We suggest using a special "null" value which is distinct from all other signing roots, although a value like `0x0` may be used instead (as it is extremely unlikely to collide with any real signing root). -* Care must be taken to avoid signing messages within a gap in the database (an area of unknown signing activity). This could occur if two interchanges were imported with a large gap between the last entry of the first and the first entry of the second. Signing in this gap is not safe, and would violate conditions (2), (4) and (5). It can be avoided by storing an explicit low watermark in addition to the actual messages of the slashing protection database, or by pruning on import so that the oldest messages from the interchange become the oldest messages in the database. +- You MUST ensure that, in addition to importing all of the messages from an interchange, all the [conditions](#conditions) are enforced. In particular, conditions (2), (4) and (5) may not have been enforced by your implementation before adopting the interchange format. Our recommendation is to enforce these rules at all times, to keep the implementation clean and minimise the attack surface. For example: your slashing protection mechanism should not sign a block with a slot number less than, or equal to, the minimum slot number of a previously signed block, _irrespective_ of whether that minimum-slot block was imported from an interchange file, or inserted as part of your database's regular operation. +- If your database records the signing roots of messages in addition to their slot/epochs, you should ensure that imported messages without signing roots are assigned a suitable dummy signing root internally. We suggest using a special "null" value which is distinct from all other signing roots, although a value like `0x0` may be used instead (as it is extremely unlikely to collide with any real signing root). +- Care must be taken to avoid signing messages within a gap in the database (an area of unknown signing activity). This could occur if two interchanges were imported with a large gap between the last entry of the first and the first entry of the second. Signing in this gap is not safe, and would violate conditions (2), (4) and (5). It can be avoided by storing an explicit low watermark in addition to the actual messages of the slashing protection database, or by pruning on import so that the oldest messages from the interchange become the oldest messages in the database. ### Advice for Minimal Databases For implementers who wish to implement their slashing protection database by storing only the latest block and attestation for each validator, we make the following recommendations: -* During import, make sure you take the _maximum_ slot block and _maximum_ source and target attestations for each validator. Although the [conditions](#conditions) require the minimums to be enforced, taking the maximums from an interchange file and merging them with any existing values in the database is the recommended approach. For example, if the interchange file includes blocks for validator `V` at slots 4, 98 and 243, then the latest signed block for validator `V` should be updated to the one from slot 243. However, if the database has already included a block for this validator at a slot greater than 243, for example, slot 351, then the database's existing value should remain unchanged. +- During import, make sure you take the _maximum_ slot block and _maximum_ source and target attestations for each validator. Although the [conditions](#conditions) require the minimums to be enforced, taking the maximums from an interchange file and merging them with any existing values in the database is the recommended approach. For example, if the interchange file includes blocks for validator `V` at slots 4, 98 and 243, then the latest signed block for validator `V` should be updated to the one from slot 243. However, if the database has already included a block for this validator at a slot greater than 243, for example, slot 351, then the database's existing value should remain unchanged. ### General Recommendations -* To avoid exporting an outdated interchange file -- an action which creates a slashing risk -- your implementation should only allow the slashing protection database to be exported when the validator client or signer is _stopped_ -- in other words, when the client or signer is no longer adding new messages to the database. -* Similarly, your implementation should only allow an interchange file to be imported when the validator client is stopped. +- To avoid exporting an outdated interchange file -- an action which creates a slashing risk -- your implementation should only allow the slashing protection database to be exported when the validator client or signer is _stopped_ -- in other words, when the client or signer is no longer adding new messages to the database. +- Similarly, your implementation should only allow an interchange file to be imported when the validator client is stopped. ## Copyright From 87888792986b702bcac127c9e610d5b515bac9b6 Mon Sep 17 00:00:00 2001 From: g11tech Date: Tue, 20 Jun 2023 22:18:41 +0530 Subject: [PATCH 95/97] Update EIP-1: allow multi file commit urls Merged by EIP-Bot. --- EIPS/eip-1.md | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/EIPS/eip-1.md b/EIPS/eip-1.md index ebec1036d1bf5d..e55c0351830a1e 100644 --- a/EIPS/eip-1.md +++ b/EIPS/eip-1.md @@ -213,7 +213,7 @@ Which renders to: Permitted Execution Client Specifications URLs must anchor to a specific commit, and so must match this regular expression: ```regex -^(https://github.com/ethereum/execution-specs/blob/[0-9a-f]{40}/.*|https://github.com/ethereum/execution-specs/tree/[0-9a-f]{40}/.*)$ +^(https://github.com/ethereum/execution-specs/(blob|commit)/[0-9a-f]{40}/.*|https://github.com/ethereum/execution-specs/tree/[0-9a-f]{40}/.*)$ ``` ### Consensus Layer Specifications @@ -231,7 +231,7 @@ Which renders to: Permitted Consensus Layer Specifications URLs must anchor to a specific commit, and so must match this regular expression: ```regex -^https://github.com/ethereum/consensus-specs/blob/[0-9a-f]{40}/.*$ +^https://github.com/ethereum/consensus-specs/(blob|commit)/[0-9a-f]{40}/.*$ ``` ### Networking Specifications @@ -249,7 +249,7 @@ Which renders as: Permitted Networking Specifications URLs must anchor to a specific commit, and so must match this regular expression: ```regex -^https://github.com/ethereum/devp2p/blob/[0-9a-f]{40}/.*$ +^https://github.com/ethereum/devp2p/(blob|commit)/[0-9a-f]{40}/.*$ ``` ### World Wide Web Consortium (W3C) From a2ea76c5859528e90190d93bd0d45a20669dab43 Mon Sep 17 00:00:00 2001 From: Danny Ryan Date: Wed, 21 Jun 2023 11:18:27 -0600 Subject: [PATCH 96/97] Update EIP-7045: minor copy and link updates Merged by EIP-Bot. --- EIPS/eip-7045.md | 14 +++++++++----- 1 file changed, 9 insertions(+), 5 deletions(-) diff --git a/EIPS/eip-7045.md b/EIPS/eip-7045.md index 9f516b163d8ec0..e8fdf043988b04 100644 --- a/EIPS/eip-7045.md +++ b/EIPS/eip-7045.md @@ -1,7 +1,7 @@ --- eip: 7045 title: Increase max attestation inclusion slot -description: Increases max attestaton inclusion slot to the last slot in `N+1` where `N` is the epoch containing the attestations slot. +description: Increases max attestaton inclusion slot to the last slot in `N+1` where `N` is the epoch containing the attestation's slot. author: Danny Ryan (@djrtwo) discussions-to: https://ethereum-magicians.org/t/eip-7045-increase-attestation-slot-inclusion-range/14342 status: Draft @@ -22,7 +22,7 @@ Attestations can currently be included after some minimum delay (`1` slot on mai Since this decision, it has become apparent that the alternative design is critical for current LMD-GHOST security proofs as well as a new confirmation rule (which will allow for block confirmations in approximately 3-4 slots in normal mainnet conditions). -This specification, thus increases the max inclusion slot for attestations in accordance with the learned security proof and confirmation rule needs. +This specification thus increases the max inclusion slot for attestations in accordance with the learned security proof and confirmation rule needs. ## Specification @@ -38,12 +38,14 @@ This requires no changes to the Execution Layer. ### Consensus layer +Specification changes are built into the Consensus Specs Deneb upgrade. + The specification makes two minor changes to the state transition function: -* Modify `process_attestation` to not have an upper bound on the slot check and instead just rely on the minimum slot as well as the target epoch being in either current or previous epoch. -* Modify `get_attestation_participation_flag_indices` to set the `TIMELY_TARGET_FLAG` without consideration of `inclusion_delay` to ensure that the extended inclusion attestations have a non-zero reward. +* Modify [`process_attestation`](https://github.com/ethereum/consensus-specs/blob/95f36d99cf4aa59974da06af24ef9a7c12d3c301/specs/deneb/beacon-chain.md#modified-process_attestation) to not have an upper bound on the slot check and instead define the inclusion range via the minimum slot as well as the target epoch being in either current or previous epoch. +* Modify [`get_attestation_participation_flag_indices`](https://github.com/ethereum/consensus-specs/blob/95f36d99cf4aa59974da06af24ef9a7c12d3c301/specs/deneb/beacon-chain.md#modified-get_attestation_participation_flag_indices) to set the `TIMELY_TARGET_FLAG` without consideration of `inclusion_delay` to ensure that the extended inclusion attestations have a non-zero reward. -Additionally, the specification modifies the attestation and aggregate attestation gossip conditions to allow for gossip during this extended range. +Additionally, the specification modifies the [attestation](https://github.com/ethereum/consensus-specs/blob/95f36d99cf4aa59974da06af24ef9a7c12d3c301/specs/deneb/p2p-interface.md#beacon_attestation_subnet_id) and [aggregate attestation](https://github.com/ethereum/consensus-specs/blob/95f36d99cf4aa59974da06af24ef9a7c12d3c301/specs/deneb/p2p-interface.md#beacon_aggregate_and_proof) gossip conditions to allow for gossip during this extended range. ## Rationale @@ -57,6 +59,8 @@ Previously, `get_attestation_participation_flag_indices` would only set the `TIM The `inclusion_delay` consideration for this flag is removed to ensure that whatever the valid inclusion window is for an attestation, it can receive a baseline non-zero reward for correct target. This ensures that clients will still attempt to pack such attestations into blocks which is important for the security analysis. +Note, this was the intended behavior with the previously defined range which was equivalent to the max. + ## Backwards Compatibility This EIP introduces backwards incompatible changes to the block validation rule set on the consensus layer and must be accompanied by a hard fork. From a5f5490cf1779fd654d11ae1e3e9135beb551ac8 Mon Sep 17 00:00:00 2001 From: Manu NALEPA Date: Thu, 22 Jun 2023 03:19:03 +0200 Subject: [PATCH 97/97] Update EIP-3076: Update eip-3076.md Merged by EIP-Bot. --- EIPS/eip-3076.md | 13 +++++++------ 1 file changed, 7 insertions(+), 6 deletions(-) diff --git a/EIPS/eip-3076.md b/EIPS/eip-3076.md index 5040150f07b45a..47075b8fa6c807 100644 --- a/EIPS/eip-3076.md +++ b/EIPS/eip-3076.md @@ -173,14 +173,15 @@ After importing an interchange file with data field `data`, a signer must respec 2. Refuse to sign any block with `slot <= min(b.slot for b in data.signed_blocks if b.pubkey == proposer_pubkey)`, except if it is a repeat signing as determined by the `signing_root`. 3. Refuse to sign any attestation that is slashable with respect to the attestations contained in `data.signed_attestations`. For details of what constitutes a slashable attestation, see `is_slashable_attestation_data`. + 4. Refuse to sign any attestation with source epoch less than the minimum source epoch present in that signer's attestations (as seen in `data.signed_attestations`). In pseudocode: -```python3 -source.epoch < - min(att.source_epoch - for att in data.signed_attestations - if att.pubkey == attester_pubkey) -``` + ```python3 + source.epoch < + min(att.source_epoch + for att in data.signed_attestations + if att.pubkey == attester_pubkey) + ``` 5. Refuse to sign any attestation with target epoch less than or equal to the minimum target epoch present in that signer's attestations (as seen in `data.signed_attestations`), except if it is a repeat signing as determined by the `signing_root`. In pseudocode:

E#<6^UwZJbgS;v7;(n4GYJC_ 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м?^iy|_ziuq?nb{P4$M+{g}}e-&IOz5JGEbohY- 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